Changeset 988 for vendor/current/source4/dsdb/repl

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source4/dsdb/repl

Files:

• drepl_extended.c (modified) (4 diffs)
• drepl_fsmo.c (modified) (5 diffs)
• drepl_notify.c (modified) (5 diffs)
• drepl_out_helpers.c (modified) (24 diffs)
• drepl_out_pull.c (modified) (3 diffs)
• drepl_partitions.c (modified) (15 diffs)
• drepl_periodic.c (modified) (2 diffs)
• drepl_ridalloc.c (modified) (9 diffs)
• drepl_service.c (modified) (6 diffs)
• drepl_service.h (modified) (3 diffs)
• replicated_objects.c (modified) (29 diffs)

vendor/current/source4/dsdb/repl/drepl_extended.c

@@ -40 +40 @@
  */
 static WERROR drepl_create_extended_source_dsa(struct dreplsrv_service *service,
+                                               TALLOC_CTX *mem_ctx,
                                                struct ldb_dn *nc_dn,
                                                struct ldb_dn *source_dsa_dn,
@@ -94 +95 @@
         }
 
-        sdsa->repsFrom1->other_info->dns_name =
-                talloc_asprintf(sdsa->repsFrom1->other_info, "%s._msdcs.%s",
-                                GUID_string(sdsa->repsFrom1->other_info, &sdsa->repsFrom1->source_dsa_obj_guid),
-                                lpcfg_dnsdomain(service->task->lp_ctx));
+        sdsa->repsFrom1->other_info->dns_name = samdb_ntds_msdcs_dns_name(ldb,
+                                                                          sdsa->repsFrom1->other_info,
+                                                                          &sdsa->repsFrom1->source_dsa_obj_guid);
         if (!sdsa->repsFrom1->other_info->dns_name) {
                 talloc_free(sdsa);
@@ -167 +167 @@
 {
         struct extended_op_data *data = talloc_get_type_abort(cb_data, struct extended_op_data);
-        talloc_free(data->sdsa);
+        talloc_unlink(data, data->sdsa);
         data->callback(service, err, exop_error, data->callback_data);
         talloc_free(data);
@@ -186 +186 @@
         WERROR werr;
         struct extended_op_data *data;
-        struct dreplsrv_partition_source_dsa *sdsa;
-
-        werr = drepl_create_extended_source_dsa(service, nc_dn, source_dsa_dn, min_usn, &sdsa);
-        W_ERROR_NOT_OK_RETURN(werr);
 
         data = talloc(service, struct extended_op_data);
         W_ERROR_HAVE_NO_MEMORY(data);
 
+        werr = drepl_create_extended_source_dsa(service, data, nc_dn, source_dsa_dn, min_usn, &data->sdsa);
+        W_ERROR_NOT_OK_RETURN(werr);
+
         data->callback = callback;
         data->callback_data = callback_data;
-        data->sdsa = sdsa;
-
-        werr = dreplsrv_schedule_partition_pull_source(service, sdsa,
+
+        werr = dreplsrv_schedule_partition_pull_source(service, data->sdsa,
                                                        0, extended_op, fsmo_info,
                                                        extended_op_callback, data);
         if (!W_ERROR_IS_OK(werr)) {
-                talloc_free(sdsa);
                 talloc_free(data);
         }

vendor/current/source4/dsdb/repl/drepl_fsmo.c

@@ -32 +32 @@
 #include "param/param.h"
 
+struct fsmo_role_state {
+        struct irpc_message *msg;
+        struct drepl_takeFSMORole *r;
+};
+
 static void drepl_role_callback(struct dreplsrv_service *service,
                                 WERROR werr,
@@ -37 +42 @@
                                 void *cb_data)
 {
+        struct fsmo_role_state *fsmo = talloc_get_type_abort(cb_data, struct fsmo_role_state);
         if (!W_ERROR_IS_OK(werr)) {
-                DEBUG(0,(__location__ ": Failed role transfer - %s - extended_ret[0x%X]\n",
+                DEBUG(2,(__location__ ": Failed role transfer - %s - extended_ret[0x%X]\n",
                          win_errstr(werr), ext_err));
         } else {
-                DEBUG(0,(__location__ ": Successful role transfer\n"));
+                DEBUG(2,(__location__ ": Successful role transfer\n"));
         }
-}
-
-static bool fsmo_master_cmp(struct ldb_dn *ntds_dn, struct ldb_dn *role_owner_dn)
-{
-        if (ldb_dn_compare(ntds_dn, role_owner_dn) == 0) {
-                DEBUG(0,("\nWe are the FSMO master.\n"));
-                return true;
-        }
-        return false;
+        fsmo->r->out.result = werr;
+        irpc_send_reply(fsmo->msg, NT_STATUS_OK);
 }
 
@@ -57 +56 @@
   see which role is we are asked to assume, initialize data and send request
  */
-WERROR dreplsrv_fsmo_role_check(struct dreplsrv_service *service,
-                                enum drepl_role_master role)
+NTSTATUS drepl_take_FSMO_role(struct irpc_message *msg,
+                              struct drepl_takeFSMORole *r)
 {
-        struct ldb_dn *role_owner_dn, *fsmo_role_dn, *ntds_dn;
+        struct dreplsrv_service *service = talloc_get_type(msg->private_data,
+                                                           struct dreplsrv_service);
+        struct ldb_dn *role_owner_dn, *fsmo_role_dn;
         TALLOC_CTX *tmp_ctx = talloc_new(service);
         uint64_t fsmo_info = 0;
         enum drsuapi_DsExtendedOperation extended_op = DRSUAPI_EXOP_NONE;
         WERROR werr;
-
-        ntds_dn = samdb_ntds_settings_dn(service->samdb);
-        if (!ntds_dn) {
-                return WERR_DS_DRA_INTERNAL_ERROR;
-        }
+        enum drepl_role_master role = r->in.role;
+        struct fsmo_role_state *fsmo;
+        bool is_us;
+        int ret;
 
         werr = dsdb_get_fsmo_role_info(tmp_ctx, service->samdb, role,
                                        &fsmo_role_dn, &role_owner_dn);
         if (!W_ERROR_IS_OK(werr)) {
-                return werr;
+                talloc_free(tmp_ctx);
+                r->out.result = werr;
+                return NT_STATUS_OK;
         }
 
@@ -90 +92 @@
                 break;
         default:
-                return WERR_DS_DRA_INTERNAL_ERROR;
+                DEBUG(0,("Unknown role %u in role transfer\n",
+                         (unsigned)role));
+                /* IRPC messages are trusted, so this really should not happen */
+                smb_panic("Unknown role despite dsdb_get_fsmo_role_info success");
         }
 
-        if (fsmo_master_cmp(ntds_dn, role_owner_dn) ||
-            (extended_op == DRSUAPI_EXOP_NONE)) {
-                DEBUG(0,("FSMO role check failed for DN %s and owner %s ",
+        ret = samdb_dn_is_our_ntdsa(service->samdb, role_owner_dn, &is_us);
+        if (ret != LDB_SUCCESS) {
+                DEBUG(0,("FSMO role check failed (failed to confirm if our ntdsDsa) for DN %s and owner %s \n",
                          ldb_dn_get_linearized(fsmo_role_dn),
                          ldb_dn_get_linearized(role_owner_dn)));
-                return WERR_OK;
+                talloc_free(tmp_ctx);
+                r->out.result = WERR_DS_DRA_INTERNAL_ERROR;
+                return NT_STATUS_OK;
         }
+        
+        if (is_us) {
+                DEBUG(5,("FSMO role check failed, we already own DN %s with %s\n",
+                         ldb_dn_get_linearized(fsmo_role_dn),
+                         ldb_dn_get_linearized(role_owner_dn)));
+                r->out.result = WERR_OK;
+                talloc_free(tmp_ctx);
+                return NT_STATUS_OK;
+        }
+
+        fsmo = talloc(msg, struct fsmo_role_state);
+        NT_STATUS_HAVE_NO_MEMORY(fsmo);
+
+        fsmo->msg = msg;
+        fsmo->r   = r;
 
         werr = drepl_request_extended_op(service,
@@ -108 +130 @@
                                          0,
                                          drepl_role_callback,
-                                         NULL);
-        if (W_ERROR_IS_OK(werr)) {
-                dreplsrv_run_pending_ops(service);
-        } else {
-                DEBUG(0,("%s: drepl_request_extended_op() failed with %s",
-                         __FUNCTION__, win_errstr(werr)));
+                                         fsmo);
+        if (!W_ERROR_IS_OK(werr)) {
+                r->out.result = werr;
+                talloc_free(tmp_ctx);
+                return NT_STATUS_OK;
         }
-        return werr;
+
+        /* mark this message to be answered later */
+        msg->defer_reply = true;
+        dreplsrv_run_pending_ops(service);
+        talloc_free(tmp_ctx);
+        return NT_STATUS_OK;
 }

vendor/current/source4/dsdb/repl/drepl_notify.c

@@ -196 +196 @@
                          nt_errstr(status), win_errstr(werr)));
         } else {
-                DEBUG(2,("dreplsrv_notify: DsReplicaSync OK for %s\n",
+                DEBUG(2,("dreplsrv_notify: DsReplicaSync successfuly sent to %s\n",
                          op->source_dsa->repsFrom1->other_info->dns_name));
                 op->source_dsa->notify_uSN = op->uSN;
@@ -256 +256 @@
         /* first check the sources list */
         for (s=p->sources; s; s=s->next) {
-                if (GUID_compare(&s->repsFrom1->source_dsa_obj_guid, guid) == 0) {
+                if (GUID_equal(&s->repsFrom1->source_dsa_obj_guid, guid)) {
                         return s;
                 }
@@ -263 +263 @@
         /* then the notifies list */
         for (s=p->notifies; s; s=s->next) {
-                if (GUID_compare(&s->repsFrom1->source_dsa_obj_guid, guid) == 0) {
+                if (GUID_equal(&s->repsFrom1->source_dsa_obj_guid, guid)) {
                         return s;
                 }
@@ -324 +324 @@
         op->schedule_time = time(NULL);
 
-        DLIST_ADD_END(service->ops.notifies, op, struct dreplsrv_notify_operation *);
+        DLIST_ADD_END(service->ops.notifies, op);
         talloc_steal(service, op);
         return WERR_OK;
@@ -452 +452 @@
         service->notify.next_event = next_time;
 
-        new_te = event_add_timed(service->task->event_ctx, service,
+        new_te = tevent_add_timer(service->task->event_ctx, service,
                                  service->notify.next_event,
                                  dreplsrv_notify_handler_te, service);

vendor/current/source4/dsdb/repl/drepl_out_helpers.c

@@ -68 +68 @@
         state->drsuapi  = conn->drsuapi;
 
-        if (state->drsuapi && !state->drsuapi->pipe->conn->dead) {
-                tevent_req_done(req);
-                return tevent_req_post(req, ev);
-        }
-
-        if (state->drsuapi && state->drsuapi->pipe->conn->dead) {
-                talloc_free(state->drsuapi);
-                conn->drsuapi = NULL;
+        if (state->drsuapi != NULL) {
+                struct dcerpc_binding_handle *b =
+                        state->drsuapi->pipe->binding_handle;
+                bool is_connected = dcerpc_binding_handle_is_connected(b);
+
+                if (is_connected) {
+                        tevent_req_done(req);
+                        return tevent_req_post(req, ev);
+                }
+
+                TALLOC_FREE(conn->drsuapi);
         }
 
@@ -115 +118 @@
 
         status = gensec_session_key(state->drsuapi->pipe->conn->security_state.generic_state,
+                                    state->drsuapi,
                                     &state->drsuapi->gensec_skey);
         if (tevent_req_nterror(req, status)) {
@@ -173 +177 @@
                         break;
                 }
+                case 28: {
+                        *info28 = state->bind_r.out.bind_info->info.info28;
+                        break;
+                }
+                case 32: {
+                        struct drsuapi_DsBindInfo32 *info32;
+                        info32 = &state->bind_r.out.bind_info->info.info32;
+
+                        info28->supported_extensions    = info32->supported_extensions;
+                        info28->site_guid               = info32->site_guid;
+                        info28->pid                     = info32->pid;
+                        info28->repl_epoch              = info32->repl_epoch;
+                        break;
+                }
                 case 48: {
                         struct drsuapi_DsBindInfo48 *info48;
@@ -183 +201 @@
                         break;
                 }
-                case 28:
-                        *info28 = state->bind_r.out.bind_info->info.info28;
+                case 52: {
+                        struct drsuapi_DsBindInfo52 *info52;
+                        info52 = &state->bind_r.out.bind_info->info.info52;
+
+                        info28->supported_extensions    = info52->supported_extensions;
+                        info28->site_guid               = info52->site_guid;
+                        info28->pid                     = info52->pid;
+                        info28->repl_epoch              = info52->repl_epoch;
+                        break;
+                }
+                default:
+                        DEBUG(1, ("Warning: invalid info length in bind info: %d\n",
+                                state->bind_r.out.bind_info->length));
                         break;
                 }
@@ -262 +291 @@
 
 /*
-  get a partial attribute set for a replication call
+  get a RODC partial attribute set for a replication call
  */
 static NTSTATUS dreplsrv_get_rodc_partial_attribute_set(struct dreplsrv_service *service,
@@ -280 +309 @@
         pas->version = 1;
         pas->attids = talloc_array(pas, enum drsuapi_DsAttributeId, schema->num_attributes);
-        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(pas->attids, pas);
+        if (pas->attids == NULL) {
+                TALLOC_FREE(pas);
+                return NT_STATUS_NO_MEMORY;
+        }
 
         for (i=0; i<schema->num_attributes; i++) {
@@ -294 +326 @@
                 pas->num_attids++;
         }
+
+        pas->attids = talloc_realloc(pas, pas->attids, enum drsuapi_DsAttributeId, pas->num_attids);
+        if (pas->attids == NULL) {
+                TALLOC_FREE(pas);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        *_pas = pas;
+        return NT_STATUS_OK;
+}
+
+
+/*
+  get a GC partial attribute set for a replication call
+ */
+static NTSTATUS dreplsrv_get_gc_partial_attribute_set(struct dreplsrv_service *service,
+                                                      TALLOC_CTX *mem_ctx,
+                                                      struct drsuapi_DsPartialAttributeSet **_pas)
+{
+        struct drsuapi_DsPartialAttributeSet *pas;
+        struct dsdb_schema *schema;
+        uint32_t i;
+
+        pas = talloc_zero(mem_ctx, struct drsuapi_DsPartialAttributeSet);
+        NT_STATUS_HAVE_NO_MEMORY(pas);
+
+        schema = dsdb_get_schema(service->samdb, NULL);
+
+        pas->version = 1;
+        pas->attids = talloc_array(pas, enum drsuapi_DsAttributeId, schema->num_attributes);
+        if (pas->attids == NULL) {
+                TALLOC_FREE(pas);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        for (i=0; i<schema->num_attributes; i++) {
+                struct dsdb_attribute *a;
+                a = schema->attributes_by_attributeID_id[i];
+                if (a->isMemberOfPartialAttributeSet) {
+                        pas->attids[pas->num_attids] = dsdb_attribute_get_attid(a, false);
+                        pas->num_attids++;
+                }
+        }
+
+        pas->attids = talloc_realloc(pas, pas->attids, enum drsuapi_DsAttributeId, pas->num_attids);
+        if (pas->attids == NULL) {
+                TALLOC_FREE(pas);
+                return NT_STATUS_NO_MEMORY;
+        }
+
         *_pas = pas;
         return NT_STATUS_OK;
@@ -337 +419 @@
         NTSTATUS status;
         uint32_t replica_flags;
+        struct drsuapi_DsReplicaHighWaterMark highwatermark;
+        struct ldb_dn *schema_dn = ldb_get_schema_basedn(service->samdb);
 
         r = talloc(state, struct drsuapi_DsGetNCChanges);
@@ -373 +457 @@
 
         replica_flags = rf1->replica_flags;
-
-        if (service->am_rodc) {
+        highwatermark = rf1->highwatermark;
+
+        if (partition->partial_replica) {
+                status = dreplsrv_get_gc_partial_attribute_set(service, r, &pas);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0,(__location__ ": Failed to construct GC partial attribute set : %s\n", nt_errstr(status)));
+                        return;
+                }
+                replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
+        } else if (partition->rodc_replica) {
                 bool for_schema = false;
-                if (ldb_dn_compare_base(ldb_get_schema_basedn(service->samdb), partition->dn) == 0) {
+                if (ldb_dn_compare_base(schema_dn, partition->dn) == 0) {
                         for_schema = true;
                 }
@@ -382 +474 @@
                 status = dreplsrv_get_rodc_partial_attribute_set(service, r, &pas, for_schema);
                 if (!NT_STATUS_IS_OK(status)) {
-                        DEBUG(0,(__location__ ": Failed to construct partial attribute set : %s\n", nt_errstr(status)));
+                        DEBUG(0,(__location__ ": Failed to construct RODC partial attribute set : %s\n", nt_errstr(status)));
                         return;
                 }
+                replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
                 if (state->op->extended_op == DRSUAPI_EXOP_REPL_SECRET) {
                         replica_flags &= ~DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING;
-                }
+                } else {
+                        replica_flags |= DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING;
+                }
+        }
+        if (state->op->extended_op != DRSUAPI_EXOP_NONE) {
+                /*
+                 * If it's an exop never set the ADD_REF even if it's in
+                 * repsFrom flags.
+                 */
+                replica_flags &= ~DRSUAPI_DRS_ADD_REF;
+        }
+
+        /* is this a full resync of all objects? */
+        if (state->op->options & DRSUAPI_DRS_FULL_SYNC_NOW) {
+                ZERO_STRUCT(highwatermark);
+                /* clear the FULL_SYNC_NOW option for subsequent
+                   stages of the replication cycle */
+                state->op->options &= ~DRSUAPI_DRS_FULL_SYNC_NOW;
+                state->op->options |= DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS;
+                replica_flags |= DRSUAPI_DRS_NEVER_SYNCED;
+        }
+        if (state->op->options & DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS) {
+                uptodateness_vector = NULL;
         }
 
@@ -396 +511 @@
                 r->in.req->req8.source_dsa_invocation_id= rf1->source_dsa_invocation_id;
                 r->in.req->req8.naming_context          = &partition->nc;
-                r->in.req->req8.highwatermark           = rf1->highwatermark;
+                r->in.req->req8.highwatermark           = highwatermark;
                 r->in.req->req8.uptodateness_vector     = uptodateness_vector;
                 r->in.req->req8.replica_flags           = replica_flags;
@@ -412 +527 @@
                 r->in.req->req5.source_dsa_invocation_id= rf1->source_dsa_invocation_id;
                 r->in.req->req5.naming_context          = &partition->nc;
-                r->in.req->req5.highwatermark           = rf1->highwatermark;
+                r->in.req->req5.highwatermark           = highwatermark;
                 r->in.req->req5.uptodateness_vector     = uptodateness_vector;
                 r->in.req->req5.replica_flags           = replica_flags;
@@ -454 +569 @@
         struct drsuapi_DsGetNCChangesCtr1 *ctr1 = NULL;
         struct drsuapi_DsGetNCChangesCtr6 *ctr6 = NULL;
-        enum drsuapi_DsExtendedError extended_ret;
+        enum drsuapi_DsExtendedError extended_ret = DRSUAPI_EXOP_ERR_NONE;
         state->ndr_struct_ptr = NULL;
 
@@ -543 +658 @@
         struct dreplsrv_partition *partition = state->op->source_dsa->partition;
         struct dreplsrv_drsuapi_connection *drsuapi = state->op->source_dsa->conn->drsuapi;
+        struct ldb_dn *schema_dn = ldb_get_schema_basedn(service->samdb);
         struct dsdb_schema *schema;
         struct dsdb_schema *working_schema = NULL;
@@ -555 +671 @@
         WERROR status;
         NTSTATUS nt_status;
+        uint32_t dsdb_repl_flags = 0;
 
         switch (ctr_level) {
@@ -563 +680 @@
                 linked_attributes_count         = 0;
                 linked_attributes               = NULL;
+                rf1.source_dsa_obj_guid         = ctr1->source_dsa_guid;
+                rf1.source_dsa_invocation_id    = ctr1->source_dsa_invocation_id;
                 rf1.highwatermark               = ctr1->new_highwatermark;
                 uptodateness_vector             = NULL; /* TODO: map it */
@@ -573 +692 @@
                 linked_attributes_count         = ctr6->linked_attributes_count;
                 linked_attributes               = ctr6->linked_attributes;
+                rf1.source_dsa_obj_guid         = ctr6->source_dsa_guid;
+                rf1.source_dsa_invocation_id    = ctr6->source_dsa_invocation_id;
                 rf1.highwatermark               = ctr6->new_highwatermark;
                 uptodateness_vector             = ctr6->uptodateness_vector;
@@ -594 +715 @@
          * We won't need a working schema for empty replicas sent.
          */
-        if (first_object && ldb_dn_compare(partition->dn, schema->base_dn) == 0) {
-                /* create working schema to convert objects with */
-                status = dsdb_repl_make_working_schema(service->samdb,
-                                                       schema,
-                                                       mapping_ctr,
-                                                       object_count,
-                                                       first_object,
-                                                       &drsuapi->gensec_skey,
-                                                       state, &working_schema);
-                if (!W_ERROR_IS_OK(status)) {
-                        DEBUG(0,("Failed to create working schema: %s\n",
-                                 win_errstr(status)));
-                        tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
-                        return;
-                }
+        if (first_object) {
+                bool is_schema = ldb_dn_compare(partition->dn, schema_dn) == 0;
+                if (is_schema) {
+                        /* create working schema to convert objects with */
+                        status = dsdb_repl_make_working_schema(service->samdb,
+                                                               schema,
+                                                               mapping_ctr,
+                                                               object_count,
+                                                               first_object,
+                                                               &drsuapi->gensec_skey,
+                                                               state, &working_schema);
+                        if (!W_ERROR_IS_OK(status)) {
+                                DEBUG(0,("Failed to create working schema: %s\n",
+                                         win_errstr(status)));
+                                tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+                                return;
+                        }
+                }
+        }
+
+        if (partition->partial_replica || partition->rodc_replica) {
+                dsdb_repl_flags |= DSDB_REPL_FLAG_PARTIAL_REPLICA;
+        }
+        if (state->op->options & DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS) {
+                dsdb_repl_flags |= DSDB_REPL_FLAG_PRIORITISE_INCOMING;
+        }
+        if (state->op->options & DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING) {
+                dsdb_repl_flags |= DSDB_REPL_FLAG_EXPECT_NO_SECRETS;
         }
 
@@ -622 +756 @@
                                                  uptodateness_vector,
                                                  &drsuapi->gensec_skey,
+                                                 dsdb_repl_flags,
                                                  state, &objects);
         if (!W_ERROR_IS_OK(status)) {
@@ -648 +783 @@
                 *state->op->source_dsa->repsFrom1 = rf1;
         }
-        /*
-         * TODO: update our uptodatevector!
-         */
 
         /* we don't need this maybe very large structure anymore */
@@ -691 +823 @@
         struct dreplsrv_drsuapi_connection *drsuapi = state->op->source_dsa->conn->drsuapi;
         struct drsuapi_DsReplicaUpdateRefs *r;
-        char *ntds_guid_str;
         char *ntds_dns_name;
         struct tevent_req *subreq;
@@ -700 +831 @@
         }
 
-        ntds_guid_str = GUID_string(r, &service->ntds_guid);
-        if (tevent_req_nomem(ntds_guid_str, req)) {
-                return;
-        }
-
-        ntds_dns_name = talloc_asprintf(r, "%s._msdcs.%s",
-                                        ntds_guid_str,
-                                        lpcfg_dnsdomain(service->task->lp_ctx));
+        ntds_dns_name = samdb_ntds_msdcs_dns_name(service->samdb, r, &service->ntds_guid);
         if (tevent_req_nomem(ntds_dns_name, req)) {
+                talloc_free(r);
                 return;
         }
@@ -728 +853 @@
                                                            r);
         if (tevent_req_nomem(subreq, req)) {
+                talloc_free(r);
                 return;
         }
@@ -764 +890 @@
                          r->in.req.req1.dest_dsa_dns_name,
                          r->in.req.req1.naming_context->dn));
-                tevent_req_nterror(req, status);
-                return;
+                /*
+                 * TODO we are currently not sending the
+                 * DsReplicaUpdateRefs at the correct moment,
+                 * we do it just after a GetNcChanges which is
+                 * not always correct.
+                 * Especially when another DC is trying to demote
+                 * it will sends us a DsReplicaSync that will trigger a getNcChanges
+                 * this call will succeed but the DsRecplicaUpdateRefs that we send
+                 * just after will not because the DC is in a demote state and
+                 * will reply us a WERR_DS_DRA_BUSY, this error will cause us to
+                 * answer to the DsReplicaSync with a non OK status, the other DC
+                 * will stop the demote due to this error.
+                 * In order to cope with this we will for the moment concider
+                 * a DS_DRA_BUSY not as an error.
+                 * It's not ideal but it should not have a too huge impact for
+                 * running production as this error otherwise never happen and
+                 * due to the fact the send a DsReplicaUpdateRefs after each getNcChanges
+                 */
+                if (!W_ERROR_EQUAL(r->out.result, WERR_DS_DRA_BUSY)) {
+                        tevent_req_nterror(req, status);
+                        return;
+                }
         }
 

vendor/current/source4/dsdb/repl/drepl_out_pull.c

@@ -58 +58 @@
 
         for (i=0; i<count; i++) {
-                if (GUID_compare(source_dsa_obj_guid,
-                                 &reps[i].ctr.ctr1.source_dsa_obj_guid) == 0) {
+                if (GUID_equal(source_dsa_obj_guid,
+                               &reps[i].ctr.ctr1.source_dsa_obj_guid)) {
                         break;
                 }
@@ -102 +102 @@
 
         op->service     = s;
-        op->source_dsa  = source;
+        /*
+         * source may either be the long-term list of partners, or
+         * from dreplsrv_partition_source_dsa_temporary().  Because it
+         * can be either, we can't talloc_steal() it here, so we
+         * instead we reference it.
+         *
+         * We never talloc_free() the p->sources pointers - indeed we
+         * never remove them - and the temp source will otherwise go
+         * away with the msg it is allocated on.
+         *
+         * Finally the pointer created in drepl_request_extended_op()
+         * is removed with talloc_unlink().
+         *
+         */
+        op->source_dsa  = talloc_reference(op, source);
+        if (!op->source_dsa) {
+                return WERR_NOMEM;
+        }
+
         op->options     = options;
         op->extended_op = extended_op;
@@ -110 +128 @@
         op->schedule_time = time(NULL);
 
-        DLIST_ADD_END(s->ops.pending, op, struct dreplsrv_out_operation *);
+        DLIST_ADD_END(s->ops.pending, op);
 
         return WERR_OK;

vendor/current/source4/dsdb/repl/drepl_partitions.c

@@ -33 +33 @@
 #include "libcli/security/security.h"
 #include "param/param.h"
-
+#include "dsdb/common/util.h"
+
+/*
+  load the partitions list based on replicated NC attributes in our
+  NTDSDSA object
+ */
 WERROR dreplsrv_load_partitions(struct dreplsrv_service *s)
 {
         WERROR status;
-        static const char *attrs[] = { "namingContexts", NULL };
-        unsigned int i;
+        static const char *attrs[] = { "hasMasterNCs", "msDS-hasMasterNCs", "hasPartialReplicaNCs", "msDS-HasFullReplicaNCs", NULL };
+        unsigned int a;
         int ret;
         TALLOC_CTX *tmp_ctx;
         struct ldb_result *res;
         struct ldb_message_element *el;
+        struct ldb_dn *ntds_dn;
 
         tmp_ctx = talloc_new(s);
         W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
 
-        ret = ldb_search(s->samdb, tmp_ctx, &res,
-                         ldb_dn_new(tmp_ctx, s->samdb, ""), LDB_SCOPE_BASE, attrs, NULL);
+        ntds_dn = samdb_ntds_settings_dn(s->samdb, tmp_ctx);
+        if (!ntds_dn) {
+                DEBUG(1,(__location__ ": Unable to find ntds_dn: %s\n", ldb_errstring(s->samdb)));
+                talloc_free(tmp_ctx);
+                return WERR_DS_DRA_INTERNAL_ERROR;
+        }
+
+        ret = dsdb_search_dn(s->samdb, tmp_ctx, &res, ntds_dn, attrs, DSDB_SEARCH_SHOW_EXTENDED_DN);
         if (ret != LDB_SUCCESS) {
-                DEBUG(1,("Searching for namingContexts in rootDSE failed: %s\n", ldb_errstring(s->samdb)));
+                DEBUG(1,("Searching for hasMasterNCs in NTDS DN failed: %s\n", ldb_errstring(s->samdb)));
                 talloc_free(tmp_ctx);
                 return WERR_DS_DRA_INTERNAL_ERROR;
-       }
-
-       el = ldb_msg_find_element(res->msgs[0], "namingContexts");
-       if (!el) {
-               DEBUG(1,("Finding namingContexts element in root_res failed: %s\n",
-                        ldb_errstring(s->samdb)));
-               talloc_free(tmp_ctx);
-               return WERR_DS_DRA_INTERNAL_ERROR;
-       }
-
-       for (i=0; i<el->num_values; i++) {
-               struct ldb_dn *pdn;
-               struct dreplsrv_partition *p;
-
-               pdn = ldb_dn_from_ldb_val(tmp_ctx, s->samdb, &el->values[i]);
-               if (pdn == NULL) {
-                       talloc_free(tmp_ctx);
-                       return WERR_DS_DRA_INTERNAL_ERROR;
-               }
-               if (!ldb_dn_validate(pdn)) {
-                       return WERR_DS_DRA_INTERNAL_ERROR;
-               }
-
-               p = talloc_zero(s, struct dreplsrv_partition);
-               W_ERROR_HAVE_NO_MEMORY(p);
-
-               p->dn = talloc_steal(p, pdn);
-
-               DLIST_ADD(s->partitions, p);
-
-               DEBUG(2, ("dreplsrv_partition[%s] loaded\n", ldb_dn_get_linearized(p->dn)));
+        }
+
+        for (a=0; attrs[a]; a++) {
+                int i;
+
+                el = ldb_msg_find_element(res->msgs[0], attrs[a]);
+                if (el == NULL) {
+                        continue;
+                }
+                for (i=0; i<el->num_values; i++) {
+                        struct ldb_dn *pdn;
+                        struct dreplsrv_partition *p, *tp;
+                        bool found;
+
+                        pdn = ldb_dn_from_ldb_val(tmp_ctx, s->samdb, &el->values[i]);
+                        if (pdn == NULL) {
+                                talloc_free(tmp_ctx);
+                                return WERR_DS_DRA_INTERNAL_ERROR;
+                        }
+                        if (!ldb_dn_validate(pdn)) {
+                                return WERR_DS_DRA_INTERNAL_ERROR;
+                        }
+
+                        p = talloc_zero(s, struct dreplsrv_partition);
+                        W_ERROR_HAVE_NO_MEMORY(p);
+
+                        p->dn = talloc_steal(p, pdn);
+                        p->service = s;
+
+                        if (strcasecmp(attrs[a], "hasPartialReplicaNCs") == 0) {
+                                p->partial_replica = true;
+                        } else if (strcasecmp(attrs[a], "msDS-HasFullReplicaNCs") == 0) {
+                                p->rodc_replica = true;
+                        }
+
+                        /* Do not add partitions more than once */
+                        found = false;
+                        for (tp = s->partitions; tp; tp = tp->next) {
+                                if (ldb_dn_compare(tp->dn, p->dn) == 0) {
+                                        found = true;
+                                        break;
+                                }
+                        }
+                        if (found) {
+                                talloc_free(p);
+                                continue;
+                        }
+
+                        DLIST_ADD(s->partitions, p);
+                        DEBUG(2, ("dreplsrv_partition[%s] loaded\n", ldb_dn_get_linearized(p->dn)));
+                }
         }
 
@@ -92 +124 @@
 
         return WERR_OK;
+}
+
+/*
+  Check if particular SPN exists for an account
+ */
+static bool dreplsrv_spn_exists(struct ldb_context *samdb, struct ldb_dn *account_dn,
+                                const char *principal_name)
+{
+        TALLOC_CTX *tmp_ctx;
+        const char *attrs_empty[] = { NULL };
+        int ret;
+        struct ldb_result *res;
+
+        tmp_ctx = talloc_new(samdb);
+
+        ret = dsdb_search(samdb, tmp_ctx, &res, account_dn, LDB_SCOPE_BASE, attrs_empty,
+                        0, "servicePrincipalName=%s",
+                        ldb_binary_encode_string(tmp_ctx, principal_name));
+        if (ret != LDB_SUCCESS || res->count != 1) {
+                talloc_free(tmp_ctx);
+                return false;
+        }
+
+        talloc_free(tmp_ctx);
+        return true;
 }
 
@@ -97 +154 @@
   work out the principal to use for DRS replication connections
  */
-NTSTATUS dreplsrv_get_target_principal(struct dreplsrv_service *s,
-                                       TALLOC_CTX *mem_ctx,
-                                       const struct repsFromTo1 *rft,
-                                       const char **target_principal)
+static NTSTATUS dreplsrv_get_target_principal(struct dreplsrv_service *s,
+                                              TALLOC_CTX *mem_ctx,
+                                              const struct repsFromTo1 *rft,
+                                              char **target_principal)
 {
         TALLOC_CTX *tmp_ctx;
         struct ldb_result *res;
-        const char *attrs[] = { "dNSHostName", NULL };
+        const char *attrs_server[] = { "dNSHostName", "serverReference", NULL };
+        const char *attrs_ntds[] = { "msDS-HasDomainNCs", "hasMasterNCs", NULL };
         int ret;
-        const char *hostname;
-        struct ldb_dn *dn;
+        const char *hostname, *dnsdomain=NULL;
+        struct ldb_dn *ntds_dn, *server_dn, *computer_dn;
+        struct ldb_dn *forest_dn, *nc_dn;
 
         *target_principal = NULL;
@@ -114 +173 @@
 
         /* we need to find their hostname */
-        ret = dsdb_find_dn_by_guid(s->samdb, tmp_ctx, &rft->source_dsa_obj_guid, &dn);
+        ret = dsdb_find_dn_by_guid(s->samdb, tmp_ctx, &rft->source_dsa_obj_guid, 0, &ntds_dn);
         if (ret != LDB_SUCCESS) {
                 talloc_free(tmp_ctx);
@@ -121 +180 @@
         }
 
+        server_dn = ldb_dn_copy(tmp_ctx, ntds_dn);
+        if (server_dn == NULL) {
+                talloc_free(tmp_ctx);
+                return NT_STATUS_OK;
+        }
+
         /* strip off the NTDS Settings */
-        if (!ldb_dn_remove_child_components(dn, 1)) {
+        if (!ldb_dn_remove_child_components(server_dn, 1)) {
                 talloc_free(tmp_ctx);
                 return NT_STATUS_OK;
         }
 
-        ret = dsdb_search_dn(s->samdb, tmp_ctx, &res, dn, attrs, 0);
+        ret = dsdb_search_dn(s->samdb, tmp_ctx, &res, server_dn, attrs_server, 0);
         if (ret != LDB_SUCCESS) {
                 talloc_free(tmp_ctx);
-                /* its OK for their account DN not to be in our database */
+                /* its OK for their server DN not to be in our database */
                 return NT_STATUS_OK;
         }
 
+        forest_dn = ldb_get_root_basedn(s->samdb);
+        if (forest_dn == NULL) {
+                talloc_free(tmp_ctx);
+                return NT_STATUS_OK;
+        }
+
         hostname = ldb_msg_find_attr_as_string(res->msgs[0], "dNSHostName", NULL);
-        if (hostname == NULL) {
-                talloc_free(tmp_ctx);
-                /* its OK to not have a dnshostname */
+        computer_dn = ldb_msg_find_attr_as_dn(s->samdb, tmp_ctx, res->msgs[0], "serverReference");
+        if (hostname != NULL && computer_dn != NULL) {
+                char *local_principal;
+
+                /*
+                  if we have the dNSHostName attribute then we can use
+                  the GC/hostname/realm SPN. All DCs should have this SPN
+
+                  Windows DC may set up it's dNSHostName before setting up
+                  GC/xx/xx SPN. So make sure it exists, before using it.
+                 */
+                local_principal = talloc_asprintf(mem_ctx, "GC/%s/%s",
+                                                    hostname,
+                                                    samdb_dn_to_dns_domain(tmp_ctx, forest_dn));
+                if (dreplsrv_spn_exists(s->samdb, computer_dn, local_principal)) {
+                        *target_principal = local_principal;
+                        talloc_free(tmp_ctx);
+                        return NT_STATUS_OK;
+                }
+
+                talloc_free(local_principal);
+        }
+
+        /*
+           if we can't find the dNSHostName then we will try for the
+           E3514235-4B06-11D1-AB04-00C04FC2DCD2/${NTDSGUID}/${DNSDOMAIN}
+           SPN. To use that we need the DNS domain name of the target
+           DC. We find that by first looking for the msDS-HasDomainNCs
+           in the NTDSDSA object of the DC, and if we don't find that,
+           then we look for the hasMasterNCs attribute, and eliminate
+           the known schema and configuruation DNs. Despite how
+           bizarre this seems, Hongwei tells us that this is in fact
+           what windows does to find the SPN!!
+        */
+        ret = dsdb_search_dn(s->samdb, tmp_ctx, &res, ntds_dn, attrs_ntds, 0);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(tmp_ctx);
                 return NT_STATUS_OK;
         }
 
-        /* All DCs have the GC/hostname/realm name, but if some of the
-         * preconditions are not satisfied, then we will fall back to
-         * the
-         * E3514235-4B06-11D1-AB04-00C04FC2DCD2/${NTDSGUID}/${DNSDOMAIN}
-         * name.  This means that if a AD server has a dnsHostName set
-         * on it's record, it must also have GC/hostname/realm
-         * servicePrincipalName */
-
-        *target_principal = talloc_asprintf(mem_ctx, "GC/%s/%s",
-                                            hostname,
-                                            lpcfg_dnsdomain(s->task->lp_ctx));
+        nc_dn = ldb_msg_find_attr_as_dn(s->samdb, tmp_ctx, res->msgs[0], "msDS-HasDomainNCs");
+        if (nc_dn != NULL) {
+                dnsdomain = samdb_dn_to_dns_domain(tmp_ctx, nc_dn);
+        }
+
+        if (dnsdomain == NULL) {
+                struct ldb_message_element *el;
+                int i;
+                el = ldb_msg_find_element(res->msgs[0], "hasMasterNCs");
+                for (i=0; el && i<el->num_values; i++) {
+                        nc_dn = ldb_dn_from_ldb_val(tmp_ctx, s->samdb, &el->values[i]);
+                        if (nc_dn == NULL ||
+                            ldb_dn_compare(ldb_get_config_basedn(s->samdb), nc_dn) == 0 ||
+                            ldb_dn_compare(ldb_get_schema_basedn(s->samdb), nc_dn) == 0) {
+                                continue;
+                        }
+                        /* it must be a domain DN, get the equivalent
+                           DNS domain name */
+                        dnsdomain = samdb_dn_to_dns_domain(tmp_ctx, nc_dn);
+                        break;
+                }
+        }
+
+        if (dnsdomain != NULL) {
+                *target_principal = talloc_asprintf(mem_ctx,
+                                                    "E3514235-4B06-11D1-AB04-00C04FC2DCD2/%s/%s@%s",
+                                                    GUID_string(tmp_ctx, &rft->source_dsa_obj_guid),
+                                                    dnsdomain, dnsdomain);
+        }
+
         talloc_free(tmp_ctx);
         return NT_STATUS_OK;
@@ -174 +298 @@
         hostname = rft->other_info->dns_name;
 
-        for (cur = s->connections; cur; cur = cur->next) {              
-                if (strcmp(cur->binding->host, hostname) == 0) {
+        for (cur = s->connections; cur; cur = cur->next) {
+                const char *host;
+
+                host = dcerpc_binding_get_string_option(cur->binding, "host");
+                if (host == NULL) {
+                        continue;
+                }
+
+                if (strcmp(host, hostname) == 0) {
                         conn = cur;
                         break;
@@ -184 +315 @@
                 NTSTATUS nt_status;
                 char *binding_str;
+                char *target_principal = NULL;
 
                 conn = talloc_zero(s, struct dreplsrv_out_connection);
@@ -201 +333 @@
                 /* use the GC principal for DRS replication */
                 nt_status = dreplsrv_get_target_principal(s, conn->binding,
-                                                          rft, &conn->binding->target_principal);
+                                                          rft, &target_principal);
                 if (!NT_STATUS_IS_OK(nt_status)) {
                         return ntstatus_to_werror(nt_status);
                 }
 
-                DLIST_ADD_END(s->connections, conn, struct dreplsrv_out_connection *);
-
-                DEBUG(4,("dreplsrv_out_connection_attach(%s): create\n", conn->binding->host));
+                nt_status = dcerpc_binding_set_string_option(conn->binding,
+                                                             "target_principal",
+                                                             target_principal);
+                TALLOC_FREE(target_principal);
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return ntstatus_to_werror(nt_status);
+                }
+
+                DLIST_ADD_END(s->connections, conn);
+
+                DEBUG(4,("dreplsrv_out_connection_attach(%s): create\n", hostname));
         } else {
-                DEBUG(4,("dreplsrv_out_connection_attach(%s): attach\n", conn->binding->host));
+                DEBUG(4,("dreplsrv_out_connection_attach(%s): attach\n", hostname));
         }
 
@@ -225 +365 @@
         struct dreplsrv_partition_source_dsa *s;
         for (s=list; s; s=s->next) {
-                if (GUID_compare(&s->repsFrom1->source_dsa_obj_guid, guid) == 0) {
+                if (GUID_equal(&s->repsFrom1->source_dsa_obj_guid, guid)) {
                         return s;
                 }
@@ -276 +416 @@
         /* re-use an existing source if found */
         for (s2=*listp; s2; s2=s2->next) {
-                if (GUID_compare(&s2->repsFrom1->source_dsa_obj_guid, 
-                                 &source->repsFrom1->source_dsa_obj_guid) == 0) {
+                if (GUID_equal(&s2->repsFrom1->source_dsa_obj_guid,
+                                 &source->repsFrom1->source_dsa_obj_guid)) {
                         talloc_free(s2->repsFrom1->other_info);
                         *s2->repsFrom1 = *source->repsFrom1;
@@ -286 +426 @@
         }
 
-        DLIST_ADD_END(*listp, source, struct dreplsrv_partition_source_dsa *);
+        DLIST_ADD_END(*listp, source);
         return WERR_OK;
 }
 
+/**
+ * Find a partition when given a NC
+ * If the NC can't be found it will return BAD_NC
+ * Initial checks for invalid parameters have to be done beforehand
+ */
 WERROR dreplsrv_partition_find_for_nc(struct dreplsrv_service *s,
-                                      const struct GUID *nc_guid,
-                                      const struct dom_sid *nc_sid,
+                                      struct GUID *nc_guid,
+                                      struct dom_sid *nc_sid,
                                       const char *nc_dn_str,
                                       struct dreplsrv_partition **_p)
@@ -306 +451 @@
         valid_guid = nc_guid && !GUID_all_zero(nc_guid);
 
-        if (!valid_sid && !valid_guid && !nc_dn_str) {
-                return WERR_DS_DRA_INVALID_PARAMETER;
+        if (!valid_sid && !valid_guid && (!nc_dn_str)) {
+                return WERR_DS_DRA_BAD_NC;
         }
 
@@ -315 +460 @@
                     || (valid_sid && dom_sid_equal(&p->nc.sid, nc_sid)))
                 {
+                        /* fill in he right guid and sid if possible */
+                        if (nc_guid && !valid_guid) {
+                                dsdb_get_extended_dn_guid(p->dn, nc_guid, "GUID");
+                        }
+                        if (nc_sid && !valid_sid) {
+                                dsdb_get_extended_dn_sid(p->dn, nc_sid, "SID");
+                        }
                         *_p = p;
                         return WERR_OK;
@@ -363 +515 @@
 
 
+/*
+  create a temporary dsa structure for a replication. This is needed
+  for the initial replication of a new partition, such as when a new
+  domain NC is created and we are a global catalog server
+ */
+WERROR dreplsrv_partition_source_dsa_temporary(struct dreplsrv_partition *p,
+                                               TALLOC_CTX *mem_ctx,
+                                               const struct GUID *dsa_guid,
+                                               struct dreplsrv_partition_source_dsa **_dsa)
+{
+        struct dreplsrv_partition_source_dsa *dsa;
+        WERROR werr;
+
+        dsa = talloc_zero(mem_ctx, struct dreplsrv_partition_source_dsa);
+        W_ERROR_HAVE_NO_MEMORY(dsa);
+
+        dsa->partition = p;
+        dsa->repsFrom1 = &dsa->_repsFromBlob.ctr.ctr1;
+        dsa->repsFrom1->replica_flags = 0;
+        dsa->repsFrom1->source_dsa_obj_guid = *dsa_guid;
+
+        dsa->repsFrom1->other_info = talloc_zero(dsa, struct repsFromTo1OtherInfo);
+        W_ERROR_HAVE_NO_MEMORY(dsa->repsFrom1->other_info);
+
+        dsa->repsFrom1->other_info->dns_name = samdb_ntds_msdcs_dns_name(p->service->samdb,
+                                                                         dsa->repsFrom1->other_info, dsa_guid);
+        W_ERROR_HAVE_NO_MEMORY(dsa->repsFrom1->other_info->dns_name);
+
+        werr = dreplsrv_out_connection_attach(p->service, dsa->repsFrom1, &dsa->conn);
+        if (!W_ERROR_IS_OK(werr)) {
+                DEBUG(0,(__location__ ": Failed to attach connection to %s\n",
+                         ldb_dn_get_linearized(p->dn)));
+                talloc_free(dsa);
+                return werr;
+        }
+
+        *_dsa = dsa;
+
+        return WERR_OK;
+}
+
+
 static WERROR dreplsrv_refresh_partition(struct dreplsrv_service *s,
                                          struct dreplsrv_partition *p)
 {
         WERROR status;
-        struct dom_sid *nc_sid;
+        NTSTATUS ntstatus;
         struct ldb_message_element *orf_el = NULL;
-        struct ldb_result *r;
+        struct ldb_result *r = NULL;
         unsigned int i;
         int ret;
         TALLOC_CTX *mem_ctx = talloc_new(p);
         static const char *attrs[] = {
-                "objectSid",
-                "objectGUID",
                 "repsFrom",
                 "repsTo",
                 NULL
         };
+        struct ldb_dn *dn;
 
         DEBUG(4, ("dreplsrv_refresh_partition(%s)\n",
                 ldb_dn_get_linearized(p->dn)));
 
-        ret = ldb_search(s->samdb, mem_ctx, &r, p->dn, LDB_SCOPE_BASE, attrs,
-                         "(objectClass=*)");
-        if (ret != LDB_SUCCESS) {
+        ret = dsdb_search_dn(s->samdb, mem_ctx, &r, p->dn, attrs, DSDB_SEARCH_SHOW_EXTENDED_DN);
+        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                /* we haven't replicated the partition yet, but we
+                 * can fill in the guid, sid etc from the partition DN */
+                dn = p->dn;
+        } else if (ret != LDB_SUCCESS) {
                 talloc_free(mem_ctx);
                 return WERR_FOOBAR;
+        } else {
+                dn = r->msgs[0]->dn;
         }
         
         talloc_free(discard_const(p->nc.dn));
         ZERO_STRUCT(p->nc);
-        p->nc.dn        = ldb_dn_alloc_linearized(p, p->dn);
+        p->nc.dn        = ldb_dn_alloc_linearized(p, dn);
         W_ERROR_HAVE_NO_MEMORY(p->nc.dn);
-        p->nc.guid      = samdb_result_guid(r->msgs[0], "objectGUID");
-        nc_sid          = samdb_result_dom_sid(p, r->msgs[0], "objectSid");
-        if (nc_sid) {
-                p->nc.sid       = *nc_sid;
-                talloc_free(nc_sid);
-        }
+        ntstatus = dsdb_get_extended_dn_guid(dn, &p->nc.guid, "GUID");
+        if (!NT_STATUS_IS_OK(ntstatus)) {
+                DEBUG(0,(__location__ ": unable to get GUID for %s: %s\n",
+                         p->nc.dn, nt_errstr(ntstatus)));
+                talloc_free(mem_ctx);
+                return WERR_DS_DRA_INTERNAL_ERROR;
+        }
+        dsdb_get_extended_dn_sid(dn, &p->nc.sid, "SID");
 
         talloc_free(p->uptodatevector.cursors);
@@ -412 +612 @@
         }
 
-        orf_el = ldb_msg_find_element(r->msgs[0], "repsFrom");
-        if (orf_el) {
+        status = WERR_OK;
+
+        if (r != NULL && (orf_el = ldb_msg_find_element(r->msgs[0], "repsFrom"))) {
                 for (i=0; i < orf_el->num_values; i++) {
-                        status = dreplsrv_partition_add_source_dsa(s, p, &p->sources, 
+                        status = dreplsrv_partition_add_source_dsa(s, p, &p->sources,
                                                                    NULL, &orf_el->values[i]);
-                        W_ERROR_NOT_OK_RETURN(status);  
-                }
-        }
-
-        orf_el = ldb_msg_find_element(r->msgs[0], "repsTo");
-        if (orf_el) {
+                        W_ERROR_NOT_OK_GOTO_DONE(status);
+                }
+        }
+
+        if (r != NULL && (orf_el = ldb_msg_find_element(r->msgs[0], "repsTo"))) {
                 for (i=0; i < orf_el->num_values; i++) {
-                        status = dreplsrv_partition_add_source_dsa(s, p, &p->notifies, 
+                        status = dreplsrv_partition_add_source_dsa(s, p, &p->notifies,
                                                                    p->sources, &orf_el->values[i]);
-                        W_ERROR_NOT_OK_RETURN(status);  
-                }
-        }
-
+                        W_ERROR_NOT_OK_GOTO_DONE(status);
+                }
+        }
+
+done:
         talloc_free(mem_ctx);
-
-        return WERR_OK;
+        return status;
 }
 

vendor/current/source4/dsdb/repl/drepl_periodic.c

@@ -75 +75 @@
         service->periodic.next_event = next_time;
 
-        new_te = event_add_timed(service->task->event_ctx, service,
+        new_te = tevent_add_timer(service->task->event_ctx, service,
                                  service->periodic.next_event,
                                  dreplsrv_periodic_handler_te, service);
@@ -134 +134 @@
         }
 }
+
+static void dreplsrv_pending_run(struct dreplsrv_service *service);
+
+static void dreplsrv_pending_handler_te(struct tevent_context *ev, struct tevent_timer *te,
+                                        struct timeval t, void *ptr)
+{
+        struct dreplsrv_service *service = talloc_get_type(ptr, struct dreplsrv_service);
+
+        service->pending.te = NULL;
+
+        dreplsrv_pending_run(service);
+}
+
+WERROR dreplsrv_pendingops_schedule(struct dreplsrv_service *service, uint32_t next_interval)
+{
+        TALLOC_CTX *tmp_mem;
+        struct tevent_timer *new_te;
+        struct timeval next_time;
+
+        /* prevent looping */
+        if (next_interval == 0) {
+                next_interval = 1;
+        }
+
+        next_time = timeval_current_ofs(next_interval, 50);
+
+        if (service->pending.te) {
+                /*
+                 * if the timestamp of the new event is higher,
+                 * as current next we don't need to reschedule
+                 */
+                if (timeval_compare(&next_time, &service->pending.next_event) > 0) {
+                        return WERR_OK;
+                }
+        }
+
+        /* reset the next scheduled timestamp */
+        service->pending.next_event = next_time;
+
+        new_te = tevent_add_timer(service->task->event_ctx, service,
+                                  service->pending.next_event,
+                                 dreplsrv_pending_handler_te, service);
+        W_ERROR_HAVE_NO_MEMORY(new_te);
+
+        tmp_mem = talloc_new(service);
+        DEBUG(4,("dreplsrv_pending_schedule(%u) %sscheduled for: %s\n",
+                next_interval,
+                (service->pending.te?"re":""),
+                nt_time_string(tmp_mem, timeval_to_nttime(&next_time))));
+        talloc_free(tmp_mem);
+
+        talloc_free(service->pending.te);
+        service->pending.te = new_te;
+
+        return WERR_OK;
+}
+
+static void dreplsrv_pending_run(struct dreplsrv_service *service)
+{
+        dreplsrv_run_pending_ops(service);
+}

vendor/current/source4/dsdb/repl/drepl_ridalloc.c

@@ -96 +96 @@
         *_alloc_pool = UINT64_MAX;
 
-        server_dn = ldb_dn_get_parent(tmp_ctx, samdb_ntds_settings_dn(ldb));
+        server_dn = ldb_dn_get_parent(tmp_ctx, samdb_ntds_settings_dn(ldb, tmp_ctx));
         if (!server_dn) {
                 talloc_free(tmp_ctx);
@@ -104 +104 @@
         ret = samdb_reference_dn(ldb, tmp_ctx, server_dn, "serverReference", &machine_dn);
         if (ret != LDB_SUCCESS) {
-                DEBUG(0,(__location__ ": Failed to find serverReference in %s - %s",
+                DEBUG(0,(__location__ ": Failed to find serverReference in %s - %s\n",
                          ldb_dn_get_linearized(server_dn), ldb_errstring(ldb)));
                 talloc_free(tmp_ctx);
@@ -118 +118 @@
         }
         if (ret != LDB_SUCCESS) {
-                DEBUG(0,(__location__ ": Failed to find rIDSetReferences in %s - %s",
+                DEBUG(0,(__location__ ": Failed to find rIDSetReferences in %s - %s\n",
                          ldb_dn_get_linearized(machine_dn), ldb_errstring(ldb)));
                 talloc_free(tmp_ctx);
@@ -126 +126 @@
         ret = ldb_search(ldb, tmp_ctx, &res, rid_set_dn, LDB_SCOPE_BASE, attrs, NULL);
         if (ret != LDB_SUCCESS) {
-                DEBUG(0,(__location__ ": Failed to load RID Set attrs from %s - %s",
+                DEBUG(0,(__location__ ": Failed to load RID Set attrs from %s - %s\n",
                          ldb_dn_get_linearized(rid_set_dn), ldb_errstring(ldb)));
                 talloc_free(tmp_ctx);
@@ -169 +169 @@
         int ret;
         uint64_t alloc_pool;
+        bool is_us;
 
         if (service->am_rodc) {
@@ -195 +196 @@
         ret = samdb_rid_manager_dn(ldb, tmp_ctx, &rid_manager_dn);
         if (ret != LDB_SUCCESS) {
-                DEBUG(0, (__location__ ": Failed to find RID Manager object - %s", ldb_errstring(ldb)));
+                DEBUG(0, (__location__ ": Failed to find RID Manager object - %s\n", ldb_errstring(ldb)));
                 talloc_free(tmp_ctx);
                 return WERR_DS_DRA_INTERNAL_ERROR;
@@ -203 +204 @@
         ret = samdb_reference_dn(ldb, tmp_ctx, rid_manager_dn, "fSMORoleOwner", &fsmo_role_dn);
         if (ret != LDB_SUCCESS) {
-                DEBUG(0,(__location__ ": Failed to find fSMORoleOwner in RID Manager object - %s",
+                DEBUG(0,(__location__ ": Failed to find fSMORoleOwner in RID Manager object - %s\n",
                          ldb_errstring(ldb)));
                 talloc_free(tmp_ctx);
@@ -209 +210 @@
         }
 
-        if (ldb_dn_compare(samdb_ntds_settings_dn(ldb), fsmo_role_dn) == 0) {
+        ret = samdb_dn_is_our_ntdsa(ldb, fsmo_role_dn, &is_us);
+        if (ret != LDB_SUCCESS) {
+                DEBUG(0,(__location__ ": Failed to find detrmine if %s is our ntdsDsa object - %s\n",
+                         ldb_dn_get_linearized(fsmo_role_dn), ldb_errstring(ldb)));
+                talloc_free(tmp_ctx);
+                return WERR_DS_DRA_INTERNAL_ERROR;
+        }
+
+        if (is_us) {
                 /* we are the RID Manager - no need to do a
                    DRSUAPI_EXOP_FSMO_RID_ALLOC */
@@ -237 +246 @@
 /* called by the samldb ldb module to tell us to ask for a new RID
    pool */
-void dreplsrv_allocate_rid(struct messaging_context *msg, void *private_data,
+void dreplsrv_allocate_rid(struct imessaging_context *msg, void *private_data,
                            uint32_t msg_type,
                            struct server_id server_id, DATA_BLOB *data)

vendor/current/source4/dsdb/repl/drepl_service.c

@@ -34 +34 @@
 #include "librpc/gen_ndr/ndr_irpc.h"
 #include "param/param.h"
+#include "libds/common/roles.h"
 
 /**
@@ -307 +308 @@
                                                                      &req1->source_dsa_guid,
                                                                      &dsa);
+                        if (W_ERROR_EQUAL(werr, WERR_DS_DRA_NO_REPLICA)) {
+                                /* we don't have this source setup as
+                                   a replication partner. Create a
+                                   temporary dsa structure for this
+                                   replication */
+                                werr = dreplsrv_partition_source_dsa_temporary(p,
+                                                                               msg,
+                                                                               &req1->source_dsa_guid,
+                                                                               &dsa);
+                        }
                 }
                 if (!W_ERROR_IS_OK(werr)) {
@@ -329 +340 @@
          * replication as soon as possible
          */
-        dreplsrv_periodic_schedule(service, 0);
+        dreplsrv_pendingops_schedule(service, 0);
 
 done:
@@ -353 +364 @@
 }
 
-static NTSTATUS drepl_take_FSMO_role(struct irpc_message *msg,
-                                     struct drepl_takeFSMORole *r)
-{
-        struct dreplsrv_service *service = talloc_get_type(msg->private_data,
-                                                           struct dreplsrv_service);
-        r->out.result = dreplsrv_fsmo_role_check(service, r->in.role);
-        return NT_STATUS_OK;
-}
-
 /**
  * Called when the auth code wants us to try and replicate
@@ -434 +436 @@
                                       false);
                 return;
-        case ROLE_DOMAIN_CONTROLLER:
+        case ROLE_ACTIVE_DIRECTORY_DC:
                 /* Yes, we want DSDB replication */
                 break;
@@ -507 +509 @@
         IRPC_REGISTER(task->msg_ctx, irpc, DREPL_TAKEFSMOROLE, drepl_take_FSMO_role, service);
         IRPC_REGISTER(task->msg_ctx, irpc, DREPL_TRIGGER_REPL_SECRET, drepl_trigger_repl_secret, service);
-        messaging_register(task->msg_ctx, service, MSG_DREPL_ALLOCATE_RID, dreplsrv_allocate_rid);
+        imessaging_register(task->msg_ctx, service, MSG_DREPL_ALLOCATE_RID, dreplsrv_allocate_rid);
 }
 

vendor/current/source4/dsdb/repl/drepl_service.h

@@ -53 +53 @@
         /* the out going connection to the source dsa */
         struct dreplsrv_drsuapi_connection *drsuapi;
-
-        /* used to force the GC principal name */
-        const char *principal_name;
 };
 
@@ -110 +107 @@
         struct dreplsrv_partition_source_dsa *notifies;
 
-        bool incoming_only;
+        bool partial_replica;
+        bool rodc_replica;
 };
 
@@ -190 +188 @@
         } periodic;
 
+        /* some stuff for running only the pendings ops */
+        struct {
+                /*
+                 * the interval between notify runs
+                 */
+                uint32_t interval;
+
+                /*
+                 * the timestamp for the next event,
+                 * this is the timstamp passed to event_add_timed()
+                 */
+                struct timeval next_event;
+
+                /* here we have a reference to the timed event the schedules the notifies */
+                struct tevent_timer *te;
+        } pending;
+
         /* some stuff for notify processing */
         struct {

vendor/current/source4/dsdb/repl/replicated_objects.c

@@ -32 +32 @@
 #include "param/param.h"
 
+static WERROR dsdb_repl_merge_working_schema(struct ldb_context *ldb,
+                                             struct dsdb_schema *dest_schema,
+                                             const struct dsdb_schema *ref_schema)
+{
+        const struct dsdb_class *cur_class = NULL;
+        const struct dsdb_attribute *cur_attr = NULL;
+        int ret;
+
+        for (cur_class = ref_schema->classes;
+             cur_class;
+             cur_class = cur_class->next)
+        {
+                const struct dsdb_class *tmp1;
+                struct dsdb_class *tmp2;
+
+                tmp1 = dsdb_class_by_governsID_id(dest_schema,
+                                                  cur_class->governsID_id);
+                if (tmp1 != NULL) {
+                        continue;
+                }
+
+                /*
+                 * Do a shallow copy so that original next and prev are
+                 * not modified, we don't need to do a deep copy
+                 * as the rest won't be modified and this is for
+                 * a short lived object.
+                 */
+                tmp2 = talloc(dest_schema, struct dsdb_class);
+                if (tmp2 == NULL) {
+                        return WERR_NOMEM;
+                }
+                *tmp2 = *cur_class;
+                DLIST_ADD(dest_schema->classes, tmp2);
+        }
+
+        for (cur_attr = ref_schema->attributes;
+             cur_attr;
+             cur_attr = cur_attr->next)
+        {
+                const struct dsdb_attribute *tmp1;
+                struct dsdb_attribute *tmp2;
+
+                tmp1 = dsdb_attribute_by_attributeID_id(dest_schema,
+                                                cur_attr->attributeID_id);
+                if (tmp1 != NULL) {
+                        continue;
+                }
+
+                /*
+                 * Do a shallow copy so that original next and prev are
+                 * not modified, we don't need to do a deep copy
+                 * as the rest won't be modified and this is for
+                 * a short lived object.
+                 */
+                tmp2 = talloc(dest_schema, struct dsdb_attribute);
+                if (tmp2 == NULL) {
+                        return WERR_NOMEM;
+                }
+                *tmp2 = *cur_attr;
+                DLIST_ADD(dest_schema->attributes, tmp2);
+        }
+
+        ret = dsdb_setup_sorted_accessors(ldb, dest_schema);
+        if (LDB_SUCCESS != ret) {
+                DEBUG(0,("Failed to add new attribute to reference schema!\n"));
+                return WERR_INTERNAL_ERROR;
+        }
+
+        return WERR_OK;
+}
+
+WERROR dsdb_repl_resolve_working_schema(struct ldb_context *ldb,
+                                        TALLOC_CTX *mem_ctx,
+                                        struct dsdb_schema_prefixmap *pfm_remote,
+                                        uint32_t cycle_before_switching,
+                                        struct dsdb_schema *initial_schema,
+                                        struct dsdb_schema *resulting_schema,
+                                        uint32_t object_count,
+                                        const struct drsuapi_DsReplicaObjectListItemEx *first_object)
+{
+        struct schema_list {
+                struct schema_list *next, *prev;
+                const struct drsuapi_DsReplicaObjectListItemEx *obj;
+        };
+        struct schema_list *schema_list = NULL, *schema_list_item, *schema_list_next_item;
+        WERROR werr;
+        struct dsdb_schema *working_schema;
+        const struct drsuapi_DsReplicaObjectListItemEx *cur;
+        DATA_BLOB empty_key = data_blob_null;
+        int ret, pass_no;
+        uint32_t ignore_attids[] = {
+                        DRSUAPI_ATTID_auxiliaryClass,
+                        DRSUAPI_ATTID_mayContain,
+                        DRSUAPI_ATTID_mustContain,
+                        DRSUAPI_ATTID_possSuperiors,
+                        DRSUAPI_ATTID_systemPossSuperiors,
+                        DRSUAPI_ATTID_INVALID
+        };
+
+        /* create a list of objects yet to be converted */
+        for (cur = first_object; cur; cur = cur->next_object) {
+                schema_list_item = talloc(mem_ctx, struct schema_list);
+                if (schema_list_item == NULL) {
+                        return WERR_NOMEM;
+                }
+
+                schema_list_item->obj = cur;
+                DLIST_ADD_END(schema_list, schema_list_item);
+        }
+
+        /* resolve objects until all are resolved and in local schema */
+        pass_no = 1;
+        working_schema = initial_schema;
+
+        while (schema_list) {
+                uint32_t converted_obj_count = 0;
+                uint32_t failed_obj_count = 0;
+
+                if (resulting_schema != working_schema) {
+                        /*
+                         * If the selfmade schema is not the schema used to
+                         * translate and validate replicated object,
+                         * Which means that we are using the bootstrap schema
+                         * Then we add attributes and classes that were already
+                         * translated to the working schema, the idea is that
+                         * we might need to add new attributes and classes
+                         * to be able to translate critical replicated objects
+                         * and without that we wouldn't be able to translate them
+                         */
+                        werr = dsdb_repl_merge_working_schema(ldb,
+                                                        working_schema,
+                                                        resulting_schema);
+                        if (!W_ERROR_IS_OK(werr)) {
+                                return werr;
+                        }
+                }
+
+                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.
+                         */
+                        werr = dsdb_convert_object_ex(ldb, working_schema,
+                                                      NULL,
+                                                      pfm_remote,
+                                                      cur, &empty_key,
+                                                      ignore_attids,
+                                                      0,
+                                                      schema_list_item, &object);
+                        if (!W_ERROR_IS_OK(werr)) {
+                                DEBUG(4,("debug: Failed to convert schema "
+                                         "object %s into ldb msg, "
+                                         "will try during next loop\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
+                                 *
+                                 * It's not likely, but possible to get the
+                                 * same object twice and we should keep
+                                 * the last instance.
+                                 */
+                                werr = dsdb_schema_set_el_from_ldb_msg_dups(ldb,
+                                                                resulting_schema,
+                                                                object.msg,
+                                                                true);
+                                if (!W_ERROR_IS_OK(werr)) {
+                                        DEBUG(4,("debug: failed to convert "
+                                                 "object %s into a schema element, "
+                                                 "will try during next loop: %s\n",
+                                                 ldb_dn_get_linearized(object.msg->dn),
+                                                 win_errstr(werr)));
+                                        failed_obj_count++;
+                                } else {
+                                        DEBUG(8,("Converted object %s into a schema element\n",
+                                                 ldb_dn_get_linearized(object.msg->dn)));
+                                        DLIST_REMOVE(schema_list, schema_list_item);
+                                        TALLOC_FREE(schema_list_item);
+                                        converted_obj_count++;
+                                }
+                        }
+                }
+
+                DEBUG(4,("Schema load pass %d: converted %d, %d of %d objects left to be converted.\n",
+                         pass_no, converted_obj_count, failed_obj_count, object_count));
+
+                /* 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 WERR_INTERNAL_ERROR;
+                }
+
+                /*
+                 * Don't try to load the schema if there is missing object
+                 * _and_ we are on the first pass as some critical objects
+                 * might be missing.
+                 */
+                if (failed_obj_count == 0 || pass_no > cycle_before_switching) {
+                        /* prepare for another cycle */
+                        working_schema = resulting_schema;
+
+                        ret = dsdb_setup_sorted_accessors(ldb, working_schema);
+                        if (LDB_SUCCESS != ret) {
+                                DEBUG(0,("Failed to create schema-cache indexes!\n"));
+                                return WERR_INTERNAL_ERROR;
+                        }
+                }
+                pass_no++;
+        }
+
+        return WERR_OK;
+}
+
 /**
  * Multi-pass working schema creation
@@ -51 +286 @@
                                      struct dsdb_schema **_schema_out)
 {
-        struct schema_list {
-                struct schema_list *next, *prev;
-                const struct drsuapi_DsReplicaObjectListItemEx *obj;
-        };
-
         WERROR werr;
         struct dsdb_schema_prefixmap *pfm_remote;
-        struct schema_list *schema_list = NULL, *schema_list_item, *schema_list_next_item;
         struct dsdb_schema *working_schema;
-        const struct drsuapi_DsReplicaObjectListItemEx *cur;
-        int ret, pass_no;
-        uint32_t ignore_attids[] = {
-                        DRSUAPI_ATTID_auxiliaryClass,
-                        DRSUAPI_ATTID_mayContain,
-                        DRSUAPI_ATTID_mustContain,
-                        DRSUAPI_ATTID_possSuperiors,
-                        DRSUAPI_ATTID_systemPossSuperiors,
-                        DRSUAPI_ATTID_INVALID
-        };
 
         /* make a copy of the iniatial_scheam so we don't mess with it */
@@ -87 +306 @@
         }
 
-        /* create a list of objects yet to be converted */
-        for (cur = first_object; cur; cur = cur->next_object) {
-                schema_list_item = talloc(mem_ctx, 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;
-
-        while (schema_list) {
-                uint32_t converted_obj_count = 0;
-                uint32_t failed_obj_count = 0;
-                TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
-                W_ERROR_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.
-                         */
-                        werr = dsdb_convert_object_ex(ldb, working_schema, pfm_remote,
-                                                      cur, gensec_skey,
-                                                      ignore_attids,
-                                                      tmp_ctx, &object);
-                        if (!W_ERROR_IS_OK(werr)) {
-                                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
-                                 */
-                                werr = dsdb_schema_set_el_from_ldb_msg(ldb,
-                                                                       working_schema,
-                                                                       object.msg);
-                                if (!W_ERROR_IS_OK(werr)) {
-                                        DEBUG(1,("Warning: failed to convert object %s into a schema element: %s\n",
-                                                 ldb_dn_get_linearized(object.msg->dn),
-                                                 win_errstr(werr)));
-                                        failed_obj_count++;
-                                } else {
-                                        DLIST_REMOVE(schema_list, schema_list_item);
-                                        talloc_free(schema_list_item);
-                                        converted_obj_count++;
-                                }
-                        }
-                }
-                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 WERR_INTERNAL_ERROR;
-                }
-
-                /* rebuild indexes */
-                ret = dsdb_setup_sorted_accessors(ldb, working_schema);
-                if (LDB_SUCCESS != ret) {
-                        DEBUG(0,("Failed to create schema-cache indexes!\n"));
-                        return WERR_INTERNAL_ERROR;
-                }
-        };
+        werr = dsdb_repl_resolve_working_schema(ldb, mem_ctx,
+                                                pfm_remote,
+                                                0, /* cycle_before_switching */
+                                                working_schema,
+                                                working_schema,
+                                                object_count,
+                                                first_object);
+        if (!W_ERROR_IS_OK(werr)) {
+                DEBUG(0, ("%s: dsdb_repl_resolve_working_schema() failed: %s",
+                          __location__, win_errstr(werr)));
+                return werr;
+        }
 
         *_schema_out = working_schema;
@@ -189 +340 @@
 WERROR dsdb_convert_object_ex(struct ldb_context *ldb,
                               const struct dsdb_schema *schema,
+                              struct ldb_dn *partition_dn,
                               const struct dsdb_schema_prefixmap *pfm_remote,
                               const struct drsuapi_DsReplicaObjectListItemEx *in,
                               const DATA_BLOB *gensec_skey,
                               const uint32_t *ignore_attids,
+                              uint32_t dsdb_repl_flags,
                               TALLOC_CTX *mem_ctx,
                               struct dsdb_extended_replicated_object *out)
 {
         NTSTATUS nt_status;
-        WERROR status;
+        WERROR status = WERR_OK;
         uint32_t i;
         struct ldb_message *msg;
         struct replPropertyMetaDataBlob *md;
+        int instanceType;
+        struct ldb_message_element *instanceType_e = NULL;
         struct ldb_val guid_value;
+        struct ldb_val parent_guid_value;
         NTTIME whenChanged = 0;
         time_t whenChanged_t;
         const char *whenChanged_s;
-        const char *rdn_name = NULL;
-        const struct ldb_val *rdn_value = NULL;
-        const struct dsdb_attribute *rdn_attr = NULL;
-        uint32_t rdn_attid;
         struct drsuapi_DsReplicaAttribute *name_a = NULL;
         struct drsuapi_DsReplicaMetaData *name_d = NULL;
@@ -244 +396 @@
         W_ERROR_HAVE_NO_MEMORY(msg->dn);
 
-        rdn_name        = ldb_dn_get_rdn_name(msg->dn);
-        rdn_attr        = dsdb_attribute_by_lDAPDisplayName(schema, rdn_name);
-        if (!rdn_attr) {
-                return WERR_FOOBAR;
-        }
-        rdn_attid       = rdn_attr->attributeID_id;
-        rdn_value       = ldb_dn_get_rdn_val(msg->dn);
-
         msg->num_elements       = in->object.attribute_ctr.num_attributes;
         msg->elements           = talloc_array(msg, struct ldb_message_element,
-                                               msg->num_elements);
+                                               msg->num_elements + 1); /* +1 because of the RDN attribute */
         W_ERROR_HAVE_NO_MEMORY(msg->elements);
 
@@ -286 +430 @@
                 }
 
+                if (GUID_all_zero(&d->originating_invocation_id)) {
+                        status = WERR_DS_SRC_GUID_MISMATCH;
+                        DEBUG(0, ("Refusing replication of object containing invalid zero invocationID on attribute %d of %s: %s\n",
+                                  a->attid,
+                                  ldb_dn_get_linearized(msg->dn),
+                                  win_errstr(status)));
+                        return status;
+                }
+
+                if (a->attid == DRSUAPI_ATTID_instanceType) {
+                        if (instanceType_e != NULL) {
+                                return WERR_FOOBAR;
+                        }
+                        instanceType_e = e;
+                }
+
                 for (j=0; j<a->value_ctr.num_values; j++) {
-                        status = drsuapi_decrypt_attribute(a->value_ctr.values[j].blob, gensec_skey, rid, a);
-                        W_ERROR_NOT_OK_RETURN(status);
-                }
-
+                        status = drsuapi_decrypt_attribute(a->value_ctr.values[j].blob,
+                                                           gensec_skey, rid,
+                                                           dsdb_repl_flags, a);
+                        if (!W_ERROR_IS_OK(status)) {
+                                break;
+                        }
+                }
+                if (W_ERROR_EQUAL(status, WERR_TOO_MANY_SECRETS)) {
+                        WERROR get_name_status = dsdb_attribute_drsuapi_to_ldb(ldb, schema, pfm_remote,
+                                                                               a, msg->elements, e, NULL);
+                        if (W_ERROR_IS_OK(get_name_status)) {
+                                DEBUG(0, ("Unxpectedly got secret value %s on %s from DRS server\n",
+                                          e->name, ldb_dn_get_linearized(msg->dn)));
+                        } else {
+                                DEBUG(0, ("Unxpectedly got secret value on %s from DRS server",
+                                          ldb_dn_get_linearized(msg->dn)));
+                        }
+                } else if (!W_ERROR_IS_OK(status)) {
+                        return status;
+                }
+
+                /*
+                 * This function also fills in the local attid value,
+                 * based on comparing the remote and local prefixMap
+                 * tables.  If we don't convert the value, then we can
+                 * have invalid values in the replPropertyMetaData we
+                 * store on disk, as the prefixMap is per host, not
+                 * per-domain.  This may be why Microsoft added the
+                 * msDS-IntID feature, however this is not used for
+                 * extra attributes in the schema partition itself.
+                 */
                 status = dsdb_attribute_drsuapi_to_ldb(ldb, schema, pfm_remote,
-                                                       a, msg->elements, e);
+                                                       a, msg->elements, e,
+                                                       &m->attid);
                 W_ERROR_NOT_OK_RETURN(status);
 
-                m->attid                        = a->attid;
                 m->version                      = d->version;
                 m->originating_change_time      = d->originating_change_time;
@@ -320 +507 @@
         if (rdn_m) {
                 struct ldb_message_element *el;
+                const char *rdn_name = NULL;
+                const struct ldb_val *rdn_value = NULL;
+                const struct dsdb_attribute *rdn_attr = NULL;
+                uint32_t rdn_attid;
+
+                /*
+                 * We only need the schema calls for the RDN in this
+                 * codepath, and by doing this we avoid needing to
+                 * have the dsdb_attribute_by_lDAPDisplayName accessor
+                 * working during the schema load.
+                 */
+                rdn_name        = ldb_dn_get_rdn_name(msg->dn);
+                rdn_attr        = dsdb_attribute_by_lDAPDisplayName(schema, rdn_name);
+                if (!rdn_attr) {
+                        return WERR_FOOBAR;
+                }
+                rdn_attid       = rdn_attr->attributeID_id;
+                rdn_value       = ldb_dn_get_rdn_val(msg->dn);
+
                 el = ldb_msg_find_element(msg, rdn_attr->lDAPDisplayName);
                 if (!el) {
@@ -350 +556 @@
         }
 
+        if (instanceType_e == NULL) {
+                return WERR_FOOBAR;
+        }
+
+        instanceType = ldb_msg_find_attr_as_int(msg, "instanceType", 0);
+
+        if (instanceType & INSTANCE_TYPE_IS_NC_HEAD && partition_dn) {
+                int partition_dn_cmp = ldb_dn_compare(partition_dn, msg->dn);
+                if (partition_dn_cmp != 0) {
+                        DEBUG(4, ("Remote server advised us of a new partition %s while processing %s, ignoring\n",
+                                  ldb_dn_get_linearized(msg->dn),
+                                  ldb_dn_get_linearized(partition_dn)));
+                        return WERR_DS_ADD_REPLICA_INHIBITED;
+                }
+        }
+
+        if (dsdb_repl_flags & DSDB_REPL_FLAG_PARTIAL_REPLICA) {
+                /* the instanceType type for partial_replica
+                   replication is sent via DRS with TYPE_WRITE set, but
+                   must be used on the client with TYPE_WRITE removed
+                */
+                if (instanceType & INSTANCE_TYPE_WRITE) {
+                        /*
+                         * Make sure we do not change the order
+                         * of msg->elements!
+                         *
+                         * That's why we use
+                         * instanceType_e->num_values = 0
+                         * instead of
+                         * ldb_msg_remove_attr(msg, "instanceType");
+                         */
+                        struct ldb_message_element *e;
+
+                        e = ldb_msg_find_element(msg, "instanceType");
+                        if (e != instanceType_e) {
+                                DEBUG(0,("instanceType_e[%p] changed to e[%p]\n",
+                                         instanceType_e, e));
+                                return WERR_FOOBAR;
+                        }
+
+                        instanceType_e->num_values = 0;
+
+                        instanceType &= ~INSTANCE_TYPE_WRITE;
+                        if (ldb_msg_add_fmt(msg, "instanceType", "%d", instanceType) != LDB_SUCCESS) {
+                                return WERR_INTERNAL_ERROR;
+                        }
+                }
+        } else {
+                if (!(instanceType & INSTANCE_TYPE_WRITE)) {
+                        DEBUG(0, ("Refusing to replicate %s from a read-only repilca into a read-write replica!\n",
+                                  ldb_dn_get_linearized(msg->dn)));
+                        return WERR_DS_DRA_SOURCE_IS_PARTIAL_REPLICA;
+                }
+        }
+
         whenChanged_t = nt_time_to_unix(whenChanged);
         whenChanged_s = ldb_timestring(msg, whenChanged_t);
@@ -359 +620 @@
         }
 
+        if (in->parent_object_guid) {
+                nt_status = GUID_to_ndr_blob(in->parent_object_guid, msg, &parent_guid_value);
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return ntstatus_to_werror(nt_status);
+                }
+        } else {
+                parent_guid_value = data_blob_null;
+        }
+
         out->msg                = msg;
         out->guid_value         = guid_value;
+        out->parent_guid_value  = parent_guid_value;
         out->when_changed       = whenChanged_s;
         out->meta_data          = md;
@@ -377 +648 @@
                                        const struct drsuapi_DsReplicaCursor2CtrEx *uptodateness_vector,
                                        const DATA_BLOB *gensec_skey,
+                                       uint32_t dsdb_repl_flags,
                                        TALLOC_CTX *mem_ctx,
                                        struct dsdb_extended_replicated_objects **objects)
@@ -390 +662 @@
         W_ERROR_HAVE_NO_MEMORY(out);
         out->version            = DSDB_EXTENDED_REPLICATED_OBJECTS_VERSION;
+        out->dsdb_repl_flags    = dsdb_repl_flags;
 
         /*
@@ -429 +702 @@
         out->uptodateness_vector= uptodateness_vector;
 
-        out->num_objects        = object_count;
+        out->num_objects        = 0;
         out->objects            = talloc_array(out,
                                                struct dsdb_extended_replicated_object,
-                                               out->num_objects);
+                                               object_count);
         W_ERROR_HAVE_NO_MEMORY_AND_FREE(out->objects, out);
 
@@ -441 +714 @@
 
         for (i=0, cur = first_object; cur; cur = cur->next_object, i++) {
-                if (i == out->num_objects) {
+                if (i == object_count) {
                         talloc_free(out);
                         return WERR_FOOBAR;
                 }
 
-                status = dsdb_convert_object_ex(ldb, schema, pfm_remote,
+                status = dsdb_convert_object_ex(ldb, schema, out->partition_dn,
+                                                pfm_remote,
                                                 cur, gensec_skey,
                                                 NULL,
-                                                out->objects, &out->objects[i]);
+                                                dsdb_repl_flags,
+                                                out->objects,
+                                                &out->objects[out->num_objects]);
+
+                /*
+                 * Check to see if we have been advised of a
+                 * subdomain or new application partition.  We don't
+                 * want to start on that here, instead the caller
+                 * should consider if it would like to replicate it
+                 * based on the cross-ref object.
+                 */
+                if (W_ERROR_EQUAL(status, WERR_DS_ADD_REPLICA_INHIBITED)) {
+                        continue;
+                }
+
                 if (!W_ERROR_IS_OK(status)) {
                         talloc_free(out);
@@ -457 +745 @@
                         return status;
                 }
-        }
-        if (i != out->num_objects) {
+
+                /* Assuming we didn't skip or error, increment the number of objects */
+                out->num_objects++;
+        }
+        out->objects = talloc_realloc(out, out->objects,
+                                      struct dsdb_extended_replicated_object,
+                                      out->num_objects);
+        if (out->num_objects != 0 && out->objects == NULL) {
+                talloc_free(out);
+                return WERR_FOOBAR;
+        }
+        if (i != object_count) {
                 talloc_free(out);
                 return WERR_FOOBAR;
@@ -485 +783 @@
         struct ldb_result *ext_res;
         struct dsdb_schema *cur_schema = NULL;
+        struct dsdb_schema *new_schema = NULL;
         int ret;
         uint64_t seq_num1, seq_num2;
+        bool used_global_schema = false;
+
+        TALLOC_CTX *tmp_ctx = talloc_new(objects);
+        if (!tmp_ctx) {
+                DEBUG(0,("Failed to start talloc\n"));
+                return WERR_NOMEM;
+        }
 
         /* TODO: handle linked attributes */
@@ -503 +809 @@
                 DEBUG(0,(__location__ " Failed to load partition uSN\n"));
                 ldb_transaction_cancel(ldb);
+                TALLOC_FREE(tmp_ctx);
                 return WERR_FOOBAR;             
         }
@@ -514 +821 @@
         if (working_schema) {
                 /* store current schema so we can fall back in case of failure */
-                cur_schema = dsdb_get_schema(ldb, working_schema);
+                cur_schema = dsdb_get_schema(ldb, tmp_ctx);
+                used_global_schema = dsdb_uses_global_schema(ldb);
 
                 ret = dsdb_reference_schema(ldb, working_schema, false);
@@ -522 +830 @@
                         /* TODO: Map LDB Error to NTSTATUS? */
                         ldb_transaction_cancel(ldb);
+                        TALLOC_FREE(tmp_ctx);
                         return WERR_INTERNAL_ERROR;
                 }
@@ -529 +838 @@
         if (ret != LDB_SUCCESS) {
                 /* restore previous schema */
-                if (cur_schema ) {
+                if (used_global_schema) { 
+                        dsdb_set_global_schema(ldb);
+                } else if (cur_schema) {
                         dsdb_reference_schema(ldb, cur_schema, false);
-                        dsdb_make_schema_global(ldb, cur_schema);
                 }
 
@@ -537 +847 @@
                          ldb_errstring(ldb), ldb_strerror(ret)));
                 ldb_transaction_cancel(ldb);
+                TALLOC_FREE(tmp_ctx);
                 return WERR_FOOBAR;
         }
@@ -548 +859 @@
                 if (!W_ERROR_IS_OK(werr)) {
                         /* restore previous schema */
-                        if (cur_schema ) {
+                        if (used_global_schema) { 
+                                dsdb_set_global_schema(ldb);
+                        } else if (cur_schema ) {
                                 dsdb_reference_schema(ldb, cur_schema, false);
-                                dsdb_make_schema_global(ldb, cur_schema);
                         }
                         DEBUG(0,("Failed to save updated prefixMap: %s\n",
                                  win_errstr(werr)));
+                        TALLOC_FREE(tmp_ctx);
                         return werr;
                 }
@@ -561 +874 @@
         if (ret != LDB_SUCCESS) {
                 /* restore previous schema */
-                if (cur_schema ) {
+                if (used_global_schema) { 
+                        dsdb_set_global_schema(ldb);
+                } else if (cur_schema ) {
                         dsdb_reference_schema(ldb, cur_schema, false);
-                        dsdb_make_schema_global(ldb, cur_schema);
                 }
                 DEBUG(0,(__location__ " Failed to prepare commit of transaction: %s\n",
                          ldb_errstring(ldb)));
+                TALLOC_FREE(tmp_ctx);
                 return WERR_FOOBAR;
         }
@@ -573 +888 @@
         if (ret != LDB_SUCCESS) {
                 /* restore previous schema */
-                if (cur_schema ) {
+                if (used_global_schema) { 
+                        dsdb_set_global_schema(ldb);
+                } else if (cur_schema ) {
                         dsdb_reference_schema(ldb, cur_schema, false);
-                        dsdb_make_schema_global(ldb, cur_schema);
                 }
                 DEBUG(0,(__location__ " Failed to load partition uSN\n"));
                 ldb_transaction_cancel(ldb);
+                TALLOC_FREE(tmp_ctx);
                 return WERR_FOOBAR;             
-        }
-
-        /* if this replication partner didn't need to be notified
-           before this transaction then it still doesn't need to be
-           notified, as the changes came from this server */    
-        if (seq_num2 > seq_num1 && seq_num1 <= *notify_uSN) {
-                *notify_uSN = seq_num2;
         }
 
@@ -592 +902 @@
         if (ret != LDB_SUCCESS) {
                 /* restore previous schema */
-                if (cur_schema ) {
+                if (used_global_schema) { 
+                        dsdb_set_global_schema(ldb);
+                } else if (cur_schema ) {
                         dsdb_reference_schema(ldb, cur_schema, false);
-                        dsdb_make_schema_global(ldb, cur_schema);
                 }
                 DEBUG(0,(__location__ " Failed to commit transaction\n"));
+                TALLOC_FREE(tmp_ctx);
                 return WERR_FOOBAR;
+        }
+
+        /* if this replication partner didn't need to be notified
+           before this transaction then it still doesn't need to be
+           notified, as the changes came from this server */
+        if (seq_num2 > seq_num1 && seq_num1 <= *notify_uSN) {
+                *notify_uSN = seq_num2;
         }
 
@@ -605 +924 @@
          */
         if (working_schema) {
-                cur_schema = dsdb_get_schema(ldb, NULL);
-                /* TODO: What we do in case dsdb_get_schema() fail?
-                 *       We can't fallback at this point anymore */
-                if (cur_schema) {
-                        dsdb_make_schema_global(ldb, cur_schema);
+                struct ldb_message *msg;
+                struct ldb_request *req;
+
+                /* Force a reload */
+                working_schema->last_refresh = 0;
+                new_schema = dsdb_get_schema(ldb, tmp_ctx);
+                /* TODO: 
+                 * If dsdb_get_schema() fails, we just fall back
+                 * to what we had.  However, the database is probably
+                 * unable to operate for other users from this
+                 * point... */
+                if (new_schema && used_global_schema) {
+                        dsdb_make_schema_global(ldb, new_schema);
+                } else if (used_global_schema) { 
+                        DEBUG(0,("Failed to re-load schema after commit of transaction\n"));
+                        dsdb_set_global_schema(ldb);
+                        TALLOC_FREE(tmp_ctx);
+                        return WERR_INTERNAL_ERROR;
+                } else {
+                        DEBUG(0,("Failed to re-load schema after commit of transaction\n"));
+                        dsdb_reference_schema(ldb, cur_schema, false);
+                        TALLOC_FREE(tmp_ctx);
+                        return WERR_INTERNAL_ERROR;
+                }
+                msg = ldb_msg_new(tmp_ctx);
+                if (msg == NULL) {
+                        TALLOC_FREE(tmp_ctx);
+                        return WERR_NOMEM;
+                }
+                msg->dn = ldb_dn_new(msg, ldb, "");
+                if (msg->dn == NULL) {
+                        TALLOC_FREE(tmp_ctx);
+                        return WERR_NOMEM;
+                }
+
+                ret = ldb_msg_add_string(msg, "schemaUpdateNow", "1");
+                if (ret != LDB_SUCCESS) {
+                        TALLOC_FREE(tmp_ctx);
+                        return WERR_INTERNAL_ERROR;
+                }
+
+                ret = ldb_build_mod_req(&req, ldb, objects,
+                                msg,
+                                NULL,
+                                NULL,
+                                ldb_op_default_callback,
+                                NULL);
+
+                if (ret != LDB_SUCCESS) {
+                        TALLOC_FREE(tmp_ctx);
+                        return WERR_DS_DRA_INTERNAL_ERROR;
+                }
+
+                ret = ldb_transaction_start(ldb);
+                if (ret != LDB_SUCCESS) {
+                        TALLOC_FREE(tmp_ctx);
+                        DEBUG(0, ("Autotransaction start failed\n"));
+                        return WERR_DS_DRA_INTERNAL_ERROR;
+                }
+
+                ret = ldb_request(ldb, req);
+                if (ret == LDB_SUCCESS) {
+                        ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+                }
+
+                if (ret == LDB_SUCCESS) {
+                        ret = ldb_transaction_commit(ldb);
+                } else {
+                        DEBUG(0, ("Schema update now failed: %s\n",
+                                  ldb_errstring(ldb)));
+                        ldb_transaction_cancel(ldb);
+                }
+
+                if (ret != LDB_SUCCESS) {
+                        DEBUG(0, ("Commit failed: %s\n", ldb_errstring(ldb)));
+                        TALLOC_FREE(tmp_ctx);
+                        return WERR_DS_INTERNAL_FAILURE;
                 }
         }
@@ -617 +1008 @@
                  ldb_dn_get_linearized(objects->partition_dn)));
                  
+        TALLOC_FREE(tmp_ctx);
         return WERR_OK;
 }
@@ -657 +1049 @@
 
                 status = dsdb_attribute_drsuapi_to_ldb(ldb, schema, schema->prefixmap,
-                                                       a, msg->elements, e);
+                                                       a, msg->elements, e, NULL);
                 W_ERROR_NOT_OK_RETURN(status);
         }
@@ -671 +1063 @@
                                   const struct drsuapi_DsReplicaObjectListItem *first_object,
                                   uint32_t *_num,
+                                  uint32_t dsdb_repl_flags,
                                   struct drsuapi_DsReplicaObjectIdentifier2 **_ids)
 {
@@ -729 +1122 @@
         }
 
+        if (dsdb_repl_flags & DSDB_REPL_FLAG_ADD_NCNAME) {
+                /* check for possible NC creation */
+                for (i=0; i < num_objects; i++) {
+                        struct ldb_message *msg = objects[i];
+                        struct ldb_message_element *el;
+                        struct ldb_dn *nc_dn;
+
+                        if (ldb_msg_check_string_attribute(msg, "objectClass", "crossRef") == 0) {
+                                continue;
+                        }
+                        el = ldb_msg_find_element(msg, "nCName");
+                        if (el == NULL || el->num_values != 1) {
+                                continue;
+                        }
+                        nc_dn = ldb_dn_from_ldb_val(objects, ldb, &el->values[0]);
+                        if (!ldb_dn_validate(nc_dn)) {
+                                continue;
+                        }
+                        ret = dsdb_create_partial_replica_NC(ldb, nc_dn);
+                        if (ret != LDB_SUCCESS) {
+                                status = WERR_DS_INTERNAL_FAILURE;
+                                goto cancel;
+                        }
+                }
+        }
+
         for (i=0; i < num_objects; i++) {
                 struct dom_sid *sid = NULL;