r12717: Always compile the skel module, so we know when we break it.

[jelmer/samba4-debian.git] / source / lib / ldb / modules / skel.c

diff --git a/source/lib/ldb/modules/skel.c b/source/lib/ldb/modules/skel.c
index 3581969c1897be003883a84133c80ed93fbca7fb..1bbb81f2881a8b0a10086d3cca18c11d94f25bc4 100644 (file)
--- a/source/lib/ldb/modules/skel.c
+++ b/source/lib/ldb/modules/skel.c
@@ -36,104 +36,124 @@
 #include "ldb/include/ldb.h"
 #include "ldb/include/ldb_private.h"
 
-/* close */
-static int skel_close(struct ldb_module *module)
-{
-       return ldb_next_close(module);
-}
+struct private_data {
+
+       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);
 }
 
-/* search_free */
-static int skel_search_free(struct ldb_module *module, struct ldb_message **res)
-{
-       return ldb_next_search_free(module, res);
+/* add */
+static int skel_add(struct ldb_module *module, struct ldb_request *req){
+       return ldb_next_request(module, req);
 }
 
-/* add_record */
-static int skel_add_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_add_record(module, msg);
+       return ldb_next_request(module, req);
 }
 
-/* modify_record */
-static int skel_modify_record(struct ldb_module *module, const struct ldb_message *msg)
+/* delete */
+static int skel_delete(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)
+/* rename */
+static int skel_rename(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)
+/* start a transaction */
+static int skel_start_trans(struct ldb_module *module)
 {
-       return ldb_next_rename_record(module, olddn, newdn);
+       return ldb_next_start_trans(module);
 }
 
-/* named_lock */
-static const char *skel_named_lock(struct ldb_module *module, const char *lockname)
+/* end a transaction */
+static int skel_end_trans(struct ldb_module *module)
 {
-       return ldb_next_named_lock(module, lockname);
+       return ldb_next_end_trans(module);
 }
 
-/* named_unlock */
-static const char *skel_named_unlock(struct ldb_module *module, const char *lockname)
+/* delete a transaction */
+static int skel_del_trans(struct ldb_module *module)
 {
-       return ldb_next_named_unlock(module, lockname);
+       return ldb_next_del_trans(module);
 }
 
-/* return extended error information */
-static const char *skel_errstring(struct ldb_module *module)
+static int skel_destructor(void *module_ctx)
 {
-       return ldb_next_errstring(module);
+       struct ldb_module *ctx = talloc_get_type(module_ctx, struct ldb_module);
+       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 void skel_cache_free(struct ldb_module *module)
+static int skel_request(struct ldb_module *module, struct ldb_request *req)
 {
-       ldb_next_cache_free(module);
+       switch (req->operation) {
+
+       case LDB_REQ_SEARCH:
+               return skel_search(module, req);
+
+       case LDB_REQ_ADD:
+               return skel_add(module, req);
+
+       case LDB_REQ_MODIFY:
+               return skel_modify(module, req);
+
+       case LDB_REQ_DELETE:
+               return skel_delete(module, req);
+
+       case LDB_REQ_RENAME:
+               return skel_rename(module,
+                                  req);
+
+       default:
+               return ldb_next_request(module, req);
+
+       }
 }
 
 static const struct ldb_module_ops skel_ops = {
-       "skel",
-       skel_close, 
-       skel_search,
-       skel_search_free,
-       skel_add_record,
-       skel_modify_record,
-       skel_delete_record,
-       skel_rename_record,
-       skel_named_lock,
-       skel_named_unlock,
-       skel_errstring,
-       skel_cache_free
+       .name              = "skel",
+       .request           = skel_request,
+       .start_transaction = skel_start_trans,
+       .end_transaction   = skel_end_trans,
+       .del_transaction   = skel_del_trans,
 };
 
-#ifdef HAVE_DLOPEN
- struct ldb_module *init_module(struct ldb_context *ldb, const char *options[])
-#else
-struct ldb_module *skel_plugin_init(struct ldb_context *ldb, const char *options[])
-#endif
+struct ldb_module *skel_module_init(struct ldb_context *ldb, const char *options[])
 {
        struct ldb_module *ctx;
+       struct private_data *data;
 
-       ctx = (struct ldb_module *)malloc(sizeof(struct ldb_module));
+       ctx = talloc(ldb, struct ldb_module);
        if (!ctx)
                return NULL;
 
+       data = talloc(ctx, struct private_data);
+       if (data == NULL) {
+               talloc_free(ctx);
+               return NULL;
+       }
+
+       data->some_private_data = NULL;
+       ctx->private_data = data;
+
        ctx->ldb = ldb;
        ctx->prev = ctx->next = NULL;
-       ctx->private_data = NULL;
        ctx->ops = &skel_ops;
 
+       talloc_set_destructor (ctx, skel_destructor);
+
        return ctx;
 }