Copyright (C) Andrew Tridgell 2005
- ** NOTE! The following LGPL license applies to the ldb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
- 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 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- 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, see <http://www.gnu.org/licenses/>.
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
*/
#include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
+#include "ldb_module.h"
#include "auth/credentials/credentials.h"
struct proxy_data {
*/
static int load_proxy_info(struct ldb_module *module)
{
- struct proxy_data *proxy = talloc_get_type(module->private_data, struct proxy_data);
+ struct ldb_context *ldb = ldb_module_get_ctx(module);
+ struct proxy_data *proxy = talloc_get_type(ldb_module_get_private(module), struct proxy_data);
struct ldb_dn *dn;
struct ldb_result *res = NULL;
int ret;
/* see if we have already loaded it */
if (proxy->upstream != NULL) {
- return 0;
+ return LDB_SUCCESS;
}
- dn = ldb_dn_new(proxy, module->ldb, "@PROXYINFO");
+ dn = ldb_dn_new(proxy, ldb, "@PROXYINFO");
if (dn == NULL) {
goto failed;
}
- ret = ldb_search(module->ldb, proxy, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
+ ret = ldb_search(ldb, proxy, &res, dn, LDB_SCOPE_BASE, NULL, NULL);
talloc_free(dn);
if (ret != LDB_SUCCESS || res->count != 1) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "Can't find @PROXYINFO\n");
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "Can't find @PROXYINFO\n");
goto failed;
}
newstr = ldb_msg_find_attr_as_string(res->msgs[0], "newstr", NULL);
if (url == NULL || olddn == NULL || newdn == NULL || username == NULL || password == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "Need url, olddn, newdn, oldstr, newstr, username and password in @PROXYINFO\n");
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "Need url, olddn, newdn, oldstr, newstr, username and password in @PROXYINFO\n");
goto failed;
}
- proxy->olddn = ldb_dn_new(proxy, module->ldb, olddn);
+ proxy->olddn = ldb_dn_new(proxy, ldb, olddn);
if (proxy->olddn == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "Failed to explode olddn '%s'\n", olddn);
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "Failed to explode olddn '%s'\n", olddn);
goto failed;
}
- proxy->newdn = ldb_dn_new(proxy, module->ldb, newdn);
+ proxy->newdn = ldb_dn_new(proxy, ldb, newdn);
if (proxy->newdn == NULL) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "Failed to explode newdn '%s'\n", newdn);
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "Failed to explode newdn '%s'\n", newdn);
goto failed;
}
proxy->upstream = ldb_init(proxy, ldb_get_event_context(ldb));
if (proxy->upstream == NULL) {
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
goto failed;
}
proxy->oldstr = str_list_make(proxy, oldstr, ", ");
if (proxy->oldstr == NULL) {
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
goto failed;
}
proxy->newstr = str_list_make(proxy, newstr, ", ");
if (proxy->newstr == NULL) {
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
goto failed;
}
/* setup credentials for connection */
creds = cli_credentials_init(proxy->upstream);
if (creds == NULL) {
- ldb_oom(module->ldb);
+ ldb_oom(ldb);
goto failed;
}
- cli_credentials_guess(creds, ldb_get_opaque(module->ldb, "loadparm"));
+ cli_credentials_guess(creds, ldb_get_opaque(ldb, "loadparm"));
cli_credentials_set_username(creds, username, CRED_SPECIFIED);
cli_credentials_set_password(creds, password, CRED_SPECIFIED);
ldb_set_opaque(proxy->upstream, "credentials", creds);
ret = ldb_connect(proxy->upstream, url, 0, NULL);
- if (ret != 0) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "proxy failed to connect to %s\n", url);
+ if (ret != LDB_SUCCESS) {
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "proxy failed to connect to %s\n", url);
goto failed;
}
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "proxy connected to %s\n", url);
+ ldb_debug(ldb, LDB_DEBUG_TRACE, "proxy connected to %s\n", url);
talloc_free(res);
- return 0;
+ return LDB_SUCCESS;
failed:
talloc_free(res);
talloc_free(proxy->newdn);
talloc_free(proxy->upstream);
proxy->upstream = NULL;
- return -1;
+ return ldb_operr(ldb);
}
static void proxy_convert_blob(TALLOC_CTX *mem_ctx, struct ldb_val *v,
const char *oldstr, const char *newstr)
{
- int len1, len2, len3;
+ size_t len1, len2, len3;
uint8_t *olddata = v->data;
char *p = strcasestr((char *)v->data, oldstr);
*/
static void proxy_convert_value(struct proxy_data *proxy, struct ldb_message *msg, struct ldb_val *v)
{
- int i;
+ size_t i;
for (i=0;proxy->oldstr[i];i++) {
char *p = strcasestr((char *)v->data, proxy->oldstr[i]);
struct proxy_data *proxy,
struct ldb_parse_tree *tree)
{
- int i;
+ size_t i;
char *expression = ldb_filter_from_tree(mem_ctx, tree);
for (i=0;proxy->newstr[i];i++) {
struct proxy_data *proxy,
struct ldb_message *msg)
{
- int attr, v;
+ unsigned int attr, v;
/* fix the message DN */
if (ldb_dn_compare_base(proxy->olddn, msg->dn) == 0) {
static int proxy_search_callback(struct ldb_request *req,
struct ldb_reply *ares)
{
+ struct ldb_context *ldb;
struct proxy_data *proxy;
struct proxy_ctx *ac;
int ret;
ac = talloc_get_type(req->context, struct proxy_ctx);
- proxy = talloc_get_type(ac->module->private_data, struct proxy_data);
+ ldb = ldb_module_get_ctx(ac->module);
+ proxy = talloc_get_type(ldb_module_get_private(module), struct proxy_data);
if (!ares) {
return ldb_module_done(ac->req, NULL, NULL,
#ifdef DEBUG_PROXY
ac->count++;
#endif
- proxy_convert_record(ac->module->ldb, proxy, ares->message);
- ret = ldb_module_send_entry(ac->req, ares->message);
+ proxy_convert_record(ldb, proxy, ares->message);
+ ret = ldb_module_send_entry(ac->req, ares->message, ares->controls);
break;
case LDB_REPLY_REFERRAL:
/* search */
static int proxy_search_bytree(struct ldb_module *module, struct ldb_request *req)
{
+ struct ldb_context *ldb;
struct proxy_ctx *ac;
struct ldb_parse_tree *newtree;
- struct proxy_data *proxy = talloc_get_type(module->private_data, struct proxy_data);
+ struct proxy_data *proxy = talloc_get_type(ldb_module_get_private(module), struct proxy_data);
struct ldb_request *newreq;
struct ldb_dn *base;
- int ret, i;
+ unsigned int i;
+ int ret;
+
+ ldb = ldb_module_get_ctx(module);
if (req->op.search.base == NULL ||
(req->op.search.base->comp_num == 1 &&
goto passthru;
}
- if (load_proxy_info(module) != 0) {
- return LDB_ERR_OPERATIONS_ERROR;
+ if (load_proxy_info(module) != LDB_SUCCESS) {
+ return ldb_operr(ldb);
}
/* see if the dn is within olddn */
ac = talloc(req, struct proxy_ctx);
if (ac == NULL) {
- return LDB_ERR_OPERATIONS_ERROR;
+ return ldb_oom(ldb);
}
ac->module = module;
#endif
newtree = proxy_convert_tree(ac, proxy, req->op.search.tree);
+ if (newtree == NULL) {
+ goto failed;
+ }
/* convert the basedn of this search */
base = ldb_dn_copy(ac, req->op.search.base);
ldb_dn_remove_base_components(base, ldb_dn_get_comp_num(proxy->newdn));
ldb_dn_add_base(base, proxy->olddn);
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "proxying: '%s' with dn '%s' \n",
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "proxying: '%s' with dn '%s' \n",
ldb_filter_from_tree(ac, newreq->op.search.tree), ldb_dn_get_linearized(newreq->op.search.base));
for (i = 0; req->op.search.attrs && req->op.search.attrs[i]; i++) {
- ldb_debug(module->ldb, LDB_DEBUG_FATAL, "attr: '%s'\n", req->op.search.attrs[i]);
+ ldb_debug(ldb, LDB_DEBUG_FATAL, "attr: '%s'\n", req->op.search.attrs[i]);
}
- ret = ldb_build_search_req_ex(&newreq, module->ldb, ac,
+ ret = ldb_build_search_req_ex(&newreq, ldb, ac,
base, req->op.search.scope,
newtree, req->op.search.attrs,
req->controls,
ac, proxy_search_callback,
req);
-
+ LDB_REQ_SET_LOCATION(newreq);
/* FIXME: warning, need a real event system hooked up for this to work properly,
* for now this makes the module *not* ASYNC */
ret = ldb_request(proxy->upstream, newreq);
if (ret != LDB_SUCCESS) {
- ldb_set_errstring(module->ldb, ldb_errstring(proxy->upstream));
+ ldb_set_errstring(ldb, ldb_errstring(proxy->upstream));
}
ret = ldb_wait(newreq->handle, LDB_WAIT_ALL);
if (ret != LDB_SUCCESS) {
- ldb_set_errstring(module->ldb, ldb_errstring(proxy->upstream));
+ ldb_set_errstring(ldb, ldb_errstring(proxy->upstream));
}
return ret;
failed:
- ldb_debug(module->ldb, LDB_DEBUG_TRACE, "proxy failed for %s\n",
+ ldb_debug(ldb, LDB_DEBUG_TRACE, "proxy failed for %s\n",
ldb_dn_get_linearized(req->op.search.base));
passthru:
}
}
-_PUBLIC_ const struct ldb_module_ops ldb_proxy_module_ops = {
+static const struct ldb_module_ops ldb_proxy_module_ops = {
.name = "proxy",
.request = proxy_request
};
+
+int ldb_proxy_module_init(const char *version)
+{
+ LDB_MODULE_CHECK_VERSION(version);
+ return ldb_register_module(&ldb_proxy_module_ops);
+}