Commit be03fa68 authored by Jelmer Vernooij's avatar Jelmer Vernooij

New upstream version 1.1.29

parent 3d57990b
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
pyldb_Dn_FromDn: PyObject *(struct ldb_dn *)
pyldb_Object_AsDn: bool (TALLOC_CTX *, PyObject *, struct ldb_context *, struct ldb_dn **)
pyldb_Dn_FromDn: PyObject *(struct ldb_dn *)
pyldb_Object_AsDn: bool (TALLOC_CTX *, PyObject *, struct ldb_context *, struct ldb_dn **)
pyldb_Dn_FromDn: PyObject *(struct ldb_dn *)
pyldb_Object_AsDn: bool (TALLOC_CTX *, PyObject *, struct ldb_context *, struct ldb_dn **)
pyldb_Dn_FromDn: PyObject *(struct ldb_dn *)
pyldb_Object_AsDn: bool (TALLOC_CTX *, PyObject *, struct ldb_context *, struct ldb_dn **)
pyldb_Dn_FromDn: PyObject *(struct ldb_dn *)
pyldb_Object_AsDn: bool (TALLOC_CTX *, PyObject *, struct ldb_context *, struct ldb_dn **)
pyldb_Dn_FromDn: PyObject *(struct ldb_dn *)
pyldb_Object_AsDn: bool (TALLOC_CTX *, PyObject *, struct ldb_context *, struct ldb_dn **)
......@@ -708,6 +708,7 @@ def SAMBA_CONFIG_H(conf, path=None):
testflags=True)
conf.ADD_CFLAGS('-Wformat=2 -Wno-format-y2k', testflags=True)
conf.ADD_CFLAGS('-Werror=format-security -Wformat-security', testflags=True)
# This check is because for ldb_search(), a NULL format string
# is not an error, but some compilers complain about that.
if CHECK_CFLAGS(conf, ["-Werror=format", "-Wformat=2"], '''
......@@ -725,6 +726,7 @@ int main(void) {
if Options.options.picky_developer:
conf.ADD_NAMED_CFLAGS('PICKY_CFLAGS', '-Werror -Wno-error=deprecated-declarations', testflags=True)
conf.ADD_NAMED_CFLAGS('PICKY_CFLAGS', '-Wno-error=tautological-compare', testflags=True)
if Options.options.fatal_errors:
conf.ADD_CFLAGS('-Wfatal-errors', testflags=True)
......
......@@ -49,7 +49,8 @@ def SAMBA_CHECK_PERL(conf, mandatory=True, version=(5,0,0)):
conf.env.PERL_LIB_INSTALL_DIR = perl_lib_install_dir
perl_inc = read_perl_config_var('print "@INC"')
perl_inc.remove('.')
if '.' in perl_inc:
perl_inc.remove('.')
conf.start_msg("PERL_INC: ")
conf.end_msg("%s" % (perl_inc), 'GREEN')
conf.env.PERL_INC = perl_inc
......@@ -402,6 +402,22 @@ def configure(conf):
addmain=False,
msg='Checking for library destructor support')
conf.CHECK_CODE('''
void test_attribute(void) __attribute__ (());
void test_attribute(void)
{
return;
}
int main(void) {
return 0;
}
''',
'HAVE___ATTRIBUTE__',
addmain=False,
msg='Checking for __attribute__')
if sys.platform.startswith('aix'):
conf.DEFINE('_ALL_SOURCE', 1, add_to_cflags=True)
# Might not be needed if ALL_SOURCE is defined
......
......@@ -284,15 +284,17 @@ void ldb_set_errstring(struct ldb_context *ldb, const char *err_string)
void ldb_asprintf_errstring(struct ldb_context *ldb, const char *format, ...)
{
va_list ap;
char *old_err_string = NULL;
if (ldb->err_string) {
talloc_free(ldb->err_string);
old_err_string = ldb->err_string;
}
va_start(ap, format);
ldb->err_string = talloc_vasprintf(ldb, format, ap);
va_end(ap);
TALLOC_FREE(old_err_string);
if (ldb->flags & LDB_FLG_ENABLE_TRACING) {
ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_asprintf/set_errstring: %s",
ldb->err_string);
......@@ -594,7 +596,9 @@ int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
if ((handle->status != LDB_SUCCESS) &&
(handle->ldb->err_string == NULL)) {
/* if no error string was setup by the backend */
ldb_asprintf_errstring(handle->ldb, "ldb_wait: %s (%d)",
ldb_asprintf_errstring(handle->ldb,
"ldb_wait from %s with LDB_ASYNC_DONE: %s (%d)",
handle->location,
ldb_strerror(handle->status),
handle->status);
}
......@@ -612,19 +616,21 @@ int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
if (ret != 0) {
return ldb_operr(handle->ldb);
}
if (handle->status != LDB_SUCCESS) {
if (handle->ldb->err_string == NULL) {
/*
* if no error string was setup by the backend
*/
ldb_asprintf_errstring(handle->ldb,
"ldb_wait: %s (%d)",
ldb_strerror(handle->status),
handle->status);
}
if (handle->status == LDB_SUCCESS) {
return LDB_SUCCESS;
}
if (handle->ldb->err_string != NULL) {
return handle->status;
}
break;
/*
* if no error string was setup by the backend
*/
ldb_asprintf_errstring(handle->ldb,
"ldb_wait from %s with LDB_WAIT_NONE: %s (%d)",
handle->location,
ldb_strerror(handle->status),
handle->status);
return handle->status;
case LDB_WAIT_ALL:
while (handle->state != LDB_ASYNC_DONE) {
......@@ -633,32 +639,38 @@ int ldb_wait(struct ldb_handle *handle, enum ldb_wait_type type)
return ldb_operr(handle->ldb);
}
if (handle->status != LDB_SUCCESS) {
if (handle->ldb->err_string == NULL) {
/*
* if no error string was setup by the
* backend
*/
ldb_asprintf_errstring(handle->ldb,
"ldb_wait: %s (%d)",
ldb_strerror(handle->status),
handle->status);
if (handle->ldb->err_string != NULL) {
return handle->status;
}
return handle->status;
}
}
if (handle->status != LDB_SUCCESS) {
if (handle->ldb->err_string == NULL) {
/*
* if no error string was setup by the backend
* if no error string was setup by the
* backend
*/
ldb_asprintf_errstring(handle->ldb,
"ldb_wait: %s (%d)",
"ldb_wait from %s with "
"LDB_WAIT_ALL: %s (%d)",
handle->location,
ldb_strerror(handle->status),
handle->status);
return handle->status;
}
}
if (handle->status == LDB_SUCCESS) {
return LDB_SUCCESS;
}
if (handle->ldb->err_string != NULL) {
return handle->status;
}
break;
/*
* if no error string was setup by the backend
*/
ldb_asprintf_errstring(handle->ldb,
"ldb_wait from %s with LDB_WAIT_ALL,"
" LDB_ASYNC_DONE: %s (%d)",
handle->location,
ldb_strerror(handle->status),
handle->status);
return handle->status;
}
return LDB_SUCCESS;
......
......@@ -31,6 +31,41 @@
#include "ldb_private.h"
#include "ldb_handlers.h"
/*
fill in an attribute to the ldb_schema into the supplied buffer
if flags contains LDB_ATTR_FLAG_ALLOCATED
the attribute name string will be copied using
talloc_strdup(), otherwise it needs to be a static const
string at least with a lifetime longer than the ldb struct!
the ldb_schema_syntax structure should be a pointer
to a static const struct or at least it needs to be
a struct with a longer lifetime than the ldb context!
*/
int ldb_schema_attribute_fill_with_syntax(struct ldb_context *ldb,
TALLOC_CTX *mem_ctx,
const char *attribute,
unsigned flags,
const struct ldb_schema_syntax *syntax,
struct ldb_schema_attribute *a)
{
a->name = attribute;
a->flags = flags;
a->syntax = syntax;
if (a->flags & LDB_ATTR_FLAG_ALLOCATED) {
a->name = talloc_strdup(mem_ctx, a->name);
if (a->name == NULL) {
ldb_oom(ldb);
return -1;
}
}
return 0;
}
/*
add a attribute to the ldb_schema
......@@ -215,6 +250,39 @@ void ldb_schema_attribute_remove(struct ldb_context *ldb, const char *name)
ldb->schema.num_attributes--;
}
/*
remove attributes with a specified flag (eg LDB_ATTR_FLAG_FROM_DB) for this ldb context
This is to permit correct reloads
*/
void ldb_schema_attribute_remove_flagged(struct ldb_context *ldb, unsigned int flag)
{
ptrdiff_t i;
for (i = 0; i < ldb->schema.num_attributes;) {
const struct ldb_schema_attribute *a
= &ldb->schema.attributes[i];
/* FIXED attributes are never removed */
if (a->flags & LDB_ATTR_FLAG_FIXED) {
i++;
continue;
}
if ((a->flags & flag) == 0) {
i++;
continue;
}
if (a->flags & LDB_ATTR_FLAG_ALLOCATED) {
talloc_free(discard_const_p(char, a->name));
}
if (i < ldb->schema.num_attributes - 1) {
memmove(&ldb->schema.attributes[i],
a+1, sizeof(*a) * (ldb->schema.num_attributes-(i+1)));
}
ldb->schema.num_attributes--;
}
}
/*
setup a attribute handler using a standard syntax
*/
......
This diff is collapsed.
......@@ -54,7 +54,7 @@ struct ldb_dn_component {
struct ldb_dn_ext_component {
char *name;
const char *name;
struct ldb_val value;
};
......@@ -171,7 +171,7 @@ struct ldb_dn *ldb_dn_new_fmt(TALLOC_CTX *mem_ctx,
char *strdn;
va_list ap;
if ( (! mem_ctx) || (! ldb)) return NULL;
if (! ldb) return NULL;
va_start(ap, new_fmt);
strdn = talloc_vasprintf(mem_ctx, new_fmt, ap);
......@@ -408,11 +408,7 @@ static bool ldb_dn_explode(struct ldb_dn *dn)
goto failed;
}
dn->ext_components[dn->ext_comp_num].name = talloc_strdup(dn->ext_components, ex_name);
if (!dn->ext_components[dn->ext_comp_num].name) {
/* ouch */
goto failed;
}
dn->ext_components[dn->ext_comp_num].name = ext_syntax->name;
ret = ext_syntax->read_fn(dn->ldb, dn->ext_components,
&ex_val, &dn->ext_components[dn->ext_comp_num].value);
if (ret != LDB_SUCCESS) {
......@@ -1703,7 +1699,7 @@ bool ldb_dn_remove_child_components(struct ldb_dn *dn, unsigned int num)
*/
bool ldb_dn_replace_components(struct ldb_dn *dn, struct ldb_dn *new_dn)
{
int i;
unsigned int i;
if ( ! ldb_dn_validate(dn) || ! ldb_dn_validate(new_dn)) {
return false;
......@@ -1908,11 +1904,11 @@ int ldb_dn_set_component(struct ldb_dn *dn, int num,
return LDB_ERR_OTHER;
}
if (num >= dn->comp_num) {
if (num < 0) {
return LDB_ERR_OTHER;
}
if (num < 0) {
if ((unsigned)num >= dn->comp_num) {
return LDB_ERR_OTHER;
}
......@@ -1990,12 +1986,14 @@ int ldb_dn_set_extended_component(struct ldb_dn *dn,
struct ldb_dn_ext_component *p;
unsigned int i;
struct ldb_val v2;
const struct ldb_dn_extended_syntax *ext_syntax;
if ( ! ldb_dn_validate(dn)) {
return LDB_ERR_OTHER;
}
if (!ldb_dn_extended_syntax_by_name(dn->ldb, name)) {
ext_syntax = ldb_dn_extended_syntax_by_name(dn->ldb, name);
if (ext_syntax == NULL) {
/* We don't know how to handle this type of thing */
return LDB_ERR_INVALID_DN_SYNTAX;
}
......@@ -2006,10 +2004,8 @@ int ldb_dn_set_extended_component(struct ldb_dn *dn,
dn->ext_components[i].value =
ldb_val_dup(dn->ext_components, val);
dn->ext_components[i].name =
talloc_strdup(dn->ext_components, name);
if (!dn->ext_components[i].name ||
!dn->ext_components[i].value.data) {
dn->ext_components[i].name = ext_syntax->name;
if (!dn->ext_components[i].value.data) {
ldb_dn_mark_invalid(dn);
return LDB_ERR_OPERATIONS_ERROR;
}
......@@ -2170,7 +2166,6 @@ bool ldb_dn_minimise(struct ldb_dn *dn)
*/
for (i = 1; i < dn->ext_comp_num; i++) {
LDB_FREE(dn->ext_components[i].name);
LDB_FREE(dn->ext_components[i].value.data);
}
dn->ext_comp_num = 1;
......
......@@ -693,9 +693,7 @@ _PRIVATE_ int ldb_register_extended_match_rules(struct ldb_context *ldb)
}
/*
register a new ldb backend
if override is true, then override any existing backend for this prefix
register a new ldb extended matching rule
*/
int ldb_register_extended_match_rule(struct ldb_context *ldb,
const struct ldb_extended_match_rule *rule)
......
......@@ -901,7 +901,10 @@ static int ldb_modules_load_path(const char *path, const char *version)
} *loaded;
struct loaded *le;
int dlopen_flags;
#ifdef RTLD_DEEPBIND
bool deepbind_enabled = (getenv("LDB_MODULES_DISABLE_DEEPBIND") == NULL);
#endif
ret = stat(path, &st);
if (ret != 0) {
......@@ -937,13 +940,13 @@ static int ldb_modules_load_path(const char *path, const char *version)
#ifdef RTLD_DEEPBIND
/*
* use deepbind if possible, to avoid issues with different
* system library varients, for example ldb modules may be linked
* system library variants, for example ldb modules may be linked
* against Heimdal while the application may use MIT kerberos.
*
* See the dlopen manpage for details.
*
* One typical user is the bind_dlz module of Samba,
* but symbol versioniong might be enough...
* but symbol versioning might be enough...
*
* We need a way to disable this in order to allow the
* ldb_*ldap modules to work with a preloaded socket wrapper.
......
......@@ -185,8 +185,7 @@ static bool ldb_consume_element_data(uint8_t **pp, size_t *premaining)
unsigned int remaining = *premaining;
uint8_t *p = *pp;
uint32_t num_values = pull_uint32(p, 0);
uint32_t len;
int j;
uint32_t j, len;
p += 4;
if (remaining < 4) {
......@@ -211,20 +210,20 @@ static bool ldb_consume_element_data(uint8_t **pp, size_t *premaining)
return true;
}
/*
* Unpack a ldb message from a linear buffer in ldb_val
*
* Providing a list of attributes to this function allows selective unpacking.
* Giving a NULL list (or a list_size of 0) unpacks all the attributes.
*
* Free with ldb_unpack_data_free()
*/
int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
const struct ldb_val *data,
struct ldb_message *message,
const char * const *list,
unsigned int list_size,
unsigned int *nb_elements_in_db)
int ldb_unpack_data_only_attr_list_flags(struct ldb_context *ldb,
const struct ldb_val *data,
struct ldb_message *message,
const char * const *list,
unsigned int list_size,
unsigned int flags,
unsigned int *nb_elements_in_db)
{
uint8_t *p;
size_t remaining;
......@@ -234,6 +233,7 @@ int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
unsigned int nelem = 0;
size_t len;
unsigned int found = 0;
struct ldb_val *ldb_val_single_array = NULL;
if (list == NULL) {
list_size = 0;
......@@ -271,10 +271,14 @@ int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
errno = EIO;
goto failed;
}
message->dn = ldb_dn_new(message, ldb, (char *)p);
if (message->dn == NULL) {
errno = ENOMEM;
goto failed;
if (flags & LDB_UNPACK_DATA_FLAG_NO_DN) {
message->dn = NULL;
} else {
message->dn = ldb_dn_new(message, ldb, (char *)p);
if (message->dn == NULL) {
errno = ENOMEM;
goto failed;
}
}
/*
* Redundant: by definition, remaining must be more
......@@ -310,6 +314,26 @@ int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
goto failed;
}
/*
* In typical use, most values are single-valued. This makes
* it quite expensive to allocate an array of ldb_val for each
* of these, just to then hold the pointer to the data buffer
* (in the LDB_UNPACK_DATA_FLAG_NO_DATA_ALLOC we don't
* allocate the data). So with
* LDB_UNPACK_DATA_FLAG_NO_VALUES_ALLOC we allocate this ahead
* of time and use it for the single values where possible.
* (This is used the the normal search case, but not in the
* index case because of caller requirements).
*/
if (flags & LDB_UNPACK_DATA_FLAG_NO_VALUES_ALLOC) {
ldb_val_single_array = talloc_array(message->elements, struct ldb_val,
message->num_elements);
if (ldb_val_single_array == NULL) {
errno = ENOMEM;
goto failed;
}
}
for (i=0;i<message->num_elements;i++) {
const char *attr = NULL;
size_t attr_len;
......@@ -344,7 +368,7 @@ int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
*/
if (list_size != 0) {
bool keep = false;
int h;
unsigned int h;
/*
* We know that p has a \0 terminator before the
......@@ -373,11 +397,15 @@ int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
}
}
element = &message->elements[nelem];
element->name = talloc_memdup(message->elements, attr, attr_len+1);
if (flags & LDB_UNPACK_DATA_FLAG_NO_DATA_ALLOC) {
element->name = attr;
} else {
element->name = talloc_memdup(message->elements, attr, attr_len+1);
if (element->name == NULL) {
errno = ENOMEM;
goto failed;
if (element->name == NULL) {
errno = ENOMEM;
goto failed;
}
}
element->flags = 0;
......@@ -389,7 +417,9 @@ int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
p += attr_len + 1;
element->num_values = pull_uint32(p, 0);
element->values = NULL;
if (element->num_values != 0) {
if ((flags & LDB_UNPACK_DATA_FLAG_NO_VALUES_ALLOC) && element->num_values == 1) {
element->values = &ldb_val_single_array[nelem];
} else if (element->num_values != 0) {
element->values = talloc_array(message->elements,
struct ldb_val,
element->num_values);
......@@ -422,15 +452,18 @@ int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
}
element->values[j].length = len;
element->values[j].data = talloc_size(element->values, len+1);
if (element->values[j].data == NULL) {
errno = ENOMEM;
goto failed;
if (flags & LDB_UNPACK_DATA_FLAG_NO_DATA_ALLOC) {
element->values[j].data = p + 4;
} else {
element->values[j].data = talloc_size(element->values, len+1);
if (element->values[j].data == NULL) {
errno = ENOMEM;
goto failed;
}
memcpy(element->values[j].data, p + 4,
len);
element->values[j].data[len] = 0;
}
memcpy(element->values[j].data, p + 4,
len);
element->values[j].data[len] = 0;
remaining -= len;
p += len+4+1;
}
......@@ -463,6 +496,30 @@ failed:
return -1;
}
/*
* Unpack a ldb message from a linear buffer in ldb_val
*
* Providing a list of attributes to this function allows selective unpacking.
* Giving a NULL list (or a list_size of 0) unpacks all the attributes.
*
* Free with ldb_unpack_data_free()
*/
int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
const struct ldb_val *data,
struct ldb_message *message,
const char * const *list,
unsigned int list_size,
unsigned int *nb_elements_in_db)
{
return ldb_unpack_data_only_attr_list_flags(ldb,
data,
message,
list,
list_size,
0,
nb_elements_in_db);
}
int ldb_unpack_data(struct ldb_context *ldb,
const struct ldb_val *data,
struct ldb_message *message)
......
......@@ -427,6 +427,11 @@ const struct ldb_dn_extended_syntax *ldb_dn_extended_syntax_by_name(struct ldb_c
*/
#define LDB_ATTR_FLAG_FORCE_BASE64_LDIF (1<<5)
/*
* The attribute was loaded from a DB, rather than via the C API
*/
#define LDB_ATTR_FLAG_FROM_DB (1<<6)
/**
LDAP attribute syntax for a DN
......@@ -498,6 +503,13 @@ typedef int (*ldb_qsort_cmp_fn_t) (void *v1, void *v2, void *opaque);
#define LDB_CONTROL_BYPASS_OPERATIONAL_OID "1.3.6.1.4.1.7165.4.3.13"
#define LDB_CONTROL_BYPASS_OPERATIONAL_NAME "bypassoperational"
/**
OID for recalculate RDN (rdn attribute and 'name') control. This control forces
the rdn_name module to the recalculate the rdn and name attributes as if the
object was just created.
*/
#define LDB_CONTROL_RECALCULATE_RDN_OID "1.3.6.1.4.1.7165.4.3.30"
/**
OID for recalculate SD control. This control force the
dsdb code to recalculate the SD of the object as if the
......@@ -849,7 +861,7 @@ struct ldb_vlv_req_control {
} gtOrEq;
} match;
int ctxid_len;
char *contextId;
uint8_t *contextId;
};
struct ldb_vlv_resp_control {
......@@ -857,7 +869,7 @@ struct ldb_vlv_resp_control {
int contentCount;
int vlv_result;
int ctxid_len;
char *contextId;
uint8_t *contextId;
};
struct ldb_verify_name_control {
......
......@@ -390,6 +390,12 @@ int ldb_register_extended_match_rule(struct ldb_context *ldb,
int ldb_pack_data(struct ldb_context *ldb,
const struct ldb_message *message,
struct ldb_val *data);
/*
* Unpack a ldb message from a linear buffer in ldb_val
*
* Providing a list of attributes to this function allows selective unpacking.
* Giving a NULL list (or a list_size of 0) unpacks all the attributes.
*/
int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
const struct ldb_val *data,
struct ldb_message *message,
......@@ -399,5 +405,35 @@ int ldb_unpack_data_only_attr_list(struct ldb_context *ldb,
int ldb_unpack_data(struct ldb_context *ldb,
const struct ldb_val *data,
struct ldb_message *message);
/*
* Unpack a ldb message from a linear buffer in ldb_val
*
* Providing a list of attributes to this function allows selective unpacking.
* Giving a NULL list (or a list_size of 0) unpacks all the attributes.
*
* Flags allow control of allocation, so that if
* LDB_UNPACK_DATA_FLAG_NO_DATA_ALLOC is specified, then data in values are
* not allocated, instead they point into the supplier constant buffer.
*
* If LDB_UNPACK_DATA_FLAG_NO_VALUES_ALLOC is specified, then values
* array are not allocated individually (for single-valued
* attributes), instead they point into a single buffer per message.
*
* LDB_UNPACK_DATA_FLAG_NO_VALUES_ALLOC is only valid when
* LDB_UNPACK_DATA_FLAG_NO_DATA_ALLOC is also specified.
*
* Likewise if LDB_UNPACK_DATA_FLAG_NO_DN is specified, the DN is omitted.
*/
int ldb_unpack_data_only_attr_list_flags(struct ldb_context *ldb,
const struct ldb_val *data,
struct ldb_message *message,
const char * const *list,
unsigned int list_size,
unsigned int flags,
unsigned int *nb_elements_in_db);
#define LDB_UNPACK_DATA_FLAG_NO_DATA_ALLOC 0x0001
#define LDB_UNPACK_DATA_FLAG_NO_DN 0x0002
#define LDB_UNPACK_DATA_FLAG_NO_VALUES_ALLOC 0x0004
#endif
......@@ -163,6 +163,18 @@ extern const struct ldb_backend_ops ldb_ldapi_backend_ops;
extern const struct ldb_backend_ops ldb_ldaps_backend_ops;
int ldb_setup_wellknown_attributes(struct ldb_context *ldb);
/*
remove attributes with a specified flag (eg LDB_ATTR_FLAG_FROM_DB) for this ldb context
This is to permit correct reloads
*/
void ldb_schema_attribute_remove_flagged(struct ldb_context *ldb, unsigned int flag);
int ldb_schema_attribute_fill_with_syntax(struct ldb_context *ldb,
TALLOC_CTX *mem_ctx,
const char *attribute,
unsigned flags,
const struct ldb_schema_syntax *syntax,
struct ldb_schema_attribute *a);
const char **ldb_subclass_list(struct ldb_context *ldb, const char *classname);
void ldb_subclass_remove(struct ldb_context *ldb, const char *classname);
......
......@@ -727,6 +727,7 @@ static void map_objectclass_generate_remote(struct ldb_module *module, const cha
struct ldb_val val;
bool found_extensibleObject = false;
unsigned int i;
int ret;