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);
if (!object_class)
return NULL;
return &object_class->schemaIDGUID;
}
static int ldif_canonicalise_objectCategory(struct ldb_context *ldb, void *mem_ctx,
const struct ldb_val *in, struct ldb_val *out)
{
struct ldb_dn *dn1 = NULL;
const struct dsdb_schema *schema = dsdb_get_schema(ldb, NULL);
const struct dsdb_class *sclass;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
if (!tmp_ctx) {
return LDB_ERR_OPERATIONS_ERROR;
}
if (!schema) {
talloc_free(tmp_ctx);
*out = data_blob_talloc(mem_ctx, in->data, in->length);
if (in->data && !out->data) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_SUCCESS;
}
dn1 = ldb_dn_from_ldb_val(tmp_ctx, ldb, in);
if ( ! ldb_dn_validate(dn1)) {
const char *lDAPDisplayName = talloc_strndup(tmp_ctx, (char *)in->data, in->length);
sclass = dsdb_class_by_lDAPDisplayName(schema, lDAPDisplayName);
if (sclass) {
struct ldb_dn *dn = ldb_dn_new(tmp_ctx, ldb,
sclass->defaultObjectCategory);
if (dn == NULL) {
talloc_free(tmp_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
*out = data_blob_string_const(ldb_dn_alloc_casefold(mem_ctx, dn));
talloc_free(tmp_ctx);
if (!out->data) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_SUCCESS;
} else {
*out = data_blob_talloc(mem_ctx, in->data, in->length);
talloc_free(tmp_ctx);
if (in->data && !out->data) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_SUCCESS;
}
}
*out = data_blob_string_const(ldb_dn_alloc_casefold(mem_ctx, dn1));
talloc_free(tmp_ctx);
if (!out->data) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_SUCCESS;
}
char *schema_class_to_dITContentRule(TALLOC_CTX *mem_ctx, const struct dsdb_class *sclass,
const struct dsdb_schema *schema)
{
int i;
char *schema_description;
const char **aux_class_list = NULL;
const char **attrs;
const char **must_attr_list = NULL;
const char **may_attr_list = NULL;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
const struct dsdb_class *aux_class;
if (!tmp_ctx) {
return NULL;
}
aux_class_list = merge_attr_list(tmp_ctx, aux_class_list, sclass->systemAuxiliaryClass);
aux_class_list = merge_attr_list(tmp_ctx, aux_class_list, sclass->auxiliaryClass);
for (i=0; aux_class_list && aux_class_list[i]; i++) {
aux_class = dsdb_class_by_lDAPDisplayName(schema, aux_class_list[i]);
attrs = dsdb_attribute_list(mem_ctx, aux_class, DSDB_SCHEMA_ALL_MUST);
must_attr_list = merge_attr_list(mem_ctx, must_attr_list, attrs);
attrs = dsdb_attribute_list(mem_ctx, aux_class, DSDB_SCHEMA_ALL_MAY);
may_attr_list = merge_attr_list(mem_ctx, may_attr_list, attrs);
}
schema_description
= schema_class_description(mem_ctx,
TARGET_AD_SCHEMA_SUBENTRY,
" ",
sclass->governsID_oid,
sclass->lDAPDisplayName,
(const char **)aux_class_list,
NULL, /* Must not specify a
* SUP (subclass) in
* ditContentRules
* per MS-ADTS
* 3.1.1.3.1.1.1 */
-1, must_attr_list, may_attr_list,
NULL);
talloc_free(tmp_ctx);
return schema_description;
}
static char *print_schema_recursive(char *append_to_string, struct dsdb_schema *schema, const char *print_class,
enum dsdb_schema_convert_target target,
const char **attrs_skip, const struct attr_map *attr_map, const struct oid_map *oid_map)
{
char *out = append_to_string;
const struct dsdb_class *objectclass;
objectclass = dsdb_class_by_lDAPDisplayName(schema, print_class);
if (!objectclass) {
DEBUG(0, ("Cannot find class %s in schema\n", print_class));
return NULL;
}
do {
TALLOC_CTX *mem_ctx = talloc_new(append_to_string);
const char *name = objectclass->lDAPDisplayName;
const char *oid = objectclass->governsID_oid;
const char *subClassOf = objectclass->subClassOf;
int objectClassCategory = objectclass->objectClassCategory;
const char **must;
const char **may;
char *schema_entry = NULL;
const char *objectclass_name_as_list[] = {
objectclass->lDAPDisplayName,
NULL
};
int j;
int attr_idx;
if (!mem_ctx) {
DEBUG(0, ("Failed to create new talloc context\n"));
return NULL;
}
/* We have been asked to skip some attributes/objectClasses */
if (attrs_skip && str_list_check_ci(attrs_skip, name)) {
continue;
}
/* We might have been asked to remap this oid, due to a conflict */
for (j=0; oid_map && oid_map[j].old_oid; j++) {
if (strcasecmp(oid, oid_map[j].old_oid) == 0) {
oid = oid_map[j].new_oid;
break;
}
}
/* We might have been asked to remap this name, due to a conflict */
for (j=0; name && attr_map && attr_map[j].old_attr; j++) {
if (strcasecmp(name, attr_map[j].old_attr) == 0) {
name = attr_map[j].new_attr;
break;
}
}
may = dsdb_full_attribute_list(mem_ctx, schema, objectclass_name_as_list, DSDB_SCHEMA_ALL_MAY);
for (j=0; may && may[j]; j++) {
/* We might have been asked to remap this name, due to a conflict */
for (attr_idx=0; attr_map && attr_map[attr_idx].old_attr; attr_idx++) {
if (strcasecmp(may[j], attr_map[attr_idx].old_attr) == 0) {
may[j] = attr_map[attr_idx].new_attr;
break;
}
}
}
must = dsdb_full_attribute_list(mem_ctx, schema, objectclass_name_as_list, DSDB_SCHEMA_ALL_MUST);
for (j=0; must && must[j]; j++) {
/* We might have been asked to remap this name, due to a conflict */
for (attr_idx=0; attr_map && attr_map[attr_idx].old_attr; attr_idx++) {
if (strcasecmp(must[j], attr_map[attr_idx].old_attr) == 0) {
must[j] = attr_map[attr_idx].new_attr;
break;
}
}
}
schema_entry = schema_class_description(mem_ctx, target,
SEPERATOR,
oid,
name,
NULL,
subClassOf,
objectClassCategory,
must,
may,
NULL);
if (schema_entry == NULL) {
DEBUG(0, ("failed to generate schema description for %s\n", name));
return NULL;
}
switch (target) {
case TARGET_OPENLDAP:
out = talloc_asprintf_append(out, "objectclass %s\n\n", schema_entry);
break;
case TARGET_FEDORA_DS:
out = talloc_asprintf_append(out, "objectClasses: %s\n", schema_entry);
break;
}
talloc_free(mem_ctx);
} while (0);
for (objectclass=schema->classes; objectclass; objectclass = objectclass->next) {
if (ldb_attr_cmp(objectclass->subClassOf, print_class) == 0
&& ldb_attr_cmp(objectclass->lDAPDisplayName, print_class) != 0) {
out = print_schema_recursive(out, schema, objectclass->lDAPDisplayName,
target, attrs_skip, attr_map, oid_map);
}
}
return out;
}
