r22471: Convert more code to use proper LDB error codes.

This is a 1 to 1 convertion, next step is to make this
code report an error if the basedn is not used, hopefully
avoiding an  explicit search on the base object in the most
common cases.

diff --git a/source/lib/ldb/ldb_tdb/ldb_cache.c b/source/lib/ldb/ldb_tdb/ldb_cache.c
index 7032852d1c6bfdefa587561962280cd657615c98..52e3d2f4e93b67d3faed575d87eb85d8f8e68a13 100644 (file)
--- a/source/lib/ldb/ldb_tdb/ldb_cache.c
+++ b/source/lib/ldb/ldb_tdb/ldb_cache.c
@@ -110,12 +110,13 @@ static int ltdb_attributes_load(struct ldb_module *module)
        struct ltdb_private *ltdb = module->private_data;
        struct ldb_message *msg = ltdb->cache->attributes;
        struct ldb_dn *dn;
-       int i;
+       int i, r;
 
        dn = ldb_dn_new(module, module->ldb, LTDB_ATTRIBUTES);
        if (dn == NULL) goto failed;
 
-       if (ltdb_search_dn1(module, dn, msg) == -1) {
+       r = ltdb_search_dn1(module, dn, msg);
+       if (r != LDB_SUCCESS && r != LDB_ERR_NO_SUCH_OBJECT) {
                talloc_free(dn);
                goto failed;
        }
@@ -176,12 +177,13 @@ static int ltdb_subclasses_load(struct ldb_module *module)
        struct ltdb_private *ltdb = module->private_data;
        struct ldb_message *msg = ltdb->cache->subclasses;
        struct ldb_dn *dn;
-       int i, j;
+       int i, j, r;
 
        dn = ldb_dn_new(module, module->ldb, LTDB_SUBCLASSES);
        if (dn == NULL) goto failed;
 
-       if (ltdb_search_dn1(module, dn, msg) == -1) {
+       r = ltdb_search_dn1(module, dn, msg);
+       if (r != LDB_SUCCESS && r != LDB_ERR_NO_SUCH_OBJECT) {
                talloc_free(dn);
                goto failed;
        }
@@ -277,7 +279,7 @@ static int ltdb_baseinfo_init(struct ldb_module *module)
 failed:
        talloc_free(msg);
        errno = ENOMEM;
-       return -1;
+       return LDB_ERR_OPERATIONS_ERROR;
 }
 
 /*
@@ -313,6 +315,7 @@ int ltdb_cache_load(struct ldb_module *module)
        struct ldb_dn *indexlist_dn = NULL;
        uint64_t seq;
        struct ldb_message *baseinfo = NULL;
+       int r;
 
        /* a very fast check to avoid extra database reads */
        if (ltdb->cache != NULL && 
@@ -339,16 +342,17 @@ int ltdb_cache_load(struct ldb_module *module)
        baseinfo_dn = ldb_dn_new(module, module->ldb, LTDB_BASEINFO);
        if (baseinfo_dn == NULL) goto failed;
 
-       if (ltdb_search_dn1(module, baseinfo_dn, baseinfo) == -1) {
+       r= ltdb_search_dn1(module, baseinfo_dn, baseinfo);
+       if (r != LDB_SUCCESS && r != LDB_ERR_NO_SUCH_OBJECT) {
                goto failed;
        }
        
        /* possibly initialise the baseinfo */
        if (!baseinfo->dn) {
-               if (ltdb_baseinfo_init(module) != 0) {
+               if (ltdb_baseinfo_init(module) != LDB_SUCCESS) {
                        goto failed;
                }
-               if (ltdb_search_dn1(module, baseinfo_dn, baseinfo) != 1) {
+               if (ltdb_search_dn1(module, baseinfo_dn, baseinfo) != LDB_SUCCESS) {
                        goto failed;
                }
        }
@@ -384,7 +388,8 @@ int ltdb_cache_load(struct ldb_module *module)
        indexlist_dn = ldb_dn_new(module, module->ldb, LTDB_INDEXLIST);
        if (indexlist_dn == NULL) goto failed;
 
-       if (ltdb_search_dn1(module, indexlist_dn, ltdb->cache->indexlist) == -1) {
+       r = ltdb_search_dn1(module, indexlist_dn, ltdb->cache->indexlist);
+       if (r != LDB_SUCCESS && r != LDB_ERR_NO_SUCH_OBJECT) {
                goto failed;
        }
 
@@ -426,13 +431,13 @@ int ltdb_increase_sequence_number(struct ldb_module *module)
        msg = talloc(ltdb, struct ldb_message);
        if (msg == NULL) {
                errno = ENOMEM;
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        s = talloc_asprintf(msg, "%llu", ltdb->sequence_number+1);
        if (!s) {
                errno = ENOMEM;
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        msg->num_elements = ARRAY_SIZE(el);
@@ -441,13 +446,13 @@ int ltdb_increase_sequence_number(struct ldb_module *module)
        if (msg->dn == NULL) {
                talloc_free(msg);
                errno = ENOMEM;
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
        el[0].name = talloc_strdup(msg, LTDB_SEQUENCE_NUMBER);
        if (el[0].name == NULL) {
                talloc_free(msg);
                errno = ENOMEM;
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
        el[0].values = &val;
        el[0].num_values = 1;
@@ -459,7 +464,7 @@ int ltdb_increase_sequence_number(struct ldb_module *module)
        if (el[1].name == NULL) {
                talloc_free(msg);
                errno = ENOMEM;
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
        el[1].values = &val_time;
        el[1].num_values = 1;
@@ -467,7 +472,7 @@ int ltdb_increase_sequence_number(struct ldb_module *module)
 
        s = ldb_timestring(msg, t);
        if (s == NULL) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        val_time.data = (uint8_t *)s;
@@ -477,7 +482,7 @@ int ltdb_increase_sequence_number(struct ldb_module *module)
 
        talloc_free(msg);
 
-       if (ret == 0) {
+       if (ret == LDB_SUCCESS) {
                ltdb->sequence_number += 1;
        }
 

diff --git a/source/lib/ldb/ldb_tdb/ldb_index.c b/source/lib/ldb/ldb_tdb/ldb_index.c
index 7fe769a010604df36c430ae2e38b6522527e0cd4..e3682afac7839227269eb86248b196840118c413 100644 (file)
--- a/source/lib/ldb/ldb_tdb/ldb_index.c
+++ b/source/lib/ldb/ldb_tdb/ldb_index.c
@@ -202,22 +202,22 @@ static int ltdb_index_dn_simple(struct ldb_module *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) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        /* the attribute is indexed. Pull the list of DNs that match the 
           search criterion */
        dn = ltdb_index_key(ldb, tree->u.equality.attr, &tree->u.equality.value);
-       if (!dn) return -1;
+       if (!dn) return LDB_ERR_OPERATIONS_ERROR;
 
        msg = talloc(list, struct ldb_message);
        if (msg == NULL) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        ret = ltdb_search_dn1(module, dn, msg);
        talloc_free(dn);
-       if (ret == 0 || ret == -1) {
+       if (ret != LDB_SUCCESS) {
                return ret;
        }
 
@@ -233,7 +233,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
                list->dn = talloc_array(list, char *, el->num_values);
                if (!list->dn) {
                        talloc_free(msg);
-                       return -1;
+                       return LDB_ERR_OPERATIONS_ERROR;
                }
 
                for (j=0;j<el->num_values;j++) {
@@ -241,7 +241,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
                                talloc_strdup(list->dn, (char *)el->values[j].data);
                        if (!list->dn[list->count]) {
                                talloc_free(msg);
-                               return -1;
+                               return LDB_ERR_OPERATIONS_ERROR;
                        }
                        list->count++;
                }
@@ -253,7 +253,7 @@ static int ltdb_index_dn_simple(struct ldb_module *module,
                qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t) list_cmp);
        }
 
-       return 1;
+       return LDB_SUCCESS;
 }
 
 
@@ -291,24 +291,24 @@ static int ltdb_index_dn_objectclass(struct ldb_module *module,
                tree2.operation = LDB_OP_EQUALITY;
                tree2.u.equality.attr = LTDB_OBJECTCLASS;
                if (!tree2.u.equality.attr) {
-                       return -1;
+                       return LDB_ERR_OPERATIONS_ERROR;
                }
                tree2.u.equality.value.data = 
                        (uint8_t *)talloc_strdup(list, subclasses[i]);
                if (tree2.u.equality.value.data == NULL) {
-                       return -1;                      
+                       return LDB_ERR_OPERATIONS_ERROR;                        
                }
                tree2.u.equality.value.length = strlen(subclasses[i]);
                list2 = talloc(list, struct dn_list);
                if (list2 == NULL) {
                        talloc_free(tree2.u.equality.value.data);
-                       return -1;
+                       return LDB_ERR_OPERATIONS_ERROR;
                }
                if (ltdb_index_dn_objectclass(module, &tree2, 
-                                             index_list, list2) == 1) {
+                                             index_list, list2) == LDB_SUCCESS) {
                        if (list->count == 0) {
                                *list = *list2;
-                               ret = 1;
+                               ret = LDB_SUCCESS;
                        } else {
                                list_union(ldb, list, list2);
                                talloc_free(list2);
@@ -335,15 +335,15 @@ static int ltdb_index_dn_leaf(struct ldb_module *module,
                list->dn = talloc_array(list, char *, 1);
                if (list->dn == NULL) {
                        ldb_oom(module->ldb);
-                       return -1;
+                       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(module->ldb);
-                       return -1;
+                       return LDB_ERR_OPERATIONS_ERROR;
                }
                list->count = 1;
-               return 1;
+               return LDB_SUCCESS;
        }
        return ltdb_index_dn_simple(module, tree, index_list, list);
 }
@@ -362,18 +362,18 @@ static int list_intersect(struct ldb_context *ldb,
 
        if (list->count == 0 || list2->count == 0) {
                /* 0 & X == 0 */
-               return 0;
+               return LDB_ERR_NO_SUCH_OBJECT;
        }
 
        list3 = talloc(ldb, struct dn_list);
        if (list3 == NULL) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        list3->dn = talloc_array(list3, char *, list->count);
        if (!list3->dn) {
                talloc_free(list3);
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
        list3->count = 0;
 
@@ -392,7 +392,7 @@ static int list_intersect(struct ldb_context *ldb,
        list->count = list3->count;
        talloc_free(list3);
 
-       return 0;
+       return LDB_ERR_NO_SUCH_OBJECT;
 }
 
 
@@ -410,12 +410,12 @@ static int list_union(struct ldb_context *ldb,
 
        if (list->count == 0 && list2->count == 0) {
                /* 0 | 0 == 0 */
-               return 0;
+               return LDB_ERR_NO_SUCH_OBJECT;
        }
 
        d = talloc_realloc(list, list->dn, char *, list->count + list2->count);
        if (!d) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
        list->dn = d;
 
@@ -424,7 +424,7 @@ static int list_union(struct ldb_context *ldb,
                              sizeof(char *), (comparison_fn_t)strcmp) == -1) {
                        list->dn[list->count] = talloc_strdup(list->dn, list2->dn[i]);
                        if (!list->dn[list->count]) {
-                               return -1;
+                               return LDB_ERR_OPERATIONS_ERROR;
                        }
                        list->count++;
                }               
@@ -434,7 +434,7 @@ static int list_union(struct ldb_context *ldb,
                qsort(list->dn, list->count, sizeof(char *), (comparison_fn_t)list_cmp);
        }
 
-       return 0;
+       return LDB_ERR_NO_SUCH_OBJECT;
 }
 
 static int ltdb_index_dn(struct ldb_module *module, 
@@ -455,7 +455,7 @@ static int ltdb_index_dn_or(struct ldb_module *module,
        unsigned int i;
        int ret;
        
-       ret = -1;
+       ret = LDB_ERR_OPERATIONS_ERROR;
        list->dn = NULL;
        list->count = 0;
 
@@ -465,43 +465,43 @@ static int ltdb_index_dn_or(struct ldb_module *module,
 
                list2 = talloc(module, struct dn_list);
                if (list2 == NULL) {
-                       return -1;
+                       return LDB_ERR_OPERATIONS_ERROR;
                }
 
                v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, list2);
 
-               if (v == 0) {
+               if (v == LDB_ERR_NO_SUCH_OBJECT) {
                        /* 0 || X == X */
-                       if (ret == -1) {
-                               ret = 0;
+                       if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
+                               ret = v;
                        }
                        talloc_free(list2);
                        continue;
                }
 
-               if (v == -1) {
+               if (v != LDB_SUCCESS && v != LDB_ERR_NO_SUCH_OBJECT) {
                        /* 1 || X == 1 */
                        talloc_free(list->dn);
                        talloc_free(list2);
-                       return -1;
+                       return v;
                }
 
-               if (ret == -1) {
-                       ret = 1;
+               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 -1;
+                               return LDB_ERR_OPERATIONS_ERROR;
                        }
-                       ret = 1;
+                       ret = LDB_SUCCESS;
                }
                talloc_free(list2);
        }
 
        if (list->count == 0) {
-               return 0;
+               return LDB_ERR_NO_SUCH_OBJECT;
        }
 
        return ret;
@@ -524,7 +524,7 @@ static int ltdb_index_dn_not(struct ldb_module *module,
           instead, we just give up, and rely on a full index scan
           (unless an outer & manages to reduce the list)
        */
-       return -1;
+       return LDB_ERR_OPERATIONS_ERROR;
 }
 
 /*
@@ -539,7 +539,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
        unsigned int i;
        int ret;
        
-       ret = -1;
+       ret = LDB_ERR_OPERATIONS_ERROR;
        list->dn = NULL;
        list->count = 0;
 
@@ -549,32 +549,32 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 
                list2 = talloc(module, struct dn_list);
                if (list2 == NULL) {
-                       return -1;
+                       return LDB_ERR_OPERATIONS_ERROR;
                }
 
                v = ltdb_index_dn(module, tree->u.list.elements[i], index_list, list2);
 
-               if (v == 0) {
+               if (v == LDB_ERR_NO_SUCH_OBJECT) {
                        /* 0 && X == 0 */
                        talloc_free(list->dn);
                        talloc_free(list2);
-                       return 0;
+                       return LDB_ERR_NO_SUCH_OBJECT;
                }
 
-               if (v == -1) {
+               if (v != LDB_SUCCESS && v != LDB_ERR_NO_SUCH_OBJECT) {
                        talloc_free(list2);
                        continue;
                }
 
-               if (ret == -1) {
-                       ret = 1;
+               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 -1;
+                               return LDB_ERR_OPERATIONS_ERROR;
                        }
                }
 
@@ -582,7 +582,7 @@ static int ltdb_index_dn_and(struct ldb_module *module,
 
                if (list->count == 0) {
                        talloc_free(list->dn);
-                       return 0;
+                       return LDB_ERR_NO_SUCH_OBJECT;
                }
        }
 
@@ -606,7 +606,7 @@ static int ltdb_index_dn_one(struct ldb_module *module,
        
        list2 = talloc_zero(module, struct dn_list);
        if (list2 == NULL) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        /* the attribute is indexed. Pull the list of DNs that match the 
@@ -616,18 +616,18 @@ static int ltdb_index_dn_one(struct ldb_module *module,
        key = ltdb_index_key(ldb, LTDB_IDXONE, &val);
        if (!key) {
                talloc_free(list2);
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        msg = talloc(list2, struct ldb_message);
        if (msg == NULL) {
                talloc_free(list2);
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        ret = ltdb_search_dn1(module, key, msg);
        talloc_free(key);
-       if (ret == 0 || ret == -1) {
+       if (ret != LDB_SUCCESS) {
                return ret;
        }
 
@@ -643,14 +643,14 @@ static int ltdb_index_dn_one(struct ldb_module *module,
                list2->dn = talloc_array(list2, char *, el->num_values);
                if (!list2->dn) {
                        talloc_free(list2);
-                       return -1;
+                       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 -1;
+                               return LDB_ERR_OPERATIONS_ERROR;
                        }
                        list2->count++;
                }
@@ -658,7 +658,7 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 
        if (list2->count == 0) {
                talloc_free(list2);
-               return 0;
+               return LDB_ERR_NO_SUCH_OBJECT;
        }
 
        if (list2->count > 1) {
@@ -668,13 +668,13 @@ static int ltdb_index_dn_one(struct ldb_module *module,
        if (list->count > 0) {
                if (list_intersect(ldb, list, list2) == -1) {
                        talloc_free(list2);
-                       return -1;
+                       return LDB_ERR_OPERATIONS_ERROR;
                }
 
                if (list->count == 0) {
                        talloc_free(list->dn);
                        talloc_free(list2);
-                       return 0;
+                       return LDB_ERR_NO_SUCH_OBJECT;
                }
        } else {
                list->dn = talloc_move(list, &list2->dn);
@@ -683,19 +683,19 @@ static int ltdb_index_dn_one(struct ldb_module *module,
 
        talloc_free(list2);
 
-       return 1;
+       return LDB_SUCCESS;
 }
 
 /*
   return a list of dn's that might match a indexed search or
-  -1 if an error. return 0 for no matches, or 1 for matches
+  an error. return LDB_ERR_NO_SUCH_OBJECT for no matches, or LDB_SUCCESS for matches
  */
 static int ltdb_index_dn(struct ldb_module *module, 
                         const struct ldb_parse_tree *tree,
                         const struct ldb_message *index_list,
                         struct dn_list *list)
 {
-       int ret = -1;
+       int ret = LDB_ERR_OPERATIONS_ERROR;
 
        switch (tree->operation) {
        case LDB_OP_AND:
@@ -721,7 +721,7 @@ static int ltdb_index_dn(struct ldb_module *module,
        case LDB_OP_APPROX:
        case LDB_OP_EXTENDED:
                /* we can't index with fancy bitops yet */
-               ret = -1;
+               ret = LDB_ERR_OPERATIONS_ERROR;
                break;
        }
 
@@ -767,13 +767,13 @@ static int ltdb_index_filter(const struct dn_list *dn_list,
 
                ret = ltdb_search_dn1(ac->module, dn, ares->message);
                talloc_free(dn);
-               if (ret == 0) {
+               if (ret == LDB_ERR_NO_SUCH_OBJECT) {
                        /* the record has disappeared? yes, this can happen */
                        talloc_free(ares);
                        continue;
                }
 
-               if (ret == -1) {
+               if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
                        /* an internal error */
                        talloc_free(ares);
                        return LDB_ERR_OPERATIONS_ERROR;
@@ -834,14 +834,14 @@ int ltdb_search_indexed(struct ldb_handle *handle)
        if ((ac->scope == LDB_SCOPE_ONELEVEL && (idxattr+idxone == 0)) ||
            (ac->scope == LDB_SCOPE_SUBTREE && idxattr == 0)) {
                /* no indexs? must do full search */
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       ret = -1;
+       ret = LDB_ERR_OPERATIONS_ERROR;
 
        dn_list = talloc_zero(handle, struct dn_list);
        if (dn_list == NULL) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        if (ac->scope == LDB_SCOPE_BASE) {
@@ -849,21 +849,21 @@ int ltdb_search_indexed(struct ldb_handle *handle)
                dn_list->dn = talloc_array(dn_list, char *, 1);
                if (dn_list->dn == NULL) {
                        ldb_oom(ac->module->ldb);
-                       return -1;
+                       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(ac->module->ldb);
-                       return -1;
+                       return LDB_ERR_OPERATIONS_ERROR;
                }
                dn_list->count = 1;
-               ret = 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 < 0) {
+               if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
                        talloc_free(dn_list);
                        return ret;
                }
@@ -873,7 +873,7 @@ int ltdb_search_indexed(struct ldb_handle *handle)
                ret = ltdb_index_dn_one(ac->module, ac->base, dn_list);
        }
 
-       if (ret == 1) {
+       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, handle);
@@ -899,25 +899,25 @@ static int ltdb_index_add1_new(struct ldb_context *ldb,
        el = talloc_realloc(msg, msg->elements, 
                               struct ldb_message_element, msg->num_elements+1);
        if (!el) {
-               return -1;
+               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 -1;
+               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 -1;
+               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 0;
+       return LDB_SUCCESS;
 }
 
 
@@ -936,7 +936,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
        /* 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 0;
+                       return LDB_SUCCESS;
                }
        }
 
@@ -944,7 +944,7 @@ static int ltdb_index_add1_add(struct ldb_context *ldb,
                              struct ldb_val, 
                              msg->elements[idx].num_values+1);
        if (!v2) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
        msg->elements[idx].values = v2;
 
@@ -970,23 +970,23 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
        msg = talloc(module, struct ldb_message);
        if (msg == NULL) {
                errno = ENOMEM;
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx]);
        if (!dn_key) {
                talloc_free(msg);
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
        talloc_steal(msg, dn_key);
 
        ret = ltdb_search_dn1(module, dn_key, msg);
-       if (ret == -1) {
+       if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
                talloc_free(msg);
-               return -1;
+               return ret;
        }
 
-       if (ret == 0) {
+       if (ret == LDB_ERR_NO_SUCH_OBJECT) {
                msg->dn = dn_key;
                msg->num_elements = 0;
                msg->elements = NULL;
@@ -1004,7 +1004,7 @@ static int ltdb_index_add1(struct ldb_module *module, const char *dn,
                ret = ltdb_index_add1_add(ldb, msg, i, dn);
        }
 
-       if (ret == 0) {
+       if (ret == LDB_SUCCESS) {
                ret = ltdb_store(module, msg, TDB_REPLACE);
        }
 
@@ -1021,12 +1021,12 @@ static int ltdb_index_add0(struct ldb_module *module, const char *dn,
        unsigned int i, j;
 
        if (dn[0] == '@') {
-               return 0;
+               return LDB_SUCCESS;
        }
 
        if (ltdb->cache->indexlist->num_elements == 0) {
                /* no indexed fields */
-               return 0;
+               return LDB_SUCCESS;
        }
 
        for (i = 0; i < num_el; i++) {
@@ -1037,18 +1037,17 @@ static int ltdb_index_add0(struct ldb_module *module, const char *dn,
                }
                for (j = 0; j < elements[i].num_values; j++) {
                        ret = ltdb_index_add1(module, dn, &elements[i], j);
-                       if (ret == -1) {
-                               return -1;
+                       if (ret != LDB_SUCCESS) {
+                               return ret;
                        }
                }
        }
 
-       return 0;
+       return LDB_SUCCESS;
 }
 
 /*
   add the index entries for a new record
-  return -1 on failure
 */
 int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 {
@@ -1057,7 +1056,7 @@ int ltdb_index_add(struct ldb_module *module, const struct ldb_message *msg)
 
        dn = ldb_dn_get_linearized(msg->dn);
        if (dn == NULL) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
@@ -1079,31 +1078,31 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
        unsigned int j;
 
        if (dn[0] == '@') {
-               return 0;
+               return LDB_SUCCESS;
        }
 
        dn_key = ltdb_index_key(ldb, el->name, &el->values[v_idx]);
        if (!dn_key) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        msg = talloc(dn_key, struct ldb_message);
        if (msg == NULL) {
                talloc_free(dn_key);
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        ret = ltdb_search_dn1(module, dn_key, msg);
-       if (ret == -1) {
+       if (ret != LDB_SUCCESS && ret != LDB_ERR_NO_SUCH_OBJECT) {
                talloc_free(dn_key);
-               return -1;
+               return ret;
        }
 
-       if (ret == 0) {
+       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 0;
+               return LDB_SUCCESS;
        }
 
        i = ldb_msg_find_idx(msg, dn, &j, LTDB_IDX);
@@ -1113,7 +1112,7 @@ int ltdb_index_del_value(struct ldb_module *module, const char *dn,
                                ldb_dn_get_linearized(dn_key));
                /* it ain't there. hmmm */
                talloc_free(dn_key);
-               return 0;
+               return LDB_SUCCESS;
        }
 
        if (j != msg->elements[i].num_values - 1) {
@@ -1149,16 +1148,16 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
        /* find the list of indexed fields */   
        if (ltdb->cache->indexlist->num_elements == 0) {
                /* no indexed fields */
-               return 0;
+               return LDB_SUCCESS;
        }
 
        if (ldb_dn_is_special(msg->dn)) {
-               return 0;
+               return LDB_SUCCESS;
        }
 
        dn = ldb_dn_get_linearized(msg->dn);
        if (dn == NULL) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        for (i = 0; i < msg->num_elements; i++) {
@@ -1169,13 +1168,13 @@ int ltdb_index_del(struct ldb_module *module, const struct ldb_message *msg)
                }
                for (j = 0; j < msg->elements[i].num_values; j++) {
                        ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
-                       if (ret == -1) {
-                               return -1;
+                       if (ret != LDB_SUCCESS) {
+                               return ret;
                        }
                }
        }
 
-       return 0;
+       return LDB_SUCCESS;
 }
 
 /* 
@@ -1193,24 +1192,24 @@ int ltdb_index_one(struct ldb_module *module, const struct ldb_message *msg, int
        /* We index for ONE Level only if requested */
        ret = ldb_msg_find_idx(ltdb->cache->indexlist, NULL, NULL, LTDB_IDXONE);
        if (ret != 0) {
-               return 0;
+               return LDB_SUCCESS;
        }
 
        pdn = ldb_dn_get_parent(module, msg->dn);
        if (pdn == NULL) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        dn = ldb_dn_get_linearized(msg->dn);
        if (dn == NULL) {
                talloc_free(pdn);
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        val.data = (uint8_t *)((intptr_t)ldb_dn_get_casefold(pdn));
        if (val.data == NULL) {
                talloc_free(pdn);
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        val.length = strlen((char *)val.data);
@@ -1292,7 +1291,7 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
        }
 
        ret = ltdb_index_one(module, msg, 1);
-       if (ret == 0) {
+       if (ret == LDB_SUCCESS) {
                ret = ltdb_index_add0(module, dn, msg->elements, msg->num_elements);
        } else {
                ldb_debug(module->ldb, LDB_DEBUG_ERROR,
@@ -1302,7 +1301,9 @@ static int re_index(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *
 
        talloc_free(msg);
 
-       return ret;
+       if (ret != LDB_SUCCESS) return -1;
+
+       return 0;
 }
 
 /*
@@ -1314,25 +1315,25 @@ int ltdb_reindex(struct ldb_module *module)
        int ret;
 
        if (ltdb_cache_reload(module) != 0) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        /* first traverse the database deleting any @INDEX records */
        ret = tdb_traverse(ltdb->tdb, delete_index, NULL);
        if (ret == -1) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        /* if we don't have indexes we have nothing todo */
        if (ltdb->cache->indexlist->num_elements == 0) {
-               return 0;
+               return LDB_SUCCESS;
        }
 
        /* now traverse adding any indexes for normal LDB records */
        ret = tdb_traverse(ltdb->tdb, re_index, module);
        if (ret == -1) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       return 0;
+       return LDB_SUCCESS;
 }

diff --git a/source/lib/ldb/ldb_tdb/ldb_search.c b/source/lib/ldb/ldb_tdb/ldb_search.c
index 6890378185f8781ce65b8ad68b2603c5fc93af25..838f599642e63d2ab54e75f43011243b90f54b6f 100644 (file)
--- a/source/lib/ldb/ldb_tdb/ldb_search.c
+++ b/source/lib/ldb/ldb_tdb/ldb_search.c
@@ -207,7 +207,8 @@ static struct ldb_message *ltdb_pull_attrs(struct ldb_module *module,
   search the database for a single simple dn, returning all attributes
   in a single message
 
-  return 1 on success, 0 on record-not-found and -1 on error
+  return LDB_ERR_NO_SUCH_OBJECT on record-not-found
+  and LDB_SUCCESS on success
 */
 int ltdb_search_dn1(struct ldb_module *module, struct ldb_dn *dn, struct ldb_message *msg)
 {
@@ -220,13 +221,13 @@ int ltdb_search_dn1(struct ldb_module *module, struct ldb_dn *dn, struct ldb_mes
        /* form the key */
        tdb_key = ltdb_key(module, dn);
        if (!tdb_key.dptr) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
        tdb_data = tdb_fetch(ltdb->tdb, tdb_key);
        talloc_free(tdb_key.dptr);
        if (!tdb_data.dptr) {
-               return 0;
+               return LDB_ERR_NO_SUCH_OBJECT;
        }
 
        msg->num_elements = 0;
@@ -235,17 +236,17 @@ int ltdb_search_dn1(struct ldb_module *module, struct ldb_dn *dn, struct ldb_mes
        ret = ltdb_unpack_data(module, &tdb_data, msg);
        free(tdb_data.dptr);
        if (ret == -1) {
-               return -1;              
+               return LDB_ERR_OPERATIONS_ERROR;                
        }
 
        if (!msg->dn) {
                msg->dn = ldb_dn_copy(msg, dn);
        }
        if (!msg->dn) {
-               return -1;
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       return 1;
+       return LDB_SUCCESS;
 }
 
 /*
@@ -495,7 +496,7 @@ int ltdb_search(struct ldb_module *module, struct ldb_request *req)
        ltdb_ac->attrs = req->op.search.attrs;
 
        ret = ltdb_search_indexed(req->handle);
-       if (ret == -1) {
+       if (ret == LDB_ERR_OPERATIONS_ERROR) {
                ret = ltdb_search_full(req->handle);
        }
        if (ret != LDB_SUCCESS) {

diff --git a/source/lib/ldb/ldb_tdb/ldb_tdb.c b/source/lib/ldb/ldb_tdb/ldb_tdb.c
index 16ab5b905b231e7ce0d7b850e41bbbbfa7e44394..8a6d26ff9827c5063a95850e69a83eaacb8c8a3a 100644 (file)
--- a/source/lib/ldb/ldb_tdb/ldb_tdb.c
+++ b/source/lib/ldb/ldb_tdb/ldb_tdb.c
@@ -198,7 +198,7 @@ int ltdb_check_special_dn(struct ldb_module *module, const struct ldb_message *m
 */
 static int ltdb_modified(struct ldb_module *module, struct ldb_dn *dn)
 {
-       int ret = 0;
+       int ret = LDB_SUCCESS;
 
        if (ldb_dn_is_special(dn) &&
            (ldb_dn_check_special(dn, LTDB_INDEXLIST) ||
@@ -206,7 +206,7 @@ static int ltdb_modified(struct ldb_module *module, struct ldb_dn *dn)
                ret = ltdb_reindex(module);
        }
 
-       if (ret == 0 &&
+       if (ret == LDB_SUCCESS &&
            !(ldb_dn_is_special(dn) &&
              ldb_dn_check_special(dn, LTDB_BASEINFO)) ) {
                ret = ltdb_increase_sequence_number(module);
@@ -243,7 +243,7 @@ int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flg
        }
        
        ret = ltdb_index_add(module, msg);
-       if (ret == -1) {
+       if (ret != LDB_SUCCESS) {
                tdb_delete(ltdb->tdb, tdb_key);
        }
 
@@ -278,12 +278,12 @@ static int ltdb_add_internal(struct ldb_module *module, const struct ldb_message
        if (ret == LDB_SUCCESS) {
                ret = ltdb_index_one(module, msg, 1);
                if (ret != LDB_SUCCESS) {
-                       return LDB_ERR_OPERATIONS_ERROR;
+                       return ret;
                }
 
                ret = ltdb_modified(module, msg->dn);
                if (ret != LDB_SUCCESS) {
-                       return LDB_ERR_OPERATIONS_ERROR;
+                       return ret;
                }
        }
 
@@ -362,40 +362,36 @@ static int ltdb_delete_internal(struct ldb_module *module, struct ldb_dn *dn)
        /* in case any attribute of the message was indexed, we need
           to fetch the old record */
        ret = ltdb_search_dn1(module, dn, msg);
-       if (ret != 1) {
+       if (ret != LDB_SUCCESS) {
                /* not finding the old record is an error */
-               talloc_free(msg);
-               return LDB_ERR_NO_SUCH_OBJECT;
+               goto done;
        }
 
        ret = ltdb_delete_noindex(module, dn);
        if (ret != LDB_SUCCESS) {
-               talloc_free(msg);
-               return LDB_ERR_NO_SUCH_OBJECT;
+               goto done;
        }
 
        /* remove one level attribute */
        ret = ltdb_index_one(module, msg, 0);
        if (ret != LDB_SUCCESS) {
-               talloc_free(msg);
-               return LDB_ERR_OPERATIONS_ERROR;
+               goto done;
        }
 
        /* remove any indexed attributes */
        ret = ltdb_index_del(module, msg);
        if (ret != LDB_SUCCESS) {
-               talloc_free(msg);
-               return LDB_ERR_OPERATIONS_ERROR;
+               goto done;
        }
 
        ret = ltdb_modified(module, dn);
        if (ret != LDB_SUCCESS) {
-               talloc_free(msg);
-               return LDB_ERR_OPERATIONS_ERROR;
+               goto done;
        }
 
+done:
        talloc_free(msg);
-       return LDB_SUCCESS;
+       return ret;
 }
 
 /*
@@ -718,8 +714,8 @@ int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *ms
                                        ret = LDB_ERR_NO_SUCH_ATTRIBUTE;
                                        goto failed;
                                }
-                               if (ltdb_index_del_value(module, dn, &msg->elements[i], j) != 0) {
-                                       ret = LDB_ERR_OTHER;
+                               ret = ltdb_index_del_value(module, dn, &msg->elements[i], j);
+                               if (ret != LDB_SUCCESS) {
                                        goto failed;
                                }
                        }
@@ -739,8 +735,8 @@ int ltdb_modify_internal(struct ldb_module *module, const struct ldb_message *ms
                goto failed;
        }
 
-       if (ltdb_modified(module, msg->dn) != LDB_SUCCESS) {
-               ret = LDB_ERR_OPERATIONS_ERROR;
+       ret = ltdb_modified(module, msg->dn);
+       if (ret != LDB_SUCCESS) {
                goto failed;
        }
 
@@ -835,9 +831,9 @@ static int ltdb_rename(struct ldb_module *module, struct ldb_request *req)
        /* 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 != 1) {
+       if (tret != LDB_SUCCESS) {
                /* not finding the old record is an error */
-               req->handle->status = LDB_ERR_NO_SUCH_OBJECT;
+               req->handle->status = tret;
                goto done;
        }
 
@@ -944,10 +940,10 @@ static int ltdb_sequence_number(struct ldb_module *module, struct ldb_request *r
        req->op.seq_num.flags = 0;
 
        tret = ltdb_search_dn1(module, dn, msg);
-       if (tret != 1) {
+       if (tret != LDB_SUCCESS) {
                talloc_free(tmp_ctx);
-               req->op.seq_num.seq_num = 0;
                /* zero is as good as anything when we don't know */
+               req->op.seq_num.seq_num = 0;
                return LDB_SUCCESS;
        }