r23795: more v2->v3 conversion

[samba.git] / source / lib / ldb / modules / skel.c

diff --git a/source/lib/ldb/modules/skel.c b/source/lib/ldb/modules/skel.c
index 9fb01941c97c4ea01681393ed9b5bbde98d1abe0..70759b9704b1693e373c843103b02847d814a5f8 100644 (file)
--- a/source/lib/ldb/modules/skel.c
+++ b/source/lib/ldb/modules/skel.c
@@ -10,7 +10,7 @@
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
+   version 3 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -32,111 +32,106 @@
  *  Author: Simo Sorce
  */
 
-#include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_private.h"
+#include "ldb_includes.h"
 
-const struct private_data {
+struct private_data {
 
-       const char *error_string;
+       char *some_private_data;
 };
 
 /* search */
-static int skel_search(struct ldb_module *module, const char *base,
-                      enum ldb_scope scope, const char *expression,
-                      const char * const *attrs, struct ldb_message ***res)
+static int skel_search(struct ldb_module *module, struct ldb_request *req)
 {
-       return ldb_next_search(module, base, scope, expression, attrs, res); 
+       return ldb_next_request(module, req);
 }
 
-/* add_record */
-static int skel_add_record(struct ldb_module *module, const struct ldb_message *msg)
-{
-       return ldb_next_add_record(module, msg);
+/* add */
+static int skel_add(struct ldb_module *module, struct ldb_request *req){
+       return ldb_next_request(module, req);
 }
 
-/* modify_record */
-static int skel_modify_record(struct ldb_module *module, const struct ldb_message *msg)
+/* modify */
+static int skel_modify(struct ldb_module *module, struct ldb_request *req)
 {
-       return ldb_next_modify_record(module, msg);
+       return ldb_next_request(module, req);
 }
 
-/* delete_record */
-static int skel_delete_record(struct ldb_module *module, const char *dn)
+/* delete */
+static int skel_delete(struct ldb_module *module, struct ldb_request *req)
 {
-       return ldb_next_delete_record(module, dn);
+       return ldb_next_request(module, req);
 }
 
-/* rename_record */
-static int skel_rename_record(struct ldb_module *module, const char *olddn, const char *newdn)
+/* rename */
+static int skel_rename(struct ldb_module *module, struct ldb_request *req)
 {
-       return ldb_next_rename_record(module, olddn, newdn);
+       return ldb_next_request(module, req);
 }
 
-/* named_lock */
-static int skel_named_lock(struct ldb_module *module, const char *lockname)
+/* start a transaction */
+static int skel_start_trans(struct ldb_module *module)
 {
-       return ldb_next_named_lock(module, lockname);
+       return ldb_next_start_trans(module);
 }
 
-/* named_unlock */
-static int skel_named_unlock(struct ldb_module *module, const char *lockname)
+/* end a transaction */
+static int skel_end_trans(struct ldb_module *module)
 {
-       return ldb_next_named_unlock(module, lockname);
+       return ldb_next_end_trans(module);
 }
 
-/* return extended error information */
-static const char *skel_errstring(struct ldb_module *module)
+/* delete a transaction */
+static int skel_del_trans(struct ldb_module *module)
 {
-       return ldb_next_errstring(module);
+       return ldb_next_del_trans(module);
 }
 
-static int skel_destructor(void *module_ctx)
+static int skel_destructor(struct ldb_module *ctx)
 {
-       struct ldb_module *ctx = module_ctx;
+       struct private_data *data = talloc_get_type(ctx->private_data, struct private_data);
        /* put your clean-up functions here */
+       if (data->some_private_data) talloc_free(data->some_private_data);
        return 0;
 }
 
-static const struct ldb_module_ops skel_ops = {
-       "skel",
-       skel_search,
-       skel_add_record,
-       skel_modify_record,
-       skel_delete_record,
-       skel_rename_record,
-       skel_named_lock,
-       skel_named_unlock,
-       skel_errstring
-};
+static int skel_request(struct ldb_module *module, struct ldb_request *req)
+{
+       return ldb_next_request(module, req);
+}
 
-#ifdef HAVE_DLOPEN_DISABLED
-struct ldb_module *init_module(struct ldb_context *ldb, const char *options[])
-#else
-struct ldb_module *skel_module_init(struct ldb_context *ldb, const char *options[])
-#endif
+static int skel_init(struct ldb_module *module)
 {
-       struct ldb_module *ctx;
        struct private_data *data;
 
-       ctx = talloc(ldb, struct ldb_module);
-       if (!ctx)
-               return NULL;
-
-       data = talloc(ctx, struct private_data);
+       data = talloc(module, struct private_data);
        if (data == NULL) {
-               talloc_free(ctx);
-               return NULL;
+               ldb_oom(module->ldb);
+               return LDB_ERR_OPERATIONS_ERROR;
        }
 
-       data->error_string = NULL;
-       ctx->private_data = data;
+       data->some_private_data = NULL;
+       module->private_data = data;
 
-       ctx->ldb = ldb;
-       ctx->prev = ctx->next = NULL;
-       ctx->ops = &skel_ops;
+       talloc_set_destructor (module, skel_destructor);
 
-       talloc_set_destructor (ctx, skel_destructor);
+       return ldb_next_init(module);
+}
 
-       return ctx;
+static const struct ldb_module_ops skel_ops = {
+       .name              = "skel",
+       .init_context      = skel_init,
+       .search            = skel_search,
+       .add               = skel_add,
+       .modify            = skel_modify,
+       .del               = skel_delete,
+       .rename            = skel_rename,
+       .request           = skel_request,
+       .start_transaction = skel_start_trans,
+       .end_transaction   = skel_end_trans,
+       .del_transaction   = skel_del_trans,
+};
+
+int ldb_skel_init(void)
+{
+       return ldb_register_module(&skel_ops);
 }