Changeset 745 for trunk/server/source4/lib/ldb/tools

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source4/lib/ldb/tools/cmdline.c (modified) (9 diffs)
• source4/lib/ldb/tools/cmdline.h (modified) (1 diff)
• source4/lib/ldb/tools/config.mk (deleted)
• source4/lib/ldb/tools/ldbadd.c (modified) (9 diffs)
• source4/lib/ldb/tools/ldbdel.c (modified) (3 diffs)
• source4/lib/ldb/tools/ldbedit.c (modified) (17 diffs)
• source4/lib/ldb/tools/ldbmodify.c (modified) (5 diffs)
• source4/lib/ldb/tools/ldbrename.c (modified) (3 diffs)
• source4/lib/ldb/tools/ldbsearch.c (modified) (14 diffs)
• source4/lib/ldb/tools/ldbtest.c (modified) (20 diffs)
• source4/lib/ldb/tools/ldbutil.c (copied) (copied from vendor/current/source4/lib/ldb/tools/ldbutil.c )
• source4/lib/ldb/tools/ldbutil.h (copied) (copied from vendor/current/source4/lib/ldb/tools/ldbutil.h )

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

@@ -22 +22 @@
 */
 
-#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" },
@@ -54 +49 @@
         { "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;
 }
 
@@ -81 +96 @@
 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);
@@ -122 +131 @@
         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);
 
@@ -160 +178 @@
                 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;
                 }
@@ -206 +267 @@
         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;
         }
@@ -226 +287 @@
         }
 
-#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;
         }
 
@@ -256 +304 @@
         }
 
+        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;
 }
@@ -274 +328 @@
 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

@@ -42 +42 @@
         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

@@ -1 @@
-/* 
+/*
    ldb database library
 
@@ -7 +7 @@
      ** 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
@@ -34 +34 @@
 #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);
 }
 
@@ -49 +51 @@
   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))) {
@@ -61 +69 @@
                 }
 
-                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);
@@ -82 +102 @@
 {
         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;
         }
 
@@ -103 +128 @@
                         if (!f) {
                                 perror(fname);
-                                exit(1);
+                                return LDB_ERR_OPERATIONS_ERROR;
                         }
                         ret = process_file(ldb, f, &count);
@@ -111 +136 @@
 
         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 {
@@ -119 +145 @@
         }
 
-        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

@@ -32 +32 @@
  */
 
+#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));
                 }
         }
@@ -53 +68 @@
 
         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;
         }
 
@@ -86 +111 @@
 
                 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

@@ -1 @@
-/* 
+/*
    ldb database library
 
@@ -7 +7 @@
      ** 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
@@ -31 +31 @@
  *  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)
@@ -55 +60 @@
   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;
         }
 
@@ -75 +82 @@
         }
 
-        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;
 }
 
@@ -89 +99 @@
 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) {
@@ -105 +115 @@
 */
 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;
@@ -125 +140 @@
                                 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),
@@ -134 +149 @@
                         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;
                         }
                 }
@@ -147 +165 @@
                                 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),
@@ -158 +176 @@
         }
 
-        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;
 }
 
@@ -171 +189 @@
   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;
@@ -195 +213 @@
   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;
@@ -204 +222 @@
         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
@@ -270 +288 @@
 }
 
-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);
 }
 
@@ -285 +303 @@
         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];
@@ -304 +327 @@
         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

@@ -34 +34 @@
 #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);
 }
 
@@ -48 +50 @@
   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);
@@ -82 +94 @@
 {
         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);
@@ -99 +114 @@
                         if (!f) {
                                 perror(fname);
-                                exit(1);
+                                return LDB_ERR_OPERATIONS_ERROR;
                         }
                         ret = process_file(ldb, f, &count);
@@ -106 +121 @@
         }
 
-        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

@@ -37 +37 @@
 #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);
 }
 
@@ -52 +52 @@
         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  {
@@ -81 +79 @@
         }
 
-        talloc_free(ldb);
+        talloc_free(mem_ctx);
         
         return ret;

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

@@ -32 +32 @@
  */
 
-#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);
 }
 
@@ -55 +57 @@
 
         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;
 };
@@ -132 +134 @@
 {
         struct search_context *sctx;
-        int ret;
+        int ret = LDB_SUCCESS;
 
         sctx = talloc_get_type(req->context, struct search_context);
@@ -173 +175 @@
 
         talloc_free(ares);
-        if (ret) {
+        if (ret != LDB_SUCCESS) {
                 return ldb_request_done(req, LDB_ERR_OPERATIONS_ERROR);
         }
@@ -192 +194 @@
         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) {
@@ -225 +222 @@
                 talloc_free(sctx);
                 printf("allocating request failed: %s\n", ldb_errstring(ldb));
-                return -1;
+                return ret;
         }
 
@@ -233 +230 @@
         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;
         }
 
@@ -246 +243 @@
 
         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++) {
@@ -261 +257 @@
         }
 
-        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);
 
@@ -267 +263 @@
         talloc_free(req);
 
-        return 0;
+        return LDB_SUCCESS;
 }
 
@@ -278 +274 @@
         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;
         }
 
@@ -301 +298 @@
         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;
                 }
         }
@@ -310 +306 @@
                 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 {
@@ -318 +312 @@
         }
 
-        talloc_free(ldb);
+        talloc_free(mem_ctx);
+
         return ret;
 }

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

@@ -32 +32 @@
  */
 
-#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
@@ -123 +129 @@
                 if (ldb_add(ldb, &msg) != 0) {
                         printf("Add of %s failed - %s\n", name, ldb_errstring(ldb));
-                        exit(1);
+                        exit(LDB_ERR_OPERATIONS_ERROR);
                 }
 
@@ -134 +140 @@
         if (ldb_unlock(ldb, "transaction") != 0) {
                 printf("transaction unlock failed\n");
-                exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
         }
 #endif
@@ -142 +148 @@
 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++) {
@@ -180 +186 @@
                 if (ldb_modify(ldb, &msg) != 0) {
                         printf("Modify of %s failed - %s\n", name, ldb_errstring(ldb));
-                        exit(1);
+                        exit(LDB_ERR_OPERATIONS_ERROR);
                 }
 
@@ -195 +201 @@
 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++) {
@@ -210 +216 @@
                 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);
@@ -218 +224 @@
 }
 
-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++) {
@@ -233 +240 @@
                 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);
 
@@ -251 +258 @@
 }
 
-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;
@@ -257 +265 @@
         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);
         }
 
@@ -323 +331 @@
         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);
         }
 
@@ -338 +346 @@
         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);
         }
 
@@ -351 +359 @@
         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);
         }
 
@@ -371 +381 @@
             ldb_delete(*ldb, indexlist) != 0) {
                 printf("cleanup failed - %s\n", ldb_errstring(*ldb));
-                exit(1);
+                exit(LDB_ERR_OPERATIONS_ERROR);
         }
 
@@ -378 +388 @@
 
 
-static void usage(void)
+static void usage(struct ldb_context *ldb)
 {
         printf("Usage: ldbtest <options>\n");
@@ -387 +397 @@
         printf("\n");
         printf("tests ldb API\n\n");
-        exit(1);
+        exit(LDB_ERR_OPERATIONS_ERROR);
 }
 
@@ -396 +406 @@
 
         ldb = ldb_init(mem_ctx, NULL);
+        if (ldb == NULL) {
+                return LDB_ERR_OPERATIONS_ERROR;
+        }
 
         options = ldb_cmdline_process(ldb, argc, argv, usage);
@@ -410 +423 @@
                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);
@@ -416 +431 @@
         talloc_free(mem_ctx);
 
-        return 0;
-}
+        return LDB_SUCCESS;
+}