Changeset 740 for vendor/current/source4/dsdb/schema

Timestamp:

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

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/source4/dsdb/schema

Files:

• dsdb_dn.c (added)
• prefixmap.h (added)
• schema.h (modified) (10 diffs)
• schema_convert_to_ol.c (modified) (5 diffs)
• schema_description.c (modified) (2 diffs)
• schema_filtered.c (added)
• schema_inferiors.c (modified) (18 diffs)
• schema_info_attr.c (added)
• schema_init.c (modified) (38 diffs)
• schema_prefixmap.c (added)
• schema_query.c (modified) (21 diffs)
• schema_set.c (modified) (33 diffs)
• schema_syntax.c (modified) (100 diffs)
• tests (added)
• tests/schema_syntax.c (added)

vendor/current/source4/dsdb/schema/schema.h

@@ -23 +23 @@
 #define _DSDB_SCHEMA_H
 
+#include "prefixmap.h"
+
 struct dsdb_attribute;
 struct dsdb_class;
 struct dsdb_schema;
+struct dsdb_dn;
+
+struct dsdb_syntax_ctx {
+        struct ldb_context *ldb;
+        const struct dsdb_schema *schema;
+
+        /* set when converting objects under Schema NC */
+        bool is_schema_nc;
+
+        /* remote prefixMap to be used for drsuapi_to_ldb conversions */
+        const struct dsdb_schema_prefixmap *pfm_remote;
+};
+
 
 struct dsdb_syntax {
@@ -38 +53 @@
         const char *ldb_syntax;
 
-        WERROR (*drsuapi_to_ldb)(struct ldb_context *ldb, 
-                                 const struct dsdb_schema *schema,
+        WERROR (*drsuapi_to_ldb)(const struct dsdb_syntax_ctx *ctx,
                                  const struct dsdb_attribute *attr,
                                  const struct drsuapi_DsReplicaAttribute *in,
                                  TALLOC_CTX *mem_ctx,
                                  struct ldb_message_element *out);
-        WERROR (*ldb_to_drsuapi)(struct ldb_context *ldb, 
-                                 const struct dsdb_schema *schema,
+        WERROR (*ldb_to_drsuapi)(const struct dsdb_syntax_ctx *ctx,
                                  const struct dsdb_attribute *attr,
                                  const struct ldb_message_element *in,
                                  TALLOC_CTX *mem_ctx,
                                  struct drsuapi_DsReplicaAttribute *out);
+        WERROR (*validate_ldb)(const struct dsdb_syntax_ctx *ctx,
+                               const struct dsdb_attribute *attr,
+                               const struct ldb_message_element *in);
 };
 
@@ -61 +77 @@
         struct GUID schemaIDGUID;
         uint32_t mAPIID;
+        uint32_t msDS_IntId;
 
         struct GUID attributeSecurityGUID;
+        struct GUID objectGUID;
 
         uint32_t searchFlags;
@@ -103 +121 @@
         uint32_t governsID_id;
         struct GUID schemaIDGUID;
+        struct GUID objectGUID;
 
         uint32_t objectClassCategory;
@@ -120 +139 @@
         const char **mayContain;
         const char **possibleInferiors;
+        const char **systemPossibleInferiors;
 
         const char *defaultSecurityDescriptor;
@@ -134 +154 @@
         bool systemOnly;
 
-        char **supclasses;
-        char **subclasses;
-        char **subclasses_direct;
-        char **posssuperiors;
+        const char **supclasses;
+        const char **subclasses;
+        const char **subclasses_direct;
+        const char **posssuperiors;
         uint32_t subClassOf_id;
         uint32_t *systemAuxiliaryClass_ids;
@@ -156 +176 @@
 };
 
-struct dsdb_schema_oid_prefix {
-        uint32_t id;
-        const char *oid;
-        size_t oid_len;
-};
+/**
+ * data stored in schemaInfo attribute
+ */
+struct dsdb_schema_info {
+        uint32_t        revision;
+        struct GUID     invocation_id;
+};
+
 
 struct dsdb_schema {
-        uint32_t num_prefixes;
-        struct dsdb_schema_oid_prefix *prefixes;
+        struct ldb_dn *base_dn;
+
+        struct dsdb_schema_prefixmap *prefixmap;
 
         /* 
@@ -176 +200 @@
         const char *schema_info;
 
+        /* We can also tell the schema version from the USN on the partition */
+        uint64_t loaded_usn;
+
         struct dsdb_attribute *attributes;
         struct dsdb_class *classes;
@@ -193 +220 @@
         struct dsdb_attribute **attributes_by_attributeID_oid;
         struct dsdb_attribute **attributes_by_linkID;
+        uint32_t num_int_id_attr;
+        struct dsdb_attribute **attributes_by_msDS_IntId;
 
         struct {
@@ -199 +228 @@
         } fsmo;
 
-        struct smb_iconv_convenience *iconv_convenience;
+        /* Was this schema loaded from ldb (if so, then we will reload it when we detect a change in ldb) */
+        struct ldb_module *loaded_from_module;
+        struct dsdb_schema *(*refresh_fn)(struct ldb_module *module, struct dsdb_schema *schema, bool is_global_schema);
+        bool refresh_in_progress;
+        /* an 'opaque' sequence number that the reload function may also wish to use */
+        uint64_t reload_seq_number;
+
+        /* Should the syntax handlers in this case handle all incoming OIDs automatically, assigning them as an OID if no text name is known? */
+        bool relax_OID_conversions;
 };
 

vendor/current/source4/dsdb/schema/schema_convert_to_ol.c

@@ -63 +63 @@
                         .values = &objectclass_name_as_ldb_val
                 };
-                int j;
-                int attr_idx;
+                unsigned int j;
+                unsigned int attr_idx;
                 
                 if (!mem_ctx) {
@@ -88 +88 @@
                         if (strcasecmp(name, attr_map[j].old_attr) == 0) {
                                 name =  attr_map[j].new_attr;
+                                break;
+                        }
+                }
+                
+                /* We might have been asked to remap this subClassOf, due to a conflict */
+                for (j=0; subClassOf && attr_map && attr_map[j].old_attr; j++) {
+                        if (strcasecmp(subClassOf, attr_map[j].old_attr) == 0) {
+                                subClassOf =  attr_map[j].new_attr;
                                 break;
                         }
@@ -176 +184 @@
         char *out;
         const char **attrs_skip = NULL;
-        int num_skip = 0;
+        unsigned int num_skip = 0;
         struct oid_map *oid_map = NULL;
-        int num_oid_maps = 0;
+        unsigned int num_oid_maps = 0;
         struct attr_map *attr_map = NULL;
-        int num_attr_maps = 0;  
+        unsigned int num_attr_maps = 0;
         struct dsdb_attribute *attribute;
         struct dsdb_schema *schema;
@@ -254 +262 @@
         }
 
-        schema = dsdb_get_schema(ldb);
+        schema = dsdb_get_schema(ldb, mem_ctx);
         if (!schema) {
                 DEBUG(0, ("No schema on ldb to convert!\n"));
@@ -277 +285 @@
 
                 char *schema_entry = NULL;
-                int j;
+                unsigned int j;
 
                 /* We have been asked to skip some attributes/objectClasses */

vendor/current/source4/dsdb/schema/schema_description.c

@@ -178 +178 @@
 #define APPEND_ATTRS(attributes)                                \
         do {                                                            \
-                int k;                                                  \
+                unsigned int k;                                         \
                 for (k=0; attributes && attributes[k]; k++) {           \
                         const char *attr_name = attributes[k];          \
@@ -343 +343 @@
                                      const struct dsdb_schema *schema)
 {
-        int i;
+        unsigned int i;
         char *schema_description;
         const char **aux_class_list = NULL;

vendor/current/source4/dsdb/schema/schema_inferiors.c

@@ -1 +1 @@
 /* 
-   Unix SMB/CIFS mplementation.
+   Unix SMB/CIFS implementation.
 
    implement possibleInferiors calculation
@@ -35 +35 @@
   create the SUPCLASSES() list
  */
-static char **schema_supclasses(struct dsdb_schema *schema, struct dsdb_class *schema_class)
-{
-        char **list;
+static const char **schema_supclasses(const struct dsdb_schema *schema,
+                                      struct dsdb_class *schema_class)
+{
+        const char **list;
 
         if (schema_class->supclasses) {
@@ -43 +44 @@
         }
 
-        list = str_list_make_empty(schema_class);
+        list = const_str_list(str_list_make_empty(schema_class));
         if (list == NULL) {
                 DEBUG(0,(__location__ " out of memory\n"));
@@ -49 +50 @@
         }
 
-        /* Cope with 'top SUP top', ie top is subClassOf top */ 
+        /* Cope with 'top SUP top', i.e. top is subClassOf top */
         if (schema_class->subClassOf &&
             strcmp(schema_class->lDAPDisplayName, schema_class->subClassOf) == 0) {
@@ -57 +58 @@
 
         if (schema_class->subClassOf) {
+                const struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, schema_class->subClassOf);
                 const char **list2;
-                list = str_list_add_const(list, schema_class->subClassOf);
-
-                list2 = schema_supclasses(schema,  
-                                          discard_const_p(struct dsdb_class, 
-                                                          dsdb_class_by_lDAPDisplayName(schema, 
-                                                                                        schema_class->subClassOf)));
+                list = str_list_add_const(list, schema_class->subClassOf);
+
+                list2 = schema_supclasses(schema, discard_const_p(struct dsdb_class, schema_class2));
                 list = str_list_append_const(list, list2);
         }
 
         schema_class->supclasses = str_list_unique(list);
-        
-        return list;
+
+        return schema_class->supclasses;
 }
 
@@ -76 +75 @@
   matches SUBCLASSES() python function
  */
-static char **schema_subclasses(struct dsdb_schema *schema, TALLOC_CTX *mem_ctx, char **oclist)
-{
-        char **list = str_list_make_empty(mem_ctx);
-        int i;
+static const char **schema_subclasses(const struct dsdb_schema *schema,
+                                      TALLOC_CTX *mem_ctx,
+                                      const char **oclist)
+{
+        const char **list = const_str_list(str_list_make_empty(mem_ctx));
+        unsigned int i;
 
         for (i=0; oclist && oclist[i]; i++) {
-                struct dsdb_class *schema_class = dsdb_class_by_lDAPDisplayName(schema, oclist[i]);
+                const struct dsdb_class *schema_class = dsdb_class_by_lDAPDisplayName(schema, oclist[i]);
                 if (!schema_class) {
                         DEBUG(0, ("ERROR: Unable to locate subClass: '%s'\n", oclist[i]));
@@ -96 +97 @@
    equivalent of the POSSSUPERIORS() python function
  */
-static char **schema_posssuperiors(struct dsdb_schema *schema, 
-                                   struct dsdb_class *schema_class)
+static const char **schema_posssuperiors(const struct dsdb_schema *schema,
+                                         struct dsdb_class *schema_class)
 {
         if (schema_class->posssuperiors == NULL) {
-                char **list2 = str_list_make_empty(schema_class);
-                char **list3;
-                int i;
+                const char **list2 = const_str_list(str_list_make_empty(schema_class));
+                const char **list3;
+                unsigned int i;
 
                 list2 = str_list_append_const(list2, schema_class->systemPossSuperiors);
@@ -108 +109 @@
                 list3 = schema_supclasses(schema, schema_class);
                 for (i=0; list3 && list3[i]; i++) {
-                        struct dsdb_class *class2 = dsdb_class_by_lDAPDisplayName(schema, list3[i]);
+                        const struct dsdb_class *class2 = dsdb_class_by_lDAPDisplayName(schema, list3[i]);
                         if (!class2) {
                                 DEBUG(0, ("ERROR: Unable to locate supClass: '%s'\n", list3[i]));
                                 continue;
                         }
-                        list2 = str_list_append_const(list2, schema_posssuperiors(schema, class2));
+                        list2 = str_list_append_const(list2, schema_posssuperiors(schema,
+                                discard_const_p(struct dsdb_class, class2)));
                 }
                 list2 = str_list_append_const(list2, schema_subclasses(schema, list2, list2));
@@ -123 +125 @@
 }
 
-static char **schema_subclasses_recurse(struct dsdb_schema *schema, struct dsdb_class *schema_class)
-{
-        char **list = str_list_copy_const(schema_class, schema_class->subclasses_direct);
-        int i;
+static const char **schema_subclasses_recurse(const struct dsdb_schema *schema,
+                                              struct dsdb_class *schema_class)
+{
+        const char **list = str_list_copy_const(schema_class, schema_class->subclasses_direct);
+        unsigned int i;
         for (i=0;list && list[i]; i++) {
-                struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, list[i]);
+                const struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, list[i]);
                 if (schema_class != schema_class2) {
-                        list = str_list_append_const(list, schema_subclasses_recurse(schema, schema_class2));
+                        list = str_list_append_const(list, schema_subclasses_recurse(schema,
+                                discard_const_p(struct dsdb_class, schema_class2)));
                 }
         }
@@ -138 +142 @@
 /* Walk down the subClass tree, setting a higher index as we go down
  * each level.  top is 1, subclasses of top are 2, etc */
-void schema_subclasses_order_recurse(struct dsdb_schema *schema, struct dsdb_class *schema_class, int order)
+void schema_subclasses_order_recurse(const struct dsdb_schema *schema,
+                                     struct dsdb_class *schema_class,
+                                     const int order)
 {
         const char **list = schema_class->subclasses_direct;
-        int i;
+        unsigned int i;
         schema_class->subClass_order = order;
         for (i=0;list && list[i]; i++) {
-                struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, list[i]);
-                schema_subclasses_order_recurse(schema, schema_class2, order+1);
+                const struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, list[i]);
+                schema_subclasses_order_recurse(schema, discard_const_p(struct dsdb_class, schema_class2), order+1);
         }
         return;
 }
 
-static void schema_create_subclasses(struct dsdb_schema *schema)
-{
-        struct dsdb_class *schema_class;
+static int schema_create_subclasses(const struct dsdb_schema *schema)
+{
+        struct dsdb_class *schema_class, *top;
 
         for (schema_class=schema->classes; schema_class; schema_class=schema_class->next) {
-                struct dsdb_class *schema_class2 = dsdb_class_by_lDAPDisplayName(schema, schema_class->subClassOf);
+                struct dsdb_class *schema_class2 = discard_const_p(struct dsdb_class,
+                        dsdb_class_by_lDAPDisplayName(schema, schema_class->subClassOf));
                 if (schema_class2 == NULL) {
-                        DEBUG(0,("ERROR: no subClassOf for '%s'\n", schema_class->lDAPDisplayName));
-                        continue;
+                        DEBUG(0,("ERROR: no subClassOf '%s' for '%s'\n",
+                                 schema_class->subClassOf,
+                                 schema_class->lDAPDisplayName));
+                        return LDB_ERR_OPERATIONS_ERROR;
                 }
                 if (schema_class2 && schema_class != schema_class2) {
                         if (schema_class2->subclasses_direct == NULL) {
-                                schema_class2->subclasses_direct = str_list_make_empty(schema_class2);
-                        }
-                        schema_class2->subclasses_direct = str_list_add_const(schema_class2->subclasses_direct, 
-                                                                        schema_class->lDAPDisplayName);
+                                schema_class2->subclasses_direct = const_str_list(str_list_make_empty(schema_class2));
+                                if (!schema_class2->subclasses_direct) {
+                                        return LDB_ERR_OPERATIONS_ERROR;
+                                }
+                        }
+                        schema_class2->subclasses_direct = str_list_add_const(schema_class2->subclasses_direct,
+                                                schema_class->lDAPDisplayName);
                 }
         }
@@ -172 +184 @@
                 schema_class->subclasses = str_list_unique(schema_subclasses_recurse(schema, schema_class));
 
-                /* Initilise the subClass order, to ensure we can't have uninitilised sort on the subClass hirarchy */
+                /* Initialize the subClass order, to ensure we can't have uninitialized sort on the subClass hierarchy */
                 schema_class->subClass_order = 0;
         }
 
-        schema_subclasses_order_recurse(schema, dsdb_class_by_lDAPDisplayName(schema, "top"), 1);
-}
-
-static void schema_fill_possible_inferiors(struct dsdb_schema *schema, struct dsdb_class *schema_class)
+        top = discard_const_p(struct dsdb_class, dsdb_class_by_lDAPDisplayName(schema, "top"));
+        if (!top) {
+                DEBUG(0,("ERROR: no 'top' class in loaded schema\n"));
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+
+        schema_subclasses_order_recurse(schema, top, 1);
+        return LDB_SUCCESS;
+}
+
+static void schema_fill_possible_inferiors(const struct dsdb_schema *schema,
+                                           struct dsdb_class *schema_class)
 {
         struct dsdb_class *c2;
 
         for (c2=schema->classes; c2; c2=c2->next) {
-                char **superiors = schema_posssuperiors(schema, c2);
+                const char **superiors = schema_posssuperiors(schema, c2);
                 if (c2->systemOnly == false 
                     && c2->objectClassCategory != 2 
@@ -190 +210 @@
                     && str_list_check(superiors, schema_class->lDAPDisplayName)) {
                         if (schema_class->possibleInferiors == NULL) {
-                                schema_class->possibleInferiors = str_list_make_empty(schema_class);
+                                schema_class->possibleInferiors = const_str_list(str_list_make_empty(schema_class));
                         }
                         schema_class->possibleInferiors = str_list_add_const(schema_class->possibleInferiors,
-                                                                       c2->lDAPDisplayName);
+                                                        c2->lDAPDisplayName);
                 }
         }
@@ -199 +219 @@
 }
 
+static void schema_fill_system_possible_inferiors(const struct dsdb_schema *schema,
+                                                  struct dsdb_class *schema_class)
+{
+        struct dsdb_class *c2;
+
+        for (c2=schema->classes; c2; c2=c2->next) {
+                const char **superiors = schema_posssuperiors(schema, c2);
+                if (c2->objectClassCategory != 2
+                    && c2->objectClassCategory != 3
+                    && str_list_check(superiors, schema_class->lDAPDisplayName)) {
+                        if (schema_class->systemPossibleInferiors == NULL) {
+                                schema_class->systemPossibleInferiors = const_str_list(str_list_make_empty(schema_class));
+                        }
+                        schema_class->systemPossibleInferiors = str_list_add_const(schema_class->systemPossibleInferiors,
+                                                        c2->lDAPDisplayName);
+                }
+        }
+        schema_class->systemPossibleInferiors = str_list_unique(schema_class->systemPossibleInferiors);
+}
+
 /*
   fill in a string class name from a governs_ID
  */
-static void schema_fill_from_class_one(struct dsdb_schema *schema, struct dsdb_class *c, 
-                                    const char **s, uint32_t id)
+static void schema_fill_from_class_one(const struct dsdb_schema *schema,
+                                       const struct dsdb_class *c,
+                                       const char **s,
+                                       const uint32_t id)
 {
         if (*s == NULL && id != 0) {
-                struct dsdb_class *c2 = dsdb_class_by_governsID_id(schema, id);
+                const struct dsdb_class *c2 =
+                                        dsdb_class_by_governsID_id(schema, id);
                 if (c2) {
                         *s = c2->lDAPDisplayName;
@@ -216 +259 @@
   fill in a list of string class names from a governs_ID list
  */
-static void schema_fill_from_class_list(struct dsdb_schema *schema, struct dsdb_class *c, 
-                                     const char ***s, uint32_t *ids)
+static void schema_fill_from_class_list(const struct dsdb_schema *schema,
+                                        const struct dsdb_class *c,
+                                        const char ***s,
+                                        const uint32_t *ids)
 {
         if (*s == NULL && ids != NULL) {
-                int i;
+                unsigned int i;
                 for (i=0;ids[i];i++) ;
                 *s = talloc_array(c, const char *, i+1);
                 for (i=0;ids[i];i++) {
-                        struct dsdb_class *c2 = dsdb_class_by_governsID_id(schema, ids[i]);
+                        const struct dsdb_class *c2 =
+                                dsdb_class_by_governsID_id(schema, ids[i]);
                         if (c2) {
                                 (*s)[i] = c2->lDAPDisplayName;
@@ -238 +284 @@
   fill in a list of string attribute names from a attributeID list
  */
-static void schema_fill_from_attribute_list(struct dsdb_schema *schema, struct dsdb_class *c, 
-                                            const char ***s, uint32_t *ids)
+static void schema_fill_from_attribute_list(const struct dsdb_schema *schema,
+                                            const struct dsdb_class *c,
+                                            const char ***s,
+                                            const uint32_t *ids)
 {
         if (*s == NULL && ids != NULL) {
-                int i;
+                unsigned int i;
                 for (i=0;ids[i];i++) ;
                 *s = talloc_array(c, const char *, i+1);
                 for (i=0;ids[i];i++) {
-                        struct dsdb_attribute *a = dsdb_attribute_by_attributeID_id(schema, ids[i]);
+                        const struct dsdb_attribute *a =
+                                dsdb_attribute_by_attributeID_id(schema, ids[i]);
                         if (a) {
                                 (*s)[i] = a->lDAPDisplayName;
@@ -260 +309 @@
   if the schema came from DRS then some attributes will be setup as IDs
  */
-static void schema_fill_from_ids(struct dsdb_schema *schema)
+static void schema_fill_from_ids(const struct dsdb_schema *schema)
 {
         struct dsdb_class *c;
@@ -276 +325 @@
 }
 
-void schema_fill_constructed(struct dsdb_schema *schema) 
-{
+int schema_fill_constructed(const struct dsdb_schema *schema)
+{
+        int ret;
         struct dsdb_class *schema_class;
 
         schema_fill_from_ids(schema);
 
-        schema_create_subclasses(schema);
+        ret = schema_create_subclasses(schema);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
 
         for (schema_class=schema->classes; schema_class; schema_class=schema_class->next) {
                 schema_fill_possible_inferiors(schema, schema_class);
+                schema_fill_system_possible_inferiors(schema, schema_class);
         }
 
@@ -299 +353 @@
                 schema_class->posssuperiors = NULL;
         }
-}
+
+        return LDB_SUCCESS;
+}

vendor/current/source4/dsdb/schema/schema_init.c

@@ -23 +23 @@
 #include "includes.h"
 #include "dsdb/samdb/samdb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include "dsdb/common/util.h"
+#include <ldb_errors.h>
 #include "../lib/util/dlinklist.h"
 #include "librpc/gen_ndr/ndr_misc.h"
@@ -29 +30 @@
 #include "librpc/gen_ndr/ndr_drsblobs.h"
 #include "param/param.h"
-#include "lib/ldb/include/ldb_module.h"
-
-struct dsdb_schema *dsdb_new_schema(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience)
+#include <ldb_module.h>
+#include "../lib/util/asn1.h"
+
+
+struct dsdb_schema *dsdb_new_schema(TALLOC_CTX *mem_ctx)
 {
         struct dsdb_schema *schema = talloc_zero(mem_ctx, struct dsdb_schema);
@@ -38 +41 @@
         }
 
-        schema->iconv_convenience = iconv_convenience;
         return schema;
 }
 
-
-WERROR dsdb_load_oid_mappings_drsuapi(struct dsdb_schema *schema, const struct drsuapi_DsReplicaOIDMapping_Ctr *ctr)
-{
-        uint32_t i,j;
-
-        schema->prefixes = talloc_array(schema, struct dsdb_schema_oid_prefix, ctr->num_mappings);
-        W_ERROR_HAVE_NO_MEMORY(schema->prefixes);
-
-        for (i=0, j=0; i < ctr->num_mappings; i++) {
-                if (ctr->mappings[i].oid.oid == NULL) {
-                        return WERR_INVALID_PARAM;
+struct dsdb_schema *dsdb_schema_copy_shallow(TALLOC_CTX *mem_ctx,
+                                             struct ldb_context *ldb,
+                                             const struct dsdb_schema *schema)
+{
+        int ret;
+        struct dsdb_class *cls;
+        struct dsdb_attribute *attr;
+        struct dsdb_schema *schema_copy;
+
+        schema_copy = dsdb_new_schema(mem_ctx);
+        if (!schema_copy) {
+                return NULL;
+        }
+
+        /* schema base_dn */
+        schema_copy->base_dn = ldb_dn_copy(schema_copy, schema->base_dn);
+        if (!schema_copy->base_dn) {
+                goto failed;
+        }
+
+        /* copy prexiMap & schemaInfo */
+        schema_copy->prefixmap = dsdb_schema_pfm_copy_shallow(schema_copy,
+                                                              schema->prefixmap);
+        if (!schema_copy->prefixmap) {
+                goto failed;
+        }
+
+        schema_copy->schema_info = talloc_strdup(schema_copy, schema->schema_info);
+
+        /* copy classes and attributes*/
+        for (cls = schema->classes; cls; cls = cls->next) {
+                struct dsdb_class *class_copy = talloc_memdup(schema_copy,
+                                                              cls, sizeof(*cls));
+                if (!class_copy) {
+                        goto failed;
                 }
-
-                if (strncasecmp(ctr->mappings[i].oid.oid, "ff", 2) == 0) {
-                        if (ctr->mappings[i].id_prefix != 0) {
-                                return WERR_INVALID_PARAM;
-                        }
-
-                        /* the magic value should be in the last array member */
-                        if (i != (ctr->num_mappings - 1)) {
-                                return WERR_INVALID_PARAM;
-                        }
-
-                        if (ctr->mappings[i].oid.__ndr_size != 21) {
-                                return WERR_INVALID_PARAM;
-                        }
-
-                        schema->schema_info = talloc_strdup(schema, ctr->mappings[i].oid.oid);
-                        W_ERROR_HAVE_NO_MEMORY(schema->schema_info);
-                } else {
-                        /* the last array member should contain the magic value not a oid */
-                        if (i == (ctr->num_mappings - 1)) {
-                                return WERR_INVALID_PARAM;
-                        }
-
-                        schema->prefixes[j].id  = ctr->mappings[i].id_prefix<<16;
-                        schema->prefixes[j].oid = talloc_asprintf(schema->prefixes, "%s.",
-                                                                  ctr->mappings[i].oid.oid);
-                        W_ERROR_HAVE_NO_MEMORY(schema->prefixes[j].oid);
-                        schema->prefixes[j].oid_len = strlen(schema->prefixes[j].oid);
-                        j++;
+                DLIST_ADD(schema_copy->classes, class_copy);
+        }
+        schema_copy->num_classes = schema->num_classes;
+
+        for (attr = schema->attributes; attr; attr = attr->next) {
+                struct dsdb_attribute *a_copy = talloc_memdup(schema_copy,
+                                                              attr, sizeof(*attr));
+                if (!a_copy) {
+                        goto failed;
                 }
-        }
-
-        schema->num_prefixes = j;
+                DLIST_ADD(schema_copy->attributes, a_copy);
+        }
+        schema_copy->num_attributes = schema->num_attributes;
+
+        /* rebuild indexes */
+        ret = dsdb_setup_sorted_accessors(ldb, schema_copy);
+        if (ret != LDB_SUCCESS) {
+                goto failed;
+        }
+
+        /* leave reload_seq_number = 0 so it will be refresh ASAP */
+        schema_copy->refresh_fn = schema->refresh_fn;
+        schema_copy->loaded_from_module = schema->loaded_from_module;
+
+        return schema_copy;
+
+failed:
+        talloc_free(schema_copy);
+        return NULL;
+}
+
+
+WERROR dsdb_load_prefixmap_from_drsuapi(struct dsdb_schema *schema,
+                                        const struct drsuapi_DsReplicaOIDMapping_Ctr *ctr)
+{
+        WERROR werr;
+        const char *schema_info;
+        struct dsdb_schema_prefixmap *pfm;
+
+        werr = dsdb_schema_pfm_from_drsuapi_pfm(ctr, true, schema, &pfm, &schema_info);
+        W_ERROR_NOT_OK_RETURN(werr);
+
+        /* set loaded prefixMap */
+        talloc_free(schema->prefixmap);
+        schema->prefixmap = pfm;
+
+        talloc_free(discard_const(schema->schema_info));
+        schema->schema_info = schema_info;
+
         return WERR_OK;
+}
+
+static WERROR _dsdb_prefixmap_from_ldb_val(const struct ldb_val *pfm_ldb_val,
+                                           TALLOC_CTX *mem_ctx,
+                                           struct dsdb_schema_prefixmap **_pfm)
+{
+        WERROR werr;
+        enum ndr_err_code ndr_err;
+        struct prefixMapBlob pfm_blob;
+
+        TALLOC_CTX *temp_ctx = talloc_new(mem_ctx);
+        W_ERROR_HAVE_NO_MEMORY(temp_ctx);
+
+        ndr_err = ndr_pull_struct_blob(pfm_ldb_val, temp_ctx,
+                                &pfm_blob,
+                                (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
+                DEBUG(0,("_dsdb_prefixmap_from_ldb_val: Failed to parse prefixmap of length %u: %s\n",
+                         (unsigned int)pfm_ldb_val->length, ndr_map_error2string(ndr_err)));
+                talloc_free(temp_ctx);
+                return ntstatus_to_werror(nt_status);
+        }
+
+        if (pfm_blob.version != PREFIX_MAP_VERSION_DSDB) {
+                DEBUG(0,("_dsdb_prefixmap_from_ldb_val: pfm_blob->version %u incorrect\n", (unsigned int)pfm_blob.version));
+                talloc_free(temp_ctx);
+                return WERR_VERSION_PARSE_ERROR;
+        }
+
+        /* call the drsuapi version */
+        werr = dsdb_schema_pfm_from_drsuapi_pfm(&pfm_blob.ctr.dsdb, false, mem_ctx, _pfm, NULL);
+        if (!W_ERROR_IS_OK(werr)) {
+                DEBUG(0, (__location__ " dsdb_schema_pfm_from_drsuapi_pfm failed: %s\n", win_errstr(werr)));
+                talloc_free(temp_ctx);
+                return werr;
+        }
+
+        talloc_free(temp_ctx);
+
+        return werr;
 }
 
@@ -94 +177 @@
                                   const struct ldb_val *schemaInfo)
 {
-        WERROR status;
-        enum ndr_err_code ndr_err;
-        struct prefixMapBlob pfm;
-        char *schema_info;
-
-        TALLOC_CTX *mem_ctx = talloc_new(schema);
+        WERROR werr;
+        const char *schema_info;
+        struct dsdb_schema_prefixmap *pfm;
+        TALLOC_CTX *mem_ctx;
+
+        /* verify schemaInfo blob is valid one */
+        if (!dsdb_schema_info_blob_is_valid(schemaInfo)) {
+                DEBUG(0,(__location__": dsdb_schema_info_blob_is_valid() failed.\n"));
+                return WERR_INVALID_PARAMETER;
+        }
+
+        mem_ctx = talloc_new(schema);
         W_ERROR_HAVE_NO_MEMORY(mem_ctx);
-        
-        ndr_err = ndr_pull_struct_blob(prefixMap, mem_ctx, schema->iconv_convenience, &pfm, (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
+
+        /* fetch prefixMap */
+        werr = _dsdb_prefixmap_from_ldb_val(prefixMap,
+                                            mem_ctx, &pfm);
+        if (!W_ERROR_IS_OK(werr)) {
+                DEBUG(0, (__location__ " _dsdb_prefixmap_from_ldb_val failed: %s\n", win_errstr(werr)));
                 talloc_free(mem_ctx);
-                return ntstatus_to_werror(nt_status);
-        }
-
-        if (pfm.version != PREFIX_MAP_VERSION_DSDB) {
+                return werr;
+        }
+
+        /* decode schema_info */
+        schema_info = hex_encode_talloc(mem_ctx,
+                                        schemaInfo->data,
+                                        schemaInfo->length);
+        if (!schema_info) {
                 talloc_free(mem_ctx);
-                return WERR_FOOBAR;
-        }
-
-        if (schemaInfo->length != 21 && schemaInfo->data[0] == 0xFF) {
-                talloc_free(mem_ctx);
-                return WERR_FOOBAR;
-        }
-
-        /* append the schema info as last element */
-        pfm.ctr.dsdb.num_mappings++;
-        pfm.ctr.dsdb.mappings = talloc_realloc(mem_ctx, pfm.ctr.dsdb.mappings,
-                                               struct drsuapi_DsReplicaOIDMapping,
-                                               pfm.ctr.dsdb.num_mappings);
-        W_ERROR_HAVE_NO_MEMORY(pfm.ctr.dsdb.mappings);
-
-        schema_info = data_blob_hex_string(pfm.ctr.dsdb.mappings, schemaInfo);
-        W_ERROR_HAVE_NO_MEMORY(schema_info);
-
-        pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].id_prefix          = 0;    
-        pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].oid.__ndr_size     = schemaInfo->length;
-        pfm.ctr.dsdb.mappings[pfm.ctr.dsdb.num_mappings - 1].oid.oid            = schema_info;
-
-        /* call the drsuapi version */
-        status = dsdb_load_oid_mappings_drsuapi(schema, &pfm.ctr.dsdb);
+                return WERR_NOMEM;
+        }
+
+        /* store prefixMap and schema_info into cached Schema */
+        talloc_free(schema->prefixmap);
+        schema->prefixmap = talloc_steal(schema, pfm);
+
+        talloc_free(discard_const(schema->schema_info));
+        schema->schema_info = talloc_steal(schema, schema_info);
+
+        /* clean up locally allocated mem */
         talloc_free(mem_ctx);
-
-        W_ERROR_NOT_OK_RETURN(status);
 
         return WERR_OK;
@@ -147 +227 @@
                                      struct drsuapi_DsReplicaOIDMapping_Ctr **_ctr)
 {
-        struct drsuapi_DsReplicaOIDMapping_Ctr *ctr;
-        uint32_t i;
-
-        ctr = talloc(mem_ctx, struct drsuapi_DsReplicaOIDMapping_Ctr);
-        W_ERROR_HAVE_NO_MEMORY(ctr);
-
-        ctr->num_mappings       = schema->num_prefixes;
-        if (include_schema_info) ctr->num_mappings++;
-        ctr->mappings = talloc_array(schema, struct drsuapi_DsReplicaOIDMapping, ctr->num_mappings);
-        W_ERROR_HAVE_NO_MEMORY(ctr->mappings);
-
-        for (i=0; i < schema->num_prefixes; i++) {
-                ctr->mappings[i].id_prefix      = schema->prefixes[i].id>>16;
-                ctr->mappings[i].oid.oid        = talloc_strndup(ctr->mappings,
-                                                                 schema->prefixes[i].oid,
-                                                                 schema->prefixes[i].oid_len - 1);
-                W_ERROR_HAVE_NO_MEMORY(ctr->mappings[i].oid.oid);
-        }
-
-        if (include_schema_info) {
-                ctr->mappings[i].id_prefix      = 0;
-                ctr->mappings[i].oid.oid        = talloc_strdup(ctr->mappings,
-                                                                schema->schema_info);
-                W_ERROR_HAVE_NO_MEMORY(ctr->mappings[i].oid.oid);
-        }
-
-        *_ctr = ctr;
+        return dsdb_drsuapi_pfm_from_schema_pfm(schema->prefixmap,
+                                                include_schema_info ? schema->schema_info : NULL,
+                                                mem_ctx, _ctr);
+}
+
+WERROR dsdb_get_drsuapi_prefixmap_as_blob(const struct drsuapi_DsReplicaOIDMapping_Ctr *ctr,
+                                          TALLOC_CTX *mem_ctx,
+                                          struct ldb_val *prefixMap)
+{
+        struct prefixMapBlob pfm;
+        enum ndr_err_code ndr_err;
+        pfm.version     = PREFIX_MAP_VERSION_DSDB;
+        pfm.reserved    = 0;
+        pfm.ctr.dsdb    = *ctr;
+
+        ndr_err = ndr_push_struct_blob(prefixMap, mem_ctx, &pfm,
+                                        (ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
+                return ntstatus_to_werror(nt_status);
+        }
         return WERR_OK;
 }
@@ -183 +257 @@
 {
         WERROR status;
-        enum ndr_err_code ndr_err;
         struct drsuapi_DsReplicaOIDMapping_Ctr *ctr;
-        struct prefixMapBlob pfm;
 
         status = dsdb_get_oid_mappings_drsuapi(schema, false, mem_ctx, &ctr);
         W_ERROR_NOT_OK_RETURN(status);
 
-        pfm.version     = PREFIX_MAP_VERSION_DSDB;
-        pfm.reserved    = 0;
-        pfm.ctr.dsdb    = *ctr;
-
-        ndr_err = ndr_push_struct_blob(prefixMap, mem_ctx, schema->iconv_convenience, &pfm, (ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
+        status = dsdb_get_drsuapi_prefixmap_as_blob(ctr, mem_ctx, prefixMap);
         talloc_free(ctr);
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
-                return ntstatus_to_werror(nt_status);
-        }
+        W_ERROR_NOT_OK_RETURN(status);
 
         *schemaInfo = strhex_to_data_blob(mem_ctx, schema->schema_info);
@@ -207 +272 @@
 }
 
-WERROR dsdb_verify_oid_mappings_drsuapi(const struct dsdb_schema *schema, const struct drsuapi_DsReplicaOIDMapping_Ctr *ctr)
-{
-        uint32_t i,j;
-
-        for (i=0; i < ctr->num_mappings; i++) {
-                if (ctr->mappings[i].oid.oid == NULL) {
-                        return WERR_INVALID_PARAM;
-                }
-
-                if (strncasecmp(ctr->mappings[i].oid.oid, "ff", 2) == 0) {
-                        if (ctr->mappings[i].id_prefix != 0) {
-                                return WERR_INVALID_PARAM;
-                        }
-
-                        /* the magic value should be in the last array member */
-                        if (i != (ctr->num_mappings - 1)) {
-                                return WERR_INVALID_PARAM;
-                        }
-
-                        if (ctr->mappings[i].oid.__ndr_size != 21) {
-                                return WERR_INVALID_PARAM;
-                        }
-
-                        if (strcasecmp(schema->schema_info, ctr->mappings[i].oid.oid) != 0) {
-                                return WERR_DS_DRA_SCHEMA_MISMATCH;
-                        }
-                } else {
-                        /* the last array member should contain the magic value not a oid */
-                        if (i == (ctr->num_mappings - 1)) {
-                                return WERR_INVALID_PARAM;
-                        }
-
-                        for (j=0; j < schema->num_prefixes; j++) {
-                                size_t oid_len;
-                                if (schema->prefixes[j].id != (ctr->mappings[i].id_prefix<<16)) {
-                                        continue;
-                                }
-
-                                oid_len = strlen(ctr->mappings[i].oid.oid);
-
-                                if (oid_len != (schema->prefixes[j].oid_len - 1)) {
-                                        return WERR_DS_DRA_SCHEMA_MISMATCH;
-                                }
-
-                                if (strncmp(ctr->mappings[i].oid.oid, schema->prefixes[j].oid, oid_len) != 0) {
-                                        return WERR_DS_DRA_SCHEMA_MISMATCH;                             
-                                }
-
-                                break;
-                        }
-
-                        if (j == schema->num_prefixes) {
-                                return WERR_DS_DRA_SCHEMA_MISMATCH;                             
-                        }
-                }
-        }
-
-        return WERR_OK;
-}
-
-WERROR dsdb_map_oid2int(const struct dsdb_schema *schema, const char *in, uint32_t *out)
-{
-        return dsdb_find_prefix_for_oid(schema->num_prefixes, schema->prefixes, in, out);
-}
-
-
-WERROR dsdb_map_int2oid(const struct dsdb_schema *schema, uint32_t in, TALLOC_CTX *mem_ctx, const char **out)
-{
-        uint32_t i;
-
-        for (i=0; i < schema->num_prefixes; i++) {
-                const char *val;
-                if (schema->prefixes[i].id != (in & 0xFFFF0000)) {
-                        continue;
-                }
-
-                val = talloc_asprintf(mem_ctx, "%s%u",
-                                      schema->prefixes[i].oid,
-                                      in & 0xFFFF);
-                W_ERROR_HAVE_NO_MEMORY(val);
-
-                *out = val;
-                return WERR_OK;
-        }
-
-        return WERR_DS_NO_MSDS_INTID;
-}
 
 /*
@@ -301 +279 @@
 {
         WERROR status;
-        uint32_t num_prefixes;
-        struct dsdb_schema_oid_prefix *prefixes;
+        uint32_t attid;
         TALLOC_CTX *mem_ctx;
-        uint32_t out;
+        struct dsdb_schema_prefixmap *pfm;
 
         mem_ctx = talloc_new(ldb);
@@ -310 +287 @@
 
         /* Read prefixes from disk*/
-        status = dsdb_read_prefixes_from_ldb( mem_ctx, ldb, &num_prefixes, &prefixes ); 
+        status = dsdb_read_prefixes_from_ldb(ldb, mem_ctx, &pfm);
         if (!W_ERROR_IS_OK(status)) {
                 DEBUG(0,("dsdb_create_prefix_mapping: dsdb_read_prefixes_from_ldb: %s\n",
@@ -319 +296 @@
 
         /* Check if there is a prefix for the oid in the prefixes array*/
-        status = dsdb_find_prefix_for_oid( num_prefixes, prefixes, full_oid, &out ); 
+        status = dsdb_schema_pfm_find_oid(pfm, full_oid, NULL);
         if (W_ERROR_IS_OK(status)) {
                 /* prefix found*/
                 talloc_free(mem_ctx);
                 return status;
-        } else if (!W_ERROR_EQUAL(WERR_DS_NO_MSDS_INTID, status)) {
+        } else if (!W_ERROR_EQUAL(status, WERR_NOT_FOUND)) {
                 /* error */
                 DEBUG(0,("dsdb_create_prefix_mapping: dsdb_find_prefix_for_oid: %s\n",
@@ -333 +310 @@
 
         /* Create the new mapping for the prefix of full_oid */
-        status = dsdb_prefix_map_update(mem_ctx, &num_prefixes, &prefixes, full_oid);
+        status = dsdb_schema_pfm_make_attid(pfm, full_oid, &attid);
         if (!W_ERROR_IS_OK(status)) {
-                DEBUG(0,("dsdb_create_prefix_mapping: dsdb_prefix_map_update: %s\n",
+                DEBUG(0,("dsdb_create_prefix_mapping: dsdb_schema_pfm_make_attid: %s\n",
                         win_errstr(status)));
                 talloc_free(mem_ctx);
@@ -341 +318 @@
         }
 
-        talloc_free(schema->prefixes);
-        schema->prefixes = talloc_steal(schema, prefixes);
-        schema->num_prefixes = num_prefixes;
+        talloc_unlink(schema, schema->prefixmap);
+        schema->prefixmap = talloc_steal(schema, pfm);
 
         /* Update prefixMap in ldb*/
@@ -355 +331 @@
 
         DEBUG(2,(__location__ " Added prefixMap %s - now have %u prefixes\n",
-                 full_oid, num_prefixes));
+                 full_oid, schema->prefixmap->length));
 
         talloc_free(mem_ctx);
@@ -361 +337 @@
 }
 
-WERROR dsdb_prefix_map_update(TALLOC_CTX *mem_ctx, uint32_t *num_prefixes, struct dsdb_schema_oid_prefix **prefixes, const char *oid)
-{
-        uint32_t new_num_prefixes, index_new_prefix, new_entry_id;
-        const char* lastDotOffset;
-        size_t size;
-        
-        new_num_prefixes = *num_prefixes + 1;
-        index_new_prefix = *num_prefixes;
-
-        /*
-         * this is the algorithm we use to create new mappings for now
-         *
-         * TODO: find what algorithm windows use
-         */
-        new_entry_id = (*num_prefixes)<<16;
-
-        /* Extract the prefix from the oid*/
-        lastDotOffset = strrchr(oid, '.');
-        if (lastDotOffset == NULL) {
-                DEBUG(0,("dsdb_prefix_map_update: failed to find the last dot\n"));
-                return WERR_NOT_FOUND;
-        }
-
-        /* Calculate the size of the remainig string that should be the prefix of it */
-        size = strlen(oid) - strlen(lastDotOffset);
-        if (size <= 0) {
-                DEBUG(0,("dsdb_prefix_map_update: size of the remaining string invalid\n"));
-                return WERR_FOOBAR;
-        }
-        /* Add one because we need to copy the dot */
-        size += 1;
-
-        /* Create a spot in the prefixMap for one more prefix*/
-        (*prefixes) = talloc_realloc(mem_ctx, *prefixes, struct dsdb_schema_oid_prefix, new_num_prefixes);
-        W_ERROR_HAVE_NO_MEMORY(*prefixes);
-
-        /* Add the new prefix entry*/
-        (*prefixes)[index_new_prefix].id = new_entry_id;
-        (*prefixes)[index_new_prefix].oid = talloc_strndup(mem_ctx, oid, size);
-        (*prefixes)[index_new_prefix].oid_len = strlen((*prefixes)[index_new_prefix].oid);
-
-        /* Increase num_prefixes because new prefix has been added */
-        ++(*num_prefixes);
-
-        return WERR_OK;
-}
-
-WERROR dsdb_find_prefix_for_oid(uint32_t num_prefixes, const struct dsdb_schema_oid_prefix *prefixes, const char *in, uint32_t *out)
-{
-        uint32_t i;
-
-        for (i=0; i < num_prefixes; i++) {
-                const char *val_str;
-                char *end_str;
-                unsigned val;
-
-                if (strncmp(prefixes[i].oid, in, prefixes[i].oid_len) != 0) {
-                        continue;
-                }
-
-                val_str = in + prefixes[i].oid_len;
-                end_str = NULL;
-                errno = 0;
-
-                if (val_str[0] == '\0') {
-                        return WERR_INVALID_PARAM;
-                }
-
-                /* two '.' chars are invalid */
-                if (val_str[0] == '.') {
-                        return WERR_INVALID_PARAM;
-                }
-
-                val = strtoul(val_str, &end_str, 10);
-                if (end_str[0] == '.' && end_str[1] != '\0') {
-                        /*
-                         * if it's a '.' and not the last char
-                         * then maybe an other mapping apply
-                         */
-                        continue;
-                } else if (end_str[0] != '\0') {
-                        return WERR_INVALID_PARAM;
-                } else if (val > 0xFFFF) {
-                        return WERR_INVALID_PARAM;
-                }
-
-                *out = prefixes[i].id | val;
-                return WERR_OK;
-        }
-
-        DEBUG(5,(__location__ " Failed to find oid %s - have %u prefixes\n", in, num_prefixes));
-
-        return WERR_DS_NO_MSDS_INTID;
-}
 
 WERROR dsdb_write_prefixes_from_schema_to_ldb(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
-                                                     const struct dsdb_schema *schema)
-{
-        struct ldb_message *msg = ldb_msg_new(mem_ctx);
+                                              const struct dsdb_schema *schema)
+{
+        WERROR status;
+        int ldb_ret;
+        struct ldb_message *msg;
         struct ldb_dn *schema_dn;
-        struct prefixMapBlob pm;
+        struct prefixMapBlob pfm_blob;
         struct ldb_val ndr_blob;
         enum ndr_err_code ndr_err;
-        uint32_t i;
-        int ret;
-
-        if (!msg) {
-                return WERR_NOMEM;
-        }
-        
-        schema_dn = samdb_schema_dn(ldb);
+        TALLOC_CTX *temp_ctx;
+        struct drsuapi_DsReplicaOIDMapping_Ctr *ctr;
+
+        schema_dn = ldb_get_schema_basedn(ldb);
         if (!schema_dn) {
-                DEBUG(0,("dsdb_write_prefixes_from_schema_to_ldb: no schema dn present\n"));    
+                DEBUG(0,("dsdb_write_prefixes_from_schema_to_ldb: no schema dn present\n"));
                 return WERR_FOOBAR;
         }
 
-        pm.version                      = PREFIX_MAP_VERSION_DSDB;
-        pm.ctr.dsdb.num_mappings        = schema->num_prefixes;
-        pm.ctr.dsdb.mappings            = talloc_array(msg,
-                                                struct drsuapi_DsReplicaOIDMapping,
-                                                pm.ctr.dsdb.num_mappings);
-        if (!pm.ctr.dsdb.mappings) {
-                talloc_free(msg);
-                return WERR_NOMEM;
-        }
-
-        for (i=0; i < schema->num_prefixes; i++) {
-                pm.ctr.dsdb.mappings[i].id_prefix = schema->prefixes[i].id>>16;
-                pm.ctr.dsdb.mappings[i].oid.oid = talloc_strdup(pm.ctr.dsdb.mappings, schema->prefixes[i].oid);
-        }
-
-        ndr_err = ndr_push_struct_blob(&ndr_blob, msg,
-                                       lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
-                                       &pm,
+        temp_ctx = talloc_new(mem_ctx);
+        W_ERROR_HAVE_NO_MEMORY(temp_ctx);
+
+        /* convert schema_prefixMap to prefixMap blob */
+        status = dsdb_get_oid_mappings_drsuapi(schema, false, temp_ctx, &ctr);
+        if (!W_ERROR_IS_OK(status)) {
+                talloc_free(temp_ctx);
+                return status;
+        }
+
+        pfm_blob.version        = PREFIX_MAP_VERSION_DSDB;
+        pfm_blob.ctr.dsdb       = *ctr;
+
+        ndr_err = ndr_push_struct_blob(&ndr_blob, temp_ctx,
+                                       &pfm_blob,
                                        (ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                talloc_free(msg);
+                talloc_free(temp_ctx);
                 return WERR_FOOBAR;
         }
  
+        /* write serialized prefixMap into LDB */
+        msg = ldb_msg_new(temp_ctx);
+        if (!msg) {
+                talloc_free(temp_ctx);
+                return WERR_NOMEM;
+        }
+
         msg->dn = schema_dn;
-        ret = ldb_msg_add_value(msg, "prefixMap", &ndr_blob, NULL);
-        if (ret != 0) {
-                talloc_free(msg);
+        ldb_ret = ldb_msg_add_value(msg, "prefixMap", &ndr_blob, NULL);
+        if (ldb_ret != 0) {
+                talloc_free(temp_ctx);
                 DEBUG(0,("dsdb_write_prefixes_from_schema_to_ldb: ldb_msg_add_value failed\n"));        
                 return WERR_NOMEM;
         }
  
-        ret = samdb_replace( ldb, msg, msg );
-        talloc_free(msg);
-
-        if (ret != 0) {
-                DEBUG(0,("dsdb_write_prefixes_from_schema_to_ldb: samdb_replace failed\n"));    
+        ldb_ret = dsdb_replace(ldb, msg, DSDB_FLAG_AS_SYSTEM);
+
+        talloc_free(temp_ctx);
+
+        if (ldb_ret != 0) {
+                DEBUG(0,("dsdb_write_prefixes_from_schema_to_ldb: dsdb_replace failed\n"));
                 return WERR_FOOBAR;
         }
@@ -520 +405 @@
 }
 
-WERROR dsdb_read_prefixes_from_ldb(TALLOC_CTX *mem_ctx, struct ldb_context *ldb, uint32_t* num_prefixes, struct dsdb_schema_oid_prefix **prefixes)
-{
-        struct prefixMapBlob *blob;
-        enum ndr_err_code ndr_err;
-        uint32_t i;
+WERROR dsdb_read_prefixes_from_ldb(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, struct dsdb_schema_prefixmap **_pfm)
+{
+        WERROR werr;
+        int ldb_ret;
         const struct ldb_val *prefix_val;
         struct ldb_dn *schema_dn;
-        struct ldb_result *schema_res;
-        int ret;    
+        struct ldb_result *schema_res = NULL;
         static const char *schema_attrs[] = {
                 "prefixMap",
@@ -534 +417 @@
         };
 
-        schema_dn = samdb_schema_dn(ldb);
+        schema_dn = ldb_get_schema_basedn(ldb);
         if (!schema_dn) {
                 DEBUG(0,("dsdb_read_prefixes_from_ldb: no schema dn present\n"));
@@ -540 +423 @@
         }
 
-        ret = ldb_search(ldb, mem_ctx, &schema_res, schema_dn, LDB_SCOPE_BASE, schema_attrs, NULL);
-        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+        ldb_ret = ldb_search(ldb, mem_ctx, &schema_res, schema_dn, LDB_SCOPE_BASE, schema_attrs, NULL);
+        if (ldb_ret == LDB_ERR_NO_SUCH_OBJECT) {
                 DEBUG(0,("dsdb_read_prefixes_from_ldb: no prefix map present\n"));
                 talloc_free(schema_res);
                 return WERR_FOOBAR;
-        } else if (ret != LDB_SUCCESS) {
+        } else if (ldb_ret != LDB_SUCCESS) {
                 DEBUG(0,("dsdb_read_prefixes_from_ldb: failed to search the schema head\n"));
                 talloc_free(schema_res);
@@ -558 +441 @@
         }
 
-        blob = talloc(mem_ctx, struct prefixMapBlob);
-        W_ERROR_HAVE_NO_MEMORY(blob);
-
-        ndr_err = ndr_pull_struct_blob(prefix_val, blob, 
-                                           lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")), 
-                                           blob,
-                                           (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                DEBUG(0,("dsdb_read_prefixes_from_ldb: ndr_pull_struct_blob failed\n"));
-                talloc_free(blob);
-                talloc_free(schema_res);
-                return WERR_FOOBAR;
-        }
-
+        werr = _dsdb_prefixmap_from_ldb_val(prefix_val,
+                                            mem_ctx,
+                                            _pfm);
         talloc_free(schema_res);
-
-        if (blob->version != PREFIX_MAP_VERSION_DSDB) {
-                DEBUG(0,("dsdb_read_prefixes_from_ldb: blob->version incorect\n"));
-                talloc_free(blob);
-                return WERR_FOOBAR;
-        }
-        
-        *num_prefixes = blob->ctr.dsdb.num_mappings;
-        *prefixes = talloc_array(mem_ctx, struct dsdb_schema_oid_prefix, *num_prefixes);
-        if(!(*prefixes)) {
-                talloc_free(blob);
-                return WERR_NOMEM;
-        }
-        for (i=0; i < blob->ctr.dsdb.num_mappings; i++) {
-                char *oid;
-                (*prefixes)[i].id = blob->ctr.dsdb.mappings[i].id_prefix<<16;
-                oid = talloc_strdup(mem_ctx, blob->ctr.dsdb.mappings[i].oid.oid);
-                (*prefixes)[i].oid = talloc_asprintf_append(oid, "."); 
-                (*prefixes)[i].oid_len = strlen((*prefixes)[i].oid);
-        }
-
-        talloc_free(blob);
+        W_ERROR_NOT_OK_RETURN(werr);
+
         return WERR_OK;
 }
@@ -604 +456 @@
 static bool dsdb_schema_unique_attribute(const char *attr)
 {
-        const char *attrs[] = { "objectGUID", "objectSID" , NULL };
-        int i;
+        const char *attrs[] = { "objectGUID", "objectSid" , NULL };
+        unsigned int i;
         for (i=0;attrs[i];i++) {
                 if (strcasecmp(attr, attrs[i]) == 0) {
@@ -638 +490 @@
 
         if (s == NULL) {
-                return LDB_ERR_OPERATIONS_ERROR;                
+                return ldb_operr(ldb);
         }
 
         attr->ldb_schema_attribute = a = talloc(attr, struct ldb_schema_attribute);
         if (attr->ldb_schema_attribute == NULL) {
-                ldb_oom(ldb);
-                return LDB_ERR_OPERATIONS_ERROR;
+                return ldb_oom(ldb);
         }
 
@@ -667 +518 @@
         if (get_string_val == NULL) { \
                 if (strict) {                                     \
-                        d_printf("%s: %s == NULL\n", __location__, attr); \
+                        d_printf("%s: %s == NULL in %s\n", __location__, attr, ldb_dn_get_linearized(msg->dn)); \
                         return WERR_INVALID_PARAM;                      \
                 } else {                                                \
@@ -683 +534 @@
 } while (0)
 
-#define GET_STRING_LIST_LDB(msg, attr, mem_ctx, p, elem, strict) do {   \
+#define GET_STRING_LIST_LDB(msg, attr, mem_ctx, p, elem) do {   \
         int get_string_list_counter;                                    \
         struct ldb_message_element *get_string_list_el = ldb_msg_find_element(msg, attr); \
-        if (get_string_list_el == NULL) {                               \
-                if (strict) {                                           \
-                        d_printf("%s: %s == NULL\n", __location__, attr); \
-                        return WERR_INVALID_PARAM;                      \
-                } else {                                                \
-                        (p)->elem = NULL;                               \
-                        break;                                          \
-                }                                                       \
+        /* We may get empty attributes over the replication channel */  \
+        if (get_string_list_el == NULL || get_string_list_el->num_values == 0) {                                \
+                (p)->elem = NULL;                                       \
+                break;                                                  \
         }                                                               \
         (p)->elem = talloc_array(mem_ctx, const char *, get_string_list_el->num_values + 1); \
@@ -713 +560 @@
 #define GET_BOOL_LDB(msg, attr, p, elem, strict) do { \
         const char *str; \
-        str = samdb_result_string(msg, attr, NULL);\
+        str = ldb_msg_find_attr_as_string(msg, attr, NULL);\
         if (str == NULL) { \
                 if (strict) { \
@@ -732 +579 @@
 
 #define GET_UINT32_LDB(msg, attr, p, elem) do { \
-        (p)->elem = samdb_result_uint(msg, attr, 0);\
+        (p)->elem = ldb_msg_find_attr_as_uint(msg, attr, 0);\
 } while (0)
 
-#define GET_UINT32_PTR_LDB(msg, attr, p, elem) do { \
-        uint64_t _v = samdb_result_uint64(msg, attr, UINT64_MAX);\
+#define GET_UINT32_PTR_LDB(msg, attr, mem_ctx, p, elem) do {            \
+        uint64_t _v = ldb_msg_find_attr_as_uint64(msg, attr, UINT64_MAX);\
         if (_v == UINT64_MAX) { \
                 (p)->elem = NULL; \
@@ -769 +616 @@
 
 WERROR dsdb_attribute_from_ldb(struct ldb_context *ldb,
-                               const struct dsdb_schema *schema,
-                               struct ldb_message *msg,
-                               TALLOC_CTX *mem_ctx,
-                               struct dsdb_attribute *attr)
+                               struct dsdb_schema *schema,
+                               struct ldb_message *msg)
 {
         WERROR status;
-
-        GET_STRING_LDB(msg, "cn", mem_ctx, attr, cn, false);
-        GET_STRING_LDB(msg, "lDAPDisplayName", mem_ctx, attr, lDAPDisplayName, true);
-        GET_STRING_LDB(msg, "attributeID", mem_ctx, attr, attributeID_oid, true);
-        if (schema->num_prefixes == 0) {
+        struct dsdb_attribute *attr = talloc_zero(schema, struct dsdb_attribute);
+        if (!attr) {
+                return WERR_NOMEM;
+        }
+
+        GET_STRING_LDB(msg, "cn", attr, attr, cn, false);
+        GET_STRING_LDB(msg, "lDAPDisplayName", attr, attr, lDAPDisplayName, true);
+        GET_STRING_LDB(msg, "attributeID", attr, attr, attributeID_oid, true);
+        if (!schema->prefixmap || schema->prefixmap->length == 0) {
                 /* set an invalid value */
-                attr->attributeID_id = 0xFFFFFFFF;
+                attr->attributeID_id = DRSUAPI_ATTID_INVALID;
         } else {
-                status = dsdb_map_oid2int(schema, attr->attributeID_oid, &attr->attributeID_id);
+                status = dsdb_schema_pfm_make_attid(schema->prefixmap,
+                                                    attr->attributeID_oid,
+                                                    &attr->attributeID_id);
                 if (!W_ERROR_IS_OK(status)) {
                         DEBUG(0,("%s: '%s': unable to map attributeID %s: %s\n",
@@ -791 +642 @@
                 }
         }
+        /* fetch msDS-IntId to be used in resolving ATTRTYP values */
+        GET_UINT32_LDB(msg, "msDS-IntId", attr, msDS_IntId);
+
         GET_GUID_LDB(msg, "schemaIDGUID", attr, schemaIDGUID);
         GET_UINT32_LDB(msg, "mAPIID", attr, mAPIID);
 
         GET_GUID_LDB(msg, "attributeSecurityGUID", attr, attributeSecurityGUID);
+
+        GET_GUID_LDB(msg, "objectGUID", attr, objectGUID);
 
         GET_UINT32_LDB(msg, "searchFlags", attr, searchFlags);
@@ -801 +657 @@
         GET_UINT32_LDB(msg, "linkID", attr, linkID);
 
-        GET_STRING_LDB(msg, "attributeSyntax", mem_ctx, attr, attributeSyntax_oid, true);
-        if (schema->num_prefixes == 0) {
+        GET_STRING_LDB(msg, "attributeSyntax", attr, attr, attributeSyntax_oid, true);
+        if (!schema->prefixmap || schema->prefixmap->length == 0) {
                 /* set an invalid value */
-                attr->attributeSyntax_id = 0xFFFFFFFF;
+                attr->attributeSyntax_id = DRSUAPI_ATTID_INVALID;
         } else {
-                status = dsdb_map_oid2int(schema, attr->attributeSyntax_oid, &attr->attributeSyntax_id);
+                status = dsdb_schema_pfm_attid_from_oid(schema->prefixmap,
+                                                        attr->attributeSyntax_oid,
+                                                        &attr->attributeSyntax_id);
                 if (!W_ERROR_IS_OK(status)) {
                         DEBUG(0,("%s: '%s': unable to map attributeSyntax_ %s: %s\n",
@@ -815 +673 @@
         }
         GET_UINT32_LDB(msg, "oMSyntax", attr, oMSyntax);
-        GET_BLOB_LDB(msg, "oMObjectClass", mem_ctx, attr, oMObjectClass);
+        GET_BLOB_LDB(msg, "oMObjectClass", attr, attr, oMObjectClass);
 
         GET_BOOL_LDB(msg, "isSingleValued", attr, isSingleValued, true);
-        GET_UINT32_PTR_LDB(msg, "rangeLower", attr, rangeLower);
-        GET_UINT32_PTR_LDB(msg, "rangeUpper", attr, rangeUpper);
+        GET_UINT32_PTR_LDB(msg, "rangeLower", attr, attr, rangeLower);
+        GET_UINT32_PTR_LDB(msg, "rangeUpper", attr, attr, rangeUpper);
         GET_BOOL_LDB(msg, "extendedCharsAllowed", attr, extendedCharsAllowed, false);
 
         GET_UINT32_LDB(msg, "schemaFlagsEx", attr, schemaFlagsEx);
-        GET_BLOB_LDB(msg, "msDs-Schema-Extensions", mem_ctx, attr, msDs_Schema_Extensions);
+        GET_BLOB_LDB(msg, "msDs-Schema-Extensions", attr, attr, msDs_Schema_Extensions);
 
         GET_BOOL_LDB(msg, "showInAdvancedViewOnly", attr, showInAdvancedViewOnly, false);
-        GET_STRING_LDB(msg, "adminDisplayName", mem_ctx, attr, adminDisplayName, false);
-        GET_STRING_LDB(msg, "adminDescription", mem_ctx, attr, adminDescription, false);
-        GET_STRING_LDB(msg, "classDisplayName", mem_ctx, attr, classDisplayName, false);
+        GET_STRING_LDB(msg, "adminDisplayName", attr, attr, adminDisplayName, false);
+        GET_STRING_LDB(msg, "adminDescription", attr, attr, adminDescription, false);
+        GET_STRING_LDB(msg, "classDisplayName", attr, attr, classDisplayName, false);
         GET_BOOL_LDB(msg, "isEphemeral", attr, isEphemeral, false);
         GET_BOOL_LDB(msg, "isDefunct", attr, isDefunct, false);
@@ -835 +693 @@
         attr->syntax = dsdb_syntax_for_attribute(attr);
         if (!attr->syntax) {
+                DEBUG(0,(__location__ ": Unknown schema syntax for %s\n",
+                         attr->lDAPDisplayName));
                 return WERR_DS_ATT_SCHEMA_REQ_SYNTAX;
         }
 
         if (dsdb_schema_setup_ldb_schema_attribute(ldb, attr) != LDB_SUCCESS) {
+                DEBUG(0,(__location__ ": Unknown schema syntax for %s - ldb_syntax: %s, ldap_oid: %s\n",
+                         attr->lDAPDisplayName,
+                         attr->syntax->ldb_syntax,
+                         attr->syntax->ldap_oid));
                 return WERR_DS_ATT_SCHEMA_REQ_SYNTAX;
         }
 
+        DLIST_ADD(schema->attributes, attr);
         return WERR_OK;
 }
 
-WERROR dsdb_class_from_ldb(const struct dsdb_schema *schema,
-                           struct ldb_message *msg,
-                           TALLOC_CTX *mem_ctx,
-                           struct dsdb_class *obj)
+WERROR dsdb_class_from_ldb(struct dsdb_schema *schema,
+                           struct ldb_message *msg)
 {
         WERROR status;
-
-        GET_STRING_LDB(msg, "cn", mem_ctx, obj, cn, false);
-        GET_STRING_LDB(msg, "lDAPDisplayName", mem_ctx, obj, lDAPDisplayName, true);
-        GET_STRING_LDB(msg, "governsID", mem_ctx, obj, governsID_oid, true);
-        if (schema->num_prefixes == 0) {
+        struct dsdb_class *obj = talloc_zero(schema, struct dsdb_class);
+        if (!obj) {
+                return WERR_NOMEM;
+        }
+        GET_STRING_LDB(msg, "cn", obj, obj, cn, false);
+        GET_STRING_LDB(msg, "lDAPDisplayName", obj, obj, lDAPDisplayName, true);
+        GET_STRING_LDB(msg, "governsID", obj, obj, governsID_oid, true);
+        if (!schema->prefixmap || schema->prefixmap->length == 0) {
                 /* set an invalid value */
-                obj->governsID_id = 0xFFFFFFFF;
+                obj->governsID_id = DRSUAPI_ATTID_INVALID;
         } else {
-                status = dsdb_map_oid2int(schema, obj->governsID_oid, &obj->governsID_id);
+                status = dsdb_schema_pfm_make_attid(schema->prefixmap,
+                                                    obj->governsID_oid,
+                                                    &obj->governsID_id);
                 if (!W_ERROR_IS_OK(status)) {
                         DEBUG(0,("%s: '%s': unable to map governsID %s: %s\n",
@@ -868 +736 @@
         }
         GET_GUID_LDB(msg, "schemaIDGUID", obj, schemaIDGUID);
+        GET_GUID_LDB(msg, "objectGUID", obj, objectGUID);
 
         GET_UINT32_LDB(msg, "objectClassCategory", obj, objectClassCategory);
-        GET_STRING_LDB(msg, "rDNAttID", mem_ctx, obj, rDNAttID, false);
-        GET_STRING_LDB(msg, "defaultObjectCategory", mem_ctx, obj, defaultObjectCategory, true);
+        GET_STRING_LDB(msg, "rDNAttID", obj, obj, rDNAttID, false);
+        GET_STRING_LDB(msg, "defaultObjectCategory", obj, obj, defaultObjectCategory, true);
  
-        GET_STRING_LDB(msg, "subClassOf", mem_ctx, obj, subClassOf, true);
-
-        GET_STRING_LIST_LDB(msg, "systemAuxiliaryClass", mem_ctx, obj, systemAuxiliaryClass, false);
-        GET_STRING_LIST_LDB(msg, "auxiliaryClass", mem_ctx, obj, auxiliaryClass, false);
-
-        GET_STRING_LIST_LDB(msg, "systemMustContain", mem_ctx, obj, systemMustContain, false);
-        GET_STRING_LIST_LDB(msg, "systemMayContain", mem_ctx, obj, systemMayContain, false);
-        GET_STRING_LIST_LDB(msg, "mustContain", mem_ctx, obj, mustContain, false);
-        GET_STRING_LIST_LDB(msg, "mayContain", mem_ctx, obj, mayContain, false);
-
-        GET_STRING_LIST_LDB(msg, "systemPossSuperiors", mem_ctx, obj, systemPossSuperiors, false);
-        GET_STRING_LIST_LDB(msg, "possSuperiors", mem_ctx, obj, possSuperiors, false);
-
-        GET_STRING_LDB(msg, "defaultSecurityDescriptor", mem_ctx, obj, defaultSecurityDescriptor, false);
+        GET_STRING_LDB(msg, "subClassOf", obj, obj, subClassOf, true);
+
+        GET_STRING_LIST_LDB(msg, "systemAuxiliaryClass", obj, obj, systemAuxiliaryClass);
+        GET_STRING_LIST_LDB(msg, "auxiliaryClass", obj, obj, auxiliaryClass);
+
+        GET_STRING_LIST_LDB(msg, "systemMustContain", obj, obj, systemMustContain);
+        GET_STRING_LIST_LDB(msg, "systemMayContain", obj, obj, systemMayContain);
+        GET_STRING_LIST_LDB(msg, "mustContain", obj, obj, mustContain);
+        GET_STRING_LIST_LDB(msg, "mayContain", obj, obj, mayContain);
+
+        GET_STRING_LIST_LDB(msg, "systemPossSuperiors", obj, obj, systemPossSuperiors);
+        GET_STRING_LIST_LDB(msg, "possSuperiors", obj, obj, possSuperiors);
+
+        GET_STRING_LDB(msg, "defaultSecurityDescriptor", obj, obj, defaultSecurityDescriptor, false);
 
         GET_UINT32_LDB(msg, "schemaFlagsEx", obj, schemaFlagsEx);
-        GET_BLOB_LDB(msg, "msDs-Schema-Extensions", mem_ctx, obj, msDs_Schema_Extensions);
+        GET_BLOB_LDB(msg, "msDs-Schema-Extensions", obj, obj, msDs_Schema_Extensions);
 
         GET_BOOL_LDB(msg, "showInAdvancedViewOnly", obj, showInAdvancedViewOnly, false);
-        GET_STRING_LDB(msg, "adminDisplayName", mem_ctx, obj, adminDisplayName, false);
-        GET_STRING_LDB(msg, "adminDescription", mem_ctx, obj, adminDescription, false);
-        GET_STRING_LDB(msg, "classDisplayName", mem_ctx, obj, classDisplayName, false);
+        GET_STRING_LDB(msg, "adminDisplayName", obj, obj, adminDisplayName, false);
+        GET_STRING_LDB(msg, "adminDescription", obj, obj, adminDescription, false);
+        GET_STRING_LDB(msg, "classDisplayName", obj, obj, classDisplayName, false);
         GET_BOOL_LDB(msg, "defaultHidingValue", obj, defaultHidingValue, false);
         GET_BOOL_LDB(msg, "isDefunct", obj, isDefunct, false);
         GET_BOOL_LDB(msg, "systemOnly", obj, systemOnly, false);
 
+        DLIST_ADD(schema->classes, obj);
         return WERR_OK;
 }
@@ -907 +777 @@
  Create a DSDB schema from the ldb results provided.  This is called
  directly when the schema is provisioned from an on-disk LDIF file, or
- from dsdb_schema_from_schema_dn below
+ from dsdb_schema_from_schema_dn in schema_fsmo
 */
 
 int dsdb_schema_from_ldb_results(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
-                                 struct smb_iconv_convenience *iconv_convenience, 
                                  struct ldb_result *schema_res,
                                  struct ldb_result *attrs_res, struct ldb_result *objectclass_res, 
@@ -918 +787 @@
 {
         WERROR status;
-        uint32_t i;
+        unsigned int i;
         const struct ldb_val *prefix_val;
         const struct ldb_val *info_val;
@@ -924 +793 @@
         struct dsdb_schema *schema;
 
-        schema = dsdb_new_schema(mem_ctx, iconv_convenience);
+        schema = dsdb_new_schema(mem_ctx);
         if (!schema) {
                 dsdb_oom(error_string, mem_ctx);
-                return LDB_ERR_OPERATIONS_ERROR;
-        }
+                return ldb_operr(ldb);
+        }
+
+        schema->base_dn = talloc_steal(schema, schema_res->msgs[0]->dn);
 
         prefix_val = ldb_msg_find_ldb_val(schema_res->msgs[0], "prefixMap");
@@ -939 +810 @@
         info_val = ldb_msg_find_ldb_val(schema_res->msgs[0], "schemaInfo");
         if (!info_val) {
-                info_val_default = strhex_to_data_blob(mem_ctx, "FF0000000000000000000000000000000000000000");
-                if (!info_val_default.data) {
-                        dsdb_oom(error_string, mem_ctx);
-                        return LDB_ERR_OPERATIONS_ERROR;
+                status = dsdb_schema_info_blob_new(mem_ctx, &info_val_default);
+                if (!W_ERROR_IS_OK(status)) {
+                        *error_string = talloc_asprintf(mem_ctx,
+                                                        "schema_fsmo_init: dsdb_schema_info_blob_new() failed - %s",
+                                                        win_errstr(status));
+                        DEBUG(0,(__location__ ": %s\n", *error_string));
+                        return ldb_operr(ldb);
                 }
                 info_val = &info_val_default;
@@ -957 +831 @@
 
         for (i=0; i < attrs_res->count; i++) {
-                struct dsdb_attribute *sa;
-
-                sa = talloc_zero(schema, struct dsdb_attribute);
-                if (!sa) {
-                        dsdb_oom(error_string, mem_ctx);
-                        return LDB_ERR_OPERATIONS_ERROR;
-                }
-
-                status = dsdb_attribute_from_ldb(ldb, schema, attrs_res->msgs[i], sa, sa);
+                status = dsdb_attribute_from_ldb(ldb, schema, attrs_res->msgs[i]);
                 if (!W_ERROR_IS_OK(status)) {
                         *error_string = talloc_asprintf(mem_ctx, 
@@ -974 +840 @@
                         return LDB_ERR_CONSTRAINT_VIOLATION;
                 }
-
-                DLIST_ADD(schema->attributes, sa);
         }
 
         for (i=0; i < objectclass_res->count; i++) {
-                struct dsdb_class *sc;
-
-                sc = talloc_zero(schema, struct dsdb_class);
-                if (!sc) {
-                        dsdb_oom(error_string, mem_ctx);
-                        return LDB_ERR_OPERATIONS_ERROR;
-                }
-
-                status = dsdb_class_from_ldb(schema, objectclass_res->msgs[i], sc, sc);
+                status = dsdb_class_from_ldb(schema, objectclass_res->msgs[i]);
                 if (!W_ERROR_IS_OK(status)) {
                         *error_string = talloc_asprintf(mem_ctx, 
@@ -996 +852 @@
                         return LDB_ERR_CONSTRAINT_VIOLATION;
                 }
-
-                DLIST_ADD(schema->classes, sc);
         }
 
@@ -1013 +867 @@
         return LDB_SUCCESS;
 }
-
-/*
-  Given an LDB, and the DN, return a populated schema
-*/
-
-int dsdb_schema_from_schema_dn(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
-                               struct smb_iconv_convenience *iconv_convenience, 
-                               struct ldb_dn *schema_dn,
-                               struct dsdb_schema **schema,
-                               char **error_string_out) 
-{
-        TALLOC_CTX *tmp_ctx;
-        char *error_string;
-        int ret;
-
-        struct ldb_result *schema_res;
-        struct ldb_result *a_res;
-        struct ldb_result *c_res;
-        static const char *schema_attrs[] = {
-                "prefixMap",
-                "schemaInfo",
-                "fSMORoleOwner",
-                NULL
-        };
-        unsigned flags;
-
-        tmp_ctx = talloc_new(mem_ctx);
-        if (!tmp_ctx) {
-                dsdb_oom(error_string_out, mem_ctx);
-                return LDB_ERR_OPERATIONS_ERROR;
-        }
-
-        /* we don't want to trace the schema load */
-        flags = ldb_get_flags(ldb);
-        ldb_set_flags(ldb, flags & ~LDB_FLG_ENABLE_TRACING);
-
-        /*
-         * setup the prefix mappings and schema info
-         */
-        ret = ldb_search(ldb, tmp_ctx, &schema_res,
-                         schema_dn, LDB_SCOPE_BASE, schema_attrs, NULL);
-        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
-                goto failed;
-        } else if (ret != LDB_SUCCESS) {
-                *error_string_out = talloc_asprintf(mem_ctx, 
-                                       "dsdb_schema: failed to search the schema head: %s",
-                                       ldb_errstring(ldb));
-                goto failed;
-        }
-        if (schema_res->count != 1) {
-                *error_string_out = talloc_asprintf(mem_ctx, 
-                              "dsdb_schema: [%u] schema heads found on a base search",
-                              schema_res->count);
-                goto failed;
-        }
-
-        /*
-         * load the attribute definitions
-         */
-        ret = ldb_search(ldb, tmp_ctx, &a_res,
-                         schema_dn, LDB_SCOPE_ONELEVEL, NULL,
-                         "(objectClass=attributeSchema)");
-        if (ret != LDB_SUCCESS) {
-                *error_string_out = talloc_asprintf(mem_ctx, 
-                                       "dsdb_schema: failed to search attributeSchema objects: %s",
-                                       ldb_errstring(ldb));
-                goto failed;
-        }
-
-        /*
-         * load the objectClass definitions
-         */
-        ret = ldb_search(ldb, tmp_ctx, &c_res,
-                         schema_dn, LDB_SCOPE_ONELEVEL, NULL,
-                         "(objectClass=classSchema)");
-        if (ret != LDB_SUCCESS) {
-                *error_string_out = talloc_asprintf(mem_ctx, 
-                                       "dsdb_schema: failed to search attributeSchema objects: %s",
-                                       ldb_errstring(ldb));
-                goto failed;
-        }
-
-        ret = dsdb_schema_from_ldb_results(tmp_ctx, ldb,
-                                           lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
-                                           schema_res, a_res, c_res, schema, &error_string);
-        if (ret != LDB_SUCCESS) {
-                *error_string_out = talloc_asprintf(mem_ctx, 
-                                                    "dsdb_schema load failed: %s",
-                                                    error_string);
-                goto failed;
-        }
-        talloc_steal(mem_ctx, *schema);
-        talloc_free(tmp_ctx);
-
-        if (flags & LDB_FLG_ENABLE_TRACING) {
-                flags = ldb_get_flags(ldb);
-                ldb_set_flags(ldb, flags | LDB_FLG_ENABLE_TRACING);
-        }
-
-        return LDB_SUCCESS;
-
-failed:
-        if (flags & LDB_FLG_ENABLE_TRACING) {
-                flags = ldb_get_flags(ldb);
-                ldb_set_flags(ldb, flags | LDB_FLG_ENABLE_TRACING);
-        }
-        talloc_free(tmp_ctx);
-        return ret;
-}       
-
-
-static const struct {
-        const char *name;
-        const char *oid;
-} name_mappings[] = {
-        { "cn",                                 "2.5.4.3" },
-        { "name",                               "1.2.840.113556.1.4.1" },
-        { "lDAPDisplayName",                    "1.2.840.113556.1.2.460" },
-        { "attributeID",                        "1.2.840.113556.1.2.30" },
-        { "schemaIDGUID",                       "1.2.840.113556.1.4.148" },
-        { "mAPIID",                             "1.2.840.113556.1.2.49" },
-        { "attributeSecurityGUID",              "1.2.840.113556.1.4.149" },
-        { "searchFlags",                        "1.2.840.113556.1.2.334" },
-        { "systemFlags",                        "1.2.840.113556.1.4.375" },
-        { "isMemberOfPartialAttributeSet",      "1.2.840.113556.1.4.639" },
-        { "linkID",                             "1.2.840.113556.1.2.50" },
-        { "attributeSyntax",                    "1.2.840.113556.1.2.32" },
-        { "oMSyntax",                           "1.2.840.113556.1.2.231" },
-        { "oMObjectClass",                      "1.2.840.113556.1.2.218" },
-        { "isSingleValued",                     "1.2.840.113556.1.2.33" },
-        { "rangeLower",                         "1.2.840.113556.1.2.34" },
-        { "rangeUpper",                         "1.2.840.113556.1.2.35" },
-        { "extendedCharsAllowed",               "1.2.840.113556.1.2.380" },
-        { "schemaFlagsEx",                      "1.2.840.113556.1.4.120" },
-        { "msDs-Schema-Extensions",             "1.2.840.113556.1.4.1440" },
-        { "showInAdvancedViewOnly",             "1.2.840.113556.1.2.169" },
-        { "adminDisplayName",                   "1.2.840.113556.1.2.194" },
-        { "adminDescription",                   "1.2.840.113556.1.2.226" },
-        { "classDisplayName",                   "1.2.840.113556.1.4.610" },
-        { "isEphemeral",                        "1.2.840.113556.1.4.1212" },
-        { "isDefunct",                          "1.2.840.113556.1.4.661" },
-        { "systemOnly",                         "1.2.840.113556.1.4.170" },
-        { "governsID",                          "1.2.840.113556.1.2.22" },
-        { "objectClassCategory",                "1.2.840.113556.1.2.370" },
-        { "rDNAttID",                           "1.2.840.113556.1.2.26" },
-        { "defaultObjectCategory",              "1.2.840.113556.1.4.783" },
-        { "subClassOf",                         "1.2.840.113556.1.2.21" },
-        { "systemAuxiliaryClass",               "1.2.840.113556.1.4.198" },
-        { "systemPossSuperiors",                "1.2.840.113556.1.4.195" },
-        { "systemMustContain",                  "1.2.840.113556.1.4.197" },
-        { "systemMayContain",                   "1.2.840.113556.1.4.196" },
-        { "auxiliaryClass",                     "1.2.840.113556.1.2.351" },
-        { "possSuperiors",                      "1.2.840.113556.1.2.8" },
-        { "mustContain",                        "1.2.840.113556.1.2.24" },
-        { "mayContain",                         "1.2.840.113556.1.2.25" },
-        { "defaultSecurityDescriptor",          "1.2.840.113556.1.4.224" },
-        { "defaultHidingValue",                 "1.2.840.113556.1.4.518" },
-};
-
-static struct drsuapi_DsReplicaAttribute *dsdb_find_object_attr_name(struct dsdb_schema *schema,
-                                                                     struct drsuapi_DsReplicaObject *obj,
-                                                                     const char *name,
-                                                                     uint32_t *idx)
-{
-        WERROR status;
-        uint32_t i, id;
-        const char *oid = NULL;
-
-        for(i=0; i < ARRAY_SIZE(name_mappings); i++) {
-                if (strcmp(name_mappings[i].name, name) != 0) continue;
-
-                oid = name_mappings[i].oid;
-                break;
-        }
-
-        if (!oid) {
-                return NULL;
-        }
-
-        status = dsdb_map_oid2int(schema, oid, &id);
-        if (!W_ERROR_IS_OK(status)) {
-                return NULL;
-        }
-
-        for (i=0; i < obj->attribute_ctr.num_attributes; i++) {
-                if (obj->attribute_ctr.attributes[i].attid != id) continue;
-
-                if (idx) *idx = i;
-                return &obj->attribute_ctr.attributes[i];
-        }
-
-        return NULL;
-}
-
-#define GET_STRING_DS(s, r, attr, mem_ctx, p, elem, strict) do { \
-        struct drsuapi_DsReplicaAttribute *_a; \
-        _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
-        if (strict && !_a) { \
-                d_printf("%s: %s == NULL\n", __location__, attr); \
-                return WERR_INVALID_PARAM; \
-        } \
-        if (strict && _a->value_ctr.num_values != 1) { \
-                d_printf("%s: %s num_values == %u\n", __location__, attr, \
-                        _a->value_ctr.num_values); \
-                return WERR_INVALID_PARAM; \
-        } \
-        if (_a && _a->value_ctr.num_values >= 1) { \
-                size_t _ret; \
-                if (!convert_string_talloc_convenience(mem_ctx, s->iconv_convenience, CH_UTF16, CH_UNIX, \
-                                             _a->value_ctr.values[0].blob->data, \
-                                             _a->value_ctr.values[0].blob->length, \
-                                             (void **)discard_const(&(p)->elem), &_ret, false)) { \
-                        DEBUG(0,("%s: invalid data!\n", attr)); \
-                        dump_data(0, \
-                                     _a->value_ctr.values[0].blob->data, \
-                                     _a->value_ctr.values[0].blob->length); \
-                        return WERR_FOOBAR; \
-                } \
-        } else { \
-                (p)->elem = NULL; \
-        } \
-} while (0)
-
-#define GET_UINT32_LIST_DS(s, r, attr, mem_ctx, p, elem) do { \
-        int list_counter;                                       \
-        struct drsuapi_DsReplicaAttribute *_a; \
-        _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
-        (p)->elem = _a ? talloc_array(mem_ctx, uint32_t, _a->value_ctr.num_values + 1) : NULL; \
-        for (list_counter=0;                                    \
-             _a && list_counter < _a->value_ctr.num_values;     \
-             list_counter++) {                          \
-                if (_a->value_ctr.values[list_counter].blob->length != 4) { \
-                        return WERR_INVALID_PARAM;                      \
-                }                                                       \
-                (p)->elem[list_counter] = IVAL(_a->value_ctr.values[list_counter].blob->data, 0); \
-        }                                                               \
-        if (_a) (p)->elem[list_counter] = 0;                            \
-} while (0)
-
-#define GET_DN_DS(s, r, attr, mem_ctx, p, elem, strict) do { \
-        struct drsuapi_DsReplicaAttribute *_a; \
-        _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
-        if (strict && !_a) { \
-                d_printf("%s: %s == NULL\n", __location__, attr); \
-                return WERR_INVALID_PARAM; \
-        } \
-        if (strict && _a->value_ctr.num_values != 1) { \
-                d_printf("%s: %s num_values == %u\n", __location__, attr, \
-                        _a->value_ctr.num_values); \
-                return WERR_INVALID_PARAM; \
-        } \
-        if (strict && !_a->value_ctr.values[0].blob) { \
-                d_printf("%s: %s data == NULL\n", __location__, attr); \
-                return WERR_INVALID_PARAM; \
-        } \
-        if (_a && _a->value_ctr.num_values >= 1 \
-            && _a->value_ctr.values[0].blob) { \
-                struct drsuapi_DsReplicaObjectIdentifier3 _id3; \
-                enum ndr_err_code _ndr_err; \
-                _ndr_err = ndr_pull_struct_blob_all(_a->value_ctr.values[0].blob, \
-                                                      mem_ctx, s->iconv_convenience, &_id3,\
-                                                      (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);\
-                if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
-                        NTSTATUS _nt_status = ndr_map_error2ntstatus(_ndr_err); \
-                        return ntstatus_to_werror(_nt_status); \
-                } \
-                (p)->elem = _id3.dn; \
-        } else { \
-                (p)->elem = NULL; \
-        } \
-} while (0)
-
-#define GET_BOOL_DS(s, r, attr, p, elem, strict) do { \
-        struct drsuapi_DsReplicaAttribute *_a; \
-        _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
-        if (strict && !_a) { \
-                d_printf("%s: %s == NULL\n", __location__, attr); \
-                return WERR_INVALID_PARAM; \
-        } \
-        if (strict && _a->value_ctr.num_values != 1) { \
-                d_printf("%s: %s num_values == %u\n", __location__, attr, \
-                         (unsigned int)_a->value_ctr.num_values);       \
-                return WERR_INVALID_PARAM; \
-        } \
-        if (strict && !_a->value_ctr.values[0].blob) { \
-                d_printf("%s: %s data == NULL\n", __location__, attr); \
-                return WERR_INVALID_PARAM; \
-        } \
-        if (strict && _a->value_ctr.values[0].blob->length != 4) { \
-                d_printf("%s: %s length == %u\n", __location__, attr, \
-                         (unsigned int)_a->value_ctr.values[0].blob->length); \
-                return WERR_INVALID_PARAM; \
-        } \
-        if (_a && _a->value_ctr.num_values >= 1 \
-            && _a->value_ctr.values[0].blob \
-            && _a->value_ctr.values[0].blob->length == 4) { \
-                (p)->elem = (IVAL(_a->value_ctr.values[0].blob->data,0)?true:false);\
-        } else { \
-                (p)->elem = false; \
-        } \
-} while (0)
-
-#define GET_UINT32_DS(s, r, attr, p, elem) do { \
-        struct drsuapi_DsReplicaAttribute *_a; \
-        _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
-        if (_a && _a->value_ctr.num_values >= 1 \
-            && _a->value_ctr.values[0].blob \
-            && _a->value_ctr.values[0].blob->length == 4) { \
-                (p)->elem = IVAL(_a->value_ctr.values[0].blob->data,0);\
-        } else { \
-                (p)->elem = 0; \
-        } \
-} while (0)
-
-#define GET_UINT32_PTR_DS(s, r, attr, p, elem) do { \
-        struct drsuapi_DsReplicaAttribute *_a; \
-        _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
-        if (_a && _a->value_ctr.num_values >= 1 \
-            && _a->value_ctr.values[0].blob \
-            && _a->value_ctr.values[0].blob->length == 4) { \
-                (p)->elem = talloc(mem_ctx, uint32_t); \
-                if (!(p)->elem) { \
-                        d_printf("%s: talloc failed for %s\n", __location__, attr); \
-                        return WERR_NOMEM; \
-                } \
-                *(p)->elem = IVAL(_a->value_ctr.values[0].blob->data,0);\
-        } else { \
-                (p)->elem = NULL; \
-        } \
-} while (0)
-
-#define GET_GUID_DS(s, r, attr, mem_ctx, p, elem) do { \
-        struct drsuapi_DsReplicaAttribute *_a; \
-        _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
-        if (_a && _a->value_ctr.num_values >= 1 \
-            && _a->value_ctr.values[0].blob \
-            && _a->value_ctr.values[0].blob->length == 16) { \
-                enum ndr_err_code _ndr_err; \
-                _ndr_err = ndr_pull_struct_blob_all(_a->value_ctr.values[0].blob, \
-                                                      mem_ctx, s->iconv_convenience, &(p)->elem, \
-                                                      (ndr_pull_flags_fn_t)ndr_pull_GUID); \
-                if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
-                        NTSTATUS _nt_status = ndr_map_error2ntstatus(_ndr_err); \
-                        return ntstatus_to_werror(_nt_status); \
-                } \
-        } else { \
-                ZERO_STRUCT((p)->elem);\
-        } \
-} while (0)
-
-#define GET_BLOB_DS(s, r, attr, mem_ctx, p, elem) do { \
-        struct drsuapi_DsReplicaAttribute *_a; \
-        _a = dsdb_find_object_attr_name(s, r, attr, NULL); \
-        if (_a && _a->value_ctr.num_values >= 1 \
-            && _a->value_ctr.values[0].blob) { \
-                (p)->elem = *_a->value_ctr.values[0].blob;\
-                talloc_steal(mem_ctx, (p)->elem.data); \
-        } else { \
-                ZERO_STRUCT((p)->elem);\
-        }\
-} while (0)
-
-WERROR dsdb_attribute_from_drsuapi(struct ldb_context *ldb,
-                                   struct dsdb_schema *schema,
-                                   struct drsuapi_DsReplicaObject *r,
-                                   TALLOC_CTX *mem_ctx,
-                                   struct dsdb_attribute *attr)
-{
-        WERROR status;
-
-        GET_STRING_DS(schema, r, "name", mem_ctx, attr, cn, true);
-        GET_STRING_DS(schema, r, "lDAPDisplayName", mem_ctx, attr, lDAPDisplayName, true);
-        GET_UINT32_DS(schema, r, "attributeID", attr, attributeID_id);
-        status = dsdb_map_int2oid(schema, attr->attributeID_id, mem_ctx, &attr->attributeID_oid);
-        if (!W_ERROR_IS_OK(status)) {
-                DEBUG(0,("%s: '%s': unable to map attributeID 0x%08X: %s\n",
-                        __location__, attr->lDAPDisplayName, attr->attributeID_id,
-                        win_errstr(status)));
-                return status;
-        }
-        GET_GUID_DS(schema, r, "schemaIDGUID", mem_ctx, attr, schemaIDGUID);
-        GET_UINT32_DS(schema, r, "mAPIID", attr, mAPIID);
-
-        GET_GUID_DS(schema, r, "attributeSecurityGUID", mem_ctx, attr, attributeSecurityGUID);
-
-        GET_UINT32_DS(schema, r, "searchFlags", attr, searchFlags);
-        GET_UINT32_DS(schema, r, "systemFlags", attr, systemFlags);
-        GET_BOOL_DS(schema, r, "isMemberOfPartialAttributeSet", attr, isMemberOfPartialAttributeSet, false);
-        GET_UINT32_DS(schema, r, "linkID", attr, linkID);
-
-        GET_UINT32_DS(schema, r, "attributeSyntax", attr, attributeSyntax_id);
-        status = dsdb_map_int2oid(schema, attr->attributeSyntax_id, mem_ctx, &attr->attributeSyntax_oid);
-        if (!W_ERROR_IS_OK(status)) {
-                DEBUG(0,("%s: '%s': unable to map attributeSyntax 0x%08X: %s\n",
-                        __location__, attr->lDAPDisplayName, attr->attributeSyntax_id,
-                        win_errstr(status)));
-                return status;
-        }
-        GET_UINT32_DS(schema, r, "oMSyntax", attr, oMSyntax);
-        GET_BLOB_DS(schema, r, "oMObjectClass", mem_ctx, attr, oMObjectClass);
-
-        GET_BOOL_DS(schema, r, "isSingleValued", attr, isSingleValued, true);
-        GET_UINT32_PTR_DS(schema, r, "rangeLower", attr, rangeLower);
-        GET_UINT32_PTR_DS(schema, r, "rangeUpper", attr, rangeUpper);
-        GET_BOOL_DS(schema, r, "extendedCharsAllowed", attr, extendedCharsAllowed, false);
-
-        GET_UINT32_DS(schema, r, "schemaFlagsEx", attr, schemaFlagsEx);
-        GET_BLOB_DS(schema, r, "msDs-Schema-Extensions", mem_ctx, attr, msDs_Schema_Extensions);
-
-        GET_BOOL_DS(schema, r, "showInAdvancedViewOnly", attr, showInAdvancedViewOnly, false);
-        GET_STRING_DS(schema, r, "adminDisplayName", mem_ctx, attr, adminDisplayName, false);
-        GET_STRING_DS(schema, r, "adminDescription", mem_ctx, attr, adminDescription, false);
-        GET_STRING_DS(schema, r, "classDisplayName", mem_ctx, attr, classDisplayName, false);
-        GET_BOOL_DS(schema, r, "isEphemeral", attr, isEphemeral, false);
-        GET_BOOL_DS(schema, r, "isDefunct", attr, isDefunct, false);
-        GET_BOOL_DS(schema, r, "systemOnly", attr, systemOnly, false);
-
-        attr->syntax = dsdb_syntax_for_attribute(attr);
-        if (!attr->syntax) {
-                return WERR_DS_ATT_SCHEMA_REQ_SYNTAX;
-        }
-
-        if (dsdb_schema_setup_ldb_schema_attribute(ldb, attr) != LDB_SUCCESS) {
-                return WERR_DS_ATT_SCHEMA_REQ_SYNTAX;
-        }
-
-        return WERR_OK;
-}
-
-WERROR dsdb_class_from_drsuapi(struct dsdb_schema *schema,
-                               struct drsuapi_DsReplicaObject *r,
-                               TALLOC_CTX *mem_ctx,
-                               struct dsdb_class *obj)
-{
-        WERROR status;
-
-        GET_STRING_DS(schema, r, "name", mem_ctx, obj, cn, true);
-        GET_STRING_DS(schema, r, "lDAPDisplayName", mem_ctx, obj, lDAPDisplayName, true);
-        GET_UINT32_DS(schema, r, "governsID", obj, governsID_id);
-        status = dsdb_map_int2oid(schema, obj->governsID_id, mem_ctx, &obj->governsID_oid);
-        if (!W_ERROR_IS_OK(status)) {
-                DEBUG(0,("%s: '%s': unable to map governsID 0x%08X: %s\n",
-                        __location__, obj->lDAPDisplayName, obj->governsID_id,
-                        win_errstr(status)));
-                return status;
-        }
-        GET_GUID_DS(schema, r, "schemaIDGUID", mem_ctx, obj, schemaIDGUID);
-
-        GET_UINT32_DS(schema, r, "objectClassCategory", obj, objectClassCategory);
-        GET_STRING_DS(schema, r, "rDNAttID", mem_ctx, obj, rDNAttID, false);
-        GET_DN_DS(schema, r, "defaultObjectCategory", mem_ctx, obj, defaultObjectCategory, true);
-
-        GET_UINT32_DS(schema, r, "subClassOf", obj, subClassOf_id);
-
-        GET_UINT32_LIST_DS(schema, r, "systemAuxiliaryClass", mem_ctx, obj, systemAuxiliaryClass_ids);
-        GET_UINT32_LIST_DS(schema, r, "auxiliaryClass", mem_ctx, obj, auxiliaryClass_ids);
-
-        GET_UINT32_LIST_DS(schema, r, "systemMustContain", mem_ctx, obj, systemMustContain_ids);
-        GET_UINT32_LIST_DS(schema, r, "systemMayContain", mem_ctx, obj, systemMayContain_ids);
-        GET_UINT32_LIST_DS(schema, r, "mustContain", mem_ctx, obj, mustContain_ids);
-        GET_UINT32_LIST_DS(schema, r, "mayContain", mem_ctx, obj, mayContain_ids);
-
-        GET_UINT32_LIST_DS(schema, r, "systemPossSuperiors", mem_ctx, obj, systemPossSuperiors_ids);
-        GET_UINT32_LIST_DS(schema, r, "possSuperiors", mem_ctx, obj, possSuperiors_ids);
-
-        GET_STRING_DS(schema, r, "defaultSecurityDescriptor", mem_ctx, obj, defaultSecurityDescriptor, false);
-
-        GET_UINT32_DS(schema, r, "schemaFlagsEx", obj, schemaFlagsEx);
-        GET_BLOB_DS(schema, r, "msDs-Schema-Extensions", mem_ctx, obj, msDs_Schema_Extensions);
-
-        GET_BOOL_DS(schema, r, "showInAdvancedViewOnly", obj, showInAdvancedViewOnly, false);
-        GET_STRING_DS(schema, r, "adminDisplayName", mem_ctx, obj, adminDisplayName, false);
-        GET_STRING_DS(schema, r, "adminDescription", mem_ctx, obj, adminDescription, false);
-        GET_STRING_DS(schema, r, "classDisplayName", mem_ctx, obj, classDisplayName, false);
-        GET_BOOL_DS(schema, r, "defaultHidingValue", obj, defaultHidingValue, false);
-        GET_BOOL_DS(schema, r, "isDefunct", obj, isDefunct, false);
-        GET_BOOL_DS(schema, r, "systemOnly", obj, systemOnly, false);
-
-        return WERR_OK;
-}
-

vendor/current/source4/dsdb/schema/schema_query.c

@@ -23 +23 @@
 #include "includes.h"
 #include "dsdb/samdb/samdb.h"
-
-/* a binary array search, where the array is an array of pointers to structures,
-   and we want to find a match for 'target' on 'field' in those structures.
-
-   Inputs:
-      array:          base pointer to an array of structures
-      arrray_size:    number of elements in the array
-      field:          the name of the field in the structure we are keying off
-      target:         the field value we are looking for
-      comparison_fn:  the comparison function
-      result:         where the result of the search is put
-
-   if the element is found, then 'result' is set to point to the found array element. If not,
-   then 'result' is set to NULL.
-
-   The array is assumed to be sorted by the same comparison_fn as the
-   search (with, for example, qsort)
- */
-#define BINARY_ARRAY_SEARCH(array, array_size, field, target, comparison_fn, result) do { \
-        int32_t _b, _e; \
-        (result) = NULL; \
-        for (_b = 0, _e = (array_size)-1; _b <= _e; ) { \
-                int32_t _i = (_b+_e)/2; \
-                int _r = comparison_fn(target, array[_i]->field); \
-                if (_r == 0) { (result) = array[_i]; break; } \
-                if (_r < 0) _e = _i - 1; else _b = _i + 1; \
-        } } while (0)
-
+#include "lib/util/binsearch.h"
+#include "lib/util/tsort.h"
 
 static const char **dsdb_full_attribute_list_internal(TALLOC_CTX *mem_ctx, 
@@ -59 +33 @@
 static int uint32_cmp(uint32_t c1, uint32_t c2) 
 {
-        return c1 - c2;
+        if (c1 == c2) return 0;
+        return c1 > c2 ? 1 : -1;
 }
 
@@ -66 +41 @@
         int ret = strncasecmp((const char *)target->data, str, target->length);
         if (ret == 0) {
-                return (target->length - strlen(str));
+                size_t len = strlen(str);
+                if (target->length > len) {
+                        if (target->data[len] == 0) {
+                                return 0;
+                        }
+                        return 1;
+                }
+                return (target->length - len);
         }
         return ret;
@@ -82 +64 @@
         if (id == 0xFFFFFFFF) return NULL;
 
-        BINARY_ARRAY_SEARCH(schema->attributes_by_attributeID_id, 
-                            schema->num_attributes, attributeID_id, id, uint32_cmp, c);
+        /* check for msDS-IntId type attribute */
+        if (dsdb_pfm_get_attid_type(id) == DSDB_ATTID_TYPE_INTID) {
+                BINARY_ARRAY_SEARCH_P(schema->attributes_by_msDS_IntId,
+                                      schema->num_int_id_attr, msDS_IntId, id, uint32_cmp, c);
+                return c;
+        }
+
+        BINARY_ARRAY_SEARCH_P(schema->attributes_by_attributeID_id,
+                              schema->num_attributes, attributeID_id, id, uint32_cmp, c);
         return c;
 }
@@ -94 +83 @@
         if (!oid) return NULL;
 
-        BINARY_ARRAY_SEARCH(schema->attributes_by_attributeID_oid, 
-                            schema->num_attributes, attributeID_oid, oid, strcasecmp, c);
+        BINARY_ARRAY_SEARCH_P(schema->attributes_by_attributeID_oid,
+                              schema->num_attributes, attributeID_oid, oid, strcasecmp, c);
         return c;
 }
@@ -106 +95 @@
         if (!name) return NULL;
 
-        BINARY_ARRAY_SEARCH(schema->attributes_by_lDAPDisplayName, 
-                            schema->num_attributes, lDAPDisplayName, name, strcasecmp, c);
-        return c;
+        BINARY_ARRAY_SEARCH_P(schema->attributes_by_lDAPDisplayName,
+                              schema->num_attributes, lDAPDisplayName, name, strcasecmp, c);
+        return c;
+}
+
+const struct dsdb_attribute *dsdb_attribute_by_lDAPDisplayName_ldb_val(const struct dsdb_schema *schema,
+                                                                       const struct ldb_val *name)
+{
+        struct dsdb_attribute *a;
+
+        if (!name) return NULL;
+
+        BINARY_ARRAY_SEARCH_P(schema->attributes_by_lDAPDisplayName,
+                              schema->num_attributes, lDAPDisplayName, name, strcasecmp_with_ldb_val, a);
+        return a;
 }
 
@@ -116 +117 @@
         struct dsdb_attribute *c;
 
-        BINARY_ARRAY_SEARCH(schema->attributes_by_linkID, 
-                            schema->num_attributes, linkID, linkID, uint32_cmp, c);
+        BINARY_ARRAY_SEARCH_P(schema->attributes_by_linkID,
+                              schema->num_attributes, linkID, linkID, uint32_cmp, c);
         return c;
 }
@@ -132 +133 @@
         if (id == 0xFFFFFFFF) return NULL;
 
-        BINARY_ARRAY_SEARCH(schema->classes_by_governsID_id, 
-                            schema->num_classes, governsID_id, id, uint32_cmp, c);
+        BINARY_ARRAY_SEARCH_P(schema->classes_by_governsID_id,
+                              schema->num_classes, governsID_id, id, uint32_cmp, c);
         return c;
 }
@@ -142 +143 @@
         struct dsdb_class *c;
         if (!oid) return NULL;
-        BINARY_ARRAY_SEARCH(schema->classes_by_governsID_oid, 
-                            schema->num_classes, governsID_oid, oid, strcasecmp, c);
+        BINARY_ARRAY_SEARCH_P(schema->classes_by_governsID_oid,
+                              schema->num_classes, governsID_oid, oid, strcasecmp, c);
         return c;
 }
@@ -152 +153 @@
         struct dsdb_class *c;
         if (!name) return NULL;
-        BINARY_ARRAY_SEARCH(schema->classes_by_lDAPDisplayName, 
-                            schema->num_classes, lDAPDisplayName, name, strcasecmp, c);
+        BINARY_ARRAY_SEARCH_P(schema->classes_by_lDAPDisplayName,
+                              schema->num_classes, lDAPDisplayName, name, strcasecmp, c);
         return c;
 }
@@ -162 +163 @@
         struct dsdb_class *c;
         if (!name) return NULL;
-        BINARY_ARRAY_SEARCH(schema->classes_by_lDAPDisplayName, 
-                            schema->num_classes, lDAPDisplayName, name, strcasecmp_with_ldb_val, c);
+        BINARY_ARRAY_SEARCH_P(schema->classes_by_lDAPDisplayName,
+                              schema->num_classes, lDAPDisplayName, name, strcasecmp_with_ldb_val, c);
         return c;
 }
@@ -172 +173 @@
         struct dsdb_class *c;
         if (!cn) return NULL;
-        BINARY_ARRAY_SEARCH(schema->classes_by_cn, 
-                            schema->num_classes, cn, cn, strcasecmp, c);
+        BINARY_ARRAY_SEARCH_P(schema->classes_by_cn,
+                              schema->num_classes, cn, cn, strcasecmp, c);
         return c;
 }
@@ -182 +183 @@
         struct dsdb_class *c;
         if (!cn) return NULL;
-        BINARY_ARRAY_SEARCH(schema->classes_by_cn, 
-                            schema->num_classes, cn, cn, strcasecmp_with_ldb_val, c);
+        BINARY_ARRAY_SEARCH_P(schema->classes_by_cn,
+                              schema->num_classes, cn, cn, strcasecmp_with_ldb_val, c);
         return c;
 }
@@ -217 +218 @@
         const char **attr_list = NULL;
         struct dsdb_attribute *cur;
-        int i = 0;
+        unsigned int i = 0;
         for (cur = schema->attributes; cur; cur = cur->next) {
                 if (cur->linkID == 0) continue;
@@ -237 +238 @@
 {
         const char **ret_attrs;
-        int i;
+        unsigned int i;
         size_t new_len, orig_len = str_list_length(attrs);
         if (!new_attrs) {
@@ -337 +338 @@
                                                       enum dsdb_attr_list_query query)
 {
-        int i;
+        unsigned int i;
         const char **attr_list = NULL;
 
@@ -364 +365 @@
                                                          enum dsdb_attr_list_query query)
 {
-        int i;
+        unsigned int i;
         const char **attr_list = NULL;
 
@@ -378 +379 @@
 }
 
+static int qsort_string(const char **s1, const char **s2)
+{
+        return strcasecmp(*s1, *s2);
+}
+
 /* Helper function to remove duplicates from the attribute list to be returned */
 static const char **dedup_attr_list(const char **attr_list) 
@@ -384 +390 @@
         /* Remove duplicates */
         if (new_len > 1) {
-                int i;
-                qsort(attr_list, new_len,
-                      sizeof(*attr_list),
-                      (comparison_fn_t)strcasecmp);
-                
-                for (i=1 ; i < new_len; i++) {
+                size_t i;
+                TYPESAFE_QSORT(attr_list, new_len, qsort_string);
+                
+                for (i=1; i < new_len; i++) {
                         const char **val1 = &attr_list[i-1];
                         const char **val2 = &attr_list[i];
                         if (ldb_attr_cmp(*val1, *val2) == 0) {
                                 memmove(val1, val2, (new_len - i) * sizeof( *attr_list)); 
+                                attr_list[new_len-1] = NULL;
                                 new_len--;
                                 i--;
@@ -420 +425 @@
 /* Return the schemaIDGUID of a class */
 
-const struct GUID * class_schemaid_guid_by_lDAPDisplayName(const struct dsdb_schema *schema,
-                                                           const char *name)
+const struct GUID *class_schemaid_guid_by_lDAPDisplayName(const struct dsdb_schema *schema,
+                                                          const char *name)
 {
         const struct dsdb_class *object_class = dsdb_class_by_lDAPDisplayName(schema, name);
@@ -429 +434 @@
         return &object_class->schemaIDGUID;
 }
+
+const struct GUID *attribute_schemaid_guid_by_lDAPDisplayName(const struct dsdb_schema *schema,
+                                                              const char *name)
+{
+        const struct dsdb_attribute *attr = dsdb_attribute_by_lDAPDisplayName(schema, name);
+        if (!attr)
+                return NULL;
+
+        return &attr->schemaIDGUID;
+}

vendor/current/source4/dsdb/schema/schema_set.c

@@ -1 @@
-/* 
-   Unix SMB/CIFS mplementation.
+/*
+   Unix SMB/CIFS implementation.
    DSDB schema header
-   
+
    Copyright (C) Stefan Metzmacher <metze@samba.org> 2006-2007
    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006-2008
@@ -10 +10 @@
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-   
+
 */
 
@@ -24 +24 @@
 #include "lib/util/dlinklist.h"
 #include "dsdb/samdb/samdb.h"
-#include "lib/ldb/include/ldb_module.h"
+#include <ldb_module.h>
 #include "param/param.h"
+#include "librpc/ndr/libndr.h"
+#include "librpc/gen_ndr/ndr_misc.h"
+#include "lib/util/tsort.h"
 
 /*
   override the name to attribute handler function
  */
-const struct ldb_schema_attribute *dsdb_attribute_handler_override(struct ldb_context *ldb, 
+const struct ldb_schema_attribute *dsdb_attribute_handler_override(struct ldb_context *ldb,
                                                                    void *private_data,
                                                                    const char *name)
@@ -63 +66 @@
         mem_ctx = talloc_new(ldb);
         if (!mem_ctx) {
-                return LDB_ERR_OPERATIONS_ERROR;
+                return ldb_oom(ldb);
         }
 
@@ -81 +84 @@
                 goto op_error;
         }
-        msg_idx->dn = ldb_dn_new(msg, ldb, "@INDEXLIST");
+        msg_idx->dn = ldb_dn_new(msg_idx, ldb, "@INDEXLIST");
         if (!msg_idx->dn) {
                 ldb_oom(ldb);
@@ -94 +97 @@
         for (attr = schema->attributes; attr; attr = attr->next) {
                 const char *syntax = attr->syntax->ldb_syntax;
-                
+
                 if (!syntax) {
                         syntax = attr->syntax->ldap_oid;
                 }
 
-                /* Write out a rough approximation of the schema as an @ATTRIBUTES value, for bootstrapping */
+                /*
+                 * Write out a rough approximation of the schema
+                 * as an @ATTRIBUTES value, for bootstrapping
+                 */
                 if (strcmp(syntax, LDB_SYNTAX_INTEGER) == 0) {
                         ret = ldb_msg_add_string(msg, attr->lDAPDisplayName, "INTEGER");
                 } else if (strcmp(syntax, LDB_SYNTAX_DIRECTORY_STRING) == 0) {
                         ret = ldb_msg_add_string(msg, attr->lDAPDisplayName, "CASE_INSENSITIVE");
-                } 
+                }
                 if (ret != LDB_SUCCESS) {
                         break;
@@ -122 +128 @@
         }
 
-        /* Try to avoid churning the attributes too much - we only want to do this if they have changed */
-        ret = ldb_search(ldb, mem_ctx, &res, msg->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg->dn));
+        /*
+         * Try to avoid churning the attributes too much,
+         * we only want to do this if they have changed
+         */
+        ret = ldb_search(ldb, mem_ctx, &res, msg->dn, LDB_SCOPE_BASE, NULL,
+                         NULL);
         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
                 ret = ldb_add(ldb, msg);
@@ -133 +143 @@
                 /* Annoyingly added to our search results */
                 ldb_msg_remove_attr(res->msgs[0], "distinguishedName");
-                
-                mod_msg = ldb_msg_diff(ldb, res->msgs[0], msg);
+
+                ret = ldb_msg_difference(ldb, mem_ctx,
+                                         res->msgs[0], msg, &mod_msg);
+                if (ret != LDB_SUCCESS) {
+                        goto op_error;
+                }
                 if (mod_msg->num_elements > 0) {
-                        ret = samdb_replace(ldb, mem_ctx, mod_msg);
-                }
-        }
-
-        if (ret == LDB_ERR_OPERATIONS_ERROR || ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS) {
-                /* We might be on a read-only DB */
+                        ret = dsdb_replace(ldb, mod_msg, 0);
+                }
+                talloc_free(mod_msg);
+        }
+
+        if (ret == LDB_ERR_OPERATIONS_ERROR || ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS || ret == LDB_ERR_INVALID_DN_SYNTAX) {
+                /* We might be on a read-only DB or LDAP */
                 ret = LDB_SUCCESS;
         }
@@ -149 +164 @@
         }
 
-        /* Now write out the indexs, as found in the schema (if they have changed) */
-
-        ret = ldb_search(ldb, mem_ctx, &res_idx, msg_idx->dn, LDB_SCOPE_BASE, NULL, "dn=%s", ldb_dn_get_linearized(msg_idx->dn));
+        /* Now write out the indexes, as found in the schema (if they have changed) */
+
+        ret = ldb_search(ldb, mem_ctx, &res_idx, msg_idx->dn, LDB_SCOPE_BASE,
+                         NULL, NULL);
         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
                 ret = ldb_add(ldb, msg_idx);
@@ -162 +178 @@
                 ldb_msg_remove_attr(res_idx->msgs[0], "distinguishedName");
 
-                mod_msg = ldb_msg_diff(ldb, res_idx->msgs[0], msg_idx);
+                ret = ldb_msg_difference(ldb, mem_ctx,
+                                         res_idx->msgs[0], msg_idx, &mod_msg);
+                if (ret != LDB_SUCCESS) {
+                        goto op_error;
+                }
                 if (mod_msg->num_elements > 0) {
-                        ret = samdb_replace(ldb, mem_ctx, mod_msg);
-                }
-        }
-        if (ret == LDB_ERR_OPERATIONS_ERROR || ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS) {
+                        ret = dsdb_replace(ldb, mod_msg, 0);
+                }
+                talloc_free(mod_msg);
+        }
+        if (ret == LDB_ERR_OPERATIONS_ERROR || ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS || ret == LDB_ERR_INVALID_DN_SYNTAX) {
                 /* We might be on a read-only DB */
                 ret = LDB_SUCCESS;
@@ -176 +197 @@
 op_error:
         talloc_free(mem_ctx);
-        return LDB_ERR_OPERATIONS_ERROR;
+        return ldb_operr(ldb);
+}
+
+static int uint32_cmp(uint32_t c1, uint32_t c2)
+{
+        if (c1 == c2) return 0;
+        return c1 > c2 ? 1 : -1;
 }
 
@@ -185 +212 @@
 static int dsdb_compare_class_by_governsID_id(struct dsdb_class **c1, struct dsdb_class **c2)
 {
-        return (*c1)->governsID_id - (*c2)->governsID_id;
+        return uint32_cmp((*c1)->governsID_id, (*c2)->governsID_id);
 }
 static int dsdb_compare_class_by_governsID_oid(struct dsdb_class **c1, struct dsdb_class **c2)
@@ -202 +229 @@
 static int dsdb_compare_attribute_by_attributeID_id(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
 {
-        return (*a1)->attributeID_id - (*a2)->attributeID_id;
+        return uint32_cmp((*a1)->attributeID_id, (*a2)->attributeID_id);
+}
+static int dsdb_compare_attribute_by_msDS_IntId(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
+{
+        return uint32_cmp((*a1)->msDS_IntId, (*a2)->msDS_IntId);
 }
 static int dsdb_compare_attribute_by_attributeID_oid(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
@@ -210 +241 @@
 static int dsdb_compare_attribute_by_linkID(struct dsdb_attribute **a1, struct dsdb_attribute **a2)
 {
-        return (*a1)->linkID - (*a2)->linkID;
+        return uint32_cmp((*a1)->linkID, (*a2)->linkID);
+}
+
+/**
+ * Clean up Classes and Attributes accessor arrays
+ */
+static void dsdb_sorted_accessors_free(struct dsdb_schema *schema)
+{
+        /* free classes accessors */
+        TALLOC_FREE(schema->classes_by_lDAPDisplayName);
+        TALLOC_FREE(schema->classes_by_governsID_id);
+        TALLOC_FREE(schema->classes_by_governsID_oid);
+        TALLOC_FREE(schema->classes_by_cn);
+        /* free attribute accessors */
+        TALLOC_FREE(schema->attributes_by_lDAPDisplayName);
+        TALLOC_FREE(schema->attributes_by_attributeID_id);
+        TALLOC_FREE(schema->attributes_by_msDS_IntId);
+        TALLOC_FREE(schema->attributes_by_attributeID_oid);
+        TALLOC_FREE(schema->attributes_by_linkID);
 }
 
@@ -216 +265 @@
   create the sorted accessor arrays for the schema
  */
-static int dsdb_setup_sorted_accessors(struct ldb_context *ldb,
-                                       struct dsdb_schema *schema)
+int dsdb_setup_sorted_accessors(struct ldb_context *ldb,
+                                struct dsdb_schema *schema)
 {
         struct dsdb_class *cur;
         struct dsdb_attribute *a;
-        uint32_t i;
-
-        talloc_free(schema->classes_by_lDAPDisplayName);
-        talloc_free(schema->classes_by_governsID_id);
-        talloc_free(schema->classes_by_governsID_oid);
-        talloc_free(schema->classes_by_cn);
+        unsigned int i;
+        unsigned int num_int_id;
+
+        /* free all caches */
+        dsdb_sorted_accessors_free(schema);
 
         /* count the classes */
@@ -252 +300 @@
 
         /* sort the arrays */
-        qsort(schema->classes_by_lDAPDisplayName, schema->num_classes, 
-              sizeof(struct dsdb_class *), QSORT_CAST dsdb_compare_class_by_lDAPDisplayName);
-        qsort(schema->classes_by_governsID_id, schema->num_classes, 
-              sizeof(struct dsdb_class *), QSORT_CAST dsdb_compare_class_by_governsID_id);
-        qsort(schema->classes_by_governsID_oid, schema->num_classes, 
-              sizeof(struct dsdb_class *), QSORT_CAST dsdb_compare_class_by_governsID_oid);
-        qsort(schema->classes_by_cn, schema->num_classes, 
-              sizeof(struct dsdb_class *), QSORT_CAST dsdb_compare_class_by_cn);
+        TYPESAFE_QSORT(schema->classes_by_lDAPDisplayName, schema->num_classes, dsdb_compare_class_by_lDAPDisplayName);
+        TYPESAFE_QSORT(schema->classes_by_governsID_id, schema->num_classes, dsdb_compare_class_by_governsID_id);
+        TYPESAFE_QSORT(schema->classes_by_governsID_oid, schema->num_classes, dsdb_compare_class_by_governsID_oid);
+        TYPESAFE_QSORT(schema->classes_by_cn, schema->num_classes, dsdb_compare_class_by_cn);
 
         /* now build the attribute accessor arrays */
-        talloc_free(schema->attributes_by_lDAPDisplayName);
-        talloc_free(schema->attributes_by_attributeID_id);
-        talloc_free(schema->attributes_by_attributeID_oid);
-        talloc_free(schema->attributes_by_linkID);
-
-        /* count the attributes */
-        for (i=0, a=schema->attributes; a; i++, a=a->next) /* noop */ ;
+
+        /* count the attributes
+         * and attributes with msDS-IntId set */
+        num_int_id = 0;
+        for (i=0, a=schema->attributes; a; i++, a=a->next) {
+                if (a->msDS_IntId != 0) {
+                        num_int_id++;
+                }
+        }
         schema->num_attributes = i;
+        schema->num_int_id_attr = num_int_id;
 
         /* setup attributes_by_* */
         schema->attributes_by_lDAPDisplayName = talloc_array(schema, struct dsdb_attribute *, i);
         schema->attributes_by_attributeID_id    = talloc_array(schema, struct dsdb_attribute *, i);
+        schema->attributes_by_msDS_IntId        = talloc_array(schema,
+                                                               struct dsdb_attribute *, num_int_id);
         schema->attributes_by_attributeID_oid   = talloc_array(schema, struct dsdb_attribute *, i);
         schema->attributes_by_linkID              = talloc_array(schema, struct dsdb_attribute *, i);
         if (schema->attributes_by_lDAPDisplayName == NULL ||
             schema->attributes_by_attributeID_id == NULL ||
+            schema->attributes_by_msDS_IntId == NULL ||
             schema->attributes_by_attributeID_oid == NULL ||
             schema->attributes_by_linkID == NULL) {
@@ -283 +333 @@
         }
 
+        num_int_id = 0;
         for (i=0, a=schema->attributes; a; i++, a=a->next) {
                 schema->attributes_by_lDAPDisplayName[i] = a;
@@ -288 +339 @@
                 schema->attributes_by_attributeID_oid[i]   = a;
                 schema->attributes_by_linkID[i]          = a;
-        }
+                /* append attr-by-msDS-IntId values */
+                if (a->msDS_IntId != 0) {
+                        schema->attributes_by_msDS_IntId[num_int_id] = a;
+                        num_int_id++;
+                }
+        }
+        SMB_ASSERT(num_int_id == schema->num_int_id_attr);
 
         /* sort the arrays */
-        qsort(schema->attributes_by_lDAPDisplayName, schema->num_attributes, 
-              sizeof(struct dsdb_attribute *), QSORT_CAST dsdb_compare_attribute_by_lDAPDisplayName);
-        qsort(schema->attributes_by_attributeID_id, schema->num_attributes, 
-              sizeof(struct dsdb_attribute *), QSORT_CAST dsdb_compare_attribute_by_attributeID_id);
-        qsort(schema->attributes_by_attributeID_oid, schema->num_attributes, 
-              sizeof(struct dsdb_attribute *), QSORT_CAST dsdb_compare_attribute_by_attributeID_oid);
-        qsort(schema->attributes_by_linkID, schema->num_attributes, 
-              sizeof(struct dsdb_attribute *), QSORT_CAST dsdb_compare_attribute_by_linkID);
+        TYPESAFE_QSORT(schema->attributes_by_lDAPDisplayName, schema->num_attributes, dsdb_compare_attribute_by_lDAPDisplayName);
+        TYPESAFE_QSORT(schema->attributes_by_attributeID_id, schema->num_attributes, dsdb_compare_attribute_by_attributeID_id);
+        TYPESAFE_QSORT(schema->attributes_by_msDS_IntId, schema->num_int_id_attr, dsdb_compare_attribute_by_msDS_IntId);
+        TYPESAFE_QSORT(schema->attributes_by_attributeID_oid, schema->num_attributes, dsdb_compare_attribute_by_attributeID_oid);
+        TYPESAFE_QSORT(schema->attributes_by_linkID, schema->num_attributes, dsdb_compare_attribute_by_linkID);
 
         return LDB_SUCCESS;
 
 failed:
-        schema->classes_by_lDAPDisplayName = NULL;
-        schema->classes_by_governsID_id = NULL;
-        schema->classes_by_governsID_oid = NULL;
-        schema->classes_by_cn = NULL;
-        schema->attributes_by_lDAPDisplayName = NULL;
-        schema->attributes_by_attributeID_id = NULL;
-        schema->attributes_by_attributeID_oid = NULL;
-        schema->attributes_by_linkID = NULL;
-        ldb_oom(ldb);
-        return LDB_ERR_OPERATIONS_ERROR;
+        dsdb_sorted_accessors_free(schema);
+        return ldb_oom(ldb);
 }
 
@@ -327 +373 @@
          * objectClass lists efficiently) */
 
-        /* Walk the list of scheam classes */
-        
+        /* Walk the list of schema classes */
+
         /*  Create a 'total possible superiors' on each class */
         return LDB_SUCCESS;
@@ -334 +380 @@
 
 /**
- * Attach the schema to an opaque pointer on the ldb, so ldb modules
- * can find it 
- */
-
+ * Attach the schema to an opaque pointer on the ldb,
+ * so ldb modules can find it
+ */
 int dsdb_set_schema(struct ldb_context *ldb, struct dsdb_schema *schema)
 {
+        struct dsdb_schema *old_schema;
         int ret;
 
@@ -347 +393 @@
         }
 
-        schema_fill_constructed(schema);
+        ret = schema_fill_constructed(schema);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+
+        old_schema = ldb_get_opaque(ldb, "dsdb_schema");
 
         ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+
+        /* Remove the reference to the schema we just overwrote - if there was
+         * none, NULL is harmless here */
+        if (old_schema != schema) {
+                talloc_unlink(ldb, old_schema);
+                talloc_steal(ldb, schema);
+        }
+
+        ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", NULL);
         if (ret != LDB_SUCCESS) {
                 return ret;
@@ -360 +423 @@
         }
 
-        talloc_steal(ldb, schema);
-
         return LDB_SUCCESS;
 }
@@ -377 +438 @@
 {
         int ret;
+        struct dsdb_schema *old_schema;
+        old_schema = ldb_get_opaque(ldb, "dsdb_schema");
         ret = ldb_set_opaque(ldb, "dsdb_schema", schema);
         if (ret != LDB_SUCCESS) {
@@ -382 +445 @@
         }
 
-        /* Set the new attributes based on the new schema */
+        /* Remove the reference to the schema we just overwrote - if there was
+         * none, NULL is harmless here */
+        talloc_unlink(ldb, old_schema);
+
+        if (talloc_reference(ldb, schema) == NULL) {
+                return ldb_oom(ldb);
+        }
+
+        /* Make this ldb use local schema preferably */
+        ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", NULL);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+
         ret = dsdb_schema_set_attributes(ldb, schema, write_attributes);
         if (ret != LDB_SUCCESS) {
@@ -388 +464 @@
         }
 
-        /* Keep a reference to this schema, just incase the original copy is replaced */
-        if (talloc_reference(ldb, schema) == NULL) {
-                return LDB_ERR_OPERATIONS_ERROR;
-        }
-
         return LDB_SUCCESS;
 }
@@ -401 +472 @@
 int dsdb_set_global_schema(struct ldb_context *ldb)
 {
+        int ret;
+        void *use_global_schema = (void *)1;
         if (!global_schema) {
                 return LDB_SUCCESS;
         }
-
-        return dsdb_reference_schema(ldb, global_schema, false /* Don't write attributes, it's expensive */);
+        ret = ldb_set_opaque(ldb, "dsdb_use_global_schema", use_global_schema);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+
+        /* Set the new attributes based on the new schema */
+        ret = dsdb_schema_set_attributes(ldb, global_schema, false /* Don't write attributes, it's expensive */);
+        if (ret == LDB_SUCCESS) {
+                /* Keep a reference to this schema, just in case the original copy is replaced */
+                if (talloc_reference(ldb, global_schema) == NULL) {
+                        return ldb_oom(ldb);
+                }
+        }
+
+        return ret;
+}
+
+bool dsdb_uses_global_schema(struct ldb_context *ldb)
+{
+        return (ldb_get_opaque(ldb, "dsdb_use_global_schema") != NULL);
 }
 
 /**
  * Find the schema object for this ldb
- */
-
-struct dsdb_schema *dsdb_get_schema(struct ldb_context *ldb)
+ *
+ * If reference_ctx is not NULL, then talloc_reference onto that context
+ */
+
+struct dsdb_schema *dsdb_get_schema(struct ldb_context *ldb, TALLOC_CTX *reference_ctx)
 {
         const void *p;
-        struct dsdb_schema *schema;
+        struct dsdb_schema *schema_out;
+        struct dsdb_schema *schema_in;
+        bool use_global_schema;
+        TALLOC_CTX *tmp_ctx = talloc_new(reference_ctx);
+        if (!tmp_ctx) {
+                return NULL;
+        }
 
         /* see if we have a cached copy */
-        p = ldb_get_opaque(ldb, "dsdb_schema");
-        if (!p) {
-                return NULL;
-        }
-
-        schema = talloc_get_type(p, struct dsdb_schema);
-        if (!schema) {
-                return NULL;
-        }
-
-        return schema;
+        use_global_schema = dsdb_uses_global_schema(ldb);
+        if (use_global_schema) {
+                schema_in = global_schema;
+        } else {
+                p = ldb_get_opaque(ldb, "dsdb_schema");
+
+                schema_in = talloc_get_type(p, struct dsdb_schema);
+                if (!schema_in) {
+                        talloc_free(tmp_ctx);
+                        return NULL;
+                }
+        }
+
+        if (schema_in->refresh_fn && !schema_in->refresh_in_progress) {
+                if (!talloc_reference(tmp_ctx, schema_in)) {
+                        /*
+                         * ensure that the schema_in->refresh_in_progress
+                         * remains valid for the right amount of time
+                         */
+                        talloc_free(tmp_ctx);
+                        return NULL;
+                }
+                schema_in->refresh_in_progress = true;
+                /* This may change schema, if it needs to reload it from disk */
+                schema_out = schema_in->refresh_fn(schema_in->loaded_from_module,
+                                                   schema_in,
+                                                   use_global_schema);
+                schema_in->refresh_in_progress = false;
+        } else {
+                schema_out = schema_in;
+        }
+
+        /* This removes the extra reference above */
+        talloc_free(tmp_ctx);
+        if (!reference_ctx) {
+                return schema_out;
+        } else {
+                return talloc_reference(reference_ctx, schema_out);
+        }
 }
 
@@ -435 +562 @@
  */
 
-void dsdb_make_schema_global(struct ldb_context *ldb)
-{
-        struct dsdb_schema *schema = dsdb_get_schema(ldb);
+void dsdb_make_schema_global(struct ldb_context *ldb, struct dsdb_schema *schema)
+{
         if (!schema) {
                 return;
@@ -447 +573 @@
 
         /* we want the schema to be around permanently */
-        talloc_reparent(talloc_parent(schema), talloc_autofree_context(), schema);
-
+        talloc_reparent(ldb, talloc_autofree_context(), schema);
         global_schema = schema;
 
+        /* This calls the talloc_reference() of the global schema back onto the ldb */
         dsdb_set_global_schema(ldb);
 }
 
+/**
+ * When loading the schema from LDIF files, we don't get the extended DNs.
+ *
+ * We need to set these up, so that from the moment we start the provision,
+ * the defaultObjectCategory links are set up correctly.
+ */
+int dsdb_schema_fill_extended_dn(struct ldb_context *ldb, struct dsdb_schema *schema)
+{
+        struct dsdb_class *cur;
+        const struct dsdb_class *target_class;
+        for (cur = schema->classes; cur; cur = cur->next) {
+                const struct ldb_val *rdn;
+                struct ldb_val guid;
+                NTSTATUS status;
+                struct ldb_dn *dn = ldb_dn_new(NULL, ldb, cur->defaultObjectCategory);
+
+                if (!dn) {
+                        return LDB_ERR_INVALID_DN_SYNTAX;
+                }
+                rdn = ldb_dn_get_component_val(dn, 0);
+                if (!rdn) {
+                        talloc_free(dn);
+                        return LDB_ERR_INVALID_DN_SYNTAX;
+                }
+                target_class = dsdb_class_by_cn_ldb_val(schema, rdn);
+                if (!target_class) {
+                        talloc_free(dn);
+                        return LDB_ERR_CONSTRAINT_VIOLATION;
+                }
+
+                status = GUID_to_ndr_blob(&target_class->objectGUID, dn, &guid);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(dn);
+                        return ldb_operr(ldb);
+                }
+                ldb_dn_set_extended_component(dn, "GUID", &guid);
+
+                cur->defaultObjectCategory = ldb_dn_get_extended_linearized(cur, dn, 1);
+                talloc_free(dn);
+        }
+        return LDB_SUCCESS;
+}
+
+/**
+ * Add an element to the schema (attribute or class) from an LDB message
+ */
+WERROR dsdb_schema_set_el_from_ldb_msg(struct ldb_context *ldb, struct dsdb_schema *schema,
+                                       struct ldb_message *msg)
+{
+        if (samdb_find_attribute(ldb, msg,
+                                 "objectclass", "attributeSchema") != NULL) {
+                return dsdb_attribute_from_ldb(ldb, schema, msg);
+        } else if (samdb_find_attribute(ldb, msg,
+                                 "objectclass", "classSchema") != NULL) {
+                return dsdb_class_from_ldb(schema, msg);
+        }
+
+        /* Don't fail on things not classes or attributes */
+        return WERR_OK;
+}
 
 /**
@@ -473 +659 @@
         struct ldb_val info_val_default;
 
+
         mem_ctx = talloc_new(ldb);
         if (!mem_ctx) {
@@ -478 +665 @@
         }
 
-        schema = dsdb_new_schema(mem_ctx, lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")));
+        schema = dsdb_new_schema(mem_ctx);
 
         schema->fsmo.we_are_master = true;
@@ -496 +683 @@
         talloc_steal(mem_ctx, ldif);
 
-        msg = ldb_msg_canonicalize(ldb, ldif->msg);
-        if (!msg) {
+        ret = ldb_msg_normalize(ldb, mem_ctx, ldif->msg, &msg);
+        if (ret != LDB_SUCCESS) {
                 goto nomem;
         }
-        talloc_steal(mem_ctx, msg);
         talloc_free(ldif);
 
@@ -511 +697 @@
         info_val = ldb_msg_find_ldb_val(msg, "schemaInfo");
         if (!info_val) {
-                info_val_default = strhex_to_data_blob(mem_ctx, "FF0000000000000000000000000000000000000000");
-                if (!info_val_default.data) {
-                        goto nomem;
-                }
+                status = dsdb_schema_info_blob_new(mem_ctx, &info_val_default);
+                W_ERROR_NOT_OK_GOTO(status, failed);
                 info_val = &info_val_default;
         }
@@ -520 +704 @@
         status = dsdb_load_oid_mappings_ldb(schema, prefix_val, info_val);
         if (!W_ERROR_IS_OK(status)) {
+                DEBUG(0,("ERROR: dsdb_load_oid_mappings_ldb() failed with %s\n", win_errstr(status)));
                 goto failed;
         }
 
-        /*
-         * load the attribute and class definitions outof df
-         */
+        /* load the attribute and class definitions out of df */
         while ((ldif = ldb_ldif_read_string(ldb, &df))) {
-                bool is_sa;
-                bool is_sc;
-
                 talloc_steal(mem_ctx, ldif);
 
-                msg = ldb_msg_canonicalize(ldb, ldif->msg);
-                if (!msg) {
+                ret = ldb_msg_normalize(ldb, ldif, ldif->msg, &msg);
+                if (ret != LDB_SUCCESS) {
                         goto nomem;
                 }
 
-                talloc_steal(mem_ctx, msg);
+                status = dsdb_schema_set_el_from_ldb_msg(ldb, schema, msg);
                 talloc_free(ldif);
-
-                is_sa = ldb_msg_check_string_attribute(msg, "objectClass", "attributeSchema");
-                is_sc = ldb_msg_check_string_attribute(msg, "objectClass", "classSchema");
-
-                if (is_sa) {
-                        struct dsdb_attribute *sa;
-
-                        sa = talloc_zero(schema, struct dsdb_attribute);
-                        if (!sa) {
-                                goto nomem;
-                        }
-
-                        status = dsdb_attribute_from_ldb(ldb, schema, msg, sa, sa);
-                        if (!W_ERROR_IS_OK(status)) {
-                                goto failed;
-                        }
-
-                        DLIST_ADD(schema->attributes, sa);
-                } else if (is_sc) {
-                        struct dsdb_class *sc;
-
-                        sc = talloc_zero(schema, struct dsdb_class);
-                        if (!sc) {
-                                goto nomem;
-                        }
-
-                        status = dsdb_class_from_ldb(schema, msg, sc, sc);
-                        if (!W_ERROR_IS_OK(status)) {
-                                goto failed;
-                        }
-
-                        DLIST_ADD(schema->classes, sc);
+                if (!W_ERROR_IS_OK(status)) {
+                        goto failed;
                 }
         }
 
         ret = dsdb_set_schema(ldb, schema);
+        if (ret != LDB_SUCCESS) {
+                status = WERR_FOOBAR;
+                goto failed;
+        }
+
+        ret = dsdb_schema_fill_extended_dn(ldb, schema);
         if (ret != LDB_SUCCESS) {
                 status = WERR_FOOBAR;

vendor/current/source4/dsdb/schema/schema_syntax.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS mplementation.
    DSDB schema syntaxes
-   
+
    Copyright (C) Stefan Metzmacher <metze@samba.org> 2006
    Copyright (C) Simo Sorce 2005
@@ -11 +11 @@
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-   
+
 */
 #include "includes.h"
@@ -26 +26 @@
 #include "librpc/gen_ndr/ndr_security.h"
 #include "librpc/gen_ndr/ndr_misc.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "system/time.h"
 #include "../lib/util/charset/charset.h"
 #include "librpc/ndr/libndr.h"
-
-static WERROR dsdb_syntax_FOOBAR_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                const struct dsdb_schema *schema,
+#include "../lib/util/asn1.h"
+
+/**
+ * Initialize dsdb_syntax_ctx with default values
+ * for common cases.
+ */
+void dsdb_syntax_ctx_init(struct dsdb_syntax_ctx *ctx,
+                          struct ldb_context *ldb,
+                          const struct dsdb_schema *schema)
+{
+        ctx->ldb        = ldb;
+        ctx->schema     = schema;
+
+        /*
+         * 'true' will keep current behavior,
+         * i.e. attributeID_id will be returned by default
+         */
+        ctx->is_schema_nc = true;
+
+        ctx->pfm_remote = NULL;
+}
+
+
+/**
+ * Returns ATTID for DRS attribute.
+ *
+ * ATTID depends on whether we are replicating
+ * Schema NC or msDs-IntId is set for schemaAttribute
+ * for the attribute.
+ */
+uint32_t dsdb_attribute_get_attid(const struct dsdb_attribute *attr,
+                                  bool for_schema_nc)
+{
+        if (!for_schema_nc && attr->msDS_IntId) {
+                return attr->msDS_IntId;
+        }
+
+        return attr->attributeID_id;
+}
+
+/**
+ * Map an ATTID from remote DC to a local ATTID
+ * using remote prefixMap
+ */
+static bool dsdb_syntax_attid_from_remote_attid(const struct dsdb_syntax_ctx *ctx,
+                                                TALLOC_CTX *mem_ctx,
+                                                uint32_t id_remote,
+                                                uint32_t *id_local)
+{
+        WERROR werr;
+        const char *oid;
+
+        /*
+         * map remote ATTID to local directly in case
+         * of no remote prefixMap (during provision for instance)
+         */
+        if (!ctx->pfm_remote) {
+                *id_local = id_remote;
+                return true;
+        }
+
+        werr = dsdb_schema_pfm_oid_from_attid(ctx->pfm_remote, id_remote, mem_ctx, &oid);
+        if (!W_ERROR_IS_OK(werr)) {
+                DEBUG(0,("ATTID->OID failed (%s) for: 0x%08X\n", win_errstr(werr), id_remote));
+                return false;
+        }
+
+        werr = dsdb_schema_pfm_make_attid(ctx->schema->prefixmap, oid, id_local);
+        if (!W_ERROR_IS_OK(werr)) {
+                DEBUG(0,("OID->ATTID failed (%s) for: %s\n", win_errstr(werr), oid));
+                return false;
+        }
+
+        return true;
+}
+
+static WERROR dsdb_syntax_FOOBAR_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                 const struct dsdb_attribute *attr,
                                                 const struct drsuapi_DsReplicaAttribute *in,
@@ -39 +113 @@
                                                 struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
 
         out->flags      = 0;
@@ -66 +140 @@
 }
 
-static WERROR dsdb_syntax_FOOBAR_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                                const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_FOOBAR_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                                 const struct dsdb_attribute *attr,
                                                 const struct ldb_message_element *in,
@@ -76 +149 @@
 }
 
-static WERROR dsdb_syntax_BOOL_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                              const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_FOOBAR_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                              const struct dsdb_attribute *attr,
+                                              const struct ldb_message_element *in)
+{
+        return WERR_FOOBAR;
+}
+
+static WERROR dsdb_syntax_BOOL_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                               const struct dsdb_attribute *attr,
                                               const struct drsuapi_DsReplicaAttribute *in,
@@ -83 +162 @@
                                               struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
 
         out->flags      = 0;
@@ -121 +200 @@
 }
 
-static WERROR dsdb_syntax_BOOL_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                              const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_BOOL_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                               const struct dsdb_attribute *attr,
                                               const struct ldb_message_element *in,
@@ -128 +206 @@
                                               struct drsuapi_DsReplicaAttribute *out)
 {
-        uint32_t i;
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -163 +242 @@
 }
 
-static WERROR dsdb_syntax_INT32_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                               const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_BOOL_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                            const struct dsdb_attribute *attr,
+                                            const struct ldb_message_element *in)
+{
+        unsigned int i;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                int t, f;
+
+                t = strncmp("TRUE",
+                            (const char *)in->values[i].data,
+                            in->values[i].length);
+                f = strncmp("FALSE",
+                            (const char *)in->values[i].data,
+                            in->values[i].length);
+
+                if (t != 0 && f != 0) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_INT32_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                const struct dsdb_attribute *attr,
                                                const struct drsuapi_DsReplicaAttribute *in,
@@ -170 +276 @@
                                                struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
 
         out->flags      = 0;
@@ -203 +309 @@
 }
 
-static WERROR dsdb_syntax_INT32_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                               const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_INT32_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                                const struct dsdb_attribute *attr,
                                                const struct ldb_message_element *in,
@@ -210 +315 @@
                                                struct drsuapi_DsReplicaAttribute *out)
 {
-        uint32_t i;
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -245 +351 @@
 }
 
-static WERROR dsdb_syntax_INT64_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                               const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_INT32_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                             const struct dsdb_attribute *attr,
+                                             const struct ldb_message_element *in)
+{
+        unsigned int i;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                long v;
+                char buf[sizeof("-2147483648")];
+                char *end = NULL;
+
+                ZERO_STRUCT(buf);
+                if (in->values[i].length >= sizeof(buf)) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                memcpy(buf, in->values[i].data, in->values[i].length);
+                errno = 0;
+                v = strtol(buf, &end, 10);
+                if (errno != 0) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+                if (end && end[0] != '\0') {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                if (attr->rangeLower) {
+                        if ((int32_t)v < (int32_t)*attr->rangeLower) {
+                                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                        }
+                }
+
+                if (attr->rangeUpper) {
+                        if ((int32_t)v > (int32_t)*attr->rangeUpper) {
+                                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                        }
+                }
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_INT64_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                const struct dsdb_attribute *attr,
                                                const struct drsuapi_DsReplicaAttribute *in,
@@ -252 +403 @@
                                                struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
 
         out->flags      = 0;
@@ -285 +436 @@
 }
 
-static WERROR dsdb_syntax_INT64_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                               const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_INT64_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                                const struct dsdb_attribute *attr,
                                                const struct ldb_message_element *in,
@@ -292 +442 @@
                                                struct drsuapi_DsReplicaAttribute *out)
 {
-        uint32_t i;
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -325 +476 @@
 }
 
-static WERROR dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                    const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_INT64_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                             const struct dsdb_attribute *attr,
+                                             const struct ldb_message_element *in)
+{
+        unsigned int i;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                long long v;
+                char buf[sizeof("-9223372036854775808")];
+                char *end = NULL;
+
+                ZERO_STRUCT(buf);
+                if (in->values[i].length >= sizeof(buf)) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+                memcpy(buf, in->values[i].data, in->values[i].length);
+
+                errno = 0;
+                v = strtoll(buf, &end, 10);
+                if (errno != 0) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+                if (end && end[0] != '\0') {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                if (attr->rangeLower) {
+                        if ((int64_t)v < (int64_t)*attr->rangeLower) {
+                                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                        }
+                }
+
+                if (attr->rangeUpper) {
+                        if ((int64_t)v > (int64_t)*attr->rangeUpper) {
+                                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                        }
+                }
+        }
+
+        return WERR_OK;
+}
+static WERROR dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                     const struct dsdb_attribute *attr,
                                                     const struct drsuapi_DsReplicaAttribute *in,
@@ -332 +527 @@
                                                     struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
 
         out->flags      = 0;
@@ -359 +554 @@
                 t = nt_time_to_unix(v);
 
-                /* 
+                /*
                  * NOTE: On a w2k3 server you can set a GeneralizedTime string
                  *       via LDAP, but you get back an UTCTime string,
@@ -368 +563 @@
                  *       we'll loose information!
                  */
-                str = ldb_timestring_utc(out->values, t); 
+                str = ldb_timestring_utc(out->values, t);
                 W_ERROR_HAVE_NO_MEMORY(str);
                 out->values[i] = data_blob_string_const(str);
@@ -376 +571 @@
 }
 
-static WERROR dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                                    const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                                     const struct dsdb_attribute *attr,
                                                     const struct ldb_message_element *in,
@@ -383 +577 @@
                                                     struct drsuapi_DsReplicaAttribute *out)
 {
-        uint32_t i;
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -419 +614 @@
 }
 
-static WERROR dsdb_syntax_NTTIME_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_NTTIME_UTC_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                                  const struct dsdb_attribute *attr,
+                                                  const struct ldb_message_element *in)
+{
+        unsigned int i;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                time_t t;
+                char buf[sizeof("090826075717Z")];
+
+                ZERO_STRUCT(buf);
+                if (in->values[i].length >= sizeof(buf)) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+                memcpy(buf, in->values[i].data, in->values[i].length);
+
+                errno = 0;
+                t = ldb_string_utc_to_time(buf);
+                if (errno != 0) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                if (attr->rangeLower) {
+                        if ((int32_t)t < (int32_t)*attr->rangeLower) {
+                                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                        }
+                }
+
+                if (attr->rangeUpper) {
+                        if ((int32_t)t > (int32_t)*attr->rangeLower) {
+                                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                        }
+                }
+
+                /*
+                 * TODO: verify the comment in the
+                 * dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb() function!
+                 */
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_NTTIME_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                 const struct dsdb_attribute *attr,
                                                 const struct drsuapi_DsReplicaAttribute *in,
@@ -426 +667 @@
                                                 struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
 
         out->flags      = 0;
@@ -453 +694 @@
                 t = nt_time_to_unix(v);
 
-                str = ldb_timestring(out->values, t); 
+                str = ldb_timestring(out->values, t);
                 W_ERROR_HAVE_NO_MEMORY(str);
 
@@ -462 +703 @@
 }
 
-static WERROR dsdb_syntax_NTTIME_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                                const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_NTTIME_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                                 const struct dsdb_attribute *attr,
                                                 const struct ldb_message_element *in,
@@ -469 +709 @@
                                                 struct drsuapi_DsReplicaAttribute *out)
 {
-        uint32_t i;
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -489 +730 @@
                 NTTIME v;
                 time_t t;
+                int ret;
 
                 out->value_ctr.values[i].blob   = &blobs[i];
@@ -495 +737 @@
                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 
-                t = ldb_string_to_time((const char *)in->values[i].data);
+                ret = ldb_val_to_time(&in->values[i], &t);
+                if (ret != LDB_SUCCESS) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
                 unix_to_nt_time(&v, t);
                 v /= 10000000;
@@ -505 +750 @@
 }
 
-static WERROR dsdb_syntax_DATA_BLOB_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                   const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_NTTIME_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                              const struct dsdb_attribute *attr,
+                                              const struct ldb_message_element *in)
+{
+        unsigned int i;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                time_t t;
+                int ret;
+
+                ret = ldb_val_to_time(&in->values[i], &t);
+                if (ret != LDB_SUCCESS) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                if (attr->rangeLower) {
+                        if ((int32_t)t < (int32_t)*attr->rangeLower) {
+                                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                        }
+                }
+
+                if (attr->rangeUpper) {
+                        if ((int32_t)t > (int32_t)*attr->rangeLower) {
+                                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                        }
+                }
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_DATA_BLOB_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                    const struct dsdb_attribute *attr,
                                                    const struct drsuapi_DsReplicaAttribute *in,
@@ -512 +791 @@
                                                    struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
 
         out->flags      = 0;
@@ -539 +818 @@
 }
 
-static WERROR dsdb_syntax_DATA_BLOB_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                                   const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_DATA_BLOB_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                                    const struct dsdb_attribute *attr,
                                                    const struct ldb_message_element *in,
@@ -546 +824 @@
                                                    struct drsuapi_DsReplicaAttribute *out)
 {
-        uint32_t i;
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -573 +852 @@
 }
 
-static WERROR _dsdb_syntax_OID_obj_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                  const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_DATA_BLOB_validate_one_val(const struct dsdb_syntax_ctx *ctx,
+                                                     const struct dsdb_attribute *attr,
+                                                     const struct ldb_val *val)
+{
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        if (attr->rangeLower) {
+                if ((uint32_t)val->length < (uint32_t)*attr->rangeLower) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+        }
+
+        if (attr->rangeUpper) {
+                if ((uint32_t)val->length > (uint32_t)*attr->rangeUpper) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_DATA_BLOB_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                                 const struct dsdb_attribute *attr,
+                                                 const struct ldb_message_element *in)
+{
+        unsigned int i;
+        WERROR status;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                if (in->values[i].length == 0) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                status = dsdb_syntax_DATA_BLOB_validate_one_val(ctx,
+                                                                attr,
+                                                                &in->values[i]);
+                if (!W_ERROR_IS_OK(status)) {
+                        return status;
+                }
+        }
+
+        return WERR_OK;
+}
+
+static WERROR _dsdb_syntax_auto_OID_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
+                                                   const struct dsdb_attribute *attr,
+                                                   const struct drsuapi_DsReplicaAttribute *in,
+                                                   TALLOC_CTX *mem_ctx,
+                                                   struct ldb_message_element *out)
+{
+        unsigned int i;
+
+        out->flags      = 0;
+        out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
+        W_ERROR_HAVE_NO_MEMORY(out->name);
+
+        out->num_values = in->value_ctr.num_values;
+        out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
+        W_ERROR_HAVE_NO_MEMORY(out->values);
+
+        for (i=0; i < out->num_values; i++) {
+                uint32_t v;
+                const struct dsdb_class *c;
+                const struct dsdb_attribute *a;
+                const char *str = NULL;
+
+                if (in->value_ctr.values[i].blob == NULL) {
+                        return WERR_FOOBAR;
+                }
+
+                if (in->value_ctr.values[i].blob->length != 4) {
+                        return WERR_FOOBAR;
+                }
+
+                v = IVAL(in->value_ctr.values[i].blob->data, 0);
+
+                if ((c = dsdb_class_by_governsID_id(ctx->schema, v))) {
+                        str = talloc_strdup(out->values, c->lDAPDisplayName);
+                } else if ((a = dsdb_attribute_by_attributeID_id(ctx->schema, v))) {
+                        str = talloc_strdup(out->values, a->lDAPDisplayName);
+                } else {
+                        WERROR werr;
+                        SMB_ASSERT(ctx->pfm_remote);
+                        werr = dsdb_schema_pfm_oid_from_attid(ctx->pfm_remote, v,
+                                                              out->values, &str);
+                        W_ERROR_NOT_OK_RETURN(werr);
+                }
+                W_ERROR_HAVE_NO_MEMORY(str);
+
+                /* the values need to be reversed */
+                out->values[out->num_values - (i + 1)] = data_blob_string_const(str);
+        }
+
+        return WERR_OK;
+}
+
+static WERROR _dsdb_syntax_OID_obj_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                   const struct dsdb_attribute *attr,
                                                   const struct drsuapi_DsReplicaAttribute *in,
@@ -580 +960 @@
                                                   struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
 
         out->flags      = 0;
@@ -605 +985 @@
                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 
-                c = dsdb_class_by_governsID_id(schema, v);
+                /* convert remote ATTID to local ATTID */
+                if (!dsdb_syntax_attid_from_remote_attid(ctx, mem_ctx, v, &v)) {
+                        DEBUG(1,(__location__ ": Failed to map remote ATTID to local ATTID!\n"));
+                        return WERR_FOOBAR;
+                }
+
+                c = dsdb_class_by_governsID_id(ctx->schema, v);
                 if (!c) {
+                        DEBUG(1,(__location__ ": Unknown governsID 0x%08X\n", v));
                         return WERR_FOOBAR;
                 }
@@ -620 +1007 @@
 }
 
-static WERROR _dsdb_syntax_OID_attr_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                   const struct dsdb_schema *schema,
+static WERROR _dsdb_syntax_OID_attr_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                    const struct dsdb_attribute *attr,
                                                    const struct drsuapi_DsReplicaAttribute *in,
@@ -627 +1013 @@
                                                    struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
 
         out->flags      = 0;
@@ -652 +1038 @@
                 v = IVAL(in->value_ctr.values[i].blob->data, 0);
 
-                a = dsdb_attribute_by_attributeID_id(schema, v);
+                /* convert remote ATTID to local ATTID */
+                if (!dsdb_syntax_attid_from_remote_attid(ctx, mem_ctx, v, &v)) {
+                        DEBUG(1,(__location__ ": Failed to map remote ATTID to local ATTID!\n"));
+                        return WERR_FOOBAR;
+                }
+
+                a = dsdb_attribute_by_attributeID_id(ctx->schema, v);
                 if (!a) {
+                        DEBUG(1,(__location__ ": Unknown attributeID_id 0x%08X\n", v));
                         return WERR_FOOBAR;
                 }
@@ -667 +1060 @@
 }
 
-static WERROR _dsdb_syntax_OID_oid_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                  const struct dsdb_schema *schema,
+static WERROR _dsdb_syntax_OID_oid_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                   const struct dsdb_attribute *attr,
                                                   const struct drsuapi_DsReplicaAttribute *in,
@@ -674 +1066 @@
                                                   struct ldb_message_element *out)
 {
-        uint32_t i;
+        unsigned int i;
+
+        SMB_ASSERT(ctx->pfm_remote);
 
         out->flags      = 0;
@@ -685 +1079 @@
 
         for (i=0; i < out->num_values; i++) {
-                uint32_t v;
+                uint32_t attid;
                 WERROR status;
-                const char *str;
+                const char *oid;
 
                 if (in->value_ctr.values[i].blob == NULL) {
@@ -697 +1091 @@
                 }
 
-                v = IVAL(in->value_ctr.values[i].blob->data, 0);
-
-                status = dsdb_map_int2oid(schema, v, out->values, &str);
-                W_ERROR_NOT_OK_RETURN(status);
-
-                out->values[i] = data_blob_string_const(str);
-        }
-
-        return WERR_OK;
-}
-
-static WERROR _dsdb_syntax_OID_obj_ldb_to_drsuapi(struct ldb_context *ldb,
-                                                  const struct dsdb_schema *schema,
-                                                  const struct dsdb_attribute *attr,
-                                                  const struct ldb_message_element *in,
-                                                  TALLOC_CTX *mem_ctx,
-                                                  struct drsuapi_DsReplicaAttribute *out)
-{
-        uint32_t i;
+                attid = IVAL(in->value_ctr.values[i].blob->data, 0);
+
+                status = dsdb_schema_pfm_oid_from_attid(ctx->pfm_remote, attid,
+                                                        out->values, &oid);
+                if (!W_ERROR_IS_OK(status)) {
+                        DEBUG(0,(__location__ ": Error: Unknown ATTID 0x%08X\n",
+                                 attid));
+                        return status;
+                }
+
+                out->values[i] = data_blob_string_const(oid);
+        }
+
+        return WERR_OK;
+}
+
+static WERROR _dsdb_syntax_auto_OID_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
+                                                   const struct dsdb_attribute *attr,
+                                                   const struct ldb_message_element *in,
+                                                   TALLOC_CTX *mem_ctx,
+                                                   struct drsuapi_DsReplicaAttribute *out)
+{
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        out->attid= attr->attributeID_id;
+        out->attid= dsdb_attribute_get_attid(attr,
+                                             ctx->is_schema_nc);
         out->value_ctr.num_values= in->num_values;
         out->value_ctr.values= talloc_array(mem_ctx,
@@ -730 +1129 @@
         for (i=0; i < in->num_values; i++) {
                 const struct dsdb_class *obj_class;
+                const struct dsdb_attribute *obj_attr;
+                struct ldb_val *v;
 
                 out->value_ctr.values[i].blob= &blobs[i];
@@ -736 +1137 @@
                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 
-                obj_class = dsdb_class_by_lDAPDisplayName(schema, (const char *)in->values[i].data);
-                if (!obj_class) {
-                        return WERR_FOOBAR;
-                }
-                SIVAL(blobs[i].data, 0, obj_class->governsID_id);
+                /* in DRS windows puts the classes in the opposite
+                   order to the order used in ldap */
+                v = &in->values[(in->num_values-1)-i];
+
+                if ((obj_class = dsdb_class_by_lDAPDisplayName_ldb_val(ctx->schema, v))) {
+                        SIVAL(blobs[i].data, 0, obj_class->governsID_id);
+                } else if ((obj_attr = dsdb_attribute_by_lDAPDisplayName_ldb_val(ctx->schema, v))) {
+                        SIVAL(blobs[i].data, 0, obj_attr->attributeID_id);
+                } else {
+                        uint32_t attid;
+                        WERROR werr;
+                        werr = dsdb_schema_pfm_attid_from_oid(ctx->schema->prefixmap,
+                                                              (const char *)v->data,
+                                                              &attid);
+                        W_ERROR_NOT_OK_RETURN(werr);
+                        SIVAL(blobs[i].data, 0, attid);
+                }
+
         }
 
@@ -747 +1161 @@
 }
 
-static WERROR _dsdb_syntax_OID_attr_ldb_to_drsuapi(struct ldb_context *ldb,
-                                                   const struct dsdb_schema *schema,
-                                                   const struct dsdb_attribute *attr,
-                                                   const struct ldb_message_element *in,
-                                                   TALLOC_CTX *mem_ctx,
-                                                   struct drsuapi_DsReplicaAttribute *out)
-{
-        uint32_t i;
+static WERROR _dsdb_syntax_OID_obj_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
+                                                  const struct dsdb_attribute *attr,
+                                                  const struct ldb_message_element *in,
+                                                  TALLOC_CTX *mem_ctx,
+                                                  struct drsuapi_DsReplicaAttribute *out)
+{
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        out->attid= attr->attributeID_id;
+        out->attid= dsdb_attribute_get_attid(attr,
+                                             ctx->is_schema_nc);
         out->value_ctr.num_values= in->num_values;
         out->value_ctr.values= talloc_array(mem_ctx,
@@ -768 +1182 @@
 
         for (i=0; i < in->num_values; i++) {
-                const struct dsdb_attribute *obj_attr;
+                const struct dsdb_class *obj_class;
 
                 out->value_ctr.values[i].blob= &blobs[i];
@@ -775 +1189 @@
                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 
-                obj_attr = dsdb_attribute_by_lDAPDisplayName(schema, (const char *)in->values[i].data);
+                /* in DRS windows puts the classes in the opposite
+                   order to the order used in ldap */
+                obj_class = dsdb_class_by_lDAPDisplayName(ctx->schema,
+                                                          (const char *)in->values[(in->num_values-1)-i].data);
+                if (!obj_class) {
+                        return WERR_FOOBAR;
+                }
+                SIVAL(blobs[i].data, 0, obj_class->governsID_id);
+        }
+
+
+        return WERR_OK;
+}
+
+static WERROR _dsdb_syntax_OID_attr_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
+                                                   const struct dsdb_attribute *attr,
+                                                   const struct ldb_message_element *in,
+                                                   TALLOC_CTX *mem_ctx,
+                                                   struct drsuapi_DsReplicaAttribute *out)
+{
+        unsigned int i;
+        DATA_BLOB *blobs;
+
+        out->attid= dsdb_attribute_get_attid(attr,
+                                             ctx->is_schema_nc);
+        out->value_ctr.num_values= in->num_values;
+        out->value_ctr.values= talloc_array(mem_ctx,
+                                            struct drsuapi_DsAttributeValue,
+                                            in->num_values);
+        W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
+
+        blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
+        W_ERROR_HAVE_NO_MEMORY(blobs);
+
+        for (i=0; i < in->num_values; i++) {
+                const struct dsdb_attribute *obj_attr;
+
+                out->value_ctr.values[i].blob= &blobs[i];
+
+                blobs[i] = data_blob_talloc(blobs, NULL, 4);
+                W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
+
+                obj_attr = dsdb_attribute_by_lDAPDisplayName(ctx->schema, (const char *)in->values[i].data);
                 if (!obj_attr) {
                         return WERR_FOOBAR;
@@ -786 +1242 @@
 }
 
-static WERROR _dsdb_syntax_OID_oid_ldb_to_drsuapi(struct ldb_context *ldb,
-                                                  const struct dsdb_schema *schema,
+static WERROR _dsdb_syntax_OID_oid_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                                   const struct dsdb_attribute *attr,
                                                   const struct ldb_message_element *in,
@@ -793 +1248 @@
                                                   struct drsuapi_DsReplicaAttribute *out)
 {
-        uint32_t i;
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        out->attid= attr->attributeID_id;
+        out->attid= dsdb_attribute_get_attid(attr,
+                                             ctx->is_schema_nc);
         out->value_ctr.num_values= in->num_values;
         out->value_ctr.values= talloc_array(mem_ctx,
@@ -807 +1263 @@
 
         for (i=0; i < in->num_values; i++) {
-                uint32_t v;
+                uint32_t attid;
                 WERROR status;
 
@@ -815 +1271 @@
                 W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
 
-                status = dsdb_map_oid2int(schema,
-                                          (const char *)in->values[i].data,
-                                          &v);
+                status = dsdb_schema_pfm_attid_from_oid(ctx->schema->prefixmap,
+                                                        (const char *)in->values[i].data,
+                                                        &attid);
                 W_ERROR_NOT_OK_RETURN(status);
 
-                SIVAL(blobs[i].data, 0, v);
-        }
-
-        return WERR_OK;
-}
-
-static WERROR dsdb_syntax_OID_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                             const struct dsdb_schema *schema,
+                SIVAL(blobs[i].data, 0, attid);
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_OID_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                              const struct dsdb_attribute *attr,
                                              const struct drsuapi_DsReplicaAttribute *in,
@@ -833 +1288 @@
                                              struct ldb_message_element *out)
 {
-        uint32_t i;
+        WERROR werr;
 
         switch (attr->attributeID_id) {
-        case DRSUAPI_ATTRIBUTE_objectClass:
-        case DRSUAPI_ATTRIBUTE_subClassOf:
-        case DRSUAPI_ATTRIBUTE_auxiliaryClass:
-        case DRSUAPI_ATTRIBUTE_systemPossSuperiors:
-        case DRSUAPI_ATTRIBUTE_possSuperiors:
-                return _dsdb_syntax_OID_obj_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out);
-        case DRSUAPI_ATTRIBUTE_systemMustContain:
-        case DRSUAPI_ATTRIBUTE_systemMayContain:        
-        case DRSUAPI_ATTRIBUTE_mustContain:
-        case DRSUAPI_ATTRIBUTE_mayContain:
-                return _dsdb_syntax_OID_attr_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out);
-        case DRSUAPI_ATTRIBUTE_governsID:
-        case DRSUAPI_ATTRIBUTE_attributeID:
-        case DRSUAPI_ATTRIBUTE_attributeSyntax:
-                return _dsdb_syntax_OID_oid_drsuapi_to_ldb(ldb, schema, attr, in, mem_ctx, out);
-        }
-
-        out->flags      = 0;
-        out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
-        W_ERROR_HAVE_NO_MEMORY(out->name);
-
-        out->num_values = in->value_ctr.num_values;
-        out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
-        W_ERROR_HAVE_NO_MEMORY(out->values);
-
-        for (i=0; i < out->num_values; i++) {
-                uint32_t v;
-                const char *name;
-                char *str;
-
-                if (in->value_ctr.values[i].blob == NULL) {
-                        return WERR_FOOBAR;
-                }
-
-                if (in->value_ctr.values[i].blob->length != 4) {
-                        return WERR_FOOBAR;
-                }
-
-                v = IVAL(in->value_ctr.values[i].blob->data, 0);
-
-                name = dsdb_lDAPDisplayName_by_id(schema, v);
-                if (!name) {
-                        return WERR_FOOBAR;
-                }
-
-                str = talloc_strdup(out->values, name);
-                W_ERROR_HAVE_NO_MEMORY(str);
-
-                out->values[i] = data_blob_string_const(str);
-        }
-
-        return WERR_OK;
-}
-
-static WERROR dsdb_syntax_OID_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                             const struct dsdb_schema *schema,
+        case DRSUAPI_ATTID_objectClass:
+        case DRSUAPI_ATTID_subClassOf:
+        case DRSUAPI_ATTID_auxiliaryClass:
+        case DRSUAPI_ATTID_systemAuxiliaryClass:
+        case DRSUAPI_ATTID_systemPossSuperiors:
+        case DRSUAPI_ATTID_possSuperiors:
+                werr = _dsdb_syntax_OID_obj_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out);
+                break;
+        case DRSUAPI_ATTID_systemMustContain:
+        case DRSUAPI_ATTID_systemMayContain:
+        case DRSUAPI_ATTID_mustContain:
+        case DRSUAPI_ATTID_rDNAttId:
+        case DRSUAPI_ATTID_transportAddressAttribute:
+        case DRSUAPI_ATTID_mayContain:
+                werr = _dsdb_syntax_OID_attr_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out);
+                break;
+        case DRSUAPI_ATTID_governsID:
+        case DRSUAPI_ATTID_attributeID:
+        case DRSUAPI_ATTID_attributeSyntax:
+                werr = _dsdb_syntax_OID_oid_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out);
+                break;
+        default:
+                DEBUG(0,(__location__ ": Unknown handling for attributeID_id for %s\n",
+                         attr->lDAPDisplayName));
+                return _dsdb_syntax_auto_OID_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out);
+        }
+
+        /* When we are doing the vampire of a schema, we don't want
+         * the inability to reference an OID to get in the way.
+         * Otherwise, we won't get the new schema with which to
+         * understand this */
+        if (!W_ERROR_IS_OK(werr) && ctx->schema->relax_OID_conversions) {
+                return _dsdb_syntax_OID_oid_drsuapi_to_ldb(ctx, attr, in, mem_ctx, out);
+        }
+        return werr;
+}
+
+static WERROR dsdb_syntax_OID_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                              const struct dsdb_attribute *attr,
                                              const struct ldb_message_element *in,
@@ -897 +1334 @@
                                              struct drsuapi_DsReplicaAttribute *out)
 {
-        uint32_t i;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        switch (attr->attributeID_id) {
+        case DRSUAPI_ATTID_objectClass:
+        case DRSUAPI_ATTID_subClassOf:
+        case DRSUAPI_ATTID_auxiliaryClass:
+        case DRSUAPI_ATTID_systemAuxiliaryClass:
+        case DRSUAPI_ATTID_systemPossSuperiors:
+        case DRSUAPI_ATTID_possSuperiors:
+                return _dsdb_syntax_OID_obj_ldb_to_drsuapi(ctx, attr, in, mem_ctx, out);
+        case DRSUAPI_ATTID_systemMustContain:
+        case DRSUAPI_ATTID_systemMayContain:
+        case DRSUAPI_ATTID_mustContain:
+        case DRSUAPI_ATTID_rDNAttId:
+        case DRSUAPI_ATTID_transportAddressAttribute:
+        case DRSUAPI_ATTID_mayContain:
+                return _dsdb_syntax_OID_attr_ldb_to_drsuapi(ctx, attr, in, mem_ctx, out);
+        case DRSUAPI_ATTID_governsID:
+        case DRSUAPI_ATTID_attributeID:
+        case DRSUAPI_ATTID_attributeSyntax:
+                return _dsdb_syntax_OID_oid_ldb_to_drsuapi(ctx, attr, in, mem_ctx, out);
+        }
+
+        DEBUG(0,(__location__ ": Unknown handling for attributeID_id for %s\n",
+                 attr->lDAPDisplayName));
+
+        return _dsdb_syntax_auto_OID_ldb_to_drsuapi(ctx, attr, in, mem_ctx, out);
+}
+
+static WERROR _dsdb_syntax_OID_validate_numericoid(const struct dsdb_syntax_ctx *ctx,
+                                                   const struct dsdb_attribute *attr,
+                                                   const struct ldb_message_element *in)
+{
+        unsigned int i;
+        TALLOC_CTX *tmp_ctx;
+
+        tmp_ctx = talloc_new(ctx->ldb);
+        W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+        for (i=0; i < in->num_values; i++) {
+                DATA_BLOB blob;
+                char *oid_out;
+                const char *oid = (const char*)in->values[i].data;
+
+                if (!ber_write_OID_String(tmp_ctx, &blob, oid)) {
+                        DEBUG(0,("ber_write_OID_String() failed for %s\n", oid));
+                        talloc_free(tmp_ctx);
+                        return WERR_INVALID_PARAMETER;
+                }
+
+                if (!ber_read_OID_String(tmp_ctx, blob, &oid_out)) {
+                        DEBUG(0,("ber_read_OID_String() failed for %s\n",
+                                 hex_encode_talloc(tmp_ctx, blob.data, blob.length)));
+                        talloc_free(tmp_ctx);
+                        return WERR_INVALID_PARAMETER;
+                }
+
+                if (strcmp(oid, oid_out) != 0) {
+                        talloc_free(tmp_ctx);
+                        return WERR_INVALID_PARAMETER;
+                }
+        }
+
+        talloc_free(tmp_ctx);
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_OID_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                           const struct dsdb_attribute *attr,
+                                           const struct ldb_message_element *in)
+{
+        WERROR status;
+        struct drsuapi_DsReplicaAttribute drs_tmp;
+        struct ldb_message_element ldb_tmp;
+        TALLOC_CTX *tmp_ctx;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        switch (attr->attributeID_id) {
+        case DRSUAPI_ATTID_governsID:
+        case DRSUAPI_ATTID_attributeID:
+        case DRSUAPI_ATTID_attributeSyntax:
+                return _dsdb_syntax_OID_validate_numericoid(ctx, attr, in);
+        }
+
+        /*
+         * TODO: optimize and verify this code
+         */
+
+        tmp_ctx = talloc_new(ctx->ldb);
+        W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+        status = dsdb_syntax_OID_ldb_to_drsuapi(ctx,
+                                                attr,
+                                                in,
+                                                tmp_ctx,
+                                                &drs_tmp);
+        if (!W_ERROR_IS_OK(status)) {
+                talloc_free(tmp_ctx);
+                return status;
+        }
+
+        status = dsdb_syntax_OID_drsuapi_to_ldb(ctx,
+                                                attr,
+                                                &drs_tmp,
+                                                tmp_ctx,
+                                                &ldb_tmp);
+        if (!W_ERROR_IS_OK(status)) {
+                talloc_free(tmp_ctx);
+                return status;
+        }
+
+        talloc_free(tmp_ctx);
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_UNICODE_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
+                                                 const struct dsdb_attribute *attr,
+                                                 const struct drsuapi_DsReplicaAttribute *in,
+                                                 TALLOC_CTX *mem_ctx,
+                                                 struct ldb_message_element *out)
+{
+        unsigned int i;
+
+        out->flags      = 0;
+        out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
+        W_ERROR_HAVE_NO_MEMORY(out->name);
+
+        out->num_values = in->value_ctr.num_values;
+        out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
+        W_ERROR_HAVE_NO_MEMORY(out->values);
+
+        for (i=0; i < out->num_values; i++) {
+                char *str;
+
+                if (in->value_ctr.values[i].blob == NULL) {
+                        return WERR_FOOBAR;
+                }
+
+                if (in->value_ctr.values[i].blob->length == 0) {
+                        return WERR_FOOBAR;
+                }
+
+                if (!convert_string_talloc(out->values,
+                                           CH_UTF16, CH_UNIX,
+                                           in->value_ctr.values[i].blob->data,
+                                           in->value_ctr.values[i].blob->length,
+                                           (void **)&str, NULL, false)) {
+                        return WERR_FOOBAR;
+                }
+
+                out->values[i] = data_blob_string_const(str);
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_UNICODE_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
+                                                 const struct dsdb_attribute *attr,
+                                                 const struct ldb_message_element *in,
+                                                 TALLOC_CTX *mem_ctx,
+                                                 struct drsuapi_DsReplicaAttribute *out)
+{
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        switch (attr->attributeID_id) {
-        case DRSUAPI_ATTRIBUTE_objectClass:
-        case DRSUAPI_ATTRIBUTE_subClassOf:
-        case DRSUAPI_ATTRIBUTE_auxiliaryClass:
-        case DRSUAPI_ATTRIBUTE_systemPossSuperiors:
-        case DRSUAPI_ATTRIBUTE_possSuperiors:
-                return _dsdb_syntax_OID_obj_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out);
-        case DRSUAPI_ATTRIBUTE_systemMustContain:
-        case DRSUAPI_ATTRIBUTE_systemMayContain:        
-        case DRSUAPI_ATTRIBUTE_mustContain:
-        case DRSUAPI_ATTRIBUTE_mayContain:
-                return _dsdb_syntax_OID_attr_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out);
-        case DRSUAPI_ATTRIBUTE_governsID:
-        case DRSUAPI_ATTRIBUTE_attributeID:
-        case DRSUAPI_ATTRIBUTE_attributeSyntax:
-                return _dsdb_syntax_OID_oid_ldb_to_drsuapi(ldb, schema, attr, in, mem_ctx, out);
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -933 +1520 @@
 
         for (i=0; i < in->num_values; i++) {
-                uint32_t v;
-
                 out->value_ctr.values[i].blob   = &blobs[i];
 
-                blobs[i] = data_blob_talloc(blobs, NULL, 4);
-                W_ERROR_HAVE_NO_MEMORY(blobs[i].data);
-
-                v = strtol((const char *)in->values[i].data, NULL, 10);
-
-                SIVAL(blobs[i].data, 0, v);
-        }
-
-        return WERR_OK;
-}
-
-static WERROR dsdb_syntax_UNICODE_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                 const struct dsdb_schema *schema,
-                                                 const struct dsdb_attribute *attr,
-                                                 const struct drsuapi_DsReplicaAttribute *in,
-                                                 TALLOC_CTX *mem_ctx,
-                                                 struct ldb_message_element *out)
-{
-        uint32_t i;
+                if (!convert_string_talloc(blobs,
+                                           CH_UNIX, CH_UTF16,
+                                           in->values[i].data, in->values[i].length,
+                                           (void **)&blobs[i].data, &blobs[i].length, false)) {
+                        return WERR_FOOBAR;
+                }
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_UNICODE_validate_one_val(const struct dsdb_syntax_ctx *ctx,
+                                                   const struct dsdb_attribute *attr,
+                                                   const struct ldb_val *val)
+{
+        void *dst = NULL;
+        size_t size;
+        bool ok;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        ok = convert_string_talloc(ctx->ldb,
+                                   CH_UNIX, CH_UTF16,
+                                   val->data,
+                                   val->length,
+                                   (void **)&dst,
+                                   &size, false);
+        TALLOC_FREE(dst);
+        if (!ok) {
+                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+        }
+
+        if (attr->rangeLower) {
+                if ((size/2) < *attr->rangeLower) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+        }
+
+        if (attr->rangeUpper) {
+                if ((size/2) > *attr->rangeUpper) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_UNICODE_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                               const struct dsdb_attribute *attr,
+                                               const struct ldb_message_element *in)
+{
+        WERROR status;
+        unsigned int i;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                if (in->values[i].length == 0) {
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                status = dsdb_syntax_UNICODE_validate_one_val(ctx,
+                                                              attr,
+                                                              &in->values[i]);
+                if (!W_ERROR_IS_OK(status)) {
+                        return status;
+                }
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_one_DN_drsuapi_to_ldb(TALLOC_CTX *mem_ctx, struct ldb_context *ldb,
+                                                const struct dsdb_syntax *syntax,
+                                                const DATA_BLOB *in, DATA_BLOB *out)
+{
+        struct drsuapi_DsReplicaObjectIdentifier3 id3;
+        enum ndr_err_code ndr_err;
+        DATA_BLOB guid_blob;
+        struct ldb_dn *dn;
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+        int ret;
+        NTSTATUS status;
+
+        if (!tmp_ctx) {
+                W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+        }
+
+        if (in == NULL) {
+                talloc_free(tmp_ctx);
+                return WERR_FOOBAR;
+        }
+
+        if (in->length == 0) {
+                talloc_free(tmp_ctx);
+                return WERR_FOOBAR;
+        }
+
+
+        /* windows sometimes sends an extra two pad bytes here */
+        ndr_err = ndr_pull_struct_blob(in,
+                                       tmp_ctx, &id3,
+                                       (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                status = ndr_map_error2ntstatus(ndr_err);
+                talloc_free(tmp_ctx);
+                return ntstatus_to_werror(status);
+        }
+
+        dn = ldb_dn_new(tmp_ctx, ldb, id3.dn);
+        if (!dn) {
+                talloc_free(tmp_ctx);
+                /* If this fails, it must be out of memory, as it does not do much parsing */
+                W_ERROR_HAVE_NO_MEMORY(dn);
+        }
+
+        if (!GUID_all_zero(&id3.guid)) {
+                status = GUID_to_ndr_blob(&id3.guid, tmp_ctx, &guid_blob);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(tmp_ctx);
+                        return ntstatus_to_werror(status);
+                }
+
+                ret = ldb_dn_set_extended_component(dn, "GUID", &guid_blob);
+                if (ret != LDB_SUCCESS) {
+                        talloc_free(tmp_ctx);
+                        return WERR_FOOBAR;
+                }
+                talloc_free(guid_blob.data);
+        }
+
+        if (id3.__ndr_size_sid) {
+                DATA_BLOB sid_blob;
+                ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, &id3.sid,
+                                               (ndr_push_flags_fn_t)ndr_push_dom_sid);
+                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                        status = ndr_map_error2ntstatus(ndr_err);
+                        talloc_free(tmp_ctx);
+                        return ntstatus_to_werror(status);
+                }
+
+                ret = ldb_dn_set_extended_component(dn, "SID", &sid_blob);
+                if (ret != LDB_SUCCESS) {
+                        talloc_free(tmp_ctx);
+                        return WERR_FOOBAR;
+                }
+        }
+
+        *out = data_blob_string_const(ldb_dn_get_extended_linearized(mem_ctx, dn, 1));
+        talloc_free(tmp_ctx);
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_DN_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
+                                            const struct dsdb_attribute *attr,
+                                            const struct drsuapi_DsReplicaAttribute *in,
+                                            TALLOC_CTX *mem_ctx,
+                                            struct ldb_message_element *out)
+{
+        unsigned int i;
 
         out->flags      = 0;
@@ -966 +1696 @@
 
         for (i=0; i < out->num_values; i++) {
-                char *str;
-
-                if (in->value_ctr.values[i].blob == NULL) {
-                        return WERR_FOOBAR;
-                }
-
-                if (in->value_ctr.values[i].blob->length == 0) {
-                        return WERR_FOOBAR;
-                }
-
-                if (!convert_string_talloc_convenience(out->values, 
-                                                schema->iconv_convenience, 
-                                                                        CH_UTF16, CH_UNIX,
-                                            in->value_ctr.values[i].blob->data,
-                                            in->value_ctr.values[i].blob->length,
-                                            (void **)&str, NULL, false)) {
-                        return WERR_FOOBAR;
-                }
-
-                out->values[i] = data_blob_string_const(str);
-        }
-
-        return WERR_OK;
-}
-
-static WERROR dsdb_syntax_UNICODE_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                                 const struct dsdb_schema *schema,
-                                                 const struct dsdb_attribute *attr,
-                                                 const struct ldb_message_element *in,
-                                                 TALLOC_CTX *mem_ctx,
-                                                 struct drsuapi_DsReplicaAttribute *out)
-{
-        uint32_t i;
+                WERROR status = dsdb_syntax_one_DN_drsuapi_to_ldb(out->values, ctx->ldb, attr->syntax,
+                                                                  in->value_ctr.values[i].blob,
+                                                                  &out->values[i]);
+                if (!W_ERROR_IS_OK(status)) {
+                        return status;
+                }
+
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_DN_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
+                                            const struct dsdb_attribute *attr,
+                                            const struct ldb_message_element *in,
+                                            TALLOC_CTX *mem_ctx,
+                                            struct drsuapi_DsReplicaAttribute *out)
+{
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -1016 +1733 @@
 
         for (i=0; i < in->num_values; i++) {
+                struct drsuapi_DsReplicaObjectIdentifier3 id3;
+                enum ndr_err_code ndr_err;
+                struct ldb_dn *dn;
+                TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+                NTSTATUS status;
+
+                W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
                 out->value_ctr.values[i].blob   = &blobs[i];
 
-                if (!convert_string_talloc_convenience(blobs,
-                        schema->iconv_convenience, CH_UNIX, CH_UTF16,
-                        in->values[i].data, in->values[i].length,
-                        (void **)&blobs[i].data, &blobs[i].length, false)) {
-                                return WERR_FOOBAR;
-                }
-        }
-
-        return WERR_OK;
-}
-
-static WERROR dsdb_syntax_DN_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                            const struct dsdb_schema *schema,
-                                            const struct dsdb_attribute *attr,
-                                            const struct drsuapi_DsReplicaAttribute *in,
-                                            TALLOC_CTX *mem_ctx,
-                                            struct ldb_message_element *out)
-{
-        uint32_t i;
+                dn = ldb_dn_from_ldb_val(tmp_ctx, ctx->ldb, &in->values[i]);
+
+                W_ERROR_HAVE_NO_MEMORY(dn);
+
+                ZERO_STRUCT(id3);
+
+                status = dsdb_get_extended_dn_guid(dn, &id3.guid, "GUID");
+                if (!NT_STATUS_IS_OK(status) &&
+                    !NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                        talloc_free(tmp_ctx);
+                        return ntstatus_to_werror(status);
+                }
+
+                status = dsdb_get_extended_dn_sid(dn, &id3.sid, "SID");
+                if (!NT_STATUS_IS_OK(status) &&
+                    !NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                        talloc_free(tmp_ctx);
+                        return ntstatus_to_werror(status);
+                }
+
+                id3.dn = ldb_dn_get_linearized(dn);
+
+                ndr_err = ndr_push_struct_blob(&blobs[i], blobs, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                        status = ndr_map_error2ntstatus(ndr_err);
+                        talloc_free(tmp_ctx);
+                        return ntstatus_to_werror(status);
+                }
+                talloc_free(tmp_ctx);
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_DN_validate_one_val(const struct dsdb_syntax_ctx *ctx,
+                                              const struct dsdb_attribute *attr,
+                                              const struct ldb_val *val,
+                                              TALLOC_CTX *mem_ctx,
+                                              struct dsdb_dn **_dsdb_dn)
+{
+        static const char * const extended_list[] = { "GUID", "SID", NULL };
+        enum ndr_err_code ndr_err;
+        struct GUID guid;
+        struct dom_sid sid;
+        const DATA_BLOB *sid_blob;
+        struct dsdb_dn *dsdb_dn;
+        struct ldb_dn *dn;
+        char *dn_str;
+        struct ldb_dn *dn2;
+        char *dn2_str;
+        int num_components;
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+        NTSTATUS status;
+
+        W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        dsdb_dn = dsdb_dn_parse(tmp_ctx, ctx->ldb, val,
+                                attr->syntax->ldap_oid);
+        if (!dsdb_dn) {
+                talloc_free(tmp_ctx);
+                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        dn = dsdb_dn->dn;
+
+        dn2 = ldb_dn_copy(tmp_ctx, dn);
+        if (dn == NULL) {
+                talloc_free(tmp_ctx);
+                return WERR_NOMEM;
+        }
+
+        num_components = ldb_dn_get_comp_num(dn);
+
+        status = dsdb_get_extended_dn_guid(dn, &guid, "GUID");
+        if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                num_components++;
+        } else if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(tmp_ctx);
+                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+        }
+
+        sid_blob = ldb_dn_get_extended_component(dn, "SID");
+        if (sid_blob) {
+                num_components++;
+                ndr_err = ndr_pull_struct_blob_all(sid_blob,
+                                                   tmp_ctx,
+                                                   &sid,
+                                                   (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
+                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                        talloc_free(tmp_ctx);
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+        }
+
+        /* Do not allow links to the RootDSE */
+        if (num_components == 0) {
+                talloc_free(tmp_ctx);
+                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+        }
+
+        /*
+         * We need to check that only "GUID" and "SID" are
+         * specified as extended components, we do that
+         * by comparing the dn's after removing all components
+         * from one dn and only the allowed subset from the other
+         * one.
+         */
+        ldb_dn_extended_filter(dn, extended_list);
+
+        dn_str = ldb_dn_get_extended_linearized(tmp_ctx, dn, 0);
+        if (dn_str == NULL) {
+                talloc_free(tmp_ctx);
+                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        dn2_str = ldb_dn_get_extended_linearized(tmp_ctx, dn2, 0);
+        if (dn2_str == NULL) {
+                talloc_free(tmp_ctx);
+                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+        }
+
+        if (strcmp(dn_str, dn2_str) != 0) {
+                talloc_free(tmp_ctx);
+                return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+        }
+
+        *_dsdb_dn = talloc_move(mem_ctx, &dsdb_dn);
+        talloc_free(tmp_ctx);
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_DN_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                          const struct dsdb_attribute *attr,
+                                          const struct ldb_message_element *in)
+{
+        unsigned int i;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                WERROR status;
+                struct dsdb_dn *dsdb_dn;
+                TALLOC_CTX *tmp_ctx = talloc_new(ctx->ldb);
+                W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+                status = dsdb_syntax_DN_validate_one_val(ctx,
+                                                         attr,
+                                                         &in->values[i],
+                                                         tmp_ctx, &dsdb_dn);
+                if (!W_ERROR_IS_OK(status)) {
+                        talloc_free(tmp_ctx);
+                        return status;
+                }
+
+                if (dsdb_dn->dn_format != DSDB_NORMAL_DN) {
+                        talloc_free(tmp_ctx);
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                talloc_free(tmp_ctx);
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
+                                                   const struct dsdb_attribute *attr,
+                                                   const struct drsuapi_DsReplicaAttribute *in,
+                                                   TALLOC_CTX *mem_ctx,
+                                                   struct ldb_message_element *out)
+{
+        unsigned int i;
         int ret;
 
@@ -1048 +1930 @@
 
         for (i=0; i < out->num_values; i++) {
-                struct drsuapi_DsReplicaObjectIdentifier3 id3;
+                struct drsuapi_DsReplicaObjectIdentifier3Binary id3;
                 enum ndr_err_code ndr_err;
                 DATA_BLOB guid_blob;
                 struct ldb_dn *dn;
+                struct dsdb_dn *dsdb_dn;
+                NTSTATUS status;
                 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
                 if (!tmp_ctx) {
@@ -1067 +1951 @@
                 }
 
-                
+
                 /* windows sometimes sends an extra two pad bytes here */
                 ndr_err = ndr_pull_struct_blob(in->value_ctr.values[i].blob,
-                                               tmp_ctx, schema->iconv_convenience, &id3,
-                                               (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3);
+                                               tmp_ctx, &id3,
+                                               (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                        status = ndr_map_error2ntstatus(ndr_err);
                         talloc_free(tmp_ctx);
                         return ntstatus_to_werror(status);
                 }
 
-                dn = ldb_dn_new(tmp_ctx, ldb, id3.dn);
+                dn = ldb_dn_new(tmp_ctx, ctx->ldb, id3.dn);
                 if (!dn) {
                         talloc_free(tmp_ctx);
@@ -1085 +1969 @@
                 }
 
-                ndr_err = ndr_push_struct_blob(&guid_blob, tmp_ctx, schema->iconv_convenience, &id3.guid,
-                                               (ndr_push_flags_fn_t)ndr_push_GUID);
-                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                status = GUID_to_ndr_blob(&id3.guid, tmp_ctx, &guid_blob);
+                if (!NT_STATUS_IS_OK(status)) {
                         talloc_free(tmp_ctx);
                         return ntstatus_to_werror(status);
@@ -1103 +1985 @@
                 if (id3.__ndr_size_sid) {
                         DATA_BLOB sid_blob;
-                        ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, schema->iconv_convenience, &id3.sid,
+                        ndr_err = ndr_push_struct_blob(&sid_blob, tmp_ctx, &id3.sid,
                                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                                NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                                status = ndr_map_error2ntstatus(ndr_err);
                                 talloc_free(tmp_ctx);
                                 return ntstatus_to_werror(status);
@@ -1118 +2000 @@
                 }
 
-                out->values[i] = data_blob_string_const(ldb_dn_get_extended_linearized(out->values, dn, 1));
+                /* set binary stuff */
+                dsdb_dn = dsdb_dn_construct(tmp_ctx, dn, id3.binary, attr->syntax->ldap_oid);
+                if (!dsdb_dn) {
+                        /* If this fails, it must be out of memory, we know the ldap_oid is valid */
+                        talloc_free(tmp_ctx);
+                        W_ERROR_HAVE_NO_MEMORY(dsdb_dn);
+                }
+                out->values[i] = data_blob_string_const(dsdb_dn_get_extended_linearized(out->values, dsdb_dn, 1));
                 talloc_free(tmp_ctx);
         }
@@ -1125 +2014 @@
 }
 
-static WERROR dsdb_syntax_DN_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                            const struct dsdb_schema *schema,
-                                            const struct dsdb_attribute *attr,
-                                            const struct ldb_message_element *in,
-                                            TALLOC_CTX *mem_ctx,
-                                            struct drsuapi_DsReplicaAttribute *out)
-{
-        uint32_t i;
+static WERROR dsdb_syntax_DN_BINARY_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
+                                                   const struct dsdb_attribute *attr,
+                                                   const struct ldb_message_element *in,
+                                                   TALLOC_CTX *mem_ctx,
+                                                   struct drsuapi_DsReplicaAttribute *out)
+{
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -1150 +2039 @@
 
         for (i=0; i < in->num_values; i++) {
-                struct drsuapi_DsReplicaObjectIdentifier3 id3;
+                struct drsuapi_DsReplicaObjectIdentifier3Binary id3;
                 enum ndr_err_code ndr_err;
-                const DATA_BLOB *guid_blob, *sid_blob;
-                struct ldb_dn *dn;
+                const DATA_BLOB *sid_blob;
+                struct dsdb_dn *dsdb_dn;
                 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+                NTSTATUS status;
+
                 W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
 
                 out->value_ctr.values[i].blob   = &blobs[i];
 
-                dn = ldb_dn_from_ldb_val(tmp_ctx, ldb, &in->values[i]);
-
-                W_ERROR_HAVE_NO_MEMORY(dn);
-
-                guid_blob = ldb_dn_get_extended_component(dn, "GUID");
+                dsdb_dn = dsdb_dn_parse(tmp_ctx, ctx->ldb, &in->values[i], attr->syntax->ldap_oid);
+
+                if (!dsdb_dn) {
+                        talloc_free(tmp_ctx);
+                        return ntstatus_to_werror(NT_STATUS_INVALID_PARAMETER);
+                }
 
                 ZERO_STRUCT(id3);
 
-                if (guid_blob) {
-                        ndr_err = ndr_pull_struct_blob_all(guid_blob, 
-                                                           tmp_ctx, schema->iconv_convenience, &id3.guid,
-                                                           (ndr_pull_flags_fn_t)ndr_pull_GUID);
+                status = dsdb_get_extended_dn_guid(dsdb_dn->dn, &id3.guid, "GUID");
+                if (!NT_STATUS_IS_OK(status) &&
+                    !NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                        talloc_free(tmp_ctx);
+                        return ntstatus_to_werror(status);
+                }
+
+                sid_blob = ldb_dn_get_extended_component(dsdb_dn->dn, "SID");
+                if (sid_blob) {
+
+                        ndr_err = ndr_pull_struct_blob_all(sid_blob,
+                                                           tmp_ctx, &id3.sid,
+                                                           (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                                NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                                status = ndr_map_error2ntstatus(ndr_err);
                                 talloc_free(tmp_ctx);
                                 return ntstatus_to_werror(status);
@@ -1178 +2079 @@
                 }
 
-                sid_blob = ldb_dn_get_extended_component(dn, "SID");
-                if (sid_blob) {
-                        
-                        ndr_err = ndr_pull_struct_blob_all(sid_blob, 
-                                                           tmp_ctx, schema->iconv_convenience, &id3.sid,
-                                                           (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
-                        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                                NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
-                                talloc_free(tmp_ctx);
-                                return ntstatus_to_werror(status);
-                        }
-                }
-
-                id3.dn = ldb_dn_get_linearized(dn);
-
-                ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                id3.dn = ldb_dn_get_linearized(dsdb_dn->dn);
+
+                /* get binary stuff */
+                id3.binary = dsdb_dn->extra_part;
+
+                ndr_err = ndr_push_struct_blob(&blobs[i], blobs, &id3, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
+                        status = ndr_map_error2ntstatus(ndr_err);
                         talloc_free(tmp_ctx);
                         return ntstatus_to_werror(status);
@@ -1205 +2096 @@
 }
 
-static WERROR dsdb_syntax_DN_BINARY_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                   const struct dsdb_schema *schema,
+static WERROR dsdb_syntax_DN_BINARY_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                                 const struct dsdb_attribute *attr,
+                                                 const struct ldb_message_element *in)
+{
+        unsigned int i;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                WERROR status;
+                struct dsdb_dn *dsdb_dn;
+                TALLOC_CTX *tmp_ctx = talloc_new(ctx->ldb);
+                W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+                status = dsdb_syntax_DN_validate_one_val(ctx,
+                                                         attr,
+                                                         &in->values[i],
+                                                         tmp_ctx, &dsdb_dn);
+                if (!W_ERROR_IS_OK(status)) {
+                        talloc_free(tmp_ctx);
+                        return status;
+                }
+
+                if (dsdb_dn->dn_format != DSDB_BINARY_DN) {
+                        talloc_free(tmp_ctx);
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                status = dsdb_syntax_DATA_BLOB_validate_one_val(ctx,
+                                                                attr,
+                                                                &dsdb_dn->extra_part);
+                if (!W_ERROR_IS_OK(status)) {
+                        talloc_free(tmp_ctx);
+                        return status;
+                }
+
+                talloc_free(tmp_ctx);
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_DN_STRING_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
                                                    const struct dsdb_attribute *attr,
                                                    const struct drsuapi_DsReplicaAttribute *in,
@@ -1212 +2146 @@
                                                    struct ldb_message_element *out)
 {
-        uint32_t i;
-
-        out->flags      = 0;
-        out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
-        W_ERROR_HAVE_NO_MEMORY(out->name);
-
-        out->num_values = in->value_ctr.num_values;
-        out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
-        W_ERROR_HAVE_NO_MEMORY(out->values);
-
-        for (i=0; i < out->num_values; i++) {
-                struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;
-                char *binary;
-                char *str;
-                enum ndr_err_code ndr_err;
-
-                if (in->value_ctr.values[i].blob == NULL) {
-                        return WERR_FOOBAR;
-                }
-
-                if (in->value_ctr.values[i].blob->length == 0) {
-                        return WERR_FOOBAR;
-                }
-
-                ndr_err = ndr_pull_struct_blob_all(in->value_ctr.values[i].blob,
-                                                   out->values, schema->iconv_convenience, &id3b,
-                                                   (ndr_pull_flags_fn_t)ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary);
-                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
-                        return ntstatus_to_werror(status);
-                }
-
-                /* TODO: handle id3.guid and id3.sid */
-                binary = data_blob_hex_string(out->values, &id3b.binary);
-                W_ERROR_HAVE_NO_MEMORY(binary);
-
-                str = talloc_asprintf(out->values, "B:%u:%s:%s",
-                                      (unsigned int)(id3b.binary.length * 2), /* because of 2 hex chars per byte */
-                                      binary,
-                                      id3b.dn);
-                W_ERROR_HAVE_NO_MEMORY(str);
-
-                /* TODO: handle id3.guid and id3.sid */
-                out->values[i] = data_blob_string_const(str);
-        }
-
-        return WERR_OK;
-}
-
-static WERROR dsdb_syntax_DN_BINARY_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                                   const struct dsdb_schema *schema,
+        return dsdb_syntax_DN_BINARY_drsuapi_to_ldb(ctx,
+                                                    attr,
+                                                    in,
+                                                    mem_ctx,
+                                                    out);
+}
+
+static WERROR dsdb_syntax_DN_STRING_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
                                                    const struct dsdb_attribute *attr,
                                                    const struct ldb_message_element *in,
@@ -1268 +2159 @@
                                                    struct drsuapi_DsReplicaAttribute *out)
 {
-        uint32_t i;
+        return dsdb_syntax_DN_BINARY_ldb_to_drsuapi(ctx,
+                                                    attr,
+                                                    in,
+                                                    mem_ctx,
+                                                    out);
+}
+
+static WERROR dsdb_syntax_DN_STRING_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                                 const struct dsdb_attribute *attr,
+                                                 const struct ldb_message_element *in)
+{
+        unsigned int i;
+
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        for (i=0; i < in->num_values; i++) {
+                WERROR status;
+                struct dsdb_dn *dsdb_dn;
+                TALLOC_CTX *tmp_ctx = talloc_new(ctx->ldb);
+                W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
+
+                status = dsdb_syntax_DN_validate_one_val(ctx,
+                                                         attr,
+                                                         &in->values[i],
+                                                         tmp_ctx, &dsdb_dn);
+                if (!W_ERROR_IS_OK(status)) {
+                        talloc_free(tmp_ctx);
+                        return status;
+                }
+
+                if (dsdb_dn->dn_format != DSDB_STRING_DN) {
+                        talloc_free(tmp_ctx);
+                        return WERR_DS_INVALID_ATTRIBUTE_SYNTAX;
+                }
+
+                status = dsdb_syntax_UNICODE_validate_one_val(ctx,
+                                                              attr,
+                                                              &dsdb_dn->extra_part);
+                if (!W_ERROR_IS_OK(status)) {
+                        talloc_free(tmp_ctx);
+                        return status;
+                }
+
+                talloc_free(tmp_ctx);
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb(const struct dsdb_syntax_ctx *ctx,
+                                                              const struct dsdb_attribute *attr,
+                                                              const struct drsuapi_DsReplicaAttribute *in,
+                                                              TALLOC_CTX *mem_ctx,
+                                                              struct ldb_message_element *out)
+{
+        unsigned int i;
+
+        out->flags      = 0;
+        out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
+        W_ERROR_HAVE_NO_MEMORY(out->name);
+
+        out->num_values = in->value_ctr.num_values;
+        out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
+        W_ERROR_HAVE_NO_MEMORY(out->values);
+
+        for (i=0; i < out->num_values; i++) {
+                size_t len;
+                char *str;
+
+                if (in->value_ctr.values[i].blob == NULL) {
+                        return WERR_FOOBAR;
+                }
+
+                if (in->value_ctr.values[i].blob->length < 4) {
+                        return WERR_FOOBAR;
+                }
+
+                len = IVAL(in->value_ctr.values[i].blob->data, 0);
+
+                if (len != in->value_ctr.values[i].blob->length) {
+                        return WERR_FOOBAR;
+                }
+
+                if (!convert_string_talloc(out->values, CH_UTF16, CH_UNIX,
+                                           in->value_ctr.values[i].blob->data+4,
+                                           in->value_ctr.values[i].blob->length-4,
+                                           (void **)&str, NULL, false)) {
+                        return WERR_FOOBAR;
+                }
+
+                out->values[i] = data_blob_string_const(str);
+        }
+
+        return WERR_OK;
+}
+
+static WERROR dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi(const struct dsdb_syntax_ctx *ctx,
+                                                              const struct dsdb_attribute *attr,
+                                                              const struct ldb_message_element *in,
+                                                              TALLOC_CTX *mem_ctx,
+                                                              struct drsuapi_DsReplicaAttribute *out)
+{
+        unsigned int i;
         DATA_BLOB *blobs;
 
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
+        if (attr->attributeID_id == DRSUAPI_ATTID_INVALID) {
+                return WERR_FOOBAR;
+        }
+
+        out->attid                      = dsdb_attribute_get_attid(attr,
+                                                                   ctx->is_schema_nc);
         out->value_ctr.num_values       = in->num_values;
         out->value_ctr.values           = talloc_array(mem_ctx,
@@ -1286 +2282 @@
 
         for (i=0; i < in->num_values; i++) {
-                struct drsuapi_DsReplicaObjectIdentifier3Binary id3b;
-                enum ndr_err_code ndr_err;
-
-                out->value_ctr.values[i].blob   = &blobs[i];
-
-                /* TODO: handle id3b.guid and id3b.sid, id3.binary */
-                ZERO_STRUCT(id3b);
-                id3b.dn         = (const char *)in->values[i].data;
-                id3b.binary     = data_blob(NULL, 0);
-
-                ndr_err = ndr_push_struct_blob(&blobs[i], blobs, schema->iconv_convenience, &id3b,
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary);
-                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
-                        return ntstatus_to_werror(status);
-                }
-        }
-
-        return WERR_OK;
-}
-
-static WERROR dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb(struct ldb_context *ldb, 
-                                                              const struct dsdb_schema *schema,
-                                                              const struct dsdb_attribute *attr,
-                                                              const struct drsuapi_DsReplicaAttribute *in,
-                                                              TALLOC_CTX *mem_ctx,
-                                                              struct ldb_message_element *out)
-{
-        uint32_t i;
-
-        out->flags      = 0;
-        out->name       = talloc_strdup(mem_ctx, attr->lDAPDisplayName);
-        W_ERROR_HAVE_NO_MEMORY(out->name);
-
-        out->num_values = in->value_ctr.num_values;
-        out->values     = talloc_array(mem_ctx, struct ldb_val, out->num_values);
-        W_ERROR_HAVE_NO_MEMORY(out->values);
-
-        for (i=0; i < out->num_values; i++) {
-                uint32_t len;
-                char *str;
-
-                if (in->value_ctr.values[i].blob == NULL) {
-                        return WERR_FOOBAR;
-                }
-
-                if (in->value_ctr.values[i].blob->length < 4) {
-                        return WERR_FOOBAR;
-                }
-
-                len = IVAL(in->value_ctr.values[i].blob->data, 0);
-
-                if (len != in->value_ctr.values[i].blob->length) {
-                        return WERR_FOOBAR;
-                }
-
-                if (!convert_string_talloc_convenience(out->values, schema->iconv_convenience, CH_UTF16, CH_UNIX,
-                                            in->value_ctr.values[i].blob->data+4,
-                                            in->value_ctr.values[i].blob->length-4,
-                                            (void **)&str, NULL, false)) {
-                        return WERR_FOOBAR;
-                }
-
-                out->values[i] = data_blob_string_const(str);
-        }
-
-        return WERR_OK;
-}
-
-static WERROR dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi(struct ldb_context *ldb, 
-                                                              const struct dsdb_schema *schema,
-                                                              const struct dsdb_attribute *attr,
-                                                              const struct ldb_message_element *in,
-                                                              TALLOC_CTX *mem_ctx,
-                                                              struct drsuapi_DsReplicaAttribute *out)
-{
-        uint32_t i;
-        DATA_BLOB *blobs;
-
-        if (attr->attributeID_id == 0xFFFFFFFF) {
-                return WERR_FOOBAR;
-        }
-
-        out->attid                      = attr->attributeID_id;
-        out->value_ctr.num_values       = in->num_values;
-        out->value_ctr.values           = talloc_array(mem_ctx,
-                                                       struct drsuapi_DsAttributeValue,
-                                                       in->num_values);
-        W_ERROR_HAVE_NO_MEMORY(out->value_ctr.values);
-
-        blobs = talloc_array(mem_ctx, DATA_BLOB, in->num_values);
-        W_ERROR_HAVE_NO_MEMORY(blobs);
-
-        for (i=0; i < in->num_values; i++) {
                 uint8_t *data;
                 size_t ret;
@@ -1385 +2287 @@
                 out->value_ctr.values[i].blob   = &blobs[i];
 
-                if (!convert_string_talloc_convenience(blobs, schema->iconv_convenience, CH_UNIX, CH_UTF16,
-                                            in->values[i].data,
-                                            in->values[i].length,
-                                            (void **)&data, &ret, false)) {
+                if (!convert_string_talloc(blobs, CH_UNIX, CH_UTF16,
+                                           in->values[i].data,
+                                           in->values[i].length,
+                                           (void **)&data, &ret, false)) {
                         return WERR_FOOBAR;
                 }
@@ -1404 +2306 @@
 
         return WERR_OK;
+}
+
+static WERROR dsdb_syntax_PRESENTATION_ADDRESS_validate_ldb(const struct dsdb_syntax_ctx *ctx,
+                                                            const struct dsdb_attribute *attr,
+                                                            const struct ldb_message_element *in)
+{
+        return dsdb_syntax_UNICODE_validate_ldb(ctx,
+                                                attr,
+                                                in);
 }
 
@@ -1416 +2327 @@
                 .drsuapi_to_ldb         = dsdb_syntax_BOOL_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_BOOL_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_BOOL_validate_ldb,
                 .equality               = "booleanMatch",
-                .comment                = "Boolean" 
+                .comment                = "Boolean"
         },{
                 .name                   = "Integer",
@@ -1425 +2337 @@
                 .drsuapi_to_ldb         = dsdb_syntax_INT32_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_INT32_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_INT32_validate_ldb,
                 .equality               = "integerMatch",
                 .comment                = "Integer",
@@ -1435 +2348 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DATA_BLOB_validate_ldb,
                 .equality               = "octetStringMatch",
                 .comment                = "Octet String",
@@ -1444 +2358 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DATA_BLOB_validate_ldb,
                 .equality               = "octetStringMatch",
                 .comment                = "Octet String - Security Identifier (SID)",
@@ -1454 +2369 @@
                 .drsuapi_to_ldb         = dsdb_syntax_OID_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_OID_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_OID_validate_ldb,
                 .equality               = "caseIgnoreMatch", /* Would use "objectIdentifierMatch" but most are ldap attribute/class names */
                 .comment                = "OID String",
@@ -1464 +2380 @@
                 .drsuapi_to_ldb         = dsdb_syntax_INT32_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_INT32_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_INT32_validate_ldb,
                 .ldb_syntax             = LDB_SYNTAX_SAMBA_INT32
         },{
@@ -1473 +2390 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DATA_BLOB_validate_ldb,
                 .equality               = "numericStringMatch",
                 .substring              = "numericStringSubstringsMatch",
@@ -1484 +2402 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DATA_BLOB_validate_ldb,
                 .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
         },{
@@ -1492 +2411 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DATA_BLOB_validate_ldb,
                 .equality               = "caseIgnoreMatch",
                 .substring              = "caseIgnoreSubstringsMatch",
@@ -1503 +2423 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DATA_BLOB_validate_ldb,
                 .equality               = "caseExactIA5Match",
                 .comment                = "Printable String",
@@ -1513 +2434 @@
                 .drsuapi_to_ldb         = dsdb_syntax_NTTIME_UTC_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_NTTIME_UTC_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_NTTIME_UTC_validate_ldb,
                 .equality               = "generalizedTimeMatch",
                 .comment                = "UTC Time",
@@ -1522 +2444 @@
                 .drsuapi_to_ldb         = dsdb_syntax_NTTIME_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_NTTIME_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_NTTIME_validate_ldb,
                 .equality               = "generalizedTimeMatch",
                 .comment                = "Generalized Time",
@@ -1531 +2454 @@
                 .oMSyntax               = 27,
                 .attributeSyntax_oid    = "2.5.5.3",
-                .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
-                .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
+                .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
+                .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DATA_BLOB_validate_ldb,
+                .equality               = "caseExactMatch",
+                .substring              = "caseExactSubstringsMatch",
+                /* TODO (kim): according to LDAP rfc we should be using same comparison
+                 * as Directory String (LDB_SYNTAX_DIRECTORY_STRING), but case sensitive.
+                 * But according to ms docs binary compare should do the job:
+                 * http://msdn.microsoft.com/en-us/library/cc223200(v=PROT.10).aspx */
+                .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
         },{
                 .name                   = "String(Unicode)",
@@ -1540 +2471 @@
                 .drsuapi_to_ldb         = dsdb_syntax_UNICODE_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_UNICODE_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_UNICODE_validate_ldb,
                 .equality               = "caseIgnoreMatch",
                 .substring              = "caseIgnoreSubstringsMatch",
@@ -1550 +2482 @@
                 .drsuapi_to_ldb         = dsdb_syntax_INT64_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_INT64_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_INT64_validate_ldb,
                 .equality               = "integerMatch",
                 .comment                = "Large Integer",
@@ -1560 +2493 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DATA_BLOB_validate_ldb,
         },{
                 .name                   = "Object(DS-DN)",
@@ -1568 +2502 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DN_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DN_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DN_validate_ldb,
                 .equality               = "distinguishedNameMatch",
                 .comment                = "Object(DS-DN) == a DN",
         },{
                 .name                   = "Object(DN-Binary)",
-                .ldap_oid               = "1.2.840.113556.1.4.903",
+                .ldap_oid               = DSDB_SYNTAX_BINARY_DN,
                 .oMSyntax               = 127,
                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0b"),
@@ -1578 +2513 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DN_BINARY_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DN_BINARY_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DN_BINARY_validate_ldb,
                 .equality               = "octetStringMatch",
                 .comment                = "OctetString: Binary+DN",
-                .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
         },{
-        /* not used in w2k3 schema */
+        /* not used in w2k3 schema, but used in Exchange schema*/
                 .name                   = "Object(OR-Name)",
-                .ldap_oid               = "1.2.840.113556.1.4.1221",
+                .ldap_oid               = DSDB_SYNTAX_OR_NAME,
                 .oMSyntax               = 127,
                 .oMObjectClass          = OMOBJECTCLASS("\x56\x06\x01\x02\x05\x0b\x1D"),
                 .attributeSyntax_oid    = "2.5.5.7",
-                .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
-                .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
+                .drsuapi_to_ldb         = dsdb_syntax_DN_BINARY_drsuapi_to_ldb,
+                .ldb_to_drsuapi         = dsdb_syntax_DN_BINARY_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DN_BINARY_validate_ldb,
+                .equality               = "caseIgnoreMatch",
+                .ldb_syntax             = LDB_SYNTAX_DN,
         },{
-        /* 
+        /*
          * TODO: verify if DATA_BLOB is correct here...!
          *
          *       repsFrom and repsTo are the only attributes using
-         *       this attribute syntax, but they're not replicated... 
+         *       this attribute syntax, but they're not replicated...
          */
                 .name                   = "Object(Replica-Link)",
@@ -1604 +2542 @@
                 .drsuapi_to_ldb         = dsdb_syntax_DATA_BLOB_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_DATA_BLOB_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DATA_BLOB_validate_ldb,
         },{
                 .name                   = "Object(Presentation-Address)",
@@ -1612 +2551 @@
                 .drsuapi_to_ldb         = dsdb_syntax_PRESENTATION_ADDRESS_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_PRESENTATION_ADDRESS_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_PRESENTATION_ADDRESS_validate_ldb,
                 .comment                = "Presentation Address",
                 .ldb_syntax             = LDB_SYNTAX_DIRECTORY_STRING,
@@ -1623 +2563 @@
                 .drsuapi_to_ldb         = dsdb_syntax_FOOBAR_drsuapi_to_ldb,
                 .ldb_to_drsuapi         = dsdb_syntax_FOOBAR_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_FOOBAR_validate_ldb,
                 .ldb_syntax             = LDB_SYNTAX_DIRECTORY_STRING,
         },{
         /* not used in w2k3 schema */
                 .name                   = "Object(DN-String)",
-                .ldap_oid               = "1.2.840.113556.1.4.904",
+                .ldap_oid               = DSDB_SYNTAX_STRING_DN,
                 .oMSyntax               = 127,
                 .oMObjectClass          = OMOBJECTCLASS("\x2a\x86\x48\x86\xf7\x14\x01\x01\x01\x0c"),
                 .attributeSyntax_oid    = "2.5.5.14",
-                .drsuapi_to_ldb         = dsdb_syntax_DN_BINARY_drsuapi_to_ldb,
-                .ldb_to_drsuapi         = dsdb_syntax_DN_BINARY_ldb_to_drsuapi,
+                .drsuapi_to_ldb         = dsdb_syntax_DN_STRING_drsuapi_to_ldb,
+                .ldb_to_drsuapi         = dsdb_syntax_DN_STRING_ldb_to_drsuapi,
+                .validate_ldb           = dsdb_syntax_DN_STRING_validate_ldb,
                 .equality               = "octetStringMatch",
                 .comment                = "OctetString: String+DN",
-                .ldb_syntax             = LDB_SYNTAX_OCTET_STRING,
         }
 };
 
-const struct dsdb_syntax *find_syntax_map_by_ad_oid(const char *ad_oid) 
-{
-        int i;
+const struct dsdb_syntax *find_syntax_map_by_ad_oid(const char *ad_oid)
+{
+        unsigned int i;
         for (i=0; dsdb_syntaxes[i].ldap_oid; i++) {
                 if (strcasecmp(ad_oid, dsdb_syntaxes[i].attributeSyntax_oid) == 0) {
@@ -1650 +2591 @@
 }
 
-const struct dsdb_syntax *find_syntax_map_by_ad_syntax(int oMSyntax) 
-{
-        int i;
+const struct dsdb_syntax *find_syntax_map_by_ad_syntax(int oMSyntax)
+{
+        unsigned int i;
         for (i=0; dsdb_syntaxes[i].ldap_oid; i++) {
                 if (oMSyntax == dsdb_syntaxes[i].oMSyntax) {
@@ -1661 +2602 @@
 }
 
-const struct dsdb_syntax *find_syntax_map_by_standard_oid(const char *standard_oid) 
-{
-        int i;
+const struct dsdb_syntax *find_syntax_map_by_standard_oid(const char *standard_oid)
+{
+        unsigned int i;
         for (i=0; dsdb_syntaxes[i].ldap_oid; i++) {
                 if (strcasecmp(standard_oid, dsdb_syntaxes[i].ldap_oid) == 0) {
@@ -1671 +2612 @@
         return NULL;
 }
+
 const struct dsdb_syntax *dsdb_syntax_for_attribute(const struct dsdb_attribute *attr)
 {
-        uint32_t i;
+        unsigned int i;
 
         for (i=0; i < ARRAY_SIZE(dsdb_syntaxes); i++) {
@@ -1696 +2638 @@
 }
 
-WERROR dsdb_attribute_drsuapi_to_ldb(struct ldb_context *ldb, 
+WERROR dsdb_attribute_drsuapi_to_ldb(struct ldb_context *ldb,
                                      const struct dsdb_schema *schema,
+                                     const struct dsdb_schema_prefixmap *pfm_remote,
                                      const struct drsuapi_DsReplicaAttribute *in,
                                      TALLOC_CTX *mem_ctx,
@@ -1703 +2646 @@
 {
         const struct dsdb_attribute *sa;
-
-        sa = dsdb_attribute_by_attributeID_id(schema, in->attid);
+        struct dsdb_syntax_ctx syntax_ctx;
+        uint32_t attid_local;
+
+        /* use default syntax conversion context */
+        dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
+        syntax_ctx.pfm_remote = pfm_remote;
+
+        switch (dsdb_pfm_get_attid_type(in->attid)) {
+        case DSDB_ATTID_TYPE_PFM:
+                /* map remote ATTID to local ATTID */
+                if (!dsdb_syntax_attid_from_remote_attid(&syntax_ctx, mem_ctx, in->attid, &attid_local)) {
+                        DEBUG(0,(__location__ ": Can't find local ATTID for 0x%08X\n",
+                                 in->attid));
+                        return WERR_FOOBAR;
+                }
+                break;
+        case DSDB_ATTID_TYPE_INTID:
+                /* use IntId value directly */
+                attid_local = in->attid;
+                break;
+        default:
+                /* we should never get here */
+                DEBUG(0,(__location__ ": Invalid ATTID type passed for conversion - 0x%08X\n",
+                         in->attid));
+                return WERR_INVALID_PARAMETER;
+        }
+
+        sa = dsdb_attribute_by_attributeID_id(schema, attid_local);
         if (!sa) {
-                return WERR_FOOBAR;
-        }
-
-        return sa->syntax->drsuapi_to_ldb(ldb, schema, sa, in, mem_ctx, out);
-}
-
-WERROR dsdb_attribute_ldb_to_drsuapi(struct ldb_context *ldb, 
+                DEBUG(1,(__location__ ": Unknown attributeID_id 0x%08X\n", in->attid));
+                return WERR_FOOBAR;
+        }
+
+        return sa->syntax->drsuapi_to_ldb(&syntax_ctx, sa, in, mem_ctx, out);
+}
+
+WERROR dsdb_attribute_ldb_to_drsuapi(struct ldb_context *ldb,
                                      const struct dsdb_schema *schema,
                                      const struct ldb_message_element *in,
@@ -1719 +2689 @@
 {
         const struct dsdb_attribute *sa;
+        struct dsdb_syntax_ctx syntax_ctx;
 
         sa = dsdb_attribute_by_lDAPDisplayName(schema, in->name);
@@ -1725 +2696 @@
         }
 
-        return sa->syntax->ldb_to_drsuapi(ldb, schema, sa, in, mem_ctx, out);
-}
+        /* use default syntax conversion context */
+        dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema);
+
+        return sa->syntax->ldb_to_drsuapi(&syntax_ctx, sa, in, mem_ctx, out);
+}
+