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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
/*
* author: Simo Sorce
*/
-#include "includes.h"
-#include "ldb/include/includes.h"
+#include "ldb_module.h"
#define LDAP_DEPRECATED 1
#include <ldap.h>
LDAP *ldap;
};
-struct lldb_async_context {
+struct lldb_context {
struct ldb_module *module;
+ struct ldb_request *req;
+
+ struct lldb_private *lldb;
+
+ struct ldb_control **controls;
int msgid;
- int timeout;
- time_t starttime;
- void *context;
- int (*callback)(struct ldb_context *, void *, struct ldb_async_result *);
};
static int lldb_ldap_to_ldb(int err) {
return err;
}
-static struct ldb_async_handle *init_handle(struct lldb_private *lldb, struct ldb_module *module,
- void *context,
- int (*callback)(struct ldb_context *, void *, struct ldb_async_result *),
- int timeout, time_t starttime)
-{
- struct lldb_async_context *ac;
- struct ldb_async_handle *h;
-
- h = talloc_zero(lldb, struct ldb_async_handle);
- if (h == NULL) {
- ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
- return NULL;
- }
-
- h->module = module;
-
- ac = talloc(h, struct lldb_async_context);
- if (ac == NULL) {
- ldb_set_errstring(module->ldb, talloc_asprintf(module, "Out of Memory"));
- talloc_free(h);
- return NULL;
- }
-
- h->private_data = (void *)ac;
-
- h->state = LDB_ASYNC_INIT;
- h->status = LDB_SUCCESS;
-
- ac->module = module;
- ac->context = context;
- ac->callback = callback;
- ac->timeout = timeout;
- ac->starttime = starttime;
- ac->msgid = 0;
-
- return h;
-}
/*
convert a ldb_message structure to a list of LDAPMod structures
ready for ldap_add() or ldap_modify()
}
for (i=0;i<count;i++) {
- el->values[i].data = talloc_memdup(el->values, bval[i]->bv_val, bval[i]->bv_len);
+ /* we have to ensure this is null terminated so that
+ ldb_msg_find_attr_as_string() can work */
+ el->values[i].data = talloc_size(el->values, bval[i]->bv_len+1);
if (!el->values[i].data) {
+ errno = ENOMEM;
return -1;
}
+ memcpy(el->values[i].data, bval[i]->bv_val, bval[i]->bv_len);
+ el->values[i].data[bval[i]->bv_len] = 0;
el->values[i].length = bval[i]->bv_len;
el->num_values++;
}
/*
search for matching records
*/
-static int lldb_search(struct ldb_module *module, struct ldb_request *req)
+static int lldb_search(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_async_context *lldb_ac;
+ struct ldb_context *ldb;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
struct timeval tv;
int ldap_scope;
char *search_base;
char *expression;
int ret;
- if (!req->async.callback || !req->async.context) {
- ldb_set_errstring(module->ldb, talloc_asprintf(module, "Async interface called with NULL callback function or NULL context"));
+ ldb = ldb_module_get_ctx(module);
+
+ if (!req->callback || !req->context) {
+ ldb_set_errstring(ldb, "Async interface called with NULL callback function or NULL context");
return LDB_ERR_OPERATIONS_ERROR;
}
if (req->op.search.tree == NULL) {
- ldb_set_errstring(module->ldb, talloc_asprintf(module, "Invalid expression parse tree"));
+ ldb_set_errstring(ldb, "Invalid expression parse tree");
return LDB_ERR_OPERATIONS_ERROR;
}
if (req->controls != NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_WARNING, "Controls are not yet supported by ldb_ldap backend!\n");
- }
-
- req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
- if (req->async.handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ ldb_debug(ldb, LDB_DEBUG_WARNING, "Controls are not yet supported by ldb_ldap backend!\n");
}
- lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
- search_base = ldb_dn_linearize(lldb_ac, req->op.search.base);
+ search_base = ldb_dn_alloc_linearized(lldb_ac, req->op.search.base);
if (req->op.search.base == NULL) {
search_base = talloc_strdup(lldb_ac, "");
}
break;
}
- tv.tv_sec = req->async.timeout;
+ tv.tv_sec = req->timeout;
tv.tv_usec = 0;
ret = ldap_search_ext(lldb->ldap, search_base, ldap_scope,
&lldb_ac->msgid);
if (ret != LDAP_SUCCESS) {
- ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+ ldb_set_errstring(ldb, ldap_err2string(ret));
}
return lldb_ldap_to_ldb(ret);
/*
add a record
*/
-static int lldb_add(struct ldb_module *module, struct ldb_request *req)
+static int lldb_add(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_async_context *lldb_ac;
+ struct ldb_context *ldb;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
LDAPMod **mods;
char *dn;
int ret;
- /* ltdb specials should not reach this point */
- if (ldb_dn_is_special(req->op.add.message->dn)) {
- return LDB_ERR_INVALID_DN_SYNTAX;
- }
+ ldb_module_get_ctx(module);
- req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
- if (req->async.handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
-
- lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
mods = lldb_msg_to_mods(lldb_ac, req->op.add.message, 0);
if (mods == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- dn = ldb_dn_linearize(lldb_ac, req->op.add.message->dn);
+ dn = ldb_dn_alloc_linearized(lldb_ac, req->op.add.message->dn);
if (dn == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
&lldb_ac->msgid);
if (ret != LDAP_SUCCESS) {
- ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+ ldb_set_errstring(ldb, ldap_err2string(ret));
}
return lldb_ldap_to_ldb(ret);
/*
modify a record
*/
-static int lldb_modify(struct ldb_module *module, struct ldb_request *req)
+static int lldb_modify(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_async_context *lldb_ac;
+ struct ldb_context *ldb;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
LDAPMod **mods;
char *dn;
int ret;
- /* ltdb specials should not reach this point */
- if (ldb_dn_is_special(req->op.mod.message->dn)) {
- return LDB_ERR_INVALID_DN_SYNTAX;
- }
-
- req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
- if (req->async.handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ ldb_module_get_ctx(module);
- lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
mods = lldb_msg_to_mods(lldb_ac, req->op.mod.message, 1);
if (mods == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
- dn = ldb_dn_linearize(lldb_ac, req->op.mod.message->dn);
+ dn = ldb_dn_alloc_linearized(lldb_ac, req->op.mod.message->dn);
if (dn == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
&lldb_ac->msgid);
if (ret != LDAP_SUCCESS) {
- ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+ ldb_set_errstring(ldb, ldap_err2string(ret));
}
return lldb_ldap_to_ldb(ret);
/*
delete a record
*/
-static int lldb_delete(struct ldb_module *module, struct ldb_request *req)
+static int lldb_delete(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_async_context *lldb_ac;
+ struct ldb_context *ldb;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
char *dnstr;
int ret;
-
- /* ltdb specials should not reach this point */
- if (ldb_dn_is_special(req->op.del.dn)) {
- return LDB_ERR_INVALID_DN_SYNTAX;
- }
- req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
- if (req->async.handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ ldb_module_get_ctx(module);
- lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
- dnstr = ldb_dn_linearize(lldb_ac, req->op.del.dn);
+ dnstr = ldb_dn_alloc_linearized(lldb_ac, req->op.del.dn);
ret = ldap_delete_ext(lldb->ldap, dnstr,
NULL,
&lldb_ac->msgid);
if (ret != LDAP_SUCCESS) {
- ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+ ldb_set_errstring(ldb, ldap_err2string(ret));
}
return lldb_ldap_to_ldb(ret);
/*
rename a record
*/
-static int lldb_rename(struct ldb_module *module, struct ldb_request *req)
+static int lldb_rename(struct lldb_context *lldb_ac)
{
- struct lldb_private *lldb = talloc_get_type(module->private_data, struct lldb_private);
- struct lldb_async_context *lldb_ac;
+ struct ldb_context *ldb;
+ struct lldb_private *lldb = lldb_ac->lldb;
+ struct ldb_module *module = lldb_ac->module;
+ struct ldb_request *req = lldb_ac->req;
char *old_dn;
char *newrdn;
char *parentdn;
int ret;
-
- /* ltdb specials should not reach this point */
- if (ldb_dn_is_special(req->op.rename.olddn) || ldb_dn_is_special(req->op.rename.newdn)) {
- return LDB_ERR_INVALID_DN_SYNTAX;
- }
- req->async.handle = init_handle(lldb, module, req->async.context, req->async.callback, req->async.timeout, req->async.starttime);
- if (req->async.handle == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
+ ldb_module_get_ctx(module);
- lldb_ac = talloc_get_type(req->async.handle->private_data, struct lldb_async_context);
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
- old_dn = ldb_dn_linearize(lldb_ac, req->op.rename.olddn);
+ old_dn = ldb_dn_alloc_linearized(lldb_ac, req->op.rename.olddn);
if (old_dn == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
newrdn = talloc_asprintf(lldb_ac, "%s=%s",
- req->op.rename.newdn->components[0].name,
- ldb_dn_escape_value(lldb, req->op.rename.newdn->components[0].value));
+ ldb_dn_get_rdn_name(req->op.rename.newdn),
+ ldb_dn_escape_value(lldb, *(ldb_dn_get_rdn_val(req->op.rename.newdn))));
if (!newrdn) {
return LDB_ERR_OPERATIONS_ERROR;
}
- parentdn = ldb_dn_linearize(lldb_ac, ldb_dn_get_parent(lldb_ac, req->op.rename.newdn));
+ parentdn = ldb_dn_alloc_linearized(lldb_ac, ldb_dn_get_parent(lldb_ac, req->op.rename.newdn));
if (!parentdn) {
return LDB_ERR_OPERATIONS_ERROR;
}
&lldb_ac->msgid);
if (ret != LDAP_SUCCESS) {
- ldb_set_errstring(module->ldb, talloc_strdup(module, ldap_err2string(ret)));
+ ldb_set_errstring(ldb, ldap_err2string(ret));
}
return lldb_ldap_to_ldb(ret);
}
-static int lldb_parse_result(struct ldb_async_handle *handle, LDAPMessage *result)
+static int lldb_start_trans(struct ldb_module *module)
{
- struct lldb_async_context *ac = talloc_get_type(handle->private_data, struct lldb_async_context);
- struct lldb_private *lldb = talloc_get_type(ac->module->private_data, struct lldb_private);
- struct ldb_async_result *ares = NULL;
- LDAPMessage *msg;
- int type;
+ /* TODO implement a local transaction mechanism here */
+
+ return LDB_SUCCESS;
+}
+
+static int lldb_end_trans(struct ldb_module *module)
+{
+ /* TODO implement a local transaction mechanism here */
+
+ return LDB_SUCCESS;
+}
+
+static int lldb_del_trans(struct ldb_module *module)
+{
+ /* TODO implement a local transaction mechanism here */
+
+ return LDB_SUCCESS;
+}
+
+void lldb_request_done(struct lldb_context *ac,
+ struct ldb_control **ctrls, int error)
+{
+ struct ldb_request *req;
+ struct ldb_reply *ares;
+
+ req = ac->req;
+
+ ares = talloc_zero(req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(ldb_module_get_ctx(ac->module));
+ req->callback(req, NULL);
+ return;
+ }
+ ares->type = LDB_REPLY_DONE;
+ ares->controls = talloc_steal(ares, ctrls);
+ ares->error = error;
+
+ req->callback(req, ares);
+}
+
+/* return false if the request is still in progress
+ * return true if the request is completed
+ */
+static bool lldb_parse_result(struct lldb_context *ac, LDAPMessage *result)
+{
+ struct ldb_context *ldb;
+ struct lldb_private *lldb = ac->lldb;
+ LDAPControl **serverctrlsp = NULL;
+ char **referralsp = NULL;
char *matcheddnp = NULL;
char *errmsgp = NULL;
- char **referralsp = NULL;
- LDAPControl **serverctrlsp = NULL;
- int ret = LDB_SUCCESS;
+ LDAPMessage *msg;
+ int type;
+ struct ldb_message *ldbmsg;
+ char *referral;
+ bool callback_failed;
+ bool request_done;
+ bool lret;
+ int ret;
+ int i;
+
+ ldb = ldb_module_get_ctx(ac->module);
type = ldap_msgtype(result);
+ callback_failed = false;
+ request_done = false;
switch (type) {
-
case LDAP_RES_SEARCH_ENTRY:
+
msg = ldap_first_entry(lldb->ldap, result);
if (msg != NULL) {
BerElement *berptr = NULL;
char *attr, *dn;
- ares = talloc_zero(ac, struct ldb_async_result);
- if (!ares) {
+ ldbmsg = ldb_msg_new(ac);
+ if (!ldbmsg) {
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
- }
-
- ares->message = ldb_msg_new(ares);
- if (!ares->message) {
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ break;
}
dn = ldap_get_dn(lldb->ldap, msg);
if (!dn) {
+ talloc_free(ldbmsg);
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ break;
}
- ares->message->dn = ldb_dn_explode_or_special(ares->message, dn);
- if (ares->message->dn == NULL) {
+ ldbmsg->dn = ldb_dn_new(ldbmsg, ldb, dn);
+ if ( ! ldb_dn_validate(ldbmsg->dn)) {
+ talloc_free(ldbmsg);
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ break;
}
ldap_memfree(dn);
- ares->message->num_elements = 0;
- ares->message->elements = NULL;
- ares->message->private_data = NULL;
+ ldbmsg->num_elements = 0;
+ ldbmsg->elements = NULL;
/* loop over all attributes */
for (attr=ldap_first_attribute(lldb->ldap, msg, &berptr);
bval = ldap_get_values_len(lldb->ldap, msg, attr);
if (bval) {
- lldb_add_msg_attr(ac->module->ldb, ares->message, attr, bval);
+ lldb_add_msg_attr(ldb, ldbmsg, attr, bval);
ldap_value_free_len(bval);
- }
+ }
}
if (berptr) ber_free(berptr, 0);
+ ret = ldb_module_send_entry(ac->req, ldbmsg, NULL /* controls not yet supported */);
+ if (ret != LDB_SUCCESS) {
- ares->type = LDB_REPLY_ENTRY;
- ret = ac->callback(ac->module->ldb, ac->context, ares);
+ callback_failed = true;
+ }
} else {
- handle->status = LDB_ERR_PROTOCOL_ERROR;
- handle->state = LDB_ASYNC_DONE;
+ ret = LDB_ERR_OPERATIONS_ERROR;
}
break;
case LDAP_RES_SEARCH_REFERENCE:
- if (ldap_parse_result(lldb->ldap, result, &handle->status,
+
+ if (ldap_parse_result(lldb->ldap, result, &ret,
&matcheddnp, &errmsgp,
- &referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
+ &referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
}
- if (referralsp == NULL) {
- handle->status = LDB_ERR_PROTOCOL_ERROR;
- goto error;
+ if (ret != LDB_SUCCESS) {
+ break;
}
-
- ares = talloc_zero(ac, struct ldb_async_result);
- if (!ares) {
- ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ if (referralsp == NULL) {
+ ret = LDB_ERR_PROTOCOL_ERROR;
+ break;
}
- ares->referral = talloc_strdup(ares, *referralsp);
- ares->type = LDB_REPLY_REFERRAL;
- ret = ac->callback(ac->module->ldb, ac->context, ares);
+ for (i = 0; referralsp[i]; i++) {
+ referral = talloc_strdup(ac, referralsp[i]);
+ ret = ldb_module_send_referral(ac->req, referral);
+ if (ret != LDB_SUCCESS) {
+ callback_failed = true;
+ break;
+ }
+ }
break;
case LDAP_RES_SEARCH_RESULT:
- if (ldap_parse_result(lldb->ldap, result, &handle->status,
- &matcheddnp, &errmsgp,
- &referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- goto error;
- }
+ case LDAP_RES_MODIFY:
+ case LDAP_RES_ADD:
+ case LDAP_RES_DELETE:
+ case LDAP_RES_MODDN:
- ares = talloc_zero(ac, struct ldb_async_result);
- if (!ares) {
+ if (ldap_parse_result(lldb->ldap, result, &ret,
+ &matcheddnp, &errmsgp,
+ &referralsp, &serverctrlsp, 0) != LDAP_SUCCESS) {
ret = LDB_ERR_OPERATIONS_ERROR;
- goto error;
+ }
+ if (ret != LDB_SUCCESS) {
+ break;
}
if (serverctrlsp != NULL) {
/* FIXME: transform the LDAPControl list into an ldb_control one */
- ares->controls = NULL;
+ ac->controls = NULL;
}
-
- ares->type = LDB_REPLY_DONE;
- handle->state = LDB_ASYNC_DONE;
- ret = ac->callback(ac->module->ldb, ac->context, ares);
-
- break;
- case LDAP_RES_MODIFY:
- case LDAP_RES_ADD:
- case LDAP_RES_DELETE:
- case LDAP_RES_MODDN:
- if (ldap_parse_result(lldb->ldap, result, &handle->status,
- &matcheddnp, &errmsgp,
- &referralsp, &serverctrlsp, 1) != LDAP_SUCCESS) {
- handle->status = LDB_ERR_OPERATIONS_ERROR;
- goto error;
- }
- if (ac->callback && handle->status == LDB_SUCCESS) {
- ares = NULL; /* FIXME: build a corresponding ares to pass on */
- ret = ac->callback(ac->module->ldb, ac->context, ares);
- }
- handle->state = LDB_ASYNC_DONE;
+ request_done = true;
break;
default:
ret = LDB_ERR_PROTOCOL_ERROR;
- goto error;
+ break;
+ }
+
+ if (ret != LDB_SUCCESS) {
+
+ /* if the callback failed the caller will have freed the
+ * request. Just return and don't try to use it */
+ if (callback_failed) {
+
+ /* tell lldb_wait to remove the request from the
+ * queue */
+ lret = true;
+ goto free_and_return;
+ }
+
+ request_done = true;
}
+ if (request_done) {
+ lldb_request_done(ac, ac->controls, ret);
+ lret = true;
+ goto free_and_return;
+ }
+
+ lret = false;
+
+free_and_return:
+
if (matcheddnp) ldap_memfree(matcheddnp);
+ if (errmsgp && *errmsgp) {
+ ldb_set_errstring(ldb, errmsgp);
+ }
if (errmsgp) {
- ldb_set_errstring(ac->module->ldb, talloc_strdup(ac->module, errmsgp));
ldap_memfree(errmsgp);
}
if (referralsp) ldap_value_free(referralsp);
if (serverctrlsp) ldap_controls_free(serverctrlsp);
ldap_msgfree(result);
- return ret;
-error:
- handle->state = LDB_ASYNC_DONE;
- ldap_msgfree(result);
- return ret;
+ return lret;
+}
+
+static void lldb_timeout(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t,
+ void *private_data)
+{
+ struct lldb_context *ac;
+ ac = talloc_get_type(private_data, struct lldb_context);
+
+ lldb_request_done(ac, NULL, LDB_ERR_TIME_LIMIT_EXCEEDED);
}
-static int lldb_async_wait(struct ldb_async_handle *handle, enum ldb_async_wait_type type)
+static void lldb_callback(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t,
+ void *private_data)
{
- struct lldb_async_context *ac = talloc_get_type(handle->private_data, struct lldb_async_context);
- struct lldb_private *lldb = talloc_get_type(handle->module->private_data, struct lldb_private);
- struct timeval timeout;
+ struct lldb_context *ac;
+ struct tevent_timer *lte;
+ struct timeval tv;
LDAPMessage *result;
- int ret, lret;
+ int lret;
- if (handle->state == LDB_ASYNC_DONE) {
- return handle->status;
+ ac = talloc_get_type(private_data, struct lldb_context);
+
+ if (!ac->msgid) {
+ lldb_request_done(ac, NULL, LDB_ERR_OPERATIONS_ERROR);
+ return;
}
- if (!ac || !ac->msgid) {
- return LDB_ERR_OPERATIONS_ERROR;
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ lret = ldap_result(ac->lldb->ldap, ac->msgid, 0, &tv, &result);
+ if (lret == 0) {
+ goto respin;
+ }
+ if (lret == -1) {
+ lldb_request_done(ac, NULL, LDB_ERR_OPERATIONS_ERROR);
+ return;
}
- handle->state = LDB_ASYNC_PENDING;
- handle->status = LDB_SUCCESS;
+ if ( ! lldb_parse_result(ac, result)) {
+ goto respin;
+ }
- switch(type) {
- case LDB_WAIT_NONE:
+ return;
- if ((ac->timeout != -1) &&
- ((ac->starttime + ac->timeout) > time(NULL))) {
- return LDB_ERR_TIME_LIMIT_EXCEEDED;
- }
+respin:
+ tv.tv_sec = 0;
+ tv.tv_usec = 100;
+ lte = tevent_add_timer(ev, ac, tv, lldb_callback, ac);
+ if (NULL == lte) {
+ lldb_request_done(ac, NULL, LDB_ERR_OPERATIONS_ERROR);
+ }
+}
- timeout.tv_sec = 0;
- timeout.tv_usec = 0;
+static bool lldb_dn_is_special(struct ldb_request *req)
+{
+ struct ldb_dn *dn = NULL;
- lret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
- if (lret == -1) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- if (lret == 0) {
- ret = LDB_SUCCESS;
- goto done;
- }
+ switch (req->operation) {
+ case LDB_ADD:
+ dn = req->op.add.message->dn;
+ break;
+ case LDB_MODIFY:
+ dn = req->op.mod.message->dn;
+ break;
+ case LDB_DELETE:
+ dn = req->op.del.dn;
+ break;
+ case LDB_RENAME:
+ dn = req->op.rename.olddn;
+ break;
+ default:
+ break;
+ }
- return lldb_parse_result(handle, result);
+ if (dn && ldb_dn_is_special(dn)) {
+ return true;
+ }
+ return false;
+}
- case LDB_WAIT_ALL:
- timeout.tv_usec = 0;
- ret = LDB_ERR_OPERATIONS_ERROR;
+static void lldb_auto_done_callback(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t,
+ void *private_data)
+{
+ struct lldb_context *ac;
+
+ ac = talloc_get_type(private_data, struct lldb_context);
+ lldb_request_done(ac, NULL, LDB_SUCCESS);
+}
- while (handle->status == LDB_SUCCESS && handle->state != LDB_ASYNC_DONE) {
+static int lldb_handle_request(struct ldb_module *module, struct ldb_request *req)
+{
+ struct ldb_context *ldb;
+ struct lldb_private *lldb;
+ struct lldb_context *ac;
+ struct tevent_context *ev;
+ struct tevent_timer *te;
+ struct timeval tv;
+ int ret;
- if (ac->timeout == -1) {
- lret = ldap_result(lldb->ldap, ac->msgid, 0, NULL, &result);
- } else {
- timeout.tv_sec = ac->timeout - (time(NULL) - ac->starttime);
- if (timeout.tv_sec <= 0)
- return LDB_ERR_TIME_LIMIT_EXCEEDED;
- lret = ldap_result(lldb->ldap, ac->msgid, 0, &timeout, &result);
- }
- if (lret == -1) {
- return LDB_ERR_OPERATIONS_ERROR;
- }
- if (lret == 0) {
- return LDB_ERR_TIME_LIMIT_EXCEEDED;
- }
+ lldb = talloc_get_type(ldb_module_get_private(module), struct lldb_private);
+ ldb = ldb_module_get_ctx(module);
- ret = lldb_parse_result(handle, result);
- if (ret != LDB_SUCCESS) {
- return ret;
- }
+ if (req->starttime == 0 || req->timeout == 0) {
+ ldb_set_errstring(ldb, "Invalid timeout settings");
+ return LDB_ERR_TIME_LIMIT_EXCEEDED;
+ }
+
+ ev = ldb_get_event_context(ldb);
+ if (NULL == ev) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac = talloc_zero(ldb, struct lldb_context);
+ if (ac == NULL) {
+ ldb_set_errstring(ldb, "Out of Memory");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->module = module;
+ ac->req = req;
+ ac->lldb = lldb;
+ ac->msgid = 0;
+
+ if (lldb_dn_is_special(req)) {
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ te = tevent_add_timer(ev, ac, tv,
+ lldb_auto_done_callback, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
+ return LDB_SUCCESS;
+ }
+
+ switch (ac->req->operation) {
+ case LDB_SEARCH:
+ ret = lldb_search(ac);
+ break;
+ case LDB_ADD:
+ ret = lldb_add(ac);
+ break;
+ case LDB_MODIFY:
+ ret = lldb_modify(ac);
+ break;
+ case LDB_DELETE:
+ ret = lldb_delete(ac);
+ break;
+ case LDB_RENAME:
+ ret = lldb_rename(ac);
break;
-
default:
- handle->state = LDB_ASYNC_DONE;
+ /* no other op supported */
ret = LDB_ERR_OPERATIONS_ERROR;
+ break;
}
-done:
- return ret;
-}
-
-static int lldb_start_trans(struct ldb_module *module)
-{
- /* TODO implement a local transaction mechanism here */
-
- return LDB_SUCCESS;
-}
+ if (ret != LDB_SUCCESS) {
+ lldb_request_done(ac, NULL, ret);
+ return ret;
+ }
-static int lldb_end_trans(struct ldb_module *module)
-{
- /* TODO implement a local transaction mechanism here */
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ te = tevent_add_timer(ev, ac, tv, lldb_callback, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
- return LDB_SUCCESS;
-}
-static int lldb_del_trans(struct ldb_module *module)
-{
- /* TODO implement a local transaction mechanism here */
+ tv.tv_sec = req->starttime + req->timeout;
+ tv.tv_usec = 0;
+ te = tevent_add_timer(ev, ac, tv, lldb_timeout, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
return LDB_SUCCESS;
}
-static int lldb_request(struct ldb_module *module, struct ldb_request *req)
-{
- return LDB_ERR_OPERATIONS_ERROR;
-}
-
static const struct ldb_module_ops lldb_ops = {
.name = "ldap",
- .search = lldb_search,
- .add = lldb_add,
- .modify = lldb_modify,
- .del = lldb_delete,
- .rename = lldb_rename,
- .request = lldb_request,
+ .search = lldb_handle_request,
+ .add = lldb_handle_request,
+ .modify = lldb_handle_request,
+ .del = lldb_handle_request,
+ .rename = lldb_handle_request,
+ .request = lldb_handle_request,
.start_transaction = lldb_start_trans,
.end_transaction = lldb_end_trans,
.del_transaction = lldb_del_trans,
- .async_wait = lldb_async_wait
};
connect to the database
*/
static int lldb_connect(struct ldb_context *ldb,
- const char *url,
- unsigned int flags,
+ const char *url,
+ unsigned int flags,
const char *options[],
- struct ldb_module **module)
+ struct ldb_module **_module)
{
- struct lldb_private *lldb = NULL;
+ struct ldb_module *module;
+ struct lldb_private *lldb;
int version = 3;
int ret;
- lldb = talloc(ldb, struct lldb_private);
+ module = ldb_module_new(ldb, ldb, "ldb_ldap backend", &lldb_ops);
+ if (!module) return -1;
+
+ lldb = talloc_zero(module, struct lldb_private);
if (!lldb) {
ldb_oom(ldb);
goto failed;
}
-
- lldb->ldap = NULL;
+ ldb_module_set_private(module, lldb);
ret = ldap_initialize(&lldb->ldap, url);
if (ret != LDAP_SUCCESS) {
goto failed;
}
- *module = talloc(ldb, struct ldb_module);
- if (!module) {
- ldb_oom(ldb);
- talloc_free(lldb);
- return -1;
- }
- (*module)->ldb = ldb;
- (*module)->prev = (*module)->next = NULL;
- (*module)->private_data = lldb;
- (*module)->ops = &lldb_ops;
-
+ *_module = module;
return 0;
failed:
- talloc_free(lldb);
+ talloc_free(module);
return -1;
}
-int ldb_ldap_init(void)
-{
- return ldb_register_backend("ldap", lldb_connect) +
- ldb_register_backend("ldapi", lldb_connect) +
- ldb_register_backend("ldaps", lldb_connect);
-}
+const struct ldb_backend_ops ldb_ldap_backend_ops = {
+ .name = "ldap",
+ .connect_fn = lldb_connect
+};
+
+const struct ldb_backend_ops ldb_ldapi_backend_ops = {
+ .name = "ldapi",
+ .connect_fn = lldb_connect
+};
+
+const struct ldb_backend_ops ldb_ldaps_backend_ops = {
+ .name = "ldaps",
+ .connect_fn = lldb_connect
+};
git.samba.org / metze / samba / wip.git / blobdiff