r15944: rename LDB_ASYNC_ADD -> LDB_ADD, LDB_ASYNC_MODIFY -> LDB_MODIFY, etc...

(This used to be commit 55d97ef88f377ef1dbf7b1774a15cf9035e2f320)

diff --git a/source4/dsdb/samdb/ldb_modules/password_hash.c b/source4/dsdb/samdb/ldb_modules/password_hash.c
index 16fe6b8f4d1babb553db0fad500e711516d2314f..79c863374ca12fb92759c2dbf6124be46654cbba 100644 (file)
--- a/source4/dsdb/samdb/ldb_modules/password_hash.c
+++ b/source4/dsdb/samdb/ldb_modules/password_hash.c
@@ -488,7 +488,7 @@ static int build_domain_data_request(struct ph_async_context *ac,
                ldb_debug(ac->module->ldb, LDB_DEBUG_ERROR, "Out of Memory!\n");
                return LDB_ERR_OPERATIONS_ERROR;
        }
-       ac->dom_req->operation = LDB_ASYNC_SEARCH;
+       ac->dom_req->operation = LDB_SEARCH;
        ac->dom_req->op.search.base = NULL;
        ac->dom_req->op.search.scope = LDB_SCOPE_SUBTREE;
 
@@ -828,7 +828,7 @@ static int password_hash_mod_search_self(struct ldb_async_handle *h) {
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       ac->search_req->operation = LDB_ASYNC_SEARCH;
+       ac->search_req->operation = LDB_SEARCH;
        ac->search_req->op.search.base = ac->orig_req->op.mod.message->dn;
        ac->search_req->op.search.scope = LDB_SCOPE_BASE;
        ac->search_req->op.search.tree = ldb_parse_tree(ac->module->ldb, NULL);

diff --git a/source4/ldap_server/ldap_backend.c b/source4/ldap_server/ldap_backend.c
index d462a3c4e25986cdf68fbc5fa42fbf69a3943144..0c8d9da45b9b63bbcf16d0404aa83772d0598ba8 100644 (file)
--- a/source4/ldap_server/ldap_backend.c
+++ b/source4/ldap_server/ldap_backend.c
@@ -237,7 +237,7 @@ static NTSTATUS ldapsrv_SearchRequest(struct ldapsrv_call *call)
        res = talloc_zero(local_ctx, struct ldb_result);
        NT_STATUS_HAVE_NO_MEMORY(res);
        
-       lreq->operation = LDB_ASYNC_SEARCH;
+       lreq->operation = LDB_SEARCH;
        lreq->op.search.base = basedn;
        lreq->op.search.scope = scope;
        lreq->op.search.tree = req->tree;

diff --git a/source4/lib/ldb/common/ldb.c b/source4/lib/ldb/common/ldb.c
index 5fbaf54920177414bc760014287554e26763744a..53b4e51ff30191ed64e6e4ce459004a280fc6e4c 100644 (file)
--- a/source4/lib/ldb/common/ldb.c
+++ b/source4/lib/ldb/common/ldb.c
@@ -285,23 +285,23 @@ int ldb_request(struct ldb_context *ldb, struct ldb_request *req)
 
        /* call the first module in the chain */
        switch (req->operation) {
-       case LDB_ASYNC_SEARCH:
+       case LDB_SEARCH:
                FIRST_OP(ldb, search);
                ret = module->ops->search(module, req);
                break;
-       case LDB_ASYNC_ADD:
+       case LDB_ADD:
                FIRST_OP(ldb, add);
                ret = module->ops->add(module, req);
                break;
-       case LDB_ASYNC_MODIFY:
+       case LDB_MODIFY:
                FIRST_OP(ldb, modify);
                ret = module->ops->modify(module, req);
                break;
-       case LDB_ASYNC_DELETE:
+       case LDB_DELETE:
                FIRST_OP(ldb, del);
                ret = module->ops->del(module, req);
                break;
-       case LDB_ASYNC_RENAME:
+       case LDB_RENAME:
                FIRST_OP(ldb, rename);
                ret = module->ops->rename(module, req);
                break;
@@ -408,7 +408,7 @@ int ldb_search(struct ldb_context *ldb,
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       req->operation = LDB_ASYNC_SEARCH;
+       req->operation = LDB_SEARCH;
        req->op.search.base = base;
        req->op.search.scope = scope;
 
@@ -486,7 +486,7 @@ int ldb_add(struct ldb_context *ldb,
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       req->operation = LDB_ASYNC_ADD;
+       req->operation = LDB_ADD;
        req->op.add.message = message;
        req->controls = NULL;
        req->async.context = NULL;
@@ -518,7 +518,7 @@ int ldb_modify(struct ldb_context *ldb,
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       req->operation = LDB_ASYNC_MODIFY;
+       req->operation = LDB_MODIFY;
        req->op.add.message = message;
        req->controls = NULL;
        req->async.context = NULL;
@@ -547,7 +547,7 @@ int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn)
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       req->operation = LDB_ASYNC_DELETE;
+       req->operation = LDB_DELETE;
        req->op.del.dn = dn;
        req->controls = NULL;
        req->async.context = NULL;
@@ -575,7 +575,7 @@ int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct
                return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       req->operation = LDB_ASYNC_RENAME;
+       req->operation = LDB_RENAME;
        req->op.rename.olddn = olddn;
        req->op.rename.newdn = newdn;
        req->controls = NULL;

diff --git a/source4/lib/ldb/common/ldb_modules.c b/source4/lib/ldb/common/ldb_modules.c
index 4ce404d0963b0d6e1523ad7e57160dd5786f43c7..6f36bdc5e94093e43066356631a21667367ac9f5 100644 (file)
--- a/source4/lib/ldb/common/ldb_modules.c
+++ b/source4/lib/ldb/common/ldb_modules.c
@@ -351,19 +351,19 @@ int ldb_load_modules(struct ldb_context *ldb, const char *options[])
 int ldb_next_request(struct ldb_module *module, struct ldb_request *request)
 {
        switch (request->operation) {
-       case LDB_ASYNC_SEARCH:
+       case LDB_SEARCH:
                FIND_OP(module, search);
                return module->ops->search(module, request);
-       case LDB_ASYNC_ADD:
+       case LDB_ADD:
                FIND_OP(module, add);
                return module->ops->add(module, request);
-       case LDB_ASYNC_MODIFY:
+       case LDB_MODIFY:
                FIND_OP(module, modify);
                return module->ops->modify(module, request);
-       case LDB_ASYNC_DELETE:
+       case LDB_DELETE:
                FIND_OP(module, del);
                return module->ops->del(module, request);
-       case LDB_ASYNC_RENAME:
+       case LDB_RENAME:
                FIND_OP(module, rename);
                return module->ops->rename(module, request);
        default:

diff --git a/source4/lib/ldb/include/ldb.h b/source4/lib/ldb/include/ldb.h
index 8e61ccd73c0fd3b006fa5e6984192f69e1a4c057..56eed3ab24d5c8629db126354e06e53e043f5451 100644 (file)
--- a/source4/lib/ldb/include/ldb.h
+++ b/source4/lib/ldb/include/ldb.h
@@ -562,11 +562,11 @@ struct ldb_control {
 };
 
 enum ldb_request_type {
-       LDB_ASYNC_SEARCH,
-       LDB_ASYNC_ADD,
-       LDB_ASYNC_MODIFY,
-       LDB_ASYNC_DELETE,
-       LDB_ASYNC_RENAME,
+       LDB_SEARCH,
+       LDB_ADD,
+       LDB_MODIFY,
+       LDB_DELETE,
+       LDB_RENAME,
 
        LDB_REQ_REGISTER
 };

diff --git a/source4/lib/ldb/ldb_ildap/ldb_ildap.c b/source4/lib/ldb/ldb_ildap/ldb_ildap.c
index 3bb431e34f09b8afafbc90853f54df2c04d28df5..1772a091a36dd95a0287a1f450aa4a2a15d856f9 100644 (file)
--- a/source4/lib/ldb/ldb_ildap/ldb_ildap.c
+++ b/source4/lib/ldb/ldb_ildap/ldb_ildap.c
@@ -744,7 +744,7 @@ static int ildb_init(struct ldb_module *module)
 
        ildb->rootDSE = NULL;
 
-       req->operation = LDB_ASYNC_SEARCH;
+       req->operation = LDB_SEARCH;
        req->op.search.base = ldb_dn_new(req);
        req->op.search.scope = LDB_SCOPE_BASE;
        req->op.search.tree = ldb_parse_tree(req, "dn=dc=rootDSE");

diff --git a/source4/lib/ldb/modules/asq.c b/source4/lib/ldb/modules/asq.c
index 005d1e41b0155cb56a40107fb662c48a2fe2594b..396a2346df8686c2fae871f9110b506532f4150d 100644 (file)
--- a/source4/lib/ldb/modules/asq.c
+++ b/source4/lib/ldb/modules/asq.c
@@ -312,7 +312,7 @@ static int asq_async_requests(struct ldb_async_handle *handle) {
                ac->reqs[i] = talloc_zero(ac->reqs, struct ldb_request);
                if (ac->reqs[i] == NULL)
                        return LDB_ERR_OPERATIONS_ERROR;
-               ac->reqs[i]->operation = LDB_ASYNC_SEARCH;
+               ac->reqs[i]->operation = LDB_SEARCH;
                ac->reqs[i]->op.search.base = ldb_dn_explode(ac->reqs[i], (const char *)el->values[i].data);
                if (ac->reqs[i]->op.search.base == NULL) {
                        ac->asq_ret = ASQ_CTRL_INVALID_ATTRIBUTE_SYNTAX;

diff --git a/source4/lib/ldb/modules/rdn_name.c b/source4/lib/ldb/modules/rdn_name.c
index 059e7843cddad7b47c96bbaf99fbfdfa3c48f2bb..d6eb0ef13e94078fd6859b6afba1d9cce274f93e 100644 (file)
--- a/source4/lib/ldb/modules/rdn_name.c
+++ b/source4/lib/ldb/modules/rdn_name.c
@@ -202,7 +202,7 @@ static int rdn_name_rename_do_mod(struct ldb_async_handle *h) {
        
        ac->mod_req = talloc_zero(ac, struct ldb_request);
 
-       ac->mod_req->operation = LDB_ASYNC_MODIFY;
+       ac->mod_req->operation = LDB_MODIFY;
        ac->mod_req->op.mod.message = msg = ldb_msg_new(ac->mod_req);
        if (msg == NULL) {
                return LDB_ERR_OPERATIONS_ERROR;

diff --git a/source4/lib/ldb/tools/ldbsearch.c b/source4/lib/ldb/tools/ldbsearch.c
index 3378ade244cd9af50eee05466559603e69421cf2..854360b72318ea8a6b29029b098fd4bf1c3880d6 100644 (file)
--- a/source4/lib/ldb/tools/ldbsearch.c
+++ b/source4/lib/ldb/tools/ldbsearch.c
@@ -217,7 +217,7 @@ static int do_search(struct ldb_context *ldb,
        actx->entries = 0;
        actx->refs = 0;
 
-       req->operation = LDB_ASYNC_SEARCH;
+       req->operation = LDB_SEARCH;
        req->op.search.base = basedn;
        req->op.search.scope = options->scope;
        req->op.search.tree = ldb_parse_tree(ldb, expression);

diff --git a/source4/nbt_server/wins/wins_ldb.c b/source4/nbt_server/wins/wins_ldb.c
index 192697709252d8333433a5b9f9c422f77dfaefdc..c70bf652b7bab958b16c4b8d2170e2f062de5aba 100644 (file)
--- a/source4/nbt_server/wins/wins_ldb.c
+++ b/source4/nbt_server/wins/wins_ldb.c
@@ -45,11 +45,11 @@ static int wins_ldb_verify(struct ldb_module *module, struct ldb_request *req)
        char *error = NULL;
 
        switch (req->operation) {
-       case LDB_ASYNC_ADD:
+       case LDB_ADD:
                msg = req->op.add.message;
                break;
                
-       case LDB_ASYNC_MODIFY:
+       case LDB_MODIFY:
                msg = req->op.mod.message;
                break;