Changeset 745 for trunk/server/source4/lib

trunk/server

Property svn:mergeinfo changed
/vendor/current merged: 581,587,591,594,597,600,615,618,740

trunk/server/source4/lib/cmdline/popt_common.c

-              r414
+              r745
         if (reason == POPT_CALLBACK_REASON_POST) {
                 if (lp_configfile(cmdline_lp_ctx) == NULL) {
             lp_load_default(cmdline_lp_ctx);
+                if (lpcfg_configfile(cmdline_lp_ctx) == NULL) {
+                        lpcfg_load_default(cmdline_lp_ctx);
+                }
                 /* Hook any 'every Samba program must do this, after
 …
         if (reason == POPT_CALLBACK_REASON_PRE) {
                 cmdline_lp_ctx = loadparm_init(talloc_autofree_context());
+                cmdline_lp_ctx = loadparm_init_global(false);
                 /* Hook for 'almost the first thing to do in a samba program' here */
 …
         case OPT_OPTION:
                 if (!lp_set_option(cmdline_lp_ctx, arg)) {
+                if (!lpcfg_set_option(cmdline_lp_ctx, arg)) {
                         fprintf(stderr, "Error setting option '%s'\n", arg);
                         exit(1);
 …
         case 'd':
                 lp_set_cmdline(cmdline_lp_ctx, "log level", arg);
+                lpcfg_set_cmdline(cmdline_lp_ctx, "log level", arg);
                 break;
 …
         case 's':
                 if (arg) {
                         lp_load(cmdline_lp_ctx, arg);
+                        lpcfg_load(cmdline_lp_ctx, arg);
+                }
                 break;
 …
                 if (arg) {
                         char *new_logfile = talloc_asprintf(NULL, "%s/log.%s", arg, pname);
                         lp_set_cmdline(cmdline_lp_ctx, "log file", new_logfile);
+                        lpcfg_set_cmdline(cmdline_lp_ctx, "log file", new_logfile);
                         talloc_free(new_logfile);
+                }
 …
         case 'O':
                 if (arg) {
                         lp_set_cmdline(lp_ctx, "socket options", arg);
+                        lpcfg_set_cmdline(lp_ctx, "socket options", arg);
+                }
                 break;
         case 'W':
                 lp_set_cmdline(lp_ctx, "workgroup", arg);
+                lpcfg_set_cmdline(lp_ctx, "workgroup", arg);
                 break;
         case 'r':
                 lp_set_cmdline(lp_ctx, "realm", arg);
+                lpcfg_set_cmdline(lp_ctx, "realm", arg);
                 break;
         case 'n':
                 lp_set_cmdline(lp_ctx, "netbios name", arg);
+                lpcfg_set_cmdline(lp_ctx, "netbios name", arg);
                 break;
         case 'i':
                 lp_set_cmdline(lp_ctx, "netbios scope", arg);
+                lpcfg_set_cmdline(lp_ctx, "netbios scope", arg);
                 break;
         case 'm':
                 lp_set_cmdline(lp_ctx, "client max protocol", arg);
+                lpcfg_set_cmdline(lp_ctx, "client max protocol", arg);
                 break;
         case 'R':
                 lp_set_cmdline(lp_ctx, "name resolve order", arg);
+                lpcfg_set_cmdline(lp_ctx, "name resolve order", arg);
                 break;
         case 'S':
                 lp_set_cmdline(lp_ctx, "client signing", arg);
+                lpcfg_set_cmdline(lp_ctx, "client signing", arg);
                 break;

trunk/server/source4/lib/cmdline/popt_credentials.c

-              r414
+              r745
  *              -N,--no-pass
  *              -S,--signing
  *              -P --machine-pass
  *                 --simple-bind-dn
  *                 --password
+ *              -P,--machine-pass
+ *              --simple-bind-dn
+ *              --password
  */
+static bool dont_ask;
+static bool machine_account_pending;
+static bool dont_ask;
+enum opt { OPT_SIMPLE_BIND_DN, OPT_PASSWORD, OPT_KERBEROS };
+enum opt { OPT_SIMPLE_BIND_DN, OPT_PASSWORD, OPT_KERBEROS, OPT_SIGN, OPT_ENCRYPT };
 /*
 …
                         cli_credentials_set_cmdline_callbacks(cmdline_credentials);
+                }
+                if (machine_account_pending) {
+                        cli_credentials_set_machine_account(cmdline_credentials, cmdline_lp_ctx);
+                }
                 return;
+        }
 …
         case 'P':
                 /* Later, after this is all over, get the machine account details from the secrets.ldb */
                 cli_credentials_set_machine_account_pending(cmdline_credentials, cmdline_lp_ctx);
+                machine_account_pending = true;
                 break;
 …
                 if (arg) {
                         if (!set_boolean(arg, &use_kerberos)) {
+                                fprintf(stderr, "Error parsing -k %s\n", arg);
+                                fprintf(stderr, "Error parsing -k %s. Should be "
+                                        "-k [yes|no]\n", arg);
                                 exit(1);
                                 break;
 …
         case OPT_SIMPLE_BIND_DN:
+        {
                 cli_credentials_set_bind_dn(cmdline_credentials, arg);
                 break;
+        }
+        case OPT_SIGN:
+        {
+                uint32_t gensec_features;
+                gensec_features = cli_credentials_get_gensec_features(cmdline_credentials);
+                gensec_features |= GENSEC_FEATURE_SIGN;
+                cli_credentials_set_gensec_features(cmdline_credentials,
+                                                    gensec_features);
+                break;
+        }
+        case OPT_ENCRYPT:
+        {
+                uint32_t gensec_features;
+                gensec_features = cli_credentials_get_gensec_features(cmdline_credentials);
+                gensec_features |= GENSEC_FEATURE_SEAL;
+                cli_credentials_set_gensec_features(cmdline_credentials,
+                                                    gensec_features);
+                break;
+        }
+        }
+}
 …
         { "machine-pass", 'P', POPT_ARG_NONE, NULL, 'P', "Use stored machine account password (implies -k)" },
         { "simple-bind-dn", 0, POPT_ARG_STRING, NULL, OPT_SIMPLE_BIND_DN, "DN to use for a simple bind" },
+        { "kerberos", 'k', POPT_ARG_STRING, NULL, OPT_KERBEROS, "Use Kerberos" },
+        { "kerberos", 'k', POPT_ARG_STRING, NULL, OPT_KERBEROS, "Use Kerberos, -k [yes|no]" },
+        { "sign", 'S', POPT_ARG_NONE, NULL, OPT_SIGN, "Sign connection to prevent modification in transit" },
+        { "encrypt", 'e', POPT_ARG_NONE, NULL, OPT_ENCRYPT, "Encrypt connection for privacy" },
         { NULL }
 };

trunk/server/source4/lib/com/dcom/main.c

-              r414
+              r745
                 return dcerpc_pipe_connect(ctx->event_ctx, p, "ncalrpc",
                                                                    &ndr_table_IRemoteActivation,
                                                                    dcom_get_server_credentials(ctx, NULL), ctx->event_ctx, ctx->lp_ctx);
+                                                                   dcom_get_server_credentials(ctx, NULL), ctx->event_ctx, ctx->lp_ctx);
+        }
         loc_ctx = talloc_new(ctx);
 …
                 status = dcerpc_pipe_connect_b(ctx->event_ctx, p, bd,
                                                                            &ndr_table_IRemoteActivation,
                                                                    dcom_get_server_credentials(ctx, bd->host), ctx->event_ctx, ctx->lp_ctx);
+                                                                   dcom_get_server_credentials(ctx, bd->host), ctx->event_ctx, ctx->lp_ctx);
                 goto end;
+        }
 …
                 return;
+        }
+/*TODO: FIXME - for now this unused anyway */
         req = dcerpc_ndr_request_send(p, &s->d->obj.u_objref.u_standard.std.ipid, s->table, s->opnum, s, s->r);
         composite_continue_rpc(c, req, s->continuation, c);

trunk/server/source4/lib/com/main.c

r414	r745
53	53
54	54	/* Run IClassFactory::CreateInstance() */
55		error = IClassFactory_CreateInstance(factory, ctx, NULL, &classfact_iid, &iunk);
	55	error = IClassFactory_CreateInstance(factory, ctx, NULL, &classfact_iid, (struct MInterfacePointer *) &iunk);
56	56	if (!W_ERROR_IS_OK(error)) {
57	57	DEBUG(3, ("Error while calling IClassFactory::CreateInstance : %s\n", win_errstr(error)));

trunk/server/source4/lib/com/pycom.c

-              r414
+              r745
 */
+#include <Python.h>
 #include "includes.h"
-#include <Python.h>
 #include "lib/com/com.h"
 #include "librpc/ndr/libndr.h"
 #include "libcli/util/pyerrors.h"
-#ifndef Py_RETURN_NONE
-#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
-#endif
 static struct com_context *py_com_ctx = NULL; /* FIXME: evil global */

trunk/server/source4/lib/events/events.h

-              r414
+              r745
 #define __LIB_EVENTS_H__
 #define TEVENT_COMPAT_DEFINES 1
 #include <../lib/tevent/tevent.h>
+#include <tevent.h>
 struct tevent_context *s4_event_context_init(TALLOC_CTX *mem_ctx);
 struct tevent_context *event_context_find(TALLOC_CTX *mem_ctx) _DEPRECATED_;
+void s4_event_context_set_default(struct tevent_context *ev);
 #endif /* __LIB_EVENTS_H__ */

trunk/server/source4/lib/events/tevent_s4.c

-              r414
+              r745
+}
-/*
-  find an event context that is a parent of the given memory context,
-  or create a new event context as a child of the given context if
-  none is found
-  This should be used in preference to event_context_init() in places
-  where you would prefer to use the existing event context if possible
-  (which is most situations)
-*/
-struct tevent_context *event_context_find(TALLOC_CTX *mem_ctx)
+{
-        struct tevent_context *ev = talloc_find_parent_bytype(mem_ctx, struct tevent_context);
-        if (ev == NULL) {
-                ev = tevent_context_init(mem_ctx);
+        }
-        return ev;
+}

trunk/server/source4/lib/ldb-samba/ldif_handlers.c

-              r414
+              r745
    Copyright (C) Andrew Tridgell 2005
    Copyright (C) Andrew Bartlett 2006-2007
+   Copyright (C) Andrew Bartlett 2006-2009
    Copyright (C) Matthias Dieter WallnÃ¶fer 2009
      ** NOTE! The following LGPL license applies to the ldb
 …
 #include "includes.h"
 #include "lib/ldb/include/ldb.h"
 #include "lib/ldb/include/ldb_module.h"
+#include <ldb.h>
+#include <ldb_module.h>
 #include "ldb_handlers.h"
 #include "dsdb/samdb/samdb.h"
 …
 #include "librpc/gen_ndr/ndr_misc.h"
 #include "librpc/gen_ndr/ndr_drsblobs.h"
+#include "librpc/gen_ndr/ndr_dnsp.h"
 #include "librpc/ndr/libndr.h"
 #include "libcli/security/security.h"
 #include "param/param.h"
+#include "../lib/util/asn1.h"
 /*
   use ndr_print_* to convert a NDR formatted blob to a ldif formatted blob
+  If mask_errors is true, then function succeeds but out data
+  is set to "<Unable to decode binary data>" message
+  \return 0 on success; -1 on error
 */
 static int ldif_write_NDR(struct ldb_context *ldb, void *mem_ctx,
 …
                           size_t struct_size,
                           ndr_pull_flags_fn_t pull_fn,
+                          ndr_print_fn_t print_fn)
+                          ndr_print_fn_t print_fn,
+                          bool mask_errors)
+{
         uint8_t *p;
 …
         p = talloc_size(mem_ctx, struct_size);
         err = ndr_pull_struct_blob(in, mem_ctx,
-                                   lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
                                    p, pull_fn);
         if (err != NDR_ERR_SUCCESS) {
+                /* fail in not in mask_error mode */
+                if (!mask_errors) {
+                        return -1;
+                }
                 talloc_free(p);
                 out->data = (uint8_t *)talloc_strdup(mem_ctx, "<Unable to decode binary data>");
 …
                 return -1;
+        }
         ndr_err = ndr_push_struct_blob(out, mem_ctx, NULL, sid,
+        ndr_err = ndr_push_struct_blob(out, mem_ctx, sid,
                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
         talloc_free(sid);
 …
   convert a NDR formatted blob to a ldif formatted objectSid
 */
 static int ldif_write_objectSid(struct ldb_context *ldb, void *mem_ctx,
+int ldif_write_objectSid(struct ldb_context *ldb, void *mem_ctx,
                                 const struct ldb_val *in, struct ldb_val *out)
+{
 …
                 return -1;
+        }
         ndr_err = ndr_pull_struct_blob_all(in, sid, NULL, sid,
+        ndr_err = ndr_pull_struct_blob_all(in, sid, sid,
                                            (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 …
+}
 static bool ldif_comparision_objectSid_isString(const struct ldb_val *v)
+bool ldif_comparision_objectSid_isString(const struct ldb_val *v)
+{
         if (v->length < 3) {
 …
         /* Check it looks like a SID */
         ndr_err = ndr_pull_struct_blob_all(out, mem_ctx, NULL, &sid,
+        ndr_err = ndr_pull_struct_blob_all(out, mem_ctx, &sid,
                                            (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 …
         struct GUID guid;
         NTSTATUS status;
-        enum ndr_err_code ndr_err;
         status = GUID_from_data_blob(in, &guid);
 …
+        }
+        ndr_err = ndr_push_struct_blob(out, mem_ctx, NULL, &guid,
+                                       (ndr_push_flags_fn_t)ndr_push_GUID);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+        status = GUID_to_ndr_blob(&guid, mem_ctx, out);
+        if (!NT_STATUS_IS_OK(status)) {
                 return -1;
+        }
 …
+{
         struct GUID guid;
         enum ndr_err_code ndr_err;
+        ndr_err = ndr_pull_struct_blob_all(in, mem_ctx, NULL, &guid,
                                            (ndr_pull_flags_fn_t)ndr_pull_GUID);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+        NTSTATUS status;
+        status = GUID_from_ndr_blob(in, &guid);
+        if (!NT_STATUS_IS_OK(status)) {
                 return -1;
+        }
 …
+{
         struct GUID guid;
+        enum ndr_err_code ndr_err;
+        NTSTATUS status;
         if (in->length == 36 && ldif_read_objectGUID(ldb, mem_ctx, in, out) == 0) {
                 return 0;
 …
         /* Check it looks like a GUID */
         ndr_err = ndr_pull_struct_blob_all(out, mem_ctx, NULL, &guid,
                                            (ndr_pull_flags_fn_t)ndr_pull_GUID);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+        status = GUID_from_ndr_blob(out, &guid);
+        if (!NT_STATUS_IS_OK(status)) {
+                data_blob_free(out);
                 return -1;
+        }
 …
+        }
         ndr_err = ndr_pull_struct_blob(in, sd, NULL, sd,
+        ndr_err = ndr_pull_struct_blob(in, sd, sd,
                                        (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 /* If this does not parse, then it is probably SDDL, and we should try it that way */
                 const struct dom_sid *sid = samdb_domain_sid(ldb);
                 talloc_free(sd);
 …
+        }
         ndr_err = ndr_push_struct_blob(out, mem_ctx, NULL, sd,
+        ndr_err = ndr_push_struct_blob(out, mem_ctx, sd,
                                        (ndr_push_flags_fn_t)ndr_push_security_descriptor);
         talloc_free(sd);
 …
                                       sizeof(struct security_descriptor),
                                       (ndr_pull_flags_fn_t)ndr_pull_security_descriptor,
+                                      (ndr_print_fn_t)ndr_print_security_descriptor);
+                                      (ndr_print_fn_t)ndr_print_security_descriptor,
+                                      true);
+        }
 …
+        }
         /* We can't use ndr_pull_struct_blob_all because this contains relative pointers */
         ndr_err = ndr_pull_struct_blob(in, sd, NULL, sd,
+        ndr_err = ndr_pull_struct_blob(in, sd, sd,
                                            (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 …
                 return -1;
+        }
         out->data = (uint8_t *)sddl_encode(mem_ctx, sd, NULL);
+        out->data = (uint8_t *)sddl_encode(mem_ctx, sd, samdb_domain_sid_cache_only(ldb));
         talloc_free(sd);
         if (out->data == NULL) {
 …
 /*
    canonicalise an objectCategory.  We use the short form as the cannoical form:
+   canonicalise an objectCategory.  We use the short form as the canonical form:
    cn=Person,cn=Schema,cn=Configuration,<basedn> becomes 'person'
 */
 …
+{
         struct ldb_dn *dn1 = NULL;
         const struct dsdb_schema *schema = dsdb_get_schema(ldb);
+        const struct dsdb_schema *schema = dsdb_get_schema(ldb, NULL);
         const struct dsdb_class *sclass;
         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 …
                                           const struct ldb_val *v2)
+{
+        int ret, ret1, ret2;
+        struct ldb_val v1_canon, v2_canon;
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+        /* I could try and bail if tmp_ctx was NULL, but what return
+         * value would I use?
+         *
+         * It seems easier to continue on the NULL context
+         */
+        ret1 = ldif_canonicalise_objectCategory(ldb, tmp_ctx, v1, &v1_canon);
+        ret2 = ldif_canonicalise_objectCategory(ldb, tmp_ctx, v2, &v2_canon);
+        if (ret1 == LDB_SUCCESS && ret2 == LDB_SUCCESS) {
+                ret = data_blob_cmp(&v1_canon, &v2_canon);
+        } else {
+                ret = data_blob_cmp(v1, v2);
+        }
+        talloc_free(tmp_ctx);
+        return ret;
+        return ldb_any_comparison(ldb, mem_ctx, ldif_canonicalise_objectCategory,
+                                  v1, v2);
+}
+/*
+  convert a NDR formatted blob to a ldif formatted schemaInfo
+*/
+static int ldif_write_schemaInfo(struct ldb_context *ldb, void *mem_ctx,
+                                 const struct ldb_val *in, struct ldb_val *out)
+{
+        return ldif_write_NDR(ldb, mem_ctx, in, out,
+                              sizeof(struct repsFromToBlob),
+                              (ndr_pull_flags_fn_t)ndr_pull_schemaInfoBlob,
+                              (ndr_print_fn_t)ndr_print_schemaInfoBlob,
+                              true);
+}
 …
         enum ndr_err_code ndr_err;
         char *string, *line, *p, *oid;
+        DATA_BLOB oid_blob;
         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 …
         blob = talloc_zero(tmp_ctx, struct prefixMapBlob);
         if (blob == NULL) {
+                talloc_free(blob);
+                return -1;
+        }
+                talloc_free(tmp_ctx);
+                return -1;
+        }
+        /* use the switch value to detect if this is in the binary
+         * format
+         */
+        if (in->length >= 4 && IVAL(in->data, 0) == PREFIX_MAP_VERSION_DSDB) {
+                ndr_err = ndr_pull_struct_blob(in, tmp_ctx, blob,
+                                               (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob);
+                if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                        ndr_err = ndr_push_struct_blob(out, mem_ctx,
+                                                       blob,
+                                                       (ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
+                        talloc_free(tmp_ctx);
+                        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                                return -1;
+                        }
+                        return 0;
+                }
+        }
+        /* If this does not parse, then it is probably the text version, and we should try it that way */
         blob->version = PREFIX_MAP_VERSION_DSDB;
 …
+                        }
+                }
                 /* allow a traling seperator */
+                /* allow a trailing separator */
                 if (line == p) {
                         break;
 …
                 oid++;
+                blob->ctr.dsdb.mappings[blob->ctr.dsdb.num_mappings].oid.oid
+                        = talloc_strdup(blob->ctr.dsdb.mappings, oid);
+                if (!ber_write_partial_OID_String(blob->ctr.dsdb.mappings, &oid_blob, oid)) {
+                        talloc_free(tmp_ctx);
+                        return -1;
+                }
+                blob->ctr.dsdb.mappings[blob->ctr.dsdb.num_mappings].oid.length = oid_blob.length;
+                blob->ctr.dsdb.mappings[blob->ctr.dsdb.num_mappings].oid.binary_oid = oid_blob.data;
                 blob->ctr.dsdb.num_mappings++;
 …
         ndr_err = ndr_push_struct_blob(out, mem_ctx,
-                                       lp_iconv_convenience(ldb_get_opaque(ldb, "loadparm")),
                                        blob,
                                        (ndr_push_flags_fn_t)ndr_push_prefixMapBlob);
 …
         if (ldb_get_flags(ldb) & LDB_FLG_SHOW_BINARY) {
+                return ldif_write_NDR(ldb, mem_ctx, in, out,
+                                      sizeof(struct prefixMapBlob),
+                                      (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob,
+                                      (ndr_print_fn_t)ndr_print_prefixMapBlob);
+                int err;
+                /* try to decode the blob as S4 prefixMap */
+                err = ldif_write_NDR(ldb, mem_ctx, in, out,
+                                     sizeof(struct prefixMapBlob),
+                                     (ndr_pull_flags_fn_t)ndr_pull_prefixMapBlob,
+                                     (ndr_print_fn_t)ndr_print_prefixMapBlob,
+                                     false);
+                if (0 == err) {
+                        return err;
+                }
+                /* try parsing it as Windows PrefixMap value */
+                return ldif_write_NDR(ldb, mem_ctx, in, out,
+                                      sizeof(struct drsuapi_MSPrefixMap_Ctr),
+                                      (ndr_pull_flags_fn_t)ndr_pull_drsuapi_MSPrefixMap_Ctr,
+                                      (ndr_print_fn_t)ndr_print_drsuapi_MSPrefixMap_Ctr,
+                                      true);
+        }
 …
+        }
         ndr_err = ndr_pull_struct_blob_all(in, 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)) {
+                talloc_free(blob);
+                return -1;
+                goto failed;
+        }
         if (blob->version != PREFIX_MAP_VERSION_DSDB) {
                 return -1;
+                goto failed;
+        }
         string = talloc_strdup(mem_ctx, "");
         if (string == NULL) {
                 return -1;
+                goto failed;
+        }
         for (i=0; i < blob->ctr.dsdb.num_mappings; i++) {
+                DATA_BLOB oid_blob;
+                char *partial_oid = NULL;
                 if (i > 0) {
                         string = talloc_asprintf_append(string, ";");
+                }
+                oid_blob = data_blob_const(blob->ctr.dsdb.mappings[i].oid.binary_oid,
+                                           blob->ctr.dsdb.mappings[i].oid.length);
+                if (!ber_read_partial_OID_String(blob, oid_blob, &partial_oid)) {
+                        DEBUG(0, ("ber_read_partial_OID failed on prefixMap item with id: 0x%X",
+                                  blob->ctr.dsdb.mappings[i].id_prefix));
+                        goto failed;
+                }
                 string = talloc_asprintf_append(string, "%u:%s",
                                                    blob->ctr.dsdb.mappings[i].id_prefix,
+                                                   blob->ctr.dsdb.mappings[i].oid.oid);
+                                                   partial_oid);
+                talloc_free(discard_const(partial_oid));
                 if (string == NULL) {
                         return -1;
+                        goto failed;
+                }
+        }
 …
         *out = data_blob_string_const(string);
         return 0;
+failed:
+        talloc_free(blob);
+        return -1;
+}
 …
                                      const struct ldb_val *v2)
+{
+        int ret, ret1, ret2;
+        struct ldb_val v1_canon, v2_canon;
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+        /* I could try and bail if tmp_ctx was NULL, but what return
+         * value would I use?
+         *
+         * It seems easier to continue on the NULL context
+         */
+        ret1 = ldif_canonicalise_prefixMap(ldb, tmp_ctx, v1, &v1_canon);
+        ret2 = ldif_canonicalise_prefixMap(ldb, tmp_ctx, v2, &v2_canon);
+        if (ret1 == LDB_SUCCESS && ret2 == LDB_SUCCESS) {
+                ret = data_blob_cmp(&v1_canon, &v2_canon);
+        } else {
+                ret = data_blob_cmp(v1, v2);
+        }
+        talloc_free(tmp_ctx);
+        return ret;
+        return ldb_any_comparison(ldb, mem_ctx, ldif_canonicalise_prefixMap,
+                                  v1, v2);
+}
+/* length limited conversion of a ldb_val to a int32_t */
+static int val_to_int32(const struct ldb_val *in, int32_t *v)
+{
+        char *end;
+        char buf[64];
+        /* make sure we don't read past the end of the data */
+        if (in->length > sizeof(buf)-1) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        strncpy(buf, (char *)in->data, in->length);
+        buf[in->length] = 0;
+        /* We've to use "strtoll" here to have the intended overflows.
+         * Otherwise we may get "LONG_MAX" and the conversion is wrong. */
+        *v = (int32_t) strtoll(buf, &end, 0);
+        if (*end != 0) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        return LDB_SUCCESS;
+}
+/* length limited conversion of a ldb_val to a int64_t */
+static int val_to_int64(const struct ldb_val *in, int64_t *v)
+{
+        char *end;
+        char buf[64];
+        /* make sure we don't read past the end of the data */
+        if (in->length > sizeof(buf)-1) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        strncpy(buf, (char *)in->data, in->length);
+        buf[in->length] = 0;
+        *v = (int64_t) strtoll(buf, &end, 0);
+        if (*end != 0) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        return LDB_SUCCESS;
+}
 …
                         const struct ldb_val *in, struct ldb_val *out)
+{
         char *end;
         /* We've to use "strtoll" here to have the intended overflows.
+         * Otherwise we may get "LONG_MAX" and the conversion is wrong. */
         int32_t i = (int32_t) strtoll((char *)in->data, &end, 0);
         if (*end != 0) {
                 return -1;
+        int32_t i;
+        int ret;
+        ret = val_to_int32(in, &i);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
         out->data = (uint8_t *) talloc_asprintf(mem_ctx, "%d", i);
         if (out->data == NULL) {
+                return -1;
+                ldb_oom(ldb);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         out->length = strlen((char *)out->data);
 …
 /* Comparison of two 32-bit integers */
 static int ldif_comparison_int32(struct ldb_context *ldb, void *mem_ctx,
+                        const struct ldb_val *v1, const struct ldb_val *v2)
+{
+        /* We've to use "strtoll" here to have the intended overflows.
+         * Otherwise we may get "LONG_MAX" and the conversion is wrong. */
+        return (int32_t) strtoll((char *)v1->data, NULL, 0)
+         - (int32_t) strtoll((char *)v2->data, NULL, 0);
+                                 const struct ldb_val *v1, const struct ldb_val *v2)
+{
+        int32_t i1=0, i2=0;
+        val_to_int32(v1, &i1);
+        val_to_int32(v2, &i2);
+        if (i1 == i2) return 0;
+        return i1 > i2? 1 : -1;
+}
+/* Canonicalisation of two 64-bit integers */
+static int ldif_canonicalise_int64(struct ldb_context *ldb, void *mem_ctx,
+                                   const struct ldb_val *in, struct ldb_val *out)
+{
+        int64_t i;
+        int ret;
+        ret = val_to_int64(in, &i);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        out->data = (uint8_t *) talloc_asprintf(mem_ctx, "%lld", (long long)i);
+        if (out->data == NULL) {
+                ldb_oom(ldb);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        out->length = strlen((char *)out->data);
+        return 0;
+}
+/* Comparison of two 64-bit integers */
+static int ldif_comparison_int64(struct ldb_context *ldb, void *mem_ctx,
+                                 const struct ldb_val *v1, const struct ldb_val *v2)
+{
+        int64_t i1=0, i2=0;
+        val_to_int64(v1, &i1);
+        val_to_int64(v2, &i2);
+        if (i1 == i2) return 0;
+        return i1 > i2? 1 : -1;
+}
 …
                               sizeof(struct repsFromToBlob),
                               (ndr_pull_flags_fn_t)ndr_pull_repsFromToBlob,
+                              (ndr_print_fn_t)ndr_print_repsFromToBlob);
+                              (ndr_print_fn_t)ndr_print_repsFromToBlob,
+                              true);
+}
 …
                               sizeof(struct replPropertyMetaDataBlob),
                               (ndr_pull_flags_fn_t)ndr_pull_replPropertyMetaDataBlob,
+                              (ndr_print_fn_t)ndr_print_replPropertyMetaDataBlob);
+                              (ndr_print_fn_t)ndr_print_replPropertyMetaDataBlob,
+                              true);
+}
 …
                               sizeof(struct replUpToDateVectorBlob),
                               (ndr_pull_flags_fn_t)ndr_pull_replUpToDateVectorBlob,
+                              (ndr_print_fn_t)ndr_print_replPropertyMetaDataBlob);
+                              (ndr_print_fn_t)ndr_print_replUpToDateVectorBlob,
+                              true);
+}
+/*
+  convert a NDR formatted blob to a ldif formatted dnsRecord
+*/
+static int ldif_write_dnsRecord(struct ldb_context *ldb, void *mem_ctx,
+                                const struct ldb_val *in, struct ldb_val *out)
+{
+        return ldif_write_NDR(ldb, mem_ctx, in, out,
+                              sizeof(struct dnsp_DnssrvRpcRecord),
+                              (ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord,
+                              (ndr_print_fn_t)ndr_print_dnsp_DnssrvRpcRecord,
+                              true);
+}
+/*
+  convert a NDR formatted blob of a supplementalCredentials into text
+*/
+static int ldif_write_supplementalCredentialsBlob(struct ldb_context *ldb, void *mem_ctx,
+                                                  const struct ldb_val *in, struct ldb_val *out)
+{
+        return ldif_write_NDR(ldb, mem_ctx, in, out,
+                              sizeof(struct supplementalCredentialsBlob),
+                              (ndr_pull_flags_fn_t)ndr_pull_supplementalCredentialsBlob,
+                              (ndr_print_fn_t)ndr_print_supplementalCredentialsBlob,
+                              true);
+}
 …
                                  const struct ldb_val *in, struct ldb_val *out)
+{
         *out = data_blob_string_const(data_blob_hex_string(mem_ctx, in));
+        *out = data_blob_string_const(data_blob_hex_string_lower(mem_ctx, in));
         if (!out->data) {
                 return -1;
 …
         return 0;
+}
+/*
+  compare two dns
+*/
+static int samba_ldb_dn_link_comparison(struct ldb_context *ldb, void *mem_ctx,
+                                        const struct ldb_val *v1, const struct ldb_val *v2)
+{
+        struct ldb_dn *dn1 = NULL, *dn2 = NULL;
+        int ret;
+        if (dsdb_dn_is_deleted_val(v1)) {
+                /* If the DN is deleted, then we can't search for it */
+                return -1;
+        }
+        if (dsdb_dn_is_deleted_val(v2)) {
+                /* If the DN is deleted, then we can't search for it */
+                return -1;
+        }
+        dn1 = ldb_dn_from_ldb_val(mem_ctx, ldb, v1);
+        if ( ! ldb_dn_validate(dn1)) return -1;
+        dn2 = ldb_dn_from_ldb_val(mem_ctx, ldb, v2);
+        if ( ! ldb_dn_validate(dn2)) {
+                talloc_free(dn1);
+                return -1;
+        }
+        ret = ldb_dn_compare(dn1, dn2);
+        talloc_free(dn1);
+        talloc_free(dn2);
+        return ret;
+}
+static int samba_ldb_dn_link_canonicalise(struct ldb_context *ldb, void *mem_ctx,
+                                          const struct ldb_val *in, struct ldb_val *out)
+{
+        struct ldb_dn *dn;
+        int ret = -1;
+        out->length = 0;
+        out->data = NULL;
+        dn = ldb_dn_from_ldb_val(mem_ctx, ldb, in);
+        if ( ! ldb_dn_validate(dn)) {
+                return LDB_ERR_INVALID_DN_SYNTAX;
+        }
+        /* By including the RMD_FLAGS of a deleted DN, we ensure it
+         * does not casually match a not deleted DN */
+        if (dsdb_dn_is_deleted_val(in)) {
+                out->data = (uint8_t *)talloc_asprintf(mem_ctx,
+                                                       "<RMD_FLAGS=%u>%s",
+                                                       dsdb_dn_val_rmd_flags(in),
+                                                       ldb_dn_get_casefold(dn));
+        } else {
+                out->data = (uint8_t *)ldb_dn_alloc_casefold(mem_ctx, dn);
+        }
+        if (out->data == NULL) {
+                goto done;
+        }
+        out->length = strlen((char *)out->data);
+        ret = 0;
+done:
+        talloc_free(dn);
+        return ret;
+}
+/*
+  write a 64 bit 2-part range
+*/
+static int ldif_write_range64(struct ldb_context *ldb, void *mem_ctx,
+                              const struct ldb_val *in, struct ldb_val *out)
+{
+        int64_t v;
+        int ret;
+        ret = val_to_int64(in, &v);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        out->data = (uint8_t *)talloc_asprintf(mem_ctx, "%lu-%lu",
+                                               (unsigned long)(v&0xFFFFFFFF),
+                                               (unsigned long)(v>>32));
+        if (out->data == NULL) {
+                ldb_oom(ldb);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        out->length = strlen((char *)out->data);
+        return LDB_SUCCESS;
+}
+/*
+  read a 64 bit 2-part range
+*/
+static int ldif_read_range64(struct ldb_context *ldb, void *mem_ctx,
+                              const struct ldb_val *in, struct ldb_val *out)
+{
+        unsigned long high, low;
+        char buf[64];
+        if (memchr(in->data, '-', in->length) == NULL) {
+                return ldb_handler_copy(ldb, mem_ctx, in, out);
+        }
+        if (in->length > sizeof(buf)-1) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        strncpy(buf, (const char *)in->data, in->length);
+        buf[in->length] = 0;
+        if (sscanf(buf, "%lu-%lu", &low, &high) != 2) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        out->data = (uint8_t *)talloc_asprintf(mem_ctx, "%llu",
+                                               (unsigned long long)(((uint64_t)high)<<32) | (low));
+        if (out->data == NULL) {
+                ldb_oom(ldb);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        out->length = strlen((char *)out->data);
+        return LDB_SUCCESS;
+}
+/*
+  when this operator_fn is set for a syntax, the backend calls is in
+  preference to the comparison function. We are told the exact
+  comparison operation that is needed, and we can return errors
+ */
+static int samba_syntax_operator_fn(struct ldb_context *ldb, enum ldb_parse_op operation,
+                                    const struct ldb_schema_attribute *a,
+                                    const struct ldb_val *v1, const struct ldb_val *v2, bool *matched)
+{
+        switch (operation) {
+        case LDB_OP_AND:
+        case LDB_OP_OR:
+        case LDB_OP_NOT:
+        case LDB_OP_SUBSTRING:
+        case LDB_OP_APPROX:
+        case LDB_OP_EXTENDED:
+                /* handled in the backends */
+                return LDB_ERR_INAPPROPRIATE_MATCHING;
+        case LDB_OP_GREATER:
+        case LDB_OP_LESS:
+        case LDB_OP_EQUALITY:
+        {
+                TALLOC_CTX *tmp_ctx = talloc_new(ldb);
+                int ret;
+                if (tmp_ctx == NULL) {
+                        return ldb_oom(ldb);
+                }
+                ret = a->syntax->comparison_fn(ldb, tmp_ctx, v1, v2);
+                talloc_free(tmp_ctx);
+                if (operation == LDB_OP_GREATER) {
+                        *matched = (ret > 0);
+                } else if (operation == LDB_OP_LESS) {
+                        *matched = (ret < 0);
+                } else {
+                        *matched = (ret == 0);
+                }
+                return LDB_SUCCESS;
+        }
+        case LDB_OP_PRESENT:
+                *matched = true;
+                return LDB_SUCCESS;
+        }
+        /* we shouldn't get here */
+        return LDB_ERR_INAPPROPRIATE_MATCHING;
+}
+/*
+  special operation for DNs, to take account of the RMD_FLAGS deleted bit
+ */
+static int samba_syntax_operator_dn(struct ldb_context *ldb, enum ldb_parse_op operation,
+                                    const struct ldb_schema_attribute *a,
+                                    const struct ldb_val *v1, const struct ldb_val *v2, bool *matched)
+{
+        if (operation == LDB_OP_PRESENT && dsdb_dn_is_deleted_val(v1)) {
+                /* If the DN is deleted, then we can't search for it */
+                *matched = false;
+                return LDB_SUCCESS;
+        }
+        return samba_syntax_operator_fn(ldb, operation, a, v1, v2, matched);
+}
 static const struct ldb_schema_syntax samba_syntaxes[] = {
 …
                 .ldif_write_fn    = ldif_write_objectSid,
                 .canonicalise_fn  = ldif_canonicalise_objectSid,
+                .comparison_fn    = ldif_comparison_objectSid
+                .comparison_fn    = ldif_comparison_objectSid,
+                .operator_fn      = samba_syntax_operator_fn
         },{
                 .name             = LDB_SYNTAX_SAMBA_SECURITY_DESCRIPTOR,
 …
                 .ldif_write_fn    = ldif_write_ntSecurityDescriptor,
                 .canonicalise_fn  = ldb_handler_copy,
+                .comparison_fn    = ldb_comparison_binary
+                .comparison_fn    = ldb_comparison_binary,
+                .operator_fn      = samba_syntax_operator_fn
         },{
                 .name             = LDB_SYNTAX_SAMBA_GUID,
 …
                 .ldif_write_fn    = ldif_write_objectGUID,
                 .canonicalise_fn  = ldif_canonicalise_objectGUID,
+                .comparison_fn    = ldif_comparison_objectGUID
+                .comparison_fn    = ldif_comparison_objectGUID,
+                .operator_fn      = samba_syntax_operator_fn
         },{
                 .name             = LDB_SYNTAX_SAMBA_OBJECT_CATEGORY,
 …
                 .ldif_write_fn    = ldb_handler_copy,
                 .canonicalise_fn  = ldif_canonicalise_objectCategory,
+                .comparison_fn    = ldif_comparison_objectCategory
+                .comparison_fn    = ldif_comparison_objectCategory,
+                .operator_fn      = samba_syntax_operator_fn
+        },{
+                .name             = LDB_SYNTAX_SAMBA_SCHEMAINFO,
+                .ldif_read_fn     = ldb_handler_copy,
+                .ldif_write_fn    = ldif_write_schemaInfo,
+                .canonicalise_fn  = ldb_handler_copy,
+                .comparison_fn    = ldb_comparison_binary,
+                .operator_fn      = samba_syntax_operator_fn
         },{
                 .name             = LDB_SYNTAX_SAMBA_PREFIX_MAP,
 …
                 .ldif_write_fn    = ldif_write_prefixMap,
                 .canonicalise_fn  = ldif_canonicalise_prefixMap,
+                .comparison_fn    = ldif_comparison_prefixMap
+                .comparison_fn    = ldif_comparison_prefixMap,
+                .operator_fn      = samba_syntax_operator_fn
         },{
                 .name             = LDB_SYNTAX_SAMBA_INT32,
 …
                 .ldif_write_fn    = ldb_handler_copy,
                 .canonicalise_fn  = ldif_canonicalise_int32,
+                .comparison_fn    = ldif_comparison_int32
+                .comparison_fn    = ldif_comparison_int32,
+                .operator_fn      = samba_syntax_operator_fn
         },{
                 .name             = LDB_SYNTAX_SAMBA_REPSFROMTO,
 …
                 .ldif_write_fn    = ldif_write_repsFromTo,
                 .canonicalise_fn  = ldb_handler_copy,
+                .comparison_fn    = ldb_comparison_binary
+                .comparison_fn    = ldb_comparison_binary,
+                .operator_fn      = samba_syntax_operator_fn
         },{
                 .name             = LDB_SYNTAX_SAMBA_REPLPROPERTYMETADATA,
 …
                 .ldif_write_fn    = ldif_write_replPropertyMetaData,
                 .canonicalise_fn  = ldb_handler_copy,
+                .comparison_fn    = ldb_comparison_binary
+                .comparison_fn    = ldb_comparison_binary,
+                .operator_fn      = samba_syntax_operator_fn
         },{
                 .name             = LDB_SYNTAX_SAMBA_REPLUPTODATEVECTOR,
 …
                 .ldif_write_fn    = ldif_write_replUpToDateVector,
                 .canonicalise_fn  = ldb_handler_copy,
+                .comparison_fn    = ldb_comparison_binary
+        },
+                .comparison_fn    = ldb_comparison_binary,
+                .operator_fn      = samba_syntax_operator_fn
+        },{
+                .name             = DSDB_SYNTAX_BINARY_DN,
+                .ldif_read_fn     = ldb_handler_copy,
+                .ldif_write_fn    = ldb_handler_copy,
+                .canonicalise_fn  = dsdb_dn_binary_canonicalise,
+                .comparison_fn    = dsdb_dn_binary_comparison,
+                .operator_fn      = samba_syntax_operator_fn
+        },{
+                .name             = DSDB_SYNTAX_STRING_DN,
+                .ldif_read_fn     = ldb_handler_copy,
+                .ldif_write_fn    = ldb_handler_copy,
+                .canonicalise_fn  = dsdb_dn_string_canonicalise,
+                .comparison_fn    = dsdb_dn_string_comparison,
+                .operator_fn      = samba_syntax_operator_fn
+        },{
+                .name             = LDB_SYNTAX_DN,
+                .ldif_read_fn     = ldb_handler_copy,
+                .ldif_write_fn    = ldb_handler_copy,
+                .canonicalise_fn  = samba_ldb_dn_link_canonicalise,
+                .comparison_fn    = samba_ldb_dn_link_comparison,
+                .operator_fn      = samba_syntax_operator_dn
+        },{
+                .name             = LDB_SYNTAX_SAMBA_RANGE64,
+                .ldif_read_fn     = ldif_read_range64,
+                .ldif_write_fn    = ldif_write_range64,
+                .canonicalise_fn  = ldif_canonicalise_int64,
+                .comparison_fn    = ldif_comparison_int64,
+                .operator_fn      = samba_syntax_operator_fn
+        },{
+                .name             = LDB_SYNTAX_SAMBA_DNSRECORD,
+                .ldif_read_fn     = ldb_handler_copy,
+                .ldif_write_fn    = ldif_write_dnsRecord,
+                .canonicalise_fn  = ldb_handler_copy,
+                .comparison_fn    = ldb_comparison_binary,
+                .operator_fn      = samba_syntax_operator_fn
+        },{
+                .name             = LDB_SYNTAX_SAMBA_SUPPLEMENTALCREDENTIALS,
+                .ldif_read_fn     = ldb_handler_copy,
+                .ldif_write_fn    = ldif_write_supplementalCredentialsBlob,
+                .canonicalise_fn  = ldb_handler_copy,
+                .comparison_fn    = ldb_comparison_binary,
+                .operator_fn      = samba_syntax_operator_fn
+        }
 };
 …
         },{
                 .name             = "WKGUID",
+                .read_fn          = ldb_handler_copy,
+                .write_clear_fn   = ldb_handler_copy,
+                .write_hex_fn     = ldb_handler_copy
+        },{
+                .name             = "RMD_INVOCID",
+                .read_fn          = extended_dn_read_GUID,
+                .write_clear_fn   = ldif_write_objectGUID,
+                .write_hex_fn     = extended_dn_write_hex
+        },{
+                .name             = "RMD_FLAGS",
+                .read_fn          = ldb_handler_copy,
+                .write_clear_fn   = ldb_handler_copy,
+                .write_hex_fn     = ldb_handler_copy
+        },{
+                .name             = "RMD_ADDTIME",
+                .read_fn          = ldb_handler_copy,
+                .write_clear_fn   = ldb_handler_copy,
+                .write_hex_fn     = ldb_handler_copy
+        },{
+                .name             = "RMD_CHANGETIME",
+                .read_fn          = ldb_handler_copy,
+                .write_clear_fn   = ldb_handler_copy,
+                .write_hex_fn     = ldb_handler_copy
+        },{
+                .name             = "RMD_LOCAL_USN",
+                .read_fn          = ldb_handler_copy,
+                .write_clear_fn   = ldb_handler_copy,
+                .write_hex_fn     = ldb_handler_copy
+        },{
+                .name             = "RMD_ORIGINATING_USN",
+                .read_fn          = ldb_handler_copy,
+                .write_clear_fn   = ldb_handler_copy,
+                .write_hex_fn     = ldb_handler_copy
+        },{
+                .name             = "RMD_VERSION",
                 .read_fn          = ldb_handler_copy,
                 .write_clear_fn   = ldb_handler_copy,
 …
         { "objectSid",                  LDB_SYNTAX_SAMBA_SID },
         { "securityIdentifier",         LDB_SYNTAX_SAMBA_SID },
+        { "tokenGroups",                LDB_SYNTAX_SAMBA_SID },
         { "ntSecurityDescriptor",       LDB_SYNTAX_SAMBA_SECURITY_DESCRIPTOR },
+        { "objectGUID",                 LDB_SYNTAX_SAMBA_GUID },
+        { "invocationId",               LDB_SYNTAX_SAMBA_GUID },
+        { "schemaIDGUID",               LDB_SYNTAX_SAMBA_GUID },
+        { "attributeSecurityGUID",      LDB_SYNTAX_SAMBA_GUID },
+        { "parentGUID",                 LDB_SYNTAX_SAMBA_GUID },
+        { "siteGUID",                   LDB_SYNTAX_SAMBA_GUID },
+        { "pKTGUID",                    LDB_SYNTAX_SAMBA_GUID },
+        { "fRSVersionGUID",             LDB_SYNTAX_SAMBA_GUID },
+        { "fRSReplicaSetGUID",          LDB_SYNTAX_SAMBA_GUID },
+        { "netbootGUID",                LDB_SYNTAX_SAMBA_GUID },
+        { "oMSyntax",                   LDB_SYNTAX_SAMBA_INT32 },
         { "objectCategory",             LDB_SYNTAX_SAMBA_OBJECT_CATEGORY },
+        { "schemaInfo",                 LDB_SYNTAX_SAMBA_SCHEMAINFO },
         { "prefixMap",                  LDB_SYNTAX_SAMBA_PREFIX_MAP },
         { "repsFrom",                   LDB_SYNTAX_SAMBA_REPSFROMTO },
 …
         { "replPropertyMetaData",       LDB_SYNTAX_SAMBA_REPLPROPERTYMETADATA },
         { "replUpToDateVector",         LDB_SYNTAX_SAMBA_REPLUPTODATEVECTOR },
+        { "rIDAllocationPool",          LDB_SYNTAX_SAMBA_RANGE64 },
+        { "rIDPreviousAllocationPool",  LDB_SYNTAX_SAMBA_RANGE64 },
+        { "rIDAvailablePool",           LDB_SYNTAX_SAMBA_RANGE64 },
+        /*
+         * these are extracted by searching
+         * (&(attributeSyntax=2.5.5.10)(rangeLower=16)(rangeUpper=16)(omSyntax=4))
+         */
+        { "attributeSecurityGUID",              LDB_SYNTAX_SAMBA_GUID },
+        { "categoryId",                         LDB_SYNTAX_SAMBA_GUID },
+        { "controlAccessRights",                LDB_SYNTAX_SAMBA_GUID },
+        { "currMachineId",                      LDB_SYNTAX_SAMBA_GUID },
+        { "fRSReplicaSetGUID",                  LDB_SYNTAX_SAMBA_GUID },
+        { "fRSVersionGUID",                     LDB_SYNTAX_SAMBA_GUID },
+        { "implementedCategories",              LDB_SYNTAX_SAMBA_GUID },
+        { "msDS-AzObjectGuid",                  LDB_SYNTAX_SAMBA_GUID },
+        { "msDFSR-ContentSetGuid",              LDB_SYNTAX_SAMBA_GUID },
+        { "msDFSR-ReplicationGroupGuid",        LDB_SYNTAX_SAMBA_GUID },
+        { "mSMQDigests",                        LDB_SYNTAX_SAMBA_GUID },
+        { "mSMQOwnerID",                        LDB_SYNTAX_SAMBA_GUID },
+        { "mSMQQMID",                           LDB_SYNTAX_SAMBA_GUID },
+        { "mSMQQueueType",                      LDB_SYNTAX_SAMBA_GUID },
+        { "mSMQSites",                          LDB_SYNTAX_SAMBA_GUID },
+        { "netbootGUID",                        LDB_SYNTAX_SAMBA_GUID },
+        { "objectGUID",                         LDB_SYNTAX_SAMBA_GUID },
+        { "pKTGuid",                            LDB_SYNTAX_SAMBA_GUID },
+        { "requiredCategories",                 LDB_SYNTAX_SAMBA_GUID },
+        { "schemaIDGUID",                       LDB_SYNTAX_SAMBA_GUID },
+        { "siteGUID",                           LDB_SYNTAX_SAMBA_GUID },
+        { "msDFS-GenerationGUIDv2",             LDB_SYNTAX_SAMBA_GUID },
+        { "msDFS-LinkIdentityGUIDv2",           LDB_SYNTAX_SAMBA_GUID },
+        { "msDFS-NamespaceIdentityGUIDv2",      LDB_SYNTAX_SAMBA_GUID },
+        /*
+         * these are known to be GUIDs
+         */
+        { "invocationId",                       LDB_SYNTAX_SAMBA_GUID },
+        { "parentGUID",                         LDB_SYNTAX_SAMBA_GUID },
+        { "msDS-OptionalFeatureGUID",           LDB_SYNTAX_SAMBA_GUID },
+        /* These NDR encoded things we want to be able to read with --show-binary */
+        { "dnsRecord",                          LDB_SYNTAX_SAMBA_DNSRECORD },
+        { "supplementalCredentials",            LDB_SYNTAX_SAMBA_SUPPLEMENTALCREDENTIALS}
 };
 const struct ldb_schema_syntax *ldb_samba_syntax_by_name(struct ldb_context *ldb, const char *name)
+{
         uint32_t j;
+        unsigned int j;
         const struct ldb_schema_syntax *s = NULL;
 …
 const struct ldb_schema_syntax *ldb_samba_syntax_by_lDAPDisplayName(struct ldb_context *ldb, const char *name)
+{
         uint32_t j;
+        unsigned int j;
         const struct ldb_schema_syntax *s = NULL;
 …
 int ldb_register_samba_handlers(struct ldb_context *ldb)
+{
+        uint32_t i;
+        unsigned int i;
+        int ret;
+        if (ldb_get_opaque(ldb, "SAMBA_HANDLERS_REGISTERED") != NULL) {
+                return LDB_SUCCESS;
+        }
         for (i=0; i < ARRAY_SIZE(samba_attributes); i++) {
-                int ret;
                 const struct ldb_schema_syntax *s = NULL;
 …
                 if (!s) {
                         return -1;
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
 …
         for (i=0; i < ARRAY_SIZE(samba_dn_syntax); i++) {
-                int ret;
                 ret = ldb_dn_extended_add_syntax(ldb, LDB_ATTR_FLAG_FIXED, &samba_dn_syntax[i]);
                 if (ret != LDB_SUCCESS) {
 …
+                }
+        }
+        ret = ldb_set_opaque(ldb, "SAMBA_HANDLERS_REGISTERED", (void*)1);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }

trunk/server/source4/lib/ldb-samba/ldif_handlers.h

-              r414
+              r745
 #define LDB_SYNTAX_SAMBA_GUID                   "LDB_SYNTAX_SAMBA_GUID"
 #define LDB_SYNTAX_SAMBA_OBJECT_CATEGORY        "LDB_SYNTAX_SAMBA_OBJECT_CATEGORY"
+#define LDB_SYNTAX_SAMBA_SCHEMAINFO             "LDB_SYNTAX_SAMBA_SCHEMAINFO"
 #define LDB_SYNTAX_SAMBA_PREFIX_MAP             "LDB_SYNTAX_SAMBA_PREFIX_MAP"
 #define LDB_SYNTAX_SAMBA_INT32                  "LDB_SYNTAX_SAMBA_INT32"
 …
 #define LDB_SYNTAX_SAMBA_REPLPROPERTYMETADATA   "LDB_SYNTAX_SAMBA_REPLPROPERTYMETADATA"
 #define LDB_SYNTAX_SAMBA_REPLUPTODATEVECTOR     "LDB_SYNTAX_SAMBA_REPLUPTODATEVECTOR"
+#define LDB_SYNTAX_SAMBA_RANGE64                "LDB_SYNTAX_SAMBA_RANGE64"
+#define LDB_SYNTAX_SAMBA_DNSRECORD              "LDB_SYNTAX_SAMBA_DNSRECORD"
+#define LDB_SYNTAX_SAMBA_SUPPLEMENTALCREDENTIALS "LDB_SYNTAX_SAMBA_SUPPLEMENTALCREDENTIALS"
 #include "lib/ldb-samba/ldif_handlers_proto.h"

trunk/server/source4/lib/ldb/common/attrib_handlers.c

-              r414
+              r745
    Copyright (C) Andrew Tridgell  2005
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006-2009
      ** NOTE! The following LGPL license applies to the ldb
 …
+{
         char *s, *t;
         int l;
+        size_t l;
         if (!in || !out || !(in->data)) {
 …
+}
+/* length limited conversion of a ldb_val to a int32_t */
+static int val_to_int64(const struct ldb_val *in, int64_t *v)
+{
+        char *end;
+        char buf[64];
+        /* make sure we don't read past the end of the data */
+        if (in->length > sizeof(buf)-1) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        strncpy(buf, (char *)in->data, in->length);
+        buf[in->length] = 0;
+        /* We've to use "strtoll" here to have the intended overflows.
+         * Otherwise we may get "LONG_MAX" and the conversion is wrong. */
+        *v = (int64_t) strtoll(buf, &end, 0);
+        if (*end != 0) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        return LDB_SUCCESS;
+}
 …
                                     const struct ldb_val *in, struct ldb_val *out)
+{
+        char *end;
+        long long i = strtoll((char *)in->data, &end, 0);
+        if (*end != 0) {
+                return -1;
+        }
+        out->data = (uint8_t *)talloc_asprintf(mem_ctx, "%lld", i);
+        int64_t i;
+        int ret;
+        ret = val_to_int64(in, &i);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        out->data = (uint8_t *) talloc_asprintf(mem_ctx, "%lld", (long long)i);
         if (out->data == NULL) {
+                return -1;
+                ldb_oom(ldb);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         out->length = strlen((char *)out->data);
 …
                                   const struct ldb_val *v1, const struct ldb_val *v2)
+{
+        return strtoll((char *)v1->data, NULL, 0) - strtoll((char *)v2->data, NULL, 0);
+        int64_t i1=0, i2=0;
+        val_to_int64(v1, &i1);
+        val_to_int64(v2, &i2);
+        if (i1 == i2) return 0;
+        return i1 > i2? 1 : -1;
+}
 …
                 talloc_free(b1);
                 talloc_free(b2);
+                if (memcmp(s1, s2, MIN(n1, n2)) == 0) {
+                ret = memcmp(s1, s2, MIN(n1, n2));
+                if (ret == 0) {
                         if (n1 == n2) return 0;
                         if (n1 > n2) {
 …
+                        }
+                }
+                return ret;
+        }
 …
                                   const struct ldb_val *v1, const struct ldb_val *v2)
+{
+        time_t t1, t2;
+        t1 = ldb_string_to_time((char *)v1->data);
+        t2 = ldb_string_to_time((char *)v2->data);
+        return (int)t2 - (int)t1;
+        time_t t1=0, t2=0;
+        ldb_val_to_time(v1, &t1);
+        ldb_val_to_time(v2, &t2);
+        if (t1 == t2) return 0;
+        return t1 > t2? 1 : -1;
+}
 …
                                     const struct ldb_val *in, struct ldb_val *out)
+{
+        time_t t = ldb_string_to_time((char *)in->data);
+        time_t t;
+        int ret;
+        ret = ldb_val_to_time(in, &t);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
         out->data = (uint8_t *)ldb_timestring(mem_ctx, t);
         if (out->data == NULL) {
+                return -1;
+                ldb_oom(ldb);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         out->length = strlen((char *)out->data);
 …
                                                             const char *syntax)
+{
         int i;
+        unsigned int i;
         unsigned num_handlers = sizeof(ldb_standard_syntaxes)/sizeof(ldb_standard_syntaxes[0]);
         /* TODO: should be replaced with a binary search */
 …
         return NULL;
+}
+int ldb_any_comparison(struct ldb_context *ldb, void *mem_ctx,
+                       ldb_attr_handler_t canonicalise_fn,
+                       const struct ldb_val *v1,
+                       const struct ldb_val *v2)
+{
+        int ret, ret1, ret2;
+        struct ldb_val v1_canon, v2_canon;
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+        /* I could try and bail if tmp_ctx was NULL, but what return
+         * value would I use?
+         *
+         * It seems easier to continue on the NULL context
+         */
+        ret1 = canonicalise_fn(ldb, tmp_ctx, v1, &v1_canon);
+        ret2 = canonicalise_fn(ldb, tmp_ctx, v2, &v2_canon);
+        if (ret1 == LDB_SUCCESS && ret2 == LDB_SUCCESS) {
+                ret = ldb_comparison_binary(ldb, mem_ctx, &v1_canon, &v2_canon);
+        } else {
+                ret = ldb_comparison_binary(ldb, mem_ctx, v1, v2);
+        }
+        talloc_free(tmp_ctx);
+        return ret;
+}

trunk/server/source4/lib/ldb/common/ldb.c

-              r414
+              r745
 #define TEVENT_DEPRECATED 1
 #include "ldb_private.h"
+#include "ldb.h"
 static int ldb_context_destructor(void *ptr)
 …
         struct ldb_context *ldb;
         int ret;
+        const char *modules_path = getenv("LDB_MODULES_PATH");
+        if (modules_path == NULL) {
+                modules_path = LDB_MODULESDIR;
+        }
+        ret = ldb_modules_load(modules_path, LDB_VERSION);
+        if (ret != LDB_SUCCESS) {
+                return NULL;
+        }
         ldb = talloc_zero(mem_ctx, struct ldb_context);
+        /* FIXME: Hack a new event context so that CMD line utilities work
+         * until we have them all converted */
+        /* A new event context so that callers who don't want ldb
+         * operating on thier global event context can work without
+         * having to provide their own private one explicitly */
         if (ev_ctx == NULL) {
                 ev_ctx = tevent_context_init(talloc_autofree_context());
+                ev_ctx = tevent_context_init(ldb);
                 tevent_set_debug(ev_ctx, ldb_tevent_debug, ldb);
                 tevent_loop_allow_nesting(ev_ctx);
 …
         ret = ldb_setup_wellknown_attributes(ldb);
         if (ret != 0) {
+        if (ret != LDB_SUCCESS) {
                 talloc_free(ldb);
                 return NULL;
 …
+{
         int ret;
         const char *url2;
+        char *url2;
         /* We seem to need to do this here, or else some utilities don't
          * get ldb backends */
 …
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
         ret = ldb_set_opaque(ldb, "ldb_url", talloc_strdup(ldb, url2));
+        ret = ldb_set_opaque(ldb, "ldb_url", url2);
         if (ret != LDB_SUCCESS) {
                 return ret;
+        }
         ret = ldb_connect_backend(ldb, url, options, &ldb->modules);
+        ret = ldb_module_connect_backend(ldb, url, options, &ldb->modules);
         if (ret != LDB_SUCCESS) {
                 return ret;
 …
+}
+/*
+  set an ldb error based on file:line
+*/
+int ldb_error_at(struct ldb_context *ldb, int ecode,
+                 const char *reason, const char *file, int line)
+{
+        if (reason == NULL) {
+                reason = ldb_strerror(ecode);
+        }
+        ldb_asprintf_errstring(ldb, "%s at %s:%d", reason, file, line);
+        return ecode;
+}
 #define FIRST_OP_NOERR(ldb, op) do { \
         module = ldb->modules;                                  \
         while (module && module->ops->op == NULL) module = module->next; \
+        if ((ldb->flags & LDB_FLG_ENABLE_TRACING) && module) { \
+                ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_trace_request: (%s)->" #op, \
+                          module->ops->name);                           \
+        }                                                               \
 } while (0)
 …
+                }
+        }
+        if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
+                ldb_debug(module->ldb, LDB_DEBUG_TRACE, "start ldb transaction error: %s",
+                          ldb_errstring(module->ldb));
+        }
         return status;
+}
 …
                 /* if a module fails the prepare then we need
                    to call the end transaction for everyone */
                 FIRST_OP(ldb, end_transaction);
                 module->ops->end_transaction(module);
+                FIRST_OP(ldb, del_transaction);
+                module->ops->del_transaction(module);
                 if (ldb->err_string == NULL) {
                         /* no error string was setup by the backend */
 …
                                                ldb_strerror(status),
                                                status);
+                }
+                if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
+                        ldb_debug(module->ldb, LDB_DEBUG_TRACE, "prepare commit transaction error: %s",
+                                  ldb_errstring(module->ldb));
+                }
+        }
 …
                                 status);
+                }
+                if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
+                        ldb_debug(module->ldb, LDB_DEBUG_TRACE, "commit ldb transaction error: %s",
+                                  ldb_errstring(module->ldb));
+                }
                 /* cancel the transaction */
                 FIRST_OP(ldb, del_transaction);
 …
                                 status);
+                }
+                if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
+                        ldb_debug(module->ldb, LDB_DEBUG_TRACE, "cancel ldb transaction error: %s",
+                                  ldb_errstring(module->ldb));
+                }
+        }
         return status;
+}
+/*
+  cancel a transaction with no error if no transaction is pending
+  used when we fork() to clear any parent transactions
+*/
+int ldb_transaction_cancel_noerr(struct ldb_context *ldb)
+{
+        if (ldb->transaction_active > 0) {
+                return ldb_transaction_cancel(ldb);
+        }
+        return LDB_SUCCESS;
+}
 /* autostarts a transacion if none active */
 …
+{
         TALLOC_CTX *tmp_ctx = talloc_new(req);
         int i;
+        unsigned int i;
         switch (req->operation) {
 …
         } else {
                 for (i=0; req->controls && req->controls[i]; i++) {
+                        ldb_debug_add(ldb, " control: %s  crit:%u  data:%s\n",
+                                      req->controls[i]->oid,
+                                      req->controls[i]->critical,
+                                      req->controls[i]->data?"yes":"no");
+                        if (req->controls[i]->oid) {
+                                ldb_debug_add(ldb, " control: %s  crit:%u  data:%s\n",
+                                              req->controls[i]->oid,
+                                              req->controls[i]->critical,
+                                              req->controls[i]->data?"yes":"no");
+                        }
+                }
+        }
 …
         talloc_free(tmp_ctx);
+}
+/*
+  check that the element flags don't have any internal bits set
+ */
+static int ldb_msg_check_element_flags(struct ldb_context *ldb,
+                                       const struct ldb_message *message)
+{
+        unsigned i;
+        for (i=0; i<message->num_elements; i++) {
+                if (message->elements[i].flags & LDB_FLAG_INTERNAL_MASK) {
+                        ldb_asprintf_errstring(ldb, "Invalid element flags 0x%08x on element %s in %s\n",
+                                               message->elements[i].flags, message->elements[i].name,
+                                               ldb_dn_get_linearized(message->dn));
+                        return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+                }
+        }
+        return LDB_SUCCESS;
+}
 …
         switch (req->operation) {
         case LDB_SEARCH:
+                /* due to "ldb_build_search_req" base DN always != NULL */
+                if (!ldb_dn_validate(req->op.search.base)) {
+                        ldb_asprintf_errstring(ldb, "ldb_search: invalid basedn '%s'",
+                                               ldb_dn_get_linearized(req->op.search.base));
+                        return LDB_ERR_INVALID_DN_SYNTAX;
+                }
                 FIRST_OP(ldb, search);
                 ret = module->ops->search(module, req);
                 break;
         case LDB_ADD:
+                if (!ldb_dn_validate(req->op.add.message->dn)) {
+                        ldb_asprintf_errstring(ldb, "ldb_add: invalid dn '%s'",
+                                               ldb_dn_get_linearized(req->op.add.message->dn));
+                        return LDB_ERR_INVALID_DN_SYNTAX;
+                }
+                /*
+                 * we have to normalize here, as so many places
+                 * in modules and backends assume we don't have two
+                 * elements with the same name
+                 */
+                ret = ldb_msg_normalize(ldb, req, req->op.add.message,
+                                        discard_const(&req->op.add.message));
+                if (ret != LDB_SUCCESS) {
+                        ldb_oom(ldb);
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
                 FIRST_OP(ldb, add);
+                ret = ldb_msg_check_element_flags(ldb, req->op.add.message);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
                 ret = module->ops->add(module, req);
                 break;
         case LDB_MODIFY:
+                if (!ldb_dn_validate(req->op.mod.message->dn)) {
+                        ldb_asprintf_errstring(ldb, "ldb_modify: invalid dn '%s'",
+                                               ldb_dn_get_linearized(req->op.mod.message->dn));
+                        return LDB_ERR_INVALID_DN_SYNTAX;
+                }
                 FIRST_OP(ldb, modify);
+                ret = ldb_msg_check_element_flags(ldb, req->op.mod.message);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
                 ret = module->ops->modify(module, req);
                 break;
         case LDB_DELETE:
+                if (!ldb_dn_validate(req->op.del.dn)) {
+                        ldb_asprintf_errstring(ldb, "ldb_delete: invalid dn '%s'",
+                                               ldb_dn_get_linearized(req->op.del.dn));
+                        return LDB_ERR_INVALID_DN_SYNTAX;
+                }
                 FIRST_OP(ldb, del);
                 ret = module->ops->del(module, req);
                 break;
         case LDB_RENAME:
+                if (!ldb_dn_validate(req->op.rename.olddn)) {
+                        ldb_asprintf_errstring(ldb, "ldb_rename: invalid olddn '%s'",
+                                               ldb_dn_get_linearized(req->op.rename.olddn));
+                        return LDB_ERR_INVALID_DN_SYNTAX;
+                }
+                if (!ldb_dn_validate(req->op.rename.newdn)) {
+                        ldb_asprintf_errstring(ldb, "ldb_rename: invalid newdn '%s'",
+                                               ldb_dn_get_linearized(req->op.rename.newdn));
+                        return LDB_ERR_INVALID_DN_SYNTAX;
+                }
                 FIRST_OP(ldb, rename);
                 ret = module->ops->rename(module, req);
 …
+{
         struct ldb_result *res;
         int n;
+        unsigned int n;
         res = talloc_get_type(req->context, struct ldb_result);
 …
+}
+int ldb_op_default_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+int ldb_modify_default_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+        struct ldb_result *res;
+        unsigned int n;
         int ret;
+        res = talloc_get_type(req->context, struct ldb_result);
         if (!ares) {
 …
+        }
+        switch (ares->type) {
+        case LDB_REPLY_REFERRAL:
+                if (res->refs) {
+                        for (n = 0; res->refs[n]; n++) /*noop*/ ;
+                } else {
+                        n = 0;
+                }
+                res->refs = talloc_realloc(res, res->refs, char *, n + 2);
+                if (! res->refs) {
+                        return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+                }
+                res->refs[n] = talloc_move(res->refs, &ares->referral);
+                res->refs[n + 1] = NULL;
+                break;
+        case LDB_REPLY_DONE:
+                talloc_free(ares);
+                return ldb_request_done(req, LDB_SUCCESS);
+        default:
+                talloc_free(ares);
+                ldb_set_errstring(req->handle->ldb, "Invalid reply type!");
+                return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+        }
+        talloc_free(ares);
+        return ldb_request_done(req, LDB_SUCCESS);
+}
+int ldb_op_default_callback(struct ldb_request *req, struct ldb_reply *ares)
+{
+        int ret;
+        if (!ares) {
+                return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+        }
+        if (ares->error != LDB_SUCCESS) {
+                ret = ares->error;
+                talloc_free(ares);
+                return ldb_request_done(req, ret);
+        }
         if (ares->type != LDB_REPLY_DONE) {
                 talloc_free(ares);
 …
 int ldb_build_search_req_ex(struct ldb_request **ret_req,
                         struct ldb_context *ldb,
                         void *mem_ctx,
+                        TALLOC_CTX *mem_ctx,
                         struct ldb_dn *base,
                         enum ldb_scope scope,
 …
         if (parent) {
                 req->handle->nesting++;
+                req->handle->parent = parent;
+                req->handle->flags = parent->handle->flags;
+        }
 …
 int ldb_build_search_req(struct ldb_request **ret_req,
                         struct ldb_context *ldb,
                         void *mem_ctx,
+                        TALLOC_CTX *mem_ctx,
                         struct ldb_dn *base,
                         enum ldb_scope scope,
 …
 int ldb_build_add_req(struct ldb_request **ret_req,
                         struct ldb_context *ldb,
                         void *mem_ctx,
+                        TALLOC_CTX *mem_ctx,
                         const struct ldb_message *message,
                         struct ldb_control **controls,
 …
         if (parent) {
                 req->handle->nesting++;
+                req->handle->parent = parent;
+                req->handle->flags = parent->handle->flags;
+        }
 …
 int ldb_build_mod_req(struct ldb_request **ret_req,
                         struct ldb_context *ldb,
                         void *mem_ctx,
+                        TALLOC_CTX *mem_ctx,
                         const struct ldb_message *message,
                         struct ldb_control **controls,
 …
         if (parent) {
                 req->handle->nesting++;
+                req->handle->parent = parent;
+                req->handle->flags = parent->handle->flags;
+        }
 …
 int ldb_build_del_req(struct ldb_request **ret_req,
                         struct ldb_context *ldb,
                         void *mem_ctx,
+                        TALLOC_CTX *mem_ctx,
                         struct ldb_dn *dn,
                         struct ldb_control **controls,
 …
         if (parent) {
                 req->handle->nesting++;
+                req->handle->parent = parent;
+                req->handle->flags = parent->handle->flags;
+        }
 …
 int ldb_build_rename_req(struct ldb_request **ret_req,
                         struct ldb_context *ldb,
                         void *mem_ctx,
+                        TALLOC_CTX *mem_ctx,
                         struct ldb_dn *olddn,
                         struct ldb_dn *newdn,
 …
         if (parent) {
                 req->handle->nesting++;
+                req->handle->parent = parent;
+                req->handle->flags = parent->handle->flags;
+        }
 …
 int ldb_build_extended_req(struct ldb_request **ret_req,
                            struct ldb_context *ldb,
                            void *mem_ctx,
+                           TALLOC_CTX *mem_ctx,
                            const char *oid,
                            void *data,
 …
         if (parent) {
                 req->handle->nesting++;
+                req->handle->parent = parent;
+                req->handle->flags = parent->handle->flags;
+        }
 …
                                         ldb_search_default_callback,
                                         NULL);
+        ldb_req_set_location(req, "ldb_search");
         if (ret != LDB_SUCCESS) goto done;
 …
                                         ldb_op_default_callback,
                                         NULL);
+        ldb_req_set_location(req, "ldb_add");
         if (ret != LDB_SUCCESS) return ret;
 …
                                         ldb_op_default_callback,
                                         NULL);
+        ldb_req_set_location(req, "ldb_modify");
         if (ret != LDB_SUCCESS) return ret;
 …
                                         ldb_op_default_callback,
                                         NULL);
+        ldb_req_set_location(req, "ldb_delete");
         if (ret != LDB_SUCCESS) return ret;
 …
                                         ldb_op_default_callback,
                                         NULL);
+        ldb_req_set_location(req, "ldb_rename");
         if (ret != LDB_SUCCESS) return ret;
 …
         ldb->flags = flags;
+}
+/*
+  set the location in a ldb request. Used for debugging
+ */
+void ldb_req_set_location(struct ldb_request *req, const char *location)
+{
+        if (req && req->handle) {
+                req->handle->location = location;
+        }
+}
+/*
+  return the location set with dsdb_req_set_location
+ */
+const char *ldb_req_location(struct ldb_request *req)
+{
+        return req->handle->location;
+}
+/**
+  mark a request as untrusted. This tells the rootdse module to remove
+  unregistered controls
+ */
+void ldb_req_mark_untrusted(struct ldb_request *req)
+{
+        req->handle->flags |= LDB_HANDLE_FLAG_UNTRUSTED;
+}
+/**
+  mark a request as trusted.
+ */
+void ldb_req_mark_trusted(struct ldb_request *req)
+{
+        req->handle->flags &= ~LDB_HANDLE_FLAG_UNTRUSTED;
+}
+/**
+   return true is a request is untrusted
+ */
+bool ldb_req_is_untrusted(struct ldb_request *req)
+{
+        return (req->handle->flags & LDB_HANDLE_FLAG_UNTRUSTED) != 0;
+}

trunk/server/source4/lib/ldb/common/ldb_attributes.c

-              r414
+              r745
                                          const struct ldb_schema_syntax *syntax)
+{
         int i, n;
+        unsigned int i, n;
         struct ldb_schema_attribute *a;
 …
         const char *name)
+{
+        int i, e, b = 0, r;
+        /* for binary search we need signed variables */
+        unsigned int i, e, b = 0;
+        int r;
         const struct ldb_schema_attribute *def = &ldb_attribute_default;
 …
         e = ldb->schema.num_attributes - 1;
+        while (b <= e) {
+        while ((b <= e) && (e != (unsigned int) -1)) {
                 i = (b + e) / 2;
 …
                         b = i + 1;
+                }
+        }
 …
+{
         const struct ldb_schema_attribute *a;
         int i;
+        ptrdiff_t i;
         a = ldb_schema_attribute_by_name_internal(ldb, name);
 …
                 { "objectClass", LDB_SYNTAX_OBJECTCLASS }
         };
         int i;
+        unsigned int i;
         int ret;
 …
                                const struct ldb_dn_extended_syntax *syntax)
+{
         int n;
+        unsigned int n;
         struct ldb_dn_extended_syntax *a;
 …
                                                                     const char *name)
+{
         int i;
+        unsigned int i;
         for (i=0; i < ldb->schema.num_dn_extended_syntax; i++) {
                 if (ldb_attr_cmp(ldb->schema.dn_extended_syntax[i].name, name) == 0) {

trunk/server/source4/lib/ldb/common/ldb_controls.c

-              r414
+              r745
 struct ldb_control *ldb_request_get_control(struct ldb_request *req, const char *oid)
+{
         int i;
+        unsigned int i;
         if (req->controls != NULL) {
                 for (i = 0; req->controls[i]; i++) {
                         if (strcmp(oid, req->controls[i]->oid) == 0) {
+                        if (req->controls[i]->oid && strcmp(oid, req->controls[i]->oid) == 0) {
                                 break;
+                        }
 …
 struct ldb_control *ldb_reply_get_control(struct ldb_reply *rep, const char *oid)
+{
         int i;
+        unsigned int i;
         if (rep->controls != NULL) {
                 for (i = 0; rep->controls[i]; i++) {
                         if (strcmp(oid, rep->controls[i]->oid) == 0) {
+                        if (rep->controls[i]->oid && strcmp(oid, rep->controls[i]->oid) == 0) {
                                 break;
+                        }
 …
+}
+/* saves the current controls list into the "saver" and replace the one in req with a new one excluding
+the "exclude" control */
+/* returns 0 on error */
+int save_controls(struct ldb_control *exclude, struct ldb_request *req, struct ldb_control ***saver)
+/*
+ * Saves the current controls list into the "saver" (can also be NULL) and
+ * replace the one in "req" with a new one excluding the "exclude" control
+ * (if it is NULL then the list remains the same)
+ *
+ * Returns 0 on error.
+ */
+int ldb_save_controls(struct ldb_control *exclude, struct ldb_request *req, struct ldb_control ***saver)
+{
+        struct ldb_control **lcs;
+        int i, j;
+        *saver = req->controls;
+        for (i = 0; req->controls[i]; i++);
+        if (i == 1) {
+        struct ldb_control **lcs, **lcs_old;
+        unsigned int i, j;
+        lcs_old = req->controls;
+        if (saver != NULL) {
+                *saver = lcs_old;
+        }
+        for (i = 0; req->controls && req->controls[i]; i++);
+        if (i == 0) {
                 req->controls = NULL;
                 return 1;
+        }
         lcs = talloc_array(req, struct ldb_control *, i);
+        lcs = talloc_array(req, struct ldb_control *, i + 1);
         if (!lcs) {
                 return 0;
+        }
         for (i = 0, j = 0; (*saver)[i]; i++) {
                 if (exclude == (*saver)[i]) continue;
                 lcs[j] = (*saver)[i];
+        for (i = 0, j = 0; lcs_old[i]; i++) {
+                if (exclude == lcs_old[i]) continue;
+                lcs[j] = lcs_old[i];
                 j++;
+        }
         lcs[j] = NULL;
+        req->controls = lcs;
+        req->controls = talloc_realloc(req, lcs, struct ldb_control *, j + 1);
+        if (req->controls == NULL) {
+                return 0;
+        }
         return 1;
+}
+/*
+ * Returns a list of controls, except the one specified with "exclude" (can
+ * also be NULL).  Included controls become a child of returned list if they
+ * were children of "controls_in".
+ *
+ * Returns NULL on error (OOM) or an empty control list.
+ */
+struct ldb_control **ldb_controls_except_specified(struct ldb_control **controls_in,
+                                               TALLOC_CTX *mem_ctx,
+                                               struct ldb_control *exclude)
+{
+        struct ldb_control **lcs = NULL;
+        unsigned int i, j, n;
+        for (i = 0; controls_in && controls_in[i]; i++);
+        if (i == 0) {
+                return NULL;
+        }
+        n = i;
+        for (i = 0, j = 0; controls_in && controls_in[i]; i++) {
+                if (exclude == controls_in[i]) continue;
+                if (!lcs) {
+                        /* Allocate here so if we remove the only
+                         * control, or there were no controls, we
+                         * don't allocate at all, and just return
+                         * NULL */
+                        lcs = talloc_array(mem_ctx, struct ldb_control *,
+                                           n + 1);
+                        if (!lcs) {
+                                return NULL;
+                        }
+                }
+                lcs[j] = controls_in[i];
+                talloc_reparent(controls_in, lcs, lcs[j]);
+                j++;
+        }
+        if (lcs) {
+                lcs[j] = NULL;
+                lcs = talloc_realloc(mem_ctx, lcs, struct ldb_control *, j + 1);
+        }
+        return lcs;
+}
 /* check if there's any control marked as critical in the list */
 /* return True if any, False if none */
 int check_critical_controls(struct ldb_control **controls)
+int ldb_check_critical_controls(struct ldb_control **controls)
+{
         int i;
+        unsigned int i;
         if (controls == NULL) {
 …
 int ldb_request_add_control(struct ldb_request *req, const char *oid, bool critical, void *data)
+{
+        unsigned int i, n;
+        struct ldb_control **ctrls;
+        struct ldb_control *ctrl;
+        for (n=0; req->controls && req->controls[n];n++) {
+                /* having two controls of the same OID makes no sense */
+                if (req->controls[n]->oid && strcmp(oid, req->controls[n]->oid) == 0) {
+                        return LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                }
+        }
+        ctrls = talloc_array(req,
+                               struct ldb_control *,
+                               n + 2);
+        if (!ctrls) return LDB_ERR_OPERATIONS_ERROR;
+        for (i=0; i<n; i++) {
+                ctrls[i] = req->controls[i];
+        }
+        req->controls = ctrls;
+        ctrls[n] = NULL;
+        ctrls[n+1] = NULL;
+        ctrl = talloc(ctrls, struct ldb_control);
+        if (!ctrl) return LDB_ERR_OPERATIONS_ERROR;
+        ctrl->oid       = talloc_strdup(ctrl, oid);
+        if (!ctrl->oid) return LDB_ERR_OPERATIONS_ERROR;
+        ctrl->critical  = critical;
+        ctrl->data      = data;
+        ctrls[n] = ctrl;
+        return LDB_SUCCESS;
+}
+int ldb_reply_add_control(struct ldb_reply *ares, const char *oid, bool critical, void *data)
+{
         unsigned n;
 …
         struct ldb_control *ctrl;
         for (n=0; req->controls && req->controls[n];) {
+        for (n=0; ares->controls && ares->controls[n];) {
                 /* having two controls of the same OID makes no sense */
                 if (strcmp(oid, req->controls[n]->oid) == 0) {
+                if (ares->controls[n]->oid && strcmp(oid, ares->controls[n]->oid) == 0) {
                         return LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                }
 …
+        }
         ctrls = talloc_realloc(req, req->controls,
+        ctrls = talloc_realloc(ares, ares->controls,
                                struct ldb_control *,
                                n + 2);
         if (!ctrls) return LDB_ERR_OPERATIONS_ERROR;
         req->controls = ctrls;
+        ares->controls = ctrls;
         ctrls[n] = NULL;
         ctrls[n+1] = NULL;
 …
+}
+/* Parse controls from the format used on the command line and in ejs */
+struct ldb_control **ldb_parse_control_strings(struct ldb_context *ldb, void *mem_ctx, const char **control_strings)
+/* Add a control to the request, replacing the old one if it is already in the request */
+int ldb_request_replace_control(struct ldb_request *req, const char *oid, bool critical, void *data)
+{
+        int i;
+        struct ldb_control **ctrl;
+        unsigned int n;
+        int ret;
+        ret = ldb_request_add_control(req, oid, critical, data);
+        if (ret != LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) {
+                return ret;
+        }
+        for (n=0; req->controls[n];n++) {
+                if (req->controls[n]->oid && strcmp(oid, req->controls[n]->oid) == 0) {
+                        req->controls[n]->critical = critical;
+                        req->controls[n]->data = data;
+                        return LDB_SUCCESS;
+                }
+        }
+        return LDB_ERR_OPERATIONS_ERROR;
+}
+/*
+ * Return a control as string
+ * the project (ie. name:value1:value2:...:valuen
+ * The string didn't include the criticity of the critical flag
+ */
+char *ldb_control_to_string(TALLOC_CTX *mem_ctx, const struct ldb_control *control)
+{
+        char *res = NULL;
+        if (strcmp(control->oid, LDB_CONTROL_PAGED_RESULTS_OID) == 0) {
+                struct ldb_paged_control *rep_control = talloc_get_type(control->data, struct ldb_paged_control);
+                char *cookie;
+                cookie = ldb_base64_encode(mem_ctx, rep_control->cookie, rep_control->cookie_len);
+                if (cookie == NULL) {
+                        return NULL;
+                }
+                if (cookie[0] != '\0') {
+                        res = talloc_asprintf(mem_ctx, "%s:%d:%s",
+                                                LDB_CONTROL_PAGED_RESULTS_NAME,
+                                                control->critical,
+                                                cookie);
+                        talloc_free(cookie);
+                } else {
+                        res = talloc_asprintf(mem_ctx, "%s:%d",
+                                                LDB_CONTROL_PAGED_RESULTS_NAME,
+                                                control->critical);
+                }
+                return res;
+        }
+        if (strcmp(control->oid, LDB_CONTROL_VLV_RESP_OID) == 0) {
+                struct ldb_vlv_resp_control *rep_control = talloc_get_type(control->data,
+                                                                struct ldb_vlv_resp_control);
+                res = talloc_asprintf(mem_ctx, "%s:%d:%d:%d:%d:%d:%s",
+                                                LDB_CONTROL_VLV_RESP_NAME,
+                                                control->critical,
+                                                rep_control->targetPosition,
+                                                rep_control->contentCount,
+                                                rep_control->vlv_result,
+                                                rep_control->ctxid_len,
+                                                rep_control->contextId);
+                return res;
+        }
+        if (strcmp(control->oid, LDB_CONTROL_SORT_RESP_OID) == 0) {
+                struct ldb_sort_resp_control *rep_control = talloc_get_type(control->data,
+                                                                struct ldb_sort_resp_control);
+                res = talloc_asprintf(mem_ctx, "%s:%d:%d:%s",
+                                        LDB_CONTROL_SORT_RESP_NAME,
+                                        control->critical,
+                                        rep_control->result,
+                                        rep_control->attr_desc);
+                return res;
+        }
+        if (strcmp(control->oid, LDB_CONTROL_ASQ_OID) == 0) {
+                struct ldb_asq_control *rep_control = talloc_get_type(control->data,
+                                                                struct ldb_asq_control);
+                res = talloc_asprintf(mem_ctx, "%s:%d:%d",
+                                        LDB_CONTROL_SORT_RESP_NAME,
+                                        control->critical,
+                                        rep_control->result);
+                return res;
+        }
+        if (strcmp(control->oid, LDB_CONTROL_DIRSYNC_OID) == 0) {
+                char *cookie;
+                struct ldb_dirsync_control *rep_control = talloc_get_type(control->data,
+                                                                struct ldb_dirsync_control);
+                cookie = ldb_base64_encode(mem_ctx, rep_control->cookie,
+                                rep_control->cookie_len);
+                if (cookie == NULL) {
+                        return NULL;
+                }
+                res = talloc_asprintf(mem_ctx, "%s:%d:%d:%d:%s",
+                                        LDB_CONTROL_DIRSYNC_NAME,
+                                        control->critical,
+                                        rep_control->flags,
+                                        rep_control->max_attributes,
+                                        cookie);
+                talloc_free(cookie);
+                return res;
+        }
+        /*
+         * From here we don't know the control
+         */
+        if (control->data == NULL) {
+                /*
+                 * We don't know the control but there is no real data attached to it
+                 * so we can represent it with local_oid:oid:criticity
+                 */
+                res = talloc_asprintf(mem_ctx, "local_oid:%s:%d",
+                                        control->oid,
+                                        control->critical);
+                return res;
+        }
+                res = talloc_asprintf(mem_ctx, "unknown oid:%s",
+                                        control->oid);
+        return res;
+}
+/*
+ * A little trick to allow to use constants defined in headers rather than
+ * hardwritten in the file hardwritten in the file
+ * sizeof will return the \0 char as well so it will take the place of ":" in the
+ * length of the string
+ */
+#define LDB_CONTROL_CMP(control, NAME) strncmp(control, NAME ":", sizeof(NAME))
+/* Parse one string and return associated control if parsing is successful*/
+struct ldb_control *ldb_parse_control_from_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *control_strings)
+{
+        struct ldb_control *ctrl;
         char *error_string = NULL;
+        if (control_strings == NULL || control_strings[0] == NULL)
+        if (!(ctrl = talloc(mem_ctx, struct ldb_control))) {
+                ldb_oom(ldb);
                 return NULL;
+        for (i = 0; control_strings[i]; i++);
+        ctrl = talloc_array(mem_ctx, struct ldb_control *, i + 1);
+        for (i = 0; control_strings[i]; i++) {
+                if (strncmp(control_strings[i], "vlv:", 4) == 0) {
+                        struct ldb_vlv_req_control *control;
+                        const char *p;
+                        char attr[1024];
+                        char ctxid[1024];
+                        int crit, bc, ac, os, cc, ret;
+                        attr[0] = '\0';
+                        ctxid[0] = '\0';
+                        p = &(control_strings[i][4]);
+                        ret = sscanf(p, "%d:%d:%d:%d:%d:%1023[^$]", &crit, &bc, &ac, &os, &cc, ctxid);
+                        if (ret < 5) {
+                                ret = sscanf(p, "%d:%d:%d:%1023[^:]:%1023[^$]", &crit, &bc, &ac, attr, ctxid);
+                        }
+                        if ((ret < 4) || (crit < 0) || (crit > 1)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid server_sort control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b):bc(n):ac(n):<os(n):cc(n)|attr(s)>[:ctxid(o)]\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number, s = string, o = b64 binary blob");
+        }
+        if (LDB_CONTROL_CMP(control_strings,
+                                LDB_CONTROL_VLV_REQ_NAME) == 0) {
+                struct ldb_vlv_req_control *control;
+                const char *p;
+                char attr[1024];
+                char ctxid[1024];
+                int crit, bc, ac, os, cc, ret;
+                attr[0] = '\0';
+                ctxid[0] = '\0';
+                p = &(control_strings[sizeof(LDB_CONTROL_VLV_REQ_NAME)]);
+                ret = sscanf(p, "%d:%d:%d:%d:%d:%1023[^$]", &crit, &bc, &ac, &os, &cc, ctxid);
+                if (ret < 5) {
+                        ret = sscanf(p, "%d:%d:%d:%1023[^:]:%1023[^$]", &crit, &bc, &ac, attr, ctxid);
+                }
+                if ((ret < 4) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid server_sort control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b):bc(n):ac(n):<os(n):cc(n)|attr(s)>[:ctxid(o)]\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number, s = string, o = b64 binary blob");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_VLV_REQ_OID;
+                ctrl->critical = crit;
+                if (!(control = talloc(ctrl,
+                                        struct ldb_vlv_req_control))) {
+                        ldb_oom(ldb);
+                        return NULL;
+                }
+                control->beforeCount = bc;
+                control->afterCount = ac;
+                if (attr[0]) {
+                        control->type = 1;
+                        control->match.gtOrEq.value = talloc_strdup(control, attr);
+                        control->match.gtOrEq.value_len = strlen(attr);
+                } else {
+                        control->type = 0;
+                        control->match.byOffset.offset = os;
+                        control->match.byOffset.contentCount = cc;
+                }
+                if (ctxid[0]) {
+                        control->ctxid_len = ldb_base64_decode(ctxid);
+                        control->contextId = (char *)talloc_memdup(control, ctxid, control->ctxid_len);
+                } else {
+                        control->ctxid_len = 0;
+                        control->contextId = NULL;
+                }
+                ctrl->data = control;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_DIRSYNC_NAME) == 0) {
+                struct ldb_dirsync_control *control;
+                const char *p;
+                char cookie[1024];
+                int crit, flags, max_attrs, ret;
+                cookie[0] = '\0';
+                p = &(control_strings[sizeof(LDB_CONTROL_DIRSYNC_NAME)]);
+                ret = sscanf(p, "%d:%d:%d:%1023[^$]", &crit, &flags, &max_attrs, cookie);
+                if ((ret < 3) || (crit < 0) || (crit > 1) || (flags < 0) || (max_attrs < 0)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid dirsync control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b):flags(n):max_attrs(n)[:cookie(o)]\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number, o = b64 binary blob");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                /* w2k3 seems to ignore the parameter,
+                        * but w2k sends a wrong cookie when this value is to small
+                        * this would cause looping forever, while getting
+                        * the same data and same cookie forever
+                        */
+                if (max_attrs == 0) max_attrs = 0x0FFFFFFF;
+                ctrl->oid = LDB_CONTROL_DIRSYNC_OID;
+                ctrl->critical = crit;
+                control = talloc(ctrl, struct ldb_dirsync_control);
+                control->flags = flags;
+                control->max_attributes = max_attrs;
+                if (*cookie) {
+                        control->cookie_len = ldb_base64_decode(cookie);
+                        control->cookie = (char *)talloc_memdup(control, cookie, control->cookie_len);
+                } else {
+                        control->cookie = NULL;
+                        control->cookie_len = 0;
+                }
+                ctrl->data = control;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_ASQ_NAME) == 0) {
+                struct ldb_asq_control *control;
+                const char *p;
+                char attr[256];
+                int crit, ret;
+                attr[0] = '\0';
+                p = &(control_strings[sizeof(LDB_CONTROL_ASQ_NAME)]);
+                ret = sscanf(p, "%d:%255[^$]", &crit, attr);
+                if ((ret != 2) || (crit < 0) || (crit > 1) || (attr[0] == '\0')) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid asq control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b):attr(s)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_ASQ_OID;
+                ctrl->critical = crit;
+                control = talloc(ctrl, struct ldb_asq_control);
+                control->request = 1;
+                control->source_attribute = talloc_strdup(control, attr);
+                control->src_attr_len = strlen(attr);
+                ctrl->data = control;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_EXTENDED_DN_NAME) == 0) {
+                struct ldb_extended_dn_control *control;
+                const char *p;
+                int crit, type, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_EXTENDED_DN_NAME)]);
+                ret = sscanf(p, "%d:%d", &crit, &type);
+                if ((ret != 2) || (crit < 0) || (crit > 1) || (type < 0) || (type > 1)) {
+                        ret = sscanf(p, "%d", &crit);
+                        if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid extended_dn control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b)[:type(i)]\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean\n");
+                                error_string = talloc_asprintf_append(error_string, "         i = integer\n");
+                                error_string = talloc_asprintf_append(error_string, "   valid values are: 0 - hexadecimal representation\n");
+                                error_string = talloc_asprintf_append(error_string, "                     1 - normal string representation");
                                 ldb_set_errstring(ldb, error_string);
                                 talloc_free(error_string);
                                 return NULL;
+                        }
+                        if (!(ctrl[i] = talloc(ctrl, struct ldb_control))) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        control = NULL;
+                } else {
+                        control = talloc(ctrl, struct ldb_extended_dn_control);
+                        control->type = type;
+                }
+                ctrl->oid = LDB_CONTROL_EXTENDED_DN_OID;
+                ctrl->critical = crit;
+                ctrl->data = talloc_steal(ctrl, control);
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SD_FLAGS_NAME) == 0) {
+                struct ldb_sd_flags_control *control;
+                const char *p;
+                int crit, ret;
+                unsigned secinfo_flags;
+                p = &(control_strings[sizeof(LDB_CONTROL_SD_FLAGS_NAME)]);
+                ret = sscanf(p, "%d:%u", &crit, &secinfo_flags);
+                if ((ret != 2) || (crit < 0) || (crit > 1) || (secinfo_flags < 0) || (secinfo_flags > 0xF)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid sd_flags control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b):secinfo_flags(n)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_SD_FLAGS_OID;
+                ctrl->critical = crit;
+                control = talloc(ctrl, struct ldb_sd_flags_control);
+                control->secinfo_flags = secinfo_flags;
+                ctrl->data = control;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SEARCH_OPTIONS_NAME) == 0) {
+                struct ldb_search_options_control *control;
+                const char *p;
+                int crit, ret;
+                unsigned search_options;
+                p = &(control_strings[sizeof(LDB_CONTROL_SEARCH_OPTIONS_NAME)]);
+                ret = sscanf(p, "%d:%u", &crit, &search_options);
+                if ((ret != 2) || (crit < 0) || (crit > 1) || (search_options < 0) || (search_options > 0xF)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid search_options control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b):search_options(n)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_SEARCH_OPTIONS_OID;
+                ctrl->critical = crit;
+                control = talloc(ctrl, struct ldb_search_options_control);
+                control->search_options = search_options;
+                ctrl->data = control;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_BYPASS_OPERATIONAL_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_BYPASS_OPERATIONAL_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid bypassopreational control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_BYPASS_OPERATIONAL_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_RELAX_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_RELAX_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid relax control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_RELAX_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_RECALCULATE_SD_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_RECALCULATE_SD_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid recalculate_sd control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_RECALCULATE_SD_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_DOMAIN_SCOPE_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_DOMAIN_SCOPE_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid domain_scope control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_DOMAIN_SCOPE_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_PAGED_RESULTS_NAME) == 0) {
+                struct ldb_paged_control *control;
+                const char *p;
+                int crit, size, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_PAGED_RESULTS_NAME)]);
+                ret = sscanf(p, "%d:%d", &crit, &size);
+                if ((ret != 2) || (crit < 0) || (crit > 1) || (size < 0)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid paged_results control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b):size(n)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_PAGED_RESULTS_OID;
+                ctrl->critical = crit;
+                control = talloc(ctrl, struct ldb_paged_control);
+                control->size = size;
+                control->cookie = NULL;
+                control->cookie_len = 0;
+                ctrl->data = control;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SERVER_SORT_NAME) == 0) {
+                struct ldb_server_sort_control **control;
+                const char *p;
+                char attr[256];
+                char rule[128];
+                int crit, rev, ret;
+                attr[0] = '\0';
+                rule[0] = '\0';
+                p = &(control_strings[sizeof(LDB_CONTROL_SERVER_SORT_NAME)]);
+                ret = sscanf(p, "%d:%d:%255[^:]:%127[^:]", &crit, &rev, attr, rule);
+                if ((ret < 3) || (crit < 0) || (crit > 1) || (rev < 0 ) || (rev > 1) ||attr[0] == '\0') {
+                        error_string = talloc_asprintf(mem_ctx, "invalid server_sort control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b):rev(b):attr(s)[:rule(s)]\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_SERVER_SORT_OID;
+                ctrl->critical = crit;
+                control = talloc_array(ctrl, struct ldb_server_sort_control *, 2);
+                control[0] = talloc(control, struct ldb_server_sort_control);
+                control[0]->attributeName = talloc_strdup(control, attr);
+                if (rule[0])
+                        control[0]->orderingRule = talloc_strdup(control, rule);
+                else
+                        control[0]->orderingRule = NULL;
+                control[0]->reverse = rev;
+                control[1] = NULL;
+                ctrl->data = control;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_NOTIFICATION_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_NOTIFICATION_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid notification control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_NOTIFICATION_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_TREE_DELETE_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_TREE_DELETE_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid tree_delete control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_TREE_DELETE_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SHOW_DELETED_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_SHOW_DELETED_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid show_deleted control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_SHOW_DELETED_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SHOW_DEACTIVATED_LINK_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_SHOW_DEACTIVATED_LINK_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid show_deactivated_link control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_SHOW_DEACTIVATED_LINK_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_SHOW_RECYCLED_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_SHOW_RECYCLED_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid show_recycled control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_SHOW_RECYCLED_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_PERMISSIVE_MODIFY_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_PERMISSIVE_MODIFY_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid permissive_modify control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_PERMISSIVE_MODIFY_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_REVEAL_INTERNALS_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_REVEAL_INTERNALS_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid reveal_internals control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_REVEAL_INTERNALS;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (strncmp(control_strings, "local_oid:", 10) == 0) {
+                const char *p;
+                int crit = 0, ret = 0;
+                char oid[256];
+                oid[0] = '\0';
+                p = &(control_strings[10]);
+                ret = sscanf(p, "%64[^:]:%d", oid, &crit);
+                if ((ret != 2) || strlen(oid) == 0 || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid local_oid control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: oid(s):crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = talloc_strdup(ctrl, oid);
+                if (!ctrl->oid) {
+                        ldb_oom(ldb);
+                        return NULL;
+                }
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_RODC_DCPROMO_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_RODC_DCPROMO_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid rodc_join control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_RODC_DCPROMO_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        if (LDB_CONTROL_CMP(control_strings, LDB_CONTROL_PROVISION_NAME) == 0) {
+                const char *p;
+                int crit, ret;
+                p = &(control_strings[sizeof(LDB_CONTROL_PROVISION_NAME)]);
+                ret = sscanf(p, "%d", &crit);
+                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                        error_string = talloc_asprintf(mem_ctx, "invalid provision control syntax\n");
+                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                        ldb_set_errstring(ldb, error_string);
+                        talloc_free(error_string);
+                        return NULL;
+                }
+                ctrl->oid = LDB_CONTROL_PROVISION_OID;
+                ctrl->critical = crit;
+                ctrl->data = NULL;
+                return ctrl;
+        }
+        /*
+         * When no matching control has been found.
+         */
+        return NULL;
+}
+/*
+ * A little trick to allow to use constants defined in headers rather than
+ * hardwritten in the file hardwritten in the file
+ * sizeof will return the \0 char as well so it will take the place of ":" in the
+ * length of the string
+ */
+#define LDB_CONTROL_CMP(control, NAME) strncmp(control, NAME ":", sizeof(NAME))
+/* Parse controls from the format used on the command line and in ejs */
+struct ldb_control **ldb_parse_control_strings(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char **control_strings)
+{
+        unsigned int i;
+        struct ldb_control **ctrl;
+        if (control_strings == NULL || control_strings[0] == NULL)
+                return NULL;
+        for (i = 0; control_strings[i]; i++);
+        ctrl = talloc_array(mem_ctx, struct ldb_control *, i + 1);
+        ldb_reset_err_string(ldb);
+        for (i = 0; control_strings[i]; i++) {
+                ctrl[i] = ldb_parse_control_from_string(ldb, ctrl, control_strings[i]);
+                if (ctrl[i] == NULL) {
+                        if( ldb_errstring == NULL ) {
+                                /* no controls matched, throw an error */
+                                ldb_asprintf_errstring(ldb, "Invalid control name: '%s'", control_strings[i]);
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_VLV_REQ_OID;
+                        ctrl[i]->critical = crit;
+                        if (!(control = talloc(ctrl[i],
+                                               struct ldb_vlv_req_control))) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        control->beforeCount = bc;
+                        control->afterCount = ac;
+                        if (attr[0]) {
+                                control->type = 1;
+                                control->match.gtOrEq.value = talloc_strdup(control, attr);
+                                control->match.gtOrEq.value_len = strlen(attr);
+                        } else {
+                                control->type = 0;
+                                control->match.byOffset.offset = os;
+                                control->match.byOffset.contentCount = cc;
+                        }
+                        if (ctxid[0]) {
+                                control->ctxid_len = ldb_base64_decode(ctxid);
+                                control->contextId = (char *)talloc_memdup(control, ctxid, control->ctxid_len);
+                        } else {
+                                control->ctxid_len = 0;
+                                control->contextId = NULL;
+                        }
+                        ctrl[i]->data = control;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "dirsync:", 8) == 0) {
+                        struct ldb_dirsync_control *control;
+                        const char *p;
+                        char cookie[1024];
+                        int crit, flags, max_attrs, ret;
+                        cookie[0] = '\0';
+                        p = &(control_strings[i][8]);
+                        ret = sscanf(p, "%d:%d:%d:%1023[^$]", &crit, &flags, &max_attrs, cookie);
+                        if ((ret < 3) || (crit < 0) || (crit > 1) || (flags < 0) || (max_attrs < 0)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid dirsync control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b):flags(n):max_attrs(n)[:cookie(o)]\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number, o = b64 binary blob");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        /* w2k3 seems to ignore the parameter,
+                         * but w2k sends a wrong cookie when this value is to small
+                         * this would cause looping forever, while getting
+                         * the same data and same cookie forever
+                         */
+                        if (max_attrs == 0) max_attrs = 0x0FFFFFFF;
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        ctrl[i]->oid = LDB_CONTROL_DIRSYNC_OID;
+                        ctrl[i]->critical = crit;
+                        control = talloc(ctrl[i], struct ldb_dirsync_control);
+                        control->flags = flags;
+                        control->max_attributes = max_attrs;
+                        if (*cookie) {
+                                control->cookie_len = ldb_base64_decode(cookie);
+                                control->cookie = (char *)talloc_memdup(control, cookie, control->cookie_len);
+                        } else {
+                                control->cookie = NULL;
+                                control->cookie_len = 0;
+                        }
+                        ctrl[i]->data = control;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "asq:", 4) == 0) {
+                        struct ldb_asq_control *control;
+                        const char *p;
+                        char attr[256];
+                        int crit, ret;
+                        attr[0] = '\0';
+                        p = &(control_strings[i][4]);
+                        ret = sscanf(p, "%d:%255[^$]", &crit, attr);
+                        if ((ret != 2) || (crit < 0) || (crit > 1) || (attr[0] == '\0')) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid asq control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b):attr(s)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_ASQ_OID;
+                        ctrl[i]->critical = crit;
+                        control = talloc(ctrl[i], struct ldb_asq_control);
+                        control->request = 1;
+                        control->source_attribute = talloc_strdup(control, attr);
+                        control->src_attr_len = strlen(attr);
+                        ctrl[i]->data = control;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "extended_dn:", 12) == 0) {
+                        struct ldb_extended_dn_control *control;
+                        const char *p;
+                        int crit, type, ret;
+                        p = &(control_strings[i][12]);
+                        ret = sscanf(p, "%d:%d", &crit, &type);
+                        if ((ret != 2) || (crit < 0) || (crit > 1) || (type < 0) || (type > 1)) {
+                                ret = sscanf(p, "%d", &crit);
+                                if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                                        error_string = talloc_asprintf(mem_ctx, "invalid extended_dn control syntax\n");
+                                        error_string = talloc_asprintf_append(error_string, " syntax: crit(b)[:type(i)]\n");
+                                        error_string = talloc_asprintf_append(error_string, "   note: b = boolean\n");
+                                        error_string = talloc_asprintf_append(error_string, "         i = integer\n");
+                                        error_string = talloc_asprintf_append(error_string, "   valid values are: 0 - hexadecimal representation\n");
+                                        error_string = talloc_asprintf_append(error_string, "                     1 - normal string representation");
+                                        ldb_set_errstring(ldb, error_string);
+                                        talloc_free(error_string);
+                                        return NULL;
+                                }
+                                control = NULL;
+                        } else {
+                                control = talloc(ctrl, struct ldb_extended_dn_control);
+                                control->type = type;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_EXTENDED_DN_OID;
+                        ctrl[i]->critical = crit;
+                        ctrl[i]->data = talloc_steal(ctrl[i], control);
+                        continue;
+                }
+                if (strncmp(control_strings[i], "sd_flags:", 9) == 0) {
+                        struct ldb_sd_flags_control *control;
+                        const char *p;
+                        int crit, ret;
+                        unsigned secinfo_flags;
+                        p = &(control_strings[i][9]);
+                        ret = sscanf(p, "%d:%u", &crit, &secinfo_flags);
+                        if ((ret != 2) || (crit < 0) || (crit > 1) || (secinfo_flags < 0) || (secinfo_flags > 0xF)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid sd_flags control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b):secinfo_flags(n)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_SD_FLAGS_OID;
+                        ctrl[i]->critical = crit;
+                        control = talloc(ctrl[i], struct ldb_sd_flags_control);
+                        control->secinfo_flags = secinfo_flags;
+                        ctrl[i]->data = control;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "search_options:", 15) == 0) {
+                        struct ldb_search_options_control *control;
+                        const char *p;
+                        int crit, ret;
+                        unsigned search_options;
+                        p = &(control_strings[i][15]);
+                        ret = sscanf(p, "%d:%u", &crit, &search_options);
+                        if ((ret != 2) || (crit < 0) || (crit > 1) || (search_options < 0) || (search_options > 0xF)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid search_options control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b):search_options(n)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_SEARCH_OPTIONS_OID;
+                        ctrl[i]->critical = crit;
+                        control = talloc(ctrl[i], struct ldb_search_options_control);
+                        control->search_options = search_options;
+                        ctrl[i]->data = control;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "domain_scope:", 13) == 0) {
+                        const char *p;
+                        int crit, ret;
+                        p = &(control_strings[i][13]);
+                        ret = sscanf(p, "%d", &crit);
+                        if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid domain_scope control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_DOMAIN_SCOPE_OID;
+                        ctrl[i]->critical = crit;
+                        ctrl[i]->data = NULL;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "paged_results:", 14) == 0) {
+                        struct ldb_paged_control *control;
+                        const char *p;
+                        int crit, size, ret;
+                        p = &(control_strings[i][14]);
+                        ret = sscanf(p, "%d:%d", &crit, &size);
+                        if ((ret != 2) || (crit < 0) || (crit > 1) || (size < 0)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid paged_results control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b):size(n)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean, n = number");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_PAGED_RESULTS_OID;
+                        ctrl[i]->critical = crit;
+                        control = talloc(ctrl[i], struct ldb_paged_control);
+                        control->size = size;
+                        control->cookie = NULL;
+                        control->cookie_len = 0;
+                        ctrl[i]->data = control;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "server_sort:", 12) == 0) {
+                        struct ldb_server_sort_control **control;
+                        const char *p;
+                        char attr[256];
+                        char rule[128];
+                        int crit, rev, ret;
+                        attr[0] = '\0';
+                        rule[0] = '\0';
+                        p = &(control_strings[i][12]);
+                        ret = sscanf(p, "%d:%d:%255[^:]:%127[^:]", &crit, &rev, attr, rule);
+                        if ((ret < 3) || (crit < 0) || (crit > 1) || (rev < 0 ) || (rev > 1) ||attr[0] == '\0') {
+                                error_string = talloc_asprintf(mem_ctx, "invalid server_sort control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b):rev(b):attr(s)[:rule(s)]\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean, s = string");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_SERVER_SORT_OID;
+                        ctrl[i]->critical = crit;
+                        control = talloc_array(ctrl[i], struct ldb_server_sort_control *, 2);
+                        control[0] = talloc(control, struct ldb_server_sort_control);
+                        control[0]->attributeName = talloc_strdup(control, attr);
+                        if (rule[0])
+                                control[0]->orderingRule = talloc_strdup(control, rule);
+                        else
+                                control[0]->orderingRule = NULL;
+                        control[0]->reverse = rev;
+                        control[1] = NULL;
+                        ctrl[i]->data = control;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "notification:", 13) == 0) {
+                        const char *p;
+                        int crit, ret;
+                        p = &(control_strings[i][13]);
+                        ret = sscanf(p, "%d", &crit);
+                        if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid notification control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_NOTIFICATION_OID;
+                        ctrl[i]->critical = crit;
+                        ctrl[i]->data = NULL;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "show_deleted:", 13) == 0) {
+                        const char *p;
+                        int crit, ret;
+                        p = &(control_strings[i][13]);
+                        ret = sscanf(p, "%d", &crit);
+                        if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid show_deleted control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_SHOW_DELETED_OID;
+                        ctrl[i]->critical = crit;
+                        ctrl[i]->data = NULL;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "show_deactivated_link:", 22) == 0) {
+                        const char *p;
+                        int crit, ret;
+                        p = &(control_strings[i][22]);
+                        ret = sscanf(p, "%d", &crit);
+                        if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid show_deactivated_link control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_SHOW_DEACTIVATED_LINK_OID;
+                        ctrl[i]->critical = crit;
+                        ctrl[i]->data = NULL;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "show_recycled:", 14) == 0) {
+                        const char *p;
+                        int crit, ret;
+                        p = &(control_strings[i][14]);
+                        ret = sscanf(p, "%d", &crit);
+                        if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid show_recycled control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_SHOW_RECYCLED_OID;
+                        ctrl[i]->critical = crit;
+                        ctrl[i]->data = NULL;
+                        continue;
+                }
+                if (strncmp(control_strings[i], "permissive_modify:", 18) == 0) {
+                        const char *p;
+                        int crit, ret;
+                        p = &(control_strings[i][18]);
+                        ret = sscanf(p, "%d", &crit);
+                        if ((ret != 1) || (crit < 0) || (crit > 1)) {
+                                error_string = talloc_asprintf(mem_ctx, "invalid permissive_modify control syntax\n");
+                                error_string = talloc_asprintf_append(error_string, " syntax: crit(b)\n");
+                                error_string = talloc_asprintf_append(error_string, "   note: b = boolean");
+                                ldb_set_errstring(ldb, error_string);
+                                talloc_free(error_string);
+                                return NULL;
+                        }
+                        ctrl[i] = talloc(ctrl, struct ldb_control);
+                        if (!ctrl[i]) {
+                                ldb_oom(ldb);
+                                return NULL;
+                        }
+                        ctrl[i]->oid = LDB_CONTROL_PERMISSIVE_MODIFY_OID;
+                        ctrl[i]->critical = crit;
+                        ctrl[i]->data = NULL;
+                        continue;
+                }
+                /* no controls matched, throw an error */
+                ldb_asprintf_errstring(ldb, "Invalid control name: '%s'", control_strings[i]);
+                return NULL;
+                        talloc_free(ctrl);
+                        return NULL;
+                }
+        }

trunk/server/source4/lib/ldb/common/ldb_dn.c

-              r414
+              r745
 };
+/* it is helpful to be able to break on this in gdb */
+static void ldb_dn_mark_invalid(struct ldb_dn *dn)
+{
+        dn->invalid = true;
+}
 /* strdn may be NULL */
 struct ldb_dn *ldb_dn_from_ldb_val(void *mem_ctx,
+struct ldb_dn *ldb_dn_from_ldb_val(TALLOC_CTX *mem_ctx,
                                    struct ldb_context *ldb,
                                    const struct ldb_val *strdn)
 …
         if (strdn && strdn->data
             && (strlen((const char*)strdn->data) != strdn->length)) {
+            && (strnlen((const char*)strdn->data, strdn->length) != strdn->length)) {
                 /* The RDN must not contain a character with value 0x0 */
                 return NULL;
 …
         LDB_DN_NULL_FAILED(dn);
+        dn->ldb = ldb;
+        dn->ldb = talloc_get_type(ldb, struct ldb_context);
+        if (dn->ldb == NULL) {
+                /* the caller probably got the arguments to
+                   ldb_dn_new() mixed up */
+                talloc_free(dn);
+                return NULL;
+        }
         if (strdn->data && strdn->length) {
 …
 /* strdn may be NULL */
 struct ldb_dn *ldb_dn_new(void *mem_ctx,
+struct ldb_dn *ldb_dn_new(TALLOC_CTX *mem_ctx,
                           struct ldb_context *ldb,
                           const char *strdn)
+{
         struct ldb_val blob;
         blob.data = strdn;
+        blob.data = discard_const_p(uint8_t, strdn);
         blob.length = strdn ? strlen(strdn) : 0;
         return ldb_dn_from_ldb_val(mem_ctx, ldb, &blob);
+}
 struct ldb_dn *ldb_dn_new_fmt(void *mem_ctx,
+struct ldb_dn *ldb_dn_new_fmt(TALLOC_CTX *mem_ctx,
                               struct ldb_context *ldb,
                               const char *new_fmt, ...)
 …
+}
+/* see RFC2253 section 2.4 */
 static int ldb_dn_escape_internal(char *dst, const char *src, int len)
+{
         const char *p, *s;
         char *d;
         int l;
+        size_t l;
         p = s = src;
 …
         while (p - src < len) {
+                p += strcspn(p, ",=\n+<>#;\\\"");
+                p += strcspn(p, ",=\n\r+<>#;\\\" ");
                 if (p - src == len) /* found no escapable chars */
 …
                 memcpy(d, s, p - s);
                 d += (p - s); /* move to current position */
+                if (*p) { /* it is a normal escapable character */
+                switch (*p) {
+                case ' ':
+                        if (p == src || (p-src)==(len-1)) {
+                                /* if at the beginning or end
+                                 * of the string then escape */
+                                *d++ = '\\';
+                                *d++ = *p++;
+                        } else {
+                                /* otherwise don't escape */
+                                *d++ = *p++;
+                        }
+                        break;
+                case '#':
+                        /* despite the RFC, windows escapes a #
+                           anywhere in the string */
+                case ',':
+                case '+':
+                case '"':
+                case '\\':
+                case '<':
+                case '>':
+                case '?':
+                        /* these must be escaped using \c form */
                         *d++ = '\\';
                         *d++ = *p++;
+                } else { /* we have a zero byte in the string */
+                        strncpy(d, "\00", 3); /* escape the zero */
+                        d += 3;
+                        p++; /* skip the zero */
+                        break;
+                default: {
+                        /* any others get \XX form */
+                        unsigned char v;
+                        const char *hexbytes = "0123456789ABCDEF";
+                        v = *(const unsigned char *)p;
+                        *d++ = '\\';
+                        *d++ = hexbytes[v>>4];
+                        *d++ = hexbytes[v&0xF];
+                        p++;
+                        break;
+                }
+                }
                 s = p; /* move forward */
 …
+}
 char *ldb_dn_escape_value(void *mem_ctx, struct ldb_val value)
+char *ldb_dn_escape_value(TALLOC_CTX *mem_ctx, struct ldb_val value)
+{
         char *dst;
 …
+{
         char *p, *ex_name, *ex_value, *data, *d, *dt, *t;
         bool trim = false;
         bool in_extended = false;
+        bool trim = true;
+        bool in_extended = true;
         bool in_ex_name = false;
         bool in_ex_value = false;
 …
         bool is_oid = false;
         bool escape = false;
+        unsigned x;
+        int l, ret;
+        unsigned int x;
+        size_t l;
+        int ret;
         char *parse_dn;
+        bool is_index;
         if ( ! dn || dn->invalid) return false;
 …
+        }
+        /* The RDN size must be less than 255 characters */
+        if (strlen(parse_dn) > 255) {
+                return false;
+        }
+        is_index = (strncmp(parse_dn, "DN=@INDEX:", 10) == 0);
         /* Empty DNs */
 …
+        }
+        /* make sure we free this if alloced previously before replacing */
+        talloc_free(dn->components);
+        talloc_free(dn->ext_components);
+        dn->ext_components = NULL;
+        /* make sure we free this if allocated previously before replacing */
+        LDB_FREE(dn->components);
+        dn->comp_num = 0;
+        LDB_FREE(dn->ext_components);
+        dn->ext_comp_num = 0;
         /* in the common case we have 3 or more components */
 …
                 return false;
+        }
-        dn->comp_num = 0;
         /* Components data space is allocated here once */
 …
         p = parse_dn;
-        in_extended = true;
-        in_ex_name = false;
-        in_ex_value = false;
-        trim = true;
         t = NULL;
         d = dt = data;
 …
                                                           &ex_val, &dn->ext_components[dn->ext_comp_num].value);
                                 if (ret != LDB_SUCCESS) {
                                         dn->invalid = true;
+                                        ldb_dn_mark_invalid(dn);
                                         goto failed;
+                                }
 …
                                         continue;
                                 } else {
                                         dn->invalid = true;
+                                        ldb_dn_mark_invalid(dn);
                                         goto failed;
+                                }
 …
                                 if (!isascii(*p)) {
                                         /* attr names must be ascii only */
                                         dn->invalid = true;
+                                        ldb_dn_mark_invalid(dn);
                                         goto failed;
+                                }
 …
                                         /* not a digit nor an alpha,
                                          * invalid attribute name */
                                         dn->invalid = true;
+                                        ldb_dn_mark_invalid(dn);
                                         goto failed;
+                                }
 …
                         if (trim && (*p != '=')) {
                                 /* spaces/tabs are not allowed */
                                 dn->invalid = true;
+                                ldb_dn_mark_invalid(dn);
                                 goto failed;
+                        }
 …
                         if (!isascii(*p)) {
                                 /* attr names must be ascii only */
                                 dn->invalid = true;
+                                ldb_dn_mark_invalid(dn);
                                 goto failed;
+                        }
 …
                                 /* not a digit nor a dot,
                                  * invalid attribute oid */
                                 dn->invalid = true;
+                                ldb_dn_mark_invalid(dn);
                                 goto failed;
                         } else
                         if ( ! (isalpha(*p) || isdigit(*p) || (*p == '-'))) {
                                 /* not ALPHA, DIGIT or HYPHEN */
                                 dn->invalid = true;
+                                ldb_dn_mark_invalid(dn);
                                 goto failed;
+                        }
 …
                                 continue;
+                        case '+':
                         case '=':
+                        case '\n':
+                        case '+':
+                                /* to main compatibility with earlier
+                                versions of ldb indexing, we have to
+                                accept the base64 encoded binary index
+                                values, which contain a '+' or '='
+                                which should normally be escaped */
+                                if (is_index) {
+                                        if ( t ) t = NULL;
+                                        *d++ = *p++;
+                                        l++;
+                                        break;
+                                }
+                                /* fall through */
+                        case '\"':
                         case '<':
                         case '>':
-                        case '#':
                         case ';':
-                        case '\"':
                                 /* a string with not escaped specials is invalid (tested) */
                                 if ( ! escape) {
                                         dn->invalid = true;
+                                        ldb_dn_mark_invalid(dn);
                                         goto failed;
+                                }
 …
                         default:
                                 if (escape) {
+                                        if (sscanf(p, "%02x", &x) != 1) {
+                                                /* invalid escaping sequence */
+                                                dn->invalid = true;
+                                                goto failed;
+                                        if (isxdigit(p[0]) && isxdigit(p[1])) {
+                                                if (sscanf(p, "%02x", &x) != 1) {
+                                                        /* invalid escaping sequence */
+                                                        ldb_dn_mark_invalid(dn);
+                                                        goto failed;
+                                                }
+                                                p += 2;
+                                                *d++ = (unsigned char)x;
+                                        } else {
+                                                *d++ = *p++;
+                                        }
                                         escape = false;
-                                        p += 2;
-                                        *d++ = (unsigned char)x;
                                         l++;
                                         if ( t ) t = NULL;
                                         break;
 …
         if (in_attr || in_quote) {
                 /* invalid dn */
                 dn->invalid = true;
+                ldb_dn_mark_invalid(dn);
                 goto failed;
+        }
 …
 failed:
+        LDB_FREE(dn->components); /* "data" is implicitly free'd */
         dn->comp_num = 0;
+        talloc_free(dn->components);
+        LDB_FREE(dn->ext_components);
+        dn->ext_comp_num = 0;
         return false;
+}
 …
 const char *ldb_dn_get_linearized(struct ldb_dn *dn)
+{
+        int i, len;
+        unsigned int i;
+        size_t len;
         char *d, *n;
 …
         if ( ! dn->components) {
                 dn->invalid = true;
+                ldb_dn_mark_invalid(dn);
                 return NULL;
+        }
 …
+}
+char *ldb_dn_get_extended_linearized(void *mem_ctx, struct ldb_dn *dn, int mode)
+static int ldb_dn_extended_component_compare(const void *p1, const void *p2)
+{
+        const struct ldb_dn_ext_component *ec1 = (const struct ldb_dn_ext_component *)p1;
+        const struct ldb_dn_ext_component *ec2 = (const struct ldb_dn_ext_component *)p2;
+        return strcmp(ec1->name, ec2->name);
+}
+char *ldb_dn_get_extended_linearized(TALLOC_CTX *mem_ctx, struct ldb_dn *dn, int mode)
+{
         const char *linearized = ldb_dn_get_linearized(dn);
         char *p;
         int i;
+        char *p = NULL;
+        unsigned int i;
         if (!linearized) {
 …
                 return NULL;
+        }
+        /* sort the extended components by name. The idea is to make
+         * the resulting DNs consistent, plus to ensure that we put
+         * 'DELETED' first, so it can be very quickly recognised
+         */
+        TYPESAFE_QSORT(dn->ext_components, dn->ext_comp_num,
+                       ldb_dn_extended_component_compare);
         for (i = 0; i < dn->ext_comp_num; i++) {
 …
                 ext_syntax = ldb_dn_extended_syntax_by_name(dn->ldb, name);
+                if (!ext_syntax) {
+                        return NULL;
+                }
                 if (mode == 1) {
 …
                 if (i == 0) {
                         p = talloc_asprintf(mem_ctx, "<%s=%s>",
                                                         name, val.data);
+                        p = talloc_asprintf(mem_ctx, "<%s=%s>",
+                                            name, val.data);
                 } else {
                         p = talloc_asprintf_append(p, ";<%s=%s>",
                                                         name, val.data);
+                        p = talloc_asprintf_append_buffer(p, ";<%s=%s>",
+                                                          name, val.data);
+                }
 …
         if (dn->ext_comp_num && *linearized) {
                 p = talloc_asprintf_append(p, ";%s", linearized);
+                p = talloc_asprintf_append_buffer(p, ";%s", linearized);
+        }
 …
+}
+char *ldb_dn_alloc_linearized(void *mem_ctx, struct ldb_dn *dn)
+/*
+  filter out all but an acceptable list of extended DN components
+ */
+void ldb_dn_extended_filter(struct ldb_dn *dn, const char * const *accept_list)
+{
+        unsigned int i;
+        for (i=0; i<dn->ext_comp_num; i++) {
+                if (!ldb_attr_in_list(accept_list, dn->ext_components[i].name)) {
+                        memmove(&dn->ext_components[i],
+                                &dn->ext_components[i+1],
+                                (dn->ext_comp_num-(i+1))*sizeof(dn->ext_components[0]));
+                        dn->ext_comp_num--;
+                        i--;
+                }
+        }
+        LDB_FREE(dn->ext_linearized);
+}
+char *ldb_dn_alloc_linearized(TALLOC_CTX *mem_ctx, struct ldb_dn *dn)
+{
         return talloc_strdup(mem_ctx, ldb_dn_get_linearized(dn));
 …
 static bool ldb_dn_casefold_internal(struct ldb_dn *dn)
+{
+        int i, ret;
+        unsigned int i;
+        int ret;
         if ( ! dn || dn->invalid) return false;
 …
 const char *ldb_dn_get_casefold(struct ldb_dn *dn)
+{
+        int i, len;
+        unsigned int i;
+        size_t len;
         char *d, *n;
 …
+}
 char *ldb_dn_alloc_casefold(void *mem_ctx, struct ldb_dn *dn)
+char *ldb_dn_alloc_casefold(TALLOC_CTX *mem_ctx, struct ldb_dn *dn)
+{
         return talloc_strdup(mem_ctx, ldb_dn_get_casefold(dn));
 …
+{
         int ret;
         int n_base, n_dn;
+        unsigned int n_base, n_dn;
         if ( ! base || base->invalid) return 1;
 …
+        }
         if (dn->comp_num == 0) {
+        if ((dn->comp_num == 0) || (base->comp_num == 0)) {
                 if (dn->special && base->special) {
                         return strcmp(base->linearized, dn->linearized);
 …
         n_dn = dn->comp_num - 1;
         while (n_base >= 0) {
+        while (n_base != (unsigned int) -1) {
                 char *b_name = base->components[n_base].cf_name;
                 char *dn_name = dn->components[n_dn].cf_name;
 …
 int ldb_dn_compare(struct ldb_dn *dn0, struct ldb_dn *dn1)
+{
+        int i, ret;
+        unsigned int i;
+        int ret;
         if (( ! dn0) || dn0->invalid || ! dn1 || dn1->invalid) {
 …
 static struct ldb_dn_component ldb_dn_copy_component(
                                                 void *mem_ctx,
+                                                TALLOC_CTX *mem_ctx,
                                                 struct ldb_dn_component *src)
+{
 …
 static struct ldb_dn_ext_component ldb_dn_ext_copy_component(
                                                 void *mem_ctx,
+                                                TALLOC_CTX *mem_ctx,
                                                 struct ldb_dn_ext_component *src)
+{
 …
+}
 struct ldb_dn *ldb_dn_copy(void *mem_ctx, struct ldb_dn *dn)
+struct ldb_dn *ldb_dn_copy(TALLOC_CTX *mem_ctx, struct ldb_dn *dn)
+{
         struct ldb_dn *new_dn;
 …
         if (dn->components) {
                 int i;
+                unsigned int i;
                 new_dn->components =
 …
         if (dn->ext_components) {
                 int i;
+                unsigned int i;
                 new_dn->ext_components =
 …
         if (dn->components) {
                 int i;
+                unsigned int i;
                 if ( ! ldb_dn_validate(base)) {
 …
                                                 dn->comp_num + base->comp_num);
                 if ( ! dn->components) {
                         dn->invalid = true;
+                        ldb_dn_mark_invalid(dn);
                         return false;
+                }
 …
                                                         &base->components[i]);
                         if (dn->components[dn->comp_num].value.data == NULL) {
                                 dn->invalid = true;
+                                ldb_dn_mark_invalid(dn);
                                 return false;
+                        }
 …
+                }
                 if ( ! t) {
                         dn->invalid = true;
+                        ldb_dn_mark_invalid(dn);
                         return false;
+                }
 …
         /* Wipe the ext_linearized DN,
          * the GUID and SID are almost certainly no longer valid */
+        if (dn->ext_linearized) {
+                LDB_FREE(dn->ext_linearized);
+        }
+        LDB_FREE(dn->ext_linearized);
         LDB_FREE(dn->ext_components);
         dn->ext_comp_num = 0;
         return true;
+}
 …
         if (dn->components) {
+                int n, i, j;
+                unsigned int n;
+                unsigned int i, j;
+                if (dn->comp_num == 0) {
+                        return false;
+                }
                 if ( ! ldb_dn_validate(child)) {
 …
                                                 n);
                 if ( ! dn->components) {
                         dn->invalid = true;
+                        ldb_dn_mark_invalid(dn);
                         return false;
+                }
+                for (i = dn->comp_num - 1, j = n - 1; i >= 0; i--, j--) {
+                for (i = dn->comp_num - 1, j = n - 1; i != (unsigned int) -1;
+                     i--, j--) {
                         dn->components[j] = dn->components[i];
+                }
 …
                                                         &child->components[i]);
                         if (dn->components[i].value.data == NULL) {
                                 dn->invalid = true;
+                                ldb_dn_mark_invalid(dn);
                                 return false;
+                        }
 …
         if (dn->linearized) {
+                if (dn->linearized[0] == '\0') {
+                        return false;
+                }
                 s = ldb_dn_get_linearized(child);
 …
                 t = talloc_asprintf(dn, "%s,%s", s, dn->linearized);
                 if ( ! t) {
                         dn->invalid = true;
+                        ldb_dn_mark_invalid(dn);
                         return false;
+                }
 …
          * the GUID and SID are almost certainly no longer valid */
         LDB_FREE(dn->ext_linearized);
         LDB_FREE(dn->ext_components);
         dn->ext_comp_num = 0;
 …
 bool ldb_dn_remove_base_components(struct ldb_dn *dn, unsigned int num)
+{
         int i;
+        unsigned int i;
         if ( ! ldb_dn_validate(dn)) {
 …
         /* free components */
         for (i = num; i > 0; i--) {
                 LDB_FREE(dn->components[dn->comp_num - i].name);
                 LDB_FREE(dn->components[dn->comp_num - i].value.data);
                 LDB_FREE(dn->components[dn->comp_num - i].cf_name);
                 LDB_FREE(dn->components[dn->comp_num - i].cf_value.data);
+        for (i = dn->comp_num - num; i < dn->comp_num; i++) {
+                LDB_FREE(dn->components[i].name);
+                LDB_FREE(dn->components[i].value.data);
+                LDB_FREE(dn->components[i].cf_name);
+                LDB_FREE(dn->components[i].cf_value.data);
+        }
 …
          * the GUID and SID are almost certainly no longer valid */
         LDB_FREE(dn->ext_linearized);
         LDB_FREE(dn->ext_components);
         dn->ext_comp_num = 0;
 …
 bool ldb_dn_remove_child_components(struct ldb_dn *dn, unsigned int num)
+{
         int i, j;
+        unsigned int i, j;
         if ( ! ldb_dn_validate(dn)) {
 …
          * the GUID and SID are almost certainly no longer valid */
         LDB_FREE(dn->ext_linearized);
         LDB_FREE(dn->ext_components);
         dn->ext_comp_num = 0;
         return true;
+}
 struct ldb_dn *ldb_dn_get_parent(void *mem_ctx, struct ldb_dn *dn)
+struct ldb_dn *ldb_dn_get_parent(TALLOC_CTX *mem_ctx, struct ldb_dn *dn)
+{
         struct ldb_dn *new_dn;
 …
+        }
-        /* Wipe the ext_linearized DN,
-         * the GUID and SID are almost certainly no longer valid */
-        LDB_FREE(dn->ext_linearized);
-        LDB_FREE(dn->ext_components);
-        dn->ext_comp_num = 0;
         return new_dn;
+}
 …
 */
 static char *ldb_dn_canonical(void *mem_ctx, struct ldb_dn *dn, int ex_format) {
         int i;
+static char *ldb_dn_canonical(TALLOC_CTX *mem_ctx, struct ldb_dn *dn, int ex_format) {
+        unsigned int i;
         TALLOC_CTX *tmpctx;
         char *cracked = NULL;
 …
         /* Walk backwards down the DN, grabbing 'dc' components at first */
         for (i = dn->comp_num - 1 ; i >= 0; i--) {
+        for (i = dn->comp_num - 1; i != (unsigned int) -1; i--) {
                 if (ldb_attr_cmp(dn->components[i].name, "dc") != 0) {
                         break;
 …
         /* Only domain components?  Finish here */
         if (i < 0) {
+        if (i == (unsigned int) -1) {
                 cracked = talloc_strdup_append_buffer(cracked, format);
                 talloc_steal(mem_ctx, cracked);
 …
 /* Wrapper functions for the above, for the two different string formats */
 char *ldb_dn_canonical_string(void *mem_ctx, struct ldb_dn *dn) {
+char *ldb_dn_canonical_string(TALLOC_CTX *mem_ctx, struct ldb_dn *dn) {
         return ldb_dn_canonical(mem_ctx, dn, 0);
+}
 char *ldb_dn_canonical_ex_string(void *mem_ctx, struct ldb_dn *dn) {
+char *ldb_dn_canonical_ex_string(TALLOC_CTX *mem_ctx, struct ldb_dn *dn) {
         return ldb_dn_canonical(mem_ctx, dn, 1);
+}
 …
+        }
         return dn->comp_num;
+}
+int ldb_dn_get_extended_comp_num(struct ldb_dn *dn)
+{
+        if ( ! ldb_dn_validate(dn)) {
+                return -1;
+        }
+        return dn->ext_comp_num;
+}
 …
         if (dn->valid_case) {
                 int i;
+                unsigned int i;
                 for (i = 0; i < dn->comp_num; i++) {
                         LDB_FREE(dn->components[i].cf_name);
 …
          * the GUID and SID are almost certainly no longer valid */
         LDB_FREE(dn->ext_linearized);
+        LDB_FREE(dn->ext_components);
         dn->ext_comp_num = 0;
+        LDB_FREE(dn->ext_components);
         return LDB_SUCCESS;
+}
 …
                                                     const char *name)
+{
         int i;
+        unsigned int i;
         if ( ! ldb_dn_validate(dn)) {
                 return NULL;
 …
+{
         struct ldb_dn_ext_component *p;
+        int i;
+        unsigned int i;
+        struct ldb_val v2;
         if ( ! ldb_dn_validate(dn)) {
                 return LDB_ERR_OTHER;
+        }
+        if (!ldb_dn_extended_syntax_by_name(dn->ldb, name)) {
+                /* We don't know how to handle this type of thing */
+                return LDB_ERR_INVALID_DN_SYNTAX;
+        }
 …
                                 if (!dn->ext_components[i].name ||
                                     !dn->ext_components[i].value.data) {
                                         dn->invalid = true;
+                                        ldb_dn_mark_invalid(dn);
                                         return LDB_ERR_OPERATIONS_ERROR;
+                                }
                         } else {
                                 if (i != (dn->ext_comp_num - 1)) {
 …
                                                    dn->ext_comp_num);
                                 if (!dn->ext_components) {
                                         dn->invalid = true;
+                                        ldb_dn_mark_invalid(dn);
                                         return LDB_ERR_OPERATIONS_ERROR;
+                                }
+                                return LDB_SUCCESS;
+                        }
+                }
+        }
+                        }
+                        LDB_FREE(dn->ext_linearized);
+                        return LDB_SUCCESS;
+                }
+        }
+        if (val == NULL) {
+                /* removing a value that doesn't exist is not an error */
+                return LDB_SUCCESS;
+        }
+        v2 = *val;
         p = dn->ext_components
 …
                                  dn->ext_comp_num + 1);
         if (!dn->ext_components) {
                 dn->invalid = true;
+                ldb_dn_mark_invalid(dn);
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
         p[dn->ext_comp_num].value = ldb_val_dup(dn->ext_components, val);
+        p[dn->ext_comp_num].value = ldb_val_dup(dn->ext_components, &v2);
         p[dn->ext_comp_num].name = talloc_strdup(p, name);
         if (!dn->ext_components[i].name || !dn->ext_components[i].value.data) {
                 dn->invalid = true;
+                ldb_dn_mark_invalid(dn);
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
         dn->ext_comp_num++;
+        LDB_FREE(dn->ext_linearized);
         return LDB_SUCCESS;
+}
 …
 void ldb_dn_remove_extended_components(struct ldb_dn *dn)
+{
+        LDB_FREE(dn->ext_linearized);
+        LDB_FREE(dn->ext_components);
         dn->ext_comp_num = 0;
-        LDB_FREE(dn->ext_components);
+}
 …
         return false;
+}
+/*
+  this updates dn->components, taking the components from ref_dn.
+  This is used by code that wants to update the DN path of a DN
+  while not impacting on the extended DN components
+ */
+int ldb_dn_update_components(struct ldb_dn *dn, const struct ldb_dn *ref_dn)
+{
+        dn->components = talloc_realloc(dn, dn->components,
+                                        struct ldb_dn_component, ref_dn->comp_num);
+        if (!dn->components) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        memcpy(dn->components, ref_dn->components,
+               sizeof(struct ldb_dn_component)*ref_dn->comp_num);
+        dn->comp_num = ref_dn->comp_num;
+        LDB_FREE(dn->casefold);
+        LDB_FREE(dn->linearized);
+        LDB_FREE(dn->ext_linearized);
+        return LDB_SUCCESS;
+}
+/*
+  minimise a DN. The caller must pass in a validated DN.
+  If the DN has an extended component then only the first extended
+  component is kept, the DN string is stripped.
+  The existing dn is modified
+ */
+bool ldb_dn_minimise(struct ldb_dn *dn)
+{
+        unsigned int i;
+        if (!ldb_dn_validate(dn)) {
+                return false;
+        }
+        if (dn->ext_comp_num == 0) {
+                return true;
+        }
+        /* free components */
+        for (i = 0; i < dn->comp_num; i++) {
+                LDB_FREE(dn->components[i].name);
+                LDB_FREE(dn->components[i].value.data);
+                LDB_FREE(dn->components[i].cf_name);
+                LDB_FREE(dn->components[i].cf_value.data);
+        }
+        dn->comp_num = 0;
+        dn->valid_case = false;
+        LDB_FREE(dn->casefold);
+        LDB_FREE(dn->linearized);
+        /* note that we don't free dn->components as this there are
+         * several places in ldb_dn.c that rely on it being non-NULL
+         * for an exploded 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;
+        dn->ext_components = talloc_realloc(dn, dn->ext_components, struct ldb_dn_ext_component, 1);
+        if (dn->ext_components == NULL) {
+                ldb_dn_mark_invalid(dn);
+                return false;
+        }
+        LDB_FREE(dn->ext_linearized);
+        return true;
+}

trunk/server/source4/lib/ldb/common/ldb_ldif.c

-              r414
+              r745
 */
 static int ldb_read_data_file(void *mem_ctx, struct ldb_val *value)
+static int ldb_read_data_file(TALLOC_CTX *mem_ctx, struct ldb_val *value)
+{
         struct stat statbuf;
 …
   caller frees
 */
 char *ldb_base64_encode(void *mem_ctx, const char *buf, int len)
+char *ldb_base64_encode(TALLOC_CTX *mem_ctx, const char *buf, int len)
+{
         const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 …
         uint8_t *p = val->data;
-        if (ldb->flags & LDB_FLG_SHOW_BINARY) {
-                return 0;
+        }
         if (val->length == 0) {
                 return 0;
 …
                         const char *buf, size_t length, int start_pos)
+{
         unsigned int i;
+        size_t i;
         int total=0, ret;
 …
                 for (j=0;j<msg->elements[i].num_values;j++) {
                         struct ldb_val v;
+                        bool use_b64_encode;
                         ret = a->syntax->ldif_write_fn(ldb, mem_ctx, &msg->elements[i].values[j], &v);
                         if (ret != LDB_SUCCESS) {
                                 v = msg->elements[i].values[j];
+                        }
+                        if (ret != LDB_SUCCESS || ldb_should_b64_encode(ldb, &v)) {
+                        use_b64_encode = !(ldb->flags & LDB_FLG_SHOW_BINARY)
+                                        && ldb_should_b64_encode(ldb, &v);
+                        if (ret != LDB_SUCCESS || use_b64_encode) {
                                 ret = fprintf_fn(private_data, "%s:: ",
                                                  msg->elements[i].name);
 …
         CHECK_RET;
+        talloc_free(mem_ctx);
         return total;
+}
 …
 /* simple ldif attribute parser */
 static int next_attr(void *mem_ctx, char **s, const char **attr, struct ldb_val *value)
+static int next_attr(TALLOC_CTX *mem_ctx, char **s, const char **attr, struct ldb_val *value)
+{
         char *p;
 …
                 int len = ldb_read_data_file(mem_ctx, value);
                 if (len == -1) {
                         /* an error occured hile trying to retrieve the file */
+                        /* an error occurred while trying to retrieve the file */
                         return -1;
+                }

trunk/server/source4/lib/ldb/common/ldb_match.c

-              r414
+              r745
                              const struct ldb_message *msg,
                              const struct ldb_parse_tree *tree,
+                             enum ldb_scope scope)
+{
+                             enum ldb_scope scope, bool *matched)
+{
+        const struct ldb_schema_attribute *a;
+        struct ldb_message_element *el;
         if (ldb_attr_dn(tree->u.present.attr) == 0) {
+                return 1;
+        }
+        if (ldb_msg_find_element(msg, tree->u.present.attr)) {
+                return 1;
+        }
+        return 0;
+                *matched = true;
+                return LDB_SUCCESS;
+        }
+        el = ldb_msg_find_element(msg, tree->u.present.attr);
+        if (el == NULL) {
+                *matched = false;
+                return LDB_SUCCESS;
+        }
+        a = ldb_schema_attribute_by_name(ldb, el->name);
+        if (!a) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        if (a->syntax->operator_fn) {
+                unsigned int i;
+                for (i = 0; i < el->num_values; i++) {
+                        int ret = a->syntax->operator_fn(ldb, LDB_OP_PRESENT, a, &el->values[i], NULL, matched);
+                        if (ret != LDB_SUCCESS) return ret;
+                        if (*matched) return LDB_SUCCESS;
+                }
+                *matched = false;
+                return LDB_SUCCESS;
+        }
+        *matched = true;
+        return LDB_SUCCESS;
+}
 …
                                 const struct ldb_parse_tree *tree,
                                 enum ldb_scope scope,
                                 enum ldb_parse_op comp_op)
+                                enum ldb_parse_op comp_op, bool *matched)
+{
         unsigned int i;
         struct ldb_message_element *el;
         const struct ldb_schema_attribute *a;
-        int ret;
         /* FIXME: APPROX comparison not handled yet */
+        if (comp_op == LDB_OP_APPROX) return 0;
+        if (comp_op == LDB_OP_APPROX) {
+                return LDB_ERR_INAPPROPRIATE_MATCHING;
+        }
         el = ldb_msg_find_element(msg, tree->u.comparison.attr);
         if (el == NULL) {
+                return 0;
+                *matched = false;
+                return LDB_SUCCESS;
+        }
         a = ldb_schema_attribute_by_name(ldb, el->name);
+        if (!a) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
         for (i = 0; i < el->num_values; i++) {
+                ret = a->syntax->comparison_fn(ldb, ldb, &el->values[i], &tree->u.comparison.value);
+                if (ret == 0) {
+                        return 1;
+                }
+                if (ret > 0 && comp_op == LDB_OP_GREATER) {
+                        return 1;
+                }
+                if (ret < 0 && comp_op == LDB_OP_LESS) {
+                        return 1;
+                }
+        }
+        return 0;
+                if (a->syntax->operator_fn) {
+                        int ret;
+                        ret = a->syntax->operator_fn(ldb, comp_op, a, &el->values[i], &tree->u.comparison.value, matched);
+                        if (ret != LDB_SUCCESS) return ret;
+                        if (*matched) return LDB_SUCCESS;
+                } else {
+                        int ret = a->syntax->comparison_fn(ldb, ldb, &el->values[i], &tree->u.comparison.value);
+                        if (ret == 0) {
+                                *matched = true;
+                                return LDB_SUCCESS;
+                        }
+                        if (ret > 0 && comp_op == LDB_OP_GREATER) {
+                                *matched = true;
+                                return LDB_SUCCESS;
+                        }
+                        if (ret < 0 && comp_op == LDB_OP_LESS) {
+                                *matched = true;
+                                return LDB_SUCCESS;
+                        }
+                }
+        }
+        *matched = false;
+        return LDB_SUCCESS;
+}
 …
                               const struct ldb_message *msg,
                               const struct ldb_parse_tree *tree,
+                              enum ldb_scope scope)
+                              enum ldb_scope scope,
+                              bool *matched)
+{
         unsigned int i;
 …
                 valuedn = ldb_dn_from_ldb_val(ldb, ldb, &tree->u.equality.value);
                 if (valuedn == NULL) {
                         return 0;
+                        return LDB_ERR_INVALID_DN_SYNTAX;
+                }
 …
                 talloc_free(valuedn);
                 if (ret == 0) return 1;
                 return 0;
+                *matched = (ret == 0);
+                return LDB_SUCCESS;
+        }
 …
         el = ldb_msg_find_element(msg, tree->u.equality.attr);
         if (el == NULL) {
+                return 0;
+                *matched = false;
+                return LDB_SUCCESS;
+        }
         a = ldb_schema_attribute_by_name(ldb, el->name);
+        if (a == NULL) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
         for (i=0;i<el->num_values;i++) {
+                if (a->syntax->comparison_fn(ldb, ldb, &tree->u.equality.value,
+                                             &el->values[i]) == 0) {
+                        return 1;
+                }
+        }
+        return 0;
+                if (a->syntax->operator_fn) {
+                        ret = a->syntax->operator_fn(ldb, LDB_OP_EQUALITY, a,
+                                                     &tree->u.equality.value, &el->values[i], matched);
+                        if (ret != LDB_SUCCESS) return ret;
+                        if (*matched) return LDB_SUCCESS;
+                } else {
+                        if (a->syntax->comparison_fn(ldb, ldb, &tree->u.equality.value,
+                                                     &el->values[i]) == 0) {
+                                *matched = true;
+                                return LDB_SUCCESS;
+                        }
+                }
+        }
+        *matched = false;
+        return LDB_SUCCESS;
+}
 static int ldb_wildcard_compare(struct ldb_context *ldb,
                                 const struct ldb_parse_tree *tree,
                                 const struct ldb_val value)
+                                const struct ldb_val value, bool *matched)
+{
         const struct ldb_schema_attribute *a;
 …
         char *p, *g;
         uint8_t *save_p = NULL;
         int c = 0;
+        unsigned int c = 0;
         a = ldb_schema_attribute_by_name(ldb, tree->u.substring.attr);
+        if(a->syntax->canonicalise_fn(ldb, ldb, &value, &val) != 0)
+                return -1;
+        if (!a) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        if (a->syntax->canonicalise_fn(ldb, ldb, &value, &val) != 0) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
         save_p = val.data;
 …
                 chunk = tree->u.substring.chunks[c];
                 if(a->syntax->canonicalise_fn(ldb, ldb, chunk, &cnk) != 0) goto failed;
+                if (a->syntax->canonicalise_fn(ldb, ldb, chunk, &cnk) != 0) goto mismatch;
                 /* This deals with wildcard prefix searches on binary attributes (eg objectGUID) */
                 if (cnk.length > val.length) {
                         goto failed;
+                }
                 if (memcmp((char *)val.data, (char *)cnk.data, cnk.length) != 0) goto failed;
+                        goto mismatch;
+                }
+                if (memcmp((char *)val.data, (char *)cnk.data, cnk.length) != 0) goto mismatch;
                 val.length -= cnk.length;
                 val.data += cnk.length;
 …
                 chunk = tree->u.substring.chunks[c];
                 if(a->syntax->canonicalise_fn(ldb, ldb, chunk, &cnk) != 0) goto failed;
+                if(a->syntax->canonicalise_fn(ldb, ldb, chunk, &cnk) != 0) goto mismatch;
                 /* FIXME: case of embedded nulls */
                 p = strstr((char *)val.data, (char *)cnk.data);
                 if (p == NULL) goto failed;
+                if (p == NULL) goto mismatch;
                 if ( (! tree->u.substring.chunks[c + 1]) && (! tree->u.substring.end_with_wildcard) ) {
                         do { /* greedy */
 …
+        }
+        if ( (! tree->u.substring.end_with_wildcard) && (*(val.data) != 0) ) goto failed; /* last chunk have not reached end of string */
+        /* last chunk may not have reached end of string */
+        if ( (! tree->u.substring.end_with_wildcard) && (*(val.data) != 0) ) goto mismatch;
         talloc_free(save_p);
+        return 1;
+failed:
+        *matched = true;
+        return LDB_SUCCESS;
+mismatch:
+        *matched = false;
         talloc_free(save_p);
         talloc_free(cnk.data);
         return 0;
+        return LDB_SUCCESS;
+}
 …
                                const struct ldb_message *msg,
                                const struct ldb_parse_tree *tree,
                                enum ldb_scope scope)
+                               enum ldb_scope scope, bool *matched)
+{
         unsigned int i;
 …
         el = ldb_msg_find_element(msg, tree->u.substring.attr);
         if (el == NULL) {
+                return 0;
+                *matched = false;
+                return LDB_SUCCESS;
+        }
         for (i = 0; i < el->num_values; i++) {
+                if (ldb_wildcard_compare(ldb, tree, el->values[i]) == 1) {
+                        return 1;
+                }
+        }
+        return 0;
+                int ret;
+                ret = ldb_wildcard_compare(ldb, tree, el->values[i], matched);
+                if (ret != LDB_SUCCESS) return ret;
+                if (*matched) return LDB_SUCCESS;
+        }
+        *matched = false;
+        return LDB_SUCCESS;
+}
 …
   bitwise-and comparator
 */
+static int ldb_comparator_and(const struct ldb_val *v1, const struct ldb_val *v2)
+static int ldb_comparator_bitmask(const char *oid, const struct ldb_val *v1, const struct ldb_val *v2,
+                                  bool *matched)
+{
         uint64_t i1, i2;
+        i1 = strtoull((char *)v1->data, NULL, 0);
+        i2 = strtoull((char *)v2->data, NULL, 0);
+        return ((i1 & i2) == i2);
+}
+/*
+  bitwise-or comparator
+*/
+static int ldb_comparator_or(const struct ldb_val *v1, const struct ldb_val *v2)
+{
+        uint64_t i1, i2;
+        i1 = strtoull((char *)v1->data, NULL, 0);
+        i2 = strtoull((char *)v2->data, NULL, 0);
+        return ((i1 & i2) != 0);
+        char ibuf[100];
+        char *endptr = NULL;
+        if (v1->length >= sizeof(ibuf)-1) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        memcpy(ibuf, (char *)v1->data, v1->length);
+        ibuf[v1->length] = 0;
+        i1 = strtoull(ibuf, &endptr, 0);
+        if (endptr != NULL) {
+                if (endptr == ibuf || *endptr != 0) {
+                        return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+                }
+        }
+        if (v2->length >= sizeof(ibuf)-1) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        endptr = NULL;
+        memcpy(ibuf, (char *)v2->data, v2->length);
+        ibuf[v2->length] = 0;
+        i2 = strtoull(ibuf, &endptr, 0);
+        if (endptr != NULL) {
+                if (endptr == ibuf || *endptr != 0) {
+                        return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+                }
+        }
+        if (strcmp(LDB_OID_COMPARATOR_AND, oid) == 0) {
+                *matched = ((i1 & i2) == i2);
+        } else if (strcmp(LDB_OID_COMPARATOR_OR, oid) == 0) {
+                *matched = ((i1 & i2) != 0);
+        } else {
+                return LDB_ERR_INAPPROPRIATE_MATCHING;
+        }
+        return LDB_SUCCESS;
+}
 …
                               const struct ldb_message *msg,
                               const struct ldb_parse_tree *tree,
                               enum ldb_scope scope)
+{
         int i;
+                              enum ldb_scope scope, bool *matched)
+{
+        unsigned int i;
         const struct {
                 const char *oid;
                 int (*comparator)(const struct ldb_val *, const struct ldb_val *);
+                int (*comparator)(const char *, const struct ldb_val *, const struct ldb_val *, bool *);
         } rules[] = {
                 { LDB_OID_COMPARATOR_AND, ldb_comparator_and},
                 { LDB_OID_COMPARATOR_OR, ldb_comparator_or}
+                { LDB_OID_COMPARATOR_AND, ldb_comparator_bitmask},
+                { LDB_OID_COMPARATOR_OR, ldb_comparator_bitmask}
         };
         int (*comp)(const struct ldb_val *, const struct ldb_val *) = NULL;
+        int (*comp)(const char *,const struct ldb_val *, const struct ldb_val *, bool *) = NULL;
         struct ldb_message_element *el;
         if (tree->u.extended.dnAttributes) {
+                ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb: dnAttributes extended match not supported yet");
+                return -1;
+                /* FIXME: We really need to find out what this ":dn" part in
+                 * an extended match means and how to handle it. For now print
+                 * only a warning to have s3 winbind and other tools working
+                 * against us. - Matthias */
+                ldb_debug(ldb, LDB_DEBUG_WARNING, "ldb: dnAttributes extended match not supported yet");
+        }
         if (tree->u.extended.rule_id == NULL) {
                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb: no-rule extended matches not supported yet");
                 return -1;
+                return LDB_ERR_INAPPROPRIATE_MATCHING;
+        }
         if (tree->u.extended.attr == NULL) {
                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb: no-attribute extended matches not supported yet");
                 return -1;
+                return LDB_ERR_INAPPROPRIATE_MATCHING;
+        }
 …
                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb: unknown extended rule_id %s",
                           tree->u.extended.rule_id);
                 return -1;
+                return LDB_ERR_INAPPROPRIATE_MATCHING;
+        }
 …
         el = ldb_msg_find_element(msg, tree->u.extended.attr);
         if (el == NULL) {
+                return 0;
+                *matched = false;
+                return LDB_SUCCESS;
+        }
         for (i=0;i<el->num_values;i++) {
+                int ret = comp(&el->values[i], &tree->u.extended.value);
+                if (ret == -1 || ret == 1) return ret;
+        }
+        return 0;
+                int ret = comp(tree->u.extended.rule_id, &el->values[i], &tree->u.extended.value, matched);
+                if (ret != LDB_SUCCESS) return ret;
+                if (*matched) return LDB_SUCCESS;
+        }
+        *matched = false;
+        return LDB_SUCCESS;
+}
 …
                              const struct ldb_message *msg,
                              const struct ldb_parse_tree *tree,
                              enum ldb_scope scope)
+                             enum ldb_scope scope, bool *matched)
+{
         unsigned int i;
+        int v;
+        int ret;
+        *matched = false;
         switch (tree->operation) {
         case LDB_OP_AND:
                 for (i=0;i<tree->u.list.num_elements;i++) {
+                        v = ldb_match_message(ldb, msg, tree->u.list.elements[i], scope);
+                        if (!v) return 0;
+                }
+                return 1;
+                        ret = ldb_match_message(ldb, msg, tree->u.list.elements[i], scope, matched);
+                        if (ret != LDB_SUCCESS) return ret;
+                        if (!*matched) return LDB_SUCCESS;
+                }
+                *matched = true;
+                return LDB_SUCCESS;
         case LDB_OP_OR:
                 for (i=0;i<tree->u.list.num_elements;i++) {
+                        v = ldb_match_message(ldb, msg, tree->u.list.elements[i], scope);
+                        if (v) return 1;
+                }
+                return 0;
+                        ret = ldb_match_message(ldb, msg, tree->u.list.elements[i], scope, matched);
+                        if (ret != LDB_SUCCESS) return ret;
+                        if (*matched) return LDB_SUCCESS;
+                }
+                *matched = false;
+                return LDB_SUCCESS;
         case LDB_OP_NOT:
+                return ! ldb_match_message(ldb, msg, tree->u.isnot.child, scope);
+                ret = ldb_match_message(ldb, msg, tree->u.isnot.child, scope, matched);
+                if (ret != LDB_SUCCESS) return ret;
+                *matched = ! *matched;
+                return LDB_SUCCESS;
         case LDB_OP_EQUALITY:
                 return ldb_match_equality(ldb, msg, tree, scope);
+                return ldb_match_equality(ldb, msg, tree, scope, matched);
         case LDB_OP_SUBSTRING:
                 return ldb_match_substring(ldb, msg, tree, scope);
+                return ldb_match_substring(ldb, msg, tree, scope, matched);
         case LDB_OP_GREATER:
                 return ldb_match_comparison(ldb, msg, tree, scope, LDB_OP_GREATER);
+                return ldb_match_comparison(ldb, msg, tree, scope, LDB_OP_GREATER, matched);
         case LDB_OP_LESS:
                 return ldb_match_comparison(ldb, msg, tree, scope, LDB_OP_LESS);
+                return ldb_match_comparison(ldb, msg, tree, scope, LDB_OP_LESS, matched);
         case LDB_OP_PRESENT:
                 return ldb_match_present(ldb, msg, tree, scope);
+                return ldb_match_present(ldb, msg, tree, scope, matched);
         case LDB_OP_APPROX:
                 return ldb_match_comparison(ldb, msg, tree, scope, LDB_OP_APPROX);
+                return ldb_match_comparison(ldb, msg, tree, scope, LDB_OP_APPROX, matched);
         case LDB_OP_EXTENDED:
+                return ldb_match_extended(ldb, msg, tree, scope);
+        }
+        return 0;
+                return ldb_match_extended(ldb, msg, tree, scope, matched);
+        }
+        return LDB_ERR_INAPPROPRIATE_MATCHING;
+}
 …
                   enum ldb_scope scope)
+{
+        bool matched;
+        int ret;
         if ( ! ldb_match_scope(ldb, base, msg->dn, scope) ) {
                 return 0;
+        }
+        return ldb_match_message(ldb, msg, tree, scope);
+}
+        ret = ldb_match_message(ldb, msg, tree, scope, &matched);
+        if (ret != LDB_SUCCESS) {
+                /* to match the old API, we need to consider this a
+                   failure to match */
+                return 0;
+        }
+        return matched?1:0;
+}
+int ldb_match_msg_error(struct ldb_context *ldb,
+                        const struct ldb_message *msg,
+                        const struct ldb_parse_tree *tree,
+                        struct ldb_dn *base,
+                        enum ldb_scope scope,
+                        bool *matched)
+{
+        if ( ! ldb_match_scope(ldb, base, msg->dn, scope) ) {
+                *matched = false;
+                return LDB_SUCCESS;
+        }
+        return ldb_match_message(ldb, msg, tree, scope, matched);
+}
+int ldb_match_msg_objectclass(const struct ldb_message *msg,
+                              const char *objectclass)
+{
+        unsigned int i;
+        struct ldb_message_element *el = ldb_msg_find_element(msg, "objectClass");
+        if (!el) {
+                return 0;
+        }
+        for (i=0; i < el->num_values; i++) {
+                if (ldb_attr_cmp((const char *)el->values[i].data, objectclass) == 0) {
+                        return 1;
+                }
+        }
+        return 0;
+}

trunk/server/source4/lib/ldb/common/ldb_modules.c

-              r414
+              r745
 #include "ldb_private.h"
 #include "dlinklist.h"
+#define LDB_MODULE_PREFIX       "modules:"
+#define LDB_MODULE_PREFIX_LEN   8
+static void *ldb_dso_load_symbol(struct ldb_context *ldb, const char *name,
+                                 const char *symbol);
+void ldb_set_modules_dir(struct ldb_context *ldb, const char *path)
+{
+        talloc_free(ldb->modules_dir);
+        ldb->modules_dir = talloc_strdup(ldb, path);
+}
+#include "system/dir.h"
 static char *ldb_modules_strdup_no_spaces(TALLOC_CTX *mem_ctx, const char *string)
+{
         int i, len;
+        size_t i, len;
         char *trimmed;
 …
         const char **m;
         char *modstr, *p;
         int i;
+        unsigned int i;
         /* spaces not admitted */
 …
+        }
         talloc_steal(modules, modstr);
+        if (modstr[0] == '\0') {
+                modules[0] = NULL;
+                m = (const char **)modules;
+                return m;
+        }
         i = 0;
 …
 } *registered_modules = NULL;
+static const struct ldb_builtins {
+        const struct ldb_backend_ops *backend_ops;
+        const struct ldb_module_ops *module_ops;
+} builtins[];
+static ldb_connect_fn ldb_find_backend(const char *url)
+static struct backends_list_entry *ldb_find_backend(const char *url_prefix)
+{
         struct backends_list_entry *backend;
-        int i;
-        for (i = 0; builtins[i].backend_ops || builtins[i].module_ops; i++) {
-                if (builtins[i].backend_ops == NULL) continue;
-                if (strncmp(builtins[i].backend_ops->name, url,
-                            strlen(builtins[i].backend_ops->name)) == 0) {
-                        return builtins[i].backend_ops->connect_fn;
+                }
+        }
         for (backend = ldb_backends; backend; backend = backend->next) {
+                if (strncmp(backend->ops->name, url,
+                            strlen(backend->ops->name)) == 0) {
+                        return backend->ops->connect_fn;
+                if (strcmp(backend->ops->name, url_prefix) == 0) {
+                        return backend;
+                }
+        }
 …
 /*
+ register a new ldb backend
+  register a new ldb backend
+  if override is true, then override any existing backend for this prefix
 */
 int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn)
+{
         struct ldb_backend_ops *backend;
+        struct backends_list_entry *entry;
         backend = talloc(talloc_autofree_context(), struct ldb_backend_ops);
         if (!backend) return LDB_ERR_OPERATIONS_ERROR;
         entry = talloc(talloc_autofree_context(), struct backends_list_entry);
         if (!entry) {
                 talloc_free(backend);
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
         if (ldb_find_backend(url_prefix)) {
                 return LDB_SUCCESS;
+        }
         /* Maybe check for duplicity here later on? */
         backend->name = talloc_strdup(backend, url_prefix);
+        backend->connect_fn = connectfn;
         entry->ops = backend;
         DLIST_ADD(ldb_backends, entry);
+int ldb_register_backend(const char *url_prefix, ldb_connect_fn connectfn, bool override)
+{
+        struct backends_list_entry *be;
+        be = ldb_find_backend(url_prefix);
+        if (be) {
+                if (!override) {
+                        return LDB_SUCCESS;
+                }
+        } else {
+                be = talloc_zero(ldb_backends, struct backends_list_entry);
+                if (!be) {
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                be->ops = talloc_zero(be, struct ldb_backend_ops);
+                if (!be->ops) {
+                        talloc_free(be);
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                DLIST_ADD_END(ldb_backends, be, struct backends_list_entry);
+        }
+        be->ops->name = url_prefix;
+        be->ops->connect_fn = connectfn;
         return LDB_SUCCESS;
 …
    module may wish to direct certain requests at a particular backend.
 */
 int ldb_connect_backend(struct ldb_context *ldb,
                         const char *url,
                         const char *options[],
                         struct ldb_module **backend_module)
+int ldb_module_connect_backend(struct ldb_context *ldb,
+                               const char *url,
+                               const char *options[],
+                               struct ldb_module **backend_module)
+{
         int ret;
         char *backend;
         ldb_connect_fn fn;
+        struct backends_list_entry *be;
         if (strchr(url, ':') != NULL) {
 …
+        }
+        fn = ldb_find_backend(backend);
+        if (fn == NULL) {
+                struct ldb_backend_ops *ops;
+                char *symbol_name = talloc_asprintf(ldb, "ldb_%s_backend_ops", backend);
+                if (symbol_name == NULL) {
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                ops = ldb_dso_load_symbol(ldb, backend, symbol_name);
+                if (ops != NULL) {
+                        fn = ops->connect_fn;
+                }
+                talloc_free(symbol_name);
+        }
+        be = ldb_find_backend(backend);
         talloc_free(backend);
         if (fn == NULL) {
+        if (be == NULL) {
                 ldb_debug(ldb, LDB_DEBUG_FATAL,
                           "Unable to find backend for '%s'", url);
+                          "Unable to find backend for '%s' - do you need to set LDB_MODULES_PATH?", url);
                 return LDB_ERR_OTHER;
+        }
         ret = fn(ldb, url, ldb->flags, options, backend_module);
+        ret = be->ops->connect_fn(ldb, url, ldb->flags, options, backend_module);
         if (ret != LDB_SUCCESS) {
                 ldb_debug(ldb, LDB_DEBUG_ERROR,
                           "Failed to connect to '%s'", url);
+                          "Failed to connect to '%s' with backend '%s'", url, be->ops->name);
                 return ret;
+        }
 …
+}
+static struct ldb_hooks {
+        struct ldb_hooks *next, *prev;
+        ldb_hook_fn hook_fn;
+} *ldb_hooks;
+/*
+  register a ldb hook function
+ */
+int ldb_register_hook(ldb_hook_fn hook_fn)
+{
+        struct ldb_hooks *lc;
+        lc = talloc_zero(ldb_hooks, struct ldb_hooks);
+        if (lc == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        lc->hook_fn = hook_fn;
+        DLIST_ADD_END(ldb_hooks, lc, struct ldb_hooks);
+        return LDB_SUCCESS;
+}
+/*
+  call ldb hooks of a given type
+ */
+int ldb_modules_hook(struct ldb_context *ldb, enum ldb_module_hook_type t)
+{
+        struct ldb_hooks *lc;
+        for (lc = ldb_hooks; lc; lc=lc->next) {
+                int ret = lc->hook_fn(ldb, t);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
+        }
+        return LDB_SUCCESS;
+}
 static const struct ldb_module_ops *ldb_find_module_ops(const char *name)
+{
         struct ops_list_entry *e;
-        int i;
-        for (i = 0; builtins[i].backend_ops || builtins[i].module_ops; i++) {
-                if (builtins[i].module_ops == NULL) continue;
-                if (strcmp(builtins[i].module_ops->name, name) == 0)
-                        return builtins[i].module_ops;
+        }
         for (e = registered_modules; e; e = e->next) {
 …
 int ldb_register_module(const struct ldb_module_ops *ops)
+{
         struct ops_list_entry *entry = talloc(talloc_autofree_context(), struct ops_list_entry);
+        struct ops_list_entry *entry;
         if (ldb_find_module_ops(ops->name) != NULL)
+                return -1;
+                return LDB_ERR_ENTRY_ALREADY_EXISTS;
+        entry = talloc(talloc_autofree_context(), struct ops_list_entry);
         if (entry == NULL)
                 return -1;
 …
+}
+static void *ldb_dso_load_symbol(struct ldb_context *ldb, const char *name,
+                                 const char *symbol)
+{
+        char *path;
+        void *handle;
+        void *sym;
+        if (ldb->modules_dir == NULL)
+                return NULL;
+        path = talloc_asprintf(ldb, "%s/%s.%s", ldb->modules_dir, name,
+                               SHLIBEXT);
+        ldb_debug(ldb, LDB_DEBUG_TRACE, "trying to load %s from %s", name, path);
+        handle = dlopen(path, RTLD_NOW);
+        if (handle == NULL) {
+                ldb_debug(ldb, LDB_DEBUG_WARNING, "unable to load %s from %s: %s", name, path, dlerror());
+                return NULL;
+        }
+        sym = (int (*)(void))dlsym(handle, symbol);
+        if (sym == NULL) {
+                ldb_debug(ldb, LDB_DEBUG_ERROR, "no symbol `%s' found in %s: %s", symbol, path, dlerror());
+                return NULL;
+        }
+        talloc_free(path);
+        return sym;
+}
+int ldb_load_modules_list(struct ldb_context *ldb, const char **module_list, struct ldb_module *backend, struct ldb_module **out)
+/*
+  load a list of modules
+ */
+int ldb_module_load_list(struct ldb_context *ldb, const char **module_list,
+                         struct ldb_module *backend, struct ldb_module **out)
+{
         struct ldb_module *module;
         int i;
+        unsigned int i;
         module = backend;
         for (i = 0; module_list[i] != NULL; i++) {
+        for (i = 0; module_list && module_list[i] != NULL; i++) {
                 struct ldb_module *current;
                 const struct ldb_module_ops *ops;
 …
                 ops = ldb_find_module_ops(module_list[i]);
                 if (ops == NULL) {
+                        char *symbol_name = talloc_asprintf(ldb, "ldb_%s_module_ops",
+                                                                                                module_list[i]);
+                        if (symbol_name == NULL) {
+                                return LDB_ERR_OPERATIONS_ERROR;
+                        }
+                        ops = ldb_dso_load_symbol(ldb, module_list[i], symbol_name);
+                        talloc_free(symbol_name);
+                }
+                if (ops == NULL) {
+                        ldb_debug(ldb, LDB_DEBUG_WARNING, "WARNING: Module [%s] not found",
+                        ldb_debug(ldb, LDB_DEBUG_FATAL, "WARNING: Module [%s] not found - do you need to set LDB_MODULES_PATH?",
                                   module_list[i]);
                         continue;
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
 …
+}
+int ldb_init_module_chain(struct ldb_context *ldb, struct ldb_module *module)
+/*
+  initialise a chain of modules
+ */
+int ldb_module_init_chain(struct ldb_context *ldb, struct ldb_module *module)
+{
         while (module && module->ops->init_context == NULL)
 …
                 int ret = module->ops->init_context(module);
                 if (ret != LDB_SUCCESS) {
+                        ldb_debug(ldb, LDB_DEBUG_FATAL, "module %s initialization failed", module->ops->name);
+                        ldb_debug(ldb, LDB_DEBUG_FATAL, "module %s initialization failed : %s",
+                                  module->ops->name, ldb_strerror(ret));
                         return ret;
+                }
 …
 int ldb_load_modules(struct ldb_context *ldb, const char *options[])
+{
+        const char *modules_string;
         const char **modules = NULL;
-        int i;
         int ret;
         TALLOC_CTX *mem_ctx = talloc_new(ldb);
 …
         /* check if we have a custom module list passd as ldb option */
         if (options) {
+                for (i = 0; options[i] != NULL; i++) {
+                        if (strncmp(options[i], LDB_MODULE_PREFIX, LDB_MODULE_PREFIX_LEN) == 0) {
+                                modules = ldb_modules_list_from_string(ldb, mem_ctx, &options[i][LDB_MODULE_PREFIX_LEN]);
+                        }
+                modules_string = ldb_options_find(ldb, options, "modules");
+                if (modules_string) {
+                        modules = ldb_modules_list_from_string(ldb, mem_ctx, modules_string);
+                }
+        }
 …
         if (modules != NULL) {
                 ret = ldb_load_modules_list(ldb, modules, ldb->modules, &ldb->modules);
+                ret = ldb_module_load_list(ldb, modules, ldb->modules, &ldb->modules);
                 if (ret != LDB_SUCCESS) {
                         talloc_free(mem_ctx);
 …
+        }
         ret = ldb_init_module_chain(ldb, ldb->modules);
+        ret = ldb_module_init_chain(ldb, ldb->modules);
         talloc_free(mem_ctx);
         return ret;
 …
         module = module->next; \
         while (module && module->ops->op == NULL) module = module->next; \
+        if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) { \
+                ldb_debug(module->ldb, LDB_DEBUG_TRACE, "ldb_trace_next_request: (%s)->" #op, \
+                          module->ops->name);                           \
+        }                                                               \
 } while (0)
 …
+{
         return module->ldb;
+}
+const struct ldb_module_ops *ldb_module_get_ops(struct ldb_module *module)
+{
+        return module->ops;
+}
 …
                  * corner for module developers to cut themselves on
                  */
                 ldb_module_done(request, NULL, NULL, ret);
+                ret = ldb_module_done(request, NULL, NULL, ret);
+        }
         return ret;
 …
         module = module->next;
         return ldb_init_module_chain(module->ldb, module);
+        return ldb_module_init_chain(module->ldb, module);
+}
 int ldb_next_start_trans(struct ldb_module *module)
+{
+        int ret;
         FIND_OP(module, start_transaction);
+        return module->ops->start_transaction(module);
+        ret = module->ops->start_transaction(module);
+        if (ret == LDB_SUCCESS) {
+                return ret;
+        }
+        if (!ldb_errstring(module->ldb)) {
+                /* Set a default error string, to place the blame somewhere */
+                ldb_asprintf_errstring(module->ldb, "start_trans error in module %s: %s (%d)", module->ops->name, ldb_strerror(ret), ret);
+        }
+        if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
+                ldb_debug(module->ldb, LDB_DEBUG_TRACE, "ldb_next_start_trans error: %s",
+                          ldb_errstring(module->ldb));
+        }
+        return ret;
+}
 int ldb_next_end_trans(struct ldb_module *module)
+{
+        int ret;
         FIND_OP(module, end_transaction);
+        return module->ops->end_transaction(module);
+        ret = module->ops->end_transaction(module);
+        if (ret == LDB_SUCCESS) {
+                return ret;
+        }
+        if (!ldb_errstring(module->ldb)) {
+                /* Set a default error string, to place the blame somewhere */
+                ldb_asprintf_errstring(module->ldb, "end_trans error in module %s: %s (%d)", module->ops->name, ldb_strerror(ret), ret);
+        }
+        if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
+                ldb_debug(module->ldb, LDB_DEBUG_TRACE, "ldb_next_end_trans error: %s",
+                          ldb_errstring(module->ldb));
+        }
+        return ret;
+}
 int ldb_next_prepare_commit(struct ldb_module *module)
+{
+        int ret;
         FIND_OP_NOERR(module, prepare_commit);
         if (module == NULL) {
 …
                 return LDB_SUCCESS;
+        }
+        return module->ops->prepare_commit(module);
+        ret = module->ops->prepare_commit(module);
+        if (ret == LDB_SUCCESS) {
+                return ret;
+        }
+        if (!ldb_errstring(module->ldb)) {
+                /* Set a default error string, to place the blame somewhere */
+                ldb_asprintf_errstring(module->ldb, "prepare_commit error in module %s: %s (%d)", module->ops->name, ldb_strerror(ret), ret);
+        }
+        if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
+                ldb_debug(module->ldb, LDB_DEBUG_TRACE, "ldb_next_prepare_commit error: %s",
+                          ldb_errstring(module->ldb));
+        }
+        return ret;
+}
 int ldb_next_del_trans(struct ldb_module *module)
+{
+        int ret;
         FIND_OP(module, del_transaction);
+        return module->ops->del_transaction(module);
+        ret = module->ops->del_transaction(module);
+        if (ret == LDB_SUCCESS) {
+                return ret;
+        }
+        if (!ldb_errstring(module->ldb)) {
+                /* Set a default error string, to place the blame somewhere */
+                ldb_asprintf_errstring(module->ldb, "del_trans error in module %s: %s (%d)", module->ops->name, ldb_strerror(ret), ret);
+        }
+        if ((module && module->ldb->flags & LDB_FLG_ENABLE_TRACING)) {
+                ldb_debug(module->ldb, LDB_DEBUG_TRACE, "ldb_next_del_trans error: %s",
+                          ldb_errstring(module->ldb));
+        }
+        return ret;
+}
 …
         h->ldb = ldb;
         h->flags = 0;
+        h->location = NULL;
+        h->parent = NULL;
         return h;
 …
  *      ctrls: controls to send in the reply (must be a talloc pointer, steal)
  *      response: results for extended request (steal)
  *      error: LDB_SUCCESS for a succesful return
+ *      error: LDB_SUCCESS for a successful return
  *             any other ldb error otherwise
  */
 …
+        }
+        req->callback(req, ares);
+        return error;
+        return req->callback(req, ares);
+}
 /* to be used *only* in modules init functions.
  * this function i synchronous and will register
+ * this function is synchronous and will register
  * the requested OID in the rootdse module if present
  * otherwise it will return an error */
 …
+}
+#ifndef STATIC_LIBLDB_MODULES
+#ifdef HAVE_LDB_LDAP
+#define LDAP_BACKEND LDB_BACKEND(ldap), LDB_BACKEND(ldapi), LDB_BACKEND(ldaps),
+#else
+#define LDAP_BACKEND
+static int ldb_modules_load_dir(const char *modules_dir, const char *version);
+/*
+  load one module. A static list of loaded module inode numbers is
+  used to prevent a module being loaded twice
+  dlopen() is used on the module, and dlsym() is then used to look for
+  a ldb_init_module() function. If present, that function is called
+  with the ldb version number as an argument.
+  The ldb_init_module() function will typically call
+  ldb_register_module() and ldb_register_backend() to register a
+  module or backend, but it may also be used to register command line
+  handling functions, ldif handlers or any other local
+  modififications.
+  The ldb_init_module() function does not get a ldb_context passed in,
+  as modules will be used for multiple ldb context handles. The call
+  from the first ldb_init() is just a convenient way to ensure it is
+  called early enough.
+ */
+static int ldb_modules_load_path(const char *path, const char *version)
+{
+        void *handle;
+        int (*init_fn)(const char *);
+        int ret;
+        struct stat st;
+        static struct loaded {
+                struct loaded *next, *prev;
+                ino_t st_ino;
+                dev_t st_dev;
+        } *loaded;
+        struct loaded *le;
+        int dlopen_flags;
+        ret = stat(path, &st);
+        if (ret != 0) {
+                fprintf(stderr, "ldb: unable to stat module %s : %s\n", path, strerror(errno));
+                return LDB_ERR_UNAVAILABLE;
+        }
+        for (le=loaded; le; le=le->next) {
+                if (le->st_ino == st.st_ino &&
+                    le->st_dev == st.st_dev) {
+                        /* its already loaded */
+                        return LDB_SUCCESS;
+                }
+        }
+        le = talloc(loaded, struct loaded);
+        if (le == NULL) {
+                fprintf(stderr, "ldb: unable to allocated loaded entry\n");
+                return LDB_ERR_UNAVAILABLE;
+        }
+        le->st_ino = st.st_ino;
+        le->st_dev = st.st_dev;
+        DLIST_ADD_END(loaded, le, struct loaded);
+        /* if it is a directory, recurse */
+        if (S_ISDIR(st.st_mode)) {
+                return ldb_modules_load_dir(path, version);
+        }
+        dlopen_flags = RTLD_NOW;
+#ifdef RTLD_DEEPBIND
+        /* use deepbind if possible, to avoid issues with different
+           system library varients, for example ldb modules may be linked
+           against Heimdal while the application may use MIT kerberos
+           See the dlopen manpage for details
+        */
+        dlopen_flags |= RTLD_DEEPBIND;
 #endif
+#ifdef HAVE_LDB_SQLITE3
+#define SQLITE3_BACKEND LDB_BACKEND(sqlite3),
+#else
+#define SQLITE3_BACKEND
+#endif
+#define STATIC_LIBLDB_MODULES \
+        LDB_BACKEND(tdb),       \
+        LDAP_BACKEND    \
+        SQLITE3_BACKEND \
+        LDB_MODULE(rdn_name),   \
+        LDB_MODULE(paged_results),      \
+        LDB_MODULE(server_sort),                \
+        LDB_MODULE(asq), \
+        NULL
+#endif
+/*
+ * this is a bit hacked, as STATIC_LIBLDB_MODULES contains ','
+ * between the elements and we want to autogenerate the
+ * extern struct declarations, so we do some hacks and let the
+ * ',' appear in an unused function prototype.
+ */
+#undef NULL
+#define NULL LDB_MODULE(NULL),
+#define LDB_BACKEND(name) \
+        int); \
+        extern const struct ldb_backend_ops ldb_ ## name ## _backend_ops;\
+        extern void ldb_noop ## name (int
+#define LDB_MODULE(name) \
+        int); \
+        extern const struct ldb_module_ops ldb_ ## name ## _module_ops;\
+        extern void ldb_noop ## name (int
+extern void ldb_start_noop(int,
+STATIC_LIBLDB_MODULES
+int);
+#undef NULL
+#define NULL { \
+        .backend_ops = (void *)0, \
+        .module_ops = (void *)0 \
+}
+#undef LDB_BACKEND
+#define LDB_BACKEND(name) { \
+        .backend_ops = &ldb_ ## name ## _backend_ops, \
+        .module_ops = (void *)0 \
+}
+#undef LDB_MODULE
+#define LDB_MODULE(name) { \
+        .backend_ops = (void *)0, \
+        .module_ops = &ldb_ ## name ## _module_ops \
+}
+static const struct ldb_builtins builtins[] = {
+        STATIC_LIBLDB_MODULES
+};
+        handle = dlopen(path, dlopen_flags);
+        if (handle == NULL) {
+                fprintf(stderr, "ldb: unable to dlopen %s : %s\n", path, dlerror());
+                return LDB_SUCCESS;
+        }
+        init_fn = dlsym(handle, "ldb_init_module");
+        if (init_fn == NULL) {
+                /* ignore it, it could be an old-style
+                 * module. Once we've converted all modules we
+                 * could consider this an error */
+                dlclose(handle);
+                return LDB_SUCCESS;
+        }
+        ret = init_fn(version);
+        if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+                /* the module is already registered - ignore this, as
+                 * it can happen if LDB_MODULES_PATH points at both
+                 * the build and install directory
+                 */
+                ret = LDB_SUCCESS;
+        }
+        return ret;
+}
+static int qsort_string(const char **s1, const char **s2)
+{
+        return strcmp(*s1, *s2);
+}
+/*
+  load all modules from the given ldb modules directory. This is run once
+  during the first ldb_init() call.
+  Modules are loaded in alphabetical order to ensure that any module
+  load ordering dependencies are reproducible. Modules should avoid
+  relying on load order
+ */
+static int ldb_modules_load_dir(const char *modules_dir, const char *version)
+{
+        DIR *dir;
+        struct dirent *de;
+        const char **modlist = NULL;
+        TALLOC_CTX *tmp_ctx = talloc_new(NULL);
+        unsigned i, num_modules = 0;
+        dir = opendir(modules_dir);
+        if (dir == NULL) {
+                if (errno == ENOENT) {
+                        talloc_free(tmp_ctx);
+                        /* we don't have any modules */
+                        return LDB_SUCCESS;
+                }
+                talloc_free(tmp_ctx);
+                fprintf(stderr, "ldb: unable to open modules directory '%s' - %s\n",
+                        modules_dir, strerror(errno));
+                return LDB_ERR_UNAVAILABLE;
+        }
+        while ((de = readdir(dir))) {
+                if (ISDOT(de->d_name) || ISDOTDOT(de->d_name))
+                        continue;
+                modlist = talloc_realloc(tmp_ctx, modlist, const char *, num_modules+1);
+                if (modlist == NULL) {
+                        talloc_free(tmp_ctx);
+                        closedir(dir);
+                        fprintf(stderr, "ldb: unable to allocate modules list\n");
+                        return LDB_ERR_UNAVAILABLE;
+                }
+                modlist[num_modules] = talloc_asprintf(modlist, "%s/%s", modules_dir, de->d_name);
+                if (modlist[num_modules] == NULL) {
+                        talloc_free(tmp_ctx);
+                        closedir(dir);
+                        fprintf(stderr, "ldb: unable to allocate module list entry\n");
+                        return LDB_ERR_UNAVAILABLE;
+                }
+                num_modules++;
+        }
+        closedir(dir);
+        /* sort the directory, so we get consistent load ordering */
+        TYPESAFE_QSORT(modlist, num_modules, qsort_string);
+        for (i=0; i<num_modules; i++) {
+                int ret = ldb_modules_load_path(modlist[i], version);
+                if (ret != LDB_SUCCESS) {
+                        fprintf(stderr, "ldb: failed to initialise module %s : %s\n",
+                                modlist[i], ldb_strerror(ret));
+                        talloc_free(tmp_ctx);
+                        return ret;
+                }
+        }
+        talloc_free(tmp_ctx);
+        return LDB_SUCCESS;
+}
+/*
+   load any additional modules from the given directory
+*/
+void ldb_set_modules_dir(struct ldb_context *ldb, const char *path)
+{
+        int ret = ldb_modules_load_path(path, LDB_VERSION);
+        if (ret != LDB_SUCCESS) {
+                ldb_asprintf_errstring(ldb, "Failed to load modules from: %s\n", path);
+        }
+}
+/*
+  load all modules static (builtin) modules
+ */
+static int ldb_modules_load_static(const char *version)
+{
+        static bool initialised;
+#define _MODULE_PROTO(init) extern int init(const char *);
+        STATIC_ldb_MODULES_PROTO;
+        const ldb_module_init_fn static_init_functions[] = { STATIC_ldb_MODULES };
+        unsigned i;
+        if (initialised) {
+                return LDB_SUCCESS;
+        }
+        initialised = true;
+        for (i=0; static_init_functions[i]; i++) {
+                int ret = static_init_functions[i](version);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
+        }
+        return LDB_SUCCESS;
+}
+/*
+  load all modules from the given ldb modules path, colon
+  separated.
+  modules are loaded recursively for all subdirectories in the paths
+ */
+int ldb_modules_load(const char *modules_path, const char *version)
+{
+        char *tok, *path, *tok_ptr=NULL;
+        int ret;
+        ret = ldb_modules_load_static(version);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        path = talloc_strdup(NULL, modules_path);
+        if (path == NULL) {
+                fprintf(stderr, "ldb: failed to allocate modules_path\n");
+                return LDB_ERR_UNAVAILABLE;
+        }
+        for (tok=strtok_r(path, ":", &tok_ptr);
+             tok;
+             tok=strtok_r(NULL, ":", &tok_ptr)) {
+                ret = ldb_modules_load_path(tok, version);
+                if (ret != LDB_SUCCESS) {
+                        talloc_free(path);
+                        return ret;
+                }
+        }
+        talloc_free(path);
+        return LDB_SUCCESS;
+}
+/*
+  return a string representation of the calling chain for the given
+  ldb request
+ */
+char *ldb_module_call_chain(struct ldb_request *req, TALLOC_CTX *mem_ctx)
+{
+        char *ret;
+        int i=0;
+        ret = talloc_strdup(mem_ctx, "");
+        if (ret == NULL) {
+                return NULL;
+        }
+        while (req && req->handle) {
+                char *s = talloc_asprintf_append_buffer(ret, "req[%u] %p  : %s\n",
+                                                        i++, req, ldb_req_location(req));
+                if (s == NULL) {
+                        talloc_free(ret);
+                        return NULL;
+                }
+                ret = s;
+                req = req->handle->parent;
+        }
+        return ret;
+}
+/*
+  return the next module in the chain
+ */
+struct ldb_module *ldb_module_next(struct ldb_module *module)
+{
+        return module->next;
+}
+/*
+  set the next module in the module chain
+ */
+void ldb_module_set_next(struct ldb_module *module, struct ldb_module *next)
+{
+        module->next = next;
+}
+/*
+  get the popt_options pointer in the ldb structure. This allows a ldb
+  module to change the command line parsing
+ */
+struct poptOption **ldb_module_popt_options(struct ldb_context *ldb)
+{
+        return &ldb->popt_options;
+}
+/*
+  return the current ldb flags LDB_FLG_*
+ */
+uint32_t ldb_module_flags(struct ldb_context *ldb)
+{
+        return ldb->flags;
+}

trunk/server/source4/lib/ldb/common/ldb_msg.c

-              r414
+              r745
   create a new ldb_message in a given memory context (NULL for top level)
 */
 struct ldb_message *ldb_msg_new(void *mem_ctx)
+struct ldb_message *ldb_msg_new(TALLOC_CTX *mem_ctx)
+{
         return talloc_zero(mem_ctx, struct ldb_message);
 …
+{
         if (v1->length != v2->length) return 0;
+        if (v1->data == v2->data) return 1;
         if (v1->length == 0) return 1;
 …
   duplicate a ldb_val structure
 */
 struct ldb_val ldb_val_dup(void *mem_ctx, const struct ldb_val *v)
+struct ldb_val ldb_val_dup(TALLOC_CTX *mem_ctx, const struct ldb_val *v)
+{
         struct ldb_val v2;
 …
+}
+/*
+  add an empty element to a message
+*/
+int ldb_msg_add_empty(  struct ldb_message *msg,
+                        const char *attr_name,
+                        int flags,
+                        struct ldb_message_element **return_el)
+/**
+ * Adds new empty element to msg->elements
+ */
+static int _ldb_msg_add_el(struct ldb_message *msg,
+                           struct ldb_message_element **return_el)
+{
         struct ldb_message_element *els;
+        els = talloc_realloc(msg, msg->elements,
+                             struct ldb_message_element, msg->num_elements+1);
+        /*
+         * TODO: Find out a way to assert on input parameters.
+         * msg and return_el must be valid
+         */
+        els = talloc_realloc(msg, msg->elements,
+                             struct ldb_message_element, msg->num_elements + 1);
         if (!els) {
                 errno = ENOMEM;
 …
+        }
+        els[msg->num_elements].values = NULL;
+        els[msg->num_elements].num_values = 0;
+        els[msg->num_elements].flags = flags;
+        els[msg->num_elements].name = talloc_strdup(els, attr_name);
+        if (!els[msg->num_elements].name) {
+        ZERO_STRUCT(els[msg->num_elements]);
+        msg->elements = els;
+        msg->num_elements++;
+        *return_el = &els[msg->num_elements-1];
+        return LDB_SUCCESS;
+}
+/**
+ * Add an empty element with a given name to a message
+ */
+int ldb_msg_add_empty(struct ldb_message *msg,
+                      const char *attr_name,
+                      int flags,
+                      struct ldb_message_element **return_el)
+{
+        int ret;
+        struct ldb_message_element *el;
+        ret = _ldb_msg_add_el(msg, &el);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        /* initialize newly added element */
+        el->flags = flags;
+        el->name = talloc_strdup(msg->elements, attr_name);
+        if (!el->name) {
                 errno = ENOMEM;
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
-        msg->elements = els;
-        msg->num_elements++;
         if (return_el) {
                 *return_el = &els[msg->num_elements-1];
+                *return_el = el;
+        }
 …
+}
+/*
+  add an empty element to a message
+*/
+/**
+ * Adds an element to a message.
+ *
+ * NOTE: Ownership of ldb_message_element fields
+ *       is NOT transferred. Thus, if *el pointer
+ *       is invalidated for some reason, this will
+ *       corrupt *msg contents also
+ */
 int ldb_msg_add(struct ldb_message *msg,
                 const struct ldb_message_element *el,
                 int flags)
+{
+        int ret;
+        struct ldb_message_element *el_new;
         /* We have to copy this, just in case *el is a pointer into
          * what ldb_msg_add_empty() is about to realloc() */
         struct ldb_message_element el_copy = *el;
+        if (ldb_msg_add_empty(msg, el->name, flags, NULL) != 0) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        msg->elements[msg->num_elements-1] = el_copy;
+        msg->elements[msg->num_elements-1].flags = flags;
+        ret = _ldb_msg_add_el(msg, &el_new);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        el_new->flags      = flags;
+        el_new->name       = el_copy.name;
+        el_new->num_values = el_copy.num_values;
+        el_new->values     = el_copy.values;
         return LDB_SUCCESS;
 …
+        }
+        vals = talloc_realloc(msg, el->values, struct ldb_val, el->num_values+1);
+        vals = talloc_realloc(msg->elements, el->values, struct ldb_val,
+                              el->num_values+1);
         if (!vals) {
                 errno = ENOMEM;
 …
         if (val.length == 0) {
                 /* allow empty strings as non-existant attributes */
+                /* allow empty strings as non-existent attributes */
                 return LDB_SUCCESS;
+        }
 …
         val.length = strlen(str);
+        if (val.length == 0) {
+                /* allow empty strings as non-existent attributes */
+                return LDB_SUCCESS;
+        }
         return ldb_msg_add_steal_value(msg, attr_name, &val);
+}
+/*
+  add a DN element to a message
+  WARNING: this uses the linearized string from the dn, and does not
+  copy the string.
+*/
+int ldb_msg_add_linearized_dn(struct ldb_message *msg, const char *attr_name,
+                              struct ldb_dn *dn)
+{
+        char *str = ldb_dn_alloc_linearized(msg, dn);
+        if (str == NULL) {
+                /* we don't want to have unknown DNs added */
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        return ldb_msg_add_steal_string(msg, attr_name, str);
+}
 …
 /*
   compare two ldb_message_element structures
   assumes case senistive comparison
+  assumes case sensitive comparison
 */
 int ldb_msg_element_compare(struct ldb_message_element *el1,
 …
                                        unsigned int default_value)
+{
+        unsigned int ret;
         const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
         if (!v || !v->data) {
                 return default_value;
+        }
+        /* in LDAP there're only int32_t values */
+        errno = 0;
+        ret = strtol((const char *)v->data, NULL, 0);
+        if (errno == 0) {
+                return ret;
+        }
         return strtoul((const char *)v->data, NULL, 0);
+}
 …
                                      uint64_t default_value)
+{
+        uint64_t ret;
         const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
         if (!v || !v->data) {
                 return default_value;
+        }
+        /* in LDAP there're only int64_t values */
+        errno = 0;
+        ret = strtoll((const char *)v->data, NULL, 0);
+        if (errno == 0) {
+                return ret;
+        }
         return strtoull((const char *)v->data, NULL, 0);
+}
 …
 struct ldb_dn *ldb_msg_find_attr_as_dn(struct ldb_context *ldb,
                                        void *mem_ctx,
+                                       TALLOC_CTX *mem_ctx,
                                        const struct ldb_message *msg,
                                        const char *attr_name)
 …
 void ldb_msg_sort_elements(struct ldb_message *msg)
+{
         qsort(msg->elements, msg->num_elements, sizeof(struct ldb_message_element),
               (comparison_fn_t)ldb_msg_element_compare_name);
+        TYPESAFE_QSORT(msg->elements, msg->num_elements,
+                       ldb_msg_element_compare_name);
+}
 …
+{
         struct ldb_message *msg2;
         int i;
+        unsigned int i;
         msg2 = talloc(mem_ctx, struct ldb_message);
 …
+{
         struct ldb_message *msg2;
         int i, j;
+        unsigned int i, j;
         msg2 = ldb_msg_copy_shallow(mem_ctx, msg);
 …
 /*
   canonicalise a message, merging elements of the same name
 */
+/**
+ * Canonicalize a message, merging elements of the same name
+ */
 struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
                                          const struct ldb_message *msg)
+{
         int i;
+        int ret;
         struct ldb_message *msg2;
+        msg2 = ldb_msg_copy(ldb, msg);
+        if (msg2 == NULL) return NULL;
+        /*
+         * Preserve previous behavior and allocate
+         * *msg2 into *ldb context
+         */
+        ret = ldb_msg_normalize(ldb, ldb, msg, &msg2);
+        if (ret != LDB_SUCCESS) {
+                return NULL;
+        }
+        return msg2;
+}
+/**
+ * Canonicalize a message, merging elements of the same name
+ */
+int ldb_msg_normalize(struct ldb_context *ldb,
+                      TALLOC_CTX *mem_ctx,
+                      const struct ldb_message *msg,
+                      struct ldb_message **_msg_out)
+{
+        unsigned int i;
+        struct ldb_message *msg2;
+        msg2 = ldb_msg_copy(mem_ctx, msg);
+        if (msg2 == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         ldb_msg_sort_elements(msg2);
         for (i=1;i<msg2->num_elements;i++) {
+        for (i=1; i < msg2->num_elements; i++) {
                 struct ldb_message_element *el1 = &msg2->elements[i-1];
                 struct ldb_message_element *el2 = &msg2->elements[i];
                 if (ldb_msg_element_compare_name(el1, el2) == 0) {
+                        el1->values = talloc_realloc(msg2->elements, el1->values, struct ldb_val,
+                                                       el1->num_values + el2->num_values);
+                        if (el1->values == NULL) {
+                                return NULL;
+                        el1->values = talloc_realloc(msg2->elements,
+                                                     el1->values, struct ldb_val,
+                                                     el1->num_values + el2->num_values);
+                        if (el1->num_values + el2->num_values > 0 && el1->values == NULL) {
+                                talloc_free(msg2);
+                                return LDB_ERR_OPERATIONS_ERROR;
+                        }
                         memcpy(el1->values + el1->num_values,
 …
                         el1->num_values += el2->num_values;
                         talloc_free(discard_const_p(char, el2->name));
                         if (i+1<msg2->num_elements) {
                                 memmove(el2, el2+1, sizeof(struct ldb_message_element) *
+                        if ((i+1) < msg2->num_elements) {
+                                memmove(el2, el2+1, sizeof(struct ldb_message_element) *
                                         (msg2->num_elements - (i+1)));
+                        }
 …
+        }
+        return msg2;
+}
+/*
+  return a ldb_message representing the differences between msg1 and msg2. If you
+  then use this in a ldb_modify() call it can be used to save edits to a message
+*/
+        *_msg_out = msg2;
+        return LDB_SUCCESS;
+}
+/**
+ * return a ldb_message representing the differences between msg1 and msg2.
+ * If you then use this in a ldb_modify() call,
+ * it can be used to save edits to a message
+ */
 struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
                                  struct ldb_message *msg1,
                                  struct ldb_message *msg2)
+{
+        int ldb_ret;
+        struct ldb_message *mod;
+        ldb_ret = ldb_msg_difference(ldb, ldb, msg1, msg2, &mod);
+        if (ldb_ret != LDB_SUCCESS) {
+                return NULL;
+        }
+        return mod;
+}
+/**
+ * return a ldb_message representing the differences between msg1 and msg2.
+ * If you then use this in a ldb_modify() call it can be used to save edits to a message
+ *
+ * Result message is constructed as follows:
+ * - LDB_FLAG_MOD_ADD     - elements found only in msg2
+ * - LDB_FLAG_MOD_REPLACE - elements in msg2 that have different value in msg1
+ *                          Value for msg2 element is used
+ * - LDB_FLAG_MOD_DELETE  - elements found only in msg2
+ *
+ * @return LDB_SUCCESS or LDB_ERR_OPERATIONS_ERROR
+ */
+int ldb_msg_difference(struct ldb_context *ldb,
+                       TALLOC_CTX *mem_ctx,
+                       struct ldb_message *msg1,
+                       struct ldb_message *msg2,
+                       struct ldb_message **_msg_out)
+{
+        int ldb_res;
+        unsigned int i;
         struct ldb_message *mod;
         struct ldb_message_element *el;
+        unsigned int i;
+        mod = ldb_msg_new(ldb);
+        TALLOC_CTX *temp_ctx;
+        temp_ctx = talloc_new(mem_ctx);
+        if (!temp_ctx) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        mod = ldb_msg_new(temp_ctx);
+        if (mod == NULL) {
+                goto failed;
+        }
         mod->dn = msg1->dn;
 …
         mod->elements = NULL;
+        msg2 = ldb_msg_canonicalize(ldb, msg2);
+        if (msg2 == NULL) {
+                return NULL;
+        }
+        /* look in msg2 to find elements that need to be added
+           or modified */
+        /*
+         * Canonicalize *msg2 so we have no repeated elements
+         * Resulting message is allocated in *mod's mem context,
+         * as we are going to move some elements from *msg2 to
+         * *mod object later
+         */
+        ldb_res = ldb_msg_normalize(ldb, mod, msg2, &msg2);
+        if (ldb_res != LDB_SUCCESS) {
+                goto failed;
+        }
+        /* look in msg2 to find elements that need to be added or modified */
         for (i=0;i<msg2->num_elements;i++) {
                 el = ldb_msg_find_element(msg1, msg2->elements[i].name);
 …
+                }
+                if (ldb_msg_add(mod,
+                                &msg2->elements[i],
+                                el?LDB_FLAG_MOD_REPLACE:LDB_FLAG_MOD_ADD) != 0) {
+                        return NULL;
+                ldb_res = ldb_msg_add(mod,
+                                      &msg2->elements[i],
+                                      el ? LDB_FLAG_MOD_REPLACE : LDB_FLAG_MOD_ADD);
+                if (ldb_res != LDB_SUCCESS) {
+                        goto failed;
+                }
+        }
 …
         for (i=0;i<msg1->num_elements;i++) {
                 el = ldb_msg_find_element(msg2, msg1->elements[i].name);
+                if (!el) {
+                        if (ldb_msg_add_empty(mod,
+                                              msg1->elements[i].name,
+                                              LDB_FLAG_MOD_DELETE, NULL) != 0) {
+                                return NULL;
+                if (el == NULL) {
+                        ldb_res = ldb_msg_add_empty(mod,
+                                                    msg1->elements[i].name,
+                                                    LDB_FLAG_MOD_DELETE, NULL);
+                        if (ldb_res != LDB_SUCCESS) {
+                                goto failed;
+                        }
+                }
+        }
+        return mod;
+}
+        /* steal resulting message into supplied context */
+        talloc_steal(mem_ctx, mod);
+        *_msg_out = mod;
+        talloc_free(temp_ctx);
+        return LDB_SUCCESS;
+failed:
+        talloc_free(temp_ctx);
+        return LDB_ERR_OPERATIONS_ERROR;
+}
 int ldb_msg_sanity_check(struct ldb_context *ldb,
                          const struct ldb_message *msg)
+{
         int i, j;
+        unsigned int i, j;
         /* basic check on DN */
 …
+{
         const char **ret;
+        int i;
+        unsigned int i;
         for (i=0;attrs && attrs[i];i++) /* noop */ ;
         ret = talloc_array(mem_ctx, const char *, i+1);
 …
+{
         const char **ret;
         int i;
+        unsigned int i;
         bool found = false;
         for (i=0;attrs && attrs[i];i++) {
                 if (ldb_attr_cmp(attrs[i], new_attr) == 0) {
 …
 int ldb_attr_in_list(const char * const *attrs, const char *attr)
+{
         int i;
+        unsigned int i;
         for (i=0;attrs && attrs[i];i++) {
                 if (ldb_attr_cmp(attrs[i], attr) == 0) {
 …
+{
         struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
+        int ret;
         if (el == NULL) {
                 return LDB_SUCCESS;
+        }
+        if (ldb_msg_add(msg, el, 0) != 0) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        ret = ldb_msg_add(msg, el, 0);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
         return ldb_msg_rename_attr(msg, attr, replace);
 …
 void ldb_msg_remove_element(struct ldb_message *msg, struct ldb_message_element *el)
+{
         int n = (el - msg->elements);
+        ptrdiff_t n = (el - msg->elements);
         if (n >= msg->num_elements) {
                 /* should we abort() here? */
 …
 void ldb_msg_remove_attr(struct ldb_message *msg, const char *attr)
+{
+        struct ldb_message_element *el = ldb_msg_find_element(msg, attr);
+        if (el) {
+        struct ldb_message_element *el;
+        while ((el = ldb_msg_find_element(msg, attr)) != NULL) {
                 ldb_msg_remove_element(msg, el);
+        }
 …
         memset(&tm, 0, sizeof(tm));
         if (sscanf(s, "%04u%02u%02u%02u%02u%02u",
+        if (sscanf(s, "%04u%02u%02u%02u%02u%02u.0Z",
                    &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
                    &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
 …
         return timegm(&tm);
+}
+/*
+  convert a LDAP GeneralizedTime string in ldb_val format to a
+  time_t.
+*/
+int ldb_val_to_time(const struct ldb_val *v, time_t *t)
+{
+        struct tm tm;
+        if (v == NULL || !v->data || v->length < 17) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        memset(&tm, 0, sizeof(tm));
+        if (sscanf((char *)v->data, "%04u%02u%02u%02u%02u%02u.0Z",
+                   &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
+                   &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
+                return LDB_ERR_INVALID_ATTRIBUTE_SYNTAX;
+        }
+        tm.tm_year -= 1900;
+        tm.tm_mon -= 1;
+        *t = timegm(&tm);
+        return LDB_SUCCESS;
+}
 …
         memset(&tm, 0, sizeof(tm));
         if (sscanf(s, "%02u%02u%02u%02u%02u%02u",
+        if (sscanf(s, "%02u%02u%02u%02u%02u%02uZ",
                    &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
                    &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
 …
 void ldb_dump_results(struct ldb_context *ldb, struct ldb_result *result, FILE *f)
+{
         int i;
+        unsigned int i;
         for (i = 0; i < result->count; i++) {
 …
+}
+int ldb_msg_check_string_attribute(const struct ldb_message *msg, const char *name, const char *value)
+/*
+  checks for a string attribute. Returns "1" on match and otherwise "0".
+*/
+int ldb_msg_check_string_attribute(const struct ldb_message *msg,
+                                   const char *name, const char *value)
+{
         struct ldb_message_element *el;
 …
         el = ldb_msg_find_element(msg, name);
         if (el == NULL)
+        if (el == NULL) {
                 return 0;
+        }
         val.data = discard_const_p(uint8_t, value);
         val.length = strlen(value);
         if (ldb_msg_find_val(el, &val))
+        if (ldb_msg_find_val(el, &val)) {
                 return 1;
+        }
         return 0;
+}

trunk/server/source4/lib/ldb/common/ldb_parse.c

-              r414
+              r745
 #include "ldb_private.h"
 #include "system/locale.h"
+static int ldb_parse_hex2char(const char *x)
+{
+        if (isxdigit(x[0]) && isxdigit(x[1])) {
+                const char h1 = x[0], h2 = x[1];
+                int c = 0;
+                if (h1 >= 'a') c = h1 - (int)'a' + 10;
+                else if (h1 >= 'A') c = h1 - (int)'A' + 10;
+                else if (h1 >= '0') c = h1 - (int)'0';
+                c = c << 4;
+                if (h2 >= 'a') c += h2 - (int)'a' + 10;
+                else if (h2 >= 'A') c += h2 - (int)'A' + 10;
+                else if (h2 >= '0') c += h2 - (int)'0';
+                return c;
+        }
+        return -1;
+}
 /*
 …
    Used in LDAP filters.
 */
 struct ldb_val ldb_binary_decode(void *mem_ctx, const char *str)
+{
         int i, j;
+struct ldb_val ldb_binary_decode(TALLOC_CTX *mem_ctx, const char *str)
+{
+        size_t i, j;
         struct ldb_val ret;
         int slen = str?strlen(str):0;
+        size_t slen = str?strlen(str):0;
         ret.data = (uint8_t *)talloc_size(mem_ctx, slen+1);
 …
         for (i=j=0;i<slen;i++) {
                 if (str[i] == '\\') {
+                        unsigned c;
+                        if (sscanf(&str[i+1], "%02X", &c) != 1) {
+                        int c;
+                        c = ldb_parse_hex2char(&str[i+1]);
+                        if (c == -1) {
                                 talloc_free(ret.data);
                                 memset(&ret, 0, sizeof(ret));
 …
    non-printable or '\' characters
 */
 char *ldb_binary_encode(void *mem_ctx, struct ldb_val val)
+{
         int i;
+char *ldb_binary_encode(TALLOC_CTX *mem_ctx, struct ldb_val val)
+{
+        size_t i;
         char *ret;
         int len = val.length;
+        size_t len = val.length;
         unsigned char *buf = val.data;
 …
    in escaping user data in ldap filters.
 */
 char *ldb_binary_encode_string(void *mem_ctx, const char *string)
+char *ldb_binary_encode_string(TALLOC_CTX *mem_ctx, const char *string)
+{
         struct ldb_val val;
+        if (string == NULL) {
+                return NULL;
+        }
         val.data = discard_const_p(uint8_t, string);
         val.length = strlen(string);
 …
    chunks separated by wildcards that makes the value portion of the filter
 */
 static struct ldb_val **ldb_wildcard_decode(void *mem_ctx, const char *string)
+static struct ldb_val **ldb_wildcard_decode(TALLOC_CTX *mem_ctx, const char *string)
+{
         struct ldb_val **ret = NULL;
         int val = 0;
+        unsigned int val = 0;
         char *wc, *str;
 …
+}
 static struct ldb_parse_tree *ldb_parse_filter(void *mem_ctx, const char **s);
+static struct ldb_parse_tree *ldb_parse_filter(TALLOC_CTX *mem_ctx, const char **s);
 …
+}
 static enum ldb_parse_op ldb_parse_filtertype(void *mem_ctx, char **type, char **value, const char **s)
+static enum ldb_parse_op ldb_parse_filtertype(TALLOC_CTX *mem_ctx, char **type, char **value, const char **s)
+{
         enum ldb_parse_op filter = 0;
 …
   <simple> ::= <attributetype> <filtertype> <attributevalue>
 */
 static struct ldb_parse_tree *ldb_parse_simple(void *mem_ctx, const char **s)
+static struct ldb_parse_tree *ldb_parse_simple(TALLOC_CTX *mem_ctx, const char **s)
+{
         char *attr, *value;
 …
   <filterlist> ::= <filter> | <filter> <filterlist>
 */
 static struct ldb_parse_tree *ldb_parse_filterlist(void *mem_ctx, const char **s)
+static struct ldb_parse_tree *ldb_parse_filterlist(TALLOC_CTX *mem_ctx, const char **s)
+{
         struct ldb_parse_tree *ret, *next;
 …
   <not> ::= '!' <filter>
 */
 static struct ldb_parse_tree *ldb_parse_not(void *mem_ctx, const char **s)
+static struct ldb_parse_tree *ldb_parse_not(TALLOC_CTX *mem_ctx, const char **s)
+{
         struct ldb_parse_tree *ret;
 …
   <filtercomp> ::= <and> | <or> | <not> | <simple>
 */
 static struct ldb_parse_tree *ldb_parse_filtercomp(void *mem_ctx, const char **s)
+static struct ldb_parse_tree *ldb_parse_filtercomp(TALLOC_CTX *mem_ctx, const char **s)
+{
         struct ldb_parse_tree *ret;
 …
   <filter> ::= '(' <filtercomp> ')'
 */
 static struct ldb_parse_tree *ldb_parse_filter(void *mem_ctx, const char **s)
+static struct ldb_parse_tree *ldb_parse_filter(TALLOC_CTX *mem_ctx, const char **s)
+{
         struct ldb_parse_tree *ret;
 …
   expression ::= <simple> | <filter>
 */
 struct ldb_parse_tree *ldb_parse_tree(void *mem_ctx, const char *s)
+struct ldb_parse_tree *ldb_parse_tree(TALLOC_CTX *mem_ctx, const char *s)
+{
         if (s == NULL || *s == 0) {
 …
   construct a ldap parse filter given a parse tree
 */
 char *ldb_filter_from_tree(void *mem_ctx, struct ldb_parse_tree *tree)
+char *ldb_filter_from_tree(TALLOC_CTX *mem_ctx, const struct ldb_parse_tree *tree)
+{
         char *s, *s2, *ret;
         int i;
+        unsigned int i;
         if (tree == NULL) {
 …
 /*
   replace any occurances of an attribute name in the parse tree with a
+  replace any occurrences of an attribute name in the parse tree with a
   new name
 */
 …
                                  const char *replace)
+{
         int i;
+        unsigned int i;
         switch (tree->operation) {
         case LDB_OP_AND:
 …
                                                    const struct ldb_parse_tree *ot)
+{
         int i;
+        unsigned int i;
         struct ldb_parse_tree *nt;

trunk/server/source4/lib/ldb/common/ldb_utf8.c

-              r414
+              r745
   NOTE: does not handle UTF8
 */
 char *ldb_casefold_default(void *context, void *mem_ctx, const char *s, size_t n)
+char *ldb_casefold_default(void *context, TALLOC_CTX *mem_ctx, const char *s, size_t n)
+{
         int i;
+        size_t i;
         char *ret = talloc_strndup(mem_ctx, s, n);
         if (!s) {
 …
+}
 char *ldb_casefold(struct ldb_context *ldb, void *mem_ctx, const char *s, size_t n)
+char *ldb_casefold(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *s, size_t n)
+{
         return ldb->utf8_fns.casefold(ldb->utf8_fns.context, mem_ctx, s, n);
 …
 int ldb_valid_attr_name(const char *s)
+{
         int i;
+        size_t i;
         if (!s || !s[0])
 …
+}
 char *ldb_attr_casefold(void *mem_ctx, const char *s)
+char *ldb_attr_casefold(TALLOC_CTX *mem_ctx, const char *s)
+{
         int i;
+        size_t i;
         char *ret = talloc_strdup(mem_ctx, s);
         if (!ret) {

trunk/server/source4/lib/ldb/include/dlinklist.h

-              r414
+              r745
    Unix SMB/CIFS implementation.
    some simple double linked list macros
+   Copyright (C) Andrew Tridgell 1998
+   Copyright (C) Andrew Tridgell 1998-2010
+     ** NOTE! The following LGPL license applies to the ldb
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+   This library 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/>.
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 …
 #define _DLINKLIST_H
+/*
+  February 2010 - changed list format to have a prev pointer from the
+  list head. This makes DLIST_ADD_END() O(1) even though we only have
+  one list pointer.
+/* hook into the front of the list */
+  The scheme is as follows:
+) with no entries in the list:
+          list_head == NULL
+) with 1 entry in the list:
+          list_head->next == NULL
+          list_head->prev == list_head
+) with 2 entries in the list:
+          list_head->next == element2
+          list_head->prev == element2
+          element2->prev == list_head
+          element2->next == NULL
+) with N entries in the list:
+          list_head->next == element2
+          list_head->prev == elementN
+          elementN->prev == element{N-1}
+          elementN->next == NULL
+  This allows us to find the tail of the list by using
+  list_head->prev, which means we can add to the end of the list in
+  O(1) time
+  Note that the 'type' arguments below are no longer needed, but
+  are kept for now to prevent an incompatible argument change
+ */
+/*
+   add an element at the front of a list
+*/
 #define DLIST_ADD(list, p) \
 do { \
         if (!(list)) { \
                 (list) = (p); \
                 (p)->next = (p)->prev = NULL; \
+                (p)->prev = (list) = (p);  \
+                (p)->next = NULL; \
         } else { \
+                (p)->prev = (list)->prev; \
                 (list)->prev = (p); \
                 (p)->next = (list); \
-                (p)->prev = NULL; \
                 (list) = (p); \
         }\
+        } \
 } while (0)
+/* remove an element from a list - element doesn't have to be in list. */
+/*
+   remove an element from a list
+   Note that the element doesn't have to be in the list. If it
+   isn't then this is a no-op
+*/
 #define DLIST_REMOVE(list, p) \
 do { \
         if ((p) == (list)) { \
+                if ((p)->next) (p)->next->prev = (p)->prev; \
                 (list) = (p)->next; \
+                if (list) (list)->prev = NULL; \
+        } else if ((list) && (p) == (list)->prev) {     \
+                (p)->prev->next = NULL; \
+                (list)->prev = (p)->prev; \
         } else { \
                 if ((p)->prev) (p)->prev->next = (p)->next; \
                 if ((p)->next) (p)->next->prev = (p)->prev; \
         } \
         if ((p) && ((p) != (list))) (p)->next = (p)->prev = NULL; \
+        if ((p) != (list)) (p)->next = (p)->prev = NULL;        \
 } while (0)
+/* promote an element to the top of the list */
+#define DLIST_PROMOTE(list, p) \
+/*
+   find the head of the list given any element in it.
+   Note that this costs O(N), so you should avoid this macro
+   if at all possible!
+*/
+#define DLIST_HEAD(p, result_head) \
 do { \
           DLIST_REMOVE(list, p); \
           DLIST_ADD(list, p); \
 } while (0)
+       (result_head) = (p); \
+       while (DLIST_PREV(result_head)) (result_head) = (result_head)->prev; \
+} while(0)
+/* hook into the end of the list - needs the entry type */
+#define DLIST_ADD_END(list, p, type) \
+do { \
+                if (!(list)) { \
+                        (list) = (p); \
+                        (p)->next = (p)->prev = NULL; \
+                } else { \
+                        type tmp; \
+                        for (tmp = (list); tmp->next; tmp = tmp->next) ; \
+                        tmp->next = (p); \
+                        (p)->next = NULL; \
+                        (p)->prev = tmp; \
+                } \
+} while (0)
+/* return the last element in the list */
+#define DLIST_TAIL(list) ((list)?(list)->prev:NULL)
+/* return the previous element in the list. */
+#define DLIST_PREV(p) (((p)->prev && (p)->prev->next != NULL)?(p)->prev:NULL)
 /* insert 'p' after the given element 'el' in a list. If el is NULL then
 …
                 DLIST_ADD(list, p); \
         } else { \
+                p->prev = el; \
+                p->next = el->next; \
+                el->next = p; \
+                if (p->next) p->next->prev = p; \
+                (p)->prev = (el);   \
+                (p)->next = (el)->next;         \
+                (el)->next = (p);               \
+                if ((p)->next) (p)->next->prev = (p);   \
+                if ((list)->prev == (el)) (list)->prev = (p); \
         }\
 } while (0)
+/* demote an element to the end of the list, needs the entry type */
+#define DLIST_DEMOTE(list, p, type) \
+/*
+   add to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_ADD_END(list, p, type)                    \
 do { \
+                DLIST_REMOVE(list, p); \
+                DLIST_ADD_END(list, p, type); \
+        if (!(list)) { \
+                DLIST_ADD(list, p); \
+        } else { \
+                DLIST_ADD_AFTER(list, p, (list)->prev); \
+        } \
 } while (0)
+/* concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list */
+#define DLIST_CONCATENATE(list1, list2, type) \
+/* promote an element to the from of a list */
+#define DLIST_PROMOTE(list, p) \
 do { \
+                if (!(list1)) { \
+                        (list1) = (list2); \
+                } else { \
+                        type tmp; \
+                        for (tmp = (list1); tmp->next; tmp = tmp->next) ; \
+                        tmp->next = (list2); \
+                        if (list2) { \
+                                (list2)->prev = tmp;    \
+                        } \
+          DLIST_REMOVE(list, p); \
+          DLIST_ADD(list, p); \
+} while (0)
+/*
+   demote an element to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_DEMOTE(list, p, type)                     \
+do { \
+        DLIST_REMOVE(list, p); \
+        DLIST_ADD_END(list, p, NULL);           \
+} while (0)
+/*
+   concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list.
+   Note that 'type' is ignored
+*/
+#define DLIST_CONCATENATE(list1, list2, type)   \
+do { \
+        if (!(list1)) { \
+                (list1) = (list2); \
+        } else { \
+                (list1)->prev->next = (list2); \
+                if (list2) { \
+                        void *_tmplist = (void *)(list1)->prev; \
+                        (list1)->prev = (list2)->prev; \
+                        (list2)->prev = _tmplist; \
                 } \
+        } \
 } while (0)

trunk/server/source4/lib/ldb/include/ldb.h

-              r414
+              r745
 #include <stdbool.h>
+#include "talloc.h"
+#include "tevent.h"
+#include "ldb_errors.h"
+#include <talloc.h>
+#include <tevent.h>
+#include <ldb_version.h>
+#include <ldb_errors.h>
 /*
 …
 #ifndef PRINTF_ATTRIBUTE
 #define PRINTF_ATTRIBUTE(a,b)
+#endif
+#ifndef _DEPRECATED_
+#if (__GNUC__ >= 3) && (__GNUC_MINOR__ >= 1 )
+#define _DEPRECATED_ __attribute__ ((deprecated))
+#else
+#define _DEPRECATED_
+#endif
 #endif
 /*! \endcond */
 …
 /**
+  use this to extract the mod type from the operation
+ */
+#define LDB_FLAG_MOD_TYPE(flags) ((flags) & LDB_FLAG_MOD_MASK)
+/**
    Flag value used in ldap_modify() to indicate that attributes are
    being added.
 …
 */
 #define LDB_FLAG_MOD_DELETE  3
+/**
+    flag bits on an element usable only by the internal implementation
+*/
+#define LDB_FLAG_INTERNAL_MASK 0xFFFFFFF0
 /**
 …
 struct ldb_parse_tree *ldb_parse_tree(TALLOC_CTX *mem_ctx, const char *s);
 char *ldb_filter_from_tree(TALLOC_CTX *mem_ctx, struct ldb_parse_tree *tree);
+char *ldb_filter_from_tree(TALLOC_CTX *mem_ctx, const struct ldb_parse_tree *tree);
 /**
 …
 typedef int (*ldb_attr_handler_t)(struct ldb_context *, TALLOC_CTX *mem_ctx, const struct ldb_val *, struct ldb_val *);
 typedef int (*ldb_attr_comparison_t)(struct ldb_context *, TALLOC_CTX *mem_ctx, const struct ldb_val *, const struct ldb_val *);
+struct ldb_schema_attribute;
+typedef int (*ldb_attr_operator_t)(struct ldb_context *, enum ldb_parse_op operation,
+                                   const struct ldb_schema_attribute *a,
+                                   const struct ldb_val *, const struct ldb_val *, bool *matched);
 /*
 …
         ldb_attr_handler_t canonicalise_fn;
         ldb_attr_comparison_t comparison_fn;
+        ldb_attr_operator_t operator_fn;
 };
 …
 typedef int (*ldb_qsort_cmp_fn_t) (void *v1, void *v2, void *opaque);
+/* Individual controls */
+/**
+  OID for getting and manipulating attributes from the ldb
+  without interception in the operational module.
+  It can be used to access attribute that used to be stored in the sam
+  and that are now calculated.
+*/
+#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 SD control. This control force the
+  dsdb code to recalculate the SD of the object as if the
+  object was just created.
+*/
+#define LDB_CONTROL_RECALCULATE_SD_OID "1.3.6.1.4.1.7165.4.3.5"
+#define LDB_CONTROL_RECALCULATE_SD_NAME "recalculate_sd"
+/**
+   REVEAL_INTERNALS is used to reveal internal attributes and DN
+   components which are not normally shown to the user
+*/
+#define LDB_CONTROL_REVEAL_INTERNALS "1.3.6.1.4.1.7165.4.3.6"
+#define LDB_CONTROL_REVEAL_INTERNALS_NAME       "reveal_internals"
+/**
+   LDB_CONTROL_AS_SYSTEM is used to skip access checks on operations
+   that are performed by the system, but with a user's credentials, e.g.
+   updating prefix map
+*/
+#define LDB_CONTROL_AS_SYSTEM_OID "1.3.6.1.4.1.7165.4.3.7"
+/**
+   LDB_CONTROL_PROVISION_OID is used to skip some constraint checks. It's is
+   mainly thought to be used for the provisioning.
+*/
+#define LDB_CONTROL_PROVISION_OID "1.3.6.1.4.1.7165.4.3.16"
+#define LDB_CONTROL_PROVISION_NAME      "provision"
+/* AD controls */
 /**
    OID for the paged results control. This control is included in the
 …
 */
 #define LDB_CONTROL_PAGED_RESULTS_OID   "1.2.840.113556.1.4.319"
+#define LDB_CONTROL_PAGED_RESULTS_NAME  "paged_result"
 /**
 …
 */
 #define LDB_CONTROL_SD_FLAGS_OID        "1.2.840.113556.1.4.801"
+#define LDB_CONTROL_SD_FLAGS_NAME       "sd_flags"
 /**
 …
 */
 #define LDB_CONTROL_DOMAIN_SCOPE_OID    "1.2.840.113556.1.4.1339"
+#define LDB_CONTROL_DOMAIN_SCOPE_NAME   "domain_scope"
 /**
 …
 */
 #define LDB_CONTROL_SEARCH_OPTIONS_OID  "1.2.840.113556.1.4.1340"
+#define LDB_CONTROL_SEARCH_OPTIONS_NAME "search_options"
 /**
 …
 */
 #define LDB_CONTROL_NOTIFICATION_OID    "1.2.840.113556.1.4.528"
+#define LDB_CONTROL_NOTIFICATION_NAME   "notification"
+/**
+   OID for performing subtree deletes
+   \sa <a href="http://msdn.microsoft.com/en-us/library/aa366991(v=VS.85).aspx">Microsoft documentation of this OID</a>
+*/
+#define LDB_CONTROL_TREE_DELETE_OID     "1.2.840.113556.1.4.805"
+#define LDB_CONTROL_TREE_DELETE_NAME    "tree_delete"
 /**
 …
 */
 #define LDB_CONTROL_SHOW_DELETED_OID    "1.2.840.113556.1.4.417"
+#define LDB_CONTROL_SHOW_DELETED_NAME   "show_deleted"
 /**
 …
 */
 #define LDB_CONTROL_SHOW_RECYCLED_OID         "1.2.840.113556.1.4.2064"
+#define LDB_CONTROL_SHOW_RECYCLED_NAME  "show_recycled"
 /**
 …
 */
 #define LDB_CONTROL_SHOW_DEACTIVATED_LINK_OID "1.2.840.113556.1.4.2065"
+#define LDB_CONTROL_SHOW_DEACTIVATED_LINK_NAME  "show_deactivated_link"
 /**
 …
 */
 #define LDB_CONTROL_EXTENDED_DN_OID     "1.2.840.113556.1.4.529"
+#define LDB_CONTROL_EXTENDED_DN_NAME    "extended_dn"
 /**
 …
 */
 #define LDB_CONTROL_SERVER_SORT_OID     "1.2.840.113556.1.4.473"
+#define LDB_CONTROL_SERVER_SORT_NAME    "server_sort"
 /**
 …
 */
 #define LDB_CONTROL_SORT_RESP_OID       "1.2.840.113556.1.4.474"
+#define LDB_CONTROL_SORT_RESP_NAME      "server_sort_resp"
 /**
 …
 */
 #define LDB_CONTROL_ASQ_OID             "1.2.840.113556.1.4.1504"
+#define LDB_CONTROL_ASQ_NAME    "asq"
 /**
 …
 */
 #define LDB_CONTROL_DIRSYNC_OID         "1.2.840.113556.1.4.841"
+#define LDB_CONTROL_DIRSYNC_NAME        "dirsync"
 …
 */
 #define LDB_CONTROL_VLV_REQ_OID         "2.16.840.1.113730.3.4.9"
+#define LDB_CONTROL_VLV_REQ_NAME        "vlv"
 /**
 …
 */
 #define LDB_CONTROL_VLV_RESP_OID        "2.16.840.1.113730.3.4.10"
+#define LDB_CONTROL_VLV_RESP_NAME       "vlv_resp"
 /**
 …
 */
 #define LDB_CONTROL_PERMISSIVE_MODIFY_OID       "1.2.840.113556.1.4.1413"
+#define LDB_CONTROL_PERMISSIVE_MODIFY_NAME      "permissive_modify"
+/**
+    OID to allow the server to be more 'fast and loose' with the data being added.
+    \sa <a href="http://msdn.microsoft.com/en-us/library/aa366982(v=VS.85).aspx">Microsoft documentation of this OID</a>
+*/
+#define LDB_CONTROL_SERVER_LAZY_COMMIT   "1.2.840.113556.1.4.619"
+/**
+   Control for RODC join -see [MS-ADTS] section 3.1.1.3.4.1.23
+   \sa <a href="">Microsoft documentation of this OID</a>
+*/
+#define LDB_CONTROL_RODC_DCPROMO_OID "1.2.840.113556.1.4.1341"
+#define LDB_CONTROL_RODC_DCPROMO_NAME   "rodc_join"
+/* Other standardised controls */
+/**
+   OID for the allowing client to request temporary relaxed
+   enforcement of constraints of the x.500 model.
+   Mainly used for the OpenLDAP backend.
+   \sa <a href="http://opends.dev.java.net/public/standards/draft-zeilenga-ldap-managedit.txt">draft managedit</a>.
+*/
+#define LDB_CONTROL_RELAX_OID "1.3.6.1.4.1.4203.666.5.12"
+#define LDB_CONTROL_RELAX_NAME  "relax"
+/* Extended operations */
+/**
+   OID for LDAP Extended Operation SEQUENCE_NUMBER
+   This extended operation is used to retrieve the extended sequence number.
+*/
+#define LDB_EXTENDED_SEQUENCE_NUMBER    "1.3.6.1.4.1.7165.4.4.3"
+/**
+   OID for LDAP Extended Operation PASSWORD_CHANGE.
+   This Extended operation is used to allow user password changes by the user
+   itself.
+*/
+#define LDB_EXTENDED_PASSWORD_CHANGE_OID        "1.3.6.1.4.1.4203.1.11.1"
+/**
+   OID for LDAP Extended Operation FAST_BIND
+   This Extended operations is used to perform a fast bind.
+*/
+#define LDB_EXTENDED_FAST_BIND_OID      "1.2.840.113556.1.4.1781"
 /**
    OID for LDAP Extended Operation START_TLS.
    This Extended operation is used to start a new TLS
    channel on top of a clear text channel.
+   This Extended operation is used to start a new TLS channel on top of a clear
+   text channel.
 */
 #define LDB_EXTENDED_START_TLS_OID      "1.3.6.1.4.1.1466.20037"
 /**
+   OID for LDAP Extended Operation DYNAMIC_REFRESH.
+   This Extended operation is used to create and maintain objects which exist
+   only a specific time, e.g. when a certain client or a certain person is
+   logged in. Data refreshes have to be periodically sent in a specific
+   interval. Otherwise the entry is going to be removed.
 */
 #define LDB_EXTENDED_DYNAMIC_OID        "1.3.6.1.4.1.1466.101.119.1"
-/**
-*/
-#define LDB_EXTENDED_FAST_BIND_OID      "1.2.840.113556.1.4.1781"
 struct ldb_sd_flags_control {
 …
 };
-#define LDB_EXTENDED_SEQUENCE_NUMBER    "1.3.6.1.4.1.7165.4.4.3"
 enum ldb_sequence_type {
         LDB_SEQ_HIGHEST_SEQ,
 …
 int ldb_op_default_callback(struct ldb_request *req, struct ldb_reply *ares);
+int ldb_modify_default_callback(struct ldb_request *req, struct ldb_reply *ares);
 /**
 …
 /**
+  replace a ldb_control in a ldb_request
+  \param req the request struct where to add the control
+  \param oid the object identifier of the control as string
+  \param critical whether the control should be critical or not
+  \param data a talloc pointer to the control specific data
+  \return result code (LDB_SUCCESS on success, or a failure code)
+*/
+int ldb_request_replace_control(struct ldb_request *req, const char *oid, bool critical, void *data);
+/**
    check if a control with the specified "oid" exist and return it
   \param req the request struct where to add the control
 …
 int ldb_transaction_cancel(struct ldb_context *ldb);
+/*
+  cancel a transaction with no error if no transaction is pending
+  used when we fork() to clear any parent transactions
+*/
+int ldb_transaction_cancel_noerr(struct ldb_context *ldb);
 /**
 …
   \param mode Style of extended DN to return (0 is HEX representation of binary form, 1 is a string form)
 */
 char *ldb_dn_get_extended_linearized(void *mem_ctx, struct ldb_dn *dn, int mode);
+char *ldb_dn_get_extended_linearized(TALLOC_CTX *mem_ctx, struct ldb_dn *dn, int mode);
 const struct ldb_val *ldb_dn_get_extended_component(struct ldb_dn *dn, const char *name);
 int ldb_dn_set_extended_component(struct ldb_dn *dn, const char *name, const struct ldb_val *val);
+void ldb_dn_extended_filter(struct ldb_dn *dn, const char * const *accept_list);
 void ldb_dn_remove_extended_components(struct ldb_dn *dn);
 bool ldb_dn_has_extended(struct ldb_dn *dn);
 …
 */
 struct ldb_dn *ldb_dn_from_ldb_val(void *mem_ctx, struct ldb_context *ldb, const struct ldb_val *strdn);
+struct ldb_dn *ldb_dn_from_ldb_val(TALLOC_CTX *mem_ctx, struct ldb_context *ldb, const struct ldb_val *strdn);
 /**
 …
 char *ldb_dn_canonical_ex_string(TALLOC_CTX *mem_ctx, struct ldb_dn *dn);
 int ldb_dn_get_comp_num(struct ldb_dn *dn);
+int ldb_dn_get_extended_comp_num(struct ldb_dn *dn);
 const char *ldb_dn_get_component_name(struct ldb_dn *dn, unsigned int num);
 const struct ldb_val *ldb_dn_get_component_val(struct ldb_dn *dn, unsigned int num);
 …
 bool ldb_dn_check_special(struct ldb_dn *dn, const char *check);
 bool ldb_dn_is_null(struct ldb_dn *dn);
+int ldb_dn_update_components(struct ldb_dn *dn, const struct ldb_dn *ref_dn);
 …
 int ldb_msg_add_string(struct ldb_message *msg,
                        const char *attr_name, const char *str);
+int ldb_msg_add_linearized_dn(struct ldb_message *msg, const char *attr_name,
+                              struct ldb_dn *dn);
 int ldb_msg_add_fmt(struct ldb_message *msg,
                     const char *attr_name, const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
 …
                                  const struct ldb_message *msg);
+/*
+ * ldb_msg_canonicalize() is now depreciated
+ * Please use ldb_msg_normalize() instead
+ *
+ * NOTE: Returned ldb_message object is allocated
+ * into *ldb's context. Callers are recommended
+ * to steal the returned object into a TALLOC_CTX
+ * with short lifetime.
+ */
 struct ldb_message *ldb_msg_canonicalize(struct ldb_context *ldb,
+                                         const struct ldb_message *msg);
+                                         const struct ldb_message *msg) _DEPRECATED_;
+int ldb_msg_normalize(struct ldb_context *ldb,
+                      TALLOC_CTX *mem_ctx,
+                      const struct ldb_message *msg,
+                      struct ldb_message **_msg_out);
+/*
+ * ldb_msg_diff() is now depreciated
+ * Please use ldb_msg_difference() instead
+ *
+ * NOTE: Returned ldb_message object is allocated
+ * into *ldb's context. Callers are recommended
+ * to steal the returned object into a TALLOC_CTX
+ * with short lifetime.
+ */
 struct ldb_message *ldb_msg_diff(struct ldb_context *ldb,
                                  struct ldb_message *msg1,
+                                 struct ldb_message *msg2);
+                                 struct ldb_message *msg2) _DEPRECATED_;
+/**
+ * return a ldb_message representing the differences between msg1 and msg2.
+ * If you then use this in a ldb_modify() call,
+ * it can be used to save edits to a message
+ *
+ * Result message is constructed as follows:
+ * - LDB_FLAG_MOD_ADD     - elements found only in msg2
+ * - LDB_FLAG_MOD_REPLACE - elements in msg2 that have
+ *                          different value in msg1
+ *                          Value for msg2 element is used
+ * - LDB_FLAG_MOD_DELETE  - elements found only in msg2
+ *
+ * @return LDB_SUCCESS or LDB_ERR_OPERATIONS_ERROR
+ */
+int ldb_msg_difference(struct ldb_context *ldb,
+                       TALLOC_CTX *mem_ctx,
+                       struct ldb_message *msg1,
+                       struct ldb_message *msg2,
+                       struct ldb_message **_msg_out);
+/**
+   Tries to find a certain string attribute in a message
+   \param msg the message to check
+   \param name attribute name
+   \param value attribute value
+   \return 1 on match and 0 otherwise.
+*/
 int ldb_msg_check_string_attribute(const struct ldb_message *msg,
                                    const char *name,
 …
 /**
+  convert a LDAP GeneralizedTime string in ldb_val format to a
+  time_t.
+*/
+int ldb_val_to_time(const struct ldb_val *v, time_t *t);
+/**
    Convert a time structure to a string
 …
 void ldb_qsort (void *const pbase, size_t total_elems, size_t size, void *opaque, ldb_qsort_cmp_fn_t cmp);
+#ifndef discard_const
+#define discard_const(ptr) ((void *)((uintptr_t)(ptr)))
+#endif
+/*
+  a wrapper around ldb_qsort() that ensures the comparison function is
+  type safe. This will produce a compilation warning if the types
+  don't match
+ */
+#define LDB_TYPESAFE_QSORT(base, numel, opaque, comparison)     \
+do { \
+        if (numel > 1) { \
+                ldb_qsort(base, numel, sizeof((base)[0]), discard_const(opaque), (ldb_qsort_cmp_fn_t)comparison); \
+                comparison(&((base)[0]), &((base)[1]), opaque);         \
+        } \
+} while (0)
+/* allow ldb to also call TYPESAFE_QSORT() */
+#ifndef TYPESAFE_QSORT
+#define TYPESAFE_QSORT(base, numel, comparison) \
+do { \
+        if (numel > 1) { \
+                qsort(base, numel, sizeof((base)[0]), (int (*)(const void *, const void *))comparison); \
+                comparison(&((base)[0]), &((base)[1])); \
+        } \
+} while (0)
+#endif
+/**
+   Convert a control into its string representation.
+   \param mem_ctx TALLOC context to return result on, and to allocate error_string on
+   \param control A struct ldb_control to convert
+   \return string representation of the control
+*/
+char* ldb_control_to_string(TALLOC_CTX *mem_ctx, const struct ldb_control *control);
+/**
+   Convert a string representing a control into a ldb_control structure
+   \param ldb LDB context
+   \param mem_ctx TALLOC context to return result on, and to allocate error_string on
+   \param control_strings A string-formatted control
+   \return a ldb_control element
+*/
+struct ldb_control *ldb_parse_control_from_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *control_strings);
 /**
    Convert an array of string represention of a control into an array of ldb_control structures
 …
+struct ldb_dn *ldb_dn_binary_from_ldb_val(TALLOC_CTX *mem_ctx,
+                                          struct ldb_context *ldb,
+                                          const struct ldb_val *strdn);
+int ldb_dn_get_binary(struct ldb_dn *dn, struct ldb_val *val);
+int ldb_dn_set_binary(struct ldb_dn *dn, struct ldb_val *val);
+/* debugging functions for ldb requests */
+void ldb_req_set_location(struct ldb_request *req, const char *location);
+const char *ldb_req_location(struct ldb_request *req);
+/* set the location marker on a request handle - used for debugging */
+#define LDB_REQ_SET_LOCATION(req) ldb_req_set_location(req, __location__)
+/*
+  minimise a DN. The caller must pass in a validated DN.
+  If the DN has an extended component then only the first extended
+  component is kept, the DN string is stripped.
+  The existing dn is modified
+ */
+bool ldb_dn_minimise(struct ldb_dn *dn);
 #endif

trunk/server/source4/lib/ldb/include/ldb_errors.h

r414	r745
198	198
199	199	/**
200		The function referred to an alias which points to a non-existant
	200	The function referred to an alias which points to a non-existent
201	201	object in the database.
202	202	*/

trunk/server/source4/lib/ldb/include/ldb_handlers.h

r414	r745
36	36	int ldb_comparison_binary( struct ldb_context ldb, void mem_ctx,
37	37	const struct ldb_val v1, const struct ldb_val v2);
38		~~int db_handler_fold( struct ldb_context ldb, void mem_ctx,~~
39		~~const struct ldb_val in, struct ldb_val out);~~
40	38	int ldb_comparison_fold( struct ldb_context ldb, void mem_ctx,
41	39	const struct ldb_val v1, const struct ldb_val v2);

trunk/server/source4/lib/ldb/include/ldb_module.h

-              r414
+              r745
 #define _LDB_MODULE_H_
 #include "ldb.h"
+#include <ldb.h>
 struct ldb_context;
 struct ldb_module;
+/**
+   internal flag bits on message elements. Must be within LDB_FLAG_INTERNAL_MASK
+ */
+#define LDB_FLAG_INTERNAL_DISABLE_VALIDATION 0x10
+/* disable any single value checking on this attribute */
+#define LDB_FLAG_INTERNAL_DISABLE_SINGLE_VALUE_CHECK 0x20
+/* attribute has failed access check and must not be exposed */
+#define LDB_FLAG_INTERNAL_INACCESSIBLE_ATTRIBUTE 0x40
+/* force single value checking on this attribute */
+#define LDB_FLAG_INTERNAL_FORCE_SINGLE_VALUE_CHECK 0x80
 /*
 …
 void ldb_debug_end(struct ldb_context *ldb, enum ldb_debug_level level);
+#define ldb_oom(ldb) ldb_debug_set(ldb, LDB_DEBUG_FATAL, "ldb out of memory at %s:%d\n", __FILE__, __LINE__)
+#define ldb_error(ldb, ecode, reason) ldb_error_at(ldb, ecode, reason, __FILE__, __LINE__)
+#define ldb_oom(ldb) ldb_error(ldb, LDB_ERR_OPERATIONS_ERROR, "ldb out of memory")
+#define ldb_module_oom(module) ldb_oom(ldb_module_get_ctx(module))
+#define ldb_operr(ldb) ldb_error(ldb, LDB_ERR_OPERATIONS_ERROR, "operations error")
 /* The following definitions come from lib/ldb/common/ldb.c  */
 …
                                                void *private_data);
+/* A useful function to build comparison functions with */
+int ldb_any_comparison(struct ldb_context *ldb, void *mem_ctx,
+                       ldb_attr_handler_t canonicalise_fn,
+                       const struct ldb_val *v1,
+                       const struct ldb_val *v2);
 /* The following definitions come from lib/ldb/common/ldb_controls.c  */
+struct ldb_control *get_control_from_list(struct ldb_control **controls, const char *oid);
+int save_controls(struct ldb_control *exclude, struct ldb_request *req, struct ldb_control ***saver);
+int check_critical_controls(struct ldb_control **controls);
+int ldb_save_controls(struct ldb_control *exclude, struct ldb_request *req, struct ldb_control ***saver);
+/* Returns a list of controls, except the one specified.  Included
+ * controls become a child of returned list if they were children of
+ * controls_in */
+struct ldb_control **ldb_controls_except_specified(struct ldb_control **controls_in,
+                                               TALLOC_CTX *mem_ctx,
+                                               struct ldb_control *exclude);
+int ldb_check_critical_controls(struct ldb_control **controls);
 /* The following definitions come from lib/ldb/common/ldb_ldif.c  */
 …
                   enum ldb_scope scope);
+int ldb_match_msg_error(struct ldb_context *ldb,
+                        const struct ldb_message *msg,
+                        const struct ldb_parse_tree *tree,
+                        struct ldb_dn *base,
+                        enum ldb_scope scope,
+                        bool *matched);
+int ldb_match_msg_objectclass(const struct ldb_message *msg,
+                              const char *objectclass);
 /* The following definitions come from lib/ldb/common/ldb_modules.c  */
 …
 void *ldb_module_get_private(struct ldb_module *module);
 void ldb_module_set_private(struct ldb_module *module, void *private_data);
+const struct ldb_module_ops *ldb_module_get_ops(struct ldb_module *module);
 int ldb_next_request(struct ldb_module *module, struct ldb_request *request);
 …
 void ldb_asprintf_errstring(struct ldb_context *ldb, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 void ldb_reset_err_string(struct ldb_context *ldb);
+int ldb_error_at(struct ldb_context *ldb, int ecode, const char *reason, const char *file, int line);
 const char *ldb_default_modules_dir(void);
 …
 const char *ldb_default_modules_dir(void);
 int ldb_register_backend(const char *url_prefix, ldb_connect_fn);
+int ldb_register_backend(const char *url_prefix, ldb_connect_fn, bool);
 struct ldb_handle *ldb_handle_new(TALLOC_CTX *mem_ctx, struct ldb_context *ldb);
 …
 void ldb_set_default_dns(struct ldb_context *ldb);
+/**
+  Add a ldb_control to a ldb_reply
+  \param ares the reply struct where to add the control
+  \param oid the object identifier of the control as string
+  \param critical whether the control should be critical or not
+  \param data a talloc pointer to the control specific data
+  \return result code (LDB_SUCCESS on success, or a failure code)
+*/
+int ldb_reply_add_control(struct ldb_reply *ares, const char *oid, bool critical, void *data);
+/**
+  mark a request as untrusted. This tells the rootdse module to remove
+  unregistered controls
+ */
+void ldb_req_mark_untrusted(struct ldb_request *req);
+/**
+  mark a request as trusted.
+ */
+void ldb_req_mark_trusted(struct ldb_request *req);
+/**
+   return true is a request is untrusted
+ */
+bool ldb_req_is_untrusted(struct ldb_request *req);
+/* load all modules from the given directory */
+int ldb_modules_load(const char *modules_path, const char *version);
+/* init functions prototype */
+typedef int (*ldb_module_init_fn)(const char *);
+/*
+  general ldb hook function
+ */
+enum ldb_module_hook_type { LDB_MODULE_HOOK_CMDLINE_OPTIONS     = 1,
+                            LDB_MODULE_HOOK_CMDLINE_PRECONNECT  = 2,
+                            LDB_MODULE_HOOK_CMDLINE_POSTCONNECT = 3 };
+typedef int (*ldb_hook_fn)(struct ldb_context *, enum ldb_module_hook_type );
+/*
+  register a ldb hook function
+ */
+int ldb_register_hook(ldb_hook_fn hook_fn);
+/*
+  call ldb hooks of a given type
+ */
+int ldb_modules_hook(struct ldb_context *ldb, enum ldb_module_hook_type t);
+#define LDB_MODULE_CHECK_VERSION(version) do { \
+ if (strcmp(version, LDB_VERSION) != 0) { \
+        fprintf(stderr, "ldb: module version mismatch in %s : ldb_version=%s module_version=%s\n", \
+                        __FILE__, version, LDB_VERSION); \
+        return LDB_ERR_UNAVAILABLE; \
+ }} while (0)
+/*
+  return a string representation of the calling chain for the given
+  ldb request
+ */
+char *ldb_module_call_chain(struct ldb_request *req, TALLOC_CTX *mem_ctx);
+/*
+  return the next module in the chain
+ */
+struct ldb_module *ldb_module_next(struct ldb_module *module);
+/*
+  set the next module in the module chain
+ */
+void ldb_module_set_next(struct ldb_module *module, struct ldb_module *next);
+/*
+  load a list of modules
+ */
+int ldb_module_load_list(struct ldb_context *ldb, const char **module_list,
+                         struct ldb_module *backend, struct ldb_module **out);
+/*
+  get the popt_options pointer in the ldb structure. This allows a ldb
+  module to change the command line parsing
+ */
+struct poptOption **ldb_module_popt_options(struct ldb_context *ldb);
+/* modules are called in inverse order on the stack.
+   Lets place them as an admin would think the right order is.
+   Modules order is important */
+const char **ldb_modules_list_from_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *string);
+/*
+  return the current ldb flags LDB_FLG_*
+ */
+uint32_t ldb_module_flags(struct ldb_context *ldb);
+int ldb_module_connect_backend(struct ldb_context *ldb,
+                               const char *url,
+                               const char *options[],
+                               struct ldb_module **backend_module);
+/*
+  initialise a chain of modules
+ */
+int ldb_module_init_chain(struct ldb_context *ldb, struct ldb_module *module);
+/*
+ * prototype for the init function defined by dynamically loaded modules
+ */
+int ldb_init_module(const char *version);
 #endif

trunk/server/source4/lib/ldb/include/ldb_private.h

-              r414
+              r745
 #define _LDB_PRIVATE_H_ 1
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb.h"
 #include "ldb_module.h"
 …
 #define LDB_HANDLE_FLAG_DONE_CALLED 1
+/* call is from an untrusted source - eg. over ldap:// */
+#define LDB_HANDLE_FLAG_UNTRUSTED   2
 struct ldb_handle {
 …
         unsigned flags;
         unsigned nesting;
+        /* used for debugging */
+        struct ldb_request *parent;
+        const char *location;
 };
 …
         unsigned int create_perms;
-        char *modules_dir;
         struct tevent_context *ev_ctx;
 …
         char *partial_debug;
+        struct poptOption *popt_options;
 };
 /* The following definitions come from lib/ldb/common/ldb.c  */
-int ldb_connect_backend(struct ldb_context *ldb, const char *url, const char *options[],
-                        struct ldb_module **backend_module);
 extern const struct ldb_module_ops ldb_objectclass_module_ops;
 …
 /* The following definitions come from lib/ldb/common/ldb_utf8.c */
 char *ldb_casefold_default(void *context, void *mem_ctx, const char *s, size_t n);
+char *ldb_casefold_default(void *context, TALLOC_CTX *mem_ctx, const char *s, size_t n);
 void ldb_dump_results(struct ldb_context *ldb, struct ldb_result *result, FILE *f);
 …
 const char **ldb_modules_list_from_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *string);
-int ldb_load_modules_list(struct ldb_context *ldb, const char **module_list, struct ldb_module *backend, struct ldb_module **out);
 int ldb_load_modules(struct ldb_context *ldb, const char *options[]);
-int ldb_init_module_chain(struct ldb_context *ldb, struct ldb_module *module);
+struct ldb_val ldb_binary_decode(void *mem_ctx, const char *str);
+struct ldb_val ldb_binary_decode(TALLOC_CTX *mem_ctx, const char *str);
+/* The following definitions come from lib/ldb/common/ldb_options.c  */
+const char *ldb_options_find(struct ldb_context *ldb, const char *options[],
+                             const char *option_name);
 #endif

trunk/server/source4/lib/ldb/ldb.pc.in

r414	r745
10	10	Requires.private: tdb
11	11	Requires: talloc
12		Libs: -L${libdir} -lldb
	12	Libs: @LIB_RPATH@ -L${libdir} -lldb
13	13	Libs.private: @LDAP_LIBS@
14	14	Cflags: -I${includedir}

trunk/server/source4/lib/ldb/ldb_ldap/ldb_ldap.c

-              r414
+              r745
  *  Modifications:
+ *
  *  - description: make the module use asyncronous calls
+ *  - description: make the module use asynchronous calls
  *    date: Feb 2006
  *    author: Simo Sorce
  */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_module.h"
+#include "ldb_private.h"
 #define LDAP_DEPRECATED 1
 …
                                 goto failed;
+                        }
                         mods[num_mods]->mod_vals.modv_bvals[j]->bv_val = el->values[j].data;
+                        mods[num_mods]->mod_vals.modv_bvals[j]->bv_val = (char *)el->values[j].data;
                         mods[num_mods]->mod_vals.modv_bvals[j]->bv_len = el->values[j].length;
+                }
 …
         ret = ldap_search_ext(lldb->ldap, search_base, ldap_scope,
                             expression,
                             discard_const_p(char *, req->op.search.attrs),
 ,
                             NULL,
                             NULL,
                             &tv,
                             LDAP_NO_LIMIT,
                             &lldb_ac->msgid);
+                              expression,
+                              discard_const_p(char *, req->op.search.attrs),
+,
+                              NULL,
+                              NULL,
+                              &tv,
+                              LDAP_NO_LIMIT,
+                              &lldb_ac->msgid);
         if (ret != LDAP_SUCCESS) {
 …
         int ret;
         ldb_module_get_ctx(module);
+        ldb = ldb_module_get_ctx(module);
         ldb_request_set_state(req, LDB_ASYNC_PENDING);
 …
         int ret;
         ldb_module_get_ctx(module);
+        ldb = ldb_module_get_ctx(module);
         ldb_request_set_state(req, LDB_ASYNC_PENDING);
 …
         int ret;
         ldb_module_get_ctx(module);
+        ldb = ldb_module_get_ctx(module);
         ldb_request_set_state(req, LDB_ASYNC_PENDING);
 …
         struct ldb_module *module = lldb_ac->module;
         struct ldb_request *req = lldb_ac->req;
+        const char *rdn_name;
+        const struct ldb_val *rdn_val;
         char *old_dn;
         char *newrdn;
+        char *newrdn;
         char *parentdn;
         int ret;
         ldb_module_get_ctx(module);
+        ldb = ldb_module_get_ctx(module);
         ldb_request_set_state(req, LDB_ASYNC_PENDING);
 …
+        }
+        newrdn = talloc_asprintf(lldb_ac, "%s=%s",
+                                 ldb_dn_get_rdn_name(req->op.rename.newdn),
+                                 ldb_dn_escape_value(lldb, *(ldb_dn_get_rdn_val(req->op.rename.newdn))));
+        rdn_name = ldb_dn_get_rdn_name(req->op.rename.newdn);
+        rdn_val = ldb_dn_get_rdn_val(req->op.rename.newdn);
+        if ((rdn_name != NULL) && (rdn_val != NULL)) {
+                newrdn = talloc_asprintf(lldb_ac, "%s=%s", rdn_name,
+                                         rdn_val->length > 0 ? ldb_dn_escape_value(lldb, *rdn_val) : "");
+        } else {
+                newrdn = talloc_strdup(lldb_ac, "");
+        }
         if (!newrdn) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
+}
 void lldb_request_done(struct lldb_context *ac,
+static void lldb_request_done(struct lldb_context *ac,
                         struct ldb_control **ctrls, int error)
+{
 …
         bool request_done;
         bool lret;
+        unsigned int i;
         int ret;
-        int i;
         ldb = ldb_module_get_ctx(ac->module);
 …
                         ldbmsg = ldb_msg_new(ac);
                         if (!ldbmsg) {
+                                ldb_oom(ldb);
                                 ret = LDB_ERR_OPERATIONS_ERROR;
                                 break;
 …
                         dn = ldap_get_dn(lldb->ldap, msg);
                         if (!dn) {
+                                ldb_oom(ldb);
                                 talloc_free(ldbmsg);
                                 ret = LDB_ERR_OPERATIONS_ERROR;
 …
                         ldbmsg->dn = ldb_dn_new(ldbmsg, ldb, dn);
                         if ( ! ldb_dn_validate(ldbmsg->dn)) {
+                                ldb_asprintf_errstring(ldb, "Invalid DN '%s' in reply", dn);
                                 talloc_free(ldbmsg);
                                 ret = LDB_ERR_OPERATIONS_ERROR;
+                                ldap_memfree(dn);
                                 break;
+                        }
 …
                         ret = ldb_module_send_entry(ac->req, ldbmsg, NULL /* controls not yet supported */);
                         if (ret != LDB_SUCCESS) {
+                                ldb_asprintf_errstring(ldb, "entry send failed: %s",
+                                                       ldb_errstring(ldb));
                                 callback_failed = true;
+                        }
 …
         case LDAP_RES_SEARCH_REFERENCE:
+                if (ldap_parse_result(lldb->ldap, result, &ret,
+                                        &matcheddnp, &errmsgp,
+                                        &referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
+                ret = ldap_parse_reference(lldb->ldap, result,
+                                           &referralsp, &serverctrlsp, 0);
+                if (ret != LDAP_SUCCESS) {
+                        ldb_asprintf_errstring(ldb, "ldap reference parse error: %s : %s",
+                                               ldap_err2string(ret), errmsgp);
                         ret = LDB_ERR_OPERATIONS_ERROR;
+                }
-                if (ret != LDB_SUCCESS) {
                         break;
+                }
                 if (referralsp == NULL) {
+                        ldb_asprintf_errstring(ldb, "empty ldap referrals list");
                         ret = LDB_ERR_PROTOCOL_ERROR;
                         break;
 …
                         ret = ldb_module_send_referral(ac->req, referral);
                         if (ret != LDB_SUCCESS) {
+                                ldb_asprintf_errstring(ldb, "referral send failed: %s",
+                                                       ldb_errstring(ldb));
                                 callback_failed = true;
                                 break;
 …
+                }
                 if (ret != LDB_SUCCESS) {
+                        ldb_asprintf_errstring(ldb, "ldap parse error for type %d: %s : %s",
+                                               type, ldap_err2string(ret), errmsgp);
                         break;
+                }
 …
         default:
+                ldb_asprintf_errstring(ldb, "unknown ldap return type: %d", type);
                 ret = LDB_ERR_PROTOCOL_ERROR;
                 break;
 …
         default:
                 /* no other op supported */
                 ret = LDB_ERR_OPERATIONS_ERROR;
+                ret = LDB_ERR_PROTOCOL_ERROR;
                 break;
+        }
 …
+}
+/*
+  optionally perform a bind
+ */
+static int lldb_bind(struct ldb_module *module,
+                     const char *options[])
+{
+        const char *bind_mechanism;
+        struct lldb_private *lldb;
+        struct ldb_context *ldb = ldb_module_get_ctx(module);
+        int ret;
+        bind_mechanism = ldb_options_find(ldb, options, "bindMech");
+        if (bind_mechanism == NULL) {
+                /* no bind wanted */
+                return LDB_SUCCESS;
+        }
+        lldb = talloc_get_type(ldb_module_get_private(module), struct lldb_private);
+        if (strcmp(bind_mechanism, "simple") == 0) {
+                const char *bind_id, *bind_secret;
+                bind_id = ldb_options_find(ldb, options, "bindID");
+                bind_secret = ldb_options_find(ldb, options, "bindSecret");
+                if (bind_id == NULL || bind_secret == NULL) {
+                        ldb_asprintf_errstring(ldb, "simple bind requires bindID and bindSecret");
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                ret = ldap_simple_bind_s(lldb->ldap, bind_id, bind_secret);
+                if (ret != LDAP_SUCCESS) {
+                        ldb_asprintf_errstring(ldb, "bind failed: %s", ldap_err2string(ret));
+                        return ret;
+                }
+                return LDB_SUCCESS;
+        }
+        ldb_asprintf_errstring(ldb, "bind failed: unknown mechanism %s", bind_mechanism);
+        return LDB_ERR_INAPPROPRIATE_AUTHENTICATION;
+}
 /*
   connect to the database
 …
         module = ldb_module_new(ldb, ldb, "ldb_ldap backend", &lldb_ops);
         if (!module) return -1;
+        if (!module) return LDB_ERR_OPERATIONS_ERROR;
         lldb = talloc_zero(module, struct lldb_private);
 …
         *_module = module;
+        return 0;
+        ret = lldb_bind(module, options);
+        if (ret != LDB_SUCCESS) {
+                goto failed;
+        }
+        return LDB_SUCCESS;
 failed:
         talloc_free(module);
+        return -1;
+}
+const struct ldb_backend_ops ldb_ldap_backend_ops = {
+        .name = "ldap",
+        .connect_fn = lldb_connect
+};
+const struct ldb_backend_ops ldb_ldapi_backend_ops = {
+        .name = "ldapi",
+        .connect_fn = lldb_connect
+};
+const struct ldb_backend_ops ldb_ldaps_backend_ops = {
+        .name = "ldaps",
+        .connect_fn = lldb_connect
+};
+        return LDB_ERR_OPERATIONS_ERROR;
+}
+/*
+  initialise the module
+ */
+int ldb_ldap_init(const char *version)
+{
+        int ret, i;
+        const char *names[] = { "ldap", "ldaps", "ldapi", NULL };
+        LDB_MODULE_CHECK_VERSION(version);
+        for (i=0; names[i]; i++) {
+                ret = ldb_register_backend(names[i], lldb_connect, false);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
+        }
+        return LDB_SUCCESS;
+}

trunk/server/source4/lib/ldb/ldb_map/ldb_map.c

-              r414
+              r745
  */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_map.h"
 #include "ldb_map_private.h"
 …
 static const struct ldb_map_objectclass *map_objectclass_find_local(const struct ldb_map_context *data, const char *name)
+{
         int i;
+        unsigned int i;
         for (i = 0; data->objectclass_maps && data->objectclass_maps[i].local_name; i++) {
 …
 static const struct ldb_map_objectclass *map_objectclass_find_remote(const struct ldb_map_context *data, const char *name)
+{
         int i;
+        unsigned int i;
         for (i = 0; data->objectclass_maps && data->objectclass_maps[i].remote_name; i++) {
 …
 const struct ldb_map_attribute *map_attr_find_local(const struct ldb_map_context *data, const char *name)
+{
         int i;
+        unsigned int i;
         for (i = 0; data->attribute_maps[i].local_name; i++) {
 …
         const struct ldb_map_attribute *map;
         const struct ldb_map_attribute *wildcard = NULL;
         int i, j;
+        unsigned int i, j;
         for (i = 0; data->attribute_maps[i].local_name; i++) {
 …
                 switch (map->type) {
                 case MAP_IGNORE:
+                case LDB_MAP_IGNORE:
                         break;
                 case MAP_KEEP:
+                case LDB_MAP_KEEP:
                         if (ldb_attr_cmp(map->local_name, name) == 0) {
                                 return map;
 …
                         break;
                 case MAP_RENAME:
                 case MAP_CONVERT:
+                case LDB_MAP_RENAME:
+                case LDB_MAP_CONVERT:
                         if (ldb_attr_cmp(map->u.rename.remote_name, name) == 0) {
                                 return map;
 …
                         break;
                 case MAP_GENERATE:
+                case LDB_MAP_GENERATE:
                         for (j = 0; map->u.generate.remote_names && map->u.generate.remote_names[j]; j++) {
                                 if (ldb_attr_cmp(map->u.generate.remote_names[j], name) == 0) {
 …
                 return false;
+        }
         if (map->type == MAP_IGNORE) {
+        if (map->type == LDB_MAP_IGNORE) {
                 return false;
+        }
 …
         switch (map->type) {
         case MAP_KEEP:
+        case LDB_MAP_KEEP:
                 return talloc_strdup(mem_ctx, attr);
         case MAP_RENAME:
         case MAP_CONVERT:
+        case LDB_MAP_RENAME:
+        case LDB_MAP_CONVERT:
                 return talloc_strdup(mem_ctx, map->u.rename.remote_name);
 …
+        }
         if (map->type == MAP_KEEP) {
+        if (map->type == LDB_MAP_KEEP) {
                 return talloc_strdup(mem_ctx, attr);
+        }
 …
                     const char ***attrs, const char * const *more_attrs)
+{
         int i, j, k;
+        unsigned int i, j, k;
         for (i = 0; *attrs && (*attrs)[i]; i++) /* noop */ ;
 …
                                  const struct ldb_map_attribute *map, const struct ldb_val *val)
+{
         if (map && (map->type == MAP_CONVERT) && (map->u.convert.convert_local)) {
+        if (map && (map->type == LDB_MAP_CONVERT) && (map->u.convert.convert_local)) {
                 return map->u.convert.convert_local(module, mem_ctx, val);
+        }
 …
                                   const struct ldb_map_attribute *map, const struct ldb_val *val)
+{
         if (map && (map->type == MAP_CONVERT) && (map->u.convert.convert_remote)) {
+        if (map && (map->type == LDB_MAP_CONVERT) && (map->u.convert.convert_remote)) {
                 return map->u.convert.convert_remote(module, mem_ctx, val);
+        }
 …
                 /* Unknown attribute - leave this RDN as is and hope the best... */
                 if (map == NULL) {
                         map_type = MAP_KEEP;
+                        map_type = LDB_MAP_KEEP;
                 } else {
                         map_type = map->type;
 …
                 switch (map_type) {
                 case MAP_IGNORE:
                 case MAP_GENERATE:
+                case LDB_MAP_IGNORE:
+                case LDB_MAP_GENERATE:
                         ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
                                   "MAP_IGNORE/MAP_GENERATE attribute '%s' "
+                                  "LDB_MAP_IGNORE/LDB_MAP_GENERATE attribute '%s' "
                                   "used in DN!", ldb_dn_get_component_name(dn, i));
                         goto failed;
                 case MAP_CONVERT:
+                case LDB_MAP_CONVERT:
                         if (map->u.convert.convert_local == NULL) {
                                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
 …
+                        }
                         /* fall through */
                 case MAP_KEEP:
                 case MAP_RENAME:
+                case LDB_MAP_KEEP:
+                case LDB_MAP_RENAME:
                         name = map_attr_map_local(newdn, map, ldb_dn_get_component_name(dn, i));
                         if (name == NULL) goto failed;
 …
                 /* Unknown attribute - leave this RDN as is and hope the best... */
                 if (map == NULL) {
                         map_type = MAP_KEEP;
+                        map_type = LDB_MAP_KEEP;
                 } else {
                         map_type = map->type;
 …
                 switch (map_type) {
                 case MAP_IGNORE:
                 case MAP_GENERATE:
+                case LDB_MAP_IGNORE:
+                case LDB_MAP_GENERATE:
                         ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
                                   "MAP_IGNORE/MAP_GENERATE attribute '%s' "
+                                  "LDB_MAP_IGNORE/LDB_MAP_GENERATE attribute '%s' "
                                   "used in DN!", ldb_dn_get_component_name(dn, i));
                         goto failed;
                 case MAP_CONVERT:
+                case LDB_MAP_CONVERT:
                         if (map->u.convert.convert_remote == NULL) {
                                 ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
 …
+                        }
                         /* fall through */
                 case MAP_KEEP:
                 case MAP_RENAME:
+                case LDB_MAP_KEEP:
+                case LDB_MAP_RENAME:
                         name = map_attr_map_remote(newdn, map, ldb_dn_get_component_name(dn, i));
                         if (name == NULL) goto failed;
 …
         struct ldb_val val;
         bool found_extensibleObject = false;
         int i;
+        unsigned int i;
         ldb = ldb_module_get_ctx(module);
 …
         struct ldb_message_element *el, *oc;
         struct ldb_val val;
         int i;
+        unsigned int i;
         ldb = ldb_module_get_ctx(module);
 …
 static const struct ldb_map_attribute objectclass_convert_map = {
         .local_name = "objectClass",
         .type = MAP_CONVERT,
+        .type = LDB_MAP_CONVERT,
         .u = {
                 .convert = {
 …
                                         context, callback,
                                         ac->req);
+        LDB_REQ_SET_LOCATION(req);
         if (ret != LDB_SUCCESS) {
                 return NULL;
 …
                                 context, callback,
                                 ac->req);
+        LDB_REQ_SET_LOCATION(req);
         if (ret != LDB_SUCCESS) {
                 goto failed;
 …
+        {
                 .local_name = "dn",
                 .type = MAP_CONVERT,
+                .type = LDB_MAP_CONVERT,
                 .u = {
                         .convert = {
 …
 static const struct ldb_map_attribute objectclass_attribute_map = {
         .local_name = "objectClass",
         .type = MAP_GENERATE,
+        .type = LDB_MAP_GENERATE,
         .convert_operator = map_objectclass_convert_operator,
         .u = {
 …
                          const char * const *wildcard_attributes)
+{
         int i, j, last;
+        unsigned int i, j, last;
         last = 0;

trunk/server/source4/lib/ldb/ldb_map/ldb_map.h

-              r414
+              r745
         enum ldb_map_attr_type {
                 MAP_IGNORE, /* Ignore this local attribute. Doesn't exist remotely.  */
                 MAP_KEEP,   /* Keep as is. Same name locally and remotely. */
                 MAP_RENAME, /* Simply rename the attribute. Name changes, data is the same */
                 MAP_CONVERT, /* Rename + convert data */
                 MAP_GENERATE /* Use generate function for generating new name/data.
+                LDB_MAP_IGNORE, /* Ignore this local attribute. Doesn't exist remotely.  */
+                LDB_MAP_KEEP,   /* Keep as is. Same name locally and remotely. */
+                LDB_MAP_RENAME, /* Simply rename the attribute. Name changes, data is the same */
+                LDB_MAP_CONVERT, /* Rename + convert data */
+                LDB_MAP_GENERATE /* Use generate function for generating new name/data.
                                                 Used for generating attributes based on
                                                 multiple remote attributes. */
 …
                  const char *name);
 int map_add(struct ldb_module *module, struct ldb_request *req);
 int map_search(struct ldb_module *module, struct ldb_request *req);
 int map_rename(struct ldb_module *module, struct ldb_request *req);
 int map_delete(struct ldb_module *module, struct ldb_request *req);
 int map_modify(struct ldb_module *module, struct ldb_request *req);
+int ldb_map_add(struct ldb_module *module, struct ldb_request *req);
+int ldb_map_search(struct ldb_module *module, struct ldb_request *req);
+int ldb_map_rename(struct ldb_module *module, struct ldb_request *req);
+int ldb_map_delete(struct ldb_module *module, struct ldb_request *req);
+int ldb_map_modify(struct ldb_module *module, struct ldb_request *req);
 #define LDB_MAP_OPS \
         .add            = map_add, \
         .modify         = map_modify, \
         .del            = map_delete, \
         .rename         = map_rename, \
         .search         = map_search,
+        .add            = ldb_map_add, \
+        .modify         = ldb_map_modify, \
+        .del            = ldb_map_delete, \
+        .rename         = ldb_map_rename, \
+        .search         = ldb_map_search,
 #endif /* __LDB_MAP_H__ */

trunk/server/source4/lib/ldb/ldb_map/ldb_map_inbound.c

-              r414
+              r745
 */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_map.h"
 #include "ldb_map_private.h"
 …
+{
         struct ldb_message_element *el;
         int i;
+        unsigned int i;
         el = talloc_zero(mem_ctx, struct ldb_message_element);
 …
         switch (map->type) {
         case MAP_IGNORE:
+        case LDB_MAP_IGNORE:
                 goto local;
         case MAP_CONVERT:
+        case LDB_MAP_CONVERT:
                 if (map->u.convert.convert_local == NULL) {
                         ldb_debug(ldb, LDB_DEBUG_WARNING, "ldb_map: "
 …
+                }
                 /* fall through */
         case MAP_KEEP:
         case MAP_RENAME:
+        case LDB_MAP_KEEP:
+        case LDB_MAP_RENAME:
                 el = ldb_msg_el_map_local(module, remote, map, old);
                 break;
         case MAP_GENERATE:
+        case LDB_MAP_GENERATE:
                 if (map->u.generate.generate_remote == NULL) {
                         ldb_debug(ldb, LDB_DEBUG_WARNING, "ldb_map: "
 …
         const struct ldb_map_context *data = map_get_context(module);
         bool ret;
         int i;
+        unsigned int i;
         for (i = 0; i < msg->num_elements; i++) {
 …
         /* const char * const names[]; */
         struct ldb_context *ldb;
+        int i, ret;
+        unsigned int i;
+        int ret;
         ldb = ldb_module_get_ctx(module);
 …
 /* Add a record. */
 int map_add(struct ldb_module *module, struct ldb_request *req)
+int ldb_map_add(struct ldb_module *module, struct ldb_request *req)
+{
         const struct ldb_message *msg = req->op.add.message;
 …
         struct map_context *ac;
         struct ldb_message *remote_msg;
-        const char *dn;
         int ret;
 …
                                 ac, map_op_remote_callback,
                                 req);
+        LDB_REQ_SET_LOCATION(ac->remote_req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
         /* Store remote DN in 'IS_MAPPED' */
         /* TODO: use GUIDs here instead */
+        dn = ldb_dn_alloc_linearized(ac->local_msg, remote_msg->dn);
+        if (ldb_msg_add_string(ac->local_msg, IS_MAPPED, dn) != 0) {
+        ret = ldb_msg_add_linearized_dn(ac->local_msg, IS_MAPPED,
+                                        remote_msg->dn);
+        if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
                                 map_op_local_callback,
                                 ac->req);
+        LDB_REQ_SET_LOCATION(local_req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
 /* Modify a record. */
 int map_modify(struct ldb_module *module, struct ldb_request *req)
+int ldb_map_modify(struct ldb_module *module, struct ldb_request *req)
+{
         const struct ldb_message *msg = req->op.mod.message;
 …
                                 ac, map_op_remote_callback,
                                 req);
+        LDB_REQ_SET_LOCATION(ac->remote_req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
         struct ldb_request *local_req;
         struct ldb_context *ldb;
-        char *dn;
         int ret;
 …
                         return LDB_ERR_OPERATIONS_ERROR;
+                }
                 dn = ldb_dn_alloc_linearized(ac->local_msg,
                                         ac->remote_req->op.mod.message->dn);
                 if (ldb_msg_add_string(ac->local_msg, IS_MAPPED, dn) != 0) {
+                ret = ldb_msg_add_linearized_dn(ac->local_msg, IS_MAPPED,
+                                                ac->remote_req->op.mod.message->dn);
+                if (ret != 0) {
                         return LDB_ERR_OPERATIONS_ERROR;
+                }
 …
                                         map_op_local_callback,
                                         ac->req);
+                LDB_REQ_SET_LOCATION(local_req);
                 if (ret != LDB_SUCCESS) {
                         return LDB_ERR_OPERATIONS_ERROR;
 …
                                         map_op_local_callback,
                                         ac->req);
+                LDB_REQ_SET_LOCATION(local_req);
                 if (ret != LDB_SUCCESS) {
                         return LDB_ERR_OPERATIONS_ERROR;
 …
 /* Delete a record. */
 int map_delete(struct ldb_module *module, struct ldb_request *req)
+int ldb_map_delete(struct ldb_module *module, struct ldb_request *req)
+{
         struct ldb_request *search_req;
 …
                                    map_op_remote_callback,
                                    req);
+        LDB_REQ_SET_LOCATION(ac->remote_req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
                                    map_op_local_callback,
                                    ac->req);
+        LDB_REQ_SET_LOCATION(local_req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
 /* Rename a record. */
 int map_rename(struct ldb_module *module, struct ldb_request *req)
+int ldb_map_rename(struct ldb_module *module, struct ldb_request *req)
+{
         struct ldb_request *search_req;
 …
                                    ac, map_op_remote_callback,
                                    req);
+        LDB_REQ_SET_LOCATION(ac->remote_req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
                                    map_rename_local_callback,
                                    ac->req);
+        LDB_REQ_SET_LOCATION(local_req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;

trunk/server/source4/lib/ldb/ldb_map/ldb_map_outbound.c

-              r414
+              r745
 */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_map.h"
 #include "ldb_map_private.h"
 …
         const struct ldb_map_context *data = map_get_context(module);
         const char **result;
         int i, last;
+        unsigned int i, last;
         if (attrs == NULL)
 …
         const struct ldb_map_attribute *map;
         const char *name=NULL;
         int i, j, last;
+        unsigned int i, j, last;
         int ret;
 …
                 switch (map->type) {
                 case MAP_IGNORE:
+                case LDB_MAP_IGNORE:
                         continue;
                 case MAP_KEEP:
+                case LDB_MAP_KEEP:
                         name = attrs[i];
                         goto named;
                 case MAP_RENAME:
                 case MAP_CONVERT:
+                case LDB_MAP_RENAME:
+                case LDB_MAP_CONVERT:
                         name = map->u.rename.remote_name;
                         goto named;
                 case MAP_GENERATE:
+                case LDB_MAP_GENERATE:
                         /* Add all remote names of "generate" attrs */
                         for (j = 0; map->u.generate.remote_names[j]; j++) {
 …
                                                          const struct ldb_message_element *old)
+{
+        const struct ldb_map_context *data = map_get_context(module);
+        const char *local_attr_name = attr_name;
         struct ldb_message_element *el;
         int i;
+        unsigned int i;
         el = talloc_zero(mem_ctx, struct ldb_message_element);
 …
+        }
+        el->name = talloc_strdup(el, attr_name);
+        for (i = 0; data->attribute_maps[i].local_name; i++) {
+                struct ldb_map_attribute *am = &data->attribute_maps[i];
+                if ((am->type == LDB_MAP_RENAME &&
+                        !strcmp(am->u.rename.remote_name, attr_name))
+                    || (am->type == LDB_MAP_CONVERT &&
+                        !strcmp(am->u.convert.remote_name, attr_name))) {
+                        local_attr_name = am->local_name;
+                        break;
+                }
+        }
+        el->name = talloc_strdup(el, local_attr_name);
         if (el->name == NULL) {
                 talloc_free(el);
 …
         switch (map->type) {
         case MAP_IGNORE:
                 break;
         case MAP_CONVERT:
+        case LDB_MAP_IGNORE:
+                break;
+        case LDB_MAP_CONVERT:
                 remote_name = map->u.convert.remote_name;
                 break;
         case MAP_KEEP:
+        case LDB_MAP_KEEP:
                 remote_name = attr_name;
                 break;
         case MAP_RENAME:
+        case LDB_MAP_RENAME:
                 remote_name = map->u.rename.remote_name;
                 break;
         case MAP_GENERATE:
+        case LDB_MAP_GENERATE:
                 break;
+        }
         switch (map->type) {
         case MAP_IGNORE:
+        case LDB_MAP_IGNORE:
                 return LDB_SUCCESS;
         case MAP_CONVERT:
+        case LDB_MAP_CONVERT:
                 if (map->u.convert.convert_remote == NULL) {
                         ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
 …
+                }
                 /* fall through */
         case MAP_KEEP:
         case MAP_RENAME:
+        case LDB_MAP_KEEP:
+        case LDB_MAP_RENAME:
                 old = ldb_msg_find_element(remote, remote_name);
                 if (old) {
 …
                 break;
         case MAP_GENERATE:
+        case LDB_MAP_GENERATE:
                 if (map->u.generate.generate_local == NULL) {
                         ldb_debug(ldb, LDB_DEBUG_ERROR, "ldb_map: "
 …
         const struct ldb_map_attribute *map = map_attr_find_local(data, "*");
         struct ldb_message_element *el=NULL;
+        int i, ret;
+        unsigned int i;
+        int ret;
         /* Perhaps we have a mapping for "*" */
         if (map && map->type == MAP_KEEP) {
+        if (map && map->type == LDB_MAP_KEEP) {
                 /* We copy everything over, and hope that anything with a
                    more specific rule is overwritten */
 …
 static int ldb_msg_merge_local(struct ldb_module *module, struct ldb_message *msg1, struct ldb_message *msg2)
+{
+        int i, ret;
+        unsigned int i;
+        int ret;
         for (i = 0; i < msg2->num_elements; i++) {
 …
                                 struct ldb_message *remote)
+{
+        int i, ret;
+        unsigned int i;
+        int ret;
         const char * const *attrs = ac->all_attrs;
         if (!attrs) {
 …
+{
         const char **new_attrs;
+        int i, ret;
+        unsigned int i;
+        int ret;
         if (tree == NULL) {
 …
                 return 0;
+        }
-        return -1;
+}
 …
 static int map_subtree_select_local_list(struct ldb_module *module, void *mem_ctx, struct ldb_parse_tree **new, const struct ldb_parse_tree *tree)
+{
+        int i, j, ret=0;
+        unsigned int i, j;
+        int ret=0;
         /* Prepare new tree */
 …
 static int map_subtree_collect_remote_list(struct ldb_module *module, void *mem_ctx, struct ldb_parse_tree **new, const struct ldb_parse_tree *tree)
+{
+        int i, j, ret=0;
+        unsigned int i, j;
+        int ret=0;
         /* Prepare new tree */
 …
         **new = *tree;
         if (map->type == MAP_KEEP) {
+        if (map->type == LDB_MAP_KEEP) {
                 /* Nothing to do here */
                 return 0;
 …
+        }
         if (map->type == MAP_RENAME) {
+        if (map->type == LDB_MAP_RENAME) {
                 /* Nothing more to do here, the attribute has been renamed */
                 return 0;
 …
+        }
         if (map->type == MAP_GENERATE) {
+        if (map->type == LDB_MAP_GENERATE) {
                 ldb_debug(ldb, LDB_DEBUG_WARNING, "ldb_map: "
                           "Skipping attribute '%s': "
 …
         const char * const *attrs;
         struct ldb_context *ldb;
+        int i;
+        unsigned int i;
+        int ret;
+        bool matched;
         ldb = ldb_module_get_ctx(ac->module);
         /* Merged result doesn't match original query, skip */
+        if (!ldb_match_msg(ldb, ares->message,
+                           ac->req->op.search.tree,
+                           ac->req->op.search.base,
+                           ac->req->op.search.scope)) {
+        ret = ldb_match_msg_error(ldb, ares->message,
+                                  ac->req->op.search.tree,
+                                  ac->req->op.search.base,
+                                  ac->req->op.search.scope,
+                                  &matched);
+        if (ret != LDB_SUCCESS) return ret;
+        if (!matched) {
                 ldb_debug(ldb, LDB_DEBUG_TRACE, "ldb_map: "
                           "Skipping record '%s': "
 …
 /* Search a record. */
 int map_search(struct ldb_module *module, struct ldb_request *req)
+int ldb_map_search(struct ldb_module *module, struct ldb_request *req)
+{
         struct ldb_parse_tree *remote_tree;
 …
                                       ac, map_remote_search_callback,
                                       req);
+        LDB_REQ_SET_LOCATION(remote_req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
+                }
                 talloc_free(ares);
+                ac->remote_done_ares = talloc_steal(ac, ares);
                 ret = map_search_local(ac);
 …
         case LDB_REPLY_DONE:
+                /* We don't need the local 'ares', but we will use the remote one from below */
                 talloc_free(ares);
 …
                  * finish operations for this module */
                 return ldb_module_done(ac->req,
                                         ac->r_current->remote->controls,
                                         ac->r_current->remote->response,
                                         ac->r_current->remote->error);
+                                        ac->remote_done_ares->controls,
+                                        ac->remote_done_ares->response,
+                                        ac->remote_done_ares->error);
+        }

trunk/server/source4/lib/ldb/ldb_map/ldb_map_private.h

-              r414
+              r745
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 /* A handy macro to report Out of Memory conditions */
 …
         struct map_reply *r_list;
         struct map_reply *r_current;
+        /* The response continaing any controls the remote server gave */
+        struct ldb_reply *remote_done_ares;
 };

trunk/server/source4/lib/ldb/ldb_sqlite3/ldb_sqlite3.c

-              r414
+              r745
         char *ret = NULL;
         char *attr;
         int i;
+        unsigned int i;
         ldb = ldb_module_get_ctx(module);
 …
 /*
  * This is a bad hack to support ldap style comparisons whithin sqlite.
+ * This is a bad hack to support ldap style comparisons within sqlite.
  * val is the attribute in the row currently under test
  * func is the desired test "<=" ">=" "~" ":"
 …
         struct ldb_message *msg;
         long long eid;
+        int i, ret;
+        unsigned int i;
+        int ret;
         ac = talloc_get_type(result, struct lsql_context);
 …
                  * except the first time */
                 if (ac->current_eid != 0) {
+                        msg = ldb_msg_canonicalize(ldb, msg);
+                        if (!msg) return SQLITE_ABORT;
+                        ret = ldb_msg_normalize(ldb, ac->req, msg, &msg);
+                        if (ret != LDB_SUCCESS) {
+                                return SQLITE_ABORT;
+                        }
                         ret = ldb_module_send_entry(ac->req, msg, NULL);
                         if (ret != LDB_SUCCESS) {
                                 ac->callback_failed = true;
+                                /* free msg object */
+                                TALLOC_FREE(msg);
                                 return SQLITE_ABORT;
+                        }
+                        /* free msg object */
+                        TALLOC_FREE(msg);
+                }
 …
         /* complete the last message if any */
         if (ctx->ares) {
+                ctx->ares->message = ldb_msg_canonicalize(ldb, ctx->ares->message);
+                if (ctx->ares->message == NULL) {
+                ret = ldb_msg_normalize(ldb, ctx->ares,
+                                        ctx->ares->message,
+                                        &ctx->ares->message);
+                if (ret != LDB_SUCCESS) {
                         return LDB_ERR_OPERATIONS_ERROR;
+                }
 …
         char *errmsg;
         char *query;
         int i;
+        unsigned int i;
         int ret;
 …
                 const struct ldb_schema_attribute *a;
                 char *attr;
                 int j;
+                unsigned int j;
                 /* Get a case-folded copy of the attribute name */
 …
                 a = ldb_schema_attribute_by_name(ldb, el->name);
+                if (el->num_value == 0) {
+                        ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illegal)",
+                                               el->name, ldb_dn_get_linearized(msg->dn));
+                        return LDB_ERR_CONSTRAINT_VIOLATION;
+                }
                 /* For each value of the specified attribute name... */
 …
         struct ldb_context *ldb;
         struct ldb_message *msg = req->op.mod.message;
         long long eid;
+        long long eid;
         char *errmsg;
         int i;
+        unsigned int i;
         int ret;
 …
                 char *attr;
                 char *mod;
                 int j;
+                unsigned int j;
                 /* Get a case-folded copy of the attribute name */
 …
                 case LDB_FLAG_MOD_REPLACE:
+                        for (j=0; j<el->num_values; j++) {
+                                if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+                                        ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
+                                        return LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                }
+                        }
                         /* remove all attributes before adding the replacements */
 …
                 case LDB_FLAG_MOD_ADD:
+#warning "We should throw an error if no value is provided!"
+                        if (el->num_values == 0) {
+                                ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illigal)",
+                                                       el->name, ldb_dn_get_linearized(msg->dn));
+                                return LDB_ERR_CONSTRAINT_VIOLATION;
+                        }
                         /* For each value of the specified attribute name... */
                         for (j = 0; j < el->num_values; j++) {
 …
         default:
                 /* no other op supported */
                 ret = LDB_ERR_UNWILLING_TO_PERFORM;
+                ret = LDB_ERR_PROTOCOL_ERROR;
+        }
 …
         struct timeval tv;
         if (check_critical_controls(req->controls)) {
+        if (ldb_check_critical_controls(req->controls)) {
                 return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+        }
 …
         struct ldb_module *module;
         struct lsqlite3_private *lsqlite3;
+        int i, ret;
+        unsigned int i;
+        int ret;
         module = ldb_module_new(ldb, ldb, "ldb_sqlite3 backend", &lsqlite3_ops);
         if (!module) return -1;
+        if (!module) return LDB_ERR_OPERATIONS_ERROR;
         lsqlite3 = talloc(module, struct lsqlite3_private);
 …
         *_module = module;
         return 0;
+        return LDB_SUCCESS;
 failed:
 …
+        }
         talloc_free(lsqlite3);
+        return -1;
+}
+const struct ldb_backend_ops ldb_sqlite3_backend_ops = {
+        .name = "sqlite3",
+        .connect_fn = lsqlite3_connect
+};
+        return LDB_ERR_OPERATIONS_ERROR;
+}
+int ldb_sqlite3_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_backend("sqlite3", lsqlite3_connect, false);
+}

trunk/server/source4/lib/ldb/ldb_tdb/ldb_cache.c

-              r414
+              r745
         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
         struct ldb_message *msg;
         int i;
+        unsigned int i;
         ldb = ldb_module_get_ctx(module);
 …
 static int ltdb_attributes_flags(struct ldb_message_element *el, unsigned *v)
+{
         int i;
+        unsigned int i;
         unsigned value = 0;
         for (i=0;i<el->num_values;i++) {
                 int j;
+                unsigned int j;
                 for (j=0;ltdb_valid_attr_flags[j].name;j++) {
                         if (strcmp(ltdb_valid_attr_flags[j].name,
 …
         struct ldb_message *msg = ltdb->cache->attributes;
         struct ldb_dn *dn;
+        int i, r;
+        unsigned int i;
+        int r;
         ldb = ldb_module_get_ctx(module);
 …
                 /* we skip loading the @ATTRIBUTES record when a module is supplying
                    its own attribute handling */
                 return LDB_SUCCESS;
+                return 0;
+        }
 …
         ltdb->sequence_number = atof(initial_sequence_number);
         msg = talloc(ltdb, struct ldb_message);
+        msg = ldb_msg_new(ltdb);
         if (msg == NULL) {
                 goto failed;
 …
                 ltdb->cache = talloc_zero(ltdb, struct ltdb_cache);
                 if (ltdb->cache == NULL) goto failed;
                 ltdb->cache->indexlist = talloc_zero(ltdb->cache, struct ldb_message);
                 ltdb->cache->attributes = talloc_zero(ltdb->cache, struct ldb_message);
+                ltdb->cache->indexlist = ldb_msg_new(ltdb->cache);
+                ltdb->cache->attributes = ldb_msg_new(ltdb->cache);
                 if (ltdb->cache->indexlist == NULL ||
                     ltdb->cache->attributes == NULL) {
 …
+        }
         baseinfo = talloc(ltdb->cache, struct ldb_message);
+        baseinfo = ldb_msg_new(ltdb->cache);
         if (baseinfo == NULL) goto failed;
         baseinfo_dn = ldb_dn_new(module, ldb, LTDB_BASEINFO);
+        baseinfo_dn = ldb_dn_new(baseinfo, ldb, LTDB_BASEINFO);
         if (baseinfo_dn == NULL) goto failed;
 …
         /* Read an interpret database options */
         options = talloc(ltdb->cache, struct ldb_message);
+        options = ldb_msg_new(ltdb->cache);
         if (options == NULL) goto failed;
 …
         memset(&ltdb->cache->last_attribute, 0, sizeof(ltdb->cache->last_attribute));
-        ltdb_attributes_unload(module);
         talloc_free(ltdb->cache->indexlist);
+        ltdb->cache->indexlist = talloc_zero(ltdb->cache, struct ldb_message);
+        ltdb->cache->attributes = talloc_zero(ltdb->cache, struct ldb_message);
+        ltdb_attributes_unload(module); /* calls internally "talloc_free" */
+        ltdb->cache->indexlist = ldb_msg_new(ltdb->cache);
+        ltdb->cache->attributes = ldb_msg_new(ltdb->cache);
         if (ltdb->cache->indexlist == NULL ||
             ltdb->cache->attributes == NULL) {
                 goto failed;
+        }
+        ltdb->cache->one_level_indexes = false;
+        ltdb->cache->attribute_indexes = false;
         indexlist_dn = ldb_dn_new(module, ldb, LTDB_INDEXLIST);
 …
+        }
+        if (ldb_msg_find_element(ltdb->cache->indexlist, LTDB_IDXONE) != NULL) {
+                ltdb->cache->one_level_indexes = true;
+        }
+        if (ldb_msg_find_element(ltdb->cache->indexlist, LTDB_IDXATTR) != NULL) {
+                ltdb->cache->attribute_indexes = true;
+        }
         if (ltdb_attributes_load(module) == -1) {
                 goto failed;
 …
         talloc_free(options);
         talloc_free(baseinfo);
-        talloc_free(baseinfo_dn);
         talloc_free(indexlist_dn);
         return 0;
 …
         talloc_free(options);
         talloc_free(baseinfo);
-        talloc_free(baseinfo_dn);
         talloc_free(indexlist_dn);
         return -1;
 …
         ldb = ldb_module_get_ctx(module);
         msg = talloc(ltdb, struct ldb_message);
+        msg = ldb_msg_new(ltdb);
         if (msg == NULL) {
                 errno = ENOMEM;
 …
         s = talloc_asprintf(msg, "%llu", ltdb->sequence_number+1);
         if (!s) {
+                talloc_free(msg);
                 errno = ENOMEM;
                 return LDB_ERR_OPERATIONS_ERROR;
 …
         s = ldb_timestring(msg, t);
         if (s == NULL) {
+                talloc_free(msg);
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
         val_time.length = strlen(s);
         ret = ltdb_modify_internal(module, msg);
+        ret = ltdb_modify_internal(module, msg, NULL);
         talloc_free(msg);
 …
 int ltdb_check_at_attributes_values(const struct ldb_val *value)
+{
         int i;
+        unsigned int i;
         for (i = 0; ltdb_valid_attr_flags[i].name != NULL; i++) {

trunk/server/source4/lib/ldb/ldb_tdb/ldb_index.c

-              r414
+              r745
    ldb database library
    Copyright (C) Andrew Tridgell  2004
+   Copyright (C) Andrew Tridgell  2004-2009
      ** NOTE! The following LGPL license applies to the ldb
 …
 #include "ldb_tdb.h"
+#include "dlinklist.h"
+/*
+  the idxptr code is a bit unusual. The way it works is to replace
+  @IDX elements in records during a transaction with @IDXPTR
+  elements. The @IDXPTR elements don't contain the actual index entry
+  values, but contain a pointer to a linked list of values.
+  This means we are storing pointers in a database, which is normally
+  not allowed, but in this case we are storing them only for the
+  duration of a transaction, and re-writing them into the normal @IDX
+  format at the end of the transaction. That means no other processes
+  are ever exposed to the @IDXPTR values.
+  The advantage is that the linked list doesn't cause huge
+  fragmentation during a transaction. Without the @IDXPTR method we
+  often ended up with a ldb that was between 10x and 100x larger then
+  it needs to be due to massive fragmentation caused by re-writing
+  @INDEX records many times during indexing.
+ */
+struct ldb_index_pointer {
+        struct ldb_index_pointer *next, *prev;
+        struct ldb_val value;
+struct dn_list {
+        unsigned int count;
+        struct ldb_val *dn;
 };
 struct ltdb_idxptr {
+        int num_dns;
+        const char **dn_list;
+        bool repack;
+        struct tdb_context *itdb;
+        int error;
 };
+/*
+  add to the list of DNs that need to be fixed on transaction end
+ */
+static int ltdb_idxptr_add(struct ldb_module *module, const struct ldb_message *msg)
+{
+        void *data = ldb_module_get_private(module);
+        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+        ltdb->idxptr->dn_list = talloc_realloc(ltdb->idxptr, ltdb->idxptr->dn_list,
+                                               const char *, ltdb->idxptr->num_dns+1);
+        if (ltdb->idxptr->dn_list == NULL) {
+                ltdb->idxptr->num_dns = 0;
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ltdb->idxptr->dn_list[ltdb->idxptr->num_dns] =
+                talloc_strdup(ltdb->idxptr->dn_list, ldb_dn_get_linearized(msg->dn));
+        if (ltdb->idxptr->dn_list[ltdb->idxptr->num_dns] == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ltdb->idxptr->num_dns++;
+        return LDB_SUCCESS;
+}
+/* free an idxptr record */
+static int ltdb_free_idxptr(struct ldb_module *module, struct ldb_message_element *el)
+{
+        struct ldb_val val;
+        struct ldb_index_pointer *ptr;
+        if (el->num_values != 1) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        val = el->values[0];
+        if (val.length != sizeof(void *)) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ptr = *(struct ldb_index_pointer **)val.data;
+        if (talloc_get_type(ptr, struct ldb_index_pointer) != ptr) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        while (ptr) {
+                struct ldb_index_pointer *tmp = ptr;
+                DLIST_REMOVE(ptr, ptr);
+                talloc_free(tmp);
+        }
+        return LDB_SUCCESS;
+}
+/* convert from the IDXPTR format to a ldb_message_element format */
+static int ltdb_convert_from_idxptr(struct ldb_module *module, struct ldb_message_element *el)
+{
+        struct ldb_val val;
+        struct ldb_index_pointer *ptr, *tmp;
+        int i;
+        struct ldb_val *val2;
+        if (el->num_values != 1) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        val = el->values[0];
+        if (val.length != sizeof(void *)) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ptr = *(struct ldb_index_pointer **)val.data;
+        if (talloc_get_type(ptr, struct ldb_index_pointer) != ptr) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        /* count the length of the list */
+        for (i=0, tmp = ptr; tmp; tmp=tmp->next) {
+                i++;
+        }
+        /* allocate the new values array */
+        val2 = talloc_realloc(NULL, el->values, struct ldb_val, i);
+        if (val2 == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        el->values = val2;
+        el->num_values = i;
+        /* populate the values array */
+        for (i=0, tmp = ptr; tmp; tmp=tmp->next, i++) {
+                el->values[i].length = tmp->value.length;
+                /* we need to over-allocate here as there are still some places
+                   in ldb that rely on null termination. */
+                el->values[i].data = talloc_size(el->values, tmp->value.length+1);
+                if (el->values[i].data == NULL) {
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                memcpy(el->values[i].data, tmp->value.data, tmp->value.length);
+                el->values[i].data[tmp->value.length] = 0;
+        }
+        /* update the name */
+        el->name = LTDB_IDX;
+        return LDB_SUCCESS;
+}
+/* convert to the IDXPTR format from a ldb_message_element format */
+static int ltdb_convert_to_idxptr(struct ldb_module *module, struct ldb_message_element *el)
+{
+        struct ldb_index_pointer *ptr, *tmp;
+        int i;
+        struct ldb_val *val2;
+        void *data = ldb_module_get_private(module);
+        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+        ptr = NULL;
+        for (i=0;i<el->num_values;i++) {
+                tmp = talloc(ltdb->idxptr, struct ldb_index_pointer);
+                if (tmp == NULL) {
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                tmp->value = el->values[i];
+                tmp->value.data = talloc_memdup(tmp, tmp->value.data, tmp->value.length);
+                if (tmp->value.data == NULL) {
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                DLIST_ADD(ptr, tmp);
+        }
+        /* allocate the new values array */
+        val2 = talloc_realloc(NULL, el->values, struct ldb_val, 1);
+        if (val2 == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        el->values = val2;
+        el->num_values = 1;
+        el->values[0].data = talloc_memdup(el->values, &ptr, sizeof(ptr));
+        el->values[0].length = sizeof(ptr);
+        /* update the name */
+        el->name = LTDB_IDXPTR;
+        return LDB_SUCCESS;
+}
+/* we put a @IDXVERSION attribute on index entries. This
+   allows us to tell if it was written by an older version
+*/
+#define LTDB_INDEXING_VERSION 2
 /* enable the idxptr mode when transactions start */
 int ltdb_index_transaction_start(struct ldb_module *module)
+{
+        void *data = ldb_module_get_private(module);
+        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+        ltdb->idxptr = talloc_zero(module, struct ltdb_idxptr);
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        ltdb->idxptr = talloc_zero(ltdb, struct ltdb_idxptr);
         return LDB_SUCCESS;
+}
+/*
+  a wrapper around ltdb_search_dn1() which translates pointer based index records
+  and maps them into normal ldb message structures
+ */
+static int ltdb_search_dn1_index(struct ldb_module *module,
+                                struct ldb_dn *dn, struct ldb_message *msg)
+{
+        int ret, i;
+/* compare two DN entries in a dn_list. Take account of possible
+ * differences in string termination */
+static int dn_list_cmp(const struct ldb_val *v1, const struct ldb_val *v2)
+{
+        if (v1->length > v2->length && v1->data[v2->length] != 0) {
+                return -1;
+        }
+        if (v1->length < v2->length && v2->data[v1->length] != 0) {
+                return 1;
+        }
+        return strncmp((char *)v1->data, (char *)v2->data, v1->length);
+}
+/*
+  find a entry in a dn_list, using a ldb_val. Uses a case sensitive
+  comparison with the dn returns -1 if not found
+ */
+static int ltdb_dn_list_find_val(const struct dn_list *list, const struct ldb_val *v)
+{
+        unsigned int i;
+        for (i=0; i<list->count; i++) {
+                if (dn_list_cmp(&list->dn[i], v) == 0) return i;
+        }
+        return -1;
+}
+/*
+  find a entry in a dn_list. Uses a case sensitive comparison with the dn
+  returns -1 if not found
+ */
+static int ltdb_dn_list_find_str(struct dn_list *list, const char *dn)
+{
+        struct ldb_val v;
+        v.data = discard_const_p(unsigned char, dn);
+        v.length = strlen(dn);
+        return ltdb_dn_list_find_val(list, &v);
+}
+/*
+  this is effectively a cast function, but with lots of paranoia
+  checks and also copes with CPUs that are fussy about pointer
+  alignment
+ */
+static struct dn_list *ltdb_index_idxptr(struct ldb_module *module, TDB_DATA rec, bool check_parent)
+{
+        struct dn_list *list;
+        if (rec.dsize != sizeof(void *)) {
+                ldb_asprintf_errstring(ldb_module_get_ctx(module),
+                                       "Bad data size for idxptr %u", (unsigned)rec.dsize);
+                return NULL;
+        }
+        /* note that we can't just use a cast here, as rec.dptr may
+           not be aligned sufficiently for a pointer. A cast would cause
+           platforms like some ARM CPUs to crash */
+        memcpy(&list, rec.dptr, sizeof(void *));
+        list = talloc_get_type(list, struct dn_list);
+        if (list == NULL) {
+                ldb_asprintf_errstring(ldb_module_get_ctx(module),
+                                       "Bad type '%s' for idxptr",
+                                       talloc_get_name(list));
+                return NULL;
+        }
+        if (check_parent && list->dn && talloc_parent(list->dn) != list) {
+                ldb_asprintf_errstring(ldb_module_get_ctx(module),
+                                       "Bad parent '%s' for idxptr",
+                                       talloc_get_name(talloc_parent(list->dn)));
+                return NULL;
+        }
+        return list;
+}
+/*
+  return the @IDX list in an index entry for a dn as a
+  struct dn_list
+ */
+static int ltdb_dn_list_load(struct ldb_module *module,
+                             struct ldb_dn *dn, struct dn_list *list)
+{
+        struct ldb_message *msg;
+        int ret;
+        struct ldb_message_element *el;
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        TDB_DATA rec;
+        struct dn_list *list2;
+        TDB_DATA key;
+        list->dn = NULL;
+        list->count = 0;
+        /* see if we have any in-memory index entries */
+        if (ltdb->idxptr == NULL ||
+            ltdb->idxptr->itdb == NULL) {
+                goto normal_index;
+        }
+        key.dptr = discard_const_p(unsigned char, ldb_dn_get_linearized(dn));
+        key.dsize = strlen((char *)key.dptr);
+        rec = tdb_fetch(ltdb->idxptr->itdb, key);
+        if (rec.dptr == NULL) {
+                goto normal_index;
+        }
+        /* we've found an in-memory index entry */
+        list2 = ltdb_index_idxptr(module, rec, true);
+        if (list2 == NULL) {
+                free(rec.dptr);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        free(rec.dptr);
+        *list = *list2;
+        return LDB_SUCCESS;
+normal_index:
+        msg = ldb_msg_new(list);
+        if (msg == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         ret = ltdb_search_dn1(module, dn, msg);
         if (ret != LDB_SUCCESS) {
+                talloc_free(msg);
                 return ret;
+        }
+        /* if this isn't a @INDEX record then don't munge it */
+        if (strncmp(ldb_dn_get_linearized(msg->dn), LTDB_INDEX ":", strlen(LTDB_INDEX) + 1) != 0) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        for (i=0;i<msg->num_elements;i++) {
+                struct ldb_message_element *el = &msg->elements[i];
+                if (strcmp(el->name, LTDB_IDXPTR) == 0) {
+                        ret = ltdb_convert_from_idxptr(module, el);
+                        if (ret != LDB_SUCCESS) {
+                                return ret;
+                        }
+                }
+        }
+        return ret;
+}
+/*
+  fixup the idxptr for one DN
+ */
+static int ltdb_idxptr_fix_dn(struct ldb_module *module, const char *strdn)
+{
+        struct ldb_context *ldb;
+        struct ldb_dn *dn;
+        struct ldb_message *msg = ldb_msg_new(module);
+        /* TODO: check indexing version number */
+        el = ldb_msg_find_element(msg, LTDB_IDX);
+        if (!el) {
+                talloc_free(msg);
+                return LDB_SUCCESS;
+        }
+        /* we avoid copying the strings by stealing the list */
+        list->dn = talloc_steal(list, el->values);
+        list->count = el->num_values;
+        return LDB_SUCCESS;
+}
+/*
+  save a dn_list into a full @IDX style record
+ */
+static int ltdb_dn_list_store_full(struct ldb_module *module, struct ldb_dn *dn,
+                                   struct dn_list *list)
+{
+        struct ldb_message *msg;
         int ret;
+        ldb = ldb_module_get_ctx(module);
+        dn = ldb_dn_new(msg, ldb, strdn);
+        if (ltdb_search_dn1_index(module, dn, msg) == LDB_SUCCESS) {
+                ret = ltdb_store(module, msg, TDB_REPLACE);
+        }
+        if (list->count == 0) {
+                ret = ltdb_delete_noindex(module, dn);
+                if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                        return LDB_SUCCESS;
+                }
+                return ret;
+        }
+        msg = ldb_msg_new(module);
+        if (!msg) {
+                return ldb_module_oom(module);
+        }
+        ret = ldb_msg_add_fmt(msg, LTDB_IDXVERSION, "%u", LTDB_INDEXING_VERSION);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(msg);
+                return ldb_module_oom(module);
+        }
+        msg->dn = dn;
+        if (list->count > 0) {
+                struct ldb_message_element *el;
+                ret = ldb_msg_add_empty(msg, LTDB_IDX, LDB_FLAG_MOD_ADD, &el);
+                if (ret != LDB_SUCCESS) {
+                        talloc_free(msg);
+                        return ldb_module_oom(module);
+                }
+                el->values = list->dn;
+                el->num_values = list->count;
+        }
+        ret = ltdb_store(module, msg, TDB_REPLACE);
         talloc_free(msg);
         return ret;
+}
+/*
+  save a dn_list into the database, in either @IDX or internal format
+ */
+static int ltdb_dn_list_store(struct ldb_module *module, struct ldb_dn *dn,
+                              struct dn_list *list)
+{
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        TDB_DATA rec, key;
+        int ret;
+        struct dn_list *list2;
+        if (ltdb->idxptr == NULL) {
+                return ltdb_dn_list_store_full(module, dn, list);
+        }
+        if (ltdb->idxptr->itdb == NULL) {
+                ltdb->idxptr->itdb = tdb_open(NULL, 1000, TDB_INTERNAL, O_RDWR, 0);
+                if (ltdb->idxptr->itdb == NULL) {
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+        }
+        key.dptr = discard_const_p(unsigned char, ldb_dn_get_linearized(dn));
+        key.dsize = strlen((char *)key.dptr);
+        rec = tdb_fetch(ltdb->idxptr->itdb, key);
+        if (rec.dptr != NULL) {
+                list2 = ltdb_index_idxptr(module, rec, false);
+                if (list2 == NULL) {
+                        free(rec.dptr);
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                free(rec.dptr);
+                list2->dn = talloc_steal(list2, list->dn);
+                list2->count = list->count;
+                return LDB_SUCCESS;
+        }
+        list2 = talloc(ltdb->idxptr, struct dn_list);
+        if (list2 == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        list2->dn = talloc_steal(list2, list->dn);
+        list2->count = list->count;
+        rec.dptr = (uint8_t *)&list2;
+        rec.dsize = sizeof(void *);
+        ret = tdb_store(ltdb->idxptr->itdb, key, rec, TDB_INSERT);
+        if (ret == -1) {
+                return ltdb_err_map(tdb_error(ltdb->idxptr->itdb));
+        }
+        return LDB_SUCCESS;
+}
+/*
+  traverse function for storing the in-memory index entries on disk
+ */
+static int ltdb_index_traverse_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
+{
+        struct ldb_module *module = state;
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        struct ldb_dn *dn;
+        struct ldb_context *ldb = ldb_module_get_ctx(module);
+        struct ldb_val v;
+        struct dn_list *list;
+        list = ltdb_index_idxptr(module, data, true);
+        if (list == NULL) {
+                ltdb->idxptr->error = LDB_ERR_OPERATIONS_ERROR;
+                return -1;
+        }
+        v.data = key.dptr;
+        v.length = strnlen((char *)key.dptr, key.dsize);
+        dn = ldb_dn_from_ldb_val(module, ldb, &v);
+        if (dn == NULL) {
+                ldb_asprintf_errstring(ldb, "Failed to parse index key %*.*s as an LDB DN", (int)v.length, (int)v.length, (const char *)v.data);
+                ltdb->idxptr->error = LDB_ERR_OPERATIONS_ERROR;
+                return -1;
+        }
+        ltdb->idxptr->error = ltdb_dn_list_store_full(module, dn, list);
+        talloc_free(dn);
+        if (ltdb->idxptr->error != 0) {
+                return -1;
+        }
+        return 0;
+}
 /* cleanup the idxptr mode when transaction commits */
 int ltdb_index_transaction_commit(struct ldb_module *module)
+{
+        int i;
+        void *data = ldb_module_get_private(module);
+        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+        /* fix all the DNs that we have modified */
+        if (ltdb->idxptr) {
+                for (i=0;i<ltdb->idxptr->num_dns;i++) {
+                        ltdb_idxptr_fix_dn(module, ltdb->idxptr->dn_list[i]);
+                }
+                if (ltdb->idxptr->repack) {
+                        tdb_repack(ltdb->tdb);
+                }
+        }
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        int ret;
+        struct ldb_context *ldb = ldb_module_get_ctx(module);
+        ldb_reset_err_string(ldb);
+        if (ltdb->idxptr->itdb) {
+                tdb_traverse(ltdb->idxptr->itdb, ltdb_index_traverse_store, module);
+                tdb_close(ltdb->idxptr->itdb);
+        }
+        ret = ltdb->idxptr->error;
+        if (ret != LDB_SUCCESS) {
+                if (!ldb_errstring(ldb)) {
+                        ldb_set_errstring(ldb, ldb_strerror(ret));
+                }
+                ldb_asprintf_errstring(ldb, "Failed to store index records in transaction commit: %s", ldb_errstring(ldb));
+        }
+        talloc_free(ltdb->idxptr);
+        ltdb->idxptr = NULL;
+        return ret;
+}
+/* cleanup the idxptr mode when transaction cancels */
+int ltdb_index_transaction_cancel(struct ldb_module *module)
+{
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        if (ltdb->idxptr && ltdb->idxptr->itdb) {
+                tdb_close(ltdb->idxptr->itdb);
+        }
         talloc_free(ltdb->idxptr);
         ltdb->idxptr = NULL;
 …
+}
-/* cleanup the idxptr mode when transaction cancels */
-int ltdb_index_transaction_cancel(struct ldb_module *module)
+{
-        void *data = ldb_module_get_private(module);
-        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
-        talloc_free(ltdb->idxptr);
-        ltdb->idxptr = NULL;
-        return LDB_SUCCESS;
+}
-/* a wrapper around ltdb_store() for the index code which
-   stores in IDXPTR format when idxptr mode is enabled
-   WARNING: This modifies the msg which is passed in
-*/
-int ltdb_store_idxptr(struct ldb_module *module, const struct ldb_message *msg, int flgs)
+{
-        void *data = ldb_module_get_private(module);
-        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
-        int ret;
-        if (ltdb->idxptr) {
-                int i;
-                struct ldb_message *msg2 = ldb_msg_new(module);
-                /* free any old pointer */
-                ret = ltdb_search_dn1(module, msg->dn, msg2);
-                if (ret == 0) {
-                        for (i=0;i<msg2->num_elements;i++) {
-                                struct ldb_message_element *el = &msg2->elements[i];
-                                if (strcmp(el->name, LTDB_IDXPTR) == 0) {
-                                        ret = ltdb_free_idxptr(module, el);
-                                        if (ret != LDB_SUCCESS) {
-                                                return ret;
+                                        }
+                                }
+                        }
+                }
-                talloc_free(msg2);
-                for (i=0;i<msg->num_elements;i++) {
-                        struct ldb_message_element *el = &msg->elements[i];
-                        if (strcmp(el->name, LTDB_IDX) == 0) {
-                                ret = ltdb_convert_to_idxptr(module, el);
-                                if (ret != LDB_SUCCESS) {
-                                        return ret;
+                                }
+                        }
+                }
-                if (ltdb_idxptr_add(module, msg) != 0) {
-                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+        }
-        ret = ltdb_store(module, msg, flgs);
-        return ret;
+}
-/*
-  find an element in a list, using the given comparison function and
-  assuming that the list is already sorted using comp_fn
-  return -1 if not found, or the index of the first occurance of needle if found
-*/
-static int ldb_list_find(const void *needle,
-                         const void *base, size_t nmemb, size_t size,
-                         comparison_fn_t comp_fn)
+{
-        const char *base_p = (const char *)base;
-        size_t min_i, max_i, test_i;
-        if (nmemb == 0) {
-                return -1;
+        }
-        min_i = 0;
-        max_i = nmemb-1;
-        while (min_i < max_i) {
-                int r;
-                test_i = (min_i + max_i) / 2;
-                /* the following cast looks strange, but is
-                 correct. The key to understanding it is that base_p
-                 is a pointer to an array of pointers, so we have to
-                 dereference it after casting to void **. The strange
-                 const in the middle gives us the right type of pointer
-                 after the dereference  (tridge) */
-                r = comp_fn(needle, *(void * const *)(base_p + (size * test_i)));
-                if (r == 0) {
-                        /* scan back for first element */
-                        while (test_i > 0 &&
-                               comp_fn(needle, *(void * const *)(base_p + (size * (test_i-1)))) == 0) {
-                                test_i--;
+                        }
-                        return test_i;
+                }
-                if (r < 0) {
-                        if (test_i == 0) {
-                                return -1;
+                        }
-                        max_i = test_i - 1;
+                }
-                if (r > 0) {
-                        min_i = test_i + 1;
+                }
+        }
-        if (comp_fn(needle, *(void * const *)(base_p + (size * min_i))) == 0) {
-                return min_i;
+        }
-        return -1;
+}
-struct dn_list {
-        unsigned int count;
-        char **dn;
-};
 /*
   return the dn key to be used for an index
   caller frees
+  the caller is responsible for freeing
 */
 static struct ldb_dn *ltdb_index_key(struct ldb_context *ldb,
 …
         if (ldb_should_b64_encode(ldb, &v)) {
                 char *vstr = ldb_base64_encode(ldb, (char *)v.data, v.length);
+                if (!vstr) return NULL;
+                if (!vstr) {
+                        talloc_free(attr_folded);
+                        return NULL;
+                }
                 ret = ldb_dn_new_fmt(ldb, ldb, "%s:%s::%s", LTDB_INDEX, attr_folded, vstr);
                 talloc_free(vstr);
 …
   see if a attribute value is in the list of indexed attributes
 */
+static int ldb_msg_find_idx(const struct ldb_message *msg, const char *attr,
+                            unsigned int *v_idx, const char *key)
+{
+        unsigned int i, j;
+        for (i=0;i<msg->num_elements;i++) {
+                if (ldb_attr_cmp(msg->elements[i].name, key) == 0) {
+                        const struct ldb_message_element *el = &msg->elements[i];
+                        if (attr == NULL) {
+                                /* in this case we are just looking to see if key is present,
+                                   we are not spearching for a specific index */
+                                return 0;
+                        }
+                        for (j=0;j<el->num_values;j++) {
+                                if (ldb_attr_cmp((char *)el->values[j].data, attr) == 0) {
+                                        if (v_idx) {
+                                                *v_idx = j;
+                                        }
+                                        return i;
+                                }
+                        }
+                }
+        }
+        return -1;
+}
+/* used in sorting dn lists */
+static int list_cmp(const char **s1, const char **s2)
+{
+        return strcmp(*s1, *s2);
+}
+/*
+  return a list of dn's that might match a simple indexed search or
+static bool ltdb_is_indexed(const struct ldb_message *index_list, const char *attr)
+{
+        unsigned int i;
+        struct ldb_message_element *el;
+        el = ldb_msg_find_element(index_list, LTDB_IDXATTR);
+        if (el == NULL) {
+                return false;
+        }
+        /* TODO: this is too expensive! At least use a binary search */
+        for (i=0; i<el->num_values; i++) {
+                if (ldb_attr_cmp((char *)el->values[i].data, attr) == 0) {
+                        return true;
+                }
+        }
+        return false;
+}
+/*
+  in the following logic functions, the return value is treated as
+  follows:
+     LDB_SUCCESS: we found some matching index values
+     LDB_ERR_NO_SUCH_OBJECT: we know for sure that no object matches
+     LDB_ERR_OPERATIONS_ERROR: indexing could not answer the call,
+                               we'll need a full search
+ */
+/*
+  return a list of dn's that might match a simple indexed search (an
+  equality search only)
  */
 static int ltdb_index_dn_simple(struct ldb_module *module,
 …
         struct ldb_dn *dn;
         int ret;
-        unsigned int i, j;
-        struct ldb_message *msg;
         ldb = ldb_module_get_ctx(module);
 …
         /* if the attribute isn't in the list of indexed attributes then
            this node needs a full search */
         if (ldb_msg_find_idx(index_list, tree->u.equality.attr, NULL, LTDB_IDXATTR) == -1) {
+        if (!ltdb_is_indexed(index_list, tree->u.equality.attr)) {
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
         if (!dn) return LDB_ERR_OPERATIONS_ERROR;
+        msg = talloc(list, struct ldb_message);
+        if (msg == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ltdb_search_dn1_index(module, dn, msg);
+        ret = ltdb_dn_list_load(module, dn, list);
         talloc_free(dn);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        for (i=0;i<msg->num_elements;i++) {
+                struct ldb_message_element *el;
+                if (strcmp(msg->elements[i].name, LTDB_IDX) != 0) {
+                        continue;
+                }
+                el = &msg->elements[i];
+                list->dn = talloc_array(list, char *, el->num_values);
+                if (!list->dn) {
+                        talloc_free(msg);
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                for (j=0;j<el->num_values;j++) {
+                        list->dn[list->count] =
+                                talloc_strdup(list->dn, (char *)el->values[j].data);
+                        if (!list->dn[list->count]) {
+                                talloc_free(msg);
+                                return LDB_ERR_OPERATIONS_ERROR;
+                        }
+                        list->count++;
+                }
+        }
+        talloc_free(msg);
+        if (list->count > 1) {
+                qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) list_cmp);
+        }
+        return LDB_SUCCESS;
+}
+static int list_union(struct ldb_context *, struct dn_list *, const struct dn_list *);
+        return ret;
+}
+static bool list_union(struct ldb_context *, struct dn_list *, const struct dn_list *);
 /*
 …
                               struct dn_list *list)
+{
-        struct ldb_context *ldb;
-        ldb = ldb_module_get_ctx(module);
         if (ldb_attr_dn(tree->u.equality.attr) == 0) {
                 list->dn = talloc_array(list, char *, 1);
+                list->dn = talloc_array(list, struct ldb_val, 1);
                 if (list->dn == NULL) {
                         ldb_oom(ldb);
+                        ldb_module_oom(module);
                         return LDB_ERR_OPERATIONS_ERROR;
+                }
+                list->dn[0] = talloc_strdup(list->dn, (char *)tree->u.equality.value.data);
+                if (list->dn[0] == NULL) {
+                        ldb_oom(ldb);
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                list->dn[0] = tree->u.equality.value;
                 list->count = 1;
                 return LDB_SUCCESS;
 …
   list intersection
   list = list & list2
+  relies on the lists being sorted
+*/
+static int list_intersect(struct ldb_context *ldb,
+                          struct dn_list *list, const struct dn_list *list2)
+*/
+static bool list_intersect(struct ldb_context *ldb,
+                           struct dn_list *list, const struct dn_list *list2)
+{
         struct dn_list *list3;
         unsigned int i;
         if (list->count == 0 || list2->count == 0) {
+        if (list->count == 0) {
                 /* 0 & X == 0 */
+                return LDB_ERR_NO_SUCH_OBJECT;
+        }
+        list3 = talloc(ldb, struct dn_list);
+                return true;
+        }
+        if (list2->count == 0) {
+                /* X & 0 == 0 */
+                list->count = 0;
+                list->dn = NULL;
+                return true;
+        }
+        /* the indexing code is allowed to return a longer list than
+           what really matches, as all results are filtered by the
+           full expression at the end - this shortcut avoids a lot of
+           work in some cases */
+        if (list->count < 2 && list2->count > 10) {
+                return true;
+        }
+        if (list2->count < 2 && list->count > 10) {
+                list->count = list2->count;
+                list->dn = list2->dn;
+                /* note that list2 may not be the parent of list2->dn,
+                   as list2->dn may be owned by ltdb->idxptr. In that
+                   case we expect this reparent call to fail, which is
+                   OK */
+                talloc_reparent(list2, list, list2->dn);
+                return true;
+        }
+        list3 = talloc_zero(list, struct dn_list);
         if (list3 == NULL) {
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
         list3->dn = talloc_array(list3, char *, list->count);
+                return false;
+        }
+        list3->dn = talloc_array(list3, struct ldb_val, list->count);
         if (!list3->dn) {
                 talloc_free(list3);
                 return LDB_ERR_OPERATIONS_ERROR;
+                return false;
+        }
         list3->count = 0;
         for (i=0;i<list->count;i++) {
+                if (ldb_list_find(list->dn[i], list2->dn, list2->count,
+                              sizeof(char *), (comparison_fn_t)strcmp) != -1) {
+                        list3->dn[list3->count] = talloc_move(list3->dn, &list->dn[i]);
+                if (ltdb_dn_list_find_val(list2, &list->dn[i]) != -1) {
+                        list3->dn[list3->count] = list->dn[i];
                         list3->count++;
+                } else {
+                        talloc_free(list->dn[i]);
+                }
+        }
+        talloc_free(list->dn);
+        list->dn = talloc_move(list, &list3->dn);
+                }
+        }
+        list->dn = talloc_steal(list, list3->dn);
         list->count = list3->count;
         talloc_free(list3);
         return LDB_ERR_NO_SUCH_OBJECT;
+        return true;
+}
 …
   list union
   list = list | list2
+  relies on the lists being sorted
+*/
+static int list_union(struct ldb_context *ldb,
+                      struct dn_list *list, const struct dn_list *list2)
+{
+        unsigned int i;
+        char **d;
+        unsigned int count = list->count;
+        if (list->count == 0 && list2->count == 0) {
+                /* 0 | 0 == 0 */
+                return LDB_ERR_NO_SUCH_OBJECT;
+        }
+        d = talloc_realloc(list, list->dn, char *, list->count + list2->count);
+        if (!d) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        list->dn = d;
+        for (i=0;i<list2->count;i++) {
+                if (ldb_list_find(list2->dn[i], list->dn, count,
+                              sizeof(char *), (comparison_fn_t)strcmp) == -1) {
+                        list->dn[list->count] = talloc_strdup(list->dn, list2->dn[i]);
+                        if (!list->dn[list->count]) {
+                                return LDB_ERR_OPERATIONS_ERROR;
+                        }
+                        list->count++;
+                }
+        }
+        if (list->count != count) {
+                qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t)list_cmp);
+        }
+        return LDB_ERR_NO_SUCH_OBJECT;
+*/
+static bool list_union(struct ldb_context *ldb,
+                       struct dn_list *list, const struct dn_list *list2)
+{
+        struct ldb_val *dn3;
+        if (list2->count == 0) {
+                /* X | 0 == X */
+                return true;
+        }
+        if (list->count == 0) {
+                /* 0 | X == X */
+                list->count = list2->count;
+                list->dn = list2->dn;
+                /* note that list2 may not be the parent of list2->dn,
+                   as list2->dn may be owned by ltdb->idxptr. In that
+                   case we expect this reparent call to fail, which is
+                   OK */
+                talloc_reparent(list2, list, list2->dn);
+                return true;
+        }
+        dn3 = talloc_array(list, struct ldb_val, list->count + list2->count);
+        if (!dn3) {
+                ldb_oom(ldb);
+                return false;
+        }
+        /* we allow for duplicates here, and get rid of them later */
+        memcpy(dn3, list->dn, sizeof(list->dn[0])*list->count);
+        memcpy(dn3+list->count, list2->dn, sizeof(list2->dn[0])*list2->count);
+        list->dn = dn3;
+        list->count += list2->count;
+        return true;
+}
 …
 /*
   OR two index results
+  process an OR list (a union)
  */
 static int ltdb_index_dn_or(struct ldb_module *module,
 …
         struct ldb_context *ldb;
         unsigned int i;
-        int ret;
         ldb = ldb_module_get_ctx(module);
-        ret = LDB_ERR_OPERATIONS_ERROR;
         list->dn = NULL;
         list->count = 0;
         for (i=0;i<tree->u.list.num_elements;i++) {
+        for (i=0; i<tree->u.list.num_elements; i++) {
                 struct dn_list *list2;
                 int v;
                 list2 = talloc(module, struct dn_list);
+                int ret;
+                list2 = talloc_zero(list, struct dn_list);
                 if (list2 == NULL) {
                         return LDB_ERR_OPERATIONS_ERROR;
+                }
+                v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, list2);
+                if (v == LDB_ERR_NO_SUCH_OBJECT) {
+                        /* 0 || X == X */
+                        if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
+                                ret = v;
+                        }
+                ret = ltdb_index_dn(module, tree->u.list.elements[i], index_list, list2);
+                if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                        /* X || 0 == X */
                         talloc_free(list2);
                         continue;
+                }
+                if (v != LDB_SUCCESS && v != LDB_ERR_NO_SUCH_OBJECT) {
+                        /* 1 || X == 1 */
+                        talloc_free(list->dn);
+                if (ret != LDB_SUCCESS) {
+                        /* X || * == * */
                         talloc_free(list2);
+                        return v;
+                }
+                if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
+                        ret = LDB_SUCCESS;
+                        list->dn = talloc_move(list, &list2->dn);
+                        list->count = list2->count;
+                } else {
+                        if (list_union(ldb, list, list2) == -1) {
+                                talloc_free(list2);
+                                return LDB_ERR_OPERATIONS_ERROR;
+                        }
+                        ret = LDB_SUCCESS;
+                }
+                talloc_free(list2);
+                        return ret;
+                }
+                if (!list_union(ldb, list, list2)) {
+                        talloc_free(list2);
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+        }
 …
+        }
         return ret;
+        return LDB_SUCCESS;
+}
 …
 /*
   AND two index results
+  process an AND expression (intersection)
  */
 static int ltdb_index_dn_and(struct ldb_module *module,
 …
         struct ldb_context *ldb;
         unsigned int i;
         int ret, pass;
+        bool found;
         ldb = ldb_module_get_ctx(module);
-        ret = LDB_ERR_OPERATIONS_ERROR;
         list->dn = NULL;
         list->count = 0;
+        for (pass=0;pass<=1;pass++) {
+                /* in the first pass we only look for unique simple
+                   equality tests, in the hope of avoiding having to look
+                   at any others */
+                bool only_unique = pass==0?true:false;
+                for (i=0;i<tree->u.list.num_elements;i++) {
+                        struct dn_list *list2;
+                        int v;
+                        bool is_unique = false;
+                        const struct ldb_parse_tree *subtree = tree->u.list.elements[i];
+                        if (subtree->operation == LDB_OP_EQUALITY &&
+                            ltdb_index_unique(ldb, subtree->u.equality.attr)) {
+                                is_unique = true;
+                        }
+                        if (is_unique != only_unique) continue;
+        /* in the first pass we only look for unique simple
+           equality tests, in the hope of avoiding having to look
+           at any others */
+        for (i=0; i<tree->u.list.num_elements; i++) {
+                const struct ldb_parse_tree *subtree = tree->u.list.elements[i];
+                int ret;
+                if (subtree->operation != LDB_OP_EQUALITY ||
+                    !ltdb_index_unique(ldb, subtree->u.equality.attr)) {
+                        continue;
+                }
+                ret = ltdb_index_dn(module, subtree, index_list, list);
+                if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                        /* 0 && X == 0 */
+                        return LDB_ERR_NO_SUCH_OBJECT;
+                }
+                if (ret == LDB_SUCCESS) {
+                        /* a unique index match means we can
+                         * stop. Note that we don't care if we return
+                         * a few too many objects, due to later
+                         * filtering */
+                        return LDB_SUCCESS;
+                }
+        }
+        /* now do a full intersection */
+        found = false;
+        for (i=0; i<tree->u.list.num_elements; i++) {
+                const struct ldb_parse_tree *subtree = tree->u.list.elements[i];
+                struct dn_list *list2;
+                int ret;
+                list2 = talloc_zero(list, struct dn_list);
+                if (list2 == NULL) {
+                        return ldb_module_oom(module);
+                }
+                        list2 = talloc(module, struct dn_list);
+                        if (list2 == NULL) {
+                                return LDB_ERR_OPERATIONS_ERROR;
+                        }
+                ret = ltdb_index_dn(module, subtree, index_list, list2);
+                if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                        /* X && 0 == 0 */
+                        list->dn = NULL;
+                        list->count = 0;
+                        talloc_free(list2);
+                        return LDB_ERR_NO_SUCH_OBJECT;
+                }
+                if (ret != LDB_SUCCESS) {
+                        /* this didn't adding anything */
+                        talloc_free(list2);
+                        continue;
+                }
+                if (!found) {
+                        talloc_reparent(list2, list, list->dn);
+                        list->dn = list2->dn;
+                        list->count = list2->count;
+                        found = true;
+                } else if (!list_intersect(ldb, list, list2)) {
+                        talloc_free(list2);
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                        v = ltdb_index_dn(module, subtree, index_list, list2);
+                        if (v == LDB_ERR_NO_SUCH_OBJECT) {
+                                /* 0 && X == 0 */
+                                talloc_free(list->dn);
+                                talloc_free(list2);
+                                return LDB_ERR_NO_SUCH_OBJECT;
+                        }
+                if (list->count == 0) {
+                        list->dn = NULL;
+                        return LDB_ERR_NO_SUCH_OBJECT;
+                }
+                        if (v != LDB_SUCCESS && v != LDB_ERR_NO_SUCH_OBJECT) {
+                                talloc_free(list2);
+                                continue;
+                        }
+                        if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
+                                ret = LDB_SUCCESS;
+                                talloc_free(list->dn);
+                                list->dn = talloc_move(list, &list2->dn);
+                                list->count = list2->count;
+                        } else {
+                                if (list_intersect(ldb, list, list2) == -1) {
+                                        talloc_free(list2);
+                                        return LDB_ERR_OPERATIONS_ERROR;
+                                }
+                        }
+                        talloc_free(list2);
+                        if (list->count == 0) {
+                                talloc_free(list->dn);
+                                return LDB_ERR_NO_SUCH_OBJECT;
+                        }
+                        if (list->count == 1) {
+                                /* it isn't worth loading the next part of the tree */
+                                return ret;
+                        }
+                if (list->count < 2) {
+                        /* it isn't worth loading the next part of the tree */
+                        return LDB_SUCCESS;
+                }
+        }
+        return ret;
+        if (!found) {
+                /* none of the attributes were indexed */
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        return LDB_SUCCESS;
+}
 /*
   AND index results and ONE level special index
+  return a list of matching objects using a one-level index
  */
 static int ltdb_index_dn_one(struct ldb_module *module,
 …
+{
         struct ldb_context *ldb;
-        struct dn_list *list2;
-        struct ldb_message *msg;
         struct ldb_dn *key;
         struct ldb_val val;
-        unsigned int i, j;
         int ret;
         ldb = ldb_module_get_ctx(module);
+        list2 = talloc_zero(module, struct dn_list);
+        if (list2 == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        /* the attribute is indexed. Pull the list of DNs that match the
+           search criterion */
+        /* work out the index key from the parent DN */
         val.data = (uint8_t *)((uintptr_t)ldb_dn_get_casefold(parent_dn));
         val.length = strlen((char *)val.data);
         key = ltdb_index_key(ldb, LTDB_IDXONE, &val, NULL);
         if (!key) {
+                talloc_free(list2);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        msg = talloc(list2, struct ldb_message);
+        if (msg == NULL) {
+                talloc_free(list2);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ltdb_search_dn1_index(module, key, msg);
+                ldb_oom(ldb);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ltdb_dn_list_load(module, key, list);
         talloc_free(key);
         if (ret != LDB_SUCCESS) {
 …
+        }
+        for (i = 0; i < msg->num_elements; i++) {
+                struct ldb_message_element *el;
+                if (strcmp(msg->elements[i].name, LTDB_IDX) != 0) {
+                        continue;
+                }
+                el = &msg->elements[i];
+                list2->dn = talloc_array(list2, char *, el->num_values);
+                if (!list2->dn) {
+                        talloc_free(list2);
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+                for (j = 0; j < el->num_values; j++) {
+                        list2->dn[list2->count] = talloc_strdup(list2->dn, (char *)el->values[j].data);
+                        if (!list2->dn[list2->count]) {
+                                talloc_free(list2);
+                                return LDB_ERR_OPERATIONS_ERROR;
+                        }
+                        list2->count++;
+                }
+        }
+        if (list2->count == 0) {
+                talloc_free(list2);
+        if (list->count == 0) {
                 return LDB_ERR_NO_SUCH_OBJECT;
+        }
-        if (list2->count > 1) {
-                qsort(list2->dn, list2->count, sizeof(char *), (comparison_fn_t) list_cmp);
+        }
-        if (list->count > 0) {
-                if (list_intersect(ldb, list, list2) == -1) {
-                        talloc_free(list2);
-                        return LDB_ERR_OPERATIONS_ERROR;
+                }
-                if (list->count == 0) {
-                        talloc_free(list->dn);
-                        talloc_free(list2);
-                        return LDB_ERR_NO_SUCH_OBJECT;
+                }
-        } else {
-                list->dn = talloc_move(list, &list2->dn);
-                list->count = list2->count;
+        }
-        talloc_free(list2);
         return LDB_SUCCESS;
 …
                 struct ldb_dn *dn;
                 int ret;
+                bool matched;
                 msg = ldb_msg_new(ac);
 …
+                }
                 dn = ldb_dn_new(msg, ldb, dn_list->dn[i]);
+                dn = ldb_dn_from_ldb_val(msg, ldb, &dn_list->dn[i]);
                 if (dn == NULL) {
                         talloc_free(msg);
 …
+                }
+                if (!ldb_match_msg(ldb, msg,
+                                   ac->tree, ac->base, ac->scope)) {
+                ret = ldb_match_msg_error(ldb, msg,
+                                          ac->tree, ac->base, ac->scope, &matched);
+                if (ret != LDB_SUCCESS) {
+                        talloc_free(msg);
+                        return ret;
+                }
+                if (!matched) {
                         talloc_free(msg);
                         continue;
 …
                 ret = ldb_module_send_entry(ac->req, msg, NULL);
                 if (ret != LDB_SUCCESS) {
+                        /* Regardless of success or failure, the msg
+                         * is the callbacks responsiblity, and should
+                         * not be talloc_free()'ed */
                         ac->request_terminated = true;
                         return ret;
 …
         return LDB_SUCCESS;
+}
+/*
+  remove any duplicated entries in a indexed result
+ */
+static void ltdb_dn_list_remove_duplicates(struct dn_list *list)
+{
+        unsigned int i, new_count;
+        if (list->count < 2) {
+                return;
+        }
+        TYPESAFE_QSORT(list->dn, list->count, dn_list_cmp);
+        new_count = 1;
+        for (i=1; i<list->count; i++) {
+                if (dn_list_cmp(&list->dn[i], &list->dn[new_count-1]) != 0) {
+                        if (new_count != i) {
+                                list->dn[new_count] = list->dn[i];
+                        }
+                        new_count++;
+                }
+        }
+        list->count = new_count;
+}
 …
 int ltdb_search_indexed(struct ltdb_context *ac, uint32_t *match_count)
+{
+        struct ldb_context *ldb;
+        void *data = ldb_module_get_private(ac->module);
+        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(ac->module), struct ltdb_private);
         struct dn_list *dn_list;
+        int ret, idxattr, idxone;
+        ldb = ldb_module_get_ctx(ac->module);
+        idxattr = idxone = 0;
+        ret = ldb_msg_find_idx(ltdb->cache->indexlist, NULL, NULL, LTDB_IDXATTR);
+        if (ret == 0 ) {
+                idxattr = 1;
+        }
+        /* We do one level indexing only if requested */
+        ret = ldb_msg_find_idx(ltdb->cache->indexlist, NULL, NULL, LTDB_IDXONE);
+        if (ret == 0 ) {
+                idxone = 1;
+        }
+        if ((ac->scope == LDB_SCOPE_ONELEVEL && (idxattr+idxone == 0)) ||
+            (ac->scope == LDB_SCOPE_SUBTREE && idxattr == 0)) {
+                /* no indexes? must do full search */
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = LDB_ERR_OPERATIONS_ERROR;
+        int ret;
+        /* see if indexing is enabled */
+        if (!ltdb->cache->attribute_indexes &&
+            !ltdb->cache->one_level_indexes &&
+            ac->scope != LDB_SCOPE_BASE) {
+                /* fallback to a full search */
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         dn_list = talloc_zero(ac, struct dn_list);
         if (dn_list == NULL) {
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
         if (ac->scope == LDB_SCOPE_BASE) {
                 /* with BASE searches only one DN can match */
                 dn_list->dn = talloc_array(dn_list, char *, 1);
+                return ldb_module_oom(ac->module);
+        }
+        switch (ac->scope) {
+        case LDB_SCOPE_BASE:
+                dn_list->dn = talloc_array(dn_list, struct ldb_val, 1);
                 if (dn_list->dn == NULL) {
+                        ldb_oom(ldb);
+                        talloc_free(dn_list);
+                        return ldb_module_oom(ac->module);
+                }
+                dn_list->dn[0].data = discard_const_p(unsigned char, ldb_dn_get_linearized(ac->base));
+                if (dn_list->dn[0].data == NULL) {
+                        talloc_free(dn_list);
+                        return ldb_module_oom(ac->module);
+                }
+                dn_list->dn[0].length = strlen((char *)dn_list->dn[0].data);
+                dn_list->count = 1;
+                break;
+        case LDB_SCOPE_ONELEVEL:
+                if (!ltdb->cache->one_level_indexes) {
+                        talloc_free(dn_list);
                         return LDB_ERR_OPERATIONS_ERROR;
+                }
+                dn_list->dn[0] = ldb_dn_alloc_linearized(dn_list, ac->base);
+                if (dn_list->dn[0] == NULL) {
+                        ldb_oom(ldb);
+                ret = ltdb_index_dn_one(ac->module, ac->base, dn_list);
+                if (ret != LDB_SUCCESS) {
+                        talloc_free(dn_list);
+                        return ret;
+                }
+                break;
+        case LDB_SCOPE_SUBTREE:
+        case LDB_SCOPE_DEFAULT:
+                if (!ltdb->cache->attribute_indexes) {
+                        talloc_free(dn_list);
                         return LDB_ERR_OPERATIONS_ERROR;
+                }
-                dn_list->count = 1;
-                ret = LDB_SUCCESS;
+        }
-        if (ac->scope != LDB_SCOPE_BASE && idxattr == 1) {
                 ret = ltdb_index_dn(ac->module, ac->tree, ltdb->cache->indexlist, dn_list);
+        }
+        if (ret == LDB_ERR_OPERATIONS_ERROR &&
+            ac->scope == LDB_SCOPE_ONELEVEL && idxone == 1) {
+                ret = ltdb_index_dn_one(ac->module, ac->base, dn_list);
+        }
+        if (ret == LDB_SUCCESS) {
+                /* we've got a candidate list - now filter by the full tree
+                   and extract the needed attributes */
+                ret = ltdb_index_filter(dn_list, ac, match_count);
+        }
+                if (ret != LDB_SUCCESS) {
+                        talloc_free(dn_list);
+                        return ret;
+                }
+                ltdb_dn_list_remove_duplicates(dn_list);
+                break;
+        }
+        ret = ltdb_index_filter(dn_list, ac, match_count);
         talloc_free(dn_list);
         return ret;
+}
-/*
-  add a index element where this is the first indexed DN for this value
-*/
-static int ltdb_index_add1_new(struct ldb_context *ldb,
-                               struct ldb_message *msg,
-                               const char *dn)
+{
-        struct ldb_message_element *el;
-        /* add another entry */
-        el = talloc_realloc(msg, msg->elements,
-                               struct ldb_message_element, msg->num_elements+1);
-        if (!el) {
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        msg->elements = el;
-        msg->elements[msg->num_elements].name = talloc_strdup(msg->elements, LTDB_IDX);
-        if (!msg->elements[msg->num_elements].name) {
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        msg->elements[msg->num_elements].num_values = 0;
-        msg->elements[msg->num_elements].values = talloc(msg->elements, struct ldb_val);
-        if (!msg->elements[msg->num_elements].values) {
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        msg->elements[msg->num_elements].values[0].length = strlen(dn);
-        msg->elements[msg->num_elements].values[0].data = discard_const_p(uint8_t, dn);
-        msg->elements[msg->num_elements].num_values = 1;
-        msg->num_elements++;
-        return LDB_SUCCESS;
+}
-/*
-  add a index element where this is not the first indexed DN for this
-  value
-*/
-static int ltdb_index_add1_add(struct ldb_context *ldb,
-                               struct ldb_message *msg,
-                               int idx,
-                               const char *dn,
-                               const struct ldb_schema_attribute *a)
+{
-        struct ldb_val *v2;
-        unsigned int i;
-        /* for multi-valued attributes we can end up with repeats */
-        for (i=0;i<msg->elements[idx].num_values;i++) {
-                if (strcmp(dn, (char *)msg->elements[idx].values[i].data) == 0) {
-                        return LDB_SUCCESS;
+                }
+        }
-        if (a->flags & LDB_ATTR_FLAG_UNIQUE_INDEX) {
-                return LDB_ERR_ENTRY_ALREADY_EXISTS;
+        }
-        v2 = talloc_realloc(msg->elements, msg->elements[idx].values,
-                              struct ldb_val,
-                              msg->elements[idx].num_values+1);
-        if (!v2) {
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        msg->elements[idx].values = v2;
-        msg->elements[idx].values[msg->elements[idx].num_values].length = strlen(dn);
-        msg->elements[idx].values[msg->elements[idx].num_values].data = discard_const_p(uint8_t, dn);
-        msg->elements[idx].num_values++;
-        return LDB_SUCCESS;
+}
 …
+{
         struct ldb_context *ldb;
-        struct ldb_message *msg;
         struct ldb_dn *dn_key;
         int ret;
-        unsigned int i;
         const struct ldb_schema_attribute *a;
+        struct dn_list *list;
+        unsigned alloc_len;
         ldb = ldb_module_get_ctx(module);
+        msg = talloc(module, struct ldb_message);
+        if (msg == NULL) {
+                errno = ENOMEM;
+        list = talloc_zero(module, struct dn_list);
+        if (list == NULL) {
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
         dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx], &a);
         if (!dn_key) {
                 talloc_free(msg);
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
         talloc_steal(msg, dn_key);
         ret = ltdb_search_dn1_index(module, dn_key, msg);
+                talloc_free(list);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        talloc_steal(list, dn_key);
+        ret = ltdb_dn_list_load(module, dn_key, list);
         if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
                 talloc_free(msg);
+                talloc_free(list);
                 return ret;
+        }
+        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                msg->dn = dn_key;
+                msg->num_elements = 0;
+                msg->elements = NULL;
+        }
+        for (i=0;i<msg->num_elements;i++) {
+                if (strcmp(LTDB_IDX, msg->elements[i].name) == 0) {
+                        break;
+                }
+        }
+        if (i == msg->num_elements) {
+                ret = ltdb_index_add1_new(ldb, msg, dn);
+        } else {
+                ret = ltdb_index_add1_add(ldb, msg, i, dn, a);
+        }
+        if (ret == LDB_SUCCESS) {
+                ret = ltdb_store_idxptr(module, msg, TDB_REPLACE);
+        }
+        talloc_free(msg);
+        if (ltdb_dn_list_find_str(list, dn) != -1) {
+                talloc_free(list);
+                return LDB_SUCCESS;
+        }
+        if (list->count > 0 &&
+            a->flags & LDB_ATTR_FLAG_UNIQUE_INDEX) {
+                talloc_free(list);
+                ldb_asprintf_errstring(ldb, __location__ ": unique index violation on %s in %s",
+                                       el->name, dn);
+                return LDB_ERR_ENTRY_ALREADY_EXISTS;
+        }
+        /* overallocate the list a bit, to reduce the number of
+         * realloc trigered copies */
+        alloc_len = ((list->count+1)+7) & ~7;
+        list->dn = talloc_realloc(list, list->dn, struct ldb_val, alloc_len);
+        if (list->dn == NULL) {
+                talloc_free(list);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        list->dn[list->count].data = (uint8_t *)talloc_strdup(list->dn, dn);
+        list->dn[list->count].length = strlen(dn);
+        list->count++;
+        ret = ltdb_dn_list_store(module, dn_key, list);
+        talloc_free(list);
         return ret;
+}
+static int ltdb_index_add0(struct ldb_module *module, const char *dn,
+                           struct ldb_message_element *elements, int num_el)
+{
+        void *data = ldb_module_get_private(module);
+        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+        int ret;
+        unsigned int i, j;
+/*
+  add index entries for one elements in a message
+ */
+static int ltdb_index_add_el(struct ldb_module *module, const char *dn,
+                             struct ldb_message_element *el)
+{
+        unsigned int i;
+        for (i = 0; i < el->num_values; i++) {
+                int ret = ltdb_index_add1(module, dn, el, i);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
+        }
+        return LDB_SUCCESS;
+}
+/*
+  add index entries for all elements in a message
+ */
+static int ltdb_index_add_all(struct ldb_module *module, const char *dn,
+                              struct ldb_message_element *elements, int num_el)
+{
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        unsigned int i;
         if (dn[0] == '@') {
 …
         for (i = 0; i < num_el; i++) {
+                ret = ldb_msg_find_idx(ltdb->cache->indexlist, elements[i].name,
+                                       NULL, LTDB_IDXATTR);
+                if (ret == -1) {
+                int ret;
+                if (!ltdb_is_indexed(ltdb->cache->indexlist, elements[i].name)) {
                         continue;
+                }
+                for (j = 0; j < elements[i].num_values; j++) {
+                        ret = ltdb_index_add1(module, dn, &elements[i], j);
+                        if (ret != LDB_SUCCESS) {
+                                return ret;
+                        }
+                ret = ltdb_index_add_el(module, dn, &elements[i]);
+                if (ret != LDB_SUCCESS) {
+                        struct ldb_context *ldb = ldb_module_get_ctx(module);
+                        ldb_asprintf_errstring(ldb,
+                                               __location__ ": Failed to re-index %s in %s - %s",
+                                               elements[i].name, dn, ldb_errstring(ldb));
+                        return ret;
+                }
+        }
 …
+}
+/*
+  add the index entries for a new record
+*/
+int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
+{
+        const char *dn;
+        int ret;
+        dn = ldb_dn_get_linearized(msg->dn);
+        if (dn == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
+        return ret;
+}
+/*
+  delete an index entry for one message element
+*/
+int ltdb_index_del_value(struct ldb_module *module, const char *dn,
+                         struct ldb_message_element *el, int v_idx)
+{
+        struct ldb_context *ldb;
+        struct ldb_message *msg;
+        struct ldb_dn *dn_key;
+        int ret, i;
+        unsigned int j;
+        ldb = ldb_module_get_ctx(module);
+        if (dn[0] == '@') {
+                return LDB_SUCCESS;
+        }
+        dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx], NULL);
+        if (!dn_key) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        msg = talloc(dn_key, struct ldb_message);
+        if (msg == NULL) {
+                talloc_free(dn_key);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ltdb_search_dn1_index(module, dn_key, msg);
+        if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
+                talloc_free(dn_key);
+                return ret;
+        }
+        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                /* it wasn't indexed. Did we have an earlier error? If we did then
+                   its gone now */
+                talloc_free(dn_key);
+                return LDB_SUCCESS;
+        }
+        i = ldb_msg_find_idx(msg, dn, &j, LTDB_IDX);
+        if (i == -1) {
+                struct ldb_ldif ldif;
+                char *ldif_string;
+                ldif.changetype = LDB_CHANGETYPE_NONE;
+                ldif.msg = msg;
+                ldif_string = ldb_ldif_write_string(ldb, NULL, &ldif);
+                ldb_debug(ldb, LDB_DEBUG_ERROR,
+                          "ERROR: dn %s not found in %s", dn,
+                          ldif_string);
+                talloc_free(ldif_string);
+                /* it ain't there. hmmm */
+                talloc_free(dn_key);
+                return LDB_SUCCESS;
+        }
+        if (j != msg->elements[i].num_values - 1) {
+                memmove(&msg->elements[i].values[j],
+                        &msg->elements[i].values[j+1],
+                        (msg->elements[i].num_values-(j+1)) *
+                        sizeof(msg->elements[i].values[0]));
+        }
+        msg->elements[i].num_values--;
+        if (msg->elements[i].num_values == 0) {
+                ret = ltdb_delete_noindex(module, dn_key);
+        } else {
+                ret = ltdb_store_idxptr(module, msg, TDB_REPLACE);
+        }
+        talloc_free(dn_key);
+        return ret;
+}
+/*
+  delete the index entries for a record
+  return -1 on failure
+*/
+int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
+{
+        void *data = ldb_module_get_private(module);
+        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+        int ret;
+        const char *dn;
+        unsigned int i, j;
+        /* find the list of indexed fields */
+        if (ltdb->cache->indexlist->num_elements == 0) {
+                /* no indexed fields */
+                return LDB_SUCCESS;
+        }
+        if (ldb_dn_is_special(msg->dn)) {
+                return LDB_SUCCESS;
+        }
+        dn = ldb_dn_get_linearized(msg->dn);
+        if (dn == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        for (i = 0; i < msg->num_elements; i++) {
+                ret = ldb_msg_find_idx(ltdb->cache->indexlist, msg->elements[i].name,
+                                       NULL, LTDB_IDXATTR);
+                if (ret == -1) {
+                        continue;
+                }
+                for (j = 0; j < msg->elements[i].num_values; j++) {
+                        ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
+                        if (ret != LDB_SUCCESS) {
+                                return ret;
+                        }
+                }
+        }
+        return LDB_SUCCESS;
+}
+/*
+  handle special index for one level searches
+*/
+int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int add)
+{
+        void *data = ldb_module_get_private(module);
+        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+/*
+  insert a one level index for a message
+*/
+static int ltdb_index_onelevel(struct ldb_module *module, const struct ldb_message *msg, int add)
+{
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
         struct ldb_message_element el;
         struct ldb_val val;
 …
         int ret;
-        if (ldb_dn_is_special(msg->dn)) {
-                return LDB_SUCCESS;
+        }
         /* We index for ONE Level only if requested */
+        ret = ldb_msg_find_idx(ltdb->cache->indexlist, NULL, NULL, LTDB_IDXONE);
+        if (ret != 0) {
+        if (!ltdb->cache->one_level_indexes) {
                 return LDB_SUCCESS;
+        }
 …
                 ret = ltdb_index_add1(module, dn, &el, 0);
         } else { /* delete */
                 ret = ltdb_index_del_value(module, dn, &el, 0);
+                ret = ltdb_index_del_value(module, msg->dn, &el, 0);
+        }
 …
+}
+/*
+  add the index entries for a new element in a record
+  The caller guarantees that these element values are not yet indexed
+*/
+int ltdb_index_add_element(struct ldb_module *module, struct ldb_dn *dn,
+                           struct ldb_message_element *el)
+{
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        if (ldb_dn_is_special(dn)) {
+                return LDB_SUCCESS;
+        }
+        if (!ltdb_is_indexed(ltdb->cache->indexlist, el->name)) {
+                return LDB_SUCCESS;
+        }
+        return ltdb_index_add_el(module, ldb_dn_get_linearized(dn), el);
+}
+/*
+  add the index entries for a new record
+*/
+int ltdb_index_add_new(struct ldb_module *module, const struct ldb_message *msg)
+{
+        const char *dn;
+        int ret;
+        if (ldb_dn_is_special(msg->dn)) {
+                return LDB_SUCCESS;
+        }
+        dn = ldb_dn_get_linearized(msg->dn);
+        if (dn == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ltdb_index_add_all(module, dn, msg->elements, msg->num_elements);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        return ltdb_index_onelevel(module, msg, 1);
+}
+/*
+  delete an index entry for one message element
+*/
+int ltdb_index_del_value(struct ldb_module *module, struct ldb_dn *dn,
+                         struct ldb_message_element *el, unsigned int v_idx)
+{
+        struct ldb_context *ldb;
+        struct ldb_dn *dn_key;
+        const char *dn_str;
+        int ret, i;
+        unsigned int j;
+        struct dn_list *list;
+        ldb = ldb_module_get_ctx(module);
+        dn_str = ldb_dn_get_linearized(dn);
+        if (dn_str == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        if (dn_str[0] == '@') {
+                return LDB_SUCCESS;
+        }
+        dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx], NULL);
+        if (!dn_key) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        list = talloc_zero(dn_key, struct dn_list);
+        if (list == NULL) {
+                talloc_free(dn_key);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ltdb_dn_list_load(module, dn_key, list);
+        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                /* it wasn't indexed. Did we have an earlier error? If we did then
+                   its gone now */
+                talloc_free(dn_key);
+                return LDB_SUCCESS;
+        }
+        if (ret != LDB_SUCCESS) {
+                talloc_free(dn_key);
+                return ret;
+        }
+        i = ltdb_dn_list_find_str(list, dn_str);
+        if (i == -1) {
+                /* nothing to delete */
+                talloc_free(dn_key);
+                return LDB_SUCCESS;
+        }
+        j = (unsigned int) i;
+        if (j != list->count - 1) {
+                memmove(&list->dn[j], &list->dn[j+1], sizeof(list->dn[0])*(list->count - (j+1)));
+        }
+        list->count--;
+        list->dn = talloc_realloc(list, list->dn, struct ldb_val, list->count);
+        ret = ltdb_dn_list_store(module, dn_key, list);
+        talloc_free(dn_key);
+        return ret;
+}
+/*
+  delete the index entries for a element
+  return -1 on failure
+*/
+int ltdb_index_del_element(struct ldb_module *module, struct ldb_dn *dn,
+                           struct ldb_message_element *el)
+{
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        const char *dn_str;
+        int ret;
+        unsigned int i;
+        if (!ltdb->cache->attribute_indexes) {
+                /* no indexed fields */
+                return LDB_SUCCESS;
+        }
+        dn_str = ldb_dn_get_linearized(dn);
+        if (dn_str == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        if (dn_str[0] == '@') {
+                return LDB_SUCCESS;
+        }
+        if (!ltdb_is_indexed(ltdb->cache->indexlist, el->name)) {
+                return LDB_SUCCESS;
+        }
+        for (i = 0; i < el->num_values; i++) {
+                ret = ltdb_index_del_value(module, dn, el, i);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
+        }
+        return LDB_SUCCESS;
+}
+/*
+  delete the index entries for a record
+  return -1 on failure
+*/
+int ltdb_index_delete(struct ldb_module *module, const struct ldb_message *msg)
+{
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        int ret;
+        unsigned int i;
+        if (ldb_dn_is_special(msg->dn)) {
+                return LDB_SUCCESS;
+        }
+        ret = ltdb_index_onelevel(module, msg, 0);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        if (!ltdb->cache->attribute_indexes) {
+                /* no indexed fields */
+                return LDB_SUCCESS;
+        }
+        for (i = 0; i < msg->num_elements; i++) {
+                ret = ltdb_index_del_element(module, msg->dn, &msg->elements[i]);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
+        }
+        return LDB_SUCCESS;
+}
 /*
 …
 static int delete_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *state)
+{
+        const char *dn = "DN=" LTDB_INDEX ":";
+        if (strncmp((char *)key.dptr, dn, strlen(dn)) == 0) {
+                return tdb_delete(tdb, key);
+        }
+        struct ldb_module *module = state;
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        const char *dnstr = "DN=" LTDB_INDEX ":";
+        struct dn_list list;
+        struct ldb_dn *dn;
+        struct ldb_val v;
+        int ret;
+        if (strncmp((char *)key.dptr, dnstr, strlen(dnstr)) != 0) {
+                return 0;
+        }
+        /* we need to put a empty list in the internal tdb for this
+         * index entry */
+        list.dn = NULL;
+        list.count = 0;
+        /* the offset of 3 is to remove the DN= prefix. */
+        v.data = key.dptr + 3;
+        v.length = strnlen((char *)key.dptr, key.dsize) - 3;
+        dn = ldb_dn_from_ldb_val(ltdb, ldb_module_get_ctx(module), &v);
+        ret = ltdb_dn_list_store(module, dn, &list);
+        if (ret != LDB_SUCCESS) {
+                ldb_asprintf_errstring(ldb_module_get_ctx(module),
+                                       "Unable to store null index for %s\n",
+                                                ldb_dn_get_linearized(dn));
+                talloc_free(dn);
+                return -1;
+        }
+        talloc_free(dn);
         return 0;
+}
+struct ltdb_reindex_context {
+        struct ldb_module *module;
+        int error;
+};
 /*
   traversal function that adds @INDEX records during a re index
 …
+{
         struct ldb_context *ldb;
+        struct ldb_module *module = (struct ldb_module *)state;
+        struct ltdb_reindex_context *ctx = (struct ltdb_reindex_context *)state;
+        struct ldb_module *module = ctx->module;
         struct ldb_message *msg;
         const char *dn = NULL;
 …
+        }
         msg = talloc(module, struct ldb_message);
+        msg = ldb_msg_new(module);
         if (msg == NULL) {
                 return -1;
 …
         if (ret != 0) {
                 ldb_debug(ldb, LDB_DEBUG_ERROR, "Invalid data for index %s\n",
                           ldb_dn_get_linearized(msg->dn));
+                                                ldb_dn_get_linearized(msg->dn));
                 talloc_free(msg);
                 return -1;
 …
                 /* probably a corrupt record ... darn */
                 ldb_debug(ldb, LDB_DEBUG_ERROR, "Invalid DN in re_index: %s",
                                                         ldb_dn_get_linearized(msg->dn));
+                                                ldb_dn_get_linearized(msg->dn));
                 talloc_free(msg);
                 return 0;
 …
+        }
+        ret = ltdb_index_one(module, msg, 1);
+        if (ret == LDB_SUCCESS) {
+                ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
+        } else {
+        ret = ltdb_index_onelevel(module, msg, 1);
+        if (ret != LDB_SUCCESS) {
                 ldb_debug(ldb, LDB_DEBUG_ERROR,
+                        "Adding special ONE LEVEL index failed (%s)!",
+                        ldb_dn_get_linearized(msg->dn));
+                          "Adding special ONE LEVEL index failed (%s)!",
+                                                ldb_dn_get_linearized(msg->dn));
+                talloc_free(msg);
+                return -1;
+        }
+        ret = ltdb_index_add_all(module, dn, msg->elements, msg->num_elements);
+        if (ret != LDB_SUCCESS) {
+                ctx->error = ret;
+                talloc_free(msg);
+                return -1;
+        }
         talloc_free(msg);
-        if (ret != LDB_SUCCESS) return -1;
         return 0;
+}
 …
 int ltdb_reindex(struct ldb_module *module)
+{
+        void *data = ldb_module_get_private(module);
+        struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
         int ret;
+        struct ltdb_reindex_context ctx;
         if (ltdb_cache_reload(module) != 0) {
 …
+        }
+        /* first traverse the database deleting any @INDEX records */
+        ret = tdb_traverse(ltdb->tdb, delete_index, NULL);
+        /* first traverse the database deleting any @INDEX records by
+         * putting NULL entries in the in-memory tdb
+         */
+        ret = tdb_traverse(ltdb->tdb, delete_index, module);
         if (ret == -1) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
+        }
+        ctx.module = module;
+        ctx.error = 0;
         /* now traverse adding any indexes for normal LDB records */
         ret = tdb_traverse(ltdb->tdb, re_index, module);
+        ret = tdb_traverse(ltdb->tdb, re_index, &ctx);
         if (ret == -1) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        if (ltdb->idxptr) {
+                ltdb->idxptr->repack = true;
+                struct ldb_context *ldb = ldb_module_get_ctx(module);
+                ldb_asprintf_errstring(ldb, "reindexing traverse failed: %s", ldb_errstring(ldb));
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        if (ctx.error != LDB_SUCCESS) {
+                struct ldb_context *ldb = ldb_module_get_ctx(module);
+                ldb_asprintf_errstring(ldb, "reindexing failed: %s", ldb_errstring(ldb));
+                return ctx.error;
+        }

trunk/server/source4/lib/ldb/ldb_tdb/ldb_pack.c

-              r414
+              r745
+{
         if (el->num_values == 0) return 0;
-        if (ldb_attr_cmp(el->name, "dn") == 0) return 0;
         if (ldb_attr_cmp(el->name, "distinguishedName") == 0) return 0;
 …
         if (message->num_elements == 0) {
-                message->elements = NULL;
                 return 0;
+        }

trunk/server/source4/lib/ldb/ldb_tdb/ldb_search.c

-              r414
+              r745
         elnew->num_values = el->num_values;
+        elnew->flags = el->flags;
         ret->num_elements++;
 …
         el.num_values = 1;
         el.values = &val;
+        el.flags = 0;
         val.data = (uint8_t *)ldb_dn_alloc_linearized(msg, msg->dn);
         val.length = strlen((char *)val.data);
 …
+{
         struct ldb_message *ret;
         int i;
+        unsigned int i;
         ret = talloc(mem_ctx, struct ldb_message);
 …
 int ltdb_filter_attrs(struct ldb_message *msg, const char * const *attrs)
+{
+        int i, keep_all = 0;
+        unsigned int i;
+        int keep_all = 0;
+        struct ldb_message_element *el2;
+        uint32_t num_elements;
         if (attrs) {
 …
+        }
+        el2 = talloc_array(msg, struct ldb_message_element, msg->num_elements);
+        if (el2 == NULL) {
+                return -1;
+        }
+        num_elements = 0;
         for (i = 0; i < msg->num_elements; i++) {
+                int j, found;
+                unsigned int j;
+                int found = 0;
                 for (j = 0, found = 0; attrs[j]; j++) {
+                for (j = 0; attrs[j]; j++) {
                         if (ldb_attr_cmp(msg->elements[i].name, attrs[j]) == 0) {
                                 found = 1;
 …
+                }
+                if (!found) {
+                        ldb_msg_remove_attr(msg, msg->elements[i].name);
+                        i--;
+                }
+        }
+                if (found) {
+                        el2[num_elements] = msg->elements[i];
+                        talloc_steal(el2, el2[num_elements].name);
+                        talloc_steal(el2, el2[num_elements].values);
+                        num_elements++;
+                }
+        }
+        talloc_free(msg->elements);
+        msg->elements = talloc_realloc(msg, el2, struct ldb_message_element, msg->num_elements);
+        if (msg->elements == NULL) {
+                return -1;
+        }
+        msg->num_elements = num_elements;
         return 0;
 …
         struct ldb_message *msg;
         int ret;
+        bool matched;
         ac = talloc_get_type(state, struct ltdb_context);
 …
         /* see if it matches the given expression */
+        if (!ldb_match_msg(ldb, msg,
+                           ac->tree, ac->base, ac->scope)) {
+        ret = ldb_match_msg_error(ldb, msg,
+                                  ac->tree, ac->base, ac->scope, &matched);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(msg);
+                return -1;
+        }
+        if (!matched) {
                 talloc_free(msg);
                 return 0;
 …
                 if ( ! ctx->request_terminated && ret != LDB_SUCCESS) {
                         /* Not indexed, so we need to do a full scan */
+#if 0
+                        /* useful for debugging when slow performance
+                         * is caused by unindexed searches */
+                        char *expression = ldb_filter_from_tree(ctx, ctx->tree);
+                        printf("FULL SEARCH: %s\n", expression);
+                        talloc_free(expression);
+#endif
+                        if (ltdb->warn_unindexed) {
+                                /* useful for debugging when slow performance
+                                 * is caused by unindexed searches */
+                                char *expression = ldb_filter_from_tree(ctx, ctx->tree);
+                                ldb_debug(ldb, LDB_DEBUG_WARNING, "ldb FULL SEARCH: %s SCOPE: %s DN: %s\n",
+                                                        expression,
+                                                        req->op.search.scope==LDB_SCOPE_BASE?"base":
+                                                        req->op.search.scope==LDB_SCOPE_ONELEVEL?"one":
+                                                        req->op.search.scope==LDB_SCOPE_SUBTREE?"sub":"UNKNOWN",
+                                                        ldb_dn_get_linearized(req->op.search.base));
+                                talloc_free(expression);
+                        }
                         if (match_count != 0) {
                                 /* the indexing code gave an error
 …
                                  * duplicate entries
                                  */
+                                ltdb_unlock_read(module);
                                 return LDB_ERR_OPERATIONS_ERROR;
+                        }

trunk/server/source4/lib/ldb/ldb_tdb/ldb_tdb.c

-              r414
+              r745
    ldb database library
    Copyright (C) Andrew Tridgell  2004
    Copyright (C) Stefan Metzmacher  2004
    Copyright (C) Simo Sorce       2006-2008
+   Copyright (C) Andrew Tridgell 2004
+   Copyright (C) Stefan Metzmacher 2004
+   Copyright (C) Simo Sorce 2006-2008
+   Copyright (C) Matthias Dieter WallnÃ¶fer 2009-2010
      ** NOTE! The following LGPL license applies to the ldb
 …
  *  Modifications:
+ *
  *  - description: make the module use asyncronous calls
+ *  - description: make the module use asynchronous calls
  *    date: Feb 2006
  *    Author: Simo Sorce
 …
  *    date: Jan 2008
  *    Author: Simo Sorce
+ *
+ *  - description: fix up memory leaks and small bugs
+ *    date: Oct 2009
+ *    Author: Matthias Dieter WallnÃ¶fer
  */
 …
   map a tdb error code to a ldb error code
 */
 static int ltdb_err_map(enum TDB_ERROR tdb_code)
+int ltdb_err_map(enum TDB_ERROR tdb_code)
+{
         switch (tdb_code) {
 …
         case TDB_ERR_RDONLY:
                 return LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS;
+        default:
+                break;
+        }
         return LDB_ERR_OTHER;
 …
         void *data = ldb_module_get_private(module);
         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
+        if (ltdb->in_transaction == 0) {
+                return tdb_lockall_read(ltdb->tdb);
+        }
+        return 0;
+        int ret = 0;
+        if (ltdb->in_transaction == 0 &&
+            ltdb->read_lock_count == 0) {
+                ret = tdb_lockall_read(ltdb->tdb);
+        }
+        if (ret == 0) {
+                ltdb->read_lock_count++;
+        }
+        return ret;
+}
 …
         void *data = ldb_module_get_private(module);
         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
         if (ltdb->in_transaction == 0) {
+        if (ltdb->in_transaction == 0 && ltdb->read_lock_count == 1) {
                 return tdb_unlockall_read(ltdb->tdb);
+        }
+        ltdb->read_lock_count--;
         return 0;
+}
 …
 */
 static int ltdb_check_special_dn(struct ldb_module *module,
                           const struct ldb_message *msg)
+                                 const struct ldb_message *msg)
+{
         struct ldb_context *ldb = ldb_module_get_ctx(module);
         int i, j;
+        unsigned int i, j;
         if (! ldb_dn_is_special(msg->dn) ||
             ! ldb_dn_check_special(msg->dn, LTDB_ATTRIBUTES)) {
                 return 0;
+                return LDB_SUCCESS;
+        }
 …
         /* should we check that we deny multivalued attributes ? */
         for (i = 0; i < msg->num_elements; i++) {
+                if (ldb_attr_cmp(msg->elements[i].name, "distinguishedName") == 0) continue;
                 for (j = 0; j < msg->elements[i].num_values; j++) {
                         if (ltdb_check_at_attributes_values(&msg->elements[i].values[j]) != 0) {
 …
+        }
         return 0;
+        return LDB_SUCCESS;
+}
 …
+{
         int ret = LDB_SUCCESS;
+        struct ltdb_private *ltdb = talloc_get_type(ldb_module_get_private(module), struct ltdb_private);
+        /* only allow modifies inside a transaction, otherwise the
+         * ldb is unsafe */
+        if (ltdb->in_transaction == 0) {
+                ldb_set_errstring(ldb_module_get_ctx(module), "ltdb modify without transaction");
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         if (ldb_dn_is_special(dn) &&
 …
+        }
+        /* If the modify was to a normal record, or any special except @BASEINFO, update the seq number */
         if (ret == LDB_SUCCESS &&
             !(ldb_dn_is_special(dn) &&
 …
+        }
+        /* If the modify was to @OPTIONS, reload the cache */
+        if (ret == LDB_SUCCESS &&
+            ldb_dn_is_special(dn) &&
+            (ldb_dn_check_special(dn, LTDB_OPTIONS)) ) {
+                ret = ltdb_cache_reload(module);
+        }
         return ret;
+}
 …
         struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);
         TDB_DATA tdb_key, tdb_data;
         int ret;
+        int ret = LDB_SUCCESS;
         tdb_key = ltdb_key(module, msg->dn);
         if (!tdb_key.dptr) {
+        if (tdb_key.dptr == NULL) {
                 return LDB_ERR_OTHER;
+        }
 …
+        }
-        ret = ltdb_index_add(module, msg);
-        if (ret != LDB_SUCCESS) {
-                tdb_delete(ltdb->tdb, tdb_key);
+        }
 done:
         talloc_free(tdb_key.dptr);
 …
+/*
+  check if a attribute is a single valued, for a given element
+ */
+static bool ldb_tdb_single_valued(const struct ldb_schema_attribute *a,
+                                  struct ldb_message_element *el)
+{
+        if (!a) return false;
+        if (el != NULL) {
+                if (el->flags & LDB_FLAG_INTERNAL_FORCE_SINGLE_VALUE_CHECK) {
+                        /* override from a ldb module, for example
+                           used for the description field, which is
+                           marked multi-valued in the schema but which
+                           should not actually accept multiple
+                           values */
+                        return true;
+                }
+                if (el->flags & LDB_FLAG_INTERNAL_DISABLE_SINGLE_VALUE_CHECK) {
+                        /* override from a ldb module, for example used for
+                           deleted linked attribute entries */
+                        return false;
+                }
+        }
+        if (a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+                return true;
+        }
+        return false;
+}
 static int ltdb_add_internal(struct ldb_module *module,
                              const struct ldb_message *msg)
+{
         struct ldb_context *ldb = ldb_module_get_ctx(module);
+        int ret, i;
+        ret = ltdb_check_special_dn(module, msg);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        if (ltdb_cache_load(module) != 0) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        int ret = LDB_SUCCESS;
+        unsigned int i;
         for (i=0;i<msg->num_elements;i++) {
 …
                 if (el->num_values == 0) {
                         ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illegal)",
+                        ldb_asprintf_errstring(ldb, "attribute '%s' on '%s' specified, but with 0 values (illegal)",
                                                el->name, ldb_dn_get_linearized(msg->dn));
                         return LDB_ERR_CONSTRAINT_VIOLATION;
+                }
+                if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+                        if (el->num_values > 1) {
+                                ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s speicified more than once",
+                                                       el->name, ldb_dn_get_linearized(msg->dn));
+                                return LDB_ERR_CONSTRAINT_VIOLATION;
+                        }
+                if (el->num_values > 1 && ldb_tdb_single_valued(a, el)) {
+                        ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+                                               el->name, ldb_dn_get_linearized(msg->dn));
+                        return LDB_ERR_CONSTRAINT_VIOLATION;
+                }
+        }
         ret = ltdb_store(module, msg, TDB_INSERT);
+        if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+                ldb_asprintf_errstring(ldb,
+                                        "Entry %s already exists",
+                                        ldb_dn_get_linearized(msg->dn));
+        if (ret != LDB_SUCCESS) {
+                if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+                        ldb_asprintf_errstring(ldb,
+                                               "Entry %s already exists",
+                                               ldb_dn_get_linearized(msg->dn));
+                }
                 return ret;
+        }
+        if (ret == LDB_SUCCESS) {
+                ret = ltdb_index_one(module, msg, 1);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
+                ret = ltdb_modified(module, msg->dn);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
+        }
+        ret = ltdb_index_add_new(module, msg);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        ret = ltdb_modified(module, msg->dn);
         return ret;
 …
         struct ldb_module *module = ctx->module;
         struct ldb_request *req = ctx->req;
+        int tret;
+        int ret = LDB_SUCCESS;
+        ret = ltdb_check_special_dn(module, req->op.add.message);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
         ldb_request_set_state(req, LDB_ASYNC_PENDING);
+        tret = ltdb_add_internal(module, req->op.add.message);
+        if (tret != LDB_SUCCESS) {
+                return tret;
+        }
+        return LDB_SUCCESS;
+        if (ltdb_cache_load(module) != 0) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ltdb_add_internal(module, req->op.add.message);
+        return ret;
+}
 …
+{
         struct ldb_message *msg;
         int ret;
         msg = talloc(module, struct ldb_message);
+        int ret = LDB_SUCCESS;
+        msg = ldb_msg_new(module);
         if (msg == NULL) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
+        }
-        /* remove one level attribute */
-        ret = ltdb_index_one(module, msg, 0);
-        if (ret != LDB_SUCCESS) {
-                goto done;
+        }
         /* remove any indexed attributes */
         ret = ltdb_index_del(module, msg);
+        ret = ltdb_index_delete(module, msg);
         if (ret != LDB_SUCCESS) {
                 goto done;
 …
         struct ldb_module *module = ctx->module;
         struct ldb_request *req = ctx->req;
         int tret;
+        int ret = LDB_SUCCESS;
         ldb_request_set_state(req, LDB_ASYNC_PENDING);
 …
+        }
+        tret = ltdb_delete_internal(module, req->op.del.dn);
+        if (tret != LDB_SUCCESS) {
+                return tret;
+        }
+        return LDB_SUCCESS;
+        ret = ltdb_delete_internal(module, req->op.del.dn);
+        return ret;
+}
 …
   returns 0 on success, -1 on failure (and sets errno)
 */
 static int msg_add_element(struct ldb_context *ldb,
                            struct ldb_message *msg,
                            struct ldb_message_element *el)
+static int ltdb_msg_add_element(struct ldb_context *ldb,
+                                struct ldb_message *msg,
+                                struct ldb_message_element *el)
+{
         struct ldb_message_element *e2;
         unsigned int i;
+        if (el->num_values == 0) {
+                /* nothing to do here - we don't add empty elements */
+                return 0;
+        }
         e2 = talloc_realloc(msg, msg->elements, struct ldb_message_element,
 …
         e2->name = el->name;
         e2->flags = el->flags;
+        e2->values = NULL;
+        if (el->num_values != 0) {
+                e2->values = talloc_array(msg->elements,
+                                          struct ldb_val, el->num_values);
+                if (!e2->values) {
+                        errno = ENOMEM;
+                        return -1;
+                }
+        e2->values = talloc_array(msg->elements,
+                                  struct ldb_val, el->num_values);
+        if (!e2->values) {
+                errno = ENOMEM;
+                return -1;
+        }
         for (i=0;i<el->num_values;i++) {
 …
         e2->num_values = el->num_values;
         msg->num_elements++;
+        ++msg->num_elements;
         return 0;
 …
                                 struct ldb_message *msg, const char *name)
+{
+        const char *dn;
+        unsigned int i, j;
+        dn = ldb_dn_get_linearized(msg->dn);
+        if (dn == NULL) {
+                return -1;
+        }
+        for (i=0;i<msg->num_elements;i++) {
+                if (ldb_attr_cmp(msg->elements[i].name, name) == 0) {
+                        for (j=0;j<msg->elements[i].num_values;j++) {
+                                ltdb_index_del_value(module, dn,
+                                                     &msg->elements[i], j);
+                        }
+                        talloc_free(msg->elements[i].values);
+                        if (msg->num_elements > (i+1)) {
+                                memmove(&msg->elements[i],
+                                        &msg->elements[i+1],
+                                        sizeof(struct ldb_message_element)*
+                                        (msg->num_elements - (i+1)));
+                        }
+                        msg->num_elements--;
+                        i--;
+                        msg->elements = talloc_realloc(msg, msg->elements,
+                                                        struct ldb_message_element,
+                                                        msg->num_elements);
+                }
+        }
+        return 0;
+        unsigned int i;
+        int ret;
+        struct ldb_message_element *el;
+        el = ldb_msg_find_element(msg, name);
+        if (el == NULL) {
+                return LDB_ERR_NO_SUCH_ATTRIBUTE;
+        }
+        i = el - msg->elements;
+        ret = ltdb_index_del_element(module, msg->dn, el);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        talloc_free(el->values);
+        if (msg->num_elements > (i+1)) {
+                memmove(el, el+1, sizeof(*el) * (msg->num_elements - (i+1)));
+        }
+        msg->num_elements--;
+        msg->elements = talloc_realloc(msg, msg->elements,
+                                       struct ldb_message_element,
+                                       msg->num_elements);
+        return LDB_SUCCESS;
+}
 …
   delete all elements matching an attribute name/value
   return 0 on success, -1 on failure
+  return LDB Error on failure
 */
 static int msg_delete_element(struct ldb_module *module,
 …
         struct ldb_context *ldb = ldb_module_get_ctx(module);
         unsigned int i;
         int found;
+        int found, ret;
         struct ldb_message_element *el;
         const struct ldb_schema_attribute *a;
 …
         found = find_element(msg, name);
         if (found == -1) {
+                return -1;
+        }
+        el = &msg->elements[found];
+                return LDB_ERR_NO_SUCH_ATTRIBUTE;
+        }
+        i = (unsigned int) found;
+        el = &(msg->elements[i]);
         a = ldb_schema_attribute_by_name(ldb, el->name);
         for (i=0;i<el->num_values;i++) {
+                if (a->syntax->comparison_fn(ldb, ldb,
+                                                &el->values[i], val) == 0) {
+                bool matched;
+                if (a->syntax->operator_fn) {
+                        ret = a->syntax->operator_fn(ldb, LDB_OP_EQUALITY, a,
+                                                     &el->values[i], val, &matched);
+                        if (ret != LDB_SUCCESS) return ret;
+                } else {
+                        matched = (a->syntax->comparison_fn(ldb, ldb,
+                                                            &el->values[i], val) == 0);
+                }
+                if (matched) {
+                        if (el->num_values == 1) {
+                                return msg_delete_attribute(module, ldb, msg, name);
+                        }
+                        ret = ltdb_index_del_value(module, msg->dn, el, i);
+                        if (ret != LDB_SUCCESS) {
+                                return ret;
+                        }
                         if (i<el->num_values-1) {
                                 memmove(&el->values[i], &el->values[i+1],
 …
+                        }
                         el->num_values--;
+                        if (el->num_values == 0) {
+                                return msg_delete_attribute(module, ldb,
+                                                            msg, name);
+                        }
+                        return 0;
+                        /* per definition we find in a canonicalised message an
+                           attribute value only once. So we are finished here */
+                        return LDB_SUCCESS;
+                }
+        }
+        return -1;
+        /* Not found */
+        return LDB_ERR_NO_SUCH_ATTRIBUTE;
+}
 …
   get away with it, but if we ever have really large attribute lists
   then we'll need to look at this again
+  'req' is optional, and is used to specify controls if supplied
 */
 int ltdb_modify_internal(struct ldb_module *module,
+                         const struct ldb_message *msg)
+                         const struct ldb_message *msg,
+                         struct ldb_request *req)
+{
         struct ldb_context *ldb = ldb_module_get_ctx(module);
 …
         TDB_DATA tdb_key, tdb_data;
         struct ldb_message *msg2;
+        unsigned i, j;
+        int ret, idx;
+        unsigned int i, j, k;
+        int ret = LDB_SUCCESS, idx;
+        struct ldb_control *control_permissive = NULL;
+        if (req) {
+                control_permissive = ldb_request_get_control(req,
+                                        LDB_CONTROL_PERMISSIVE_MODIFY_OID);
+        }
         tdb_key = ltdb_key(module, msg->dn);
 …
+        }
         msg2 = talloc(tdb_key.dptr, struct ldb_message);
+        msg2 = ldb_msg_new(tdb_key.dptr);
         if (msg2 == NULL) {
+                talloc_free(tdb_key.dptr);
+                return LDB_ERR_OTHER;
+                free(tdb_data.dptr);
+                ret = LDB_ERR_OTHER;
+                goto done;
+        }
         ret = ltdb_unpack_data(module, &tdb_data, msg2);
+        free(tdb_data.dptr);
         if (ret == -1) {
                 ret = LDB_ERR_OTHER;
                 goto failed;
+                goto done;
+        }
 …
+        }
+        for (i=0;i<msg->num_elements;i++) {
+                struct ldb_message_element *el = &msg->elements[i];
+                struct ldb_message_element *el2;
+        for (i=0; i<msg->num_elements; i++) {
+                struct ldb_message_element *el = &msg->elements[i], *el2;
                 struct ldb_val *vals;
+                const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(ldb, el->name);
                 const char *dn;
+                const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(ldb, el->name);
                 switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {
                 case LDB_FLAG_MOD_ADD:
+                        /* add this element to the message. fail if it
+                           already exists */
+                        if (el->num_values == 0) {
+                                ldb_asprintf_errstring(ldb,
+                                                       "attribute '%s': attribute on '%s' specified, but with 0 values (illegal)",
+                                                       el->name, ldb_dn_get_linearized(msg2->dn));
+                                ret = LDB_ERR_CONSTRAINT_VIOLATION;
+                                goto done;
+                        }
+                        /* make a copy of the array so that a permissive
+                         * control can remove duplicates without changing the
+                         * original values, but do not copy data as we do not
+                         * need to keep it around once the operation is
+                         * finished */
+                        if (control_permissive) {
+                                el = talloc(msg2, struct ldb_message_element);
+                                if (!el) {
+                                        ret = LDB_ERR_OTHER;
+                                        goto done;
+                                }
+                                *el = msg->elements[i];
+                                el->values = talloc_array(el, struct ldb_val, el->num_values);
+                                if (el->values == NULL) {
+                                        ret = LDB_ERR_OTHER;
+                                        goto done;
+                                }
+                                for (j = 0; j < el->num_values; j++) {
+                                        el->values[j] = msg->elements[i].values[j];
+                                }
+                        }
+                        if (el->num_values > 1 && ldb_tdb_single_valued(a, el)) {
+                                ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+                                                       el->name, ldb_dn_get_linearized(msg2->dn));
+                                ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                goto done;
+                        }
+                        /* Checks if element already exists */
                         idx = find_element(msg2, el->name);
-                        if (el->num_values == 0) {
-                                ldb_asprintf_errstring(ldb, "attribute %s on %s speicified, but with 0 values (illigal)",
-                                                  el->name, ldb_dn_get_linearized(msg->dn));
-                                return LDB_ERR_CONSTRAINT_VIOLATION;
+                        }
                         if (idx == -1) {
+                                if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+                                        if (el->num_values > 1) {
+                                                ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s speicified more than once",
+                                                               el->name, ldb_dn_get_linearized(msg->dn));
+                                                return LDB_ERR_CONSTRAINT_VIOLATION;
+                                if (ltdb_msg_add_element(ldb, msg2, el) != 0) {
+                                        ret = LDB_ERR_OTHER;
+                                        goto done;
+                                }
+                                ret = ltdb_index_add_element(module, msg2->dn,
+                                                             el);
+                                if (ret != LDB_SUCCESS) {
+                                        goto done;
+                                }
+                        } else {
+                                j = (unsigned int) idx;
+                                el2 = &(msg2->elements[j]);
+                                /* We cannot add another value on a existing one
+                                   if the attribute is single-valued */
+                                if (ldb_tdb_single_valued(a, el)) {
+                                        ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+                                                               el->name, ldb_dn_get_linearized(msg2->dn));
+                                        ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                        goto done;
+                                }
+                                /* Check that values don't exist yet on multi-
+                                   valued attributes or aren't provided twice */
+                                for (j = 0; j < el->num_values; j++) {
+                                        if (ldb_msg_find_val(el2, &el->values[j]) != NULL) {
+                                                if (control_permissive) {
+                                                        /* remove this one as if it was never added */
+                                                        el->num_values--;
+                                                        for (k = j; k < el->num_values; k++) {
+                                                                el->values[k] = el->values[k + 1];
+                                                        }
+                                                        j--; /* rewind */
+                                                        continue;
+                                                }
+                                                ldb_asprintf_errstring(ldb,
+                                                                       "attribute '%s': value #%u on '%s' already exists",
+                                                                       el->name, j, ldb_dn_get_linearized(msg2->dn));
+                                                ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                                goto done;
+                                        }
+                                        if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+                                                ldb_asprintf_errstring(ldb,
+                                                                       "attribute '%s': value #%u on '%s' provided more than once",
+                                                                       el->name, j, ldb_dn_get_linearized(msg2->dn));
+                                                ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                                goto done;
+                                        }
+                                }
+                                if (msg_add_element(ldb, msg2, el) != 0) {
+                                /* Now combine existing and new values to a new
+                                   attribute record */
+                                vals = talloc_realloc(msg2->elements,
+                                                      el2->values, struct ldb_val,
+                                                      el2->num_values + el->num_values);
+                                if (vals == NULL) {
+                                        ldb_oom(ldb);
                                         ret = LDB_ERR_OTHER;
                                         goto failed;
+                                        goto done;
+                                }
+                                continue;
+                        }
+                        /* If this is an add, then if it already
+                         * exists in the object, then we violoate the
+                         * single-value rule */
+                        if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+                                return LDB_ERR_CONSTRAINT_VIOLATION;
+                        }
+                        el2 = &msg2->elements[idx];
+                        /* An attribute with this name already exists,
+                         * add all values if they don't already exist
+                         * (check both the other elements to be added,
+                         * and those already in the db). */
+                        for (j=0;j<el->num_values;j++) {
+                                if (ldb_msg_find_val(el2, &el->values[j])) {
+                                        ldb_asprintf_errstring(ldb, "%s: value #%d already exists", el->name, j);
+                                        ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                        goto failed;
+                                for (j=0; j<el->num_values; j++) {
+                                        vals[el2->num_values + j] =
+                                                ldb_val_dup(vals, &el->values[j]);
+                                }
+                                if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+                                        ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
+                                        ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                        goto failed;
+                                el2->values = vals;
+                                el2->num_values += el->num_values;
+                                ret = ltdb_index_add_element(module, msg2->dn, el);
+                                if (ret != LDB_SUCCESS) {
+                                        goto done;
+                                }
+                        }
+                        vals = talloc_realloc(msg2->elements, el2->values, struct ldb_val,
+                                                el2->num_values + el->num_values);
+                        if (vals == NULL) {
+                                ret = LDB_ERR_OTHER;
+                                goto failed;
+                        break;
+                case LDB_FLAG_MOD_REPLACE:
+                        if (el->num_values > 1 && ldb_tdb_single_valued(a, el)) {
+                                ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+                                                       el->name, ldb_dn_get_linearized(msg2->dn));
+                                ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                goto done;
+                        }
+                        for (j=0;j<el->num_values;j++) {
+                                vals[el2->num_values + j] =
+                                        ldb_val_dup(vals, &el->values[j]);
+                        }
+                        el2->values = vals;
+                        el2->num_values += el->num_values;
+                        break;
+                case LDB_FLAG_MOD_REPLACE:
+                        if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+                                if (el->num_values > 1) {
+                                        ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s speicified more than once",
+                                                               el->name, ldb_dn_get_linearized(msg->dn));
+                                        return LDB_ERR_CONSTRAINT_VIOLATION;
+                        /* TODO: This is O(n^2) - replace with more efficient check */
+                        for (j=0; j<el->num_values; j++) {
+                                if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+                                        ldb_asprintf_errstring(ldb,
+                                                               "attribute '%s': value #%u on '%s' provided more than once",
+                                                               el->name, j, ldb_dn_get_linearized(msg2->dn));
+                                        ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                        goto done;
+                                }
+                        }
+                        /* replace all elements of this attribute name with the elements
+                           listed. The attribute not existing is not an error */
+                        msg_delete_attribute(module, ldb, msg2, el->name);
+                        for (j=0;j<el->num_values;j++) {
+                                if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+                                        ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
+                                        ret = LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+                                        goto failed;
+                        /* Checks if element already exists */
+                        idx = find_element(msg2, el->name);
+                        if (idx != -1) {
+                                j = (unsigned int) idx;
+                                el2 = &(msg2->elements[j]);
+                                if (ldb_msg_element_compare(el, el2) == 0) {
+                                        /* we are replacing with the same values */
+                                        continue;
+                                }
+                                /* Delete the attribute if it exists in the DB */
+                                if (msg_delete_attribute(module, ldb, msg2,
+                                                         el->name) != 0) {
+                                        ret = LDB_ERR_OTHER;
+                                        goto done;
+                                }
+                        }
+                        /* add the replacement element, if not empty */
+                        if (el->num_values != 0 &&
+                            msg_add_element(ldb, msg2, el) != 0) {
+                        /* Recreate it with the new values */
+                        if (ltdb_msg_add_element(ldb, msg2, el) != 0) {
                                 ret = LDB_ERR_OTHER;
                                 goto failed;
+                                goto done;
+                        }
+                        ret = ltdb_index_add_element(module, msg2->dn, el);
+                        if (ret != LDB_SUCCESS) {
+                                goto done;
+                        }
                         break;
                 case LDB_FLAG_MOD_DELETE:
+                        dn = ldb_dn_get_linearized(msg->dn);
+                        dn = ldb_dn_get_linearized(msg2->dn);
                         if (dn == NULL) {
                                 ret = LDB_ERR_OTHER;
                                 goto failed;
+                                goto done;
+                        }
-                        /* we could be being asked to delete all
-                           values or just some values */
                         if (msg->elements[i].num_values == 0) {
+                                if (msg_delete_attribute(module, ldb, msg2,
+                                                         msg->elements[i].name) != 0) {
+                                        ldb_asprintf_errstring(ldb, "No such attribute: %s for delete on %s", msg->elements[i].name, dn);
+                                        ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
+                                        goto failed;
+                                /* Delete the whole attribute */
+                                ret = msg_delete_attribute(module, ldb, msg2,
+                                                           msg->elements[i].name);
+                                if (ret == LDB_ERR_NO_SUCH_ATTRIBUTE &&
+                                    control_permissive) {
+                                        ret = LDB_SUCCESS;
+                                } else {
+                                        ldb_asprintf_errstring(ldb,
+                                                               "attribute '%s': no such attribute for delete on '%s'",
+                                                               msg->elements[i].name, dn);
+                                }
+                                break;
+                        }
+                        for (j=0;j<msg->elements[i].num_values;j++) {
+                                if (msg_delete_element(module,
+                                                       msg2,
+                                                       msg->elements[i].name,
+                                                       &msg->elements[i].values[j]) != 0) {
+                                        ldb_asprintf_errstring(ldb, "No matching attribute value when deleting attribute: %s on %s", msg->elements[i].name, dn);
+                                        ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
+                                        goto failed;
+                                if (ret != LDB_SUCCESS) {
+                                        goto done;
+                                }
+                                ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
+                                if (ret != LDB_SUCCESS) {
+                                        goto failed;
+                        } else {
+                                /* Delete specified values from an attribute */
+                                for (j=0; j < msg->elements[i].num_values; j++) {
+                                        ret = msg_delete_element(module,
+                                                                 msg2,
+                                                                 msg->elements[i].name,
+                                                                 &msg->elements[i].values[j]);
+                                        if (ret == LDB_ERR_NO_SUCH_ATTRIBUTE &&
+                                            control_permissive) {
+                                                ret = LDB_SUCCESS;
+                                        } else {
+                                                ldb_asprintf_errstring(ldb,
+                                                                       "attribute '%s': no matching attribute value while deleting attribute on '%s'",
+                                                                       msg->elements[i].name, dn);
+                                        }
+                                        if (ret != LDB_SUCCESS) {
+                                                goto done;
+                                        }
+                                }
+                        }
 …
                 default:
                         ldb_asprintf_errstring(ldb,
                                 "Invalid ldb_modify flags on %s: 0x%x",
                                 msg->elements[i].name,
                                 msg->elements[i].flags & LDB_FLAG_MOD_MASK);
+                                               "attribute '%s': invalid modify flags on '%s': 0x%x",
+                                               msg->elements[i].name, ldb_dn_get_linearized(msg->dn),
+                                               msg->elements[i].flags & LDB_FLAG_MOD_MASK);
                         ret = LDB_ERR_PROTOCOL_ERROR;
                         goto failed;
+                        goto done;
+                }
+        }
-        /* we've made all the mods
-         * save the modified record back into the database */
         ret = ltdb_store(module, msg2, TDB_MODIFY);
         if (ret != LDB_SUCCESS) {
                 goto failed;
+        }
         ret = ltdb_modified(module, msg->dn);
+                goto done;
+        }
+        ret = ltdb_modified(module, msg2->dn);
         if (ret != LDB_SUCCESS) {
+                goto failed;
+        }
+                goto done;
+        }
+done:
         talloc_free(tdb_key.dptr);
-        free(tdb_data.dptr);
-        return ret;
-failed:
-        talloc_free(tdb_key.dptr);
-        free(tdb_data.dptr);
         return ret;
+}
 …
         struct ldb_module *module = ctx->module;
         struct ldb_request *req = ctx->req;
+        int tret;
+        int ret = LDB_SUCCESS;
+        ret = ltdb_check_special_dn(module, req->op.mod.message);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
         ldb_request_set_state(req, LDB_ASYNC_PENDING);
-        tret = ltdb_check_special_dn(module, req->op.mod.message);
-        if (tret != LDB_SUCCESS) {
-                return tret;
+        }
         if (ltdb_cache_load(module) != 0) {
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
+        tret = ltdb_modify_internal(module, req->op.mod.message);
+        if (tret != LDB_SUCCESS) {
+                return tret;
+        }
+        return LDB_SUCCESS;
+        ret = ltdb_modify_internal(module, req->op.mod.message, req);
+        return ret;
+}
 …
         struct ldb_request *req = ctx->req;
         struct ldb_message *msg;
         int tret;
+        int ret = LDB_SUCCESS;
         ldb_request_set_state(req, LDB_ASYNC_PENDING);
 …
+        }
         msg = talloc(ctx, struct ldb_message);
+        msg = ldb_msg_new(ctx);
         if (msg == NULL) {
                 return LDB_ERR_OPERATIONS_ERROR;
 …
         /* in case any attribute of the message was indexed, we need
            to fetch the old record */
         tret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
         if (tret != LDB_SUCCESS) {
+        ret = ltdb_search_dn1(module, req->op.rename.olddn, msg);
+        if (ret != LDB_SUCCESS) {
                 /* not finding the old record is an error */
+                return tret;
+        }
+        msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
+        if (!msg->dn) {
+                return LDB_ERR_OPERATIONS_ERROR;
+                return ret;
+        }
 …
          * atomic
          */
+        tret = ltdb_delete_internal(module, req->op.rename.olddn);
+        if (tret != LDB_SUCCESS) {
+                return tret;
+        }
+        tret = ltdb_add_internal(module, msg);
+        if (tret != LDB_SUCCESS) {
+                return tret;
+        }
+        return LDB_SUCCESS;
+        ret = ltdb_delete_internal(module, msg->dn);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        msg->dn = ldb_dn_copy(msg, req->op.rename.newdn);
+        if (msg->dn == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ltdb_add_internal(module, msg);
+        return ret;
+}
 …
         struct ldb_module *module = ctx->module;
         struct ldb_request *req = ctx->req;
         TALLOC_CTX *tmp_ctx;
+        TALLOC_CTX *tmp_ctx = NULL;
         struct ldb_seqnum_request *seq;
         struct ldb_seqnum_result *res;
 …
         struct ldb_dn *dn;
         const char *date;
         int ret;
+        int ret = LDB_SUCCESS;
         ldb = ldb_module_get_ctx(module);
 …
                 goto done;
+        }
         tmp_ctx = talloc_new(req);
         if (tmp_ctx == NULL) {
 …
         dn = ldb_dn_new(tmp_ctx, ldb, LTDB_BASEINFO);
+        msg = talloc(tmp_ctx, struct ldb_message);
+        if (dn == NULL) {
+                ret = LDB_ERR_OPERATIONS_ERROR;
+                goto done;
+        }
+        msg = ldb_msg_new(tmp_ctx);
         if (msg == NULL) {
                 ret = LDB_ERR_OPERATIONS_ERROR;
 …
         (*ext)->oid = LDB_EXTENDED_SEQUENCE_NUMBER;
         (*ext)->data = talloc_steal(*ext, res);
-        ret = LDB_SUCCESS;
 done:
 …
         default:
                 /* no other op supported */
                 ret = LDB_ERR_UNWILLING_TO_PERFORM;
+                ret = LDB_ERR_PROTOCOL_ERROR;
+        }
 …
                                struct ldb_request *req)
+{
+        struct ldb_control *control_permissive;
         struct ldb_context *ldb;
         struct tevent_context *ev;
 …
         struct tevent_timer *te;
         struct timeval tv;
+        if (check_critical_controls(req->controls)) {
+                return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+        }
+        unsigned int i;
         ldb = ldb_module_get_ctx(module);
+        control_permissive = ldb_request_get_control(req,
+                                        LDB_CONTROL_PERMISSIVE_MODIFY_OID);
+        for (i = 0; req->controls && req->controls[i]; i++) {
+                if (req->controls[i]->critical &&
+                    req->controls[i] != control_permissive) {
+                        ldb_asprintf_errstring(ldb, "Unsupported critical extension %s",
+                                               req->controls[i]->oid);
+                        return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+                }
+        }
         if (req->starttime == 0 || req->timeout == 0) {
 …
         ac = talloc_zero(ldb, struct ltdb_context);
         if (ac == NULL) {
                 ldb_set_errstring(ldb, "Out of Memory");
+                ldb_oom(ldb);
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
+}
+static int ltdb_init_rootdse(struct ldb_module *module)
+{
+        struct ldb_context *ldb;
+        int ret;
+        ldb = ldb_module_get_ctx(module);
+        ret = ldb_mod_register_control(module,
+                                       LDB_CONTROL_PERMISSIVE_MODIFY_OID);
+        /* ignore errors on this - we expect it for non-sam databases */
+        /* there can be no module beyond the backend, just return */
+        return LDB_SUCCESS;
+}
 static const struct ldb_module_ops ltdb_ops = {
         .name              = "tdb",
+        .init_context      = ltdb_init_rootdse,
         .search            = ltdb_handle_request,
         .add               = ltdb_handle_request,
 …
                         ldb_debug(ldb, LDB_DEBUG_ERROR,
                                   "Invalid tdb URL '%s'", url);
                         return -1;
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
                 path = url+6;
 …
         if (!ltdb) {
                 ldb_oom(ldb);
                 return -1;
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
                           "Unable to open tdb '%s'", path);
                 talloc_free(ltdb);
+                return -1;
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        if (getenv("LDB_WARN_UNINDEXED")) {
+                ltdb->warn_unindexed = true;
+        }
 …
         if (!module) {
                 talloc_free(ltdb);
                 return -1;
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         ldb_module_set_private(module, ltdb);
+        talloc_steal(module, ltdb);
         if (ltdb_cache_load(module) != 0) {
                 talloc_free(module);
                 talloc_free(ltdb);
                 return -1;
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         *_module = module;
+        return 0;
+}
+const struct ldb_backend_ops ldb_tdb_backend_ops = {
+        .name = "tdb",
+        .connect_fn = ltdb_connect
+};
+        return LDB_SUCCESS;
+}
+int ldb_tdb_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_backend("tdb", ltdb_connect, false);
+}

trunk/server/source4/lib/ldb/ldb_tdb/ldb_tdb.h

-              r414
+              r745
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "tdb.h"
 #include "ldb_module.h"
 …
                 struct ldb_message *indexlist;
                 struct ldb_message *attributes;
+                bool one_level_indexes;
+                bool attribute_indexes;
                 struct {
 …
         struct ltdb_idxptr *idxptr;
         bool prepared_commit;
+        int read_lock_count;
+        bool warn_unindexed;
 };
 …
 #define LTDB_INDEXLIST  "@INDEXLIST"
 #define LTDB_IDX        "@IDX"
 #define LTDB_IDXPTR     "@IDXPTR"
+#define LTDB_IDXVERSION "@IDXVERSION"
 #define LTDB_IDXATTR    "@IDXATTR"
 #define LTDB_IDXONE     "@IDXONE"
 …
 int ltdb_search_indexed(struct ltdb_context *ctx, uint32_t *);
+int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg);
+int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg);
+int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int add);
+int ltdb_index_add_new(struct ldb_module *module, const struct ldb_message *msg);
+int ltdb_index_delete(struct ldb_module *module, const struct ldb_message *msg);
+int ltdb_index_del_element(struct ldb_module *module, struct ldb_dn *dn,
+                           struct ldb_message_element *el);
+int ltdb_index_add_element(struct ldb_module *module, struct ldb_dn *dn,
+                           struct ldb_message_element *el);
+int ltdb_index_del_value(struct ldb_module *module, struct ldb_dn *dn,
+                         struct ldb_message_element *el, unsigned int v_idx);
 int ltdb_reindex(struct ldb_module *module);
 int ltdb_index_transaction_start(struct ldb_module *module);
 …
 struct TDB_DATA ltdb_key(struct ldb_module *module, struct ldb_dn *dn);
 int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs);
+int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *msg, struct ldb_request *req);
 int ltdb_delete_noindex(struct ldb_module *module, struct ldb_dn *dn);
+int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *msg);
+int ltdb_index_del_value(struct ldb_module *module, const char *dn,
+                         struct ldb_message_element *el, int v_idx);
+int ltdb_err_map(enum TDB_ERROR tdb_code);
 struct tdb_context *ltdb_wrap_open(TALLOC_CTX *mem_ctx,

trunk/server/source4/lib/ldb/ldb_tdb/ldb_tdb_wrap.c

-              r414
+              r745
 #include "ldb_tdb.h"
+#include "dlinklist.h"
 /*
 …
+{
         tdb_close(w->tdb);
+        if (w->next) {
+                w->next->prev = w->prev;
+        }
+        if (w->prev) {
+                w->prev->next = w->next;
+        }
+        if (w == tdb_list) {
+                tdb_list = w->next;
+        }
+        DLIST_REMOVE(tdb_list, w);
         return 0;
+}
 …
         talloc_set_destructor(w, ltdb_wrap_destructor);
+        w->next = tdb_list;
+        w->prev = NULL;
+        if (tdb_list) {
+                tdb_list->prev = w;
+        }
+        tdb_list = w;
+        DLIST_ADD(tdb_list, w);
         return w->tdb;

trunk/server/source4/lib/ldb/man/ldbadd.1.xml

-              r414
+              r745
         <title>DESCRIPTION</title>
         <para>ldbadd adds records to an ldb(7) database. It reads
+        <para>ldbadd adds records to an ldb(3) database. It reads
                 the ldif(5) files specified on the command line and adds
                 the records from these files to the LDB database, which is specified
 …
                         <term>-H &lt;ldb-url&gt;</term>
                         <listitem><para>
                                 LDB URL to connect to. See ldb(7) for details.
+                                LDB URL to connect to. See ldb(3) for details.
                         </para></listitem>
                 </varlistentry>
 …
         <title>SEE ALSO</title>
         <para>ldb(7), ldbmodify, ldbdel, ldif(5)</para>
+        <para>ldb(3), ldbmodify, ldbdel, ldif(5)</para>
 </refsect1>

trunk/server/source4/lib/ldb/man/ldbdel.1.xml

-              r414
+              r745
         <title>DESCRIPTION</title>
         <para>ldbdel deletes records from an ldb(7) database.
+        <para>ldbdel deletes records from an ldb(3) database.
                 It deletes the records identified by the dn's specified
                 on the command-line. </para>
 …
                         <term>-H &lt;ldb-url&gt;</term>
                         <listitem><para>
                                 LDB URL to connect to. See ldb(7) for details.
+                                LDB URL to connect to. See ldb(3) for details.
                         </para></listitem>
                 </varlistentry>
 …
         <title>SEE ALSO</title>
         <para>ldb(7), ldbmodify, ldbadd, ldif(5)</para>
+        <para>ldb(3), ldbmodify, ldbadd, ldif(5)</para>
 </refsect1>

trunk/server/source4/lib/ldb/man/ldbedit.1.xml

r414	r745
173	173	<title>SEE ALSO</title>
174	174
175		<para>ldb(7), ldbmodify(1), ldbdel(1), ldif(5), vi(1)</para>
	175	<para>ldb(3), ldbmodify(1), ldbdel(1), ldif(5), vi(1)</para>
176	176
177	177	</refsect1>

trunk/server/source4/lib/ldb/man/ldbmodify.1.xml

-              r414
+              r745
                         <term>-H &lt;ldb-url&gt;</term>
                         <listitem><para>
                                 LDB URL to connect to. See ldb(7) for details.
+                                LDB URL to connect to. See ldb(3) for details.
                         </para></listitem>
                 </varlistentry>
 …
         <title>SEE ALSO</title>
         <para>ldb(7), ldbedit</para>
+        <para>ldb(3), ldbedit</para>
 </refsect1>

trunk/server/source4/lib/ldb/man/ldbrename.1.xml

-              r414
+              r745
                         <term>-H &lt;ldb-url&gt;</term>
                         <listitem><para>
                                 LDB URL to connect to. See ldb(7) for details.
+                                LDB URL to connect to. See ldb(3) for details.
                         </para></listitem>
                 </varlistentry>
 …
         <title>SEE ALSO</title>
         <para>ldb(7), ldbmodify, ldbdel, ldif(5)</para>
+        <para>ldb(3), ldbmodify, ldbdel, ldif(5)</para>
 </refsect1>

trunk/server/source4/lib/ldb/man/ldbsearch.1.xml

-              r414
+              r745
                         <term>-H &lt;ldb-url&gt;</term>
                         <listitem><para>
                                 LDB URL to connect to. See ldb(7) for details.
+                                LDB URL to connect to. See ldb(3) for details.
                         </para></listitem>
                 </varlistentry>
 …
         <title>SEE ALSO</title>
         <para>ldb(7), ldbedit(1)</para>
+        <para>ldb(3), ldbedit(1)</para>
 </refsect1>

trunk/server/source4/lib/ldb/modules/asq.c

-              r414
+              r745
  */
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_module.h"
 …
         struct ldb_request **reqs;
         int num_reqs;
         int cur_req;
+        unsigned int num_reqs;
+        unsigned int cur_req;
         struct ldb_control **controls;
 …
+{
         struct ldb_asq_control *asq;
         int i;
+        unsigned int i;
         if (ac->controls) {
 …
                                         ac->req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
+                return ret;
+        }
 …
         struct ldb_dn *dn;
         struct ldb_message_element *el;
+        int ret, i;
+        unsigned int i;
+        int ret;
         if (ac->base_res == NULL) {
 …
                                                 ac->req);
                 if (ret != LDB_SUCCESS) {
                         return LDB_ERR_OPERATIONS_ERROR;
+                        return ret;
+                }
                 /* remove the ASQ control itself */
                 control = ldb_request_get_control(ac->req, LDB_CONTROL_ASQ_OID);
                 if (!save_controls(control, ac->reqs[i], &saved_controls)) {
+                if (!ldb_save_controls(control, ac->reqs[i], &saved_controls)) {
                         return LDB_ERR_OPERATIONS_ERROR;
+                }
 …
+}
 const struct ldb_module_ops ldb_asq_module_ops = {
+static const struct ldb_module_ops ldb_asq_module_ops = {
         .name              = "asq",
         .search            = asq_search,
         .init_context      = asq_init
 };
+int ldb_asq_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_module(&ldb_asq_module_ops);
+}

trunk/server/source4/lib/ldb/modules/paged_results.c

-              r414
+              r745
  */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_module.h"
 …
 struct private_data {
+        int next_free_id;
+        unsigned int next_free_id;
         struct results_store *store;
 …
+{
         struct results_store *newr;
         int new_id = priv->next_free_id++;
+        unsigned int new_id = priv->next_free_id++;
         /* TODO: we should have a limit on the number of
 …
         struct ldb_paged_control *paged;
         struct message_store *msg;
+        int i, num_ctrls, ret;
+        unsigned int i, num_ctrls;
+        int ret;
         if (ac->store == NULL) {
 …
         ac->req = req;
         ac->size = paged_ctrl->size;
+        if (ac->size < 0) {
+                /* apparently some clients send more than 2^31. This
+                   violates the ldap standard, but we need to cope */
+                ac->size = 0x7FFFFFFF;
+        }
         /* check if it is a continuation search the store */
 …
                                                 paged_search_callback,
                                                 req);
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
                 /* save it locally and remove it from the list */
                 /* we do not need to replace them later as we
                  * are keeping the original req intact */
                 if (!save_controls(control, search_req, &saved_controls)) {
+                if (!ldb_save_controls(control, search_req, &saved_controls)) {
                         return LDB_ERR_OPERATIONS_ERROR;
+                }
 …
+}
 const struct ldb_module_ops ldb_paged_results_module_ops = {
+static const struct ldb_module_ops ldb_paged_results_module_ops = {
         .name           = "paged_results",
         .search         = paged_search,
         .init_context   = paged_request_init
 };
+int ldb_paged_results_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_module(&ldb_paged_results_module_ops);
+}

trunk/server/source4/lib/ldb/modules/paged_searches.c

-              r414
+              r745
  */
+#include "includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_module.h"
 …
         char **saved_referrals;
         int num_referrals;
+        unsigned int num_referrals;
         struct ldb_request *down_req;
 …
                         return LDB_ERR_OPERATIONS_ERROR;
                 } else {
                         /* No cookie recived yet, valid to just return the full data set */
+                        /* No cookie received yet, valid to just return the full data set */
                         /* we are done */
 …
         struct ldb_reply *ares;
         int ret;
         int i;
+        unsigned int i;
         for (i = 0; i < ac->num_referrals; i++) {
 …
                                         ps_callback,
                                         ac->req);
+        LDB_REQ_SET_LOCATION(ac->down_req);
         if (ret != LDB_SUCCESS) {
                 return ret;
 …
                                    data, check_supported_paged,
                                    NULL);
+        LDB_REQ_SET_LOCATION(req);
         if (ret != LDB_SUCCESS) {
                 return ret;
 …
+}
 _PUBLIC_ const struct ldb_module_ops ldb_paged_searches_module_ops = {
+static const struct ldb_module_ops ldb_paged_searches_module_ops = {
         .name           = "paged_searches",
         .search         = ps_search,
         .init_context   = ps_init
 };
+int ldb_paged_searches_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_module(&ldb_paged_searches_module_ops);
+}

trunk/server/source4/lib/ldb/modules/rdn_name.c

-              r414
+              r745
    ldb database library
    Copyright (C) Andrew Bartlett 2005
+   Copyright (C) Andrew Bartlett 2005-2009
    Copyright (C) Simo Sorce 2006-2008
 …
  */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_module.h"
 struct rename_context {
         struct ldb_module *module;
         struct ldb_request *req;
 …
         struct ldb_reply *ares;
 };
-static struct ldb_message_element *rdn_name_find_attribute(const struct ldb_message *msg, const char *name)
+{
-        int i;
-        for (i = 0; i < msg->num_elements; i++) {
-                if (ldb_attr_cmp(name, msg->elements[i].name) == 0) {
-                        return &msg->elements[i];
+                }
+        }
-        return NULL;
+}
 static int rdn_name_add_callback(struct ldb_request *req,
 …
                                         LDB_ERR_OPERATIONS_ERROR);
+        }
+        if (ares->type == LDB_REPLY_REFERRAL) {
+                return ldb_module_send_referral(ac->req, ares->referral);
+        }
         if (ares->error != LDB_SUCCESS) {
                 return ldb_module_done(ac->req, ares->controls,
 …
         const struct ldb_schema_attribute *a;
         const char *rdn_name;
+        const struct ldb_val *rdn_val_p;
         struct ldb_val rdn_val;
+        int i, ret;
+        unsigned int i;
+        int ret;
         ldb = ldb_module_get_ctx(module);
-        ldb_debug(ldb, LDB_DEBUG_TRACE, "rdn_name_add_record");
         /* do not manipulate our control entries */
 …
         rdn_name = ldb_dn_get_rdn_name(msg->dn);
         if (rdn_name == NULL) {
-                talloc_free(ac);
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
+        rdn_val = ldb_val_dup(msg, ldb_dn_get_rdn_val(msg->dn));
+        /* Perhaps someone above us tried to set this? */
+        if ((attribute = rdn_name_find_attribute(msg, "name")) != NULL ) {
+                attribute->num_values = 0;
+        }
+        if (ldb_msg_add_value(msg, "name", &rdn_val, NULL) != 0) {
+                talloc_free(ac);
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        attribute = rdn_name_find_attribute(msg, rdn_name);
+        rdn_val_p = ldb_dn_get_rdn_val(msg->dn);
+        if (rdn_val_p == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        if (rdn_val_p->length == 0) {
+                ldb_asprintf_errstring(ldb, "Empty RDN value on %s not permitted!",
+                                       ldb_dn_get_linearized(req->op.add.message->dn));
+                return LDB_ERR_INVALID_DN_SYNTAX;
+        }
+        rdn_val = ldb_val_dup(msg, rdn_val_p);
+        /* Perhaps someone above us tried to set this? Then ignore it */
+        ldb_msg_remove_attr(msg, "name");
+        ret = ldb_msg_add_value(msg, "name", &rdn_val, NULL);
+        if (ret != LDB_SUCCESS) {
+                return ret;
+        }
+        a = ldb_schema_attribute_by_name(ldb, rdn_name);
+        if (a == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        attribute = ldb_msg_find_element(msg, rdn_name);
         if (!attribute) {
+                if (ldb_msg_add_value(msg, rdn_name, &rdn_val, NULL) != 0) {
+                        talloc_free(ac);
+                        return LDB_ERR_OPERATIONS_ERROR;
+                /* add entry with normalised RDN information if possible */
+                if (a->name != NULL) {
+                        ret = ldb_msg_add_value(msg, a->name, &rdn_val, NULL);
+                } else {
+                        ret = ldb_msg_add_value(msg, rdn_name, &rdn_val, NULL);
+                }
+                if (ret != LDB_SUCCESS) {
+                        return ret;
+                }
         } else {
+                a = ldb_schema_attribute_by_name(ldb, rdn_name);
+                /* normalise attribute name if possible */
+                if (a->name != NULL) {
+                        attribute->name = a->name;
+                }
+                /* normalise attribute value */
                 for (i = 0; i < attribute->num_values; i++) {
+                        ret = a->syntax->comparison_fn(ldb, msg,
+                                        &rdn_val, &attribute->values[i]);
+                        if (ret == 0) {
+                        bool matched;
+                        if (a->syntax->operator_fn) {
+                                ret = a->syntax->operator_fn(ldb, LDB_OP_EQUALITY, a,
+                                                             &rdn_val, &attribute->values[i], &matched);
+                                if (ret != LDB_SUCCESS) return ret;
+                        } else {
+                                matched = (a->syntax->comparison_fn(ldb, msg,
+                                                                    &rdn_val, &attribute->values[i]) == 0);
+                        }
+                        if (matched) {
                                 /* overwrite so it matches in case */
                                 attribute->values[i] = rdn_val;
 …
+                }
                 if (i == attribute->num_values) {
+                        char *rdn_errstring = talloc_asprintf(ac, "RDN mismatch on %s: %s (%.*s) should match one of:",
+                                                          ldb_dn_get_linearized(msg->dn), rdn_name,
+                                                          (int)rdn_val.length, (const char *)rdn_val.data);
+                        char *rdn_errstring = talloc_asprintf(ac,
+                                "RDN mismatch on %s: %s (%.*s) should match one of:",
+                                ldb_dn_get_linearized(msg->dn), rdn_name,
+                                (int)rdn_val.length, (const char *)rdn_val.data);
                         for (i = 0; i < attribute->num_values; i++) {
+                                rdn_errstring = talloc_asprintf_append(rdn_errstring, " (%.*s)",
+                                                                       (int)attribute->values[i].length,
+                                                                       (const char *)attribute->values[i].data);
+                                rdn_errstring = talloc_asprintf_append(
+                                        rdn_errstring, " (%.*s)",
+                                        (int)attribute->values[i].length,
+                                        (const char *)attribute->values[i].data);
+                        }
+                        ldb_debug_set(ldb, LDB_DEBUG_FATAL, "%s", rdn_errstring);
+                        talloc_free(ac);
+                        ldb_set_errstring(ldb, rdn_errstring);
                         /* Match AD's error here */
                         return LDB_ERR_INVALID_DN_SYNTAX;
 …
                                         LDB_ERR_OPERATIONS_ERROR);
+        }
+        if (ares->type == LDB_REPLY_REFERRAL) {
+                return ldb_module_send_referral(ac->req, ares->referral);
+        }
         if (ares->error != LDB_SUCCESS) {
                 return ldb_module_done(ac->req, ares->controls,
 …
         struct ldb_request *mod_req;
         const char *rdn_name;
+        const struct ldb_val *rdn_val_p;
         struct ldb_val rdn_val;
         struct ldb_message *msg;
 …
                 goto error;
+        }
+        if (ares->type == LDB_REPLY_REFERRAL) {
+                return ldb_module_send_referral(ac->req, ares->referral);
+        }
         if (ares->error != LDB_SUCCESS) {
                 return ldb_module_done(ac->req, ares->controls,
 …
                 goto error;
+        }
         rdn_name = ldb_dn_get_rdn_name(ac->req->op.rename.newdn);
         if (rdn_name == NULL) {
                 goto error;
+        }
+        rdn_val = ldb_val_dup(msg, ldb_dn_get_rdn_val(ac->req->op.rename.newdn));
+        rdn_val_p = ldb_dn_get_rdn_val(msg->dn);
+        if (rdn_val_p == NULL) {
+                goto error;
+        }
+        if (rdn_val_p->length == 0) {
+                ldb_asprintf_errstring(ldb, "Empty RDN value on %s not permitted!",
+                                       ldb_dn_get_linearized(req->op.rename.olddn));
+                return ldb_module_done(ac->req, NULL, NULL,
+                                       LDB_ERR_NAMING_VIOLATION);
+        }
+        rdn_val = ldb_val_dup(msg, rdn_val_p);
         if (ldb_msg_add_empty(msg, rdn_name, LDB_FLAG_MOD_REPLACE, NULL) != 0) {
                 goto error;
 …
         talloc_steal(mod_req, msg);
         /* do the mod call */
         return ldb_request(ldb, mod_req);
+        /* go on with the call chain */
+        return ldb_next_request(ac->module, mod_req);
 error:
+        return ldb_module_done(ac->req, NULL, NULL,
+                                                LDB_ERR_OPERATIONS_ERROR);
+        return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
+}
 …
         ldb = ldb_module_get_ctx(module);
-        ldb_debug(ldb, LDB_DEBUG_TRACE, "rdn_name_rename");
         /* do not manipulate our control entries */
 …
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
+                return ret;
+        }
 …
+}
+const struct ldb_module_ops ldb_rdn_name_module_ops = {
+static int rdn_name_modify(struct ldb_module *module, struct ldb_request *req)
+{
+        struct ldb_context *ldb;
+        const struct ldb_val *rdn_val_p;
+        ldb = ldb_module_get_ctx(module);
+        /* do not manipulate our control entries */
+        if (ldb_dn_is_special(req->op.mod.message->dn)) {
+                return ldb_next_request(module, req);
+        }
+        rdn_val_p = ldb_dn_get_rdn_val(req->op.mod.message->dn);
+        if (rdn_val_p == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        if (rdn_val_p->length == 0) {
+                ldb_asprintf_errstring(ldb, "Empty RDN value on %s not permitted!",
+                                       ldb_dn_get_linearized(req->op.mod.message->dn));
+                return LDB_ERR_INVALID_DN_SYNTAX;
+        }
+        if (ldb_msg_find_element(req->op.mod.message, "distinguishedName")) {
+                ldb_asprintf_errstring(ldb, "Modify of 'distinguishedName' on %s not permitted, must use 'rename' operation instead",
+                                       ldb_dn_get_linearized(req->op.mod.message->dn));
+                return LDB_ERR_CONSTRAINT_VIOLATION;
+        }
+        if (ldb_msg_find_element(req->op.mod.message, "name")) {
+                ldb_asprintf_errstring(ldb, "Modify of 'name' on %s not permitted, must use 'rename' operation instead",
+                                       ldb_dn_get_linearized(req->op.mod.message->dn));
+                return LDB_ERR_NOT_ALLOWED_ON_RDN;
+        }
+        if (ldb_msg_find_element(req->op.mod.message, ldb_dn_get_rdn_name(req->op.mod.message->dn))) {
+                ldb_asprintf_errstring(ldb, "Modify of RDN '%s' on %s not permitted, must use 'rename' operation instead",
+                                       ldb_dn_get_rdn_name(req->op.mod.message->dn), ldb_dn_get_linearized(req->op.mod.message->dn));
+                return LDB_ERR_NOT_ALLOWED_ON_RDN;
+        }
+        /* All OK, they kept their fingers out of the special attributes */
+        return ldb_next_request(module, req);
+}
+static int rdn_name_search(struct ldb_module *module, struct ldb_request *req)
+{
+        struct ldb_context *ldb;
+        const char *rdn_name;
+        const struct ldb_val *rdn_val_p;
+        ldb = ldb_module_get_ctx(module);
+        /* do not manipulate our control entries */
+        if (ldb_dn_is_special(req->op.search.base)) {
+                return ldb_next_request(module, req);
+        }
+        rdn_name = ldb_dn_get_rdn_name(req->op.search.base);
+        rdn_val_p = ldb_dn_get_rdn_val(req->op.search.base);
+        if ((rdn_name != NULL) && (rdn_val_p == NULL)) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        if ((rdn_val_p != NULL) && (rdn_val_p->length == 0)) {
+                ldb_asprintf_errstring(ldb, "Empty RDN value on %s not permitted!",
+                                       ldb_dn_get_linearized(req->op.search.base));
+                return LDB_ERR_INVALID_DN_SYNTAX;
+        }
+        return ldb_next_request(module, req);
+}
+static const struct ldb_module_ops ldb_rdn_name_module_ops = {
         .name              = "rdn_name",
         .add               = rdn_name_add,
+        .modify            = rdn_name_modify,
         .rename            = rdn_name_rename,
+        .search            = rdn_name_search
 };
+int ldb_rdn_name_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_module(&ldb_rdn_name_module_ops);
+}

trunk/server/source4/lib/ldb/modules/skel.c

-              r414
+              r745
 /*
+/*
    ldb database library
 …
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
  */
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_module.h"
 …
+}
 const struct ldb_module_ops ldb_skel_module_ops = {
+static const struct ldb_module_ops ldb_skel_module_ops = {
         .name              = "skel",
         .init_context      = skel_init,
 …
         .del_transaction   = skel_del_trans,
 };
+int ldb_skel_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_module(&ldb_skel_module_ops);
+}

trunk/server/source4/lib/ldb/modules/sort.c

-              r414
+              r745
  */
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_module.h"
 …
         struct ldb_module *module;
         char *attributeName;
         char *orderingRule;
+        const char *attributeName;
+        const char *orderingRule;
         int reverse;
 …
         struct ldb_message **msgs;
         char **referrals;
         int num_msgs;
         int num_refs;
+        unsigned int num_msgs;
+        unsigned int num_refs;
         const struct ldb_schema_attribute *a;
 …
         struct ldb_control **controls;
         struct ldb_sort_resp_control *resp;
         int i;
+        unsigned int i;
         if (*ctrls) {
 …
         struct ldb_context *ldb;
         struct ldb_reply *ares;
+        int i, ret;
+        unsigned int i;
+        int ret;
         ldb = ldb_module_get_ctx(ac->module);
 …
         ac->sort_result = 0;
+        ldb_qsort(ac->msgs, ac->num_msgs,
+                  sizeof(struct ldb_message *),
+                  ac, (ldb_qsort_cmp_fn_t)sort_compare);
+        LDB_TYPESAFE_QSORT(ac->msgs, ac->num_msgs, ac, sort_compare);
         if (ac->sort_result != LDB_SUCCESS) {
 …
                                         req);
         if (ret != LDB_SUCCESS) {
                 return LDB_ERR_OPERATIONS_ERROR;
+                return ret;
+        }
 …
         /* we do not need to replace them later as we
          * are keeping the original req intact */
         if (!save_controls(control, down_req, &saved_controls)) {
+        if (!ldb_save_controls(control, down_req, &saved_controls)) {
                 return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
+}
 const struct ldb_module_ops ldb_server_sort_module_ops = {
+static const struct ldb_module_ops ldb_server_sort_module_ops = {
         .name              = "server_sort",
         .search            = server_sort_search,
         .init_context      = server_sort_init
 };
+int ldb_server_sort_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_module(&ldb_server_sort_module_ops);
+}

trunk/server/source4/lib/ldb/nssldb/ldb-nss.c

-              r414
+              r745
         size_t bufpos;
         size_t lsize;
         int i;
+        unsigned int i;
         bufpos = 0;
 …
+{
         NSS_STATUS ret;
         int i;
+        unsigned int i;
         for (i = 0; i < grlist->count; i++) {

trunk/server/source4/lib/ldb/pyldb.c

-              r414
+              r745
    Copyright (C) 2005,2006 Tim Potter <tpot@samba.org>
    Copyright (C) 2006 Simo Sorce <idra@samba.org>
    Copyright (C) 2007-2009 Jelmer Vernooij <jelmer@samba.org>
    Copyright (C) 2009 Matthias Dieter WallnÃ¶fer
          ** NOTE! The following LGPL license applies to the ldb
          ** library. This does NOT imply that all of Samba is released
          ** under the LGPL
+   Copyright (C) 2007-2010 Jelmer Vernooij <jelmer@samba.org>
+   Copyright (C) 2009-2010 Matthias Dieter WallnÃ¶fer
+    ** NOTE! The following LGPL license applies to the ldb
+    ** library. This does NOT imply that all of Samba is released
+    ** under the LGPL
    This library is free software; you can redistribute it and/or
 …
 */
+#include "replace.h"
+#include <Python.h>
+#include <pytalloc.h>
 #include "ldb_private.h"
-#include <Python.h>
 #include "pyldb.h"
+void initldb(void);
+static PyObject *PyLdbMessage_FromMessage(struct ldb_message *msg);
+static PyObject *PyExc_LdbError;
+staticforward PyTypeObject PyLdbControl;
+staticforward PyTypeObject PyLdbResult;
+staticforward PyTypeObject PyLdbMessage;
+staticforward PyTypeObject PyLdbModule;
+staticforward PyTypeObject PyLdbDn;
+staticforward PyTypeObject PyLdb;
+staticforward PyTypeObject PyLdbMessageElement;
+staticforward PyTypeObject PyLdbTree;
+static PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx);
+static PyObject *PyLdbModule_FromModule(struct ldb_module *mod);
+static struct ldb_message_element *PyObject_AsMessageElement(
+                                                      TALLOC_CTX *mem_ctx,
+                                                      PyObject *set_obj,
+                                                      int flags,
+                                                      const char *attr_name);
 /* There's no Py_ssize_t in 2.4, apparently */
 …
 #endif
+#define SIGN(a) (((a) == 0)?0:((a) < 0?-1:1))
+static PyObject *py_ldb_control_str(PyLdbControlObject *self)
+{
+        if (self->data != NULL) {
+                char* control = ldb_control_to_string(self->mem_ctx, self->data);
+                if (control == NULL) {
+                        PyErr_NoMemory();
+                        return NULL;
+                }
+                return PyString_FromString(control);
+        } else {
+                return PyString_FromFormat("ldb control");
+        }
+}
+static void py_ldb_control_dealloc(PyLdbControlObject *self)
+{
+        if (self->mem_ctx != NULL) {
+                talloc_free(self->mem_ctx);
+        }
+        self->ob_type->tp_free(self);
+}
+static PyObject *py_ldb_control_get_oid(PyLdbControlObject *self)
+{
+        return PyString_FromString(self->data->oid);
+}
+static PyObject *py_ldb_control_get_critical(PyLdbControlObject *self)
+{
+        return PyBool_FromLong(self->data->critical);
+}
+static PyObject *py_ldb_control_set_critical(PyLdbControlObject *self, PyObject *value, void *closure)
+{
+        if (PyObject_IsTrue(value)) {
+                self->data->critical = true;
+        } else {
+                self->data->critical = false;
+        }
+        return 0;
+}
+static PyObject *py_ldb_control_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+        char *data = NULL;
+        const char *array[2];
+        const char * const kwnames[] = { "ldb", "data", NULL };
+        struct ldb_control *parsed_controls;
+        PyLdbControlObject *ret;
+        PyObject *py_ldb;
+        TALLOC_CTX *mem_ctx;
+        struct ldb_context *ldb_ctx;
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Os",
+                                         discard_const_p(char *, kwnames),
+                                         &py_ldb, &data))
+                return NULL;
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        ldb_ctx = PyLdb_AsLdbContext(py_ldb);
+        parsed_controls = ldb_parse_control_from_string(ldb_ctx, mem_ctx, data);
+        if (!parsed_controls) {
+                talloc_free(mem_ctx);
+                PyErr_SetString(PyExc_ValueError, "unable to parse control string");
+                return NULL;
+        }
+        ret = PyObject_New(PyLdbControlObject, type);
+        if (ret == NULL) {
+                PyErr_NoMemory();
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        ret->mem_ctx = mem_ctx;
+        ret->data = talloc_steal(mem_ctx, parsed_controls);
+        if (ret->data == NULL) {
+                Py_DECREF(ret);
+                PyErr_NoMemory();
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        return (PyObject *)ret;
+}
+static PyGetSetDef py_ldb_control_getset[] = {
+        { discard_const_p(char, "oid"), (getter)py_ldb_control_get_oid, NULL, NULL },
+        { discard_const_p(char, "critical"), (getter)py_ldb_control_get_critical, (setter)py_ldb_control_set_critical, NULL },
+        { NULL }
+};
+static PyTypeObject PyLdbControl = {
+        .tp_name = "ldb.control",
+        .tp_dealloc = (destructor)py_ldb_control_dealloc,
+        .tp_getattro = PyObject_GenericGetAttr,
+        .tp_basicsize = sizeof(PyLdbControlObject),
+        .tp_getset = py_ldb_control_getset,
+        .tp_doc = "LDB control.",
+        .tp_str = (reprfunc)py_ldb_control_str,
+        .tp_new = py_ldb_control_new,
+        .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+};
 static void PyErr_SetLdbError(PyObject *error, int ret, struct ldb_context *ldb_ctx)
+{
 …
         PyErr_SetObject(error,
+                                        Py_BuildValue(discard_const_p(char, "(i,s)"), ret,
+                                  ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx)));
+}
+static PyObject *PyExc_LdbError;
+PyAPI_DATA(PyTypeObject) PyLdbMessage;
+PyAPI_DATA(PyTypeObject) PyLdbModule;
+PyAPI_DATA(PyTypeObject) PyLdbDn;
+PyAPI_DATA(PyTypeObject) PyLdb;
+PyAPI_DATA(PyTypeObject) PyLdbMessageElement;
+PyAPI_DATA(PyTypeObject) PyLdbTree;
+static PyObject *PyObject_FromLdbValue(struct ldb_context *ldb_ctx,
+                                                           struct ldb_message_element *el,
+                                                           struct ldb_val *val)
+{
+        struct ldb_val new_val;
+        TALLOC_CTX *mem_ctx = talloc_new(NULL);
+        PyObject *ret;
+        new_val = *val;
+        ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
+        talloc_free(mem_ctx);
+        return ret;
+                        Py_BuildValue(discard_const_p(char, "(i,s)"), ret,
+                                      ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx)));
+}
+static PyObject *PyObject_FromLdbValue(struct ldb_val *val)
+{
+        return PyString_FromStringAndSize((const char *)val->data, val->length);
+}
 /**
  * Obtain a ldb DN from a Python object.
+ * Create a Python object from a ldb_result.
+ *
+ * @param mem_ctx Memory context
+ * @param object Python object
+ * @param ldb_ctx LDB context
+ * @return Whether or not the conversion succeeded
+ * @param result LDB result to convert
+ * @return Python object with converted result (a list object)
  */
+bool PyObject_AsDn(TALLOC_CTX *mem_ctx, PyObject *object,
+                   struct ldb_context *ldb_ctx, struct ldb_dn **dn)
+{
+        struct ldb_dn *odn;
+        if (ldb_ctx != NULL && PyString_Check(object)) {
+                odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
+                *dn = odn;
+                return true;
+        }
+        if (PyLdbDn_Check(object)) {
+                *dn = PyLdbDn_AsDn(object);
+                return true;
+        }
+        PyErr_SetString(PyExc_TypeError, "Expected DN");
+        return false;
+static PyObject *PyLdbControl_FromControl(struct ldb_control *control)
+{
+        TALLOC_CTX *ctl_ctx = talloc_new(NULL);
+        PyLdbControlObject *ctrl;
+        if (ctl_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        ctrl = (PyLdbControlObject *)PyLdbControl.tp_alloc(&PyLdbControl, 0);
+        if (ctrl == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        ctrl->mem_ctx = ctl_ctx;
+        ctrl->data = talloc_steal(ctrl->mem_ctx, control);
+        if (ctrl->data == NULL) {
+                Py_DECREF(ctrl);
+                PyErr_NoMemory();
+                return NULL;
+        }
+        return (PyObject*) ctrl;
+}
 …
 static PyObject *PyLdbResult_FromResult(struct ldb_result *result)
+{
+        PyObject *ret;
+        int i;
+        PyLdbResultObject *ret;
+        PyObject *list, *controls, *referals;
+        Py_ssize_t i;
         if (result == NULL) {
                 Py_RETURN_NONE;
+        }
+        ret = PyList_New(result->count);
+        }
+        ret = (PyLdbResultObject *)PyLdbResult.tp_alloc(&PyLdbResult, 0);
+        if (ret == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        list = PyList_New(result->count);
+        if (list == NULL) {
+                PyErr_NoMemory();
+                Py_DECREF(ret);
+                return NULL;
+        }
         for (i = 0; i < result->count; i++) {
+                PyList_SetItem(ret, i, PyLdbMessage_FromMessage(result->msgs[i])
+                );
+        }
+        return ret;
+                PyList_SetItem(list, i, PyLdbMessage_FromMessage(result->msgs[i]));
+        }
+        ret->mem_ctx = talloc_new(NULL);
+        if (ret->mem_ctx == NULL) {
+                Py_DECREF(list);
+                Py_DECREF(ret);
+                PyErr_NoMemory();
+                return NULL;
+        }
+        ret->msgs = list;
+        if (result->controls) {
+                controls = PyList_New(1);
+                if (controls == NULL) {
+                        Py_DECREF(ret);
+                        PyErr_NoMemory();
+                        return NULL;
+                }
+                for (i=0; result->controls[i]; i++) {
+                        PyObject *ctrl = (PyObject*) PyLdbControl_FromControl(result->controls[i]);
+                        if (ctrl == NULL) {
+                                Py_DECREF(ret);
+                                Py_DECREF(controls);
+                                PyErr_NoMemory();
+                                return NULL;
+                        }
+                        PyList_SetItem(controls, i, ctrl);
+                }
+        } else {
+                /*
+                 * No controls so we keep an empty list
+                 */
+                controls = PyList_New(0);
+                if (controls == NULL) {
+                        Py_DECREF(ret);
+                        PyErr_NoMemory();
+                        return NULL;
+                }
+        }
+        ret->controls = controls;
+        i = 0;
+        while (result->refs && result->refs[i]) {
+                i++;
+        }
+        referals = PyList_New(i);
+        if (referals == NULL) {
+                Py_DECREF(ret);
+                PyErr_NoMemory();
+                return NULL;
+        }
+        for (i = 0;result->refs && result->refs[i]; i++) {
+                PyList_SetItem(referals, i, PyString_FromString(result->refs[i]));
+        }
+        ret->referals = referals;
+        return (PyObject *)ret;
+}
 …
  */
 static struct ldb_result *PyLdbResult_AsResult(TALLOC_CTX *mem_ctx,
                                                                                            PyObject *obj)
+                                               PyObject *obj)
+{
         struct ldb_result *res;
         int i;
+        Py_ssize_t i;
         if (obj == Py_None)
 …
                 "S.canonical_ex_str() -> string\n"
                 "Canonical version of this DN (like a posix path, with terminating newline)." },
-        { "check_special", (PyCFunction)py_ldb_dn_is_special, METH_VARARGS,
-                NULL },
         { "parent", (PyCFunction)py_ldb_dn_get_parent, METH_NOARGS,
                 "S.parent() -> dn\n"
 …
                 "Add a base DN to this DN." },
         { "check_special", (PyCFunction)py_ldb_dn_check_special, METH_VARARGS,
+                NULL },
+                "S.check_special(name) -> bool\n\n"
+                "Check if name is a special DN name"},
         { NULL }
 };
 …
         ret = ldb_dn_new(mem_ctx, ldb_ctx, str);
+        if (ret == NULL || !ldb_dn_validate(ret)) {
+        if (!ldb_dn_validate(ret)) {
                 talloc_free(mem_ctx);
                 PyErr_SetString(PyExc_ValueError, "unable to parse dn string");
 …
+}
-PyObject *PyLdbDn_FromDn(struct ldb_dn *dn)
+{
-        PyLdbDnObject *py_ret;
-        if (dn == NULL) {
-                Py_RETURN_NONE;
+        }
-        py_ret = (PyLdbDnObject *)PyLdbDn.tp_alloc(&PyLdbDn, 0);
-        if (py_ret == NULL) {
-                PyErr_NoMemory();
-                return NULL;
+        }
-        py_ret->mem_ctx = talloc_new(NULL);
-        py_ret->dn = talloc_reference(py_ret->mem_ctx, dn);
-        return (PyObject *)py_ret;
+}
 static void py_ldb_dn_dealloc(PyLdbDnObject *self)
+{
         talloc_free(self->mem_ctx);
         self->ob_type->tp_free(self);
+}
 PyTypeObject PyLdbDn = {
         .tp_name = "Dn",
+        PyObject_Del(self);
+}
+static PyTypeObject PyLdbDn = {
+        .tp_name = "ldb.Dn",
         .tp_methods = py_ldb_dn_methods,
         .tp_str = (reprfunc)py_ldb_dn_get_linearized,
 …
         .tp_new = py_ldb_dn_new,
         .tp_dealloc = (destructor)py_ldb_dn_dealloc,
         .tp_basicsize = sizeof(PyLdbObject),
+        .tp_basicsize = sizeof(PyLdbDnObject),
         .tp_flags = Py_TPFLAGS_DEFAULT,
 };
 …
+{
         PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ldb_transaction_commit(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
+        Py_RETURN_NONE;
+}
+static PyObject *py_ldb_transaction_prepare_commit(PyLdbObject *self)
+{
+        PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ldb_transaction_prepare_commit(PyLdb_AsLdbContext(self)), PyLdb_AsLdbContext(self));
         Py_RETURN_NONE;
+}
 …
 static const char **PyList_AsStringList(TALLOC_CTX *mem_ctx, PyObject *list,
                                                                                 const char *paramname)
+                                        const char *paramname)
+{
         const char **ret;
         int i;
+        Py_ssize_t i;
         if (!PyList_Check(list)) {
                 PyErr_Format(PyExc_TypeError, "%s is not a list", paramname);
 …
+        }
         ret = talloc_array(NULL, const char *, PyList_Size(list)+1);
+        if (ret == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
         for (i = 0; i < PyList_Size(list); i++) {
                 PyObject *item = PyList_GetItem(list, i);
 …
+                }
                 ret[i] = talloc_strndup(ret, PyString_AsString(item),
                                                            PyString_Size(item));
+                                        PyString_Size(item));
+        }
         ret[i] = NULL;
 …
+{
         PyObject *py_msg;
+        int ret;
+        if (!PyArg_ParseTuple(args, "O", &py_msg))
+                return NULL;
+        if (!PyLdbMessage_Check(py_msg)) {
+                PyErr_SetString(PyExc_TypeError, "Expected Ldb Message");
+                return NULL;
+        }
+        ret = ldb_modify(PyLdb_AsLdbContext(self), PyLdbMessage_AsMessage(py_msg));
+        PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, PyLdb_AsLdbContext(self));
+        Py_RETURN_NONE;
+}
+static PyObject *py_ldb_add(PyLdbObject *self, PyObject *args)
+{
+        PyObject *py_msg;
+        int ret;
+        Py_ssize_t dict_pos, msg_pos;
+        struct ldb_message_element *msgel;
+        struct ldb_message *msg;
+        PyObject *py_controls = Py_None;
         struct ldb_context *ldb_ctx;
         struct ldb_request *req;
+        PyObject *key, *value;
+        PyObject *py_controls = Py_None;
+        struct ldb_control **parsed_controls;
+        struct ldb_message *msg;
+        int ret;
         TALLOC_CTX *mem_ctx;
+        struct ldb_control **parsed_controls;
+        if (!PyArg_ParseTuple(args, "O|O", &py_msg, &py_controls ))
+                return NULL;
+        if (!PyArg_ParseTuple(args, "O|O", &py_msg, &py_controls))
+                return NULL;
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
         ldb_ctx = PyLdb_AsLdbContext(self);
-        mem_ctx = talloc_new(NULL);
         if (py_controls == Py_None) {
                 parsed_controls = NULL;
         } else {
                 const char **controls = PyList_AsStringList(ldb_ctx, py_controls, "controls");
                 parsed_controls = ldb_parse_control_strings(ldb_ctx, ldb_ctx, controls);
+                const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
+                parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
                 talloc_free(controls);
+        }
+        if (PyDict_Check(py_msg)) {
+                PyObject *dn_value = PyDict_GetItemString(py_msg, "dn");
+                msg = ldb_msg_new(mem_ctx);
+                msg->elements = talloc_zero_array(msg, struct ldb_message_element, PyDict_Size(py_msg));
+                msg_pos = dict_pos = 0;
+                if (dn_value) {
+                        if (!PyObject_AsDn(msg, dn_value, ldb_ctx, &msg->dn)) {
+                                PyErr_SetString(PyExc_TypeError, "unable to import dn object");
+                                talloc_free(mem_ctx);
+                                return NULL;
+                        }
+                        if (msg->dn == NULL) {
+                                PyErr_SetString(PyExc_TypeError, "dn set but not found");
+                                talloc_free(mem_ctx);
+                                return NULL;
+                        }
+                }
+                while (PyDict_Next(py_msg, &dict_pos, &key, &value)) {
+                        char *key_str = PyString_AsString(key);
+                        if (strcmp(key_str, "dn") != 0) {
+                                msgel = PyObject_AsMessageElement(msg->elements, value, 0, key_str);
+                                if (msgel == NULL) {
+                                        PyErr_SetString(PyExc_TypeError, "unable to import element");
+                                        talloc_free(mem_ctx);
+                                        return NULL;
+                                }
+                                memcpy(&msg->elements[msg_pos], msgel, sizeof(*msgel));
+                                msg_pos++;
+                        }
+                }
+                if (msg->dn == NULL) {
+                        PyErr_SetString(PyExc_TypeError, "no dn set");
+                        talloc_free(mem_ctx);
+                        return NULL;
+                }
+                msg->num_elements = msg_pos;
+        } else {
+                msg = PyLdbMessage_AsMessage(py_msg);
+        }
+        if (!PyLdbMessage_Check(py_msg)) {
+                PyErr_SetString(PyExc_TypeError, "Expected Ldb Message");
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        msg = PyLdbMessage_AsMessage(py_msg);
         ret = ldb_msg_sanity_check(ldb_ctx, msg);
         if (ret != LDB_SUCCESS) {
                 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, PyLdb_AsLdbContext(self));
+        if (ret != LDB_SUCCESS) {
+                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
                 talloc_free(mem_ctx);
                 return NULL;
+        }
+        ret = ldb_build_add_req(&req, ldb_ctx, ldb_ctx,
+                                        msg,
+                                        parsed_controls,
+                                        NULL,
+                                        ldb_op_default_callback,
+                                        NULL);
+        }
+        ret = ldb_build_mod_req(&req, ldb_ctx, mem_ctx, msg, parsed_controls,
+                                NULL, ldb_op_default_callback, NULL);
         if (ret != LDB_SUCCESS) {
                 PyErr_SetString(PyExc_TypeError, "failed to build request");
 …
+        }
         /* do request and autostart a transaction */
+        /* do request and autostart a transaction */
         /* Then let's LDB handle the message error in case of pb as they are meaningful */
+        ret = ldb_transaction_start(ldb_ctx);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(req);
+        ret = ldb_transaction_start(ldb_ctx);
+        if (ret != LDB_SUCCESS) {
                 talloc_free(mem_ctx);
+                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, PyLdb_AsLdbContext(self));
+        }
+        ret = ldb_request(ldb_ctx, req);
+        if (ret == LDB_SUCCESS) {
+                ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+        }
+                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
+        }
+        ret = ldb_request(ldb_ctx, req);
         if (ret == LDB_SUCCESS) {
+                ret = ldb_transaction_commit(ldb_ctx);
+        } else {
+                ldb_transaction_cancel(ldb_ctx);
+                        ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+        }
+        if (ret == LDB_SUCCESS) {
+                ret = ldb_transaction_commit(ldb_ctx);
+        } else {
+                ldb_transaction_cancel(ldb_ctx);
                 if (ldb_ctx->err_string == NULL) {
                         /* no error string was setup by the backend */
 …
+                }
+        }
+        talloc_free(req);
         talloc_free(mem_ctx);
+        PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, PyLdb_AsLdbContext(self));
+        PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
+        Py_RETURN_NONE;
+}
+/**
+ * Obtain a ldb message from a Python Dictionary object.
+ *
+ * @param mem_ctx Memory context
+ * @param py_obj Python Dictionary object
+ * @param ldb_ctx LDB context
+ * @param mod_flags Flags to be set on every message element
+ * @return ldb_message on success or NULL on failure
+ */
+static struct ldb_message *PyDict_AsMessage(TALLOC_CTX *mem_ctx,
+                                            PyObject *py_obj,
+                                            struct ldb_context *ldb_ctx,
+                                            unsigned int mod_flags)
+{
+        struct ldb_message *msg;
+        unsigned int msg_pos = 0;
+        Py_ssize_t dict_pos = 0;
+        PyObject *key, *value;
+        struct ldb_message_element *msg_el;
+        PyObject *dn_value = PyDict_GetItemString(py_obj, "dn");
+        msg = ldb_msg_new(mem_ctx);
+        msg->elements = talloc_zero_array(msg, struct ldb_message_element, PyDict_Size(py_obj));
+        if (dn_value) {
+                if (!PyObject_AsDn(msg, dn_value, ldb_ctx, &msg->dn)) {
+                        PyErr_SetString(PyExc_TypeError, "unable to import dn object");
+                        return NULL;
+                }
+                if (msg->dn == NULL) {
+                        PyErr_SetString(PyExc_TypeError, "dn set but not found");
+                        return NULL;
+                }
+        } else {
+                PyErr_SetString(PyExc_TypeError, "no dn set");
+                return NULL;
+        }
+        while (PyDict_Next(py_obj, &dict_pos, &key, &value)) {
+                char *key_str = PyString_AsString(key);
+                if (strcmp(key_str, "dn") != 0) {
+                        msg_el = PyObject_AsMessageElement(msg->elements, value,
+                                                           mod_flags, key_str);
+                        if (msg_el == NULL) {
+                                PyErr_SetString(PyExc_TypeError, "unable to import element");
+                                return NULL;
+                        }
+                        memcpy(&msg->elements[msg_pos], msg_el, sizeof(*msg_el));
+                        msg_pos++;
+                }
+        }
+        msg->num_elements = msg_pos;
+        return msg;
+}
+static PyObject *py_ldb_add(PyLdbObject *self, PyObject *args)
+{
+        PyObject *py_obj;
+        int ret;
+        struct ldb_context *ldb_ctx;
+        struct ldb_request *req;
+        struct ldb_message *msg = NULL;
+        PyObject *py_controls = Py_None;
+        TALLOC_CTX *mem_ctx;
+        struct ldb_control **parsed_controls;
+        if (!PyArg_ParseTuple(args, "O|O", &py_obj, &py_controls ))
+                return NULL;
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        ldb_ctx = PyLdb_AsLdbContext(self);
+        if (py_controls == Py_None) {
+                parsed_controls = NULL;
+        } else {
+                const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
+                parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
+                talloc_free(controls);
+        }
+        if (PyLdbMessage_Check(py_obj)) {
+                msg = PyLdbMessage_AsMessage(py_obj);
+        } else if (PyDict_Check(py_obj)) {
+                msg = PyDict_AsMessage(mem_ctx, py_obj, ldb_ctx, LDB_FLAG_MOD_ADD);
+        } else {
+                PyErr_SetString(PyExc_TypeError,
+                                "Dictionary or LdbMessage object expected!");
+        }
+        if (!msg) {
+                /* we should have a PyErr already set */
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        ret = ldb_msg_sanity_check(ldb_ctx, msg);
+        if (ret != LDB_SUCCESS) {
+                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        ret = ldb_build_add_req(&req, ldb_ctx, mem_ctx, msg, parsed_controls,
+                                NULL, ldb_op_default_callback, NULL);
+        if (ret != LDB_SUCCESS) {
+                PyErr_SetString(PyExc_TypeError, "failed to build request");
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        /* do request and autostart a transaction */
+        /* Then let's LDB handle the message error in case of pb as they are meaningful */
+        ret = ldb_transaction_start(ldb_ctx);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(mem_ctx);
+                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
+        }
+        ret = ldb_request(ldb_ctx, req);
+        if (ret == LDB_SUCCESS) {
+                        ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+        }
+        if (ret == LDB_SUCCESS) {
+                        ret = ldb_transaction_commit(ldb_ctx);
+        } else {
+                ldb_transaction_cancel(ldb_ctx);
+                if (ldb_ctx->err_string == NULL) {
+                        /* no error string was setup by the backend */
+                        ldb_asprintf_errstring(ldb_ctx, "%s (%d)", ldb_strerror(ret), ret);
+                }
+        }
+        talloc_free(mem_ctx);
+        PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
         Py_RETURN_NONE;
 …
         struct ldb_dn *dn;
         int ret;
+        struct ldb_context *ldb;
+        if (!PyArg_ParseTuple(args, "O", &py_dn))
+                return NULL;
+        ldb = PyLdb_AsLdbContext(self);
+        if (!PyObject_AsDn(NULL, py_dn, ldb, &dn))
+                return NULL;
+        ret = ldb_delete(ldb, dn);
+        PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb);
+        struct ldb_context *ldb_ctx;
+        struct ldb_request *req;
+        PyObject *py_controls = Py_None;
+        TALLOC_CTX *mem_ctx;
+        struct ldb_control **parsed_controls;
+        if (!PyArg_ParseTuple(args, "O|O", &py_dn, &py_controls))
+                return NULL;
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        ldb_ctx = PyLdb_AsLdbContext(self);
+        if (py_controls == Py_None) {
+                parsed_controls = NULL;
+        } else {
+                const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
+                parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
+                talloc_free(controls);
+        }
+        if (!PyObject_AsDn(mem_ctx, py_dn, ldb_ctx, &dn)) {
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        ret = ldb_build_del_req(&req, ldb_ctx, mem_ctx, dn, parsed_controls,
+                                NULL, ldb_op_default_callback, NULL);
+        if (ret != LDB_SUCCESS) {
+                PyErr_SetString(PyExc_TypeError, "failed to build request");
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        /* do request and autostart a transaction */
+        /* Then let's LDB handle the message error in case of pb as they are meaningful */
+        ret = ldb_transaction_start(ldb_ctx);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(mem_ctx);
+                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
+        }
+        ret = ldb_request(ldb_ctx, req);
+        if (ret == LDB_SUCCESS) {
+                ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+        }
+        if (ret == LDB_SUCCESS) {
+                ret = ldb_transaction_commit(ldb_ctx);
+        } else {
+                ldb_transaction_cancel(ldb_ctx);
+                if (ldb_ctx->err_string == NULL) {
+                        /* no error string was setup by the backend */
+                        ldb_asprintf_errstring(ldb_ctx, "%s (%d)", ldb_strerror(ret), ret);
+                }
+        }
+        talloc_free(mem_ctx);
+        PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
         Py_RETURN_NONE;
 …
         struct ldb_context *ldb;
         TALLOC_CTX *mem_ctx;
+        if (!PyArg_ParseTuple(args, "OO", &py_dn1, &py_dn2))
+                return NULL;
+        PyObject *py_controls = Py_None;
+        struct ldb_control **parsed_controls;
+        struct ldb_context *ldb_ctx;
+        struct ldb_request *req;
+        ldb_ctx = PyLdb_AsLdbContext(self);
+        if (!PyArg_ParseTuple(args, "OO|O", &py_dn1, &py_dn2, &py_controls))
+                return NULL;
         mem_ctx = talloc_new(NULL);
 …
+        }
         ldb = PyLdb_AsLdbContext(self);
+        if (py_controls == Py_None) {
+                parsed_controls = NULL;
+        } else {
+                const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
+                parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
+                talloc_free(controls);
+        }
         if (!PyObject_AsDn(mem_ctx, py_dn1, ldb, &dn1)) {
                 talloc_free(mem_ctx);
 …
+        }
+        ret = ldb_rename(ldb, dn1, dn2);
+        ret = ldb_build_rename_req(&req, ldb_ctx, mem_ctx, dn1, dn2, parsed_controls,
+                                NULL, ldb_op_default_callback, NULL);
+        if (ret != LDB_SUCCESS) {
+                PyErr_SetString(PyExc_TypeError, "failed to build request");
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        /* do request and autostart a transaction */
+        /* Then let's LDB handle the message error in case of pb as they are meaningful */
+        ret = ldb_transaction_start(ldb_ctx);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(mem_ctx);
+                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
+        }
+        ret = ldb_request(ldb_ctx, req);
+        if (ret == LDB_SUCCESS) {
+                ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+        }
+        if (ret == LDB_SUCCESS) {
+                ret = ldb_transaction_commit(ldb_ctx);
+        } else {
+                ldb_transaction_cancel(ldb_ctx);
+                if (ldb_ctx->err_string == NULL) {
+                        /* no error string was setup by the backend */
+                        ldb_asprintf_errstring(ldb_ctx, "%s (%d)", ldb_strerror(ret), ret);
+                }
+        }
         talloc_free(mem_ctx);
         PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb);
+        PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
         Py_RETURN_NONE;
 …
 static PyObject *py_ldb_write_ldif(PyLdbMessageObject *self, PyObject *args)
+static PyObject *py_ldb_write_ldif(PyLdbObject *self, PyObject *args)
+{
         int changetype;
 …
 static PyObject *py_ldb_msg_diff(PyLdbObject *self, PyObject *args)
+{
+        int ldb_ret;
         PyObject *py_msg_old;
         PyObject *py_msg_new;
         struct ldb_message *diff;
+        struct ldb_context *ldb;
         PyObject *py_ret;
 …
+        }
+        diff = ldb_msg_diff(PyLdb_AsLdbContext(self), PyLdbMessage_AsMessage(py_msg_old), PyLdbMessage_AsMessage(py_msg_new));
+        if (diff == NULL)
+                return NULL;
+        ldb = PyLdb_AsLdbContext(self);
+        ldb_ret = ldb_msg_difference(ldb, ldb,
+                                     PyLdbMessage_AsMessage(py_msg_old),
+                                     PyLdbMessage_AsMessage(py_msg_new),
+                                     &diff);
+        if (ldb_ret != LDB_SUCCESS) {
+                PyErr_SetString(PyExc_RuntimeError, "Failed to generate the Ldb Message diff");
+                return NULL;
+        }
         py_ret = PyLdbMessage_FromMessage(diff);
+        talloc_unlink(ldb, diff);
         return py_ret;
 …
+{
         PyObject *py_base = Py_None;
         enum ldb_scope scope = LDB_SCOPE_DEFAULT;
+        int scope = LDB_SCOPE_DEFAULT;
         char *expr = NULL;
         PyObject *py_attrs = Py_None;
 …
         struct ldb_dn *base;
         PyObject *py_ret;
+        TALLOC_CTX *mem_ctx;
+        /* type "int" rather than "enum" for "scope" is intentional */
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OizOO",
                                          discard_const_p(char *, kwnames),
 …
                 return NULL;
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
         ldb_ctx = PyLdb_AsLdbContext(self);
 …
                 attrs = NULL;
         } else {
+                attrs = PyList_AsStringList(NULL, py_attrs, "attrs");
+                if (attrs == NULL)
+                attrs = PyList_AsStringList(mem_ctx, py_attrs, "attrs");
+                if (attrs == NULL) {
+                        talloc_free(mem_ctx);
                         return NULL;
+                }
+        }
 …
                 parsed_controls = NULL;
         } else {
                 const char **controls = PyList_AsStringList(ldb_ctx, py_controls, "controls");
                 parsed_controls = ldb_parse_control_strings(ldb_ctx, ldb_ctx, controls);
+                const char **controls = PyList_AsStringList(mem_ctx, py_controls, "controls");
+                parsed_controls = ldb_parse_control_strings(ldb_ctx, mem_ctx, controls);
                 talloc_free(controls);
+        }
         res = talloc_zero(ldb_ctx, struct ldb_result);
+        res = talloc_zero(mem_ctx, struct ldb_result);
         if (res == NULL) {
                 PyErr_NoMemory();
                 talloc_free(attrs);
                 return NULL;
+        }
         ret = ldb_build_search_req(&req, ldb_ctx, ldb_ctx,
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        ret = ldb_build_search_req(&req, ldb_ctx, mem_ctx,
                                    base,
                                    scope,
 …
                                    NULL);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(mem_ctx);
+                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
+                return NULL;
+        }
         talloc_steal(req, attrs);
-        if (ret != LDB_SUCCESS) {
-                talloc_free(res);
-                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
-                return NULL;
+        }
         ret = ldb_request(ldb_ctx, req);
 …
+        }
-        talloc_free(req);
         if (ret != LDB_SUCCESS) {
                 talloc_free(res);
+                talloc_free(mem_ctx);
                 PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb_ctx);
                 return NULL;
 …
         py_ret = PyLdbResult_FromResult(res);
         talloc_free(res);
+        talloc_free(mem_ctx);
         return py_ret;
 …
+}
+static PyObject *py_ldb_sequence_number(PyLdbObject *self, PyObject *args)
+{
+        struct ldb_context *ldb = PyLdb_AsLdbContext(self);
+        int type, ret;
+        uint64_t value;
+        if (!PyArg_ParseTuple(args, "i", &type))
+                return NULL;
+        /* FIXME: More interpretation */
+        ret = ldb_sequence_number(ldb, type, &value);
+        if (ret != LDB_SUCCESS) {
+                PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, ldb);
+                return NULL;
+        }
+        return PyLong_FromLongLong(value);
+}
 static PyMethodDef py_ldb_methods[] = {
         { "set_debug", (PyCFunction)py_ldb_set_debug, METH_VARARGS,
 …
                 "S.transaction_start() -> None\n"
                 "Start a new transaction." },
+        { "transaction_prepare_commit", (PyCFunction)py_ldb_transaction_prepare_commit, METH_NOARGS,
+                "S.transaction_prepare_commit() -> None\n"
+                "prepare to commit a new transaction (2-stage commit)." },
         { "transaction_commit", (PyCFunction)py_ldb_transaction_commit, METH_NOARGS,
                 "S.transaction_commit() -> None\n"
 …
                 "S.modules() -> list\n"
                 "Return the list of modules on this LDB connection " },
+        { "sequence_number", (PyCFunction)py_ldb_sequence_number, METH_VARARGS,
+                "S.sequence_number(type) -> value\n"
+                "Return the value of the sequence according to the requested type" },
         { NULL },
 };
 PyObject *PyLdbModule_FromModule(struct ldb_module *mod)
+static PyObject *PyLdbModule_FromModule(struct ldb_module *mod)
+{
         PyLdbModuleObject *ret;
 …
         struct ldb_dn *dn;
         struct ldb_result *result;
+        unsigned int count;
         int ret;
+        int count;
+        if (!PyObject_AsDn(ldb_ctx, obj, ldb_ctx, &dn))
+        if (!PyObject_AsDn(ldb_ctx, obj, ldb_ctx, &dn)) {
                 return -1;
+        ret = ldb_search(ldb_ctx, ldb_ctx, &result, dn, LDB_SCOPE_BASE, NULL, NULL);
+        }
+        ret = ldb_search(ldb_ctx, ldb_ctx, &result, dn, LDB_SCOPE_BASE, NULL,
+                         NULL);
         if (ret != LDB_SUCCESS) {
                 PyErr_SetLdbError(PyExc_LdbError, ret, ldb_ctx);
 …
         talloc_free(result);
+        if (count > 1) {
+                PyErr_Format(PyExc_RuntimeError,
+                             "Searching for [%s] dn gave %u results!",
+                             ldb_dn_get_linearized(dn),
+                             count);
+                return -1;
+        }
         return count;
+}
 …
 };
 PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx)
+static PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx)
+{
         PyLdbObject *ret;
 …
+}
 PyTypeObject PyLdb = {
         .tp_name = "Ldb",
+static PyTypeObject PyLdb = {
+        .tp_name = "ldb.Ldb",
         .tp_methods = py_ldb_methods,
         .tp_repr = (reprfunc)py_ldb_repr,
 …
 };
+static void py_ldb_result_dealloc(PyLdbResultObject *self)
+{
+        talloc_free(self->mem_ctx);
+        Py_DECREF(self->msgs);
+        Py_DECREF(self->referals);
+        Py_DECREF(self->controls);
+        self->ob_type->tp_free(self);
+}
+static PyObject *py_ldb_result_get_msgs(PyLdbResultObject *self, void *closure)
+{
+        Py_INCREF(self->msgs);
+        return self->msgs;
+}
+static PyObject *py_ldb_result_get_controls(PyLdbResultObject *self, void *closure)
+{
+        Py_INCREF(self->controls);
+        return self->controls;
+}
+static PyObject *py_ldb_result_get_referals(PyLdbResultObject *self, void *closure)
+{
+        Py_INCREF(self->referals);
+        return self->referals;
+}
+static PyObject *py_ldb_result_get_count(PyLdbResultObject *self, void *closure)
+{
+        Py_ssize_t size;
+        if (self->msgs == NULL) {
+                PyErr_SetString(PyExc_AttributeError, "Count attribute is meaningless in this context");
+                return NULL;
+        }
+        size = PyList_Size(self->msgs);
+        return PyInt_FromLong(size);
+}
+static PyGetSetDef py_ldb_result_getset[] = {
+        { discard_const_p(char, "controls"), (getter)py_ldb_result_get_controls, NULL, NULL },
+        { discard_const_p(char, "msgs"), (getter)py_ldb_result_get_msgs, NULL, NULL },
+        { discard_const_p(char, "referals"), (getter)py_ldb_result_get_referals, NULL, NULL },
+        { discard_const_p(char, "count"), (getter)py_ldb_result_get_count, NULL, NULL },
+        { NULL }
+};
+static PyObject *py_ldb_result_iter(PyLdbResultObject *self)
+{
+        return PyObject_GetIter(self->msgs);
+}
+static Py_ssize_t py_ldb_result_len(PyLdbResultObject *self)
+{
+        return PySequence_Size(self->msgs);
+}
+static PyObject *py_ldb_result_find(PyLdbResultObject *self, Py_ssize_t idx)
+{
+        return PySequence_GetItem(self->msgs, idx);
+}
+static PySequenceMethods py_ldb_result_seq = {
+        .sq_length = (lenfunc)py_ldb_result_len,
+        .sq_item = (ssizeargfunc)py_ldb_result_find,
+};
+static PyObject *py_ldb_result_repr(PyLdbObject *self)
+{
+        return PyString_FromFormat("<ldb result>");
+}
+static PyTypeObject PyLdbResult = {
+        .tp_name = "ldb.Result",
+        .tp_repr = (reprfunc)py_ldb_result_repr,
+        .tp_dealloc = (destructor)py_ldb_result_dealloc,
+        .tp_iter = (getiterfunc)py_ldb_result_iter,
+        .tp_getset = py_ldb_result_getset,
+        .tp_getattro = PyObject_GenericGetAttr,
+        .tp_basicsize = sizeof(PyLdbResultObject),
+        .tp_as_sequence = &py_ldb_result_seq,
+        .tp_doc = "LDB result.",
+        .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+};
 static PyObject *py_ldb_module_repr(PyLdbModuleObject *self)
+{
 …
         const char * const*attrs;
+        /* type "int" rather than "enum" for "scope" is intentional */
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiOO",
                                          discard_const_p(char *, kwnames),
 …
+{
         talloc_free(self->mem_ctx);
         self->ob_type->tp_free(self);
+}
 PyTypeObject PyLdbModule = {
         .tp_name = "LdbModule",
+        PyObject_Del(self);
+}
+static PyTypeObject PyLdbModule = {
+        .tp_name = "ldb.LdbModule",
         .tp_methods = py_ldb_module_methods,
         .tp_repr = (reprfunc)py_ldb_module_repr,
 …
  * @return New ldb_message_element, allocated as child of mem_ctx
  */
+struct ldb_message_element *PyObject_AsMessageElement(TALLOC_CTX *mem_ctx,
+                                                                                           PyObject *set_obj, int flags,
+                                                                                           const char *attr_name)
+static struct ldb_message_element *PyObject_AsMessageElement(
+                                                      TALLOC_CTX *mem_ctx,
+                                                      PyObject *set_obj,
+                                                      int flags,
+                                                      const char *attr_name)
+{
         struct ldb_message_element *me;
+        if (PyLdbMessageElement_Check(set_obj))
+                return talloc_reference(mem_ctx,
+                                                                PyLdbMessageElement_AsMessageElement(set_obj));
+        if (PyLdbMessageElement_Check(set_obj)) {
+                PyLdbMessageElementObject *set_obj_as_me = (PyLdbMessageElementObject *)set_obj;
+                /* We have to talloc_reference() the memory context, not the pointer
+                 * which may not actually be it's own context */
+                if (talloc_reference(mem_ctx, set_obj_as_me->mem_ctx)) {
+                        return PyLdbMessageElement_AsMessageElement(set_obj);
+                }
+                return NULL;
+        }
         me = talloc(mem_ctx, struct ldb_message_element);
+        if (me == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
         me->name = talloc_strdup(me, attr_name);
 …
                 me->values[0].length = PyString_Size(set_obj);
                 me->values[0].data = talloc_memdup(me,
                         (uint8_t *)PyString_AsString(set_obj), me->values[0].length);
+                        (uint8_t *)PyString_AsString(set_obj), me->values[0].length+1);
         } else if (PySequence_Check(set_obj)) {
                 int i;
+                Py_ssize_t i;
                 me->num_values = PySequence_Size(set_obj);
                 me->values = talloc_array(me, struct ldb_val, me->num_values);
                 for (i = 0; i < me->num_values; i++) {
                         PyObject *obj = PySequence_GetItem(set_obj, i);
+                        if (!PyString_Check(obj)) {
+                                PyErr_Format(PyExc_TypeError,
+                                             "Expected string as element %zd in list", i);
+                                talloc_free(me);
+                                return NULL;
+                        }
                         me->values[i].length = PyString_Size(obj);
                         me->values[i].data = talloc_memdup(me,
                                 (uint8_t *)PyString_AsString(obj), me->values[i].length);
+                                (uint8_t *)PyString_AsString(obj), me->values[i].length+1);
+                }
         } else {
 …
 static PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
                                                                  struct ldb_message_element *me)
+{
         int i;
+static PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
+                                        struct ldb_message_element *me)
+{
+        Py_ssize_t i;
         PyObject *result;
 …
         for (i = 0; i < me->num_values; i++) {
                 PyList_SetItem(result, i,
                         PyObject_FromLdbValue(ldb_ctx, me, &me->values[i]));
+                        PyObject_FromLdbValue(&me->values[i]));
+        }
 …
 static PyObject *py_ldb_msg_element_get(PyLdbMessageElementObject *self, PyObject *args)
+{
         int i;
         if (!PyArg_ParseTuple(args, "i", &i))
                 return NULL;
         if (i < 0 || i >= PyLdbMessageElement_AsMessageElement(self)->num_values)
+        unsigned int i;
+        if (!PyArg_ParseTuple(args, "I", &i))
+                return NULL;
+        if (i >= PyLdbMessageElement_AsMessageElement(self)->num_values)
                 Py_RETURN_NONE;
+        return PyObject_FromLdbValue(NULL, PyLdbMessageElement_AsMessageElement(self),
+                                                                 &(PyLdbMessageElement_AsMessageElement(self)->values[i]));
+        return PyObject_FromLdbValue(&(PyLdbMessageElement_AsMessageElement(self)->values[i]));
+}
 static PyObject *py_ldb_msg_element_flags(PyLdbMessageElementObject *self, PyObject *args)
+{
+        struct ldb_message_element *el;
+        el = PyLdbMessageElement_AsMessageElement(self);
+        struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
         return PyInt_FromLong(el->flags);
+}
 …
 static int py_ldb_msg_element_cmp(PyLdbMessageElementObject *self, PyLdbMessageElementObject *other)
+{
+        return ldb_msg_element_compare(PyLdbMessageElement_AsMessageElement(self),
+                                                                   PyLdbMessageElement_AsMessageElement(other));
+        int ret = ldb_msg_element_compare(PyLdbMessageElement_AsMessageElement(self),
+                                                                          PyLdbMessageElement_AsMessageElement(other));
+        return SIGN(ret);
+}
 …
+}
 PyObject *PyLdbMessageElement_FromMessageElement(struct ldb_message_element *el, TALLOC_CTX *mem_ctx)
+static PyObject *PyLdbMessageElement_FromMessageElement(struct ldb_message_element *el, TALLOC_CTX *mem_ctx)
+{
         PyLdbMessageElementObject *ret;
         ret = (PyLdbMessageElementObject *)PyLdbMessageElement.tp_alloc(&PyLdbMessageElement, 0);
+        ret = PyObject_New(PyLdbMessageElementObject, &PyLdbMessageElement);
         if (ret == NULL) {
                 PyErr_NoMemory();
 …
         el = talloc_zero(mem_ctx, struct ldb_message_element);
+        if (el == NULL) {
+                PyErr_NoMemory();
+                talloc_free(mem_ctx);
+                return NULL;
+        }
         if (py_elements != NULL) {
                 int i;
+                Py_ssize_t i;
                 if (PyString_Check(py_elements)) {
                         el->num_values = 1;
                         el->values = talloc_array(el, struct ldb_val, 1);
+                        if (el->values == NULL) {
+                                talloc_free(mem_ctx);
+                                PyErr_NoMemory();
+                                return NULL;
+                        }
                         el->values[0].length = PyString_Size(py_elements);
                         el->values[0].data = talloc_memdup(el,
                                 (uint8_t *)PyString_AsString(py_elements), el->values[0].length);
+                        el->values[0].data = talloc_memdup(el->values,
+                                (uint8_t *)PyString_AsString(py_elements), el->values[0].length+1);
                 } else if (PySequence_Check(py_elements)) {
                         el->num_values = PySequence_Size(py_elements);
                         el->values = talloc_array(el, struct ldb_val, el->num_values);
+                        if (el->values == NULL) {
+                                talloc_free(mem_ctx);
+                                PyErr_NoMemory();
+                                return NULL;
+                        }
                         for (i = 0; i < el->num_values; i++) {
                                 PyObject *item = PySequence_GetItem(py_elements, i);
+                                if (item == NULL) {
+                                        talloc_free(mem_ctx);
+                                        return NULL;
+                                }
                                 if (!PyString_Check(item)) {
                                         PyErr_Format(PyExc_TypeError,
+                                                        "Expected string as element %d in list",
+                                                        i);
+                                                     "Expected string as element %zd in list", i);
                                         talloc_free(mem_ctx);
                                         return NULL;
+                                }
                                 el->values[i].length = PyString_Size(item);
                                 el->values[i].data = talloc_memdup(el,
                                         (uint8_t *)PyString_AsString(item), el->values[i].length);
+                                el->values[i].data = talloc_memdup(el,
+                                        (uint8_t *)PyString_AsString(item), el->values[i].length+1);
+                        }
                 } else {
 …
         el->name = talloc_strdup(el, name);
         ret = (PyLdbMessageElementObject *)PyLdbMessageElement.tp_alloc(&PyLdbMessageElement, 0);
+        ret = PyObject_New(PyLdbMessageElementObject, type);
         if (ret == NULL) {
-                PyErr_NoMemory();
                 talloc_free(mem_ctx);
                 return NULL;
 …
+{
         char *element_str = NULL;
         int i;
+        Py_ssize_t i;
         struct ldb_message_element *el = PyLdbMessageElement_AsMessageElement(self);
         PyObject *ret;
 …
+        }
+        ret = PyString_FromFormat("MessageElement([%s])", element_str);
+        talloc_free(element_str);
+        if (element_str != NULL) {
+                ret = PyString_FromFormat("MessageElement([%s])", element_str);
+                talloc_free(element_str);
+        } else {
+                ret = PyString_FromString("MessageElement([])");
+        }
         return ret;
 …
         if (el->num_values == 1)
                 return PyString_FromStringAndSize((char *)el->values[0].data, el->values[0].length);
         else
+        else
                 Py_RETURN_NONE;
+}
 …
+{
         talloc_free(self->mem_ctx);
         self->ob_type->tp_free(self);
+}
 PyTypeObject PyLdbMessageElement = {
         .tp_name = "MessageElement",
+        PyObject_Del(self);
+}
+static PyTypeObject PyLdbMessageElement = {
+        .tp_name = "ldb.MessageElement",
         .tp_basicsize = sizeof(PyLdbMessageElementObject),
         .tp_dealloc = (destructor)py_ldb_msg_element_dealloc,
 …
 };
+static PyObject *py_ldb_msg_from_dict(PyTypeObject *type, PyObject *args)
+{
+        PyObject *py_ldb;
+        PyObject *py_dict;
+        PyObject *py_ret;
+        struct ldb_message *msg;
+        struct ldb_context *ldb_ctx;
+        unsigned int mod_flags = LDB_FLAG_MOD_REPLACE;
+        if (!PyArg_ParseTuple(args, "O!O!|I",
+                              &PyLdb, &py_ldb, &PyDict_Type, &py_dict,
+                              &mod_flags)) {
+                return NULL;
+        }
+        /* mask only flags we are going to use */
+        mod_flags = LDB_FLAG_MOD_TYPE(mod_flags);
+        if (!mod_flags) {
+                PyErr_SetString(PyExc_ValueError,
+                                "FLAG_MOD_ADD, FLAG_MOD_REPLACE or FLAG_MOD_DELETE"
+                                " expected as mod_flag value");
+                return NULL;
+        }
+        ldb_ctx = PyLdb_AsLdbContext(py_ldb);
+        msg = PyDict_AsMessage(ldb_ctx, py_dict, ldb_ctx, mod_flags);
+        if (!msg) {
+                return NULL;
+        }
+        py_ret = PyLdbMessage_FromMessage(msg);
+        talloc_unlink(ldb_ctx, msg);
+        return py_ret;
+}
 static PyObject *py_ldb_msg_remove_attr(PyLdbMessageObject *self, PyObject *args)
+{
 …
+{
         struct ldb_message *msg = PyLdbMessage_AsMessage(self);
         int i, j = 0;
+        Py_ssize_t i, j = 0;
         PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
         if (msg->dn != NULL) {
 …
                 return NULL;
+        }
         return (PyObject *)PyLdbMessageElement_FromMessageElement(el, msg);
+        return (PyObject *)PyLdbMessageElement_FromMessageElement(el, msg->elements);
+}
 …
+{
         struct ldb_message *msg = PyLdbMessage_AsMessage(self);
         int i, j;
+        Py_ssize_t i, j = 0;
         PyObject *l = PyList_New(msg->num_elements + (msg->dn == NULL?0:1));
-        j = 0;
         if (msg->dn != NULL) {
                 PyList_SetItem(l, 0, Py_BuildValue("(sO)", "dn", PyLdbDn_FromDn(msg->dn)));
 …
+        }
         for (i = 0; i < msg->num_elements; i++, j++) {
+                PyList_SetItem(l, j, Py_BuildValue("(sO)", msg->elements[i].name, PyLdbMessageElement_FromMessageElement(&msg->elements[i], self->msg)));
+                PyObject *py_el = PyLdbMessageElement_FromMessageElement(&msg->elements[i], msg->elements);
+                PyObject *value = Py_BuildValue("(sO)", msg->elements[i].name, py_el);
+                PyList_SetItem(l, j, value);
+        }
         return l;
+}
+static PyMethodDef py_ldb_msg_methods[] = {
+        { "keys", (PyCFunction)py_ldb_msg_keys, METH_NOARGS, NULL },
+        { "remove", (PyCFunction)py_ldb_msg_remove_attr, METH_VARARGS, NULL },
+static PyObject *py_ldb_msg_elements(PyLdbMessageObject *self)
+{
+        struct ldb_message *msg = PyLdbMessage_AsMessage(self);
+        Py_ssize_t i = 0;
+        PyObject *l = PyList_New(msg->num_elements);
+        for (i = 0; i < msg->num_elements; i++) {
+                PyList_SetItem(l, i, PyLdbMessageElement_FromMessageElement(&msg->elements[i], msg->elements));
+        }
+        return l;
+}
+static PyObject *py_ldb_msg_add(PyLdbMessageObject *self, PyObject *args)
+{
+        struct ldb_message *msg = PyLdbMessage_AsMessage(self);
+        PyLdbMessageElementObject *py_element;
+        int ret;
+        struct ldb_message_element *el;
+        if (!PyArg_ParseTuple(args, "O!", &PyLdbMessageElement, &py_element))
+                return NULL;
+        el = talloc_reference(msg, py_element->el);
+        if (el == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        ret = ldb_msg_add(msg, el, el->flags);
+        PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, NULL);
+        Py_RETURN_NONE;
+}
+static PyMethodDef py_ldb_msg_methods[] = {
+        { "from_dict", (PyCFunction)py_ldb_msg_from_dict, METH_CLASS | METH_VARARGS,
+                "Message.from_dict(ldb, dict, mod_flag=FLAG_MOD_REPLACE) -> ldb.Message\n"
+                "Class method to create ldb.Message object from Dictionary.\n"
+                "mod_flag is one of FLAG_MOD_ADD, FLAG_MOD_REPLACE or FLAG_MOD_DELETE."},
+        { "keys", (PyCFunction)py_ldb_msg_keys, METH_NOARGS,
+                "S.keys() -> list\n\n"
+                "Return sequence of all attribute names." },
+        { "remove", (PyCFunction)py_ldb_msg_remove_attr, METH_VARARGS,
+                "S.remove(name)\n\n"
+                "Remove all entries for attributes with the specified name."},
         { "get", (PyCFunction)py_ldb_msg_get, METH_VARARGS, NULL },
         { "items", (PyCFunction)py_ldb_msg_items, METH_NOARGS, NULL },
+        { "elements", (PyCFunction)py_ldb_msg_elements, METH_NOARGS, NULL },
+        { "add", (PyCFunction)py_ldb_msg_add, METH_VARARGS,
+                "S.append(element)\n\n"
+                "Add an element to this message." },
         { NULL },
 };
 …
                 return -1;
+        }
         attr_name = PyString_AsString(name);
         if (value == NULL) {
 …
         } else {
                 struct ldb_message_element *el = PyObject_AsMessageElement(self->msg,
                                                                                         value, 0, attr_name);
+                                                                           value, 0, attr_name);
                 if (el == NULL)
                         return -1;
 …
+}
 PyObject *PyLdbMessage_FromMessage(struct ldb_message *msg)
+static PyObject *PyLdbMessage_FromMessage(struct ldb_message *msg)
+{
         PyLdbMessageObject *ret;
 …
+{
         talloc_free(self->mem_ctx);
+        self->ob_type->tp_free(self);
+}
+PyTypeObject PyLdbMessage = {
+        .tp_name = "Message",
+        PyObject_Del(self);
+}
+static int py_ldb_msg_compare(PyLdbMessageObject *py_msg1,
+                              PyLdbMessageObject *py_msg2)
+{
+        struct ldb_message *msg1 = PyLdbMessage_AsMessage(py_msg1),
+                           *msg2 = PyLdbMessage_AsMessage(py_msg2);
+        unsigned int i;
+        int ret;
+        if ((msg1->dn != NULL) || (msg2->dn != NULL)) {
+                ret = ldb_dn_compare(msg1->dn, msg2->dn);
+                if (ret != 0) {
+                        return SIGN(ret);
+                }
+        }
+        ret = msg1->num_elements - msg2->num_elements;
+        if (ret != 0) {
+                return SIGN(ret);
+        }
+        for (i = 0; i < msg1->num_elements; i++) {
+                ret = ldb_msg_element_compare_name(&msg1->elements[i],
+                                                   &msg2->elements[i]);
+                if (ret != 0) {
+                        return SIGN(ret);
+                }
+                ret = ldb_msg_element_compare(&msg1->elements[i],
+                                              &msg2->elements[i]);
+                if (ret != 0) {
+                        return SIGN(ret);
+                }
+        }
+        return 0;
+}
+static PyTypeObject PyLdbMessage = {
+        .tp_name = "ldb.Message",
         .tp_methods = py_ldb_msg_methods,
         .tp_getset = py_ldb_msg_getset,
 …
         .tp_flags = Py_TPFLAGS_DEFAULT,
         .tp_iter = (getiterfunc)py_ldb_msg_iter,
+        .tp_compare = (cmpfunc)py_ldb_msg_compare,
 };
 PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *tree)
+static PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *tree)
+{
         PyLdbTreeObject *ret;
 …
+{
         talloc_free(self->mem_ctx);
         self->ob_type->tp_free(self);
+}
 PyTypeObject PyLdbTree = {
         .tp_name = "Tree",
+        PyObject_Del(self);
+}
+static PyTypeObject PyLdbTree = {
+        .tp_name = "ldb.Tree",
         .tp_basicsize = sizeof(PyLdbTreeObject),
         .tp_dealloc = (destructor)py_ldb_tree_dealloc,
 …
 static PyObject *py_timestring(PyObject *module, PyObject *args)
+{
+        time_t t;
+        /* most times "time_t" is a signed integer type with 32 or 64 bit:
+         * http://stackoverflow.com/questions/471248/what-is-ultimately-a-time-t-typedef-to */
+        long int t_val;
         char *tresult;
         PyObject *ret;
         if (!PyArg_ParseTuple(args, "L", &t))
                 return NULL;
         tresult = ldb_timestring(NULL, t);
+        if (!PyArg_ParseTuple(args, "l", &t_val))
+                return NULL;
+        tresult = ldb_timestring(NULL, (time_t) t_val);
         ret = PyString_FromString(tresult);
         talloc_free(tresult);
 …
                 return;
+        if (PyType_Ready(&PyLdbResult) < 0)
+                return;
+        if (PyType_Ready(&PyLdbControl) < 0)
+                return;
         m = Py_InitModule3("ldb", py_ldb_global_methods,
                 "An interface to LDB, a LDAP-like API that can either to talk an embedded database (TDB-based) or a standards-compliant LDAP server.");
 …
                 return;
+        PyModule_AddObject(m, "SEQ_HIGHEST_SEQ", PyInt_FromLong(LDB_SEQ_HIGHEST_SEQ));
+        PyModule_AddObject(m, "SEQ_HIGHEST_TIMESTAMP", PyInt_FromLong(LDB_SEQ_HIGHEST_TIMESTAMP));
+        PyModule_AddObject(m, "SEQ_NEXT", PyInt_FromLong(LDB_SEQ_NEXT));
         PyModule_AddObject(m, "SCOPE_DEFAULT", PyInt_FromLong(LDB_SCOPE_DEFAULT));
         PyModule_AddObject(m, "SCOPE_BASE", PyInt_FromLong(LDB_SCOPE_BASE));
 …
         PyModule_AddObject(m, "ERR_OTHER", PyInt_FromLong(LDB_ERR_OTHER));
+        PyModule_AddObject(m, "FLG_RDONLY", PyInt_FromLong(LDB_FLG_RDONLY));
+        PyModule_AddObject(m, "FLG_NOSYNC", PyInt_FromLong(LDB_FLG_NOSYNC));
+        PyModule_AddObject(m, "FLG_RECONNECT", PyInt_FromLong(LDB_FLG_RECONNECT));
+        PyModule_AddObject(m, "FLG_NOMMAP", PyInt_FromLong(LDB_FLG_NOMMAP));
+        PyModule_AddObject(m, "FLG_RDONLY", PyInt_FromLong(LDB_FLG_RDONLY));
+        PyModule_AddObject(m, "FLG_NOSYNC", PyInt_FromLong(LDB_FLG_NOSYNC));
+        PyModule_AddObject(m, "FLG_RECONNECT", PyInt_FromLong(LDB_FLG_RECONNECT));
+        PyModule_AddObject(m, "FLG_NOMMAP", PyInt_FromLong(LDB_FLG_NOMMAP));
         PyModule_AddObject(m, "__docformat__", PyString_FromString("restructuredText"));
 …
         Py_INCREF(&PyLdbMessageElement);
         Py_INCREF(&PyLdbTree);
+        Py_INCREF(&PyLdbResult);
+        Py_INCREF(&PyLdbControl);
         PyModule_AddObject(m, "Ldb", (PyObject *)&PyLdb);
 …
         PyModule_AddObject(m, "Module", (PyObject *)&PyLdbModule);
         PyModule_AddObject(m, "Tree", (PyObject *)&PyLdbTree);
+}
+        PyModule_AddObject(m, "Control", (PyObject *)&PyLdbControl);
+        PyModule_AddObject(m, "__version__", PyString_FromString(PACKAGE_VERSION));
+}

trunk/server/source4/lib/ldb/pyldb.h

-              r414
+              r745
    Unix SMB/CIFS implementation.
    Swig interface to ldb.
+   Python interface to ldb.
    Copyright (C) 2007-2008 Jelmer Vernooij <jelmer@samba.org>
 …
 #define _PYLDB_H_
-#include <Python.h>
 #include <talloc.h>
 typedef struct {
         PyObject_HEAD
+        TALLOC_CTX *mem_ctx;
         struct ldb_context *ldb_ctx;
-        TALLOC_CTX *mem_ctx;
 } PyLdbObject;
-PyObject *PyLdb_FromLdbContext(struct ldb_context *ldb_ctx);
 #define PyLdb_AsLdbContext(pyobj) ((PyLdbObject *)pyobj)->ldb_ctx
 #define PyLdb_Check(ob) PyObject_TypeCheck(ob, &PyLdb)
 …
 typedef struct {
         PyObject_HEAD
+        TALLOC_CTX *mem_ctx;
         struct ldb_dn *dn;
-        TALLOC_CTX *mem_ctx;
 } PyLdbDnObject;
 …
 typedef struct {
         PyObject_HEAD
+        TALLOC_CTX *mem_ctx;
         struct ldb_message *msg;
-        TALLOC_CTX *mem_ctx;
 } PyLdbMessageObject;
 #define PyLdbMessage_Check(ob) PyObject_TypeCheck(ob, &PyLdbMessage)
 …
 typedef struct {
         PyObject_HEAD
+        TALLOC_CTX *mem_ctx;
         struct ldb_module *mod;
-        TALLOC_CTX *mem_ctx;
 } PyLdbModuleObject;
-PyObject *PyLdbMessage_FromMessage(struct ldb_message *message);
-PyObject *PyLdbModule_FromModule(struct ldb_module *mod);
 #define PyLdbModule_AsModule(pyobj) ((PyLdbModuleObject *)pyobj)->mod
 typedef struct {
+        PyObject_HEAD
+        PyObject_HEAD
+        TALLOC_CTX *mem_ctx;
         struct ldb_message_element *el;
-        TALLOC_CTX *mem_ctx;
 } PyLdbMessageElementObject;
-struct ldb_message_element *PyObject_AsMessageElement(TALLOC_CTX *mem_ctx, PyObject *obj, int flags, const char *name);
-PyObject *PyLdbMessageElement_FromMessageElement(struct ldb_message_element *, TALLOC_CTX *mem_ctx);
 #define PyLdbMessageElement_AsMessageElement(pyobj) ((PyLdbMessageElementObject *)pyobj)->el
 #define PyLdbMessageElement_Check(ob) PyObject_TypeCheck(ob, &PyLdbMessageElement)
 …
 typedef struct {
         PyObject_HEAD
+        TALLOC_CTX *mem_ctx;
         struct ldb_parse_tree *tree;
+} PyLdbTreeObject;
+#define PyLdbTree_AsTree(pyobj) ((PyLdbTreeObject *)pyobj)->tree
+typedef struct {
+        PyObject_HEAD
         TALLOC_CTX *mem_ctx;
+} PyLdbTreeObject;
+PyObject *PyLdbTree_FromTree(struct ldb_parse_tree *);
+#define PyLdbTree_AsTree(pyobj) ((PyLdbTreeObject *)pyobj)->tree
+        PyObject *msgs;
+        PyObject *referals;
+        PyObject *controls;
+} PyLdbResultObject;
+typedef struct {
+        PyObject_HEAD
+        TALLOC_CTX *mem_ctx;
+        struct ldb_control *data;
+} PyLdbControlObject;
 #define PyErr_LDB_ERROR_IS_ERR_RAISE(err,ret,ldb) \

trunk/server/source4/lib/ldb/tests/photo.ldif

r414	r745
2	2	changetype: modify
3	3	add: jpegPhoto
4		jpegPhoto:< file://tests/~~tmp/~~samba4.png
	4	jpegPhoto:< file://tests/samba4.png
5	5

trunk/server/source4/lib/ldb/tests/python/api.py

-              r414
+              r745
 #!/usr/bin/python
+#!/usr/bin/env python
 # Simple tests for the ldb python bindings.
 # Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
 import os, sys
+import os
 import unittest
-# Required for the standalone LDB build
-sys.path.append("build/lib.linux-i686-2.4")
 import ldb
 def filename():
+    return os.tempnam()
+    import tempfile
+    try:
+        dir_prefix = os.path.join(os.environ["SELFTEST_PREFIX"], "tmp")
+    except KeyError:
+        dir_prefix = None
+    return tempfile.mktemp(dir=dir_prefix)
 class NoContextTests(unittest.TestCase):
 …
     def test_modules_tdb(self):
         x = ldb.Ldb("bar.ldb")
+        x = ldb.Ldb(filename())
         self.assertEquals("[<ldb module 'tdb'>]", repr(x.modules()))
 …
     def test_search_attr_string(self):
         l = ldb.Ldb("foo.tdb")
+        l = ldb.Ldb(filename())
         self.assertRaises(TypeError, l.search, attrs="dc")
 …
         self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo2")))
+    def test_delete_w_unhandled_ctrl(self):
+        l = ldb.Ldb(filename())
+        m = ldb.Message()
+        m.dn = ldb.Dn(l, "dc=foo1")
+        m["b"] = ["a"]
+        l.add(m)
+        self.assertRaises(ldb.LdbError, lambda: l.delete(m.dn, ["search_options:1:2"]))
+        l.delete(m.dn)
     def test_contains(self):
+        l = ldb.Ldb(filename())
+        name = filename()
+        l = ldb.Ldb(name)
         self.assertFalse(ldb.Dn(l, "dc=foo3") in l)
         l = ldb.Ldb(filename())
+        l = ldb.Ldb(name)
         m = ldb.Message()
         m.dn = ldb.Dn(l, "dc=foo3")
 …
             rm = l.search(m.dn)[0]
             self.assertEquals(1, len(rm))
             rm = l.search(m.dn, attrs=["bla"])[0]
+            rm = l.search(m.dn, attrs=["bla"])
             self.assertEquals(0, len(rm))
         finally:
 …
             self.assertEquals(2, len(rm))
             self.assertEquals(["1234", "456"], list(rm["bla"]))
             #Now create another modify, but switch the flags before we do it
+            # Now create another modify, but switch the flags before we do it
             m["bla"] = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
             m["bla"].set_flags(ldb.FLAG_MOD_DELETE)
 …
             self.assertEquals(1, len(rm))
             self.assertEquals(["1234"], list(rm["bla"]))
         finally:
             l.delete(ldb.Dn(l, "dc=add"))
 …
         self.assertEquals("foo\0bar", res[0]["displayname"][0])
+    def test_no_crash_broken_expr(self):
+        l = ldb.Ldb(filename())
+        self.assertRaises(ldb.LdbError,lambda: l.search("", ldb.SCOPE_SUBTREE, "&(dc=*)(dn=*)", ["dc"]))
 class DnTests(unittest.TestCase):
 …
         y = ldb.Dn(self.ldb, "dc=foo11,bar=bloe")
         self.assertEquals(x, y)
+        y = ldb.Dn(self.ldb, "dc=foo11,bar=blie")
+        self.assertNotEquals(x, y)
     def test_str(self):
 …
         x = ldb.Dn(self.ldb, "@BLA")
         self.assertEquals(None, x.parent())
-    def test_compare(self):
-        x = ldb.Dn(self.ldb, "dc=foo17,bar=bloe")
-        y = ldb.Dn(self.ldb, "dc=foo17,bar=bloe")
-        self.assertEquals(x, y)
-        z = ldb.Dn(self.ldb, "dc=foo17,bar=blie")
-        self.assertNotEquals(z, y)
     def test_is_valid(self):
 …
         self.assertTrue(x.is_valid())
         x = ldb.Dn(self.ldb, "")
+        # is_valid()'s return values appears to be a side effect of
+        # some other ldb functions. yuck.
+        # self.assertFalse(x.is_valid())
+        self.assertTrue(x.is_valid())
     def test_is_special(self):
 …
         ldif = self.ldb.write_ldif(msg[1], ldb.CHANGETYPE_NONE)
         self.assertEquals("dn: foo=bar\n\n", ldif)
     def test_parse_ldif_more(self):
         msgs = self.ldb.parse_ldif("dn: foo=bar\n\n\ndn: bar=bar")
 …
     def test_iter_items(self):
         self.assertEquals(0, len(self.msg.items()))
         self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo28")
+        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "dc=foo28")
         self.assertEquals(1, len(self.msg.items()))
     def test_repr(self):
         self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo29")
+        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "dc=foo29")
         self.msg["dc"] = "foo"
         self.assertEquals("Message({'dn': Dn('dc=foo29'), 'dc': MessageElement(['foo'])})", repr(self.msg))
 …
     def test_del(self):
         del self.msg["foo"]
+    def test_add(self):
+        self.msg.add(ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla"))
+    def test_elements_empty(self):
+        self.assertEquals([], self.msg.elements())
+    def test_elements(self):
+        el = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
+        self.msg.add(el)
+        self.assertEquals([el], self.msg.elements())
     def test_add_value(self):
 …
     def test_keys(self):
         self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO")
+        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "@BASEINFO")
         self.msg["foo"] = ["bla"]
         self.msg["bar"] = ["bla"]
 …
     def test_get_dn(self):
         self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO")
+        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "@BASEINFO")
         self.assertEquals("@BASEINFO", self.msg.get("dn").__str__())
     def test_get_invalid(self):
         self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "@BASEINFO")
+        self.msg.dn = ldb.Dn(ldb.Ldb(filename()), "@BASEINFO")
         self.assertRaises(TypeError, self.msg.get, 42)
 …
         self.assertEquals(1, len(msgdiff))
+    def test_equal_empty(self):
+        msg1 = ldb.Message()
+        msg2 = ldb.Message()
+        self.assertEquals(msg1, msg2)
+    def test_equal_simplel(self):
+        db = ldb.Ldb(filename())
+        msg1 = ldb.Message()
+        msg1.dn = ldb.Dn(db, "foo=bar")
+        msg2 = ldb.Message()
+        msg2.dn = ldb.Dn(db, "foo=bar")
+        self.assertEquals(msg1, msg2)
+        msg1['foo'] = 'bar'
+        msg2['foo'] = 'bar'
+        self.assertEquals(msg1, msg2)
+        msg2['foo'] = 'blie'
+        self.assertNotEquals(msg1, msg2)
+        msg2['foo'] = 'blie'
+    def test_from_dict(self):
+        rec = {"dn": "dc=fromdict",
+               "a1": ["a1-val1", "a1-val1"]}
+        l = ldb.Ldb()
+        # check different types of input Flags
+        for flags in [ldb.FLAG_MOD_ADD, ldb.FLAG_MOD_REPLACE, ldb.FLAG_MOD_DELETE]:
+            m = ldb.Message.from_dict(l, rec, flags)
+            self.assertEquals(rec["a1"], list(m["a1"]))
+            self.assertEquals(flags, m["a1"].flags())
+        # check input params
+        self.assertRaises(TypeError, ldb.Message.from_dict, dict(), rec, ldb.FLAG_MOD_REPLACE)
+        self.assertRaises(TypeError, ldb.Message.from_dict, l, list(), ldb.FLAG_MOD_REPLACE)
+        self.assertRaises(ValueError, ldb.Message.from_dict, l, rec, 0)
+        # Message.from_dict expects dictionary with 'dn'
+        err_rec = {"a1": ["a1-val1", "a1-val1"]}
+        self.assertRaises(TypeError, ldb.Message.from_dict, l, err_rec, ldb.FLAG_MOD_REPLACE)
 …
         self.assertEquals(y, x)
+    def test_extended(self):
+        el = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
+        self.assertEquals("MessageElement(['456'])", repr(el))
 class ModuleTests(unittest.TestCase):
 …
                 return self.next.search(*args, **kwargs)
+        def request(self, *args, **kwargs):
+            pass
+        name = filename()
         ldb.register_module(ExampleModule)
         if os.path.exists("usemodule.ldb"):
             os.unlink("usemodule.ldb")
         l = ldb.Ldb("usemodule.ldb")
+        if os.path.exists(name):
+            os.unlink(name)
+        l = ldb.Ldb(name)
         l.add({"dn": "@MODULES", "@LIST": "bla"})
         self.assertEquals([], ops)
         l = ldb.Ldb("usemodule.ldb")
+        l = ldb.Ldb(name)
         self.assertEquals(["init"], ops)
+class LdbResultTests(unittest.TestCase):
+    def setUp(self):
+        name = filename()
+        self.name = name
+        if os.path.exists(name):
+            os.unlink(name)
+        self.l = ldb.Ldb(name)
+        self.l.add({"dn": "DC=SAMBA,DC=ORG", "name": "samba.org"})
+        self.l.add({"dn": "OU=ADMIN,DC=SAMBA,DC=ORG", "name": "Admins"})
+        self.l.add({"dn": "OU=USERS,DC=SAMBA,DC=ORG", "name": "Users"})
+        self.l.add({"dn": "OU=OU1,DC=SAMBA,DC=ORG", "name": "OU #1"})
+        self.l.add({"dn": "OU=OU2,DC=SAMBA,DC=ORG", "name": "OU #2"})
+        self.l.add({"dn": "OU=OU3,DC=SAMBA,DC=ORG", "name": "OU #3"})
+        self.l.add({"dn": "OU=OU4,DC=SAMBA,DC=ORG", "name": "OU #4"})
+        self.l.add({"dn": "OU=OU5,DC=SAMBA,DC=ORG", "name": "OU #5"})
+        self.l.add({"dn": "OU=OU6,DC=SAMBA,DC=ORG", "name": "OU #6"})
+        self.l.add({"dn": "OU=OU7,DC=SAMBA,DC=ORG", "name": "OU #7"})
+        self.l.add({"dn": "OU=OU8,DC=SAMBA,DC=ORG", "name": "OU #8"})
+        self.l.add({"dn": "OU=OU9,DC=SAMBA,DC=ORG", "name": "OU #9"})
+        self.l.add({"dn": "OU=OU10,DC=SAMBA,DC=ORG", "name": "OU #10"})
+    def tearDown(self):
+        if os.path.exists(self.name):
+            os.unlink(self.name)
+    def test_return_type(self):
+        res = self.l.search()
+        self.assertEquals(str(res), "<ldb result>")
+    def test_get_msgs(self):
+        res = self.l.search()
+        list = res.msgs
+    def test_get_controls(self):
+        res = self.l.search()
+        list = res.controls
+    def test_get_referals(self):
+        res = self.l.search()
+        list = res.referals
+    def test_iter_msgs(self):
+        found = False
+        for l in self.l.search().msgs:
+            if str(l.dn) == "OU=OU10,DC=SAMBA,DC=ORG":
+                found = True
+        self.assertTrue(found)
+    def test_iter_msgs_count(self):
+        self.assertTrue(self.l.search().count > 0)
+        # 13 objects has been added to the DC=SAMBA, DC=ORG
+        self.assertEqual(self.l.search(base="DC=SAMBA,DC=ORG").count, 13)
+    def test_iter_controls(self):
+        res = self.l.search().controls
+        it = iter(res)
+    def test_create_control(self):
+        self.assertRaises(ValueError, ldb.Control, self.l, "tatayoyo:0")
+        c = ldb.Control(self.l, "relax:1")
+        self.assertEquals(c.critical, True)
+        self.assertEquals(c.oid, "1.3.6.1.4.1.4203.666.5.12")
+    def test_iter_refs(self):
+        res = self.l.search().referals
+        it = iter(res)
+    def test_iter_as_sequence_msgs(self):
+        found = False
+        res = self.l.search().msgs
+        for i in range(0, len(res)):
+            l = res[i]
+            if str(l.dn) == "OU=OU10,DC=SAMBA,DC=ORG":
+                found = True
+        self.assertTrue(found)
+    def test_iter_as_sequence(self):
+        found = False
+        res = self.l.search()
+        for i in range(0, len(res)):
+            l = res[i]
+            if str(l.dn) == "OU=OU10,DC=SAMBA,DC=ORG":
+                found = True
+        self.assertTrue(found)
+class VersionTests(unittest.TestCase):
+    def test_version(self):
+        self.assertTrue(isinstance(ldb.__version__, str))

trunk/server/source4/lib/ldb/tests/sample_module.c

-              r414
+              r745
 */
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb_module.h"
 int sample_add(struct ldb_module *mod, struct ldb_request *req)
+static int sample_add(struct ldb_module *mod, struct ldb_request *req)
+{
+        struct ldb_control *control;
         ldb_msg_add_fmt(req->op.add.message, "touchedBy", "sample");
+        return ldb_next_request(mod, req);
+        /* check if there's a relax control */
+        control = ldb_request_get_control(req, LDB_CONTROL_RELAX_OID);
+        if (control == NULL) {
+                /* not found go on */
+                return ldb_next_request(mod, req);
+        } else {
+                return LDB_ERR_UNWILLING_TO_PERFORM;
+        }
+}
+const struct ldb_module_ops ldb_sample_module_ops = {
+static int sample_modify(struct ldb_module *mod, struct ldb_request *req)
+{
+        struct ldb_control *control;
+        /* check if there's a relax control */
+        control = ldb_request_get_control(req, LDB_CONTROL_RELAX_OID);
+        if (control == NULL) {
+                /* not found go on */
+                return ldb_next_request(mod, req);
+        } else {
+                return LDB_ERR_UNWILLING_TO_PERFORM;
+        }
+}
+static struct ldb_module_ops ldb_sample_module_ops = {
         .name              = "sample",
         .add               = sample_add,
+        .del               = sample_modify,
+        .modify            = sample_modify,
 };
+int ldb_sample_init(const char *version)
+{
+        LDB_MODULE_CHECK_VERSION(version);
+        return ldb_register_module(&ldb_sample_module_ops);
+}

trunk/server/source4/lib/ldb/tests/test-generic.sh

-              r414
+              r745
+}
 echo "testing indexed search"
+echo "Testing indexed search"
 $VALGRIND ldbsearch$EXEEXT '(uid=uham)'  || exit 1
 $VALGRIND ldbsearch$EXEEXT '(&(objectclass=person)(objectclass=person)(objectclass=top))' || exit 1
 …
 echo "Testing binary file attribute value"
-mkdir -p tests/tmp
-cp $LDBDIR/tests/samba4.png tests/tmp/samba4.png
 $VALGRIND ldbmodify$EXEEXT $LDBDIR/tests/photo.ldif || exit 1
 count=`$VALGRIND ldbsearch$EXEEXT '(cn=Hampster Ursula)' jpegPhoto | grep '^dn' | wc -l`
 …
     exit 1
 fi
-rm -f tests/tmp/samba4.png
 echo "*TODO* Testing UTF8 upper lower case searches !!"

trunk/server/source4/lib/ldb/tests/test-schema.sh

-              r414
+              r745
 $VALGRIND bin/ldbmodify $LDBDIR/tests/schema-tests/schema-mod-test-3.ldif || exit 1
 $VALGRIND bin/ldbmodify $LDBDIR/tests/schema-tests/schema-mod-test-4.ldif
 if [ "$?" == "0" ]; then
+if [ "$?" = "0" ]; then
         echo "test failed!"
         exit 1
 fi
 $VALGRIND bin/ldbmodify $LDBDIR/tests/schema-tests/schema-mod-test-5.ldif
 if [ "$?" == "0" ]; then
+if [ "$?" = "0" ]; then
         echo "test failed!"
         exit 1

trunk/server/source4/lib/ldb/tests/test-tdb.sh

r414	r745
30	30
31	31	. $LDBDIR/tests/test-tdb-features.sh
	32
	33	. $LDBDIR/tests/test-controls.sh

trunk/server/source4/lib/ldb/tests/test.ldif

-              r414
+              r745
 facsimiletelephonenumber: +1 313 555 9700
 telephonenumber: +1 313 555 5331
+dn: cn=Fred Bassett,ou=Alumni Association,ou=People,o=University of Michigan,c=TEST
+objectclass: OpenLDAPperson
+cn: Fred Bassett
+sn: Bassett
+uid: Bassett, Fred

trunk/server/source4/lib/ldb/tools/cmdline.c

-              r414
+              r745
 */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb.h"
+#include "ldb_module.h"
 #include "tools/cmdline.h"
-#if (_SAMBA_BUILD_ >= 4)
-#include "includes.h"
-#include "lib/cmdline/popt_common.h"
-#include "lib/ldb-samba/ldif_handlers.h"
-#include "auth/gensec/gensec.h"
-#include "auth/auth.h"
-#include "ldb_wrap.h"
-#include "param/param.h"
-#endif
 static struct ldb_cmdline options; /* needs to be static for older compilers */
+static struct poptOption popt_options[] = {
+enum ldb_cmdline_options { CMDLINE_RELAX=1 };
+static struct poptOption builtin_popt_options[] = {
         POPT_AUTOHELP
         { "url",       'H', POPT_ARG_STRING, &options.url, 0, "database URL", "URL" },
 …
         { "nosync", 0,   POPT_ARG_NONE, &options.nosync, 0, "non-synchronous transactions", NULL },
         { "sorted", 'S', POPT_ARG_NONE, &options.sorted, 0, "sort attributes", NULL },
-        { "input", 'I', POPT_ARG_STRING, &options.input, 0, "Input File", "Input" },
-        { "output", 'O', POPT_ARG_STRING, &options.output, 0, "Output File", "Output" },
         { NULL,    'o', POPT_ARG_STRING, NULL, 'o', "ldb_connect option", "OPTION" },
         { "controls", 0, POPT_ARG_STRING, NULL, 'c', "controls", NULL },
         { "show-binary", 0, POPT_ARG_NONE, &options.show_binary, 0, "display binary LDIF", NULL },
+#if (_SAMBA_BUILD_ >= 4)
+        POPT_COMMON_SAMBA
+        POPT_COMMON_CREDENTIALS
+        POPT_COMMON_CONNECTION
+        POPT_COMMON_VERSION
+#endif
+        { "paged", 0, POPT_ARG_NONE, NULL, 'P', "use a paged search", NULL },
+        { "show-deleted", 0, POPT_ARG_NONE, NULL, 'D', "show deleted objects", NULL },
+        { "show-recycled", 0, POPT_ARG_NONE, NULL, 'R', "show recycled objects", NULL },
+        { "show-deactivated-link", 0, POPT_ARG_NONE, NULL, 'd', "show deactivated links", NULL },
+        { "reveal", 0, POPT_ARG_NONE, NULL, 'r', "reveal ldb internals", NULL },
+        { "relax", 0, POPT_ARG_NONE, NULL, CMDLINE_RELAX, "pass relax control", NULL },
+        { "cross-ncs", 0, POPT_ARG_NONE, NULL, 'N', "search across NC boundaries", NULL },
+        { "extended-dn", 0, POPT_ARG_NONE, NULL, 'E', "show extended DNs", NULL },
         { NULL }
 };
 void ldb_cmdline_help(const char *cmdname, FILE *f)
+void ldb_cmdline_help(struct ldb_context *ldb, const char *cmdname, FILE *f)
+{
         poptContext pc;
+        pc = poptGetContext(cmdname, 0, NULL, popt_options,
+        struct poptOption **popt_options = ldb_module_popt_options(ldb);
+        pc = poptGetContext(cmdname, 0, NULL, *popt_options,
                             POPT_CONTEXT_KEEP_FIRST);
         poptPrintHelp(pc, f, 0);
+}
+/*
+  add a control to the options structure
+ */
+static bool add_control(TALLOC_CTX *mem_ctx, const char *control)
+{
+        unsigned int i;
+        /* count how many controls we already have */
+        for (i=0; options.controls && options.controls[i]; i++) ;
+        options.controls = talloc_realloc(mem_ctx, options.controls, const char *, i + 2);
+        if (options.controls == NULL) {
+                return false;
+        }
+        options.controls[i] = control;
+        options.controls[i+1] = NULL;
+        return true;
+}
 …
 struct ldb_cmdline *ldb_cmdline_process(struct ldb_context *ldb,
                                         int argc, const char **argv,
                                         void (*usage)(void))
+                                        void (*usage)(struct ldb_context *))
+{
         struct ldb_cmdline *ret=NULL;
         poptContext pc;
-#if (_SAMBA_BUILD_ >= 4)
-        int r;
-#endif
         int num_options = 0;
         int opt;
         int flags = 0;
+#if (_SAMBA_BUILD_ >= 4)
+        r = ldb_register_samba_handlers(ldb);
+        if (r != 0) {
+                goto failed;
+        }
+#endif
+        int rc;
+        struct poptOption **popt_options;
+        /* make the ldb utilities line buffered */
+        setlinebuf(stdout);
         ret = talloc_zero(ldb, struct ldb_cmdline);
 …
         options.scope = LDB_SCOPE_DEFAULT;
+        pc = poptGetContext(argv[0], argc, argv, popt_options,
+        popt_options = ldb_module_popt_options(ldb);
+        (*popt_options) = builtin_popt_options;
+        rc = ldb_modules_hook(ldb, LDB_MODULE_HOOK_CMDLINE_OPTIONS);
+        if (rc != LDB_SUCCESS) {
+                fprintf(stderr, "ldb: failed to run command line hooks : %s\n", ldb_strerror(rc));
+                goto failed;
+        }
+        pc = poptGetContext(argv[0], argc, argv, *popt_options,
                             POPT_CONTEXT_KEEP_FIRST);
 …
                 case 'c': {
                         const char *cs = poptGetOptArg(pc);
+                        const char *p, *q;
+                        int cc;
+                        for (p = cs, cc = 1; (q = strchr(p, ',')); cc++, p = q + 1) ;
+                        options.controls = talloc_array(ret, char *, cc + 1);
+                        if (options.controls == NULL) {
+                                fprintf(stderr, "Out of memory!\n");
+                                goto failed;
+                        }
+                        for (p = cs, cc = 0; p != NULL; cc++) {
+                                const char *t;
+                        const char *p;
+                        for (p = cs; p != NULL; ) {
+                                const char *t, *c;
                                 t = strchr(p, ',');
                                 if (t == NULL) {
                                         options.controls[cc] = talloc_strdup(options.controls, p);
+                                        c = talloc_strdup(options.controls, p);
                                         p = NULL;
                                 } else {
                                         options.controls[cc] = talloc_strndup(options.controls, p, t-p);
+                                        c = talloc_strndup(options.controls, p, t-p);
                                         p = t + 1;
+                                }
+                        }
+                        options.controls[cc] = NULL;
+                                if (c == NULL || !add_control(ret, c)) {
+                                        fprintf(stderr, __location__ ": out of memory\n");
+                                        goto failed;
+                                }
+                        }
                         break;
+                }
+                case 'P':
+                        if (!add_control(ret, "paged_results:1:1024")) {
+                                fprintf(stderr, __location__ ": out of memory\n");
+                                goto failed;
+                        }
+                        break;
+                case 'D':
+                        if (!add_control(ret, "show_deleted:1")) {
+                                fprintf(stderr, __location__ ": out of memory\n");
+                                goto failed;
+                        }
+                        break;
+                case 'R':
+                        if (!add_control(ret, "show_recycled:0")) {
+                                fprintf(stderr, __location__ ": out of memory\n");
+                                goto failed;
+                        }
+                        break;
+                case 'd':
+                        if (!add_control(ret, "show_deactivated_link:0")) {
+                                fprintf(stderr, __location__ ": out of memory\n");
+                                goto failed;
+                        }
+                        break;
+                case 'r':
+                        if (!add_control(ret, "reveal_internals:0")) {
+                                fprintf(stderr, __location__ ": out of memory\n");
+                                goto failed;
+                        }
+                        break;
+                case CMDLINE_RELAX:
+                        if (!add_control(ret, "relax:0")) {
+                                fprintf(stderr, __location__ ": out of memory\n");
+                                goto failed;
+                        }
+                        break;
+                case 'N':
+                        if (!add_control(ret, "search_options:1:2")) {
+                                fprintf(stderr, __location__ ": out of memory\n");
+                                goto failed;
+                        }
+                        break;
+                case 'E':
+                        if (!add_control(ret, "extended_dn:1:1")) {
+                                fprintf(stderr, __location__ ": out of memory\n");
+                                goto failed;
+                        }
+                        break;
                 default:
                         fprintf(stderr, "Invalid option %s: %s\n",
                                 poptBadOption(pc, 0), poptStrerror(opt));
                         if (usage) usage();
+                        if (usage) usage(ldb);
                         goto failed;
+                }
 …
         if (ret->url == NULL) {
                 fprintf(stderr, "You must supply a url with -H or with $LDB_URL\n");
                 if (usage) usage();
+                if (usage) usage(ldb);
                 goto failed;
+        }
 …
+        }
-#if (_SAMBA_BUILD_ >= 4)
-        /* Must be after we have processed command line options */
-        gensec_init(cmdline_lp_ctx);
-        if (ldb_set_opaque(ldb, "sessionInfo", system_session(ldb, cmdline_lp_ctx))) {
-                goto failed;
+        }
-        if (ldb_set_opaque(ldb, "credentials", cmdline_credentials)) {
-                goto failed;
+        }
-        if (ldb_set_opaque(ldb, "loadparm", cmdline_lp_ctx)) {
-                goto failed;
+        }
-        ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
-#endif
         if (options.modules_path != NULL) {
                 ldb_set_modules_dir(ldb, options.modules_path);
+        } else if (getenv("LDB_MODULES_PATH") != NULL) {
+                ldb_set_modules_dir(ldb, getenv("LDB_MODULES_PATH"));
+        }
+        rc = ldb_modules_hook(ldb, LDB_MODULE_HOOK_CMDLINE_PRECONNECT);
+        if (rc != LDB_SUCCESS) {
+                fprintf(stderr, "ldb: failed to run preconnect hooks : %s\n", ldb_strerror(rc));
+                goto failed;
+        }
 …
+        }
+        rc = ldb_modules_hook(ldb, LDB_MODULE_HOOK_CMDLINE_POSTCONNECT);
+        if (rc != LDB_SUCCESS) {
+                fprintf(stderr, "ldb: failed to run post connect hooks : %s\n", ldb_strerror(rc));
+                goto failed;
+        }
         return ret;
 failed:
         talloc_free(ret);
         exit(1);
+        exit(LDB_ERR_OPERATIONS_ERROR);
         return NULL;
+}
 …
 int handle_controls_reply(struct ldb_control **reply, struct ldb_control **request)
+{
         int i, j;
         int ret = 0;
+        unsigned int i, j;
+        int ret = 0;
         if (reply == NULL || request == NULL) return -1;

trunk/server/source4/lib/ldb/tools/cmdline.h

-              r414
+              r745
         int num_searches;
         const char *sasl_mechanism;
+        const char *input;
+        const char *output;
+        char **controls;
+        const char **controls;
         int show_binary;
         int tracing;
 };
+struct ldb_cmdline *ldb_cmdline_process(struct ldb_context *ldb, int argc, const char **argv,
+                                        void (*usage)(void));
+struct ldb_cmdline *ldb_cmdline_process(struct ldb_context *ldb, int argc,
+                                        const char **argv,
+                                        void (*usage)(struct ldb_context *));
 int handle_controls_reply(struct ldb_control **reply, struct ldb_control **request);
 void ldb_cmdline_help(const char *cmdname, FILE *f);
+void ldb_cmdline_help(struct ldb_context *ldb, const char *cmdname, FILE *f);

trunk/server/source4/lib/ldb/tools/ldbadd.c

-              r414
+              r745
 /*
+/*
    ldb database library
 …
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
 #include "ldb.h"
 #include "tools/cmdline.h"
+#include "ldbutil.h"
+static int failures;
+static unsigned int failures;
+static struct ldb_cmdline *options;
 static void usage(void)
+static void usage(struct ldb_context *ldb)
+{
         printf("Usage: ldbadd <options> <ldif...>\n");
+        printf("Usage: ldbadd <options> <ldif...>\n");
         printf("Adds records to a ldb, reading ldif the specified list of files\n\n");
         ldb_cmdline_help("ldbadd", stdout);
         exit(1);
+        ldb_cmdline_help(ldb, "ldbadd", stdout);
+        exit(LDB_ERR_OPERATIONS_ERROR);
+}
 …
   add records from an opened file
 */
 static int process_file(struct ldb_context *ldb, FILE *f, int *count)
+static int process_file(struct ldb_context *ldb, FILE *f, unsigned int *count)
+{
         struct ldb_ldif *ldif;
         int ret = LDB_SUCCESS;
+        struct ldb_control **req_ctrls = ldb_parse_control_strings(ldb, ldb, (const char **)options->controls);
+        if (options->controls != NULL &&  req_ctrls== NULL) {
+                printf("parsing controls failed: %s\n", ldb_errstring(ldb));
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         while ((ldif = ldb_ldif_read_file(ldb, f))) {
 …
+                }
+                ldif->msg = ldb_msg_canonicalize(ldb, ldif->msg);
+                ret = ldb_msg_normalize(ldb, ldif, ldif->msg, &ldif->msg);
+                if (ret != LDB_SUCCESS) {
+                        fprintf(stderr,
+                                "ERR: Message canonicalize failed - %s\n",
+                                ldb_strerror(ret));
+                        failures++;
+                        ldb_ldif_read_free(ldb, ldif);
+                        continue;
+                }
                 ret = ldb_add(ldb, ldif->msg);
+                ret = ldb_add_ctrl(ldb, ldif->msg,req_ctrls);
                 if (ret != LDB_SUCCESS) {
+                        fprintf(stderr, "ERR: \"%s\" on DN %s\n",
+                                ldb_errstring(ldb), ldb_dn_get_linearized(ldif->msg->dn));
+                        fprintf(stderr, "ERR: %s : \"%s\" on DN %s\n",
+                                ldb_strerror(ret), ldb_errstring(ldb),
+                                ldb_dn_get_linearized(ldif->msg->dn));
                         failures++;
                 } else {
                         (*count)++;
+                        if (options->verbose) {
+                                printf("Added %s\n", ldb_dn_get_linearized(ldif->msg->dn));
+                        }
+                }
                 ldb_ldif_read_free(ldb, ldif);
 …
+{
         struct ldb_context *ldb;
+        int i, ret=0, count=0;
+        struct ldb_cmdline *options;
+        unsigned int i, count = 0;
+        int ret = LDB_SUCCESS;
+        TALLOC_CTX *mem_ctx = talloc_new(NULL);
+        ldb = ldb_init(NULL, NULL);
+        ldb = ldb_init(mem_ctx, NULL);
+        if (ldb == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         options = ldb_cmdline_process(ldb, argc, argv, usage);
+        if (ldb_transaction_start(ldb) != 0) {
+        ret = ldb_transaction_start(ldb);
+        if (ret != LDB_SUCCESS) {
                 printf("Failed to start transaction: %s\n", ldb_errstring(ldb));
                 exit(1);
+                return ret;
+        }
 …
                         if (!f) {
                                 perror(fname);
                                 exit(1);
+                                return LDB_ERR_OPERATIONS_ERROR;
+                        }
                         ret = process_file(ldb, f, &count);
 …
         if (count != 0) {
+                if (ldb_transaction_commit(ldb) != 0) {
+                ret = ldb_transaction_commit(ldb);
+                if (ret != LDB_SUCCESS) {
                         printf("Failed to commit transaction: %s\n", ldb_errstring(ldb));
                         exit(1);
+                        return ret;
+                }
         } else {
 …
+        }
         talloc_free(ldb);
+        talloc_free(mem_ctx);
         printf("Added %d records with %d failures\n", count, failures);
+        printf("Added %u records with %u failures\n", count, failures);
         return ret;
+}

trunk/server/source4/lib/ldb/tools/ldbdel.c

-              r414
+              r745
  */
+#include "replace.h"
 #include "ldb.h"
 #include "tools/cmdline.h"
+#include "ldbutil.h"
 static int ldb_delete_recursive(struct ldb_context *ldb, struct ldb_dn *dn)
+static int dn_cmp(struct ldb_message **msg1, struct ldb_message **msg2)
+{
+        int ret, i, total=0;
+        return ldb_dn_compare((*msg1)->dn, (*msg2)->dn);
+}
+static int ldb_delete_recursive(struct ldb_context *ldb, struct ldb_dn *dn,struct ldb_control **req_ctrls)
+{
+        int ret;
+        unsigned int i, total=0;
         const char *attrs[] = { NULL };
         struct ldb_result *res;
         ret = ldb_search(ldb, ldb, &res, dn, LDB_SCOPE_SUBTREE, attrs, "distinguishedName=*");
+        if (ret != LDB_SUCCESS) return -1;
+        if (ret != LDB_SUCCESS) return ret;
+        /* sort the DNs, deepest first */
+        TYPESAFE_QSORT(res->msgs, res->count, dn_cmp);
         for (i = 0; i < res->count; i++) {
                 if (ldb_delete(ldb, res->msgs[i]->dn) == 0) {
+                if (ldb_delete_ctrl(ldb, res->msgs[i]->dn,req_ctrls) == LDB_SUCCESS) {
                         total++;
+                } else {
+                        printf("Failed to delete '%s' - %s\n",
+                               ldb_dn_get_linearized(res->msgs[i]->dn),
+                               ldb_errstring(ldb));
+                }
+        }
 …
         if (total == 0) {
                 return -1;
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         printf("Deleted %d records\n", total);
         return 0;
+        printf("Deleted %u records\n", total);
+        return LDB_SUCCESS;
+}
 static void usage(void)
+static void usage(struct ldb_context *ldb)
+{
         printf("Usage: ldbdel <options> <DN...>\n");
         printf("Deletes records from a ldb\n\n");
         ldb_cmdline_help("ldbdel", stdout);
         exit(1);
+        ldb_cmdline_help(ldb, "ldbdel", stdout);
+        exit(LDB_ERR_OPERATIONS_ERROR);
+}
 int main(int argc, const char **argv)
+{
+        struct ldb_control **req_ctrls;
+        struct ldb_cmdline *options;
         struct ldb_context *ldb;
         int ret = 0, i;
         struct ldb_cmdline *options;
+        TALLOC_CTX *mem_ctx = talloc_new(NULL);
+        ldb = ldb_init(NULL, NULL);
+        ldb = ldb_init(mem_ctx, NULL);
+        if (ldb == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         options = ldb_cmdline_process(ldb, argc, argv, usage);
         if (options->argc < 1) {
+                usage();
+                exit(1);
+                usage(ldb);
+        }
+        req_ctrls = ldb_parse_control_strings(ldb, ldb, (const char **)options->controls);
+        if (options->controls != NULL &&  req_ctrls== NULL) {
+                printf("parsing controls failed: %s\n", ldb_errstring(ldb));
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
                 dn = ldb_dn_new(ldb, ldb, options->argv[i]);
+                if ( ! ldb_dn_validate(dn)) {
+                        printf("Invalid DN format\n");
+                        exit(1);
+                if (dn == NULL) {
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
                 if (options->recursive) {
                         ret = ldb_delete_recursive(ldb, dn);
+                        ret = ldb_delete_recursive(ldb, dn,req_ctrls);
                 } else {
                         ret = ldb_delete(ldb, dn);
                         if (ret == 0) {
+                        ret = ldb_delete_ctrl(ldb, dn,req_ctrls);
+                        if (ret == LDB_SUCCESS) {
                                 printf("Deleted 1 record\n");
+                        }
+                }
+                if (ret != 0) {
+                        printf("delete of '%s' failed - %s\n",
+                                ldb_dn_get_linearized(dn),
+                                ldb_errstring(ldb));
+                if (ret != LDB_SUCCESS) {
+                        printf("delete of '%s' failed - (%s) %s\n",
+                               ldb_dn_get_linearized(dn),
+                               ldb_strerror(ret),
+                               ldb_errstring(ldb));
+                }
+        }
         talloc_free(ldb);
+        talloc_free(mem_ctx);
         return ret;

trunk/server/source4/lib/ldb/tools/ldbedit.c

-              r414
+              r745
 /*
+/*
    ldb database library
 …
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
  *  Author: Andrew Tridgell
  */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
+#include "system/filesys.h"
 #include "ldb.h"
 #include "tools/cmdline.h"
+#include "tools/ldbutil.h"
 static struct ldb_cmdline *options;
 /*
   debug routine
 */
 static void ldif_write_msg(struct ldb_context *ldb,
                            FILE *f,
+  debug routine
+*/
+static void ldif_write_msg(struct ldb_context *ldb,
+                           FILE *f,
                            enum ldb_changetype changetype,
                            struct ldb_message *msg)
 …
   returns the number of modified elements
 */
 static int modify_record(struct ldb_context *ldb,
+static int modify_record(struct ldb_context *ldb,
                          struct ldb_message *msg1,
+                         struct ldb_message *msg2)
+{
+                         struct ldb_message *msg2,
+                         struct ldb_control **req_ctrls)
+{
+        int ret;
         struct ldb_message *mod;
+        mod = ldb_msg_diff(ldb, msg1, msg2);
+        if (mod == NULL) {
+        if (ldb_msg_difference(ldb, ldb, msg1, msg2, &mod) != LDB_SUCCESS) {
                 fprintf(stderr, "Failed to calculate message differences\n");
                 return -1;
+        }
+        if (mod->num_elements == 0) {
+                return 0;
+        ret = mod->num_elements;
+        if (ret == 0) {
+                goto done;
+        }
 …
+        }
         if (ldb_modify(ldb, mod) != 0) {
                 fprintf(stderr, "failed to modify %s - %s\n",
+        if (ldb_modify_ctrl(ldb, mod, req_ctrls) != LDB_SUCCESS) {
+                fprintf(stderr, "failed to modify %s - %s\n",
                         ldb_dn_get_linearized(msg1->dn), ldb_errstring(ldb));
+                return -1;
+        }
+        return mod->num_elements;
+                ret = -1;
+                goto done;
+        }
+done:
+        talloc_free(mod);
+        return ret;
+}
 …
 static struct ldb_message *msg_find(struct ldb_context *ldb,
                                     struct ldb_message **msgs,
                                     int count,
+                                    unsigned int count,
                                     struct ldb_dn *dn)
+{
         int i;
+        unsigned int i;
         for (i=0;i<count;i++) {
                 if (ldb_dn_compare(dn, msgs[i]->dn) == 0) {
 …
 */
 static int merge_edits(struct ldb_context *ldb,
                        struct ldb_message **msgs1, int count1,
                        struct ldb_message **msgs2, int count2)
+{
         int i;
+                       struct ldb_message **msgs1, unsigned int count1,
+                       struct ldb_message **msgs2, unsigned int count2)
+{
+        unsigned int i;
         struct ldb_message *msg;
+        int ret = 0;
+        int adds=0, modifies=0, deletes=0;
+        if (ldb_transaction_start(ldb) != 0) {
+        int ret;
+        unsigned int adds=0, modifies=0, deletes=0;
+        struct ldb_control **req_ctrls = ldb_parse_control_strings(ldb, ldb, (const char **)options->controls);
+        if (options->controls != NULL && req_ctrls == NULL) {
+                fprintf(stderr, "parsing controls failed: %s\n", ldb_errstring(ldb));
+                return -1;
+        }
+        if (ldb_transaction_start(ldb) != LDB_SUCCESS) {
                 fprintf(stderr, "Failed to start transaction: %s\n", ldb_errstring(ldb));
                 return -1;
 …
                                 ldif_write_msg(ldb, stdout, LDB_CHANGETYPE_ADD, msgs2[i]);
+                        }
                         if (ldb_add(ldb, msgs2[i]) != 0) {
+                        if (ldb_add_ctrl(ldb, msgs2[i], req_ctrls) != LDB_SUCCESS) {
                                 fprintf(stderr, "failed to add %s - %s\n",
                                         ldb_dn_get_linearized(msgs2[i]->dn),
 …
                         adds++;
                 } else {
+                        if (modify_record(ldb, msg, msgs2[i]) > 0) {
+                                modifies++;
+                        ret = modify_record(ldb, msg, msgs2[i], req_ctrls);
+                        if (ret != -1) {
+                                modifies += (unsigned int) ret;
+                        } else {
+                                return -1;
+                        }
+                }
 …
                                 ldif_write_msg(ldb, stdout, LDB_CHANGETYPE_DELETE, msgs1[i]);
+                        }
                         if (ldb_delete(ldb, msgs1[i]->dn) != 0) {
+                        if (ldb_delete_ctrl(ldb, msgs1[i]->dn, req_ctrls) != LDB_SUCCESS) {
                                 fprintf(stderr, "failed to delete %s - %s\n",
                                         ldb_dn_get_linearized(msgs1[i]->dn),
 …
+        }
         if (ldb_transaction_commit(ldb) != 0) {
+        if (ldb_transaction_commit(ldb) != LDB_SUCCESS) {
                 fprintf(stderr, "Failed to commit transaction: %s\n", ldb_errstring(ldb));
                 return -1;
+        }
         printf("# %d adds  %d modifies  %d deletes\n", adds, modifies, deletes);
         return ret;
+        printf("# %u adds  %u modifies  %u deletes\n", adds, modifies, deletes);
+        return 0;
+}
 …
   save a set of messages as ldif to a file
 */
 static int save_ldif(struct ldb_context *ldb,
                      FILE *f, struct ldb_message **msgs, int count)
+{
         int i;
         fprintf(f, "# editing %d records\n", count);
+static int save_ldif(struct ldb_context *ldb,
+                     FILE *f, struct ldb_message **msgs, unsigned int count)
+{
+        unsigned int i;
+        fprintf(f, "# editing %u records\n", count);
         for (i=0;i<count;i++) {
                 struct ldb_ldif ldif;
                 fprintf(f, "# record %d\n", i+1);
+                fprintf(f, "# record %u\n", i+1);
                 ldif.changetype = LDB_CHANGETYPE_NONE;
 …
   edit the ldb search results in msgs using the user selected editor
 */
 static int do_edit(struct ldb_context *ldb, struct ldb_message **msgs1, int count1,
                    const char *editor)
+static int do_edit(struct ldb_context *ldb, struct ldb_message **msgs1,
+                   unsigned int count1, const char *editor)
+{
         int fd, ret;
 …
         struct ldb_ldif *ldif;
         struct ldb_message **msgs2 = NULL;
         int count2 = 0;
+        unsigned int count2 = 0;
         /* write out the original set of messages to a temporary
 …
+}
 static void usage(void)
+static void usage(struct ldb_context *ldb)
+{
         printf("Usage: ldbedit <options> <expression> <attributes ...>\n");
         ldb_cmdline_help("ldbedit", stdout);
         exit(1);
+        ldb_cmdline_help(ldb, "ldbedit", stdout);
+        exit(LDB_ERR_OPERATIONS_ERROR);
+}
 …
         const char *expression = "(|(objectClass=*)(distinguishedName=*))";
         const char * const * attrs = NULL;
+        ldb = ldb_init(NULL, NULL);
+        TALLOC_CTX *mem_ctx = talloc_new(NULL);
+        struct ldb_control **req_ctrls;
+        ldb = ldb_init(mem_ctx, NULL);
+        if (ldb == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         options = ldb_cmdline_process(ldb, argc, argv, usage);
         /* the check for '=' is for compatibility with ldapsearch */
         if (options->argc > 0 &&
+        if (options->argc > 0 &&
             strchr(options->argv[0], '=')) {
                 expression = options->argv[0];
 …
         if (options->basedn != NULL) {
                 basedn = ldb_dn_new(ldb, ldb, options->basedn);
+                if ( ! ldb_dn_validate(basedn)) {
+                        printf("Invalid Base DN format\n");
+                        exit(1);
+                }
+        }
+        ret = ldb_search(ldb, ldb, &result, basedn, options->scope, attrs, "%s", expression);
+                if (basedn == NULL) {
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+        }
+        req_ctrls = ldb_parse_control_strings(ldb, ldb, (const char **)options->controls);
+        if (options->controls != NULL &&  req_ctrls== NULL) {
+                printf("parsing controls failed: %s\n", ldb_errstring(ldb));
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
+        ret = ldb_search_ctrl(ldb, ldb, &result, basedn, options->scope, attrs, req_ctrls, "%s", expression);
         if (ret != LDB_SUCCESS) {
                 printf("search failed - %s\n", ldb_errstring(ldb));
                 exit(1);
+                return ret;
+        }
         if (result->count == 0) {
                 printf("no matching records - cannot edit\n");
+                return 0;
+        }
+        do_edit(ldb, result->msgs, result->count, options->editor);
+        if (result) {
+                ret = talloc_free(result);
+                if (ret == -1) {
+                        fprintf(stderr, "talloc_free failed\n");
+                        exit(1);
+                }
+        }
+        talloc_free(ldb);
+        return 0;
+}
+                talloc_free(mem_ctx);
+                return LDB_SUCCESS;
+        }
+        ret = do_edit(ldb, result->msgs, result->count, options->editor);
+        talloc_free(mem_ctx);
+        return ret == 0 ? LDB_SUCCESS : LDB_ERR_OPERATIONS_ERROR;
+}

trunk/server/source4/lib/ldb/tools/ldbmodify.c

-              r414
+              r745
 #include "ldb.h"
 #include "tools/cmdline.h"
+#include "ldbutil.h"
+static int failures;
+static unsigned int failures;
+static struct ldb_cmdline *options;
 static void usage(void)
+static void usage(struct ldb_context *ldb)
+{
         printf("Usage: ldbmodify <options> <ldif...>\n");
         printf("Modifies a ldb based upon ldif change records\n\n");
         ldb_cmdline_help("ldbmodify", stdout);
         exit(1);
+        ldb_cmdline_help(ldb, "ldbmodify", stdout);
+        exit(LDB_ERR_OPERATIONS_ERROR);
+}
 …
   process modifies for one file
 */
 static int process_file(struct ldb_context *ldb, FILE *f, int *count)
+static int process_file(struct ldb_context *ldb, FILE *f, unsigned int *count)
+{
         struct ldb_ldif *ldif;
         int ret = LDB_SUCCESS;
+        struct ldb_control **req_ctrls = ldb_parse_control_strings(ldb, ldb, (const char **)options->controls);
+        if (options->controls != NULL &&  req_ctrls== NULL) {
+                printf("parsing controls failed: %s\n", ldb_errstring(ldb));
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
         while ((ldif = ldb_ldif_read_file(ldb, f))) {
                 switch (ldif->changetype) {
                 case LDB_CHANGETYPE_NONE:
                 case LDB_CHANGETYPE_ADD:
                         ret = ldb_add(ldb, ldif->msg);
+                        ret = ldb_add_ctrl(ldb, ldif->msg,req_ctrls);
                         break;
                 case LDB_CHANGETYPE_DELETE:
                         ret = ldb_delete(ldb, ldif->msg->dn);
+                        ret = ldb_delete_ctrl(ldb, ldif->msg->dn,req_ctrls);
                         break;
                 case LDB_CHANGETYPE_MODIFY:
                         ret = ldb_modify(ldb, ldif->msg);
+                        ret = ldb_modify_ctrl(ldb, ldif->msg,req_ctrls);
                         break;
+                }
                 if (ret != LDB_SUCCESS) {
+                        fprintf(stderr, "ERR: \"%s\" on DN %s\n",
+                        fprintf(stderr, "ERR: (%s) \"%s\" on DN %s\n",
+                                ldb_strerror(ret),
                                 ldb_errstring(ldb), ldb_dn_get_linearized(ldif->msg->dn));
                         failures++;
                 } else {
                         (*count)++;
+                        if (options->verbose) {
+                                printf("Modified %s\n", ldb_dn_get_linearized(ldif->msg->dn));
+                        }
+                }
                 ldb_ldif_read_free(ldb, ldif);
 …
+{
         struct ldb_context *ldb;
         int count=0;
         int i, ret=LDB_SUCCESS;
         struct ldb_cmdline *options;
+        unsigned int i, count = 0;
+        int ret = LDB_SUCCESS;
+        TALLOC_CTX *mem_ctx = talloc_new(NULL);
+        ldb = ldb_init(NULL, NULL);
+        ldb = ldb_init(mem_ctx, NULL);
+        if (ldb == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         options = ldb_cmdline_process(ldb, argc, argv, usage);
 …
                         if (!f) {
                                 perror(fname);
                                 exit(1);
+                                return LDB_ERR_OPERATIONS_ERROR;
+                        }
                         ret = process_file(ldb, f, &count);
 …
+        }
         talloc_free(ldb);
+        talloc_free(mem_ctx);
         printf("Modified %d records with %d failures\n", count, failures);
+        printf("Modified %u records with %u failures\n", count, failures);
         return ret;

trunk/server/source4/lib/ldb/tools/ldbrename.c

-              r414
+              r745
 #include "tools/cmdline.h"
 static void usage(void)
+static void usage(struct ldb_context *ldb)
+{
         printf("Usage: ldbrename [<options>] <olddn> <newdn>\n");
         printf("Renames records in a ldb\n\n");
         ldb_cmdline_help("ldbmodify", stdout);
         exit(1);
+        ldb_cmdline_help(ldb, "ldbmodify", stdout);
+        exit(LDB_ERR_OPERATIONS_ERROR);
+}
 …
         struct ldb_cmdline *options;
         struct ldb_dn *dn1, *dn2;
+        TALLOC_CTX *mem_ctx = talloc_new(NULL);
+        ldb = ldb_init(NULL, NULL);
+        ldb = ldb_init(mem_ctx, NULL);
+        if (ldb == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         options = ldb_cmdline_process(ldb, argc, argv, usage);
         if (options->argc < 2) {
                 usage();
+                usage(ldb);
+        }
         dn1 = ldb_dn_new(ldb, ldb, options->argv[0]);
         dn2 = ldb_dn_new(ldb, ldb, options->argv[1]);
+        if ( ! ldb_dn_validate(dn1)) {
+                printf("Invalid DN1: %s\n", options->argv[0]);
+                return -1;
+        }
+        if ( ! ldb_dn_validate(dn2)) {
+                printf("Invalid DN2: %s\n", options->argv[1]);
+                return -1;
+        if ((dn1 == NULL) || (dn2 == NULL)) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         ret = ldb_rename(ldb, dn1, dn2);
         if (ret == 0) {
+        if (ret == LDB_SUCCESS) {
                 printf("Renamed 1 record\n");
         } else  {
 …
+        }
         talloc_free(ldb);
+        talloc_free(mem_ctx);
         return ret;

trunk/server/source4/lib/ldb/tools/ldbsearch.c

-              r414
+              r745
  */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb.h"
 #include "tools/cmdline.h"
 static void usage(void)
+static void usage(struct ldb_context *ldb)
+{
         printf("Usage: ldbsearch <options> <expression> <attrs...>\n");
         ldb_cmdline_help("ldbsearch", stdout);
         exit(1);
+        ldb_cmdline_help(ldb, "ldbsearch", stdout);
+        exit(LDB_ERR_OPERATIONS_ERROR);
+}
 …
         int sort;
         int num_stored;
+        unsigned int num_stored;
         struct ldb_message **store;
         int refs_stored;
+        unsigned int refs_stored;
         char **refs_store;
         int entries;
         int refs;
         int pending;
+        unsigned int entries;
+        unsigned int refs;
+        unsigned int pending;
         int status;
 };
 …
+{
         struct search_context *sctx;
         int ret;
+        int ret = LDB_SUCCESS;
         sctx = talloc_get_type(req->context, struct search_context);
 …
         talloc_free(ares);
         if (ret) {
+        if (ret != LDB_SUCCESS) {
                 return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
+        }
 …
         req = NULL;
         sctx = talloc(ldb, struct search_context);
         if (!sctx) return -1;
+        sctx = talloc_zero(ldb, struct search_context);
+        if (!sctx) return LDB_ERR_OPERATIONS_ERROR;
         sctx->ldb = ldb;
         sctx->sort = options->sorted;
-        sctx->num_stored = 0;
-        sctx->refs_stored = 0;
-        sctx->store = NULL;
         sctx->req_ctrls = ldb_parse_control_strings(ldb, sctx, (const char **)options->controls);
         if (options->controls != NULL &&  sctx->req_ctrls== NULL) {
                 printf("parsing controls failed: %s\n", ldb_errstring(ldb));
+                return -1;
+        }
+        sctx->entries = 0;
+        sctx->refs = 0;
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         if (basedn == NULL) {
 …
                 talloc_free(sctx);
                 printf("allocating request failed: %s\n", ldb_errstring(ldb));
                 return -1;
+                return ret;
+        }
 …
         if (ret != LDB_SUCCESS) {
                 printf("search failed - %s\n", ldb_errstring(ldb));
                 return -1;
+                return ret;
+        }
         ret = ldb_wait(req->handle, LDB_WAIT_ALL);
         if (ret != LDB_SUCCESS) {
+        if (ret != LDB_SUCCESS) {
                 printf("search error - %s\n", ldb_errstring(ldb));
                 return -1;
+                return ret;
+        }
 …
         if (sctx->sort && (sctx->num_stored != 0 || sctx->refs != 0)) {
                 int i;
+                unsigned int i;
                 if (sctx->num_stored) {
+                        ldb_qsort(sctx->store, sctx->num_stored, sizeof(struct ldb_message *),
+                                  ldb, (ldb_qsort_cmp_fn_t)do_compare_msg);
+                        LDB_TYPESAFE_QSORT(sctx->store, sctx->num_stored, ldb, do_compare_msg);
+                }
                 for (i = 0; i < sctx->num_stored; i++) {
 …
+        }
         printf("# returned %d records\n# %d entries\n# %d referrals\n",
+        printf("# returned %u records\n# %u entries\n# %u referrals\n",
                 sctx->entries + sctx->refs, sctx->entries, sctx->refs);
 …
         talloc_free(req);
         return 0;
+        return LDB_SUCCESS;
+}
 …
         int ret = -1;
         const char *expression = "(|(objectClass=*)(distinguishedName=*))";
+        ldb = ldb_init(NULL, NULL);
+        TALLOC_CTX *mem_ctx = talloc_new(NULL);
+        ldb = ldb_init(mem_ctx, NULL);
         if (ldb == NULL) {
                 return -1;
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
 …
         if (options->basedn != NULL) {
                 basedn = ldb_dn_new(ldb, ldb, options->basedn);
+                if ( ! ldb_dn_validate(basedn)) {
+                        fprintf(stderr, "Invalid Base DN format\n");
+                        exit(1);
+                if (basedn == NULL) {
+                        return LDB_ERR_OPERATIONS_ERROR;
+                }
+        }
 …
                 char line[1024];
                 while (fgets(line, sizeof(line), stdin)) {
+                        if (do_search(ldb, basedn, options, line, attrs) == -1) {
+                                ret = -1;
+                        }
+                        ret = do_search(ldb, basedn, options, line, attrs);
+                }
         } else {
 …
+        }
+        talloc_free(ldb);
+        talloc_free(mem_ctx);
         return ret;
+}

trunk/server/source4/lib/ldb/tools/ldbtest.c

-              r414
+              r745
  */
+#include "ldb_includes.h"
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/time.h"
 #include "ldb.h"
 #include "tools/cmdline.h"
 static struct timeval tp1,tp2;
+static struct timespec tp1,tp2;
 static struct ldb_cmdline *options;
 static void _start_timer(void)
+{
+        gettimeofday(&tp1,NULL);
+        if (clock_gettime(CUSTOM_CLOCK_MONOTONIC, &tp1) != 0) {
+                clock_gettime(CLOCK_REALTIME, &tp1);
+        }
+}
 static double _end_timer(void)
+{
+        gettimeofday(&tp2,NULL);
+        if (clock_gettime(CUSTOM_CLOCK_MONOTONIC, &tp2) != 0) {
+                clock_gettime(CLOCK_REALTIME, &tp2);
+        }
         return((tp2.tv_sec - tp1.tv_sec) +
                (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
+               (tp2.tv_nsec - tp1.tv_nsec)*1.0e-9);
+}
 static void add_records(struct ldb_context *ldb,
                         struct ldb_dn *basedn,
                         int count)
+                        unsigned int count)
+{
         struct ldb_message msg;
         int i;
+        unsigned int i;
 #if 0
         if (ldb_lock(ldb, "transaction") != 0) {
                 printf("transaction lock failed\n");
                 exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
 #endif
 …
                 if (ldb_add(ldb, &msg) != 0) {
                         printf("Add of %s failed - %s\n", name, ldb_errstring(ldb));
                         exit(1);
+                        exit(LDB_ERR_OPERATIONS_ERROR);
+                }
 …
         if (ldb_unlock(ldb, "transaction") != 0) {
                 printf("transaction unlock failed\n");
                 exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
 #endif
 …
 static void modify_records(struct ldb_context *ldb,
                            struct ldb_dn *basedn,
                            int count)
+                           unsigned int count)
+{
         struct ldb_message msg;
         int i;
+        unsigned int i;
         for (i=0;i<count;i++) {
 …
                 if (ldb_modify(ldb, &msg) != 0) {
                         printf("Modify of %s failed - %s\n", name, ldb_errstring(ldb));
                         exit(1);
+                        exit(LDB_ERR_OPERATIONS_ERROR);
+                }
 …
 static void delete_records(struct ldb_context *ldb,
                            struct ldb_dn *basedn,
                            int count)
+{
         int i;
+                           unsigned int count)
+{
+        unsigned int i;
         for (i=0;i<count;i++) {
 …
                 if (ldb_delete(ldb, dn) != 0) {
                         printf("Delete of %s failed - %s\n", ldb_dn_get_linearized(dn), ldb_errstring(ldb));
                         exit(1);
+                        exit(LDB_ERR_OPERATIONS_ERROR);
+                }
                 talloc_free(name);
 …
+}
+static void search_uid(struct ldb_context *ldb, struct ldb_dn *basedn, int nrecords, int nsearches)
+{
+        int i;
+static void search_uid(struct ldb_context *ldb, struct ldb_dn *basedn,
+                       unsigned int nrecords, unsigned int nsearches)
+{
+        unsigned int i;
         for (i=0;i<nsearches;i++) {
 …
                 if (ret != LDB_SUCCESS || (uid < nrecords && res->count != 1)) {
                         printf("Failed to find %s - %s\n", expr, ldb_errstring(ldb));
                         exit(1);
+                        exit(LDB_ERR_OPERATIONS_ERROR);
+                }
                 if (uid >= nrecords && res->count > 0) {
                         printf("Found %s !? - %d\n", expr, ret);
                         exit(1);
+                        exit(LDB_ERR_OPERATIONS_ERROR);
+                }
                 printf("testing uid %d/%d - %d  \r", i, uid, res->count);
+                printf("Testing uid %d/%d - %d  \r", i, uid, res->count);
                 fflush(stdout);
 …
+}
+static void start_test(struct ldb_context *ldb, int nrecords, int nsearches)
+static void start_test(struct ldb_context *ldb, unsigned int nrecords,
+                       unsigned int nsearches)
+{
         struct ldb_dn *basedn;
 …
         basedn = ldb_dn_new(ldb, ldb, options->basedn);
         if ( ! ldb_dn_validate(basedn)) {
                 printf("Invalid base DN\n");
                 exit(1);
+                printf("Invalid base DN format\n");
+                exit(LDB_ERR_INVALID_DN_SYNTAX);
+        }
 …
         if (ldb_add(*ldb, msg) != 0) {
                 printf("Add of %s failed - %s\n", ldb_dn_get_linearized(msg->dn), ldb_errstring(*ldb));
                 exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
 …
         if (ldb_add(*ldb, msg) != 0) {
                 printf("Add of %s failed - %s\n", ldb_dn_get_linearized(msg->dn), ldb_errstring(*ldb));
                 exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
         if (talloc_free(*ldb) != 0) {
                 printf("failed to free/close ldb database");
                 exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
 …
         if (ret != 0) {
                 printf("failed to connect to %s\n", options->url);
                 exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
         basedn = ldb_dn_new(*ldb, *ldb, options->basedn);
+        msg->dn = basedn;
+        ldb_dn_add_child_fmt(msg->dn, "cn=test");
         ret = ldb_search(*ldb, *ldb, &res, basedn, LDB_SCOPE_SUBTREE, NULL, "uid=test");
         if (ret != LDB_SUCCESS) {
                 printf("Search with (uid=test) filter failed!\n");
                 exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
         if(res->count != 1) {
                 printf("Should have found 1 record - found %d\n", res->count);
                 exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
 …
             ldb_delete(*ldb, indexlist) != 0) {
                 printf("cleanup failed - %s\n", ldb_errstring(*ldb));
                 exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
+        }
 …
 static void usage(void)
+static void usage(struct ldb_context *ldb)
+{
         printf("Usage: ldbtest <options>\n");
 …
         printf("\n");
         printf("tests ldb API\n\n");
         exit(1);
+        exit(LDB_ERR_OPERATIONS_ERROR);
+}
 …
         ldb = ldb_init(mem_ctx, NULL);
+        if (ldb == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
         options = ldb_cmdline_process(ldb, argc, argv, usage);
 …
                options->num_records, options->num_searches);
+        start_test(ldb, options->num_records, options->num_searches);
+        start_test(ldb,
+                   (unsigned int) options->num_records,
+                   (unsigned int) options->num_searches);
         start_test_index(&ldb);
 …
         talloc_free(mem_ctx);
         return 0;
+}
+        return LDB_SUCCESS;
+}

trunk/server/source4/lib/ldb/web/index.html

-              r414
+              r745
 <h2>Discussion and bug reports</h2>
 ldb does not currently have its own mailing list or bug tracking
+system. For now, please use the <a
 href="https://lists.samba.org/mailman/listinfo/samba-technical">samba-technical</a>
 mailing list or the <a href="https://lists.samba.org/mailman/listinfo/ldb">ldb</a>
 mailing list, and the <a href="http://bugzilla.samba.org/">Samba bugzilla</a> bug tracking system.
+ldb does not have its own mailing list or bug tracking system. Please
+use
+the <a href="https://lists.samba.org/mailman/listinfo/samba-technical">samba-technical</a>
+mailing list, and the <a href="http://bugzilla.samba.org/">Samba
+bugzilla</a> bug tracking system.
 <h2>Download</h2>
+You can download the latest release either via rsync or thtough git.<br>
+<br>
+To fetch via git see the following guide:<br>
+You can download the latest release here:<br>
+ <a href="http://samba.org/ftp/pub/ldb">http://samba.org/ftp/pub/ldb</a>
+Alternatively, you can fetch via git. See the following guide:<br>
 <a href="http://wiki.samba.org/index.php/Using_Git_for_Samba_Development">Using Git for Samba Development</a><br>
-Once you have cloned the tree switch to the v4-0-test branch and cd into the source/lib/ldb directory.<br>
-<br>
-To fetch via rsync use these commands:
-<pre>
-  rsync -Pavz samba.org::ftp/unpacked/ldb .
-  rsync -Pavz samba.org::ftp/unpacked/tdb .
-  rsync -Pavz samba.org::ftp/unpacked/talloc .
-  rsync -Pavz samba.org::ftp/unpacked/libreplace .
-</pre>
-and build in ldb. It will find the other libraries in the directory
-above automatically.
 <hr>

trunk/server/source4/lib/messaging/irpc.h

-              r414
+              r745
 #include "lib/messaging/messaging.h"
 #include "librpc/gen_ndr/irpc.h"
-#include "librpc/gen_ndr/server_id.h"
 /*
 …
         struct ndr_pull *ndr;
         bool defer_reply;
+        bool no_reply;
         struct messaging_context *msg_ctx;
         struct irpc_list *irpc;
 …
 /* don't allow calls to take too long */
+#define IRPC_CALL_TIMEOUT 10
+#define IRPC_CALL_TIMEOUT       10
+/* wait for the calls as long as it takes */
+#define IRPC_CALL_TIMEOUT_INF   0
 …
                           (irpc_function_t)function, private_data)
+/* make a irpc call */
+#define IRPC_CALL(msg_ctx, server_id, pipename, funcname, ptr, ctx) \
+   irpc_call(msg_ctx, server_id, &ndr_table_ ## pipename, NDR_ ## funcname, ptr, ctx)
+#define IRPC_CALL_SEND(msg_ctx, server_id, pipename, funcname, ptr, ctx) \
+   irpc_call_send(msg_ctx, server_id, &ndr_table_ ## pipename, NDR_ ## funcname, ptr, ctx)
+/*
+  a pending irpc call
+*/
+struct irpc_request {
+        struct messaging_context *msg_ctx;
+        const struct ndr_interface_table *table;
+        int callnum;
+        int callid;
+        void *r;
+        NTSTATUS status;
+        bool done;
+        bool reject_free;
+        TALLOC_CTX *mem_ctx;
+        struct {
+                void (*fn)(struct irpc_request *);
+                void *private_data;
+        } async;
+};
+struct loadparm_context;
+typedef void (*msg_callback_t)(struct messaging_context *msg, void *private_data,
+                               uint32_t msg_type,
+                               struct server_id server_id, DATA_BLOB *data);
+NTSTATUS messaging_send(struct messaging_context *msg, struct server_id server,
+                        uint32_t msg_type, DATA_BLOB *data);
+NTSTATUS messaging_register(struct messaging_context *msg, void *private_data,
+                            uint32_t msg_type,
+                            msg_callback_t fn);
+NTSTATUS messaging_register_tmp(struct messaging_context *msg, void *private_data,
+                                msg_callback_t fn, uint32_t *msg_type);
+struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx,
+                                         const char *dir,
+                                         struct server_id server_id,
+                                         struct smb_iconv_convenience *iconv_convenience,
+                                         struct tevent_context *ev);
+struct messaging_context *messaging_client_init(TALLOC_CTX *mem_ctx,
+                                         const char *dir,
+                                         struct smb_iconv_convenience *iconv_convenience,
+                                         struct tevent_context *ev);
+NTSTATUS messaging_send_ptr(struct messaging_context *msg, struct server_id server,
+                            uint32_t msg_type, void *ptr);
+void messaging_deregister(struct messaging_context *msg, uint32_t msg_type, void *private_data);
+struct ndr_interface_table;
 NTSTATUS irpc_register(struct messaging_context *msg_ctx,
                        const struct ndr_interface_table *table,
                        int call, irpc_function_t fn, void *private_data);
+struct irpc_request *irpc_call_send(struct messaging_context *msg_ctx,
+                                    struct server_id server_id,
+                                    const struct ndr_interface_table *table,
+                                    int callnum, void *r, TALLOC_CTX *ctx);
+NTSTATUS irpc_call_recv(struct irpc_request *irpc);
+NTSTATUS irpc_call(struct messaging_context *msg_ctx,
+                   struct server_id server_id,
+                   const struct ndr_interface_table *table,
+                   int callnum, void *r, TALLOC_CTX *ctx);
+struct dcerpc_binding_handle *irpc_binding_handle(TALLOC_CTX *mem_ctx,
+                                        struct messaging_context *msg_ctx,
+                                        struct server_id server_id,
+                                        const struct ndr_interface_table *table);
+struct dcerpc_binding_handle *irpc_binding_handle_by_name(TALLOC_CTX *mem_ctx,
+                                        struct messaging_context *msg_ctx,
+                                        const char *dest_task,
+                                        const struct ndr_interface_table *table);
+void irpc_binding_handle_add_security_token(struct dcerpc_binding_handle *h,
+                                            struct security_token *token);
 NTSTATUS irpc_add_name(struct messaging_context *msg_ctx, const char *name);
 …
 void irpc_remove_name(struct messaging_context *msg_ctx, const char *name);
 NTSTATUS irpc_send_reply(struct irpc_message *m, NTSTATUS status);
-struct server_id messaging_get_server_id(struct messaging_context *msg_ctx);
 #endif

trunk/server/source4/lib/messaging/messaging.c

-              r414
+              r745
 #include "librpc/gen_ndr/ndr_irpc.h"
 #include "lib/messaging/irpc.h"
 #include "tdb_wrap.h"
+#include "lib/util/tdb_wrap.h"
 #include "../lib/util/unix_privs.h"
 #include "librpc/rpc/dcerpc.h"
 #include "../tdb/include/tdb.h"
+#include <tdb.h>
 #include "../lib/util/util_tdb.h"
 #include "cluster/cluster.h"
+#include "../lib/util/tevent_ntstatus.h"
 /* change the message version with any incompatible changes in the protocol */
 #define MESSAGING_VERSION 1
+/*
+  a pending irpc call
+*/
+struct irpc_request {
+        struct messaging_context *msg_ctx;
+        int callid;
+        struct {
+                void (*handler)(struct irpc_request *irpc, struct irpc_message *m);
+                void *private_data;
+        } incoming;
+};
 struct messaging_context {
 …
         struct messaging_rec *pending;
         struct messaging_rec *retry_queue;
-        struct smb_iconv_convenience *iconv_convenience;
         struct irpc_list *irpc;
         struct idr_context *idr;
 …
+{
         DEBUG(1,("INFO: Received PING message from server %u.%u [%.*s]\n",
                  (uint_t)src.node, (uint_t)src.id, (int)data->length,
+                 (unsigned int)src.node, (unsigned int)src.id, (int)data->length,
                  data->data?(const char *)data->data:""));
         messaging_send(msg, src, MSG_PONG, data);
 …
 static char *messaging_path(struct messaging_context *msg, struct server_id server_id)
+{
+        return talloc_asprintf(msg, "%s/msg.%s", msg->base_path,
+                               cluster_id_string(msg, server_id));
+        TALLOC_CTX *tmp_ctx = talloc_new(msg);
+        const char *id = cluster_id_string(tmp_ctx, server_id);
+        char *s;
+        if (id == NULL) {
+                return NULL;
+        }
+        s = talloc_asprintf(msg, "%s/msg.%s", msg->base_path, id);
+        talloc_steal(s, tmp_ctx);
+        return s;
+}
 …
                 rec->retries = 0;
                 if (!NT_STATUS_IS_OK(status)) {
+                        TALLOC_CTX *tmp_ctx = talloc_new(msg);
                         DEBUG(1,("messaging: Lost message from %s to %s of type %u - %s\n",
                                  cluster_id_string(debug_ctx(), rec->header->from),
                                  cluster_id_string(debug_ctx(), rec->header->to),
+                                 cluster_id_string(tmp_ctx, rec->header->from),
+                                 cluster_id_string(tmp_ctx, rec->header->to),
                                  rec->header->msg_type,
                                  nt_errstr(status)));
+                        talloc_free(tmp_ctx);
+                }
                 DLIST_REMOVE(msg->pending, rec);
 …
 */
 NTSTATUS messaging_send(struct messaging_context *msg, struct server_id server,
                         uint32_t msg_type, DATA_BLOB *data)
+                        uint32_t msg_type, const DATA_BLOB *data)
+{
         struct messaging_rec *rec;
 …
                                          const char *dir,
                                          struct server_id server_id,
-                                         struct smb_iconv_convenience *iconv_convenience,
                                          struct tevent_context *ev)
+{
 …
         msg->path          = messaging_path(msg, server_id);
         msg->server_id     = server_id;
-        msg->iconv_convenience = iconv_convenience;
         msg->idr           = idr_init(msg);
         msg->dispatch_tree = idr_init(msg);
 …
         msg->event.fde  = event_add_fd(ev, msg, socket_get_fd(msg->sock),
                                        EVENT_FD_READ, messaging_handler, msg);
+        tevent_fd_set_auto_close(msg->event.fde);
         talloc_set_destructor(msg, messaging_destructor);
 …
 struct messaging_context *messaging_client_init(TALLOC_CTX *mem_ctx,
                                                 const char *dir,
-                                                struct smb_iconv_convenience *iconv_convenience,
                                                 struct tevent_context *ev)
+{
 …
         ZERO_STRUCT(id);
         id.id = random() % 0x10000000;
         return messaging_init(mem_ctx, dir, id, iconv_convenience, ev);
+        return messaging_init(mem_ctx, dir, id, ev);
+}
 /*
 …
+{
         struct irpc_request *irpc;
-        enum ndr_err_code ndr_err;
         irpc = (struct irpc_request *)idr_find(msg_ctx->idr, m->header.callid);
         if (irpc == NULL) return;
+        /* parse the reply data */
+        ndr_err = irpc->table->calls[irpc->callnum].ndr_pull(m->ndr, NDR_OUT, irpc->r);
+        if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                irpc->status = m->header.status;
+                talloc_steal(irpc->mem_ctx, m);
+        } else {
+                irpc->status = ndr_map_error2ntstatus(ndr_err);
+                talloc_steal(irpc, m);
+        }
+        irpc->done = true;
+        if (irpc->async.fn) {
+                irpc->async.fn(irpc);
+        }
+        irpc->incoming.handler(irpc, m);
+}
 …
         /* setup the reply */
         push = ndr_push_init_ctx(m->ndr, m->msg_ctx->iconv_convenience);
+        push = ndr_push_init_ctx(m->ndr);
         if (push == NULL) {
                 status = NT_STATUS_NO_MEMORY;
 …
         m->header.flags |= IRPC_FLAG_REPLY;
+        m->header.creds.token= NULL;
         /* construct the packet */
 …
         if (r == NULL) goto failed;
+        m->ndr->flags |= LIBNDR_FLAG_REF_ALLOC;
         /* parse the request data */
         ndr_err = i->table->calls[i->callnum].ndr_pull(m->ndr, NDR_IN, r);
 …
         m->private_data= i->private_data;
         m->defer_reply = false;
+        m->no_reply    = false;
         m->msg_ctx     = msg_ctx;
         m->irpc        = i;
 …
         m->header.status = i->fn(m, r);
+        if (m->no_reply) {
+                /* the server function won't ever be replying to this request */
+                talloc_free(m);
+                return;
+        }
         if (m->defer_reply) {
                 /* the server function has asked to defer the reply to later */
 …
         m->from = src;
         m->ndr = ndr_pull_init_blob(packet, m, msg_ctx->iconv_convenience);
+        m->ndr = ndr_pull_init_blob(packet, m);
         if (m->ndr == NULL) goto failed;
 …
+        }
-        if (irpc->reject_free) {
-                return -1;
+        }
         return 0;
+}
-/*
-  timeout a irpc request
-*/
-static void irpc_timeout(struct tevent_context *ev, struct tevent_timer *te,
-                         struct timeval t, void *private_data)
+{
-        struct irpc_request *irpc = talloc_get_type(private_data, struct irpc_request);
-        irpc->status = NT_STATUS_IO_TIMEOUT;
-        irpc->done = true;
-        if (irpc->async.fn) {
-                irpc->async.fn(irpc);
+        }
+}
-/*
-  make a irpc call - async send
-*/
-struct irpc_request *irpc_call_send(struct messaging_context *msg_ctx,
-                                    struct server_id server_id,
-                                    const struct ndr_interface_table *table,
-                                    int callnum, void *r, TALLOC_CTX *ctx)
+{
-        struct irpc_header header;
-        struct ndr_push *ndr;
-        NTSTATUS status;
-        DATA_BLOB packet;
-        struct irpc_request *irpc;
-        enum ndr_err_code ndr_err;
-        irpc = talloc(msg_ctx, struct irpc_request);
-        if (irpc == NULL) goto failed;
-        irpc->msg_ctx  = msg_ctx;
-        irpc->table    = table;
-        irpc->callnum  = callnum;
-        irpc->callid   = idr_get_new(msg_ctx->idr, irpc, UINT16_MAX);
-        if (irpc->callid == -1) goto failed;
-        irpc->r        = r;
-        irpc->done     = false;
-        irpc->async.fn = NULL;
-        irpc->mem_ctx  = ctx;
-        irpc->reject_free = false;
-        talloc_set_destructor(irpc, irpc_destructor);
-        /* setup the header */
-        header.uuid = table->syntax_id.uuid;
-        header.if_version = table->syntax_id.if_version;
-        header.callid     = irpc->callid;
-        header.callnum    = callnum;
-        header.flags      = 0;
-        header.status     = NT_STATUS_OK;
-        /* construct the irpc packet */
-        ndr = ndr_push_init_ctx(irpc, msg_ctx->iconv_convenience);
-        if (ndr == NULL) goto failed;
-        ndr_err = ndr_push_irpc_header(ndr, NDR_SCALARS|NDR_BUFFERS, &header);
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) goto failed;
-        ndr_err = table->calls[callnum].ndr_push(ndr, NDR_IN, r);
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) goto failed;
-        /* and send it */
-        packet = ndr_push_blob(ndr);
-        status = messaging_send(msg_ctx, server_id, MSG_IRPC, &packet);
-        if (!NT_STATUS_IS_OK(status)) goto failed;
-        event_add_timed(msg_ctx->event.ev, irpc,
-                        timeval_current_ofs(IRPC_CALL_TIMEOUT, 0),
-                        irpc_timeout, irpc);
-        talloc_free(ndr);
-        return irpc;
-failed:
-        talloc_free(irpc);
-        return NULL;
+}
-/*
-  wait for a irpc reply
-*/
-NTSTATUS irpc_call_recv(struct irpc_request *irpc)
+{
-        NTSTATUS status;
-        NT_STATUS_HAVE_NO_MEMORY(irpc);
-        irpc->reject_free = true;
-        while (!irpc->done) {
-                if (event_loop_once(irpc->msg_ctx->event.ev) != 0) {
-                        return NT_STATUS_CONNECTION_DISCONNECTED;
+                }
+        }
-        irpc->reject_free = false;
-        status = irpc->status;
-        talloc_free(irpc);
-        return status;
+}
-/*
-  perform a synchronous irpc request
-*/
-NTSTATUS irpc_call(struct messaging_context *msg_ctx,
-                   struct server_id server_id,
-                   const struct ndr_interface_table *table,
-                   int callnum, void *r,
-                   TALLOC_CTX *mem_ctx)
+{
-        struct irpc_request *irpc = irpc_call_send(msg_ctx, server_id,
-                                                   table, callnum, r, mem_ctx);
-        return irpc_call_recv(irpc);
+}
 …
         return msg_ctx->server_id;
+}
+struct irpc_bh_state {
+        struct messaging_context *msg_ctx;
+        struct server_id server_id;
+        const struct ndr_interface_table *table;
+        uint32_t timeout;
+        struct security_token *token;
+};
+static bool irpc_bh_is_connected(struct dcerpc_binding_handle *h)
+{
+        struct irpc_bh_state *hs = dcerpc_binding_handle_data(h,
+                                   struct irpc_bh_state);
+        if (!hs->msg_ctx) {
+                return false;
+        }
+        return true;
+}
+static uint32_t irpc_bh_set_timeout(struct dcerpc_binding_handle *h,
+                                    uint32_t timeout)
+{
+        struct irpc_bh_state *hs = dcerpc_binding_handle_data(h,
+                                   struct irpc_bh_state);
+        uint32_t old = hs->timeout;
+        hs->timeout = timeout;
+        return old;
+}
+struct irpc_bh_raw_call_state {
+        struct irpc_request *irpc;
+        uint32_t opnum;
+        DATA_BLOB in_data;
+        DATA_BLOB in_packet;
+        DATA_BLOB out_data;
+};
+static void irpc_bh_raw_call_incoming_handler(struct irpc_request *irpc,
+                                              struct irpc_message *m);
+static struct tevent_req *irpc_bh_raw_call_send(TALLOC_CTX *mem_ctx,
+                                                struct tevent_context *ev,
+                                                struct dcerpc_binding_handle *h,
+                                                const struct GUID *object,
+                                                uint32_t opnum,
+                                                uint32_t in_flags,
+                                                const uint8_t *in_data,
+                                                size_t in_length)
+{
+        struct irpc_bh_state *hs =
+                dcerpc_binding_handle_data(h,
+                struct irpc_bh_state);
+        struct tevent_req *req;
+        struct irpc_bh_raw_call_state *state;
+        bool ok;
+        struct irpc_header header;
+        struct ndr_push *ndr;
+        NTSTATUS status;
+        enum ndr_err_code ndr_err;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct irpc_bh_raw_call_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->opnum = opnum;
+        state->in_data.data = discard_const_p(uint8_t, in_data);
+        state->in_data.length = in_length;
+        ok = irpc_bh_is_connected(h);
+        if (!ok) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_CONNECTION);
+                return tevent_req_post(req, ev);
+        }
+        state->irpc = talloc_zero(state, struct irpc_request);
+        if (tevent_req_nomem(state->irpc, req)) {
+                return tevent_req_post(req, ev);
+        }
+        state->irpc->msg_ctx  = hs->msg_ctx;
+        state->irpc->callid   = idr_get_new(hs->msg_ctx->idr,
+                                            state->irpc, UINT16_MAX);
+        if (state->irpc->callid == -1) {
+                tevent_req_nterror(req, NT_STATUS_INSUFFICIENT_RESOURCES);
+                return tevent_req_post(req, ev);
+        }
+        state->irpc->incoming.handler = irpc_bh_raw_call_incoming_handler;
+        state->irpc->incoming.private_data = req;
+        talloc_set_destructor(state->irpc, irpc_destructor);
+        /* setup the header */
+        header.uuid = hs->table->syntax_id.uuid;
+        header.if_version = hs->table->syntax_id.if_version;
+        header.callid     = state->irpc->callid;
+        header.callnum    = state->opnum;
+        header.flags      = 0;
+        header.status     = NT_STATUS_OK;
+        header.creds.token= hs->token;
+        /* construct the irpc packet */
+        ndr = ndr_push_init_ctx(state->irpc);
+        if (tevent_req_nomem(ndr, req)) {
+                return tevent_req_post(req, ev);
+        }
+        ndr_err = ndr_push_irpc_header(ndr, NDR_SCALARS|NDR_BUFFERS, &header);
+        status = ndr_map_error2ntstatus(ndr_err);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return tevent_req_post(req, ev);
+        }
+        ndr_err = ndr_push_bytes(ndr, in_data, in_length);
+        status = ndr_map_error2ntstatus(ndr_err);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return tevent_req_post(req, ev);
+        }
+        /* and send it */
+        state->in_packet = ndr_push_blob(ndr);
+        status = messaging_send(hs->msg_ctx, hs->server_id,
+                                MSG_IRPC, &state->in_packet);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return tevent_req_post(req, ev);
+        }
+        if (hs->timeout != IRPC_CALL_TIMEOUT_INF) {
+                /* set timeout-callback in case caller wants that */
+                ok = tevent_req_set_endtime(req, ev, timeval_current_ofs(hs->timeout, 0));
+                if (!ok) {
+                        return tevent_req_post(req, ev);
+                }
+        }
+        return req;
+}
+static void irpc_bh_raw_call_incoming_handler(struct irpc_request *irpc,
+                                              struct irpc_message *m)
+{
+        struct tevent_req *req =
+                talloc_get_type_abort(irpc->incoming.private_data,
+                struct tevent_req);
+        struct irpc_bh_raw_call_state *state =
+                tevent_req_data(req,
+                struct irpc_bh_raw_call_state);
+        talloc_steal(state, m);
+        if (!NT_STATUS_IS_OK(m->header.status)) {
+                tevent_req_nterror(req, m->header.status);
+                return;
+        }
+        state->out_data = data_blob_talloc(state,
+                m->ndr->data + m->ndr->offset,
+                m->ndr->data_size - m->ndr->offset);
+        if ((m->ndr->data_size - m->ndr->offset) > 0 && !state->out_data.data) {
+                tevent_req_nomem(NULL, req);
+                return;
+        }
+        tevent_req_done(req);
+}
+static NTSTATUS irpc_bh_raw_call_recv(struct tevent_req *req,
+                                        TALLOC_CTX *mem_ctx,
+                                        uint8_t **out_data,
+                                        size_t *out_length,
+                                        uint32_t *out_flags)
+{
+        struct irpc_bh_raw_call_state *state =
+                tevent_req_data(req,
+                struct irpc_bh_raw_call_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                tevent_req_received(req);
+                return status;
+        }
+        *out_data = talloc_move(mem_ctx, &state->out_data.data);
+        *out_length = state->out_data.length;
+        *out_flags = 0;
+        tevent_req_received(req);
+        return NT_STATUS_OK;
+}
+struct irpc_bh_disconnect_state {
+        uint8_t _dummy;
+};
+static struct tevent_req *irpc_bh_disconnect_send(TALLOC_CTX *mem_ctx,
+                                                struct tevent_context *ev,
+                                                struct dcerpc_binding_handle *h)
+{
+        struct irpc_bh_state *hs = dcerpc_binding_handle_data(h,
+                                     struct irpc_bh_state);
+        struct tevent_req *req;
+        struct irpc_bh_disconnect_state *state;
+        bool ok;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct irpc_bh_disconnect_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        ok = irpc_bh_is_connected(h);
+        if (!ok) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_CONNECTION);
+                return tevent_req_post(req, ev);
+        }
+        hs->msg_ctx = NULL;
+        tevent_req_done(req);
+        return tevent_req_post(req, ev);
+}
+static NTSTATUS irpc_bh_disconnect_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                tevent_req_received(req);
+                return status;
+        }
+        tevent_req_received(req);
+        return NT_STATUS_OK;
+}
+static bool irpc_bh_ref_alloc(struct dcerpc_binding_handle *h)
+{
+        return true;
+}
+static const struct dcerpc_binding_handle_ops irpc_bh_ops = {
+        .name                   = "wbint",
+        .is_connected           = irpc_bh_is_connected,
+        .set_timeout            = irpc_bh_set_timeout,
+        .raw_call_send          = irpc_bh_raw_call_send,
+        .raw_call_recv          = irpc_bh_raw_call_recv,
+        .disconnect_send        = irpc_bh_disconnect_send,
+        .disconnect_recv        = irpc_bh_disconnect_recv,
+        .ref_alloc              = irpc_bh_ref_alloc,
+};
+/* initialise a irpc binding handle */
+struct dcerpc_binding_handle *irpc_binding_handle(TALLOC_CTX *mem_ctx,
+                                        struct messaging_context *msg_ctx,
+                                        struct server_id server_id,
+                                        const struct ndr_interface_table *table)
+{
+        struct dcerpc_binding_handle *h;
+        struct irpc_bh_state *hs;
+        h = dcerpc_binding_handle_create(mem_ctx,
+                                         &irpc_bh_ops,
+                                         NULL,
+                                         table,
+                                         &hs,
+                                         struct irpc_bh_state,
+                                         __location__);
+        if (h == NULL) {
+                return NULL;
+        }
+        hs->msg_ctx = msg_ctx;
+        hs->server_id = server_id;
+        hs->table = table;
+        hs->timeout = IRPC_CALL_TIMEOUT;
+        dcerpc_binding_handle_set_sync_ev(h, msg_ctx->event.ev);
+        return h;
+}
+struct dcerpc_binding_handle *irpc_binding_handle_by_name(TALLOC_CTX *mem_ctx,
+                                        struct messaging_context *msg_ctx,
+                                        const char *dest_task,
+                                        const struct ndr_interface_table *table)
+{
+        struct dcerpc_binding_handle *h;
+        struct server_id *sids;
+        struct server_id sid;
+        /* find the server task */
+        sids = irpc_servers_byname(msg_ctx, mem_ctx, dest_task);
+        if (sids == NULL) {
+                errno = EADDRNOTAVAIL;
+                return NULL;
+        }
+        if (sids[0].id == 0) {
+                talloc_free(sids);
+                errno = EADDRNOTAVAIL;
+                return NULL;
+        }
+        sid = sids[0];
+        talloc_free(sids);
+        h = irpc_binding_handle(mem_ctx, msg_ctx,
+                                sid, table);
+        if (h == NULL) {
+                return NULL;
+        }
+        return h;
+}
+void irpc_binding_handle_add_security_token(struct dcerpc_binding_handle *h,
+                                            struct security_token *token)
+{
+        struct irpc_bh_state *hs =
+                dcerpc_binding_handle_data(h,
+                struct irpc_bh_state);
+        hs->token = token;
+}

trunk/server/source4/lib/messaging/messaging.h

-              r414
+              r745
 #define _MESSAGES_H_
+#include "librpc/gen_ndr/server_id4.h"
 struct messaging_context;
 …
 #define MSG_PVFS_NOTIFY         7
 #define MSG_NTVFS_OPLOCK_BREAK  8
+#define MSG_DREPL_ALLOCATE_RID  9
 /* temporary messaging endpoints are allocated above this line */
 …
 #define SAMBA_PARENT_TASKID     0
+typedef void (*msg_callback_t)(struct messaging_context *msg, void *private_data,
+                               uint32_t msg_type,
+                               struct server_id server_id, DATA_BLOB *data);
+NTSTATUS messaging_send(struct messaging_context *msg, struct server_id server,
+                        uint32_t msg_type, const DATA_BLOB *data);
+NTSTATUS messaging_register(struct messaging_context *msg, void *private_data,
+                            uint32_t msg_type,
+                            msg_callback_t fn);
+NTSTATUS messaging_register_tmp(struct messaging_context *msg, void *private_data,
+                                msg_callback_t fn, uint32_t *msg_type);
+struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx,
+                                         const char *dir,
+                                         struct server_id server_id,
+                                         struct tevent_context *ev);
+struct messaging_context *messaging_client_init(TALLOC_CTX *mem_ctx,
+                                         const char *dir,
+                                         struct tevent_context *ev);
+NTSTATUS messaging_send_ptr(struct messaging_context *msg, struct server_id server,
+                            uint32_t msg_type, void *ptr);
+void messaging_deregister(struct messaging_context *msg, uint32_t msg_type, void *private_data);
+struct server_id messaging_get_server_id(struct messaging_context *msg_ctx);
 #endif

trunk/server/source4/lib/messaging/pymessaging.c

-              r414
+              r745
 */
+#include <Python.h>
 #include "includes.h"
-#include <Python.h>
 #include "scripting/python/modules.h"
 #include "libcli/util/pyerrors.h"
 #include "librpc/rpc/pyrpc.h"
 #include "lib/messaging/irpc.h"
+#include "librpc/rpc/pyrpc_util.h"
+#include "librpc/ndr/libndr.h"
 #include "lib/messaging/messaging.h"
 #include "lib/events/events.h"
 …
 #include "param/param.h"
 #include "param/pyparam.h"
+#ifndef Py_RETURN_NONE
+#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
+#endif
+PyAPI_DATA(PyTypeObject) messaging_Type;
+PyAPI_DATA(PyTypeObject) irpc_ClientConnectionType;
+/* FIXME: This prototype should be in py_irpc.h, or shared otherwise */
+extern const struct PyNdrRpcMethodDef py_ndr_irpc_methods[];
+#include "librpc/rpc/dcerpc.h"
+#include "librpc/gen_ndr/server_id4.h"
+void initmessaging(void);
+extern PyTypeObject messaging_Type;
 static bool server_id_from_py(PyObject *object, struct server_id *server_id)
 …
 } messaging_Object;
 PyObject *py_messaging_connect(PyTypeObject *self, PyObject *args, PyObject *kwargs)
+static PyObject *py_messaging_connect(PyTypeObject *self, PyObject *args, PyObject *kwargs)
+{
         struct tevent_context *ev;
 …
         if (messaging_path == NULL) {
                 messaging_path = lp_messaging_path(ret->mem_ctx,
+                messaging_path = lpcfg_messaging_path(ret->mem_ctx,
                                                                    py_default_loadparm_context(ret->mem_ctx));
         } else {
 …
                                             messaging_path,
                                             server_id,
-                                        py_iconv_convenience(ret->mem_ctx),
                                             ev);
         } else {
                 ret->msg_ctx = messaging_client_init(ret->mem_ctx,
                                             messaging_path,
-                                        py_iconv_convenience(ret->mem_ctx),
                                             ev);
+        }
 …
         messaging_Object *iface = (messaging_Object *)self;
         talloc_free(iface->msg_ctx);
         PyObject_Del(self);
+        self->ob_type->tp_free(self);
+}
 …
         int length;
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Ois#|:send",
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Ois#:send",
                 discard_const_p(char *, kwnames), &target, &msg_type, &data.data, &length)) {
                 return NULL;
+        }
 …
         data.length = length;
         if (!server_id_from_py(target, &server))
+        if (!server_id_from_py(target, &server))
                 return NULL;
 …
         const char *kwnames[] = { "callback", "msg_type", NULL };
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:send",
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:register",
                 discard_const_p(char *, kwnames), &callback, &msg_type)) {
                 return NULL;
 …
         const char *kwnames[] = { "callback", "msg_type", NULL };
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:send",
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|i:deregister",
                 discard_const_p(char *, kwnames), &callback, &msg_type)) {
                 return NULL;
 …
         Py_DECREF(callback);
-        Py_RETURN_NONE;
+}
-static PyObject *py_messaging_add_name(PyObject *self, PyObject *args, PyObject *kwargs)
+{
-        messaging_Object *iface = (messaging_Object *)self;
-        NTSTATUS status;
-        char *name;
-        const char *kwnames[] = { "name", NULL };
-        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|:send",
-                discard_const_p(char *, kwnames), &name)) {
-                return NULL;
+        }
-        status = irpc_add_name(iface->msg_ctx, name);
-        if (NT_STATUS_IS_ERR(status)) {
-                PyErr_SetNTSTATUS(status);
-                return NULL;
+        }
-        Py_RETURN_NONE;
+}
-static PyObject *py_messaging_remove_name(PyObject *self, PyObject *args, PyObject *kwargs)
+{
-        messaging_Object *iface = (messaging_Object *)self;
-        char *name;
-        const char *kwnames[] = { "name", NULL };
-        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|:send",
-                discard_const_p(char *, kwnames), &name)) {
-                return NULL;
+        }
-        irpc_remove_name(iface->msg_ctx, name);
         Py_RETURN_NONE;
 …
         { "deregister", (PyCFunction)py_messaging_deregister, METH_VARARGS|METH_KEYWORDS,
                 "S.deregister(callback, msg_type) -> None\nDeregister a message handler" },
-        { "add_name", (PyCFunction)py_messaging_add_name, METH_VARARGS|METH_KEYWORDS, "S.add_name(name) -> None\nListen on another name" },
-        { "remove_name", (PyCFunction)py_messaging_remove_name, METH_VARARGS|METH_KEYWORDS, "S.remove_name(name) -> None\nStop listening on a name" },
         { NULL, NULL, 0, NULL }
 };
 …
 PyTypeObject messaging_Type = {
         PyObject_HEAD_INIT(NULL) 0,
         .tp_name = "irpc.Messaging",
+        .tp_name = "messaging.Messaging",
         .tp_basicsize = sizeof(messaging_Object),
         .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 …
 };
-/*
-  state of a irpc 'connection'
-*/
-typedef struct {
-        PyObject_HEAD
-        const char *server_name;
-        struct server_id *dest_ids;
-        struct messaging_context *msg_ctx;
-        TALLOC_CTX *mem_ctx;
-} irpc_ClientConnectionObject;
-/*
-  setup a context for talking to a irpc server
-     example:
-        status = irpc.connect("smb_server");
-*/
-PyObject *py_irpc_connect(PyTypeObject *self, PyObject *args, PyObject *kwargs)
+{
-        struct tevent_context *ev;
-        const char *kwnames[] = { "server", "own_id", "messaging_path", NULL };
-        char *server;
-        const char *messaging_path = NULL;
-        PyObject *own_id = Py_None;
-        irpc_ClientConnectionObject *ret;
-        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|Oz:connect",
-                discard_const_p(char *, kwnames), &server, &own_id, &messaging_path)) {
-                return NULL;
+        }
-        ret = PyObject_New(irpc_ClientConnectionObject, &irpc_ClientConnectionType);
-        if (ret == NULL)
-                return NULL;
-        ret->mem_ctx = talloc_new(NULL);
-        ret->server_name = server;
-        ev = s4_event_context_init(ret->mem_ctx);
-        if (messaging_path == NULL) {
-                messaging_path = lp_messaging_path(ret->mem_ctx,
-                                                                   py_default_loadparm_context(ret->mem_ctx));
-        } else {
-                messaging_path = talloc_strdup(ret->mem_ctx, messaging_path);
+        }
-        if (own_id != Py_None) {
-                struct server_id server_id;
-                if (!server_id_from_py(own_id, &server_id))
-                        return NULL;
-                ret->msg_ctx = messaging_init(ret->mem_ctx,
-                                            messaging_path,
-                                            server_id,
-                                        py_iconv_convenience(ret->mem_ctx),
-                                            ev);
-        } else {
-                ret->msg_ctx = messaging_client_init(ret->mem_ctx,
-                                            messaging_path,
-                                        py_iconv_convenience(ret->mem_ctx),
-                                            ev);
+        }
-        if (ret->msg_ctx == NULL) {
-                PyErr_SetString(PyExc_RuntimeError, "irpc_connect unable to create a messaging context");
-                talloc_free(ret->mem_ctx);
-                return NULL;
+        }
-        ret->dest_ids = irpc_servers_byname(ret->msg_ctx, ret->mem_ctx, ret->server_name);
-        if (ret->dest_ids == NULL || ret->dest_ids[0].id == 0) {
-                talloc_free(ret->mem_ctx);
-                PyErr_SetNTSTATUS(NT_STATUS_OBJECT_NAME_NOT_FOUND);
-                return NULL;
-        } else {
-                return (PyObject *)ret;
+        }
+}
-typedef struct {
-        PyObject_HEAD
-        struct irpc_request **reqs;
-        int count;
-        int current;
-        TALLOC_CTX *mem_ctx;
-        py_data_unpack_fn unpack_fn;
-} irpc_ResultObject;
-static PyObject *irpc_result_next(irpc_ResultObject *iterator)
+{
-        NTSTATUS status;
-        if (iterator->current >= iterator->count) {
-                PyErr_SetString(PyExc_StopIteration, "No more results");
-                return NULL;
+        }
-        status = irpc_call_recv(iterator->reqs[iterator->current]);
-        iterator->current++;
-        if (!NT_STATUS_IS_OK(status)) {
-                PyErr_SetNTSTATUS(status);
-                return NULL;
+        }
-        return iterator->unpack_fn(iterator->reqs[iterator->current-1]->r);
+}
-static PyObject *irpc_result_len(irpc_ResultObject *self)
+{
-        return PyLong_FromLong(self->count);
+}
-static PyMethodDef irpc_result_methods[] = {
-        { "__len__", (PyCFunction)irpc_result_len, METH_NOARGS,
-                "Number of elements returned"},
-        { NULL }
-};
-static void irpc_result_dealloc(PyObject *self)
+{
-        talloc_free(((irpc_ResultObject *)self)->mem_ctx);
-        PyObject_Del(self);
+}
-PyTypeObject irpc_ResultIteratorType = {
-        PyObject_HEAD_INIT(NULL) 0,
-        .tp_name = "irpc.ResultIterator",
-        .tp_basicsize = sizeof(irpc_ResultObject),
-        .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
-        .tp_iternext = (iternextfunc)irpc_result_next,
-        .tp_iter = PyObject_SelfIter,
-        .tp_methods = irpc_result_methods,
-        .tp_dealloc = irpc_result_dealloc,
-};
-static PyObject *py_irpc_call(irpc_ClientConnectionObject *p, struct PyNdrRpcMethodDef *method_def, PyObject *args, PyObject *kwargs)
+{
-        void *ptr;
-        struct irpc_request **reqs;
-        int i, count;
-        NTSTATUS status;
-        TALLOC_CTX *mem_ctx = talloc_new(NULL);
-        irpc_ResultObject *ret;
-        /* allocate the C structure */
-        ptr = talloc_zero_size(mem_ctx, method_def->table->calls[method_def->opnum].struct_size);
-        if (ptr == NULL) {
-                status = NT_STATUS_NO_MEMORY;
-                goto done;
+        }
-        /* convert the mpr object into a C structure */
-        if (!method_def->pack_in_data(args, kwargs, ptr)) {
-                talloc_free(mem_ctx);
-                return NULL;
+        }
-        for (count=0;p->dest_ids[count].id;count++) /* noop */ ;
-        /* we need to make a call per server */
-        reqs = talloc_array(mem_ctx, struct irpc_request *, count);
-        if (reqs == NULL) {
-                status = NT_STATUS_NO_MEMORY;
-                goto done;
+        }
-        /* make the actual calls */
-        for (i=0;i<count;i++) {
-                reqs[i] = irpc_call_send(p->msg_ctx, p->dest_ids[i],
-                                         method_def->table, method_def->opnum, ptr, ptr);
-                if (reqs[i] == NULL) {
-                        status = NT_STATUS_NO_MEMORY;
-                        goto done;
+                }
-                talloc_steal(reqs, reqs[i]);
+        }
-        ret = PyObject_New(irpc_ResultObject, &irpc_ResultIteratorType);
-        ret->mem_ctx = mem_ctx;
-        ret->reqs = reqs;
-        ret->count = count;
-        ret->current = 0;
-        ret->unpack_fn = method_def->unpack_out_data;
-        return (PyObject *)ret;
-done:
-        talloc_free(mem_ctx);
-        PyErr_SetNTSTATUS(status);
-        return NULL;
+}
-static PyObject *py_irpc_call_wrapper(PyObject *self, PyObject *args, void *wrapped, PyObject *kwargs)
+{
-        irpc_ClientConnectionObject *iface = (irpc_ClientConnectionObject *)self;
-        struct PyNdrRpcMethodDef *md = wrapped;
-        return py_irpc_call(iface, md, args, kwargs);
+}
-static void py_irpc_dealloc(PyObject *self)
+{
-        irpc_ClientConnectionObject *iface = (irpc_ClientConnectionObject *)self;
-        talloc_free(iface->mem_ctx);
-        PyObject_Del(self);
+}
-PyTypeObject irpc_ClientConnectionType = {
-        PyObject_HEAD_INIT(NULL) 0,
-        .tp_name = "irpc.ClientConnection",
-        .tp_basicsize = sizeof(irpc_ClientConnectionObject),
-        .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
-        .tp_new = py_irpc_connect,
-        .tp_dealloc = py_irpc_dealloc,
-        .tp_doc = "ClientConnection(server, own_id=None, messaging_path=None)\n" \
-                  "Create a new IRPC client connection to communicate with the servers in the specified path.\n" \
-                  "If no path is specified, the default path from smb.conf will be used."
-};
-static bool irpc_AddNdrRpcMethods(PyTypeObject *ifacetype, const struct PyNdrRpcMethodDef *mds)
+{
-        int i;
-        for (i = 0; mds[i].name; i++) {
-                PyObject *ret;
-                struct wrapperbase *wb = calloc(sizeof(struct wrapperbase), 1);
-                wb->name = discard_const_p(char, mds[i].name);
-                wb->flags = PyWrapperFlag_KEYWORDS;
-                wb->wrapper = (wrapperfunc)py_irpc_call_wrapper;
-                wb->doc = discard_const_p(char, mds[i].doc);
-                ret = PyDescr_NewWrapper(ifacetype, wb, discard_const_p(void, &mds[i]));
-                PyDict_SetItemString(ifacetype->tp_dict, mds[i].name,
-                                     (PyObject *)ret);
+        }
-        return true;
+}
 void initmessaging(void)
+{
         PyObject *mod;
-        PyObject *dep_irpc;
-        dep_irpc = PyImport_ImportModule("samba.dcerpc.irpc");
-        if (dep_irpc == NULL)
-                return;
-        if (PyType_Ready(&irpc_ClientConnectionType) < 0)
-                return;
         if (PyType_Ready(&messaging_Type) < 0)
-                return;
-        if (PyType_Ready(&irpc_ResultIteratorType) < 0)
-                return;
-        if (!irpc_AddNdrRpcMethods(&irpc_ClientConnectionType, py_ndr_irpc_methods))
                 return;
 …
                 return;
-        Py_INCREF((PyObject *)&irpc_ClientConnectionType);
-        PyModule_AddObject(mod, "ClientConnection", (PyObject *)&irpc_ClientConnectionType);
         Py_INCREF((PyObject *)&messaging_Type);
         PyModule_AddObject(mod, "Messaging", (PyObject *)&messaging_Type);

trunk/server/source4/lib/messaging/tests/irpc.c

-              r414
+              r745
 #include "lib/messaging/irpc.h"
 #include "librpc/gen_ndr/ndr_echo.h"
+#include "librpc/gen_ndr/ndr_echo_c.h"
 #include "torture/torture.h"
 #include "cluster/cluster.h"
 …
+{
         struct irpc_message *irpc = talloc_get_type(private_data, struct irpc_message);
         struct echo_EchoData *r = irpc->data;
         r->out.out_data = talloc_memdup(r, r->in.in_data, r->in.len);
+        struct echo_EchoData *r = (struct echo_EchoData *)irpc->data;
+        r->out.out_data = (uint8_t *)talloc_memdup(r, r->in.in_data, r->in.len);
         if (r->out.out_data == NULL) {
                 irpc_send_reply(irpc, NT_STATUS_NO_MEMORY);
 …
         const struct irpc_test_data *data = (const struct irpc_test_data *)_data;
         uint32_t value = *(const uint32_t *)_value;
+        struct dcerpc_binding_handle *irpc_handle;
+        irpc_handle = irpc_binding_handle(test, data->msg_ctx1,
+                                          cluster_id(0, MSG_ID2),
+                                          &ndr_table_rpcecho);
+        torture_assert(test, irpc_handle, "no memory");
         /* make the call */
 …
         test_debug = true;
+        status = IRPC_CALL(data->msg_ctx1, cluster_id(0, MSG_ID2),
+                           rpcecho, ECHO_ADDONE, &r, test);
+        status = dcerpc_echo_AddOne_r(irpc_handle, test, &r);
         test_debug = false;
         torture_assert_ntstatus_ok(test, status, "AddOne failed");
 …
         const struct irpc_test_data *data = (const struct irpc_test_data *)tcase_data;
         TALLOC_CTX *mem_ctx = tctx;
+        struct dcerpc_binding_handle *irpc_handle;
+        irpc_handle = irpc_binding_handle(mem_ctx, data->msg_ctx1,
+                                          cluster_id(0, MSG_ID2),
+                                          &ndr_table_rpcecho);
+        torture_assert(tctx, irpc_handle, "no memory");
         /* make the call */
 …
         r.in.len = strlen((char *)r.in.in_data);
+        status = IRPC_CALL(data->msg_ctx1, cluster_id(0, MSG_ID2),
+                           rpcecho, ECHO_ECHODATA, &r,
+                           mem_ctx);
+        status = dcerpc_echo_EchoData_r(irpc_handle, mem_ctx, &r);
         torture_assert_ntstatus_ok(tctx, status, "EchoData failed");
 …
+}
+static void irpc_callback(struct irpc_request *irpc)
+{
+        struct echo_AddOne *r = (struct echo_AddOne *)irpc->r;
+        int *pong_count = (int *)irpc->async.private_data;
+        NTSTATUS status = irpc_call_recv(irpc);
+struct irpc_callback_state {
+        struct echo_AddOne r;
+        int *pong_count;
+};
+static void irpc_callback(struct tevent_req *subreq)
+{
+        struct irpc_callback_state *s =
+                tevent_req_callback_data(subreq,
+                struct irpc_callback_state);
+        NTSTATUS status;
+        status = dcerpc_echo_AddOne_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {
                 printf("irpc call failed - %s\n", nt_errstr(status));
+        }
         if (*r->out.out_data != r->in.in_data + 1) {
+        if (*s->r.out.out_data != s->r.in.in_data + 1) {
                 printf("AddOne wrong answer - %u + 1 = %u should be %u\n",
                        r->in.in_data, *r->out.out_data, r->in.in_data+1);
+        }
         (*pong_count)++;
+                       s->r.in.in_data, *s->r.out.out_data, s->r.in.in_data+1);
+        }
+        (*s->pong_count)++;
+}
 …
         const struct irpc_test_data *data = (const struct irpc_test_data *)tcase_data;
         struct timeval tv;
-        struct echo_AddOne r;
         TALLOC_CTX *mem_ctx = tctx;
         int timelimit = torture_setting_int(tctx, "timelimit", 10);
+        struct dcerpc_binding_handle *irpc_handle;
+        irpc_handle = irpc_binding_handle(mem_ctx, data->msg_ctx1,
+                                          cluster_id(0, MSG_ID2),
+                                          &ndr_table_rpcecho);
+        torture_assert(tctx, irpc_handle, "no memory");
         tv = timeval_current();
-        r.in.in_data = 0;
         torture_comment(tctx, "Sending echo for %d seconds\n", timelimit);
         while (timeval_elapsed(&tv) < timelimit) {
+                struct irpc_request *irpc;
+                irpc = IRPC_CALL_SEND(data->msg_ctx1, cluster_id(0, MSG_ID2),
+                                      rpcecho, ECHO_ADDONE,
+                                      &r, mem_ctx);
+                torture_assert(tctx, irpc != NULL, "AddOne send failed");
+                irpc->async.fn = irpc_callback;
+                irpc->async.private_data = &pong_count;
+                struct tevent_req *subreq;
+                struct irpc_callback_state *s;
+                s = talloc_zero(mem_ctx, struct irpc_callback_state);
+                torture_assert(tctx, s != NULL, "no mem");
+                s->pong_count = &pong_count;
+                subreq = dcerpc_echo_AddOne_r_send(mem_ctx,
+                                                   tctx->ev,
+                                                   irpc_handle,
+                                                   &s->r);
+                torture_assert(tctx, subreq != NULL, "AddOne send failed");
+                tevent_req_set_callback(subreq, irpc_callback, s);
                 ping_count++;
 …
         *_data = data = talloc(tctx, struct irpc_test_data);
         lp_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
+        lpcfg_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
         data->ev = tctx->ev;
         torture_assert(tctx, data->msg_ctx1 =
                        messaging_init(tctx,
                                       lp_messaging_path(tctx, tctx->lp_ctx),
+                                      lpcfg_messaging_path(tctx, tctx->lp_ctx),
                                       cluster_id(0, MSG_ID1),
-                                      lp_iconv_convenience(tctx->lp_ctx),
                                       data->ev),
                        "Failed to init first messaging context");
 …
         torture_assert(tctx, data->msg_ctx2 =
                        messaging_init(tctx,
                                       lp_messaging_path(tctx, tctx->lp_ctx),
+                                      lpcfg_messaging_path(tctx, tctx->lp_ctx),
                                       cluster_id(0, MSG_ID2),
-                                      lp_iconv_convenience(tctx->lp_ctx),
                                       data->ev),
                        "Failed to init second messaging context");
 …
 struct torture_suite *torture_local_irpc(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "IRPC");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "irpc");
         struct torture_tcase *tcase = torture_suite_add_tcase(suite, "irpc");
         int i;

trunk/server/source4/lib/messaging/tests/messaging.c

-              r414
+              r745
         uint32_t msg_ping, msg_exit;
         lp_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
+        lpcfg_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
         ev = tctx->ev;
         msg_server_ctx = messaging_init(tctx,
+                                        lp_messaging_path(tctx, tctx->lp_ctx),
+                                        cluster_id(0, 1),
+                                        lp_iconv_convenience(tctx->lp_ctx),
+                                        lpcfg_messaging_path(tctx, tctx->lp_ctx), cluster_id(0, 1),
                                         ev);
 …
         msg_client_ctx = messaging_init(tctx,
                                         lp_messaging_path(tctx, tctx->lp_ctx),
+                                        lpcfg_messaging_path(tctx, tctx->lp_ctx),
                                         cluster_id(0, 2),
-                                        lp_iconv_convenience(tctx->lp_ctx),
                                         ev);
 …
 struct torture_suite *torture_local_messaging(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *s = torture_suite_create(mem_ctx, "MESSAGING");
+        struct torture_suite *s = torture_suite_create(mem_ctx, "messaging");
         torture_suite_add_simple_test(s, "ping_speed", test_ping_speed);
         return s;

trunk/server/source4/lib/registry/dir.c

-              r414
+              r745
         path = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(path);
         ret = mkdir(path, 0700);
         if (ret == 0) {
                 struct dir_key *key = talloc(mem_ctx, struct dir_key);
+                W_ERROR_HAVE_NO_MEMORY(key);
                 key->key.ops = &reg_backend_dir;
                 key->path = talloc_steal(key, path);
 …
                 path = talloc_asprintf(name, "%s/%s", name, e->d_name);
+                if (!path)
+                        return WERR_NOMEM;
+                W_ERROR_HAVE_NO_MEMORY(path);
                 stat(path, &stbuf);
 …
+}
+static WERROR reg_dir_del_key(const struct hive_key *k, const char *name)
+static WERROR reg_dir_del_key(TALLOC_CTX *mem_ctx, const struct hive_key *k,
+                              const char *name)
+{
         struct dir_key *dk = talloc_get_type(k, struct dir_key);
         char *child = talloc_asprintf(NULL, "%s/%s", dk->path, name);
+        char *child;
         WERROR ret;
+        child = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(child);
         ret = reg_dir_delete_recursive(child);
 …
         fullpath = talloc_asprintf(mem_ctx, "%s/%s", p->path, name);
+        W_ERROR_HAVE_NO_MEMORY(fullpath);
         d = opendir(fullpath);
 …
                 DEBUG(3,("Unable to open '%s': %s\n", fullpath,
                         strerror(errno)));
+                talloc_free(fullpath);
                 return WERR_BADFILE;
+        }
 …
         struct dirent *e;
         const struct dir_key *dk = talloc_get_type(k, struct dir_key);
         int i = 0;
+        unsigned int i = 0;
         DIR *d;
 …
                         /* Check if file is a directory */
+                        asprintf(&thispath, "%s/%s", dk->path, e->d_name);
+                        thispath = talloc_asprintf(mem_ctx, "%s/%s", dk->path,
+                                                   e->d_name);
+                        W_ERROR_HAVE_NO_MEMORY(thispath);
                         stat(thispath, &stbuf);
                         if (!S_ISDIR(stbuf.st_mode)) {
                                 SAFE_FREE(thispath);
+                                talloc_free(thispath);
                                 continue;
+                        }
 …
                                 struct stat st;
                                 *name = talloc_strdup(mem_ctx, e->d_name);
+                                W_ERROR_HAVE_NO_MEMORY(*name);
                                 *classname = NULL;
                                 stat(thispath, &st);
                                 unix_to_nt_time(last_mod_time, st.st_mtime);
                                 SAFE_FREE(thispath);
+                                talloc_free(thispath);
                                 closedir(d);
                                 return WERR_OK;
 …
                         i++;
                         SAFE_FREE(thispath);
+                        talloc_free(thispath);
+                }
+        }
 …
         dk = talloc(parent_ctx, struct dir_key);
+        W_ERROR_HAVE_NO_MEMORY(dk);
         dk->key.ops = &reg_backend_dir;
         dk->path = talloc_strdup(dk, location);
 …
                         char *path = talloc_asprintf(ctx, "%s/%s",
                                                      dk->path, e->d_name);
+                        W_ERROR_HAVE_NO_MEMORY(path);
                         if (stat(path, &st) < 0) {
                                 DEBUG(0, ("Error statting %s: %s\n", path,
                                         strerror(errno)));
+                                talloc_free(path);
                                 continue;
+                        }
 …
+{
         const struct dir_key *dk = talloc_get_type(key, struct dir_key);
+        char *path = talloc_asprintf(dk, "%s/%s", dk->path, name);
+        if (!file_save(path, data.data, data.length))
+        char *path;
+        bool ret;
+        path = talloc_asprintf(dk, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(path);
+        ret = file_save(path, data.data, data.length);
+        talloc_free(path);
+        if (!ret) {
                 return WERR_GENERAL_FAILURE;
+        }
         /* FIXME: Type */
 …
+{
         const struct dir_key *dk = talloc_get_type(key, struct dir_key);
         char *path = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        char *path;
         size_t size;
         char *contents;
+        path = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(path);
         contents = file_load(path, &size, 0, mem_ctx);
         talloc_free(path);
         if (contents == NULL)
                 return WERR_BADFILE;
 …
 static WERROR reg_dir_enum_value(TALLOC_CTX *mem_ctx,
                                  struct hive_key *key, int idx,
+                                 struct hive_key *key, uint32_t idx,
                                  const char **name,
                                  uint32_t *type, DATA_BLOB *data)
 …
         DIR *d;
         struct dirent *e;
         int i;
+        unsigned int i;
         d = opendir(dk->path);
 …
                 if (i == idx) {
                         if (name != NULL)
+                        if (name != NULL) {
                                 *name = talloc_strdup(mem_ctx, e->d_name);
+                                W_ERROR_HAVE_NO_MEMORY(*name);
+                        }
                         W_ERROR_NOT_OK_RETURN(reg_dir_get_value(mem_ctx, key,
                                                                 *name, type,
 …
+static WERROR reg_dir_del_value (struct hive_key *key, const char *name)
+static WERROR reg_dir_del_value(TALLOC_CTX *mem_ctx,
+                                struct hive_key *key, const char *name)
+{
         const struct dir_key *dk = talloc_get_type(key, struct dir_key);
+        char *path = talloc_asprintf(key, "%s/%s", dk->path, name);
+        if (unlink(path) < 0) {
+                talloc_free(path);
+        char *path;
+        int ret;
+        path = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(path);
+        ret = unlink(path);
+        talloc_free(path);
+        if (ret < 0) {
                 if (errno == ENOENT)
                         return WERR_BADFILE;
                 return WERR_GENERAL_FAILURE;
+        }
-        talloc_free(path);
         return WERR_OK;

trunk/server/source4/lib/registry/hive.c

r414	r745
55	55	if (!strncmp(peek, "regf", 4)) {
56	56	close(fd);
57		return reg_open_regf_file(parent_ctx, location, ~~lp_iconv_convenience(lp_ctx),~~ root);
	57	return reg_open_regf_file(parent_ctx, location, root);
58	58	} else if (!strncmp(peek, "TDB file", 8)) {
59	59	close(fd);
…	…
92	92	}
93	93
94		_PUBLIC_ WERROR hive_key_del(const struct hive_key key, const char name)
	94	_PUBLIC_ WERROR hive_key_del(TALLOC_CTX mem_ctx, const struct hive_key key,
	95	const char *name)
95	96	{
96		return key->ops->del_key(key, name);
	97	return key->ops->del_key(mem_ctx, key, name);
97	98	}
98	99
…	…
164	165	}
165	166
166		WERROR hive_key_del_value(struct hive_key key, const char name)
	167	WERROR hive_key_del_value(TALLOC_CTX mem_ctx, struct hive_key key,
	168	const char *name)
167	169	{
168	170	if (key->ops->delete_value == NULL)
169	171	return WERR_NOT_SUPPORTED;
170	172
171		return key->ops->delete_value(key, name);
	173	return key->ops->delete_value(mem_ctx, key, name);
172	174	}
173	175

trunk/server/source4/lib/registry/interface.c

-              r414
+              r745
 _PUBLIC_ const char *reg_get_predef_name(uint32_t hkey)
+{
         int i;
+        unsigned int i;
         for (i = 0; reg_predefined_keys[i].name; i++) {
                 if (reg_predefined_keys[i].handle == hkey)
 …
                                                struct registry_key **key)
+{
         int i;
+        unsigned int i;
         for (i = 0; reg_predefined_keys[i].name; i++) {
 …
 _PUBLIC_ WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
                                             const struct registry_key *key,
                                             int idx, const char **name,
+                                            uint32_t idx, const char **name,
                                             const char **keyclass,
                                             NTTIME *last_changed_time)
 …
  * Delete a key.
  */
+_PUBLIC_ WERROR reg_key_del(struct registry_key *parent, const char *name)
+_PUBLIC_ WERROR reg_key_del(TALLOC_CTX *mem_ctx, struct registry_key *parent,
+                            const char *name)
+{
         if (parent == NULL)
 …
                 return WERR_NOT_SUPPORTED;
         return parent->context->ops->delete_key(parent, name);
+        return parent->context->ops->delete_key(mem_ctx, parent, name);
+}
 …
 _PUBLIC_ WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
                                  struct registry_key *parent,
                                  const char *name, const char *key_class,
+                                 const char *path, const char *key_class,
                                  struct security_descriptor *desc,
                                  struct registry_key **newkey)
 …
+        }
         return parent->context->ops->create_key(mem_ctx, parent, name,
+        return parent->context->ops->create_key(mem_ctx, parent, path,
                                                 key_class, desc, newkey);
+}
 …
  * Delete a value.
  */
+_PUBLIC_ WERROR reg_del_value(struct registry_key *key, const char *valname)
+_PUBLIC_ WERROR reg_del_value(TALLOC_CTX *mem_ctx, struct registry_key *key,
+                              const char *valname)
+{
         if (key == NULL)
 …
                 return WERR_NOT_SUPPORTED;
         return key->context->ops->delete_value(key, valname);
+        return key->context->ops->delete_value(mem_ctx, key, valname);
+}

trunk/server/source4/lib/registry/ldb.c

-              r414
+              r745
    Registry interface
    Copyright (C) 2004-2007, Jelmer Vernooij, jelmer@samba.org
    Copyright (C) 2008 Matthias Dieter WallnÃ¶fer, mwallnoefer@yahoo.de
+   Copyright (C) 2008-2010, Matthias Dieter WallnÃ¶fer, mdw@samba.org
    This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
 #include "registry.h"
 #include "lib/ldb/include/ldb.h"
 #include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "ldb_wrap.h"
 #include "librpc/gen_ndr/winreg.h"
 …
         struct ldb_dn *dn;
         struct ldb_message **subkeys, **values;
+        int subkey_count, value_count;
+        unsigned int subkey_count, value_count;
+        const char *classname;
 };
 static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx,
+static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx,
                                  struct ldb_message *msg,
                                  const char **name, uint32_t *type,
 …
         uint32_t value_type;
         if (name != NULL)
+        if (name != NULL) {
                 *name = talloc_strdup(mem_ctx,
                                       ldb_msg_find_attr_as_string(msg, "value",
+                                      NULL));
+                                      ""));
+        }
         value_type = ldb_msg_find_attr_as_uint(msg, "type", 0);
         *type = value_type;
+        *type = value_type;
         val = ldb_msg_find_ldb_val(msg, "data");
 …
         case REG_SZ:
         case REG_EXPAND_SZ:
+                if (val != NULL)
+                if (val != NULL) {
+                        /* The data should be provided as UTF16 string */
                         convert_string_talloc(mem_ctx, CH_UTF8, CH_UTF16,
                                                      val->data, val->length,
                                                      (void **)&data->data, &data->length, false);
                 else {
+                                              val->data, val->length,
+                                              (void **)&data->data, &data->length, false);
+                } else {
                         data->data = NULL;
                         data->length = 0;
 …
                 break;
+        case REG_BINARY:
+                if (val != NULL)
+                        *data = data_blob_talloc(mem_ctx, val->data, val->length);
+                else {
+        case REG_DWORD:
+        case REG_DWORD_BIG_ENDIAN:
+                if (val != NULL) {
+                        /* The data is a plain DWORD */
+                        uint32_t tmp = strtoul((char *)val->data, NULL, 0);
+                        data->data = talloc_size(mem_ctx, sizeof(uint32_t));
+                        if (data->data != NULL) {
+                                SIVAL(data->data, 0, tmp);
+                        }
+                        data->length = sizeof(uint32_t);
+                } else {
                         data->data = NULL;
                         data->length = 0;
 …
                 break;
+        case REG_DWORD: {
+                uint32_t tmp = strtoul((char *)val->data, NULL, 0);
+                *data = data_blob_talloc(mem_ctx, &tmp, 4);
+        case REG_QWORD:
+                if (val != NULL) {
+                        /* The data is a plain QWORD */
+                        uint64_t tmp = strtoull((char *)val->data, NULL, 0);
+                        data->data = talloc_size(mem_ctx, sizeof(uint64_t));
+                        if (data->data != NULL) {
+                                SBVAL(data->data, 0, tmp);
+                        }
+                        data->length = sizeof(uint64_t);
+                } else {
+                        data->data = NULL;
+                        data->length = 0;
+                }
                 break;
+        case REG_BINARY:
         default:
+                *data = data_blob_talloc(mem_ctx, val->data, val->length);
+                if (val != NULL) {
+                        data->data = talloc_memdup(mem_ctx, val->data,
+                                                   val->length);
+                        data->length = val->length;
+                } else {
+                        data->data = NULL;
+                        data->length = 0;
+                }
                 break;
+        }
 …
                                               uint32_t type, DATA_BLOB data)
+{
+        struct ldb_val val;
+        struct ldb_message *msg = talloc_zero(mem_ctx, struct ldb_message);
+        char *type_s;
+        ldb_msg_add_string(msg, "value", talloc_strdup(mem_ctx, name));
+        struct ldb_message *msg;
+        char *name_dup, *type_str;
+        int ret;
+        msg = talloc_zero(mem_ctx, struct ldb_message);
+        if (msg == NULL) {
+                return NULL;
+        }
+        name_dup = talloc_strdup(msg, name);
+        if (name_dup == NULL) {
+                talloc_free(msg);
+                return NULL;
+        }
+        ret = ldb_msg_add_string(msg, "value", name_dup);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(msg);
+                return NULL;
+        }
         switch (type) {
         case REG_SZ:
         case REG_EXPAND_SZ:
+                if (data.data[0] != '\0') {
+                        convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8,
+                                                   (void *)data.data,
+                                                   data.length,
+                                                   (void **)&val.data, &val.length, false);
+                        ldb_msg_add_value(msg, "data", &val, NULL);
+                if ((data.length > 0) && (data.data != NULL)) {
+                        struct ldb_val *val;
+                        bool ret2 = false;
+                        val = talloc_zero(msg, struct ldb_val);
+                        if (val == NULL) {
+                                talloc_free(msg);
+                                return NULL;
+                        }
+                        /* The data is provided as UTF16 string */
+                        ret2 = convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8,
+                                                     (void *)data.data, data.length,
+                                                     (void **)&val->data, &val->length,
+                                                     false);
+                        if (ret2) {
+                                ret = ldb_msg_add_value(msg, "data", val, NULL);
+                        } else {
+                                /* workaround for non-standard data */
+                                ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                        }
                 } else {
                         ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                        ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                }
                 break;
+        case REG_DWORD:
+        case REG_DWORD_BIG_ENDIAN:
+                if ((data.length > 0) && (data.data != NULL)) {
+                        if (data.length == sizeof(uint32_t)) {
+                                char *conv_str;
+                                conv_str = talloc_asprintf(msg, "0x%8.8x",
+                                                           IVAL(data.data, 0));
+                                if (conv_str == NULL) {
+                                        talloc_free(msg);
+                                        return NULL;
+                                }
+                                ret = ldb_msg_add_string(msg, "data", conv_str);
+                        } else {
+                                /* workaround for non-standard data */
+                                talloc_free(msg);
+                                return NULL;
+                        }
+                } else {
+                        ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                }
+                break;
+        case REG_QWORD:
+                if ((data.length > 0) && (data.data != NULL)) {
+                        if (data.length == sizeof(uint64_t)) {
+                                char *conv_str;
+                                conv_str = talloc_asprintf(msg, "0x%16.16llx",
+                                                           (unsigned long long)BVAL(data.data, 0));
+                                if (conv_str == NULL) {
+                                        talloc_free(msg);
+                                        return NULL;
+                                }
+                                ret = ldb_msg_add_string(msg, "data", conv_str);
+                        } else {
+                                /* workaround for non-standard data */
+                                talloc_free(msg);
+                                return NULL;
+                        }
+                } else {
+                        ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                }
+                break;
         case REG_BINARY:
+                if (data.length > 0)
+                        ldb_msg_add_value(msg, "data", &data, NULL);
+                else
+                        ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+        default:
+                if ((data.length > 0) && (data.data != NULL)) {
+                        ret = ldb_msg_add_value(msg, "data", &data, NULL);
+                } else {
+                        ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                }
                 break;
+        case REG_DWORD:
+                ldb_msg_add_string(msg, "data",
+                                   talloc_asprintf(mem_ctx, "0x%x",
+                                                   IVAL(data.data, 0)));
+                break;
+        default:
+                ldb_msg_add_value(msg, "data", &data, NULL);
+        }
+        type_s = talloc_asprintf(mem_ctx, "%u", type);
+        ldb_msg_add_string(msg, "type", type_s);
+        }
+        if (ret != LDB_SUCCESS) {
+                talloc_free(msg);
+                return NULL;
+        }
+        type_str = talloc_asprintf(mem_ctx, "%u", type);
+        if (type_str == NULL) {
+                talloc_free(msg);
+                return NULL;
+        }
+        ret = ldb_msg_add_string(msg, "type", type_str);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(msg);
+                return NULL;
+        }
         return msg;
 …
                                       const char *path, const char *add)
+{
-        TALLOC_CTX *local_ctx;
         struct ldb_dn *ret;
         char *mypath = talloc_strdup(mem_ctx, path);
+        char *mypath;
         char *begin;
         struct ldb_key_data *kd = talloc_get_type(from, struct ldb_key_data);
         struct ldb_context *ldb = kd->ldb;
+        local_ctx = talloc_new(mem_ctx);
+        if (add) {
+                ret = ldb_dn_new(mem_ctx, ldb, add);
+        } else {
+                ret = ldb_dn_new(mem_ctx, ldb, NULL);
+        }
+        mypath = talloc_strdup(mem_ctx, path);
+        if (mypath == NULL) {
+                return NULL;
+        }
+        ret = ldb_dn_new(mem_ctx, ldb, add);
         if (!ldb_dn_validate(ret)) {
                 talloc_free(ret);
-                talloc_free(local_ctx);
                 return NULL;
+        }
+        while (mypath) {
+                char *keyname;
+                begin = strrchr(mypath, '\\');
+                if (begin) keyname = begin + 1;
+                else keyname = mypath;
+                if(strlen(keyname)) {
+                        if (!ldb_dn_add_base_fmt(ret, "key=%s",
+                                                 reg_ldb_escape(local_ctx,
+                                                                keyname)))
+                        {
+                                talloc_free(local_ctx);
+                                return NULL;
+                        }
+                }
+                if(begin) {
+        if (!ldb_dn_add_base(ret, kd->dn)) {
+                talloc_free(ret);
+                return NULL;
+        }
+        while (mypath[0] != '\0') {
+                begin = strchr(mypath, '\\');
+                if (begin != NULL) {
                         *begin = '\0';
+                }
+                if (!ldb_dn_add_child_fmt(ret, "key=%s",
+                                          reg_ldb_escape(mem_ctx, mypath))) {
+                        talloc_free(ret);
+                        return NULL;
+                }
+                if (begin != NULL) {
+                        mypath = begin + 1;
                 } else {
                         break;
+                }
+        }
-        ldb_dn_add_base(ret, kd->dn);
-        talloc_free(local_ctx);
         return ret;
 …
         int ret;
         ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL, NULL, "(key=*)");
+        ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL,
+                         NULL, "(key=*)");
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("Error getting subkeys for '%s': %s\n",
 …
         ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL,
                          NULL, "(value=*)");
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("Error getting values for '%s': %s\n",
 …
                                    NTTIME *last_mod_time)
+{
-        struct ldb_message_element *el;
         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
         /* Initialization */
         if (name != NULL)
                 *name = NULL;
         if (classname != NULL)
                 *classname = NULL; /* TODO: Store properly */
+                *classname = NULL;
         if (last_mod_time != NULL)
                 *last_mod_time = 0; /* TODO: we need to add this to the
 …
                 return WERR_NO_MORE_ITEMS;
-        el = ldb_msg_find_element(kd->subkeys[idx], "key");
-        SMB_ASSERT(el != NULL);
-        SMB_ASSERT(el->num_values != 0);
         if (name != NULL)
+                *name = talloc_strdup(mem_ctx, (char *)el->values[0].data);
+        return WERR_OK;
+}
+static WERROR ldb_get_default_value(TALLOC_CTX *mem_ctx, struct hive_key *k,
+                                  const char **name, uint32_t *data_type,
+                                   DATA_BLOB *data)
+                *name = talloc_strdup(mem_ctx,
+                                      ldb_msg_find_attr_as_string(kd->subkeys[idx], "key", NULL));
+        if (classname != NULL)
+                *classname = talloc_strdup(mem_ctx,
+                                           ldb_msg_find_attr_as_string(kd->subkeys[idx], "classname", NULL));
+        return WERR_OK;
+}
+static WERROR ldb_get_default_value(TALLOC_CTX *mem_ctx,
+                                    const struct hive_key *k,
+                                    const char **name, uint32_t *data_type,
+                                    DATA_BLOB *data)
+{
         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
 …
         int ret;
         ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_BASE, attrs, "%s", "");
+        ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_BASE, attrs, "(dn=*)");
         if (ret != LDB_SUCCESS) {
 …
+        }
+        if (res->count == 0 || res->msgs[0]->num_elements == 0)
+        if (res->count == 0 || res->msgs[0]->num_elements == 0) {
+                talloc_free(res);
                 return WERR_BADFILE;
+        reg_ldb_unpack_value(mem_ctx,
+                 res->msgs[0], name, data_type, data);
+        }
+        if ((data_type != NULL) && (data != NULL)) {
+                reg_ldb_unpack_value(mem_ctx, res->msgs[0], name, data_type,
+                                     data);
+        }
         talloc_free(res);
 …
 static WERROR ldb_get_value_by_id(TALLOC_CTX *mem_ctx, struct hive_key *k,
                                   int idx, const char **name,
+                                  uint32_t idx, const char **name,
                                   uint32_t *data_type, DATA_BLOB *data)
+{
         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
         /* if default value exists, give it back */
+        /* if the default value exists, give it back */
         if (W_ERROR_IS_OK(ldb_get_default_value(mem_ctx, k, name, data_type,
                 data))) {
 …
+{
         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
+        struct ldb_context *c = kd->ldb;
+        struct ldb_result *res;
+        int ret;
+        char *query;
+        if (strlen(name) == 0) {
+                /* default value */
+        const char *res_name;
+        uint32_t idx;
+        /* the default value was requested, give it back */
+        if (name[0] == '\0') {
                 return ldb_get_default_value(mem_ctx, k, NULL, data_type, data);
+        } else {
+                /* normal value */
+                query = talloc_asprintf(mem_ctx, "(value=%s)", name);
+                ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_ONELEVEL, NULL, "%s", query);
+                talloc_free(query);
+                if (ret != LDB_SUCCESS) {
+                        DEBUG(0, ("Error getting values for '%s': %s\n",
+                                ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
+                        return WERR_FOOBAR;
+                }
+                if (res->count == 0)
+                        return WERR_BADFILE;
+                reg_ldb_unpack_value(mem_ctx, res->msgs[0], NULL, data_type, data);
+                talloc_free(res);
+        }
+        return WERR_OK;
+        }
+        /* Do the search if necessary */
+        if (kd->values == NULL) {
+                W_ERROR_NOT_OK_RETURN(cache_values(kd));
+        }
+        for (idx = 0; idx < kd->value_count; idx++) {
+                res_name = ldb_msg_find_attr_as_string(kd->values[idx], "value",
+                                                       "");
+                if (ldb_attr_cmp(name, res_name) == 0) {
+                        reg_ldb_unpack_value(mem_ctx, kd->values[idx], NULL,
+                                             data_type, data);
+                        return WERR_OK;
+                }
+        }
+        return WERR_BADFILE;
+}
 …
+{
         struct ldb_result *res;
         struct ldb_dn *ldap_path;
+        struct ldb_dn *ldb_path;
         int ret;
         struct ldb_key_data *newkd;
 …
         struct ldb_context *c = kd->ldb;
+        ldap_path = reg_path_to_ldb(mem_ctx, h, name, NULL);
+        ret = ldb_search(c, mem_ctx, &res, ldap_path, LDB_SCOPE_BASE, NULL, "(key=*)");
+        ldb_path = reg_path_to_ldb(mem_ctx, h, name, NULL);
+        W_ERROR_HAVE_NO_MEMORY(ldb_path);
+        ret = ldb_search(c, mem_ctx, &res, ldb_path, LDB_SCOPE_BASE, NULL, "(key=*)");
         if (ret != LDB_SUCCESS) {
                 DEBUG(3, ("Error opening key '%s': %s\n",
                         ldb_dn_get_linearized(ldap_path), ldb_errstring(c)));
+                        ldb_dn_get_linearized(ldb_path), ldb_errstring(c)));
                 return WERR_FOOBAR;
         } else if (res->count == 0) {
                 DEBUG(3, ("Key '%s' not found\n",
                         ldb_dn_get_linearized(ldap_path)));
+                        ldb_dn_get_linearized(ldb_path)));
                 talloc_free(res);
                 return WERR_BADFILE;
 …
         newkd = talloc_zero(mem_ctx, struct ldb_key_data);
+        W_ERROR_HAVE_NO_MEMORY(newkd);
         newkd->key.ops = &reg_backend_ldb;
         newkd->ldb = talloc_reference(newkd, kd->ldb);
+        newkd->dn = ldb_dn_copy(mem_ctx, res->msgs[0]->dn);
+        newkd->dn = ldb_dn_copy(newkd, res->msgs[0]->dn);
+        newkd->classname = talloc_steal(newkd,
+                                        ldb_msg_find_attr_as_string(res->msgs[0], "classname", NULL));
+        talloc_free(res);
         *key = (struct hive_key *)newkd;
 …
         wrap = ldb_wrap_connect(parent_ctx, ev_ctx, lp_ctx,
                                 location, session_info, credentials, 0, NULL);
+                                location, session_info, credentials, 0);
         if (wrap == NULL) {
 …
+{
         struct ldb_key_data *parentkd = discard_const_p(struct ldb_key_data, parent);
+        struct ldb_dn *ldb_path;
         struct ldb_message *msg;
         struct ldb_key_data *newkd;
         int ret;
+        ldb_path = reg_path_to_ldb(mem_ctx, parent, name, NULL);
+        W_ERROR_HAVE_NO_MEMORY(ldb_path);
         msg = ldb_msg_new(mem_ctx);
+        msg->dn = reg_path_to_ldb(msg, parent, name, NULL);
+        ldb_msg_add_string(msg, "key", talloc_strdup(mem_ctx, name));
+        if (classname != NULL)
+                ldb_msg_add_string(msg, "classname",
+                                   talloc_strdup(mem_ctx, classname));
+        W_ERROR_HAVE_NO_MEMORY(msg);
+        msg->dn = ldb_path;
+        ldb_msg_add_string(msg, "key", name);
+        if (classname != NULL) {
+                ldb_msg_add_string(msg, "classname", classname);
+        }
         ret = ldb_add(parentkd->ldb, msg);
+        talloc_free(msg);
         if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
                 return WERR_ALREADY_EXISTS;
 …
+        }
         DEBUG(2, ("key added: %s\n", ldb_dn_get_linearized(msg->dn)));
+        DEBUG(2, ("key added: %s\n", ldb_dn_get_linearized(ldb_path)));
         newkd = talloc_zero(mem_ctx, struct ldb_key_data);
+        W_ERROR_HAVE_NO_MEMORY(newkd);
         newkd->ldb = talloc_reference(newkd, parentkd->ldb);
         newkd->key.ops = &reg_backend_ldb;
+        newkd->dn = talloc_steal(newkd, msg->dn);
+        newkd->dn = talloc_steal(newkd, ldb_path);
+        newkd->classname = talloc_steal(newkd, classname);
         *newkey = (struct hive_key *)newkd;
 …
+}
+static WERROR ldb_del_value (struct hive_key *key, const char *child)
+static WERROR ldb_del_value(TALLOC_CTX *mem_ctx, struct hive_key *key,
+                            const char *child)
+{
         int ret;
         struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data);
-        TALLOC_CTX *mem_ctx;
         struct ldb_message *msg;
         struct ldb_dn *childdn;
         if (strlen(child) == 0) {
+        if (child[0] == '\0') {
                 /* default value */
-                mem_ctx = talloc_init("ldb_del_value");
                 msg = talloc_zero(mem_ctx, struct ldb_message);
+                W_ERROR_HAVE_NO_MEMORY(msg);
                 msg->dn = ldb_dn_copy(msg, kd->dn);
+                W_ERROR_HAVE_NO_MEMORY(msg->dn);
                 ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
                 ldb_msg_add_empty(msg, "type", LDB_FLAG_MOD_DELETE, NULL);
                 ret = ldb_modify(kd->ldb, msg);
+                talloc_free(msg);
                 if (ret != LDB_SUCCESS) {
                         DEBUG(1, ("ldb_del_value: %s\n", ldb_errstring(kd->ldb)));
-                        talloc_free(mem_ctx);
                         return WERR_FOOBAR;
+                }
-                talloc_free(mem_ctx);
         } else {
                 /* normal value */
 …
+}
+static WERROR ldb_del_key(const struct hive_key *key, const char *name)
+{
+        int i, ret;
+static WERROR ldb_del_key(TALLOC_CTX *mem_ctx, const struct hive_key *key,
+                          const char *name)
+{
+        unsigned int i;
+        int ret;
         struct ldb_key_data *parentkd = talloc_get_type(key, struct ldb_key_data);
+        struct ldb_dn *ldap_path;
+        TALLOC_CTX *mem_ctx = talloc_init("ldb_del_key");
+        struct ldb_dn *ldb_path;
         struct ldb_context *c = parentkd->ldb;
         struct ldb_result *res_keys;
 …
         werr = ldb_open_key(mem_ctx, key, name, &hk);
         if (!W_ERROR_IS_OK(werr)) {
-                talloc_free(mem_ctx);
                 return werr;
+        }
+        ldap_path = reg_path_to_ldb(mem_ctx, key, name, NULL);
+        if (!ldap_path) {
+                talloc_free(mem_ctx);
+                return WERR_FOOBAR;
+        }
+        ldb_path = reg_path_to_ldb(mem_ctx, key, name, NULL);
+        W_ERROR_HAVE_NO_MEMORY(ldb_path);
         /* Search for subkeys */
         ret = ldb_search(c, mem_ctx, &res_keys, ldap_path, LDB_SCOPE_ONELEVEL,
+        ret = ldb_search(c, mem_ctx, &res_keys, ldb_path, LDB_SCOPE_ONELEVEL,
                          NULL, "(key=*)");
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("Error getting subkeys for '%s': %s\n",
+                      ldb_dn_get_linearized(ldap_path), ldb_errstring(c)));
+                talloc_free(mem_ctx);
+                      ldb_dn_get_linearized(ldb_path), ldb_errstring(c)));
                 return WERR_FOOBAR;
+        }
         /* Search for values */
         ret = ldb_search(c, mem_ctx, &res_vals, ldap_path, LDB_SCOPE_ONELEVEL,
+        ret = ldb_search(c, mem_ctx, &res_vals, ldb_path, LDB_SCOPE_ONELEVEL,
                          NULL, "(value=*)");
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("Error getting values for '%s': %s\n",
+                      ldb_dn_get_linearized(ldap_path), ldb_errstring(c)));
+                talloc_free(mem_ctx);
+                      ldb_dn_get_linearized(ldb_path), ldb_errstring(c)));
                 return WERR_FOOBAR;
+        }
 …
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("ldb_transaction_start: %s\n", ldb_errstring(c)));
-                talloc_free(mem_ctx);
                 return WERR_FOOBAR;
+        }
 …
                 for (i = 0; i < res_keys->count; i++)
+                {
+                        werr = ldb_del_key(hk, ldb_msg_find_attr_as_string(
+                        werr = ldb_del_key(mem_ctx, hk,
+                                           ldb_msg_find_attr_as_string(
                                                         res_keys->msgs[i],
                                                         "key", NULL));
                         if (!W_ERROR_IS_OK(werr)) {
                                 ret = ldb_transaction_cancel(c);
-                                talloc_free(mem_ctx);
                                 return werr;
+                        }
 …
                 for (i = 0; i < res_vals->count; i++)
+                {
+                        werr = ldb_del_value(hk, ldb_msg_find_attr_as_string(
+                        werr = ldb_del_value(mem_ctx, hk,
+                                             ldb_msg_find_attr_as_string(
                                                         res_vals->msgs[i],
                                                         "value", NULL));
                         if (!W_ERROR_IS_OK(werr)) {
                                 ret = ldb_transaction_cancel(c);
-                                talloc_free(mem_ctx);
                                 return werr;
+                        }
+                }
+        }
+        talloc_free(res_keys);
+        talloc_free(res_vals);
         /* Delete the key itself */
         ret = ldb_delete(c, ldap_path);
+        ret = ldb_delete(c, ldb_path);
         if (ret != LDB_SUCCESS)
 …
                 DEBUG(1, ("ldb_del_key: %s\n", ldb_errstring(c)));
                 ret = ldb_transaction_cancel(c);
-                talloc_free(mem_ctx);
                 return WERR_FOOBAR;
+        }
 …
                 DEBUG(0, ("ldb_transaction_commit: %s\n", ldb_errstring(c)));
                 ret = ldb_transaction_cancel(c);
+                talloc_free(mem_ctx);
+                return WERR_FOOBAR;
+        }
+        talloc_free(mem_ctx);
+                return WERR_FOOBAR;
+        }
         /* reset cache */
 …
         struct ldb_message *msg;
         struct ldb_key_data *kd = talloc_get_type(parent, struct ldb_key_data);
+        unsigned int i;
         int ret;
         TALLOC_CTX *mem_ctx = talloc_init("ldb_set_value");
         msg = reg_ldb_pack_value(kd->ldb, mem_ctx, name, type, data);
+        W_ERROR_HAVE_NO_MEMORY(msg);
         msg->dn = ldb_dn_copy(msg, kd->dn);
+        if (strlen(name) > 0) {
+        W_ERROR_HAVE_NO_MEMORY(msg->dn);
+        if (name[0] != '\0') {
                 /* For a default value, we add/overwrite the attributes to/of the hive.
                    For a normal value, we create new childs. */
+                   For a normal value, we create a new child. */
                 if (!ldb_dn_add_child_fmt(msg->dn, "value=%s",
                                   reg_ldb_escape(mem_ctx, name)))
 …
+        }
+        ret = ldb_add(kd->ldb, msg);
+        if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+                int i;
+                for (i = 0; i < msg->num_elements; i++) {
+                        if (msg->elements[i].flags != LDB_FLAG_MOD_DELETE)
+                                msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
+                }
+                ret = ldb_modify(kd->ldb, msg);
+        }
+        /* Try first a "modify" and if this doesn't work do try an "add" */
+        for (i = 0; i < msg->num_elements; i++) {
+                if (msg->elements[i].flags != LDB_FLAG_MOD_DELETE) {
+                        msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
+                }
+        }
+        ret = ldb_modify(kd->ldb, msg);
+        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                i = 0;
+                while (i < msg->num_elements) {
+                        if (LDB_FLAG_MOD_TYPE(msg->elements[i].flags) == LDB_FLAG_MOD_DELETE) {
+                                ldb_msg_remove_element(msg, &msg->elements[i]);
+                        } else {
+                                ++i;
+                        }
+                }
+                ret = ldb_add(kd->ldb, msg);
+        }
+        if (ret == LDB_ERR_NO_SUCH_ATTRIBUTE) {
+                /* ignore this -> the value didn't exist and also now doesn't */
+                ret = LDB_SUCCESS;
+        }
+        talloc_free(msg);
         if (ret != LDB_SUCCESS) {
 …
+{
         struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data);
+        uint32_t default_value_type = REG_NONE;
+        DATA_BLOB default_value = { NULL, 0 };
+        WERROR werr;
         /* Initialization */
 …
                 *max_valbufsize = 0;
+        /* We need this to get the default value (if it exists) for counting
+         * the values under the key and for finding out the longest value buffer
+         * size. If no default value exists the DATA_BLOB "default_value" will
+         * remain { NULL, 0 }. */
+        werr = ldb_get_default_value(mem_ctx, key, NULL, &default_value_type,
+                                     &default_value);
+        if ((!W_ERROR_IS_OK(werr)) && (!W_ERROR_EQUAL(werr, WERR_BADFILE))) {
+                return werr;
+        }
         if (kd->subkeys == NULL) {
                 W_ERROR_NOT_OK_RETURN(cache_subkeys(kd));
+        }
         if (kd->values == NULL) {
                 W_ERROR_NOT_OK_RETURN(cache_values(kd));
+        }
+        if (classname != NULL) {
+                *classname = kd->classname;
+        }
         if (num_subkeys != NULL) {
                 *num_subkeys = kd->subkey_count;
 …
         if (num_values != NULL) {
                 *num_values = kd->value_count;
+                /* also consider the default value if it exists */
+                if (default_value.data != NULL) {
+                        ++(*num_values);
+                }
+        }
         if (max_subkeynamelen != NULL) {
                 int i;
+                unsigned int i;
                 struct ldb_message_element *el;
-                *max_subkeynamelen = 0;
                 for (i = 0; i < kd->subkey_count; i++) {
 …
         if (max_valnamelen != NULL || max_valbufsize != NULL) {
                 int i;
+                unsigned int i;
                 struct ldb_message_element *el;
                 W_ERROR_NOT_OK_RETURN(cache_values(kd));
                 if (max_valbufsize != NULL)
                         *max_valbufsize = 0;
                 if (max_valnamelen != NULL)
                         *max_valnamelen = 0;
+                /* also consider the default value if it exists */
+                if ((max_valbufsize != NULL) && (default_value.data != NULL)) {
+                                *max_valbufsize = MAX(*max_valbufsize,
+                                                      default_value.length);
+                }
                 for (i = 0; i < kd->value_count; i++) {
 …
                                 uint32_t data_type;
                                 DATA_BLOB data;
                                 reg_ldb_unpack_value(mem_ctx,
                                                      kd->values[i], NULL,
+                                reg_ldb_unpack_value(mem_ctx,
+                                                     kd->values[i], NULL,
                                                      &data_type, &data);
                                 *max_valbufsize = MAX(*max_valbufsize, data.length);
 …
+                }
+        }
+        talloc_free(default_value.data);
         return WERR_OK;

trunk/server/source4/lib/registry/local.c

-              r414
+              r745
         local_key = talloc(ctx, struct local_key);
+        local_key->hive_key = talloc_steal(local_key, hive);
+        local_key->global.context = talloc_reference(local_key, ctx);
+        local_key->path = parent_path;
+        if (local_key != NULL) {
+                local_key->hive_key = talloc_reference(local_key, hive);
+                local_key->global.context = talloc_reference(local_key, ctx);
+                local_key->path = parent_path;
+        }
         return (struct registry_key *)local_key;
 …
                              struct registry_key **result)
+{
+        char *orig = talloc_strdup(mem_ctx, path),
+                 *curbegin = orig,
+                 *curend = strchr(orig, '\\');
+        char *orig, *curbegin, *curend;
         struct local_key *local_parent = talloc_get_type(parent,
                                                          struct local_key);
 …
         int el;
+        if (path == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        orig = talloc_strdup(mem_ctx, path);
+        W_ERROR_HAVE_NO_MEMORY(orig);
+        curbegin = orig;
+        curend = strchr(orig, '\\');
         if (local_parent->path.elements != NULL) {
                 elements = talloc_array(mem_ctx, const char *,
                                         str_list_length(local_parent->path.elements) + 1);
+                W_ERROR_HAVE_NO_MEMORY(elements);
                 for (el = 0; local_parent->path.elements[el] != NULL; el++) {
                         elements[el] = talloc_reference(elements,
 …
                         *curend = '\0';
                 elements = talloc_realloc(mem_ctx, elements, const char *, el+2);
+                W_ERROR_HAVE_NO_MEMORY(elements);
                 elements[el] = talloc_strdup(elements, curbegin);
+                W_ERROR_HAVE_NO_MEMORY(elements[el]);
                 el++;
                 elements[el] = NULL;
 …
 static WERROR local_create_key(TALLOC_CTX *mem_ctx,
                                struct registry_key *parent_key,
                                const char *name,
+                               struct registry_key *parent,
+                               const char *path,
                                const char *key_class,
                                struct security_descriptor *security,
+                               struct registry_key **key)
+{
+        struct local_key *local_parent;
+        struct hive_key *hivekey;
+        const char **elements;
+        int i;
+        const char *last_part;
+        last_part = strrchr(name, '\\');
+        if (last_part == NULL) {
+                last_part = name;
+                local_parent = (struct local_key *)parent_key;
+                               struct registry_key **result)
+{
+        char *orig, *curbegin, *curend;
+        struct local_key *local_parent = talloc_get_type(parent,
+                                                         struct local_key);
+        struct hive_key *curkey = local_parent->hive_key;
+        WERROR error;
+        const char **elements = NULL;
+        int el;
+        if (path == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        orig = talloc_strdup(mem_ctx, path);
+        W_ERROR_HAVE_NO_MEMORY(orig);
+        curbegin = orig;
+        curend = strchr(orig, '\\');
+        if (local_parent->path.elements != NULL) {
+                elements = talloc_array(mem_ctx, const char *,
+                                        str_list_length(local_parent->path.elements) + 1);
+                W_ERROR_HAVE_NO_MEMORY(elements);
+                for (el = 0; local_parent->path.elements[el] != NULL; el++) {
+                        elements[el] = talloc_reference(elements,
+                                                        local_parent->path.elements[el]);
+                }
+                elements[el] = NULL;
         } else {
+                W_ERROR_NOT_OK_RETURN(reg_open_key(mem_ctx, parent_key,
+                                                   talloc_strndup(mem_ctx, name, last_part-name),
+                                                   (struct registry_key **)&local_parent));
+                last_part++;
+        }
+        W_ERROR_NOT_OK_RETURN(hive_key_add_name(mem_ctx, local_parent->hive_key,
+                                                last_part, key_class, security,
+                                                &hivekey));
+        if (local_parent->path.elements != NULL) {
+                elements = talloc_array(hivekey, const char *,
+                                        str_list_length(local_parent->path.elements)+2);
+                for (i = 0; local_parent->path.elements[i] != NULL; i++) {
+                        elements[i] = talloc_reference(elements,
+                                                       local_parent->path.elements[i]);
+                }
+        } else {
+                elements = talloc_array(hivekey, const char *, 2);
+                i = 0;
+        }
+        elements[i] = talloc_strdup(elements, name);
+        elements[i+1] = NULL;
+        *key = reg_import_hive_key(local_parent->global.context, hivekey,
+                                   local_parent->path.predefined_key,
+                                   elements);
+                elements = NULL;
+                el = 0;
+        }
+        while (curbegin != NULL && *curbegin) {
+                if (curend != NULL)
+                        *curend = '\0';
+                elements = talloc_realloc(mem_ctx, elements, const char *, el+2);
+                W_ERROR_HAVE_NO_MEMORY(elements);
+                elements[el] = talloc_strdup(elements, curbegin);
+                W_ERROR_HAVE_NO_MEMORY(elements[el]);
+                el++;
+                elements[el] = NULL;
+                error = hive_get_key_by_name(mem_ctx, curkey,
+                                             curbegin, &curkey);
+                if (W_ERROR_EQUAL(error, WERR_BADFILE)) {
+                        error = hive_key_add_name(mem_ctx, curkey, curbegin,
+                                                  key_class, security,
+                                                  &curkey);
+                }
+                if (!W_ERROR_IS_OK(error)) {
+                        DEBUG(2, ("Open/Creation of key %s failed: %s\n",
+                                curbegin, win_errstr(error)));
+                        talloc_free(orig);
+                        return error;
+                }
+                if (curend == NULL)
+                        break;
+                curbegin = curend + 1;
+                curend = strchr(curbegin, '\\');
+        }
+        talloc_free(orig);
+        *result = reg_import_hive_key(local_parent->global.context, curkey,
+                                      local_parent->path.predefined_key,
+                                      talloc_steal(curkey, elements));
         return WERR_OK;
 …
+{
         struct local_key *local = (struct local_key *)key;
+        if (name == NULL) {
+                return WERR_INVALID_PARAM;
+        }
         return hive_key_set_value(local->hive_key, name, type, data);
 …
+{
         const struct local_key *local = (const struct local_key *)key;
+        if (name == NULL) {
+                return WERR_INVALID_PARAM;
+        }
         return hive_get_value(mem_ctx, local->hive_key, name, type, data);
 …
+}
+static WERROR local_delete_key(struct registry_key *key, const char *name)
+{
+        const struct local_key *local = (const struct local_key *)key;
+        return hive_key_del(local->hive_key, name);
+}
+static WERROR local_delete_value(struct registry_key *key, const char *name)
+{
+        const struct local_key *local = (const struct local_key *)key;
+        return hive_key_del_value(local->hive_key, name);
+static WERROR local_delete_key(TALLOC_CTX *mem_ctx, struct registry_key *key,
+                               const char *name)
+{
+        const struct local_key *local = (const struct local_key *)key;
+        if (name == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        return hive_key_del(mem_ctx, local->hive_key, name);
+}
+static WERROR local_delete_value(TALLOC_CTX *mem_ctx, struct registry_key *key,
+                                 const char *name)
+{
+        const struct local_key *local = (const struct local_key *)key;
+        if (name == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        return hive_key_del_value(mem_ctx, local->hive_key, name);
+}
 …
         struct registry_local *reg_local = talloc_get_type(rctx,
                                                            struct registry_local);
+        struct mountpoint *mp = talloc(rctx, struct mountpoint);
+        int i = 0;
+        struct mountpoint *mp;
+        unsigned int i = 0;
+        mp = talloc(rctx, struct mountpoint);
+        W_ERROR_HAVE_NO_MEMORY(mp);
         mp->path.predefined_key = key_id;
         mp->prev = mp->next = NULL;
 …
                 mp->path.elements = talloc_array(mp, const char *,
                                                  str_list_length(elements));
+                W_ERROR_HAVE_NO_MEMORY(mp->path.elements);
                 for (i = 0; elements[i] != NULL; i++) {
                         mp->path.elements[i] = talloc_reference(mp->path.elements,

trunk/server/source4/lib/registry/man/regdiff.1.xml

r414	r745
1	1	<?xml version="1.0" encoding="iso-8859-1"?>
2		<!DOCTYPE refentry PUBLIC "-//~~Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc~~">
	2	<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
3	3	<refentry id="regdiff.1">
4	4

trunk/server/source4/lib/registry/man/regpatch.1.xml

r414	r745
1	1	<?xml version="1.0" encoding="iso-8859-1"?>
2		<!DOCTYPE refentry PUBLIC "-//~~Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc~~">
	2	<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
3	3	<refentry id="regpatch.1">
4	4

trunk/server/source4/lib/registry/man/regshell.1.xml

r414	r745
1	1	<?xml version="1.0" encoding="iso-8859-1"?>
2		<!DOCTYPE refentry PUBLIC "-//~~Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc~~">
	2	<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
3	3	<refentry id="regshell.1">
4	4

trunk/server/source4/lib/registry/man/regtree.1.xml

r414	r745
1	1	<?xml version="1.0" encoding="iso-8859-1"?>
2		<!DOCTYPE refentry PUBLIC "-//~~Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc~~">
	2	<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
3	3	<refentry id="regtree.1">
4	4

trunk/server/source4/lib/registry/patchfile.c

-              r414
+              r745
    Copyright (C) Jelmer Vernooij 2004-2007
    Copyright (C) Wilco Baan Hofman 2006
    Copyright (C) Matthias Dieter WallnÃ¶fer 2008
+   Copyright (C) Matthias Dieter WallnÃ¶fer 2008-2010
    This program is free software; you can redistribute it and/or modify
 …
 _PUBLIC_ WERROR reg_preg_diff_load(int fd,
-                                   struct smb_iconv_convenience *iconv_convenience,
                                    const struct reg_diff_callbacks *callbacks,
                                    void *callback_data);
 _PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
-                                     struct smb_iconv_convenience *iconv_convenience,
                                      const struct reg_diff_callbacks *callbacks,
                                      void *callback_data);
 …
                              void *callback_data)
+{
         int i;
+        unsigned int i;
         struct registry_key *t1 = NULL, *t2 = NULL;
         char *tmppath;
 …
                 if (!W_ERROR_IS_OK(error2) && !W_ERROR_EQUAL(error2, WERR_BADFILE)) {
                         DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+                        DEBUG(0, ("Error occurred while getting subkey by name: %s\n",
                                 win_errstr(error2)));
                         talloc_free(mem_ctx);
 …
                 /* didn't have such a subkey and therefore add a del diff */
                 tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
+                if (tmppath == NULL) {
+                        DEBUG(0, ("Out of memory\n"));
+                        talloc_free(mem_ctx);
+                        return WERR_NOMEM;
+                }
                 if (!W_ERROR_IS_OK(error2))
                         callbacks->del_key(callback_data, tmppath);
 …
                 error1 = reg_open_key(mem_ctx, oldkey, keyname1, &t1);
                 if (!W_ERROR_IS_OK(error1)) {
                         DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+                        DEBUG(0, ("Error occurred while getting subkey by name: %s\n",
                         win_errstr(error1)));
                         talloc_free(mem_ctx);
 …
+                }
                 /* oldkey didn't have such a subkey, add add diff */
+                /* oldkey didn't have such a subkey, add a add diff */
                 tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
+                if (tmppath == NULL) {
+                        DEBUG(0, ("Out of memory\n"));
+                        talloc_free(mem_ctx);
+                        return WERR_NOMEM;
+                }
                 callbacks->add_key(callback_data, tmppath);
 …
                 error1 = reg_open_key(mem_ctx, newkey, keyname1, &t2);
                 if (!W_ERROR_IS_OK(error1)) {
                         DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+                        DEBUG(0, ("Error occurred while getting subkey by name: %s\n",
                         win_errstr(error1)));
                         talloc_free(mem_ctx);
 …
                 const char *name;
                 uint32_t type1, type2;
                 DATA_BLOB contents1, contents2;
+                DATA_BLOB contents1 = { NULL, 0 }, contents2 = { NULL, 0 };
                 error1 = reg_key_get_value_by_index(mem_ctx, newkey, i,
 …
                 if (W_ERROR_IS_OK(error2)
+                        && (data_blob_cmp(&contents1, &contents2) == 0)
+                        && (type1 == type2))
+                    && (data_blob_cmp(&contents1, &contents2) == 0)
+                    && (type1 == type2)) {
+                        talloc_free(discard_const_p(char, name));
+                        talloc_free(contents1.data);
+                        talloc_free(contents2.data);
                         continue;
+                }
                 callbacks->set_value(callback_data, path, name,
                                      type1, contents1);
+                talloc_free(discard_const_p(char, name));
+                talloc_free(contents1.data);
+                talloc_free(contents2.data);
+        }
 …
                 const char *name;
                 uint32_t type;
                 DATA_BLOB contents;
+                DATA_BLOB contents = { NULL, 0 };
                 error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &name,
 …
                         error2 = WERR_BADFILE;
+                if (W_ERROR_IS_OK(error2))
+                if (W_ERROR_IS_OK(error2)) {
+                        talloc_free(discard_const_p(char, name));
+                        talloc_free(contents.data);
                         continue;
+                }
                 if (!W_ERROR_EQUAL(error2, WERR_BADFILE)) {
 …
                 callbacks->del_value(callback_data, path, name);
+                talloc_free(discard_const_p(char, name));
+                talloc_free(contents.data);
+        }
 …
                                   void *callback_data)
+{
         int i;
+        unsigned int i;
         WERROR error;
 …
+                }
+                /* if "r1" is NULL (old hive) and "r2" isn't (new hive) then
+                 * the hive doesn't exist yet and we have to generate an add
+                 * diff */
+                if ((r1 == NULL) && (r2 != NULL)) {
+                        callbacks->add_key(callback_data,
+                                           reg_predefined_keys[i].name);
+                }
+                /* if "r1" isn't NULL (old hive) and "r2" is (new hive) then
+                 * the hive shouldn't exist anymore and we have to generate a
+                 * del diff */
+                if ((r1 != NULL) && (r2 == NULL)) {
+                        callbacks->del_key(callback_data,
+                                           reg_predefined_keys[i].name);
+                }
                 error = reg_generate_diff_key(r1, r2,
                         reg_predefined_keys[i].name, callbacks,
 …
  */
 _PUBLIC_ WERROR reg_diff_load(const char *filename,
-                              struct smb_iconv_convenience *iconv_convenience,
                               const struct reg_diff_callbacks *callbacks,
                               void *callback_data)
 …
         if (strncmp(hdr, "PReg", 4) == 0) {
                 /* Must be a GPO Registry.pol file */
                 return reg_preg_diff_load(fd, iconv_convenience, callbacks, callback_data);
+                return reg_preg_diff_load(fd, callbacks, callback_data);
         } else {
                 /* Must be a normal .REG file */
                 return reg_dotreg_diff_load(fd, iconv_convenience, callbacks, callback_data);
+                return reg_dotreg_diff_load(fd, callbacks, callback_data);
+        }
+}
 …
         /* Recursively create the path */
         buf = talloc_strdup(ctx, key_name);
+        W_ERROR_HAVE_NO_MEMORY(buf);
         buf_ptr = buf;
 …
+                        }
                         *buf_ptr++ = '\\';
+                }
+        }
+                        talloc_free(tmp);
+                }
+        }
+        talloc_free(buf);
         /* Add the key */
 …
                 return error;
+        }
+        talloc_free(tmp);
         return WERR_OK;
+}
 …
         /* We can't proof here for success, because a common superkey could */
         /* have been deleted before the subkey's (diff order). This removed */
         /* therefore all childs recursively and the "WERR_BADFILE" result is */
+        /* therefore all children recursively and the "WERR_BADFILE" result is */
         /* expected. */
 …
+        }
+        talloc_free(tmp);
         return WERR_OK;
+}
 …
+        }
         error = reg_del_value(tmp, value_name);
+        error = reg_del_value(ctx, tmp, value_name);
         if (!W_ERROR_IS_OK(error)) {
                 DEBUG(0, ("Error deleting value '%s'\n", value_name));
 …
+        }
+        talloc_free(tmp);
         return WERR_OK;
 …
         struct registry_key *key;
         WERROR error;
         const char* value_name;
+        const char *value_name;
         error = reg_open_key_abs(ctx, ctx, key_name, &key);
 …
         while (W_ERROR_IS_OK(reg_key_get_value_by_index(
                         ctx, key, 0, &value_name, NULL, NULL))) {
                 error = reg_del_value(key, value_name);
+                error = reg_del_value(ctx, key, value_name);
                 if (!W_ERROR_IS_OK(error)) {
                         DEBUG(0, ("Error deleting value '%s'\n", value_name));
                         return error;
+                }
+        }
+                talloc_free(discard_const_p(char, value_name));
+        }
+        talloc_free(key);
         return WERR_OK;
 …
  */
 _PUBLIC_ WERROR reg_diff_apply(struct registry_context *ctx,
-                                                           struct smb_iconv_convenience *iconv_convenience,
                                                            const char *filename)
+{
 …
         callbacks.done = NULL;
+        return reg_diff_load(filename, iconv_convenience,
+                             &callbacks, ctx);
+}
+        return reg_diff_load(filename, &callbacks, ctx);
+}

trunk/server/source4/lib/registry/patchfile_dotreg.c

-              r414
+              r745
    Copyright (C) Jelmer Vernooij 2004-2007
    Copyright (C) Wilco Baan Hofman 2006-2008
+   Copyright (C) Wilco Baan Hofman 2006-2010
    This program is free software; you can redistribute it and/or modify
 …
 */
+/* FIXME Newer .REG files, created by Windows XP and above use unicode UCS-2 */
+/* FIXME:
+ * - Newer .REG files, created by Windows XP and above use unicode UCS-2
+ * - @="" constructions should write value with empty name.
+*/
 #include "includes.h"
 …
 struct dotreg_data {
         int fd;
-        struct smb_iconv_convenience *iconv_convenience;
 };
+/*
+ * This is basically a copy of data_blob_hex_string_upper, but with comma's
+ * between the bytes in hex.
+ */
+static char *dotreg_data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
+{
+        size_t i;
+        char *hex_string;
+        hex_string = talloc_array(mem_ctx, char, (blob->length*3)+1);
+        if (!hex_string) {
+                return NULL;
+        }
+        for (i = 0; i < blob->length; i++)
+                slprintf(&hex_string[i*3], 4, "%02X,", blob->data[i]);
+        /* Remove last comma and NULL-terminate the string */
+        hex_string[(blob->length*3)-1] = '\0';
+        return hex_string;
+}
+/*
+ * This is basically a copy of reg_val_data_string, except that this function
+ * has no 0x for dwords, everything else is regarded as binary, and binary
+ * strings are represented with bytes comma-separated.
+ */
+static char *reg_val_dotreg_string(TALLOC_CTX *mem_ctx, uint32_t type,
+                                   const DATA_BLOB data)
+{
+        char *ret = NULL;
+        if (data.length == 0)
+                return talloc_strdup(mem_ctx, "");
+        switch (type) {
+                case REG_EXPAND_SZ:
+                case REG_SZ:
+                        convert_string_talloc(mem_ctx,
+                                                          CH_UTF16, CH_UNIX, data.data, data.length,
+                                                          (void **)&ret, NULL, false);
+                        break;
+                case REG_DWORD:
+                case REG_DWORD_BIG_ENDIAN:
+                        SMB_ASSERT(data.length == sizeof(uint32_t));
+                        ret = talloc_asprintf(mem_ctx, "%08x",
+                                              IVAL(data.data, 0));
+                        break;
+                default: /* default means treat as binary */
+                case REG_BINARY:
+                        ret = dotreg_data_blob_hex_string(mem_ctx, &data);
+                        break;
+        }
+        return ret;
+}
 static WERROR reg_dotreg_diff_add_key(void *_data, const char *key_name)
 …
+{
         struct dotreg_data *data = (struct dotreg_data *)_data;
+        fdprintf(data->fd, "\"%s\"=%s:%s\n",
+                        value_name, str_regtype(value_type),
+                        reg_val_data_string(NULL, data->iconv_convenience, value_type, value));
+        char *data_string = reg_val_dotreg_string(NULL,
+                                                value_type, value);
+        char *data_incl_type;
+        W_ERROR_HAVE_NO_MEMORY(data_string);
+        switch (value_type) {
+                case REG_SZ:
+                        data_incl_type = talloc_asprintf(data_string, "\"%s\"",
+                                        data_string);
+                        break;
+                case REG_DWORD:
+                        data_incl_type = talloc_asprintf(data_string,
+                                        "dword:%s", data_string);
+                        break;
+                case REG_BINARY:
+                        data_incl_type = talloc_asprintf(data_string, "hex:%s",
+                                        data_string);
+                        break;
+                default:
+                        data_incl_type = talloc_asprintf(data_string, "hex(%x):%s",
+                                        value_type, data_string);
+                        break;
+        }
+        if (value_name[0] == '\0') {
+                fdprintf(data->fd, "@=%s\n", data_incl_type);
+        } else {
+                fdprintf(data->fd, "\"%s\"=%s\n",
+                         value_name, data_incl_type);
+        }
+        talloc_free(data_string);
         return WERR_OK;
 …
  */
 _PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
-                                     struct smb_iconv_convenience *iconv_convenience,
                                      struct reg_diff_callbacks **callbacks,
                                      void **callback_data)
 …
         data = talloc_zero(ctx, struct dotreg_data);
         *callback_data = data;
-        data->iconv_convenience = iconv_convenience;
         if (filename) {
 …
  */
 _PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
-                                     struct smb_iconv_convenience *iconv_convenience,
                                      const struct reg_diff_callbacks *callbacks,
                                      void *callback_data)
 …
         WERROR error;
         uint32_t value_type;
+        DATA_BLOB value;
+        DATA_BLOB data;
+        bool result;
+        char *type_str = NULL;
+        char *data_str;
+        char *value;
+        bool continue_next_line = 0;
         line = afdgets(fd, mem_ctx, 0);
 …
         while ((line = afdgets(fd, mem_ctx, 0))) {
+                /* Remove '\r' if it's a Windows text file */
+                if (line[strlen(line)-1] == '\r') {
+                        line[strlen(line)-1] = '\0';
+                }
                 /* Ignore comments and empty lines */
                 if (strlen(line) == 0 || line[0] == ';') {
 …
                 /* Start of key */
                 if (line[0] == '[') {
+                        p = strchr_m(line, ']');
+                        if (p[strlen(p)-1] != ']') {
+                                DEBUG(0, ("Missing ']'\n"));
+                                return WERR_GENERAL_FAILURE;
+                        }
+                        if (line[strlen(line)-1] != ']') {
+                                DEBUG(0, ("Missing ']' on line: %s\n", line));
+                                talloc_free(line);
+                                continue;
+                        }
                         /* Deleting key */
                         if (line[1] == '-') {
                                 curkey = talloc_strndup(line, line+2, strlen(line)-3);
+                                W_ERROR_HAVE_NO_MEMORY(curkey);
                                 error = callbacks->del_key(callback_data,
                                                            curkey);
                                 if (!W_ERROR_IS_OK(error)) {
                                         DEBUG(0,("Error deleting key %s\n",
 …
+                        }
                         curkey = talloc_strndup(mem_ctx, line+1, strlen(line)-2);
+                        W_ERROR_HAVE_NO_MEMORY(curkey);
                         error = callbacks->add_key(callback_data, curkey);
 …
                 /* Deleting/Changing value */
+                p = strchr_m(line, '=');
+                if (p == NULL) {
+                        DEBUG(0, ("Malformed line\n"));
+                        talloc_free(line);
+                        continue;
+                }
+                *p = '\0'; p++;
+                if (curkey == NULL) {
+                        DEBUG(0, ("Value change without key\n"));
+                        talloc_free(line);
+                        continue;
+                }
+                /* Delete value */
+                if (strcmp(p, "-") == 0) {
+                        error = callbacks->del_value(callback_data,
+                                                     curkey, line);
+                        if (!W_ERROR_IS_OK(error)) {
+                                DEBUG(0, ("Error deleting value %s in key %s\n",
+                                        line, curkey));
+                                talloc_free(mem_ctx);
+                                return error;
+                        }
+                        talloc_free(line);
+                        continue;
+                }
+                q = strchr_m(p, ':');
+                if (q) {
+                        *q = '\0';
+                        q++;
+                }
+                reg_string_to_val(line, iconv_convenience,
+                                  q?p:"REG_SZ", q?q:p,
+                                  &value_type, &value);
+                error = callbacks->set_value(callback_data, curkey, line,
+                                             value_type, value);
+                if (continue_next_line) {
+                        continue_next_line = 0;
+                        /* Continued data start with two whitespaces */
+                        if (line[0] != ' ' || line[1] != ' ') {
+                                DEBUG(0, ("Malformed line: %s\n", line));
+                                talloc_free(line);
+                                continue;
+                        }
+                        p = line + 2;
+                        /* Continue again if line ends with a backslash */
+                        if (line[strlen(line)-1] == '\\') {
+                                line[strlen(line)-1] = '\0';
+                                continue_next_line = 1;
+                                data_str = talloc_strdup_append(data_str, p);
+                                talloc_free(line);
+                                continue;
+                        }
+                        data_str = talloc_strdup_append(data_str, p);
+                } else {
+                        p = strchr_m(line, '=');
+                        if (p == NULL) {
+                                DEBUG(0, ("Malformed line: %s\n", line));
+                                talloc_free(line);
+                                continue;
+                        }
+                        *p = '\0'; p++;
+                        if (curkey == NULL) {
+                                DEBUG(0, ("Value change without key\n"));
+                                talloc_free(line);
+                                continue;
+                        }
+                        /* Values should be double-quoted */
+                        if (line[0] != '"') {
+                                DEBUG(0, ("Malformed line\n"));
+                                talloc_free(line);
+                                continue;
+                        }
+                        /* Chop of the quotes and store as value */
+                        value = talloc_strndup(mem_ctx, line+1,strlen(line)-2);
+                        /* Delete value */
+                        if (p[0] == '-') {
+                                error = callbacks->del_value(callback_data,
+                                                     curkey, value);
+                                /* Ignore if key does not exist (WERR_BADFILE)
+                                 * Consistent with Windows behaviour */
+                                if (!W_ERROR_IS_OK(error) &&
+                                    !W_ERROR_EQUAL(error, WERR_BADFILE)) {
+                                        DEBUG(0, ("Error deleting value %s in key %s\n",
+                                                value, curkey));
+                                        talloc_free(mem_ctx);
+                                        return error;
+                                }
+                                talloc_free(line);
+                                talloc_free(value);
+                                continue;
+                        }
+                        /* Do not look for colons in strings */
+                        if (p[0] == '"') {
+                                q = NULL;
+                                data_str = talloc_strndup(mem_ctx, p+1,strlen(p)-2);
+                        } else {
+                                /* Split the value type from the data */
+                                q = strchr_m(p, ':');
+                                if (q) {
+                                        *q = '\0';
+                                        q++;
+                                        type_str = talloc_strdup(mem_ctx, p);
+                                        data_str = talloc_strdup(mem_ctx, q);
+                                } else {
+                                        data_str = talloc_strdup(mem_ctx, p);
+                                }
+                        }
+                        /* Backslash before the CRLF means continue on next line */
+                        if (data_str[strlen(data_str)-1] == '\\') {
+                                data_str[strlen(data_str)-1] = '\0';
+                                talloc_free(line);
+                                continue_next_line = 1;
+                                continue;
+                        }
+                }
+                DEBUG(9, ("About to write %s with type %s, length %ld: %s\n", value, type_str, (long) strlen(data_str), data_str));
+                result = reg_string_to_val(value,
+                                  type_str?type_str:"REG_SZ", data_str,
+                                  &value_type, &data);
+                if (!result) {
+                        DEBUG(0, ("Error converting string to value for line:\n%s\n",
+                                        line));
+                        return WERR_GENERAL_FAILURE;
+                }
+                error = callbacks->set_value(callback_data, curkey, value,
+                                             value_type, data);
                 if (!W_ERROR_IS_OK(error)) {
                         DEBUG(0, ("Error setting value for %s in %s\n",
                                 line, curkey));
+                                value, curkey));
                         talloc_free(mem_ctx);
                         return error;
+                }
+                /* Clean up buffers */
+                if (type_str != NULL) {
+                        talloc_free(type_str);
+                        type_str = NULL;
+                }
+                talloc_free(data_str);
+                talloc_free(value);
                 talloc_free(line);
+        }
 …
         close(fd);
+        return WERR_OK;
+}
+        talloc_free(mem_ctx);
+        return WERR_OK;
+}

trunk/server/source4/lib/registry/patchfile_preg.c

-              r414
+              r745
         uint16_t v;
         if (read(fd, &v, 2) < 2) {
+        if (read(fd, &v, sizeof(uint16_t)) < sizeof(uint16_t)) {
                 return WERR_GENERAL_FAILURE;
+        }
 …
 static WERROR preg_write_utf16(int fd, const char *string)
+{
+        codepoint_t v;
+        uint16_t i;
+        size_t size;
+        uint16_t v;
+        size_t i, size;
         for (i = 0; i < strlen(string); i+=size) {
                 v = next_codepoint(&string[i], &size);
                 if (write(fd, &v, 2) < 2) {
+                if (write(fd, &v, sizeof(uint16_t)) < sizeof(uint16_t)) {
                         return WERR_GENERAL_FAILURE;
+                }
 …
         char *parent_name;
         DATA_BLOB blob;
+        parent_name = talloc_strndup(data->ctx, key_name, strrchr(key_name, '\\')-key_name);
+        blob.data = (uint8_t *)talloc_strndup(data->ctx, key_name+(strrchr(key_name, '\\')-key_name)+1,
+                        strlen(key_name)-(strrchr(key_name, '\\')-key_name));
+        WERROR werr;
+        parent_name = talloc_strndup(data->ctx, key_name,
+                                     strrchr(key_name, '\\')-key_name);
+        W_ERROR_HAVE_NO_MEMORY(parent_name);
+        blob.data = (uint8_t*)talloc_strndup(data->ctx,
+                                             key_name+(strrchr(key_name, '\\')-key_name)+1,
+                                             strlen(key_name)-(strrchr(key_name, '\\')-key_name));
+        W_ERROR_HAVE_NO_MEMORY(blob.data);
         blob.length = strlen((char *)blob.data)+1;
         /* FIXME: These values should be accumulated to be written at done(). */
+        return reg_preg_diff_set_value(data, parent_name, "**DeleteKeys", REG_SZ, blob);
+        werr = reg_preg_diff_set_value(data, parent_name, "**DeleteKeys",
+                                       REG_SZ, blob);
+        talloc_free(parent_name);
+        talloc_free(blob.data);
+        return werr;
+}
 …
         char *val;
         DATA_BLOB blob;
+        WERROR werr;
         val = talloc_asprintf(data->ctx, "**Del.%s", value_name);
+        W_ERROR_HAVE_NO_MEMORY(val);
         blob.data = (uint8_t *)talloc(data->ctx, uint32_t);
+        *(uint32_t *)blob.data = 0;
+        blob.length = 4;
+        return reg_preg_diff_set_value(data, key_name, val, REG_DWORD, blob);
+        W_ERROR_HAVE_NO_MEMORY(blob.data);
+        SIVAL(blob.data, 0, 0);
+        blob.length = sizeof(uint32_t);
+        werr = reg_preg_diff_set_value(data, key_name, val, REG_DWORD, blob);
+        talloc_free(val);
+        talloc_free(blob.data);
+        return werr;
+}
 …
         struct preg_data *data = (struct preg_data *)_data;
         DATA_BLOB blob;
+        WERROR werr;
         blob.data = (uint8_t *)talloc(data->ctx, uint32_t);
+        *(uint32_t *)blob.data = 0;
+        blob.length = 4;
+        return reg_preg_diff_set_value(data, key_name, "**DelVals.", REG_DWORD, blob);
+        W_ERROR_HAVE_NO_MEMORY(blob.data);
+        SIVAL(blob.data, 0, 0);
+        blob.length = sizeof(uint32_t);
+        werr = reg_preg_diff_set_value(data, key_name, "**DelVals.", REG_DWORD,
+                                       blob);
+        talloc_free(blob.data);
+        return werr;
+}
 …
  */
 _PUBLIC_ WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
-                                   struct smb_iconv_convenience *ic,
                                    struct reg_diff_callbacks **callbacks,
                                    void **callback_data)
 …
         strncpy(preg_header.hdr, "PReg", 4);
         SIVAL(&preg_header, 4, 1);
         write(data->fd, (uint8_t *)&preg_header,8);
+        SIVAL(&preg_header.version, 0, 1);
+        write(data->fd, (uint8_t *)&preg_header, sizeof(preg_header));
         data->ctx = ctx;
 …
  */
 _PUBLIC_ WERROR reg_preg_diff_load(int fd,
-                                   struct smb_iconv_convenience *iconv_convenience,
                                    const struct reg_diff_callbacks *callbacks,
                                    void *callback_data)
 …
         /* Read first 8 bytes (the header) */
         if (read(fd, &preg_header, 8) != 8) {
+        if (read(fd, &preg_header, sizeof(preg_header)) != sizeof(preg_header)) {
                 DEBUG(0, ("Could not read PReg file: %s\n",
                                 strerror(errno)));
 …
                 /* Get the type */
                 if (read(fd, &value_type, 4) < 4) {
+                if (read(fd, &value_type, sizeof(uint32_t)) < sizeof(uint32_t)) {
                         DEBUG(0, ("Error while reading PReg\n"));
                         ret = WERR_GENERAL_FAILURE;
 …
                         goto cleanup;
+                }
                 /* Get data length */
                 if (read(fd, &length, 4) < 4) {
+                if (read(fd, &length, sizeof(uint32_t)) < sizeof(uint32_t)) {
                         DEBUG(0, ("Error while reading PReg\n"));
                         ret = WERR_GENERAL_FAILURE;
                         goto cleanup;
+                }
+                length = IVAL(&length, 0);
                 /* Read past delimiter */
                 buf_ptr = buf;
 …
                         goto cleanup;
+                }
                 /* Get the data */
                 buf_ptr = buf;

trunk/server/source4/lib/registry/pyregistry.c

-              r414
+              r745
    Samba utility functions
    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   Copyright (C) Wilco Baan Hofman <wilco@baanhofman.nl> 2010
    This program is free software; you can redistribute it and/or modify
 …
 */
+#include <Python.h>
 #include "includes.h"
-#include <tevent.h>
-#include <Python.h>
 #include "libcli/util/pyerrors.h"
 #include "lib/registry/registry.h"
 #include "scripting/python/modules.h" /* for py_iconv_convenience() */
 #include <pytalloc.h>
+#include "lib/talloc/pytalloc.h"
+#include "lib/events/events.h"
 #include "auth/credentials/pycredentials.h"
 #include "param/pyparam.h"
+#ifndef Py_RETURN_NONE
+#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
+#endif
+PyAPI_DATA(PyTypeObject) PyRegistryKey;
+PyAPI_DATA(PyTypeObject) PyRegistry;
+PyAPI_DATA(PyTypeObject) PyHiveKey;
+extern PyTypeObject PyRegistryKey;
+extern PyTypeObject PyRegistry;
+extern PyTypeObject PyHiveKey;
 /*#define PyRegistryKey_AsRegistryKey(obj) py_talloc_get_type(obj, struct registry_key)*/
 …
                 return NULL;
         result = reg_diff_apply(ctx, py_iconv_convenience(NULL), filename);
+        result = reg_diff_apply(ctx, filename);
         PyErr_WERROR_IS_ERR_RAISE(result);
 …
         .tp_new = registry_new,
         .tp_basicsize = sizeof(py_talloc_Object),
-        .tp_dealloc = py_talloc_dealloc,
         .tp_flags = Py_TPFLAGS_DEFAULT,
 };
 …
                 return NULL;
         result = hive_key_del(key, name);
+        result = hive_key_del(NULL, key, name);
         PyErr_WERROR_IS_ERR_RAISE(result);
 …
                 return NULL;
         result = hive_key_del_value(key, name);
+        result = hive_key_del_value(NULL, key, name);
         PyErr_WERROR_IS_ERR_RAISE(result);
 …
                 result = hive_key_set_value(key, name, type, value);
         else
                 result = hive_key_del_value(key, name);
+                result = hive_key_del_value(NULL, key, name);
         PyErr_WERROR_IS_ERR_RAISE(result);
 …
 };
+static PyObject *hive_open(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+        /* reg_open_hive */
+static PyObject *hive_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) {
         Py_RETURN_NONE;
+}
+static PyObject *py_open_hive(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+        const char *kwnames[] = { "location", "lp_ctx", "session_info", "credentials", NULL };
+        WERROR result;
+        struct loadparm_context *lp_ctx;
+        PyObject *py_lp_ctx, *py_session_info, *py_credentials;
+        struct auth_session_info *session_info;
+        struct cli_credentials *credentials;
+        char *location;
+        struct hive_key *hive_key;
+        TALLOC_CTX *mem_ctx;
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|OOO",
+                                         discard_const_p(char *, kwnames),
+                                         &location,
+                                         &py_lp_ctx, &py_session_info,
+                                         &py_credentials))
+                return NULL;
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        lp_ctx = lpcfg_from_py_object(mem_ctx, py_lp_ctx);
+        if (lp_ctx == NULL) {
+                PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        credentials = cli_credentials_from_py_object(py_credentials);
+        if (credentials == NULL) {
+                PyErr_SetString(PyExc_TypeError, "Expected credentials");
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        session_info = NULL;
+        result = reg_open_hive(NULL, location, session_info, credentials,
+                               tevent_context_init(NULL),
+                               lp_ctx, &hive_key);
+        talloc_free(mem_ctx);
+        PyErr_WERROR_IS_ERR_RAISE(result);
+        return py_talloc_steal(&PyHiveKey, hive_key);
+}
 …
         .tp_name = "HiveKey",
         .tp_methods = hive_key_methods,
         .tp_new = hive_open,
+        .tp_new = hive_new,
         .tp_basicsize = sizeof(py_talloc_Object),
-        .tp_dealloc = py_talloc_dealloc,
         .tp_flags = Py_TPFLAGS_DEFAULT,
 };
 …
         .tp_name = "RegistryKey",
         .tp_basicsize = sizeof(py_talloc_Object),
-        .tp_dealloc = py_talloc_dealloc,
         .tp_flags = Py_TPFLAGS_DEFAULT,
 };
 …
         struct registry_context *reg_ctx;
         WERROR result;
     struct loadparm_context *lp_ctx;
+        struct loadparm_context *lp_ctx;
         PyObject *py_lp_ctx, *py_session_info, *py_credentials;
         struct auth_session_info *session_info;
+    struct cli_credentials *credentials;
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO", discard_const_p(char *, kwnames),
+                                         &py_lp_ctx, &py_session_info, &py_credentials))
+                return NULL;
+    lp_ctx = lp_from_py_object(py_lp_ctx);
+    if (lp_ctx == NULL) {
+        struct cli_credentials *credentials;
+        TALLOC_CTX *mem_ctx;
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO",
+                                         discard_const_p(char *, kwnames),
+                                         &py_lp_ctx, &py_session_info,
+                                         &py_credentials))
+                return NULL;
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        lp_ctx = lpcfg_from_py_object(mem_ctx, py_lp_ctx);
+        if (lp_ctx == NULL) {
                 PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
+                return NULL;
+    }
+                talloc_free(mem_ctx);
+                return NULL;
+        }
         credentials = cli_credentials_from_py_object(py_credentials);
         if (credentials == NULL) {
                 PyErr_SetString(PyExc_TypeError, "Expected credentials");
+                talloc_free(mem_ctx);
                 return NULL;
+        }
 …
         result = reg_open_samba(NULL, &reg_ctx, NULL,
                                 lp_ctx, session_info, credentials);
+        talloc_free(mem_ctx);
         if (!W_ERROR_IS_OK(result)) {
                 PyErr_SetWERROR(result);
                 return NULL;
+        }
         return py_talloc_steal(&PyRegistry, reg_ctx);
+}
 …
         WERROR result;
         char *location;
     struct loadparm_context *lp_ctx;
     struct cli_credentials *credentials;
+        struct loadparm_context *lp_ctx;
+        struct cli_credentials *credentials;
         struct hive_key *key;
         struct auth_session_info *session_info;
+        TALLOC_CTX *mem_ctx;
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|OOO",
+                                                                         discard_const_p(char *, kwnames),
+                                                                         &location,
+                                                                         &py_session_info, &py_credentials,
+                                                                         &py_lp_ctx))
+                return NULL;
+    lp_ctx = lp_from_py_object(py_lp_ctx);
+    if (lp_ctx == NULL) {
+                                         discard_const_p(char *, kwnames),
+                                         &location, &py_session_info,
+                                         &py_credentials, &py_lp_ctx))
+                return NULL;
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+        lp_ctx = lpcfg_from_py_object(mem_ctx, py_lp_ctx);
+        if (lp_ctx == NULL) {
                 PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
+                return NULL;
+    }
+                talloc_free(mem_ctx);
+                return NULL;
+        }
         credentials = cli_credentials_from_py_object(py_credentials);
         if (credentials == NULL) {
                 PyErr_SetString(PyExc_TypeError, "Expected credentials");
+                talloc_free(mem_ctx);
                 return NULL;
+        }
 …
         result = reg_open_ldb_file(NULL, location, session_info, credentials,
+                                                           tevent_context_init(NULL), lp_ctx, &key);
+                                   s4_event_context_init(NULL), lp_ctx, &key);
+        talloc_free(mem_ctx);
         PyErr_WERROR_IS_ERR_RAISE(result);
 …
         { "create_directory", py_create_directory, METH_VARARGS, "create_dir(location) -> key" },
         { "open_ldb", (PyCFunction)py_open_ldb_file, METH_VARARGS|METH_KEYWORDS, "open_ldb(location, session_info=None, credentials=None, loadparm_context=None) -> key" },
+        { "open_hive", (PyCFunction)py_open_hive, METH_VARARGS|METH_KEYWORDS, "open_hive(location, session_info=None, credentials=None, loadparm_context=None) -> key" },
         { "str_regtype", py_str_regtype, METH_VARARGS, "str_regtype(int) -> str" },
         { "get_predef_name", py_get_predef_name, METH_VARARGS, "get_predef_name(hkey) -> str" },
 …
+{
         PyObject *m;
+        PyTypeObject *talloc_type = PyTalloc_GetObjectType();
+        if (talloc_type == NULL)
+                return;
+        PyHiveKey.tp_base = talloc_type;
+        PyRegistry.tp_base = talloc_type;
+        PyRegistryKey.tp_base = talloc_type;
         if (PyType_Ready(&PyHiveKey) < 0)

trunk/server/source4/lib/registry/regf.c

-              r414
+              r745
    Registry backend for REGF files
    Copyright (C) 2005-2007 Jelmer Vernooij, jelmer@samba.org
    Copyright (C) 2006 Wilco Baan Hofman, wilco@baanhofman.nl
+   Copyright (C) 2006-2010 Wilco Baan Hofman, wilco@baanhofman.nl
    This program is free software; you can redistribute it and/or modify
 …
         struct hbin_block **hbins;
         struct regf_hdr *header;
         struct smb_iconv_convenience *iconv_convenience;
+        time_t last_write;
 };
 static WERROR regf_save_hbin(struct regf_data *data);
+static WERROR regf_save_hbin(struct regf_data *data, bool flush);
 struct regf_key_data {
 …
                                          uint32_t offset, uint32_t *rel_offset)
+{
         int i;
+        unsigned int i;
         for (i = 0; data->hbins[i]; i++) {
 …
+{
         uint32_t checksum = 0, x;
         int i;
+        unsigned int i;
         for (i = 0; i < 0x01FB; i+= 4) {
 …
         if (hbin == NULL) {
                 DEBUG(1, ("Can't find HBIN containing 0x%04x\n", offset));
+                DEBUG(1, ("Can't find HBIN at 0x%04x\n", offset));
                 return ret;
+        }
 …
                          TALLOC_CTX *ctx, tdr_pull_fn_t pull_fn, void *p)
+{
         struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+        struct tdr_pull *pull = tdr_pull_init(regf);
         pull->data = hbin_get(regf, offset);
 …
+{
         DATA_BLOB ret;
         uint32_t rel_offset = -1; /* Relative offset ! */
+        uint32_t rel_offset = (uint32_t) -1; /* Relative offset ! */
         struct hbin_block *hbin = NULL;
         int i;
+        unsigned int i;
         *offset = 0;
 …
                 DEBUG(4, ("No space available in other HBINs for block of size %d, allocating new HBIN\n",
                         size));
+                /* Add extra hbin block */
                 data->hbins = talloc_realloc(data, data->hbins,
                                              struct hbin_block *, i+2);
 …
                 data->hbins[i+1] = NULL;
+                /* Set hbin data */
                 hbin->HBIN_ID = talloc_strdup(hbin, "hbin");
                 hbin->offset_from_first = (i == 0?0:data->hbins[i-1]->offset_from_first+data->hbins[i-1]->offset_to_next);
                 hbin->offset_to_next = 0x1000;
                 hbin->unknown[0] = 0;
                 hbin->unknown[0] = 0;
+                hbin->unknown[1] = 0;
                 unix_to_nt_time(&hbin->last_change, time(NULL));
                 hbin->block_size = hbin->offset_to_next;
                 hbin->data = talloc_zero_array(hbin, uint8_t, hbin->block_size - 0x20);
+                /* Update the regf header */
+                data->header->last_block += hbin->offset_to_next;
+                /* Set the next block to it's proper size and set the
+                 * rel_offset for this block */
+                SIVAL(hbin->data, size, hbin->block_size - size - 0x20);
                 rel_offset = 0x0;
-                SIVAL(hbin->data, size, hbin->block_size - size - 0x20);
+        }
 …
         memcpy(dest.data, blob.data, blob.length);
+        /* Make sure that we have no tailing garbage in the block */
+        if (dest.length > blob.length) {
+                memset(dest.data + blob.length, 0, dest.length - blob.length);
+        }
         return ret;
+}
 …
                                tdr_push_fn_t push_fn, void *p)
+{
         struct tdr_push *push = tdr_push_init(data, data->iconv_convenience);
+        struct tdr_push *push = tdr_push_init(data);
         uint32_t ret;
 …
         /* If the next block is free, merge into big free block */
         if (rel_offset + size < hbin->offset_to_next) {
+        if (rel_offset + size < hbin->offset_to_next - 0x20) {
                 next_size = IVALS(hbin->data, rel_offset+size);
                 if (next_size > 0) {
 …
         int32_t needed_size;
         int32_t possible_size;
         int i;
+        unsigned int i;
         SMB_ASSERT(orig_offset > 0);
 …
                                       uint32_t orig_offset, void *p)
+{
         struct tdr_push *push = tdr_push_init(regf, regf->iconv_convenience);
+        struct tdr_push *push = tdr_push_init(regf);
         uint32_t ret;
 …
                                                     (char*)data.data,
                                                     private_data->nk->clsname_length);
+                        W_ERROR_HAVE_NO_MEMORY(*classname);
                 } else
                         *classname = NULL;
 …
         if (!hbin_get_tdr(regf, offset, nk,
                           (tdr_pull_fn_t)tdr_pull_nk_block, nk)) {
                 DEBUG(0, ("Unable to find HBIN data for offset %d\n", offset));
+                DEBUG(0, ("Unable to find HBIN data for offset 0x%x\n", offset));
                 return NULL;
+        }
 …
 static WERROR regf_get_value(TALLOC_CTX *ctx, struct hive_key *key,
                              int idx, const char **name,
+                             uint32_t idx, const char **name,
                              uint32_t *data_type, DATA_BLOB *data)
+{
 …
         tmp = hbin_get(regf, private_data->nk->values_offset);
         if (!tmp.data) {
+                DEBUG(0, ("Unable to find value list\n"));
+                DEBUG(0, ("Unable to find value list at 0x%x\n",
+                                private_data->nk->values_offset));
                 return WERR_GENERAL_FAILURE;
+        }
 …
         if (!hbin_get_tdr(regf, vk_offset, vk,
                           (tdr_pull_fn_t)tdr_pull_vk_block, vk)) {
                 DEBUG(0, ("Unable to get VK block at %d\n", vk_offset));
+                DEBUG(0, ("Unable to get VK block at 0x%x\n", vk_offset));
                 talloc_free(vk);
                 return WERR_GENERAL_FAILURE;
 …
         /* FIXME: name character set ?*/
         if (name != NULL)
+        if (name != NULL) {
                 *name = talloc_strndup(ctx, vk->data_name, vk->name_length);
+                W_ERROR_HAVE_NO_MEMORY(*name);
+        }
         if (data_type != NULL)
 …
         if (vk->data_length & 0x80000000) {
+                vk->data_length &=~0x80000000;
+                data->data = (uint8_t *)talloc_memdup(ctx, (uint8_t *)&vk->data_offset, vk->data_length);
+                data->length = vk->data_length;
+                /* this is data of type "REG_DWORD" or "REG_DWORD_BIG_ENDIAN" */
+                data->data = talloc_size(ctx, sizeof(uint32_t));
+                W_ERROR_HAVE_NO_MEMORY(data->data);
+                SIVAL(data->data, 0, vk->data_offset);
+                data->length = sizeof(uint32_t);
         } else {
                 *data = hbin_get(regf, vk->data_offset);
 …
                                      uint32_t *type, DATA_BLOB *data)
+{
         int i;
+        unsigned int i;
         const char *vname;
         WERROR error;
 …
                 return WERR_NO_MORE_ITEMS;
+        /* Make sure that we don't crash if the key is empty */
+        if (nk->subkeys_offset == -1) {
+                return WERR_NO_MORE_ITEMS;
+        }
         data = hbin_get(private_data->hive, nk->subkeys_offset);
         if (!data.data) {
+                DEBUG(0, ("Unable to find subkey list\n"));
+                DEBUG(0, ("Unable to find subkey list at 0x%x\n",
+                        nk->subkeys_offset));
                 return WERR_GENERAL_FAILURE;
+        }
 …
         if (!strncmp((char *)data.data, "li", 2)) {
                 struct li_block li;
                 struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(private_data->hive);
                 DEBUG(10, ("Subkeys in LI list\n"));
 …
         } else if (!strncmp((char *)data.data, "lf", 2)) {
                 struct lf_block lf;
                 struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(private_data->hive);
                 DEBUG(10, ("Subkeys in LF list\n"));
 …
         } else if (!strncmp((char *)data.data, "lh", 2)) {
                 struct lh_block lh;
                 struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(private_data->hive);
                 DEBUG(10, ("Subkeys in LH list\n"));
 …
         } else if (!strncmp((char *)data.data, "ri", 2)) {
                 struct ri_block ri;
                 struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i;
                 uint16_t sublist_count = 0;
 …
                                                     (char*)db.data,
                                                     ret->nk->clsname_length);
+                        W_ERROR_HAVE_NO_MEMORY(*classname);
                 } else
                         *classname = NULL;
 …
+        }
         pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+        pull = tdr_pull_init(ctx);
         pull->data = subkey_data;
 …
         uint32_t key_off = 0;
+        /* Make sure that we don't crash if the key is empty */
+        if (nk->subkeys_offset == -1) {
+                return WERR_BADFILE;
+        }
         data = hbin_get(private_data->hive, nk->subkeys_offset);
         if (!data.data) {
 …
         if (!strncmp((char *)data.data, "li", 2)) {
                 struct li_block li;
                 struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i;
 …
         } else if (!strncmp((char *)data.data, "lf", 2)) {
                 struct lf_block lf;
                 struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i;
 …
         } else if (!strncmp((char *)data.data, "lh", 2)) {
                 struct lh_block lh;
                 struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i;
                 uint32_t hash;
 …
         } else if (!strncmp((char *)data.data, "ri", 2)) {
                 struct ri_block ri;
                 struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i, j;
 …
         /* Push the security descriptor to a blob */
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf, NULL,
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf,
                                                           sec_desc, (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
                 DEBUG(0, ("Unable to push security descriptor\n"));
 …
         data.data = sk.sec_desc;
         data.length = sk.rec_size;
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_pull_struct_blob(&data, ctx, NULL, *sd,
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_pull_struct_blob(&data, ctx, *sd,
                                                   (ndr_pull_flags_fn_t)ndr_pull_security_descriptor))) {
                 DEBUG(0, ("Error parsing security descriptor\n"));
 …
         if (!strncmp((char *)data.data, "li", 2)) {
                 struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 struct li_block li;
+                struct nk_block sub_nk;
+                int32_t i, j;
                 pull->data = data;
 …
+                }
+                /*
+                 * Find the position to store the pointer
+                 * Extensive testing reveils that at least on windows 7 subkeys
+                 * *MUST* be stored in alphabetical order
+                 */
+                for (i = 0; i < li.key_count; i++) {
+                        /* Get the nk */
+                        hbin_get_tdr(regf, li.nk_offset[i], regf,
+                                        (tdr_pull_fn_t) tdr_pull_nk_block, &sub_nk);
+                        if (strcasecmp(name, sub_nk.key_name) < 0) {
+                                break;
+                        }
+                }
                 li.nk_offset = talloc_realloc(regf, li.nk_offset,
                                               uint32_t, li.key_count+1);
                 W_ERROR_HAVE_NO_MEMORY(li.nk_offset);
+                li.nk_offset[li.key_count] = key_offset;
+                /* Move everything behind this offset */
+                for (j = li.key_count - 1; j >= i; j--) {
+                        li.nk_offset[j+1] = li.nk_offset[j];
+                }
+                li.nk_offset[i] = key_offset;
                 li.key_count++;
                 *ret = hbin_store_tdr_resize(regf,
 …
                 talloc_free(li.nk_offset);
         } else if (!strncmp((char *)data.data, "lf", 2)) {
                 struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 struct lf_block lf;
+                struct nk_block sub_nk;
+                int32_t i, j;
                 pull->data = data;
 …
                 SMB_ASSERT(!strncmp(lf.header, "lf", 2));
+                /*
+                 * Find the position to store the hash record
+                 * Extensive testing reveils that at least on windows 7 subkeys
+                 * *MUST* be stored in alphabetical order
+                 */
+                for (i = 0; i < lf.key_count; i++) {
+                        /* Get the nk */
+                        hbin_get_tdr(regf, lf.hr[i].nk_offset, regf,
+                                        (tdr_pull_fn_t) tdr_pull_nk_block, &sub_nk);
+                        if (strcasecmp(name, sub_nk.key_name) < 0) {
+                                break;
+                        }
+                }
                 lf.hr = talloc_realloc(regf, lf.hr, struct hash_record,
                                        lf.key_count+1);
                 W_ERROR_HAVE_NO_MEMORY(lf.hr);
+                lf.hr[lf.key_count].nk_offset = key_offset;
+                lf.hr[lf.key_count].hash = talloc_strndup(lf.hr, name, 4);
+                /* Move everything behind this hash record */
+                for (j = lf.key_count - 1; j >= i; j--) {
+                        lf.hr[j+1] = lf.hr[j];
+                }
+                lf.hr[i].nk_offset = key_offset;
+                lf.hr[i].hash = talloc_strndup(lf.hr, name, 4);
                 W_ERROR_HAVE_NO_MEMORY(lf.hr[lf.key_count].hash);
                 lf.key_count++;
 …
                 talloc_free(lf.hr);
         } else if (!strncmp((char *)data.data, "lh", 2)) {
                 struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 struct lh_block lh;
+                struct nk_block sub_nk;
+                int32_t i, j;
                 pull->data = data;
 …
                 SMB_ASSERT(!strncmp(lh.header, "lh", 2));
+                /*
+                 * Find the position to store the hash record
+                 * Extensive testing reveils that at least on windows 7 subkeys
+                 * *MUST* be stored in alphabetical order
+                 */
+                for (i = 0; i < lh.key_count; i++) {
+                        /* Get the nk */
+                        hbin_get_tdr(regf, lh.hr[i].nk_offset, regf,
+                                        (tdr_pull_fn_t) tdr_pull_nk_block, &sub_nk);
+                        if (strcasecmp(name, sub_nk.key_name) < 0) {
+                                break;
+                        }
+                }
                 lh.hr = talloc_realloc(regf, lh.hr, struct lh_hash,
                                        lh.key_count+1);
                 W_ERROR_HAVE_NO_MEMORY(lh.hr);
+                lh.hr[lh.key_count].nk_offset = key_offset;
+                lh.hr[lh.key_count].base37 = regf_create_lh_hash(name);
+                /* Move everything behind this hash record */
+                for (j = lh.key_count - 1; j >= i; j--) {
+                        lh.hr[j+1] = lh.hr[j];
+                }
+                lh.hr[i].nk_offset = key_offset;
+                lh.hr[i].base37 = regf_create_lh_hash(name);
                 lh.key_count++;
                 *ret = hbin_store_tdr_resize(regf,
 …
         if (strncmp((char *)data.data, "li", 2) == 0) {
                 struct li_block li;
                 struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 uint16_t i;
                 bool found_offset = false;
 …
         } else if (strncmp((char *)data.data, "lf", 2) == 0) {
                 struct lf_block lf;
                 struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 uint16_t i;
                 bool found_offset = false;
 …
         } else if (strncmp((char *)data.data, "lh", 2) == 0) {
                 struct lh_block lh;
                 struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 uint16_t i;
                 bool found_offset = false;
 …
+}
+static WERROR regf_del_value (struct hive_key *key, const char *name)
+static WERROR regf_del_value(TALLOC_CTX *mem_ctx, struct hive_key *key,
+                             const char *name)
+{
         struct regf_key_data *private_data = (struct regf_key_data *)key;
 …
         bool found_offset = false;
         DATA_BLOB values;
         uint32_t i;
+        unsigned int i;
         if (nk->values_offset == -1) {
 …
                               private_data->offset, nk);
+        return regf_save_hbin(private_data->hive);
+}
+static WERROR regf_del_key(const struct hive_key *parent, const char *name)
+        return regf_save_hbin(private_data->hive, 0);
+}
+static WERROR regf_del_key(TALLOC_CTX *mem_ctx, const struct hive_key *parent,
+                           const char *name)
+{
         const struct regf_key_data *private_data =
 …
                 char *sk_name;
                 struct hive_key *sk = (struct hive_key *)key;
                 int i = key->nk->num_subkeys;
+                unsigned int i = key->nk->num_subkeys;
                 while (i--) {
                         /* Get subkey information. */
 …
                         /* Delete subkey. */
                         error = regf_del_key(sk, sk_name);
+                        error = regf_del_key(NULL, sk, sk_name);
                         if (!W_ERROR_IS_OK(error)) {
                                 DEBUG(0, ("Can't delete key '%s'.\n", sk_name));
 …
                 struct hive_key *sk = (struct hive_key *)key;
                 DATA_BLOB data;
                 int i = key->nk->num_values;
+                unsigned int i = key->nk->num_values;
                 while (i--) {
                         /* Get value information. */
 …
                         /* Delete value. */
                         error = regf_del_value(sk, val_name);
+                        error = regf_del_value(NULL, sk, val_name);
                         if (!W_ERROR_IS_OK(error)) {
                                 DEBUG(0, ("Can't delete value '%s'.\n", val_name));
 …
         hbin_free(private_data->hive, key->offset);
         return regf_save_hbin(private_data->hive);
+        return regf_save_hbin(private_data->hive, 0);
+}
 …
         nk.num_values = 0;
         nk.values_offset = -1;
         memset(nk.unk3, 0, 5);
+        memset(nk.unk3, 0, sizeof(nk.unk3));
         nk.clsname_offset = -1; /* FIXME: fill in */
         nk.clsname_length = 0;
 …
         if (!hbin_get_tdr(regf, regf->header->data_offset, root,
                           (tdr_pull_fn_t)tdr_pull_nk_block, root)) {
                 DEBUG(0, ("Unable to find HBIN data for offset %d\n",
+                DEBUG(0, ("Unable to find HBIN data for offset 0x%x\n",
                         regf->header->data_offset));
                 return WERR_GENERAL_FAILURE;
 …
         *ret = (struct hive_key *)regf_get_key(ctx, regf, offset);
+        return regf_save_hbin(private_data->hive);
+        DEBUG(9, ("Storing key %s\n", name));
+        return regf_save_hbin(private_data->hive, 0);
+}
 …
         struct vk_block vk;
         uint32_t i;
         uint32_t tmp_vk_offset, vk_offset, old_vk_offset = -1;
+        uint32_t tmp_vk_offset, vk_offset, old_vk_offset = (uint32_t) -1;
         DATA_BLOB values;
 …
                                           (tdr_pull_fn_t)tdr_pull_vk_block,
                                           &vk)) {
                                 DEBUG(0, ("Unable to get VK block at %d\n",
+                                DEBUG(0, ("Unable to get VK block at 0x%x\n",
                                         tmp_vk_offset));
                                 return WERR_GENERAL_FAILURE;
 …
+                        }
+                }
+                /* Free data, if any */
+                if (!(vk.data_length & 0x80000000)) {
+                        hbin_free(regf, vk.data_offset);
+                }
+        }
+        }
+        /* If it's new, create the vk struct, if it's old, free the old data. */
         if (old_vk_offset == -1) {
                 vk.header = "vk";
 …
                         vk.flag = 0;
+                }
+        }
+        } else {
+                /* Free data, if any */
+                if (!(vk.data_length & 0x80000000)) {
+                        hbin_free(regf, vk.data_offset);
+                }
+        }
         /* Set the type and data */
         vk.data_length = data.length;
         vk.data_type = type;
+        if (type == REG_DWORD) {
+        if ((type == REG_DWORD) || (type == REG_DWORD_BIG_ENDIAN)) {
+                if (vk.data_length != sizeof(uint32_t)) {
+                        DEBUG(0, ("DWORD or DWORD_BIG_ENDIAN value with size other than 4 byte!\n"));
+                        return WERR_NOT_SUPPORTED;
+                }
                 vk.data_length |= 0x80000000;
                 vk.data_offset = *(uint32_t *)data.data;
+                vk.data_offset = IVAL(data.data, 0);
         } else {
                 /* Store data somewhere */
 …
                               (tdr_push_fn_t) tdr_push_nk_block,
                               private_data->offset, nk);
         return regf_save_hbin(private_data->hive);
+}
 static WERROR regf_save_hbin(struct regf_data *regf)
+{
         struct tdr_push *push = tdr_push_init(regf, regf->iconv_convenience);
         int i;
+        return regf_save_hbin(private_data->hive, 0);
+}
+static WERROR regf_save_hbin(struct regf_data *regf, bool flush)
+{
+        struct tdr_push *push = tdr_push_init(regf);
+        unsigned int i;
         W_ERROR_HAVE_NO_MEMORY(push);
+        /* Only write once every 5 seconds, or when flush is set */
+        if (!flush && regf->last_write + 5 >= time(NULL)) {
+                return WERR_OK;
+        }
+        regf->last_write = time(NULL);
         if (lseek(regf->fd, 0, SEEK_SET) == -1) {
 …
         talloc_free(push);
         if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, regf->iconv_convenience,
+        if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
                                             (tdr_push_fn_t)tdr_push_regf_hdr,
                                             regf->header))) {
 …
         for (i = 0; regf->hbins[i]; i++) {
                 if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, regf->iconv_convenience,
+                if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
                                                     (tdr_push_fn_t)tdr_push_hbin_block,
                                                     regf->hbins[i]))) {
 …
 WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
-                            struct smb_iconv_convenience *iconv_convenience,
                             const char *location,
                             int minor_version, struct hive_key **key)
 …
         regf = (struct regf_data *)talloc_zero(NULL, struct regf_data);
-        regf->iconv_convenience = iconv_convenience;
         W_ERROR_HAVE_NO_MEMORY(regf);
 …
         nk.header = "nk";
         nk.type = REG_SUB_KEY;
+        nk.type = REG_ROOT_KEY;
         unix_to_nt_time(&nk.last_change, time(NULL));
         nk.uk1 = 0;
 …
         /* Push the security descriptor to a blob */
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf, NULL,
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf,
                                      sd, (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
                 DEBUG(0, ("Unable to push security descriptor\n"));
 …
                                                regf->header->data_offset);
         error = regf_save_hbin(regf);
+        error = regf_save_hbin(regf, 1);
         if (!W_ERROR_IS_OK(error)) {
                 return error;
 …
         /* We can drop our own reference now that *key will have created one */
         talloc_free(regf);
+        talloc_unlink(NULL, regf);
         return WERR_OK;
+}
+static WERROR regf_flush_key(struct hive_key *key)
+{
+        struct regf_key_data *private_data = (struct regf_key_data *)key;
+        struct regf_data *regf = private_data->hive;
+        WERROR error;
+        error = regf_save_hbin(regf, 1);
+        if (!W_ERROR_IS_OK(error)) {
+                DEBUG(0, ("Failed to flush regf to disk\n"));
+                return error;
+        }
+        return WERR_OK;
+}
+static int regf_destruct(struct regf_data *regf)
+{
+        WERROR error;
+        /* Write to disk */
+        error = regf_save_hbin(regf, 1);
+        if (!W_ERROR_IS_OK(error)) {
+                DEBUG(0, ("Failed to flush registry to disk\n"));
+                return -1;
+        }
+        /* Close file descriptor */
+        close(regf->fd);
+        return 0;
+}
 WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx, const char *location,
                           struct smb_iconv_convenience *iconv_convenience, struct hive_key **key)
+                          struct hive_key **key)
+{
         struct regf_data *regf;
         struct regf_hdr *regf_hdr;
         struct tdr_pull *pull;
         int i;
+        unsigned int i;
         regf = (struct regf_data *)talloc_zero(parent_ctx, struct regf_data);
-        regf->iconv_convenience = iconv_convenience;
         W_ERROR_HAVE_NO_MEMORY(regf);
+        talloc_set_destructor(regf, regf_destruct);
         DEBUG(5, ("Attempting to load registry file\n"));
 …
+        }
         pull = tdr_pull_init(regf, regf->iconv_convenience);
+        pull = tdr_pull_init(regf);
         pull->data.data = (uint8_t*)fd_load(regf->fd, &pull->data.length, 0, regf);
 …
         .del_key = regf_del_key,
         .delete_value = regf_del_value,
+        .flush_key = regf_flush_key
 };

trunk/server/source4/lib/registry/regf.idl

-              r414
+              r745
         [noprint] struct regf_version {
                 [value(1)] uint32 major;
                 [value(3)] uint32 minor;
+                uint32 minor;
                 [value(0)] uint32 release;
                 [value(1)] uint32 build;
 …
         [noprint] enum reg_key_type {
                 REG_ROOT_KEY = 0x20,
                 REG_SUB_KEY  = 0x2C,
+                REG_ROOT_KEY = 0x2C,
+                REG_SUB_KEY  = 0x20,
                 REG_SYM_LINK = 0x10
         };

trunk/server/source4/lib/registry/registry.h

-              r414
+              r745
 struct registry_context;
 struct loadparm_context;
-struct smb_iconv_convenience;
 #include <talloc.h>
 …
          */
         WERROR (*add_key) (TALLOC_CTX *ctx,
                            const struct hive_key *parent_key, const char *name,
+                           const struct hive_key *parent_key, const char *path,
                            const char *classname,
                            struct security_descriptor *desc,
 …
          * Remove an existing key.
          */
+        WERROR (*del_key) (const struct hive_key *key, const char *name);
+        WERROR (*del_key) (TALLOC_CTX *mem_ctx,
+                           const struct hive_key *key, const char *name);
         /**
 …
          */
         WERROR (*enum_value) (TALLOC_CTX *mem_ctx,
                               struct hive_key *key, int idx,
+                              struct hive_key *key, uint32_t idx,
                               const char **name, uint32_t *type,
                               DATA_BLOB *data);
 …
          * Remove a value.
          */
+        WERROR (*delete_value) (struct hive_key *key, const char *name);
+        WERROR (*delete_value) (TALLOC_CTX *mem_ctx,
+                                struct hive_key *key, const char *name);
         /* Security Descriptors */
 …
                          struct security_descriptor *desc,
                          struct hive_key **key);
+WERROR hive_key_del(const struct hive_key *key, const char *name);
+WERROR hive_key_del(TALLOC_CTX *mem_ctx,
+                    const struct hive_key *key, const char *name);
 WERROR hive_get_key_by_name(TALLOC_CTX *mem_ctx,
                             const struct hive_key *key, const char *name,
 …
                          const struct security_descriptor *security);
+WERROR hive_key_del_value(struct hive_key *key, const char *name);
+WERROR hive_key_del_value(TALLOC_CTX *mem_ctx,
+                          struct hive_key *key, const char *name);
 WERROR hive_key_flush(struct hive_key *key);
 …
                           const char *location, struct hive_key **key);
 WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
+                          const char *location, struct smb_iconv_convenience *iconv_convenience,
+                          struct hive_key **key);
+                          const char *location, struct hive_key **key);
 WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
                          struct auth_session_info *session_info,
 …
                             const char *location, struct hive_key **key);
 WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
-                            struct smb_iconv_convenience *iconv_convenience,
                             const char *location,
                             int major_version,
 …
                               struct registry_key **key);
+        WERROR (*delete_key) (struct registry_key *key, const char *name);
+        WERROR (*delete_value) (struct registry_key *key, const char *name);
+        WERROR (*delete_key) (TALLOC_CTX *mem_ctx,
+                              struct registry_key *key, const char *name);
+        WERROR (*delete_value) (TALLOC_CTX *mem_ctx,
+                                struct registry_key *key, const char *name);
         WERROR (*enum_key) (TALLOC_CTX *mem_ctx,
 …
 WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
                                    const struct registry_key *key,
                                    int idx,
+                                   uint32_t idx,
                                    const char **name,
                                    const char **classname,
 …
                                  uint32_t *type,
                                  DATA_BLOB *data);
+WERROR reg_key_del(struct registry_key *parent, const char *name);
+WERROR reg_key_del(TALLOC_CTX *mem_ctx,
+                   struct registry_key *parent, const char *name);
 WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
                         struct registry_key *parent, const char *name,
 …
 WERROR reg_get_sec_desc(TALLOC_CTX *ctx, const struct registry_key *key,
                         struct security_descriptor **secdesc);
+WERROR reg_del_value(struct registry_key *key, const char *valname);
+WERROR reg_del_value(TALLOC_CTX *mem_ctx,
+                     struct registry_key *key, const char *valname);
 WERROR reg_key_flush(struct registry_key *key);
 WERROR reg_create_key(TALLOC_CTX *mem_ctx,
 …
 /* Utility functions */
 const char *str_regtype(int type);
+char *reg_val_data_string(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t type, const DATA_BLOB data);
+char *reg_val_description(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *name,
+bool push_reg_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *s);
+bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char **a);
+bool pull_reg_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char **s);
+bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char ***a);
+int regtype_by_string(const char *str);
+char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type, const DATA_BLOB data);
+char *reg_val_description(TALLOC_CTX *mem_ctx, const char *name,
                           uint32_t type, const DATA_BLOB data);
 bool reg_string_to_val(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *type_str,
+bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
                        const char *data_str, uint32_t *type, DATA_BLOB *data);
 WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,
 …
 WERROR reg_diff_apply(struct registry_context *ctx,
                                           struct smb_iconv_convenience *ic, const char *filename);
+                                          const char *filename);
 WERROR reg_generate_diff(struct registry_context *ctx1,
 …
                          void *callback_data);
 WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
-                            struct smb_iconv_convenience *iconv_convenience,
                             struct reg_diff_callbacks **callbacks,
                             void **callback_data);
 WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
-                          struct smb_iconv_convenience *ic,
                           struct reg_diff_callbacks **callbacks,
                           void **callback_data);
 …
                              void *callback_data);
 WERROR reg_diff_load(const char *filename,
-                     struct smb_iconv_convenience *iconv_convenience,
                      const struct reg_diff_callbacks *callbacks,
                      void *callback_data);
 WERROR reg_dotreg_diff_load(int fd,
-                                     struct smb_iconv_convenience *iconv_convenience,
                                      const struct reg_diff_callbacks *callbacks,
                                      void *callback_data);
 WERROR reg_preg_diff_load(int fd,
-                   struct smb_iconv_convenience *iconv_convenience,
                                    const struct reg_diff_callbacks *callbacks,
                                    void *callback_data);

trunk/server/source4/lib/registry/registry.pc.in

-              r414
+              r745
 Requires: talloc
 Requires.private: ldb
 Version: 0.0.1
 Libs: -L${libdir} -lregistry
+Version: @PACKAGE_VERSION@
+Libs: @LIB_RPATH@ -L${libdir} -lregistry
 Cflags: -I${includedir}  -DHAVE_IMMEDIATE_STRUCTURES=1

trunk/server/source4/lib/registry/rpc.c

-              r414
+              r745
         struct registry_key key;
         struct policy_handle pol;
+        struct dcerpc_pipe *pipe;
+        struct dcerpc_binding_handle *binding_handle;
         const char* classname;
         uint32_t num_subkeys;
 …
         struct registry_context context;
         struct dcerpc_pipe *pipe;
+        struct dcerpc_binding_handle *binding_handle;
 };
 …
  */
 #define openhive(u) static WERROR open_ ## u(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
+#define openhive(u) static WERROR open_ ## u(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
 { \
         struct winreg_Open ## u r; \
 …
         r.out.handle = hnd;\
+\
         status = dcerpc_winreg_Open ## u(p, mem_ctx, &r); \
+        status = dcerpc_winreg_Open ## u ## _r(b, mem_ctx, &r); \
+\
         if (!NT_STATUS_IS_OK(status)) { \
 …
 static struct {
         uint32_t hkey;
         WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *,
+        WERROR (*open) (struct dcerpc_binding_handle *b, TALLOC_CTX *,
                         struct policy_handle *h);
 } known_hives[] = {
 …
         mykeydata = talloc_zero(ctx, struct rpc_key);
+        W_ERROR_HAVE_NO_MEMORY(mykeydata);
         mykeydata->key.context = ctx;
         mykeydata->pipe = talloc_reference(mykeydata, rctx->pipe);
+        mykeydata->binding_handle = rctx->binding_handle;
         mykeydata->num_values = -1;
         mykeydata->num_subkeys = -1;
         *k = (struct registry_key *)mykeydata;
         return known_hives[n].open(mykeydata->pipe, mykeydata, &(mykeydata->pol));
+        return known_hives[n].open(mykeydata->binding_handle, mykeydata, &mykeydata->pol);
+}
 …
         mykeydata = talloc_zero(mem_ctx, struct rpc_key);
+        W_ERROR_HAVE_NO_MEMORY(mykeydata);
         mykeydata->key.context = parentkeydata->key.context;
         mykeydata->pipe = talloc_reference(mykeydata, parentkeydata->pipe);
+        mykeydata->binding_handle = parentkeydata->binding_handle;
         mykeydata->num_values = -1;
         mykeydata->num_subkeys = -1;
 …
         r.in.parent_handle = &parentkeydata->pol;
         r.in.keyname.name = name;
         r.in.unknown = 0x00000000;
+        r.in.options = 0x00000000;
         r.in.access_mask = 0x02000000;
         r.out.handle = &mykeydata->pol;
         status = dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_OpenKey_r(mykeydata->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
 …
         r.in.enum_index = n;
         r.in.name = &name;
         r.in.type = type;
+        r.in.type = (enum winreg_Type *) type;
         r.in.value = &value;
         r.in.size = &val_size;
         r.in.length = &zero;
         r.out.name = &name;
         r.out.type = type;
+        r.out.type = (enum winreg_Type *) type;
         r.out.value = &value;
         r.out.size = &val_size;
         r.out.length = &zero;
         status = dcerpc_winreg_EnumValue(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_EnumValue_r(mykeydata->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
 …
+        }
         *value_name = talloc_reference(mem_ctx, r.out.name->name);
+        *value_name = talloc_steal(mem_ctx, r.out.name->name);
         *type = *(r.out.type);
         *data = data_blob_talloc(mem_ctx, r.out.value, *r.out.length);
 …
         r.in.handle = &mykeydata->pol;
         r.in.value_name = &name;
         r.in.type = type;
+        r.in.type = (enum winreg_Type *) type;
         r.in.data = &value;
         r.in.data_size = &val_size;
         r.in.data_length = &zero;
         r.out.type = type;
+        r.out.type = (enum winreg_Type *) type;
         r.out.data = &value;
         r.out.data_size = &val_size;
         r.out.data_length = &zero;
         status = dcerpc_winreg_QueryValue(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_QueryValue_r(mykeydata->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
 …
         r.out.last_changed_time = &change_time;
         status = dcerpc_winreg_EnumKey(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_EnumKey_r(mykeydata->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
 …
         if (name != NULL)
                 *name = talloc_reference(mem_ctx, r.out.name->name);
+                *name = talloc_steal(mem_ctx, r.out.name->name);
         if (keyclass != NULL)
                 *keyclass = talloc_reference(mem_ctx, r.out.keyclass->name);
+                *keyclass = talloc_steal(mem_ctx, r.out.keyclass->name);
         if (last_changed_time != NULL)
                 *last_changed_time = *(r.out.last_changed_time);
 …
 static WERROR rpc_add_key(TALLOC_CTX *mem_ctx,
                           struct registry_key *parent, const char *name,
+                          struct registry_key *parent, const char *path,
                           const char *key_class,
                           struct security_descriptor *sec,
 …
         ZERO_STRUCT(r);
         r.in.handle = &parentkd->pol;
         r.in.name.name = name;
+        r.in.name.name = path;
         r.in.keyclass.name = NULL;
         r.in.options = 0;
 …
         r.out.action_taken = NULL;
         status = dcerpc_winreg_CreateKey(parentkd->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_CreateKey_r(parentkd->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
 …
+        }
         rpck->pipe = talloc_reference(rpck, parentkd->pipe);
+        rpck->binding_handle = parentkd->binding_handle;
         *key = (struct registry_key *)rpck;
 …
         r.out.last_changed_time = &mykeydata->last_changed_time;
         status = dcerpc_winreg_QueryInfoKey(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_QueryInfoKey_r(mykeydata->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
 …
+        }
+        mykeydata->classname = talloc_reference(mem_ctx, r.out.classname->name);
+        return r.out.result;
+}
+static WERROR rpc_del_key(struct registry_key *parent, const char *name)
+        mykeydata->classname = talloc_steal(mem_ctx, r.out.classname->name);
+        return r.out.result;
+}
+static WERROR rpc_del_key(TALLOC_CTX *mem_ctx, struct registry_key *parent,
+                          const char *name)
+{
         NTSTATUS status;
         struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
         struct winreg_DeleteKey r;
-        TALLOC_CTX *mem_ctx = talloc_init("del_key");
         ZERO_STRUCT(r);
 …
         r.in.key.name = name;
+        status = dcerpc_winreg_DeleteKey(mykeydata->pipe, mem_ctx, &r);
+        talloc_free(mem_ctx);
+        status = dcerpc_winreg_DeleteKey_r(mykeydata->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
 …
         .delete_key = rpc_del_key,
         .get_key_info = rpc_get_info,
-        .get_predefined_key = rpc_get_predefined_key,
 };
 …
         rctx = talloc(NULL, struct rpc_registry_context);
+        W_ERROR_HAVE_NO_MEMORY(rctx);
         /* Default to local smbd if no connection is specified */
 …
         status = dcerpc_pipe_connect(rctx /* TALLOC_CTX */,
                                      &p, location,
                                          &ndr_table_winreg,
+                                     &ndr_table_winreg,
                                      credentials, ev, lp_ctx);
-        rctx->pipe = p;
         if(NT_STATUS_IS_ERR(status)) {
                 DEBUG(1, ("Unable to open '%s': %s\n", location,
 …
+        }
+        rctx->pipe = p;
+        rctx->binding_handle = p->binding_handle;
         *ctx = (struct registry_context *)rctx;
         (*ctx)->ops = &reg_backend_rpc;

trunk/server/source4/lib/registry/samba.c

-              r414
+              r745
         location = talloc_asprintf(ctx, "%s/%s.ldb",
                                    lp_private_dir(lp_ctx),
+                                   lpcfg_private_dir(lp_ctx),
                                    name);
+        W_ERROR_HAVE_NO_MEMORY(location);
         error = reg_open_hive(ctx, location, auth_info, creds, event_ctx, lp_ctx, &hive);
 …
                 error = reg_open_ldb_file(ctx, location, auth_info,
                                           creds, event_ctx, lp_ctx, &hive);
+        talloc_free(discard_const_p(char, location));
         if (!W_ERROR_IS_OK(error))

trunk/server/source4/lib/registry/tests/diff.c

-              r414
+              r745
+{
         struct diff_tcase_data *td = tcase_data;
-        struct smb_iconv_convenience *ic;
         struct reg_diff_callbacks *callbacks;
         void *data;
         WERROR error;
+        ic = lp_iconv_convenience(tctx->lp_ctx);
+        error = reg_diff_load(td->filename, iconv_convenience, callbacks, data);
+        error = reg_diff_load(td->filename, callbacks, data);
         torture_assert_werr_ok(tctx, error, "reg_diff_load");
 …
         WERROR error;
         error = reg_diff_apply(td->r1_ctx, lp_iconv_convenience(tctx->lp_ctx), td->filename);
+        error = reg_diff_apply(td->r1_ctx, td->filename);
         torture_assert_werr_ok(tctx, error, "reg_diff_apply");
 …
         torture_assert_werr_ok(tctx, error, "Creating HKLM\\..\\Policies\\Explorer failed");
+        blob.data = (void *)talloc(r2_ctx, uint32_t);
+        SIVAL(blob.data, 0, 0x03ffffff);
+        blob.length = sizeof(uint32_t);
+        blob.data = talloc_array(r2_ctx, uint8_t, 4);
+        /* set "0x03FFFFFF" in little endian format */
+        blob.data[0] = 0xFF; blob.data[1] = 0xFF;
+        blob.data[2] = 0xFF; blob.data[3] = 0x03;
+        blob.length = 4;
         r1_ctx->ops->set_value(newkey, "NoDrives", REG_DWORD, blob);
 …
+{
         struct diff_tcase_data *td;
-        struct smb_iconv_convenience *ic;
         WERROR error;
 …
         td = *data;
-        ic = lp_iconv_convenience(tctx->lp_ctx);
         td->filename = talloc_asprintf(tctx, "%s/test.pol", td->tempdir);
+        error = reg_preg_diff_save(tctx, td->filename, ic, &td->callbacks, &td->callback_data);
+        error = reg_preg_diff_save(tctx, td->filename,  &td->callbacks,
+                                                           &td->callback_data);
         torture_assert_werr_ok(tctx, error, "reg_preg_diff_save");
 …
+{
         struct diff_tcase_data *td;
-        struct smb_iconv_convenience *ic;
         WERROR error;
 …
         td = *data;
-        ic = lp_iconv_convenience(tctx->lp_ctx);
         td->filename = talloc_asprintf(tctx, "%s/test.reg", td->tempdir);
+        error = reg_dotreg_diff_save(tctx, td->filename, ic, &td->callbacks, &td->callback_data);
+        error = reg_dotreg_diff_save(tctx, td->filename, &td->callbacks,
+                                                                 &td->callback_data);
         torture_assert_werr_ok(tctx, error, "reg_dotreg_diff_save");
 …
+{
         struct torture_tcase *tcase;
         struct torture_suite *suite = torture_suite_create(mem_ctx, "DIFF");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "diff");
         tcase = torture_suite_add_tcase(suite, "PReg");

trunk/server/source4/lib/registry/tests/generic.c

-              r414
+              r745
 static bool test_str_regtype(struct torture_context *ctx)
+{
+        torture_assert_str_equal(ctx, str_regtype(0),
+                                 "REG_NONE", "REG_NONE failed");
         torture_assert_str_equal(ctx, str_regtype(1),
                                  "REG_SZ", "REG_SZ failed");
+        torture_assert_str_equal(ctx, str_regtype(2),
+                                 "REG_EXPAND_SZ", "REG_EXPAND_SZ failed");
+        torture_assert_str_equal(ctx, str_regtype(3),
+                                 "REG_BINARY", "REG_BINARY failed");
         torture_assert_str_equal(ctx, str_regtype(4),
                                  "REG_DWORD", "REG_DWORD failed");
+        torture_assert_str_equal(ctx, str_regtype(5),
+                                 "REG_DWORD_BIG_ENDIAN", "REG_DWORD_BIG_ENDIAN failed");
+        torture_assert_str_equal(ctx, str_regtype(6),
+                                 "REG_LINK", "REG_LINK failed");
+        torture_assert_str_equal(ctx, str_regtype(7),
+                                 "REG_MULTI_SZ", "REG_MULTI_SZ failed");
+        torture_assert_str_equal(ctx, str_regtype(8),
+                                 "REG_RESOURCE_LIST", "REG_RESOURCE_LIST failed");
+        torture_assert_str_equal(ctx, str_regtype(9),
+                                 "REG_FULL_RESOURCE_DESCRIPTOR", "REG_FULL_RESOURCE_DESCRIPTOR failed");
+        torture_assert_str_equal(ctx, str_regtype(10),
+                                 "REG_RESOURCE_REQUIREMENTS_LIST", "REG_RESOURCE_REQUIREMENTS_LIST failed");
+        torture_assert_str_equal(ctx, str_regtype(11),
+                                 "REG_QWORD", "REG_QWORD failed");
         return true;
 …
 static bool test_reg_val_data_string_dword(struct torture_context *ctx)
+{
         uint32_t d = 0x20;
         DATA_BLOB db = { (uint8_t *)&d, sizeof(d) };
         torture_assert_str_equal(ctx, "0x20",
                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_DWORD, db),
+        uint8_t d[] = { 0x20, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
+        torture_assert_str_equal(ctx, "0x00000020",
+                                 reg_val_data_string(ctx, REG_DWORD, db),
                                  "dword failed");
+        return true;
+}
+static bool test_reg_val_data_string_dword_big_endian(struct torture_context *ctx)
+{
+        uint8_t d[] = { 0x20, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
+        torture_assert_str_equal(ctx, "0x00000020",
+                                 reg_val_data_string(ctx, REG_DWORD_BIG_ENDIAN, db),
+                                 "dword failed");
+        return true;
+}
+static bool test_reg_val_data_string_qword(struct torture_context *ctx)
+{
+        uint8_t d[] = { 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 8 };
+        torture_assert_str_equal(ctx, "0x0000000000000020",
+                                 reg_val_data_string(ctx, REG_QWORD, db),
+                                 "qword failed");
         return true;
+}
 …
+{
         DATA_BLOB db;
         convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
+        convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
                                           "bla", 3, (void **)&db.data, &db.length, false);
         torture_assert_str_equal(ctx, "bla",
                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
+                                 reg_val_data_string(ctx, REG_SZ, db),
                                  "sz failed");
         db.length = 4;
         torture_assert_str_equal(ctx, "bl",
                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
+                                 reg_val_data_string(ctx, REG_SZ, db),
                                  "sz failed");
         return true;
 …
         DATA_BLOB db = { x, 4 };
         torture_assert_str_equal(ctx, "01020304",
                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
+                                 reg_val_data_string(ctx, REG_BINARY, db),
                                  "binary failed");
         return true;
 …
         DATA_BLOB db = { NULL, 0 };
         torture_assert_str_equal(ctx, "",
                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
+                                 reg_val_data_string(ctx, REG_BINARY, db),
                                  "empty failed");
         return true;
 …
+{
         DATA_BLOB data;
         convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
+        convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
                                             "stationary traveller",
                                             strlen("stationary traveller"),
                                             (void **)&data.data, &data.length, false);
         torture_assert_str_equal(ctx, "camel = REG_SZ : stationary traveller",
                                  reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), "camel", REG_SZ, data),
+                                 reg_val_description(ctx, "camel", REG_SZ, data),
                                  "reg_val_description failed");
         return true;
 …
+{
         DATA_BLOB data;
         convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
+        convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
                                             "west berlin",
                                             strlen("west berlin"),
                                             (void **)&data.data, &data.length, false);
         torture_assert_str_equal(ctx, "<No Name> = REG_SZ : west berlin",
                                  reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), NULL, REG_SZ, data),
+                                 reg_val_description(ctx, NULL, REG_SZ, data),
                                  "description with null name failed");
         return true;
 …
 struct torture_suite *torture_registry(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "REGISTRY");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "registry");
         torture_suite_add_simple_test(suite, "str_regtype",
                                       test_str_regtype);
         torture_suite_add_simple_test(suite, "reg_val_data_string dword",
                                       test_reg_val_data_string_dword);
+        torture_suite_add_simple_test(suite, "reg_val_data_string dword_big_endian",
+                                      test_reg_val_data_string_dword_big_endian);
+        torture_suite_add_simple_test(suite, "reg_val_data_string qword",
+                                      test_reg_val_data_string_qword);
         torture_suite_add_simple_test(suite, "reg_val_data_string sz",
                                       test_reg_val_data_string_sz);

trunk/server/source4/lib/registry/tests/hive.c

-              r414
+              r745
+{
         const struct hive_key *root = (const struct hive_key *)test_data;
         WERROR error = hive_key_del(root, "bla");
+        WERROR error = hive_key_del(tctx, root, "bla");
         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                   "invalid return code");
 …
         WERROR error;
         struct hive_key *subkey;
         char data[4];
         SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
         error = hive_key_add_name(tctx, root, "Nested Keyll", NULL,
 …
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
+        error = hive_key_set_value(root, "Answer", REG_DWORD,
+                               data_blob_talloc(tctx, data, sizeof(data)));
+        error = hive_key_set_value(root, "Answer", REG_DWORD, db);
         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 …
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
         error = hive_key_del(root, "Nested Key");
+        error = hive_key_del(mem_ctx, root, "Nested Key");
         torture_assert_werr_ok(tctx, error, "reg_key_del");
 …
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
         char data[4];
         SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
         /* Create a new key under the root */
 …
         /* Create a new value under "Child Key" */
+        error = hive_key_set_value(subkey2, "Answer Recursive", REG_DWORD,
+                               data_blob_talloc(mem_ctx, data, sizeof(data)));
+        error = hive_key_set_value(subkey2, "Answer Recursive", REG_DWORD, db);
         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
         /* Deleting "Parent Key" will also delete "Child Key" and the value. */
         error = hive_key_del(root, "Parent Key");
+        error = hive_key_del(mem_ctx, root, "Parent Key");
         torture_assert_werr_ok(tctx, error, "hive_key_del");
 …
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
         error = hive_key_del(root, "Nested Key");
+        error = hive_key_del(mem_ctx, root, "Nested Key");
         torture_assert_werr_ok(tctx, error, "reg_key_del");
         error = hive_key_del(root, "Nested Key");
+        error = hive_key_del(mem_ctx, root, "Nested Key");
         torture_assert_werr_equal(tctx, error, WERR_BADFILE, "reg_key_del");
 …
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
         char data[4];
         SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
         error = hive_key_add_name(mem_ctx, root, "YA Nested Key", NULL,
 …
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD,
+                               data_blob_talloc(mem_ctx, data, sizeof(data)));
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 …
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
-        char data[4];
         uint32_t type;
+        DATA_BLOB value;
+        SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 }, data;
         error = hive_key_add_name(mem_ctx, root, "EYA Nested Key", NULL,
 …
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
         error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
+        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data);
         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                   "getting missing value");
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD,
+                               data_blob_talloc(mem_ctx, data, sizeof(data)));
+        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
+        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
+        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
+        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data);
         torture_assert_werr_ok(tctx, error, "getting value");
         torture_assert_int_equal(tctx, value.length, 4, "value length");
+        torture_assert_int_equal(tctx, data.length, 4, "value length");
         torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
+        torture_assert_mem_equal(tctx, &data, value.data, sizeof(uint32_t),
+                                 "value data");
+        torture_assert_mem_equal(tctx, data.data, db.data, 4, "value data");
         return true;
 …
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
-        char data[4];
         uint32_t type;
+        DATA_BLOB value;
+        SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
         error = hive_key_add_name(mem_ctx, root, "EEYA Nested Key", NULL,
 …
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD,
+                               data_blob_talloc(mem_ctx, data, sizeof(data)));
+        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
+        error = hive_key_del_value(subkey, "Answer");
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
+        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
+        error = hive_key_del_value(mem_ctx, subkey, "Answer");
         torture_assert_werr_ok(tctx, error, "deleting value");
         error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
+        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &db);
         torture_assert_werr_equal(tctx, error, WERR_BADFILE, "getting value");
         error = hive_key_del_value(subkey, "Answer");
+        error = hive_key_del_value(mem_ctx, subkey, "Answer");
         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                   "deleting value");
 …
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
-        char data[4];
         uint32_t type;
+        DATA_BLOB value;
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 }, data;
         const char *name;
-        int data_val = 42;
-        SIVAL(data, 0, data_val);
         error = hive_key_add_name(mem_ctx, root, "AYAYA Nested Key", NULL,
 …
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD,
+                               data_blob_talloc(mem_ctx, data, sizeof(data)));
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
         error = hive_get_value_by_index(mem_ctx, subkey, 0, &name,
                                         &type, &value);
+                                        &type, &data);
         torture_assert_werr_ok(tctx, error, "getting value");
         torture_assert_str_equal(tctx, name, "Answer", "value name");
         torture_assert_int_equal(tctx, value.length, 4, "value length");
+        torture_assert_int_equal(tctx, data.length, 4, "value length");
         torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
+        torture_assert_mem_equal(tctx, data.data, db.data, 4, "value data");
-        torture_assert_int_equal(tctx, data_val, IVAL(value.data, 0), "value data");
         error = hive_get_value_by_index(mem_ctx, subkey, 1, &name,
                                         &type, &value);
+                                        &type, &data);
         torture_assert_werr_equal(tctx, error, WERR_NO_MORE_ITEMS,
                                   "getting missing value");
 …
         rmdir(dirname);
+        error = reg_create_regf_file(tctx, lp_iconv_convenience(tctx->lp_ctx),
+                                     dirname, 5, &key);
+        error = reg_create_regf_file(tctx, dirname, 5, &key);
         if (!W_ERROR_IS_OK(error)) {
                 fprintf(stderr, "Unable to create new regf file\n");
 …
+{
         struct torture_tcase *tcase;
         struct torture_suite *suite = torture_suite_create(mem_ctx, "HIVE");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "hive");
         torture_suite_add_simple_test(suite, "dir-refuses-null-location",

trunk/server/source4/lib/registry/tests/registry.c

-              r414
+              r745
+{
         struct registry_context *rctx = (struct registry_context *)_data;
         struct registry_key *root, *newkey1, *newkey2;
+        struct registry_key *root, *newkey;
         WERROR error;
 …
                                "getting predefined key failed");
         error = reg_key_add_name(rctx, root, "Hamburg", NULL, NULL,
                                  &newkey1);
+        error = reg_key_add_name(rctx, root, "Hamburg\\Hamburg", NULL, NULL,
+                                 &newkey);
         torture_assert_werr_ok(tctx, error, "Creating key return code");
+        torture_assert(tctx, newkey1 != NULL, "Creating new key");
+        error = reg_key_add_name(rctx, root, "Hamburg\\Hamburg", NULL, NULL,
+                                 &newkey2);
+        torture_assert_werr_ok(tctx, error, "Creating key return code");
+        torture_assert(tctx, newkey2 != NULL, "Creating new key");
+        torture_assert(tctx, newkey != NULL, "Creating new key");
         return true;
 …
         torture_assert(tctx, newkey != NULL, "Creating new key");
         error = reg_key_del(root, "Polen");
+        error = reg_key_del(tctx, root, "Polen");
         torture_assert_werr_ok(tctx, error, "Delete key");
         error = reg_key_del(root, "Polen");
+        error = reg_key_del(tctx, root, "Polen");
         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                   "Delete missing key");
 …
         torture_assert_werr_ok (tctx, error, "setting value");
         error = reg_del_value(subkey, __FUNCTION__);
+        error = reg_del_value(tctx, subkey, __FUNCTION__);
         torture_assert_werr_ok (tctx, error, "unsetting value");
 …
+{
         struct torture_tcase *tcase;
         struct torture_suite *suite = torture_suite_create(mem_ctx, "REGISTRY");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "registry");
         tcase = torture_suite_add_tcase(suite, "local");

trunk/server/source4/lib/registry/tools/regdiff.c

-              r414
+              r745
         poptFreeContext(pc);
+        error = reg_dotreg_diff_save(ctx, outputfile, lp_iconv_convenience(cmdline_lp_ctx), &callbacks,
+                                     &callback_data);
+        error = reg_dotreg_diff_save(ctx, outputfile, &callbacks, &callback_data);
         if (!W_ERROR_IS_OK(error)) {
                 fprintf(stderr, "Problem saving registry diff to '%s': %s\n",

trunk/server/source4/lib/registry/tools/regpatch.c

r414	r745
69	69	poptFreeContext(pc);
70	70
71		reg_diff_apply(h, ~~lp_iconv_convenience(cmdline_lp_ctx),~~ patch);
	71	reg_diff_apply(h, patch);
72	72
73	73	return 0;

trunk/server/source4/lib/registry/tools/regshell.c

-              r414
+              r745
 #include "lib/events/events.h"
 #include "system/time.h"
 #include "lib/smbreadline/smbreadline.h"
+#include "../libcli/smbreadline/smbreadline.h"
 #include "librpc/gen_ndr/ndr_security.h"
 #include "lib/registry/tools/common.h"
 …
                 printf("Key Class: %s\n", classname);
         last_mod = nt_time_to_unix(last_change);
         printf("Time Last Modified: %s\n", ctime(&last_mod));
+        printf("Time Last Modified: %s", ctime(&last_mod));
         printf("Number of subkeys: %d\n", num_subkeys);
         printf("Number of values: %d\n", num_values);
 …
         error = reg_get_sec_desc(ctx, ctx->current, &sec_desc);
         if (!W_ERROR_IS_OK(error)) {
                 printf("Error getting security descriptor\n");
                 return error;
+                printf("Error getting security descriptor: %s\n", win_errstr(error));
+                return WERR_OK;
+        }
         ndr_print_debug((ndr_print_fn_t)ndr_print_security_descriptor,
 …
+        }
+        if (!reg_string_to_val(ctx, lp_iconv_convenience(cmdline_lp_ctx),
+                               argv[2], argv[3], &val.data_type,
+                               &val.data)) {
+        if (!reg_string_to_val(ctx, argv[2], argv[3], &val.data_type, &val.data)) {
                 fprintf(stderr, "Unable to interpret data\n");
                 return WERR_INVALID_PARAM;
 …
         printf("%s\n%s\n", str_regtype(value_type),
                    reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), value_type, value_data));
+                   reg_val_data_string(ctx, value_type, value_data));
         return WERR_OK;
 …
 static WERROR cmd_ls(struct regshell_context *ctx, int argc, char **argv)
+{
         int i;
+        unsigned int i;
         WERROR error;
         uint32_t valuetype;
 …
         if (!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
                 fprintf(stderr, "Error occured while browsing thru keys: %s\n",
+                fprintf(stderr, "Error occurred while browsing through keys: %s\n",
                         win_errstr(error));
                 return error;
 …
                 ctx->current, i, &name, &valuetype, &valuedata)); i++)
                 printf("V \"%s\" %s %s\n", name, str_regtype(valuetype),
                            reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), valuetype, valuedata));
+                           reg_val_data_string(ctx, valuetype, valuedata));
         return WERR_OK;
 …
+        }
         error = reg_key_del(ctx->current, argv[1]);
+        error = reg_key_del(ctx, ctx->current, argv[1]);
         if(!W_ERROR_IS_OK(error)) {
                 fprintf(stderr, "Error deleting '%s'\n", argv[1]);
 …
+        }
         error = reg_del_value(ctx->current, argv[1]);
+        error = reg_del_value(ctx, ctx->current, argv[1]);
         if(!W_ERROR_IS_OK(error)) {
                 fprintf(stderr, "Error deleting value '%s'\n", argv[1]);
 …
                        int argc, char **argv)
+{
         int i;
+        unsigned int i;
         printf("Available commands:\n");
         for(i = 0; regshell_cmds[i].name; i++) {
 …
         /* Complete command */
         char **matches;
+        int i, len, samelen=0, count=1;
+        size_t len, samelen=0;
+        unsigned int i, count=1;
         matches = malloc_array_p(char *, MAX_COMPLETIONS);
 …
         struct registry_key *base;
         const char *subkeyname;
+        int i, j = 1;
+        int samelen = 0;
+        int len;
+        unsigned int i, j = 1;
+        size_t len, samelen = 0;
         char **matches;
         const char *base_n = "";
 …
         if (ctx->current == NULL) {
                 int i;
+                unsigned int i;
                 for (i = 0; (reg_predefined_keys[i].handle != 0) &&
 …
         if (ctx->current == NULL) {
                 fprintf(stderr, "Unable to access any of the predefined keys\n");
                 return -1;
+                return 1;
+        }
 …
                 char *line, *prompt;
+                asprintf(&prompt, "%s\\%s> ", ctx->predef?ctx->predef:"", ctx->path);
+                if (asprintf(&prompt, "%s\\%s> ", ctx->predef?ctx->predef:"",
+                             ctx->path) < 0) {
+                        ret = false;
+                        break;
+                }
                 current_key = ctx->current;             /* No way to pass a void * pointer

trunk/server/source4/lib/registry/tools/regtree.c

-              r414
+              r745
  * @param novals Whether values should not be printed
  */
 static void print_tree(int level, struct registry_key *p,
+static void print_tree(unsigned int level, struct registry_key *p,
                        const char *name,
                        bool fullpath, bool novals)
 …
         struct security_descriptor *sec_desc;
         WERROR error;
         int i;
+        unsigned int i;
         TALLOC_CTX *mem_ctx;
 …
         if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
                 DEBUG(0, ("Error occured while fetching subkeys for '%s': %s\n",
+                DEBUG(0, ("Error occurred while fetching subkeys for '%s': %s\n",
                                   name, win_errstr(error)));
+        }
 …
                         mem_ctx, p, i, &valuename, &valuetype, &valuedata));
                         i++) {
                         int j;
+                        unsigned int j;
                         for(j = 0; j < level+1; j++) putchar(' ');
                         printf("%s\n",  reg_val_description(mem_ctx,
+                                lp_iconv_convenience(cmdline_lp_ctx), valuename,
+                                valuetype, valuedata));
+                                valuename, valuetype, valuedata));
+                }
                 talloc_free(mem_ctx);
                 if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
                         DEBUG(0, ("Error occured while fetching values for '%s': %s\n",
+                        DEBUG(0, ("Error occurred while fetching values for '%s': %s\n",
                                 name, win_errstr(error)));
+                }
 …
 int main(int argc, char **argv)
+{
+        int opt, i;
+        int opt;
+        unsigned int i;
         const char *file = NULL;
         const char *remote = NULL;

trunk/server/source4/lib/registry/util.c

-              r414
+              r745
    Transparent registry backend handling
    Copyright (C) Jelmer Vernooij                        2003-2007.
+   Copyright (C) Wilco Baan Hofman                      2010.
    This program is free software; you can redistribute it and/or modify
 …
 #include "lib/registry/registry.h"
 #include "librpc/gen_ndr/winreg.h"
+/**
+ * @file
+ * @brief Registry utility functions
+ */
+static const struct {
+        uint32_t id;
+        const char *name;
+} reg_value_types[] = {
+        { REG_SZ, "REG_SZ" },
+        { REG_DWORD, "REG_DWORD" },
+        { REG_BINARY, "REG_BINARY" },
+        { REG_EXPAND_SZ, "REG_EXPAND_SZ" },
+        { REG_NONE, "REG_NONE" },
+        { 0, NULL }
+};
+/** Return string description of registry value type */
+_PUBLIC_ const char *str_regtype(int type)
+{
+        int i;
+        for (i = 0; reg_value_types[i].name; i++) {
+                if (reg_value_types[i].id == type)
+                        return reg_value_types[i].name;
+        }
+        return "Unknown";
+}
+_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx,
+                                   struct smb_iconv_convenience *iconv_convenience,
+                                   uint32_t type,
+#include "lib/util/data_blob.h"
+_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
                                    const DATA_BLOB data)
+{
 …
                 case REG_EXPAND_SZ:
                 case REG_SZ:
+                        convert_string_talloc_convenience(mem_ctx, iconv_convenience, CH_UTF16, CH_UNIX,
+                        convert_string_talloc(mem_ctx,
+                                              CH_UTF16, CH_UNIX,
                                               data.data, data.length,
                                               (void **)&ret, NULL, false);
+                        return ret;
+                        break;
+                case REG_DWORD:
+                case REG_DWORD_BIG_ENDIAN:
+                        SMB_ASSERT(data.length == sizeof(uint32_t));
+                        ret = talloc_asprintf(mem_ctx, "0x%8.8x",
+                                              IVAL(data.data, 0));
+                        break;
+                case REG_QWORD:
+                        SMB_ASSERT(data.length == sizeof(uint64_t));
+                        ret = talloc_asprintf(mem_ctx, "0x%16.16llx",
+                                              (long long)BVAL(data.data, 0));
+                        break;
                 case REG_BINARY:
+                        ret = data_blob_hex_string(mem_ctx, &data);
+                        return ret;
+                case REG_DWORD:
+                        if (*(int *)data.data == 0)
+                                return talloc_strdup(mem_ctx, "0");
+                        return talloc_asprintf(mem_ctx, "0x%x",
+                                               *(int *)data.data);
+                        ret = data_blob_hex_string_upper(mem_ctx, &data);
+                        break;
+                case REG_NONE:
+                        /* "NULL" is the right return value */
+                        break;
                 case REG_MULTI_SZ:
+                        /* FIXME: We don't support this yet */
+                        break;
+                default:
                         /* FIXME */
+                        break;
+                default:
+                        /* Other datatypes aren't supported -> return "NULL" */
                         break;
+        }
 …
 /** Generate a string that describes a registry value */
+_PUBLIC_ char *reg_val_description(TALLOC_CTX *mem_ctx,
+                                   struct smb_iconv_convenience *iconv_convenience,
+_PUBLIC_ char *reg_val_description(TALLOC_CTX *mem_ctx,
                                    const char *name,
                                    uint32_t data_type,
 …
         return talloc_asprintf(mem_ctx, "%s = %s : %s", name?name:"<No Name>",
                                str_regtype(data_type),
+                               reg_val_data_string(mem_ctx, iconv_convenience, data_type, data));
+}
+_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx,
+                                struct smb_iconv_convenience *iconv_convenience,
+                                const char *type_str,
+                                const char *data_str, uint32_t *type,
+                                DATA_BLOB *data)
+{
+        int i;
+        *type = -1;
+        /* Find the correct type */
+        for (i = 0; reg_value_types[i].name; i++) {
+                if (!strcmp(reg_value_types[i].name, type_str)) {
+                        *type = reg_value_types[i].id;
+                        break;
+                               reg_val_data_string(mem_ctx, data_type, data));
+}
+/*
+ * This implements reading hex bytes that include comma's.
+ * It was previously handled by strhex_to_data_blob, but that did not cover
+ * the format used by windows.
+ */
+static DATA_BLOB reg_strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *str)
+{
+        DATA_BLOB ret;
+        const char *HEXCHARS = "0123456789ABCDEF";
+        size_t i, j;
+        char *hi, *lo;
+        ret = data_blob_talloc_zero(mem_ctx, (strlen(str)+(strlen(str) % 3))/3);
+        j = 0;
+        for (i = 0; i < strlen(str); i++) {
+                hi = strchr(HEXCHARS, toupper(str[i]));
+                if (hi == NULL)
+                        continue;
+                i++;
+                lo = strchr(HEXCHARS, toupper(str[i]));
+                if (lo == NULL)
+                        break;
+                ret.data[j] = PTR_DIFF(hi, HEXCHARS) << 4;
+                ret.data[j] += PTR_DIFF(lo, HEXCHARS);
+                j++;
+                if (j > ret.length) {
+                        DEBUG(0, ("Trouble converting hex string to bin\n"));
+                        break;
+                }
+        }
+        return ret;
+}
+_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
+                                const char *data_str, uint32_t *type, DATA_BLOB *data)
+{
+        char *tmp_type_str, *p, *q;
+        int result;
+        *type = regtype_by_string(type_str);
+        if (*type == -1) {
+                /* Normal windows format is hex, hex(type int as string),
+                   dword or just a string. */
+                if (strncmp(type_str, "hex(", 4) == 0) {
+                        /* there is a hex string with the value type between
+                           the braces */
+                        tmp_type_str = talloc_strdup(mem_ctx, type_str);
+                        q = p = tmp_type_str + strlen("hex(");
+                        /* Go to the closing brace or end of the string */
+                        while (*q != ')' && *q != '\0') q++;
+                        *q = '\0';
+                        /* Convert hex string to int, store it in type */
+                        result = sscanf(p, "%x", type);
+                        if (!result) {
+                                DEBUG(0, ("Could not convert hex to int\n"));
+                                return false;
+                        }
+                        talloc_free(tmp_type_str);
+                } else if (strcmp(type_str, "hex") == 0) {
+                        *type = REG_BINARY;
+                } else if (strcmp(type_str, "dword") == 0) {
+                        *type = REG_DWORD;
+                }
+        }
 …
         /* Convert data appropriately */
+        switch (*type)
+        {
+        switch (*type) {
                 case REG_SZ:
+                        return convert_string_talloc(mem_ctx,
+                                                     CH_UNIX, CH_UTF16,
+                                                     data_str, strlen(data_str)+1,
+                                                     (void **)&data->data,
+                                                     &data->length, false);
+                        break;
+                case REG_MULTI_SZ:
                 case REG_EXPAND_SZ:
+                convert_string_talloc_convenience(mem_ctx, iconv_convenience, CH_UNIX, CH_UTF16,
+                                                     data_str, strlen(data_str),
+                                                     (void **)&data->data, &data->length, false);
+                        break;
+                case REG_DWORD: {
+                        uint32_t tmp = strtol(data_str, NULL, 0);
+                        *data = data_blob_talloc(mem_ctx, &tmp, 4);
+                case REG_BINARY:
+                        *data = reg_strhex_to_data_blob(mem_ctx, data_str);
+                        break;
+                case REG_DWORD:
+                case REG_DWORD_BIG_ENDIAN: {
+                        uint32_t tmp = strtol(data_str, NULL, 16);
+                        *data = data_blob_talloc(mem_ctx, NULL, sizeof(uint32_t));
+                        if (data->data == NULL) return false;
+                        SIVAL(data->data, 0, tmp);
+                        }
                         break;
+                case REG_QWORD: {
+                        uint64_t tmp = strtoll(data_str, NULL, 16);
+                        *data = data_blob_talloc(mem_ctx, NULL, sizeof(uint64_t));
+                        if (data->data == NULL) return false;
+                        SBVAL(data->data, 0, tmp);
+                        }
+                        break;
                 case REG_NONE:
                         ZERO_STRUCTP(data);
                         break;
-                case REG_BINARY:
-                        *data = strhex_to_data_blob(mem_ctx, data_str);
-                        break;
                 default:
                         /* FIXME */
+                        /* Other datatypes aren't supported -> return no success */
                         return false;
+        }
 …
         struct registry_key *predef;
         WERROR error;
         int predeflength;
+        size_t predeflength;
         char *predefname;
 …
         predefname = talloc_strndup(mem_ctx, name, predeflength);
+        W_ERROR_HAVE_NO_MEMORY(predefname);
         error = reg_get_predefined_key_by_name(handle, predefname, &predef);
         talloc_free(predefname);
 …
         parent_name = talloc_strndup(mem_ctx, path, strrchr(path, '\\')-path);
+        W_ERROR_HAVE_NO_MEMORY(parent_name);
         error = reg_open_key_abs(mem_ctx, ctx, parent_name, parent);
+        talloc_free(parent_name);
         if (!W_ERROR_IS_OK(error)) {
                 return error;
 …
         *name = talloc_strdup(mem_ctx, strrchr(path, '\\')+1);
+        W_ERROR_HAVE_NO_MEMORY(*name);
         return WERR_OK;
 …
         error = get_abs_parent(mem_ctx, ctx, path, &parent, &n);
         if (W_ERROR_IS_OK(error)) {
                 error = reg_key_del(parent, n);
+                error = reg_key_del(mem_ctx, parent, n);
+        }
 …
         const char *n;
         WERROR error;
+        *result = NULL;
         if (!strchr(path, '\\')) {

trunk/server/source4/lib/socket/access.c

r414	r745
35	35	#include "lib/socket/socket.h"
36	36	#include "system/locale.h"
	37	#include "lib/util/util_net.h"
37	38
38	39	#define FAIL (-1)

trunk/server/source4/lib/socket/connect_multi.c

-              r414
+              r745
 */
 struct connect_multi_state {
         const char *server_address;
+        struct socket_address *server_address;
         int num_ports;
         uint16_t *ports;
 …
 _PUBLIC_ struct composite_context *socket_connect_multi_send(
                                                     TALLOC_CTX *mem_ctx,
                                                     const char *server_address,
+                                                    const char *server_name,
                                                     int num_server_ports,
                                                     uint16_t *server_ports,
 …
         int i;
+        struct nbt_name name;
+        struct composite_context *creq;
         result = talloc_zero(mem_ctx, struct composite_context);
         if (result == NULL) return NULL;
 …
         result->private_data = multi;
-        multi->server_address = talloc_strdup(multi, server_address);
-        if (composite_nomem(multi->server_address, result)) goto failed;
         multi->num_ports = num_server_ports;
         multi->ports = talloc_array(multi, uint16_t, multi->num_ports);
 …
+        }
+        if (!is_ipaddress(server_address)) {
+                /*
+                    we don't want to do the name resolution separately
+        /*
+            we don't want to do the name resolution separately
                     for each port, so start it now, then only start on
                     the real sockets once we have an IP
+                 */
+                struct nbt_name name;
+                struct composite_context *creq;
+                make_nbt_name_server(&name, server_address);
+                creq = resolve_name_send(resolve_ctx, multi, &name, result->event_ctx);
+                if (composite_nomem(creq, result)) goto failed;
+                composite_continue(result, creq, continue_resolve_name, result);
+                return result;
+        }
+        /* now we've setup the state we can process the first socket */
+        connect_multi_next_socket(result);
+        if (!NT_STATUS_IS_OK(result->status)) {
+                goto failed;
+        }
+        */
+        make_nbt_name_server(&name, server_name);
+        creq = resolve_name_all_send(resolve_ctx, multi, 0, multi->ports[0], &name, result->event_ctx);
+        if (composite_nomem(creq, result)) goto failed;
+        composite_continue(result, creq, continue_resolve_name, result);
         return result;
  failed:
 …
         if (!composite_is_ok(result)) return;
+        /* Form up the particular address we are interested in */
+        state->addr = socket_address_from_strings(state, state->sock->backend_name,
+                                                  multi->server_address, multi->ports[next]);
+        state->addr = socket_address_copy(state, multi->server_address);
         if (composite_nomem(state->addr, result)) return;
+        socket_address_set_port(state->addr, multi->ports[next]);
         talloc_steal(state, state->sock);
 …
         struct connect_multi_state *multi = talloc_get_type(result->private_data,
                                                             struct connect_multi_state);
         const char *addr;
         result->status = resolve_name_recv(creq, multi, &addr);
+        struct socket_address **addr;
+        result->status = resolve_name_all_recv(creq, multi, &addr, NULL);
         if (!composite_is_ok(result)) return;
+        multi->server_address = addr;
+        /* Let's just go for the first for now */
+        multi->server_address = addr[0];
         connect_multi_next_socket(result);

trunk/server/source4/lib/socket/interface.c

-              r414
+              r745
 #include "system/network.h"
 #include "lib/socket/netif.h"
+#include "../lib/util/util_net.h"
 #include "../lib/util/dlinklist.h"
 …
         DLIST_ADD_END(*interfaces, iface, struct interface *);
         DEBUG(2,("added interface ip=%s nmask=%s\n", iface->ip_s, iface->nmask_s));
+        DEBUG(3,("added interface ip=%s nmask=%s\n", iface->ip_s, iface->nmask_s));
+}

trunk/server/source4/lib/socket/netif.c

-              r414
+              r745
 #include "system/network.h"
 #include "netif.h"
+#include "lib/util/tsort.h"
 /****************************************************************************
 …
         /* now we need to remove duplicates */
         qsort(ifaces, total, sizeof(ifaces[0]), QSORT_CAST iface_comp);
+        TYPESAFE_QSORT(ifaces, total, iface_comp);
         for (i=1;i<total;) {

trunk/server/source4/lib/socket/socket.c

-              r414
+              r745
 #include "system/network.h"
 #include "param/param.h"
+#include "../lib/tsocket/tsocket.h"
+#include "lib/util/util_net.h"
 /*
 …
         return sock->ops->fn_get_my_addr(sock, mem_ctx);
+}
+_PUBLIC_ struct tsocket_address *socket_address_to_tsocket_address(TALLOC_CTX *mem_ctx,
+                                                                   const struct socket_address *a)
+{
+        struct tsocket_address *r;
+        int ret;
+        if (a->sockaddr) {
+                ret = tsocket_address_bsd_from_sockaddr(mem_ctx,
+                                                        a->sockaddr,
+                                                        a->sockaddrlen,
+                                                        &r);
+        } else {
+                ret = tsocket_address_inet_from_strings(mem_ctx,
+                                                        a->family,
+                                                        a->addr,
+                                                        a->port,
+                                                        &r);
+        }
+        if (ret != 0) {
+                return NULL;
+        }
+        return r;
+}
+_PUBLIC_ void socket_address_set_port(struct socket_address *a,
+                                      uint16_t port)
+{
+        if (a->sockaddr) {
+                set_sockaddr_port(a->sockaddr, port);
+        } else {
+                a->port = port;
+        }
+}
+_PUBLIC_ struct socket_address *tsocket_address_to_socket_address(TALLOC_CTX *mem_ctx,
+                                                                  const struct tsocket_address *a)
+{
+        ssize_t ret;
+        struct sockaddr_storage ss;
+        size_t sslen = sizeof(ss);
+        ret = tsocket_address_bsd_sockaddr(a, (struct sockaddr *)(void *)&ss, sslen);
+        if (ret < 0) {
+                return NULL;
+        }
+        return socket_address_from_sockaddr(mem_ctx, (struct sockaddr *)(void *)&ss, ret);
+}
+_PUBLIC_ struct tsocket_address *socket_get_remote_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
+{
+        struct socket_address *a;
+        struct tsocket_address *r;
+        a = socket_get_peer_addr(sock, mem_ctx);
+        if (a == NULL) {
+                return NULL;
+        }
+        r = socket_address_to_tsocket_address(mem_ctx, a);
+        talloc_free(a);
+        return r;
+}
+_PUBLIC_ struct tsocket_address *socket_get_local_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
+{
+        struct socket_address *a;
+        struct tsocket_address *r;
+        a = socket_get_my_addr(sock, mem_ctx);
+        if (a == NULL) {
+                return NULL;
+        }
+        r = socket_address_to_tsocket_address(mem_ctx, a);
+        talloc_free(a);
+        return r;
+}

trunk/server/source4/lib/socket/socket.h

-              r414
+              r745
 struct resolve_context;
+struct tsocket_address;
 /* prototypes */
 …
 struct socket_address *socket_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx);
 struct socket_address *socket_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx);
+struct tsocket_address *socket_address_to_tsocket_address(TALLOC_CTX *mem_ctx,
+                                                          const struct socket_address *a);
+struct socket_address *tsocket_address_to_socket_address(TALLOC_CTX *mem_ctx,
+                                                         const struct tsocket_address *a);
+struct tsocket_address *socket_get_remote_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx);
+struct tsocket_address *socket_get_local_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx);
 int socket_get_fd(struct socket_context *sock);
 NTSTATUS socket_dup(struct socket_context *sock);
 …
                                                     struct sockaddr *sockaddr,
                                                     size_t addrlen);
+_PUBLIC_ void socket_address_set_port(struct socket_address *a,
+                                      uint16_t port);
 struct socket_address *socket_address_copy(TALLOC_CTX *mem_ctx,
                                            const struct socket_address *oaddr);
 …
                               uint16_t *port);
 void set_socket_options(int fd, const char *options);
 void socket_set_flags(struct socket_context *socket, unsigned flags);
+void socket_set_flags(struct socket_context *sock, unsigned flags);
 void socket_tevent_fd_close_fn(struct tevent_context *ev,

trunk/server/source4/lib/socket/socket_ip.c

-              r414
+              r745
 #include "lib/socket/socket.h"
 #include "system/network.h"
+#include "lib/util/util_net.h"
 static NTSTATUS ipv4_init(struct socket_context *sock)
 …
 static NTSTATUS ipv6_tcp_accept(struct socket_context *sock, struct socket_context **new_sock)
+{
         struct sockaddr_in cli_addr;
+        struct sockaddr_in6 cli_addr;
         socklen_t cli_addr_len = sizeof(cli_addr);
         int new_fd;

trunk/server/source4/lib/socket/testsuite.c

-              r414
+              r745
         struct interface *ifaces;
         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
         status = socket_create("ip", SOCKET_TYPE_DGRAM, &sock1, 0);
 …
         talloc_steal(mem_ctx, sock2);
         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
+        load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
         localhost = socket_address_from_strings(sock1, sock1->backend_name,
                                                 iface_best_ip(ifaces, "127.0.0.1"), 0);
 …
 struct torture_suite *torture_local_socket(TALLOC_CTX *mem_ctx)
+{
+        struct torture_suite *suite = torture_suite_create(mem_ctx,
+                                                                                                           "SOCKET");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "socket");
         torture_suite_add_simple_test(suite, "udp", test_udp);

trunk/server/source4/lib/stream/packet.c

-              r414
+              r745
         int processing;
         bool recv_disable;
+        bool recv_need_enable;
         bool nofree;
 …
         if (pc->recv_disable) {
+                pc->recv_need_enable = true;
                 EVENT_FD_NOT_READABLE(pc->fde);
                 return;
 …
 _PUBLIC_ void packet_recv_disable(struct packet_context *pc)
+{
-        EVENT_FD_NOT_READABLE(pc->fde);
         pc->recv_disable = true;
+}
 …
 _PUBLIC_ void packet_recv_enable(struct packet_context *pc)
+{
+        EVENT_FD_READABLE(pc->fde);
+        if (pc->recv_need_enable) {
+                pc->recv_need_enable = false;
+                EVENT_FD_READABLE(pc->fde);
+        }
         pc->recv_disable = false;
         if (pc->num_read != 0 && pc->packet_size >= pc->num_read) {
 …
   call send_callback.
   Useful for operations that must occour after sending a message, such
+  Useful for operations that must occur after sending a message, such
   as the switch to SASL encryption after as sucessful LDAP bind relpy.
 */

trunk/server/source4/lib/stream/packet.h

r414	r745
24	24	struct tevent_context;
25	25	struct tevent_fd;
	26	struct socket_context;
26	27
27	28	typedef NTSTATUS (packet_full_request_fn_t)(void private_data,

trunk/server/source4/lib/tls/tls.c

-              r414
+              r745
         int ret;
         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
         const char *keyfile = lp_tls_keyfile(tmp_ctx, lp_ctx);
         const char *certfile = lp_tls_certfile(tmp_ctx, lp_ctx);
         const char *cafile = lp_tls_cafile(tmp_ctx, lp_ctx);
         const char *crlfile = lp_tls_crlfile(tmp_ctx, lp_ctx);
         const char *dhpfile = lp_tls_dhpfile(tmp_ctx, lp_ctx);
+        const char *keyfile = lpcfg_tls_keyfile(tmp_ctx, lp_ctx);
+        const char *certfile = lpcfg_tls_certfile(tmp_ctx, lp_ctx);
+        const char *cafile = lpcfg_tls_cafile(tmp_ctx, lp_ctx);
+        const char *crlfile = lpcfg_tls_crlfile(tmp_ctx, lp_ctx);
+        const char *dhpfile = lpcfg_tls_dhpfile(tmp_ctx, lp_ctx);
         void tls_cert_generate(TALLOC_CTX *, const char *, const char *, const char *, const char *);
         params = talloc(mem_ctx, struct tls_params);
 …
+        }
         if (!lp_tls_enabled(lp_ctx) || keyfile == NULL || *keyfile == 0) {
+        if (!lpcfg_tls_enabled(lp_ctx) || keyfile == NULL || *keyfile == 0) {
                 params->tls_enabled = false;
                 talloc_free(tmp_ctx);
 …
         if (!file_exist(cafile)) {
                 char *hostname = talloc_asprintf(mem_ctx, "%s.%s",
+                                                 lp_netbios_name(lp_ctx), lp_realm(lp_ctx));
+                                                 lpcfg_netbios_name(lp_ctx),
+                                                 lpcfg_dnsdomain(lp_ctx));
                 if (hostname == NULL) {
                         goto init_failed;

trunk/server/source4/lib/tls/tls.h

-              r414
+              r745
 const struct socket_ops *socket_tls_ops(enum socket_type type);
+#endif
+struct tstream_context;
+struct tstream_tls_params;
+NTSTATUS tstream_tls_params_client(TALLOC_CTX *mem_ctx,
+                                   const char *ca_file,
+                                   const char *crl_file,
+                                   struct tstream_tls_params **_tlsp);
+NTSTATUS tstream_tls_params_server(TALLOC_CTX *mem_ctx,
+                                   const char *dns_host_name,
+                                   bool enabled,
+                                   const char *key_file,
+                                   const char *cert_file,
+                                   const char *ca_file,
+                                   const char *crl_file,
+                                   const char *dhp_file,
+                                   struct tstream_tls_params **_params);
+bool tstream_tls_params_enabled(struct tstream_tls_params *params);
+struct tevent_req *_tstream_tls_connect_send(TALLOC_CTX *mem_ctx,
+                                             struct tevent_context *ev,
+                                             struct tstream_context *plain_stream,
+                                             struct tstream_tls_params *tls_params,
+                                             const char *location);
+#define tstream_tls_connect_send(mem_ctx, ev, plain_stream, tls_params); \
+        _tstream_tls_connect_send(mem_ctx, ev, plain_stream, tls_params, __location__)
+int tstream_tls_connect_recv(struct tevent_req *req,
+                             int *perrno,
+                             TALLOC_CTX *mem_ctx,
+                             struct tstream_context **tls_stream);
+struct tevent_req *_tstream_tls_accept_send(TALLOC_CTX *mem_ctx,
+                                            struct tevent_context *ev,
+                                            struct tstream_context *plain_stream,
+                                            struct tstream_tls_params *tls_params,
+                                            const char *location);
+#define tstream_tls_accept_send(mem_ctx, ev, plain_stream, tls_params) \
+        _tstream_tls_accept_send(mem_ctx, ev, plain_stream, tls_params, __location__)
+int tstream_tls_accept_recv(struct tevent_req *req,
+                            int *perrno,
+                            TALLOC_CTX *mem_ctx,
+                            struct tstream_context **tls_stream);
+#endif /* _TLS_H_ */

trunk/server/source4/lib/tls/tlscert.c

-              r414
+              r745
         bufsize = sizeof(buf);
         TLSCHECK(gnutls_x509_crt_export(crt, GNUTLS_X509_FMT_PEM, buf, &bufsize));
+        file_save(certfile, buf, bufsize);
+        if (!file_save(certfile, buf, bufsize)) {
+                DEBUG(0,("Unable to save certificate in %s parent dir exists ?\n", certfile));
+                goto failed;
+        }
         bufsize = sizeof(buf);
         TLSCHECK(gnutls_x509_crt_export(cacrt, GNUTLS_X509_FMT_PEM, buf, &bufsize));
+        file_save(cafile, buf, bufsize);
+        if (!file_save(cafile, buf, bufsize)) {
+                DEBUG(0,("Unable to save ca cert in %s parent dir exists ?\n", cafile));
+                goto failed;
+        }
         bufsize = sizeof(buf);
         TLSCHECK(gnutls_x509_privkey_export(key, GNUTLS_X509_FMT_PEM, buf, &bufsize));
+        file_save(keyfile, buf, bufsize);
+        if (!file_save(keyfile, buf, bufsize)) {
+                DEBUG(0,("Unable to save privatekey in %s parent dir exists ?\n", keyfile));
+                goto failed;
+        }
         gnutls_x509_privkey_deinit(key);

trunk/server/source4/lib/wmi/tools/wmic.c

-              r414
+              r745
 struct program_args {
         char *hostname;
         char *query;
         char *ns;
+    char *hostname;
+    char *query;
+    char *ns;
 };
 static void parse_args(int argc, char *argv[], struct program_args *pmyargs)
+{
+        poptContext pc;
+        int opt, i;
+        int argc_new;
+        char **argv_new;
+        struct poptOption long_options[] = {
+                POPT_AUTOHELP
+                POPT_COMMON_SAMBA
+                POPT_COMMON_CONNECTION
+                POPT_COMMON_CREDENTIALS
+                POPT_COMMON_VERSION
+                {"namespace", 0, POPT_ARG_STRING, &pmyargs->ns, 0,
+                 "WMI namespace, default to root\\cimv2", 0},
+                POPT_TABLEEND
+        };
+        pc = poptGetContext("wmi", argc, (const char **) argv,
+                long_options, POPT_CONTEXT_KEEP_FIRST);
+        poptSetOtherOptionHelp(pc, "//host query\n\nExample: wmic -U [domain/]adminuser%password //host \"select * from Win32_ComputerSystem\"");
+        while ((opt = poptGetNextOpt(pc)) != -1) {
+                poptPrintUsage(pc, stdout, 0);
+                poptFreeContext(pc);
+                exit(1);
+    poptContext pc;
+    int opt, i;
+    int argc_new;
+    char **argv_new;
+    struct poptOption long_options[] = {
+        POPT_AUTOHELP
+        POPT_COMMON_SAMBA
+        POPT_COMMON_CONNECTION
+        POPT_COMMON_CREDENTIALS
+        POPT_COMMON_VERSION
+        {"namespace", 0, POPT_ARG_STRING, &pmyargs->ns, 0,
+         "WMI namespace, default to root\\cimv2", 0},
+        POPT_TABLEEND
+    };
+    pc = poptGetContext("wmi", argc, (const char **) argv,
+                long_options, POPT_CONTEXT_KEEP_FIRST);
+    poptSetOtherOptionHelp(pc, "//host query\n\nExample: wmic -U [domain/]adminuser%password //host \"select * from Win32_ComputerSystem\"");
+    while ((opt = poptGetNextOpt(pc)) != -1) {
+        poptPrintUsage(pc, stdout, 0);
+        poptFreeContext(pc);
+        exit(1);
+    }
+    argv_new = discard_const_p(char *, poptGetArgs(pc));
+    argc_new = argc;
+    for (i = 0; i < argc; i++) {
+        if (argv_new[i] == NULL) {
+            argc_new = i;
+            break;
+        }
+        argv_new = discard_const_p(char *, poptGetArgs(pc));
+        argc_new = argc;
+        for (i = 0; i < argc; i++) {
+                if (argv_new[i] == NULL) {
+                        argc_new = i;
+                        break;
+                }
+        }
+        if (argc_new != 3 || argv_new[1][0] != '/'
+                        || argv_new[1][1] != '/') {
+                poptPrintUsage(pc, stdout, 0);
+                poptFreeContext(pc);
+                exit(1);
+        }
+        pmyargs->hostname = argv_new[1] + 2;
+        pmyargs->query = argv_new[2];
+    }
+    if (argc_new != 3 || argv_new[1][0] != '/'
+        || argv_new[1][1] != '/') {
+        poptPrintUsage(pc, stdout, 0);
         poptFreeContext(pc);
+}
+static void escape_string(const char *src, char *dst, int len)
+{
+        char *p = dst, *end = dst + len - 1;
+        const char *q = src;
+        if ( q == NULL) {
+                strncpy( dst, "(null)", len);
+                return;
+        }
+        while ( *q && p <= end ) {
+                if ( strchr( "|\\(),", *q)) {
+                        *p++ = '\\';
+                        *p++ = *q++;
+                } else if ( *q == '\n' ) {
+                        *p++ = '\\';
+                        *p++ = 'n';
+                        q++;
+                } else if ( *q == '\r' ) {
+                        *p++ = '\\';
+                        *p++ = 'r';
+                        q++;
+                } else {
+                        *p++ = *q++;
+                }
+        }
+        *p++ = 0;
+        exit(1);
+    }
+    pmyargs->hostname = argv_new[1] + 2;
+    pmyargs->query = argv_new[2];
+    poptFreeContext(pc);
+}
 …
+                        }
 #define RETURN_CVAR_ARRAY_STR_START(arr) {\
         uint32_t i;\
+#define RETURN_CVAR_ARRAY_STR(fmt, arr) {\
+        uint32_t i;\
         char *r;\
+\
         if (!arr) {\
                 return talloc_strdup(mem_ctx, "(null)");\
         }\
+        if (!arr) {\
+                return talloc_strdup(mem_ctx, "NULL");\
+        }\
         r = talloc_strdup(mem_ctx, "(");\
+        for (i = 0; i < arr->count; ++i) {
+#define RETURN_CVAR_ARRAY_STR_END(fmt, arr, item) \
+                r = talloc_asprintf_append(r, fmt "%s", item, (i+1 == arr->count)?"":",");\
+        }\
+        return talloc_asprintf_append(r, ")");\
+}
+#define RETURN_CVAR_ARRAY_STR(fmt, arr) \
+        RETURN_CVAR_ARRAY_STR_START(arr) \
+        RETURN_CVAR_ARRAY_STR_END(fmt, arr, arr->item[i])
+#define RETURN_CVAR_ARRAY_ESCAPED(fmt, arr) \
+        RETURN_CVAR_ARRAY_STR_START(arr) \
+        char buf[2048]; \
+        escape_string( arr->item[i], buf, 2048); \
+        RETURN_CVAR_ARRAY_STR_END(fmt, arr, buf)
+        for (i = 0; i < arr->count; ++i) {\
+                r = talloc_asprintf_append(r, fmt "%s", arr->item[i], (i+1 == arr->count)?"":",");\
+        }\
+        return talloc_asprintf_append(r, ")");\
+}
 char *string_CIMVAR(TALLOC_CTX *mem_ctx, union CIMVAR *v, enum CIMTYPE_ENUMERATION cimtype)
 …
         case CIM_STRING:
         case CIM_DATETIME:
+        case CIM_REFERENCE: {
+                char buf[2048];
+                escape_string((char*) v-> v_string, buf, 2048);
+                return talloc_asprintf(mem_ctx, "%s", buf);
+        }
+        case CIM_REFERENCE: return talloc_asprintf(mem_ctx, "%s", v->v_string);
         case CIM_CHAR16: return talloc_asprintf(mem_ctx, "Unsupported");
         case CIM_OBJECT: return talloc_asprintf(mem_ctx, "Unsupported");
 …
         case CIM_ARR_REAL64: RETURN_CVAR_ARRAY_STR("%f", v->a_real64);
         case CIM_ARR_BOOLEAN: RETURN_CVAR_ARRAY_STR("%d", v->a_boolean);
         case CIM_ARR_STRING: RETURN_CVAR_ARRAY_ESCAPED("%s", v->a_string);
         case CIM_ARR_DATETIME: RETURN_CVAR_ARRAY_ESCAPED("%s", v->a_datetime);
         case CIM_ARR_REFERENCE: RETURN_CVAR_ARRAY_ESCAPED("%s", v->a_reference);
+        case CIM_ARR_STRING: RETURN_CVAR_ARRAY_STR("%s", v->a_string);
+        case CIM_ARR_DATETIME: RETURN_CVAR_ARRAY_STR("%s", v->a_datetime);
+        case CIM_ARR_REFERENCE: RETURN_CVAR_ARRAY_STR("%s", v->a_reference);
         default: return talloc_asprintf(mem_ctx, "Unsupported");
+        }

Context Navigation

Legend:

Download in other formats: