ldb database library
Copyright (C) Derrell Lipman 2005
- Copyright (C) Simo Sorce 2005
+ Copyright (C) Simo Sorce 2005-2006
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
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: Derrell Lipman (based on Andrew Tridgell's LDAP backend)
*/
-#include <stdarg.h>
-#include "includes.h"
-#include "ldb/include/ldb.h"
-#include "ldb/include/ldb_errors.h"
-#include "ldb/include/ldb_private.h"
-#include "ldb/ldb_sqlite3/ldb_sqlite3.h"
+#include "ldb_module.h"
+
+#include <sqlite3.h>
+
+struct lsqlite3_private {
+ int trans_count;
+ char **options;
+ sqlite3 *sqlite;
+};
+
+struct lsql_context {
+ struct ldb_module *module;
+ struct ldb_request *req;
+
+ /* search stuff */
+ long long current_eid;
+ const char * const * attrs;
+ struct ldb_reply *ares;
+};
/*
* Macros used throughout
return ret;
}
-static unsigned char base160tab[161] = {
+static char base160tab[161] = {
48 ,49 ,50 ,51 ,52 ,53 ,54 ,55 ,56 ,57 , /* 0-9 */
58 ,59 ,65 ,66 ,67 ,68 ,69 ,70 ,71 ,72 , /* : ; A-H */
73 ,74 ,75 ,76 ,77 ,78 ,79 ,80 ,81 ,82 , /* I-R */
{
int i;
int len;
- unsigned char * pTab;
- unsigned char * pBase160 =
- strdup(sqlite3_value_text(argv[0]));
- unsigned char * pStart = pBase160;
+ char * pTab;
+ char * pBase160 = strdup((const char *)sqlite3_value_text(argv[0]));
+ char * pStart = pBase160;
/*
* We need a minimum of four digits, and we will always get a multiple
void *mem_ctx,
const struct ldb_parse_tree *t)
{
- const struct ldb_attrib_handler *h;
+ const struct ldb_schema_attribute *a;
struct ldb_val value, subval;
char *wild_card_string;
char *child, *tmp;
* For simple searches, we want to retrieve the list of EIDs that
* match the criteria.
*/
- attr = ldb_casefold(mem_ctx, t->u.equality.attr);
+ attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
if (attr == NULL) return NULL;
- h = ldb_attrib_handler(module->ldb, attr);
+ a = ldb_schema_attribute_by_name(module->ldb, attr);
/* Get a canonicalised copy of the data */
- h->canonicalise_fn(module->ldb, mem_ctx, &(t->u.equality.value), &value);
+ a->syntax->canonicalise_fn(module->ldb, mem_ctx, &(t->u.equality.value), &value);
if (value.data == NULL) {
return NULL;
}
- if (strcasecmp(t->u.equality.attr, "objectclass") == 0) {
- /*
- * For object classes, we want to search for all objectclasses
- * that are subclasses as well.
- */
- return lsqlite3_tprintf(mem_ctx,
- "SELECT eid FROM ldb_attribute_values\n"
- "WHERE norm_attr_name = 'OBJECTCLASS' "
- "AND norm_attr_value IN\n"
- " (SELECT class_name FROM ldb_object_classes\n"
- " WHERE tree_key GLOB\n"
- " (SELECT tree_key FROM ldb_object_classes\n"
- " WHERE class_name = '%q'\n"
- " ) || '*'\n"
- " )\n", value.data);
-
- } else if (strcasecmp(t->u.equality.attr, "dn") == 0) {
+ if (strcasecmp(t->u.equality.attr, "dn") == 0) {
/* DN query is a special ldb case */
- char *cdn = ldb_dn_linearize_casefold(module->ldb,
- ldb_dn_explode(module->ldb,
- value.data));
+ const char *cdn = ldb_dn_get_casefold(
+ ldb_dn_new(mem_ctx, module->ldb,
+ (const char *)value.data));
return lsqlite3_tprintf(mem_ctx,
"SELECT eid FROM ldb_entry "
wild_card_string[strlen(wild_card_string) - 1] = '\0';
}
- attr = ldb_casefold(mem_ctx, t->u.substring.attr);
+ attr = ldb_attr_casefold(mem_ctx, t->u.substring.attr);
if (attr == NULL) return NULL;
- h = ldb_attrib_handler(module->ldb, attr);
+ a = ldb_schema_attribute_by_name(module->ldb, attr);
- subval.data = wild_card_string;
+ subval.data = (void *)wild_card_string;
subval.length = strlen(wild_card_string) + 1;
/* Get a canonicalised copy of the data */
- h->canonicalise_fn(module->ldb, mem_ctx, &(subval), &value);
+ a->syntax->canonicalise_fn(module->ldb, mem_ctx, &(subval), &value);
if (value.data == NULL) {
return NULL;
}
value.data);
case LDB_OP_GREATER:
- attr = ldb_casefold(mem_ctx, t->u.equality.attr);
+ attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
if (attr == NULL) return NULL;
- h = ldb_attrib_handler(module->ldb, attr);
+ a = ldb_schema_attribute_by_name(module->ldb, attr);
/* Get a canonicalised copy of the data */
- h->canonicalise_fn(module->ldb, mem_ctx, &(t->u.equality.value), &value);
+ a->syntax->canonicalise_fn(module->ldb, mem_ctx, &(t->u.equality.value), &value);
if (value.data == NULL) {
return NULL;
}
attr);
case LDB_OP_LESS:
- attr = ldb_casefold(mem_ctx, t->u.equality.attr);
+ attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
if (attr == NULL) return NULL;
- h = ldb_attrib_handler(module->ldb, attr);
+ a = ldb_schema_attribute_by_name(module->ldb, attr);
/* Get a canonicalised copy of the data */
- h->canonicalise_fn(module->ldb, mem_ctx, &(t->u.equality.value), &value);
+ a->syntax->canonicalise_fn(module->ldb, mem_ctx, &(t->u.equality.value), &value);
if (value.data == NULL) {
return NULL;
}
return talloc_strdup(mem_ctx, "SELECT eid FROM ldb_entry");
}
- attr = ldb_casefold(mem_ctx, t->u.present.attr);
+ attr = ldb_attr_casefold(mem_ctx, t->u.present.attr);
if (attr == NULL) return NULL;
return lsqlite3_tprintf(mem_ctx,
attr);
case LDB_OP_APPROX:
- attr = ldb_casefold(mem_ctx, t->u.equality.attr);
+ attr = ldb_attr_casefold(mem_ctx, t->u.equality.attr);
if (attr == NULL) return NULL;
- h = ldb_attrib_handler(module->ldb, attr);
+ a = ldb_schema_attribute_by_name(module->ldb, attr);
/* Get a canonicalised copy of the data */
- h->canonicalise_fn(module->ldb, mem_ctx, &(t->u.equality.value), &value);
+ a->syntax->canonicalise_fn(module->ldb, mem_ctx, &(t->u.equality.value), &value);
if (value.data == NULL) {
return NULL;
}
sqlite3_value **argv)
{
struct ldb_context *ldb = (struct ldb_context *)sqlite3_user_data(ctx);
- const unsigned char *val = sqlite3_value_text(argv[0]);
- const unsigned char *func = sqlite3_value_text(argv[1]);
- const unsigned char *cmp = sqlite3_value_text(argv[2]);
- const unsigned char *attr = sqlite3_value_text(argv[3]);
- const struct ldb_attrib_handler *h;
+ const char *val = (const char *)sqlite3_value_text(argv[0]);
+ const char *func = (const char *)sqlite3_value_text(argv[1]);
+ const char *cmp = (const char *)sqlite3_value_text(argv[2]);
+ const char *attr = (const char *)sqlite3_value_text(argv[3]);
+ const struct ldb_schema_attribute *a;
struct ldb_val valX;
struct ldb_val valY;
int ret;
switch (func[0]) {
/* greater */
case '>': /* >= */
- h = ldb_attrib_handler(ldb, attr);
- valX.data = cmp;
+ a = ldb_schema_attribute_by_name(ldb, attr);
+ valX.data = (void *)cmp;
valX.length = strlen(cmp);
- valY.data = val;
+ valY.data = (void *)val;
valY.length = strlen(val);
- ret = h->comparison_fn(ldb, ldb, &valY, &valX);
+ ret = a->syntax->comparison_fn(ldb, ldb, &valY, &valX);
if (ret >= 0)
sqlite3_result_int(ctx, 1);
else
/* lesser */
case '<': /* <= */
- h = ldb_attrib_handler(ldb, attr);
- valX.data = cmp;
+ a = ldb_schema_attribute_by_name(ldb, attr);
+ valX.data = (void *)cmp;
valX.length = strlen(cmp);
- valY.data = val;
+ valY.data = (void *)val;
valY.length = strlen(val);
- ret = h->comparison_fn(ldb, ldb, &valY, &valX);
+ ret = a->syntax->comparison_fn(ldb, ldb, &valY, &valX);
if (ret <= 0)
sqlite3_result_int(ctx, 1);
else
return SQLITE_OK;
}
-struct lsqlite3_msgs {
- int count;
- struct ldb_message **msgs;
- long long current_eid;
- const char * const * attrs;
- TALLOC_CTX *mem_ctx;
-};
-
/*
* add a single set of ldap message values to a ldb_message
*/
-
static int lsqlite3_search_callback(void *result, int col_num, char **cols, char **names)
{
- struct lsqlite3_msgs *msgs = (struct lsqlite3_msgs *)result;
+ struct ldb_handle *handle = talloc_get_type(result, struct ldb_handle);
+ struct lsql_context *ac = talloc_get_type(handle->private_data, struct lsql_context);
struct ldb_message *msg;
long long eid;
int i;
/* eid, dn, attr_name, attr_value */
- if (col_num != 4) return SQLITE_ABORT;
+ if (col_num != 4)
+ return SQLITE_ABORT;
eid = atoll(cols[0]);
- if (eid != msgs->current_eid) {
- msgs->msgs = talloc_realloc(msgs->mem_ctx,
- msgs->msgs,
- struct ldb_message *,
- msgs->count + 2);
- if (msgs->msgs == NULL) return SQLITE_ABORT;
+ if (eid != ac->current_eid) { /* here begin a new entry */
+
+ /* call the async callback for the last entry
+ * except the first time */
+ if (ac->current_eid != 0) {
+ ac->ares->message = ldb_msg_canonicalize(ac->module->ldb, ac->ares->message);
+ if (ac->ares->message == NULL)
+ return SQLITE_ABORT;
+
+ handle->status = ac->callback(ac->module->ldb, ac->context, ac->ares);
+ if (handle->status != LDB_SUCCESS)
+ return SQLITE_ABORT;
+ }
- msgs->msgs[msgs->count] = talloc(msgs->msgs, struct ldb_message);
- if (msgs->msgs[msgs->count] == NULL) return SQLITE_ABORT;
+ /* start over */
+ ac->ares = talloc_zero(ac, struct ldb_reply);
+ if (!ac->ares)
+ return SQLITE_ABORT;
- msgs->msgs[msgs->count]->dn = NULL;
- msgs->msgs[msgs->count]->num_elements = 0;
- msgs->msgs[msgs->count]->elements = NULL;
- msgs->msgs[msgs->count]->private_data = NULL;
+ ac->ares->message = ldb_msg_new(ac->ares);
+ if (!ac->ares->message)
+ return SQLITE_ABORT;
- msgs->count++;
- msgs->current_eid = eid;
+ ac->ares->type = LDB_REPLY_ENTRY;
+ ac->current_eid = eid;
}
- msg = msgs->msgs[msgs->count -1];
+ msg = ac->ares->message;
if (msg->dn == NULL) {
- msg->dn = ldb_dn_explode(msg, cols[1]);
- if (msg->dn == NULL) return SQLITE_ABORT;
+ msg->dn = ldb_dn_new(msg, ac->module->ldb, cols[1]);
+ if (msg->dn == NULL)
+ return SQLITE_ABORT;
}
- if (msgs->attrs) {
+ if (ac->attrs) {
int found = 0;
- for (i = 0; msgs->attrs[i]; i++) {
- if (strcasecmp(cols[2], msgs->attrs[i]) == 0) {
+ for (i = 0; ac->attrs[i]; i++) {
+ if (strcasecmp(cols[2], ac->attrs[i]) == 0) {
found = 1;
break;
}
}
- if (!found) return 0;
+ if (!found) return SQLITE_OK;
}
- msg->elements = talloc_realloc(msg,
- msg->elements,
- struct ldb_message_element,
- msg->num_elements + 1);
- if (msg->elements == NULL) return SQLITE_ABORT;
-
- msg->elements[msg->num_elements].flags = 0;
- msg->elements[msg->num_elements].name = talloc_strdup(msg->elements, cols[2]);
- if (msg->elements[msg->num_elements].name == NULL) return SQLITE_ABORT;
-
- msg->elements[msg->num_elements].num_values = 1;
- msg->elements[msg->num_elements].values = talloc_array(msg->elements,
- struct ldb_val, 1);
- if (msg->elements[msg->num_elements].values == NULL) return SQLITE_ABORT;
-
- msg->elements[msg->num_elements].values[0].length = strlen(cols[3]);
- msg->elements[msg->num_elements].values[0].data = talloc_strdup(msg->elements, cols[3]);
- if (msg->elements[msg->num_elements].values[0].data == NULL) return SQLITE_ABORT;
-
- msg->num_elements++;
+ if (ldb_msg_add_string(msg, cols[2], cols[3]) != 0) {
+ return SQLITE_ABORT;
+ }
return SQLITE_OK;
}
return eid;
}
-static long long lsqlite3_get_eid(struct ldb_module *module, const struct ldb_dn *dn)
+static long long lsqlite3_get_eid(struct ldb_module *module, struct ldb_dn *dn)
{
TALLOC_CTX *local_ctx;
struct lsqlite3_private *lsqlite3 = module->private_data;
return -1;
}
- cdn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, dn));
+ cdn = ldb_dn_alloc_casefold(local_ctx, dn);
if (!cdn) goto done;
eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, local_ctx, cdn);
*/
/* search for matching records, by tree */
-static int lsqlite3_search_bytree(struct ldb_module * module, const struct ldb_dn* basedn,
- enum ldb_scope scope, struct ldb_parse_tree * tree,
- const char * const * attrs, struct ldb_result ** res)
+int lsql_search(struct ldb_module *module, struct ldb_request *req)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
- struct lsqlite3_msgs msgs;
+ struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+ struct lsql_context *lsql_ac;
char *norm_basedn;
char *sqlfilter;
char *errmsg;
- char *query;
- int ret, i;
+ char *query = NULL;
+ int ret;
- /* create a local ctx */
- local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_search_bytree local context");
- if (local_ctx == NULL) {
- return -1;
- }
+ lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+
+ if ((( ! ldb_dn_is_valid(req->op.search.base)) || ldb_dn_is_null(req->op.search.base)) &&
+ (req->op.search.scope == LDB_SCOPE_BASE || req->op.search.scope == LDB_SCOPE_ONELEVEL))
+ return LDB_ERR_OPERATIONS_ERROR;
- if (basedn) {
- norm_basedn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, basedn));
+ if (req->op.search.base) {
+ norm_basedn = ldb_dn_alloc_casefold(lsql_ac, req->op.search.base);
if (norm_basedn == NULL) {
ret = LDB_ERR_INVALID_DN_SYNTAX;
goto failed;
}
- } else norm_basedn = talloc_strdup(local_ctx, "");
-
- if (*norm_basedn == '\0' &&
- (scope == LDB_SCOPE_BASE || scope == LDB_SCOPE_ONELEVEL)) {
- ret = LDB_ERR_UNWILLING_TO_PERFORM;
- goto failed;
- }
+ } else norm_basedn = talloc_strdup(lsql_ac, "");
/* Convert filter into a series of SQL conditions (constraints) */
- sqlfilter = parsetree_to_sql(module, local_ctx, tree);
+ sqlfilter = parsetree_to_sql(module, lsql_ac, req->op.search.tree);
- switch(scope) {
+ switch(req->op.search.scope) {
case LDB_SCOPE_DEFAULT:
case LDB_SCOPE_SUBTREE:
if (*norm_basedn != '\0') {
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(lsql_ac,
"SELECT entry.eid,\n"
" entry.dn,\n"
" av.attr_name,\n"
norm_basedn,
sqlfilter);
} else {
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(lsql_ac,
"SELECT entry.eid,\n"
" entry.dn,\n"
" av.attr_name,\n"
break;
case LDB_SCOPE_BASE:
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(lsql_ac,
"SELECT entry.eid,\n"
" entry.dn,\n"
" av.attr_name,\n"
break;
case LDB_SCOPE_ONELEVEL:
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(lsql_ac,
"SELECT entry.eid,\n"
" entry.dn,\n"
" av.attr_name,\n"
}
if (query == NULL) {
- ret = LDB_ERR_OTHER;
goto failed;
}
printf ("%s\n", query);
/ * */
- msgs.msgs = NULL;
- msgs.count = 0;
- msgs.current_eid = 0;
- msgs.mem_ctx = local_ctx;
- msgs.attrs = attrs;
+ lsql_ac->current_eid = 0;
+ lsql_ac->attrs = req->op.search.attrs;
+ lsql_ac->ares = NULL;
- ret = sqlite3_exec(lsqlite3->sqlite, query, lsqlite3_search_callback, &msgs, &errmsg);
+ req->handle->state = LDB_ASYNC_PENDING;
+
+ ret = sqlite3_exec(lsqlite3->sqlite, query, lsqlite3_search_callback, req->handle, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(module->ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
goto failed;
}
- for (i = 0; i < msgs.count; i++) {
- msgs.msgs[i] = ldb_msg_canonicalize(module->ldb, msgs.msgs[i]);
- if (msgs.msgs[i] == NULL) {
+ /* complete the last message if any */
+ if (lsql_ac->ares) {
+ lsql_ac->ares->message = ldb_msg_canonicalize(module->ldb, lsql_ac->ares->message);
+ if (lsql_ac->ares->message == NULL)
+ goto failed;
+
+ req->handle->status = lsql_ac->callback(module->ldb, lsql_ac->context, lsql_ac->ares);
+ if (req->handle->status != LDB_SUCCESS)
goto failed;
- }
- }
-
- *res = talloc(module, struct ldb_result);
- if (! *res) {
- goto failed;
}
- (*res)->msgs = talloc_steal(*res, msgs.msgs);
- (*res)->count = msgs.count;
- (*res)->controls = NULL;
+ req->handle->state = LDB_ASYNC_DONE;
- talloc_free(local_ctx);
return LDB_SUCCESS;
-/* If error, return error code; otherwise return number of results */
failed:
- talloc_free(local_ctx);
- return LDB_ERR_OTHER;
+ return LDB_ERR_OPERATIONS_ERROR;
}
-
/* add a record */
-static int lsqlite3_add(struct ldb_module *module, const struct ldb_message *msg)
+static int lsql_add(struct ldb_module *module, struct ldb_request *req)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
+ struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+ struct lsql_context *lsql_ac;
+ struct ldb_message *msg = req->op.add.message;
long long eid;
char *dn, *ndn;
char *errmsg;
char *query;
- int ret;
int i;
-
- /* create a local ctx */
- local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_add local context");
- if (local_ctx == NULL) {
- return LDB_ERR_OTHER;
- }
+ int ret = LDB_SUCCESS;
+
+ lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+ req->handle->state = LDB_ASYNC_DONE;
+ req->handle->status = LDB_SUCCESS;
/* See if this is an ltdb special */
if (ldb_dn_is_special(msg->dn)) {
- struct ldb_dn *c;
-
- c = ldb_dn_explode(local_ctx, "@SUBCLASSES");
- if (ldb_dn_compare(module->ldb, msg->dn, c) == 0) {
-#warning "insert subclasses into object class tree"
- ret = LDB_ERR_UNWILLING_TO_PERFORM;
- goto failed;
- }
-
/*
- c = ldb_dn_explode(local_ctx, "@INDEXLIST");
+ struct ldb_dn *c;
+ c = ldb_dn_new(local_ctx, module->ldb, "@INDEXLIST");
if (ldb_dn_compare(module->ldb, msg->dn, c) == 0) {
#warning "should we handle indexes somehow ?"
- goto failed;
+ ret = LDB_ERR_UNWILLING_TO_PERFORM;
+ goto done;
}
*/
- /* Others are implicitly ignored */
- return LDB_SUCCESS;
+ /* Others return an error */
+ ret = LDB_ERR_UNWILLING_TO_PERFORM;
+ goto done;
}
/* create linearized and normalized dns */
- dn = ldb_dn_linearize(local_ctx, msg->dn);
- ndn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, msg->dn));
+ dn = ldb_dn_alloc_linearized(lsql_ac, msg->dn);
+ ndn = ldb_dn_alloc_casefold(lsql_ac, msg->dn);
if (dn == NULL || ndn == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(lsql_ac,
/* Add new entry */
"INSERT OR ABORT INTO ldb_entry "
"('dn', 'norm_dn') "
dn, ndn);
if (query == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
ret = sqlite3_exec(lsqlite3->sqlite, query, NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(module->ldb, errmsg);
free(errmsg);
}
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
- eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, local_ctx, ndn);
+ eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, lsql_ac, ndn);
if (eid == -1) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
for (i = 0; i < msg->num_elements; i++) {
const struct ldb_message_element *el = &msg->elements[i];
- const struct ldb_attrib_handler *h;
+ const struct ldb_schema_attribute *a;
char *attr;
int j;
/* Get a case-folded copy of the attribute name */
- attr = ldb_casefold(local_ctx, el->name);
+ attr = ldb_attr_casefold(lsql_ac, el->name);
if (attr == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
- h = ldb_attrib_handler(module->ldb, el->name);
+ a = ldb_schema_attribute_by_name(module->ldb, el->name);
/* For each value of the specified attribute name... */
for (j = 0; j < el->num_values; j++) {
char *insert;
/* Get a canonicalised copy of the data */
- h->canonicalise_fn(module->ldb, local_ctx, &(el->values[j]), &value);
+ a->syntax->canonicalise_fn(module->ldb, lsql_ac, &(el->values[j]), &value);
if (value.data == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
- insert = lsqlite3_tprintf(local_ctx,
+ insert = lsqlite3_tprintf(lsql_ac,
"INSERT OR ROLLBACK INTO ldb_attribute_values "
"('eid', 'attr_name', 'norm_attr_name',"
" 'attr_value', 'norm_attr_value') "
el->values[j].data, value.data);
if (insert == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
ret = sqlite3_exec(lsqlite3->sqlite, insert, NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(module->ldb, errmsg);
free(errmsg);
}
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
}
}
- talloc_free(local_ctx);
- return LDB_SUCCESS;
-
-failed:
- talloc_free(local_ctx);
+ if (lsql_ac->callback) {
+ req->handle->status = lsql_ac->callback(module->ldb, lsql_ac->context, NULL);
+ }
+
+done:
+ req->handle->state = LDB_ASYNC_DONE;
return ret;
}
-
/* modify a record */
-static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *msg)
+static int lsql_modify(struct ldb_module *module, struct ldb_request *req)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
+ struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+ struct lsql_context *lsql_ac;
+ struct ldb_message *msg = req->op.mod.message;
long long eid;
char *errmsg;
- int ret;
int i;
-
- /* create a local ctx */
- local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_modify local context");
- if (local_ctx == NULL) {
- return LDB_ERR_OTHER;
- }
+ int ret = LDB_SUCCESS;
+
+ lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+ req->handle->state = LDB_ASYNC_DONE;
+ req->handle->status = LDB_SUCCESS;
/* See if this is an ltdb special */
if (ldb_dn_is_special(msg->dn)) {
- struct ldb_dn *c;
-
- c = ldb_dn_explode(local_ctx, "@SUBCLASSES");
- if (ldb_dn_compare(module->ldb, msg->dn, c) == 0) {
-#warning "modify subclasses into object class tree"
- ret = LDB_ERR_UNWILLING_TO_PERFORM;
- goto failed;
- }
-
- /* Others are implicitly ignored */
- return LDB_SUCCESS;
+ /* Others return an error */
+ ret = LDB_ERR_UNWILLING_TO_PERFORM;
+ goto done;
}
eid = lsqlite3_get_eid(module, msg->dn);
if (eid == -1) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
for (i = 0; i < msg->num_elements; i++) {
const struct ldb_message_element *el = &msg->elements[i];
- const struct ldb_attrib_handler *h;
+ const struct ldb_schema_attribute *a;
int flags = el->flags & LDB_FLAG_MOD_MASK;
char *attr;
char *mod;
int j;
/* Get a case-folded copy of the attribute name */
- attr = ldb_casefold(local_ctx, el->name);
+ attr = ldb_attr_casefold(lsql_ac, el->name);
if (attr == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
- h = ldb_attrib_handler(module->ldb, el->name);
+ a = ldb_schema_attribute_by_name(module->ldb, el->name);
switch (flags) {
case LDB_FLAG_MOD_REPLACE:
/* remove all attributes before adding the replacements */
- mod = lsqlite3_tprintf(local_ctx,
+ mod = lsqlite3_tprintf(lsql_ac,
"DELETE FROM ldb_attribute_values "
"WHERE eid = '%lld' "
"AND norm_attr_name = '%q';",
eid, attr);
if (mod == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(module->ldb, errmsg);
free(errmsg);
}
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
/* MISSING break is INTENTIONAL */
struct ldb_val value;
/* Get a canonicalised copy of the data */
- h->canonicalise_fn(module->ldb, local_ctx, &(el->values[j]), &value);
+ a->syntax->canonicalise_fn(module->ldb, lsql_ac, &(el->values[j]), &value);
if (value.data == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
- mod = lsqlite3_tprintf(local_ctx,
+ mod = lsqlite3_tprintf(lsql_ac,
"INSERT OR ROLLBACK INTO ldb_attribute_values "
"('eid', 'attr_name', 'norm_attr_name',"
" 'attr_value', 'norm_attr_value') "
if (mod == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(module->ldb, errmsg);
free(errmsg);
}
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
}
case LDB_FLAG_MOD_DELETE:
#warning "We should throw an error if the attribute we are trying to delete does not exist!"
if (el->num_values == 0) {
- mod = lsqlite3_tprintf(local_ctx,
+ mod = lsqlite3_tprintf(lsql_ac,
"DELETE FROM ldb_attribute_values "
"WHERE eid = '%lld' "
"AND norm_attr_name = '%q';",
eid, attr);
if (mod == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(module->ldb, errmsg);
free(errmsg);
}
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
}
struct ldb_val value;
/* Get a canonicalised copy of the data */
- h->canonicalise_fn(module->ldb, local_ctx, &(el->values[j]), &value);
+ a->syntax->canonicalise_fn(module->ldb, lsql_ac, &(el->values[j]), &value);
if (value.data == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
- mod = lsqlite3_tprintf(local_ctx,
+ mod = lsqlite3_tprintf(lsql_ac,
"DELETE FROM ldb_attribute_values "
"WHERE eid = '%lld' "
"AND norm_attr_name = '%q' "
if (mod == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
ret = sqlite3_exec(lsqlite3->sqlite, mod, NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(module->ldb, errmsg);
free(errmsg);
}
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
}
}
}
- talloc_free(local_ctx);
- return LDB_SUCCESS;
-
-failed:
- talloc_free(local_ctx);
+ if (lsql_ac->callback) {
+ req->handle->status = lsql_ac->callback(module->ldb, lsql_ac->context, NULL);
+ }
+
+done:
+ req->handle->state = LDB_ASYNC_DONE;
return ret;
}
/* delete a record */
-static int lsqlite3_delete(struct ldb_module *module, const struct ldb_dn *dn)
+static int lsql_delete(struct ldb_module *module, struct ldb_request *req)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
+ struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+ struct lsql_context *lsql_ac;
long long eid;
char *errmsg;
char *query;
- int ret;
+ int ret = LDB_SUCCESS;
- /* ignore ltdb specials */
- if (ldb_dn_is_special(dn)) {
- return LDB_SUCCESS;
- }
- /* create a local ctx */
- local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_delete local context");
- if (local_ctx == NULL) {
- return LDB_ERR_OTHER;
- }
+ lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+ req->handle->state = LDB_ASYNC_DONE;
+ req->handle->status = LDB_SUCCESS;
- eid = lsqlite3_get_eid(module, dn);
+ eid = lsqlite3_get_eid(module, req->op.del.dn);
if (eid == -1) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(lsql_ac,
/* Delete entry */
"DELETE FROM ldb_entry WHERE eid = %lld; "
/* Delete attributes */
eid, eid);
if (query == NULL) {
ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
ret = sqlite3_exec(lsqlite3->sqlite, query, NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(module->ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ req->handle->status = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
}
- talloc_free(local_ctx);
- return LDB_SUCCESS;
-
-failed:
- talloc_free(local_ctx);
+ if (lsql_ac->callback) {
+ ret = lsql_ac->callback(module->ldb, lsql_ac->context, NULL);
+ }
+
+done:
+ req->handle->state = LDB_ASYNC_DONE;
return ret;
}
/* rename a record */
-static int lsqlite3_rename(struct ldb_module *module, const struct ldb_dn *olddn, const struct ldb_dn *newdn)
+static int lsql_rename(struct ldb_module *module, struct ldb_request *req)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
+ struct lsqlite3_private *lsqlite3 = talloc_get_type(module->private_data, struct lsqlite3_private);
+ struct lsql_context *lsql_ac;
char *new_dn, *new_cdn, *old_cdn;
char *errmsg;
char *query;
- int ret;
-
- /* ignore ltdb specials */
- if (ldb_dn_is_special(olddn) || ldb_dn_is_special(newdn)) {
- return LDB_SUCCESS;
- }
+ int ret = LDB_SUCCESS;
- /* create a local ctx */
- local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_rename local context");
- if (local_ctx == NULL) {
- return LDB_ERR_OTHER;
- }
+ lsql_ac = talloc_get_type(req->handle->private_data, struct lsql_context);
+ req->handle->state = LDB_ASYNC_DONE;
+ req->handle->status = LDB_SUCCESS;
/* create linearized and normalized dns */
- old_cdn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, olddn));
- new_cdn = ldb_dn_linearize(local_ctx, ldb_dn_casefold(module->ldb, newdn));
- new_dn = ldb_dn_linearize(local_ctx, newdn);
+ old_cdn = ldb_dn_alloc_casefold(lsql_ac, req->op.rename.olddn);
+ new_cdn = ldb_dn_alloc_casefold(lsql_ac, req->op.rename.newdn);
+ new_dn = ldb_dn_alloc_linearized(lsql_ac, req->op.rename.newdn);
if (old_cdn == NULL || new_cdn == NULL || new_dn == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
/* build the SQL query */
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(lsql_ac,
"UPDATE ldb_entry SET dn = '%q', norm_dn = '%q' "
"WHERE norm_dn = '%q';",
new_dn, new_cdn, old_cdn);
if (query == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ goto done;
}
/* execute */
ret = sqlite3_exec(lsqlite3->sqlite, query, NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(module->ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ ret = LDB_ERR_OPERATIONS_ERROR;
+ goto done;
}
- /* clean up and exit */
- talloc_free(local_ctx);
- return LDB_SUCCESS;
+ if (lsql_ac->callback) {
+ ret = lsql_ac->callback(module->ldb, lsql_ac->context, NULL);
+ }
-failed:
- talloc_free(local_ctx);
+done:
+ req->handle->state = LDB_ASYNC_DONE;
return ret;
}
-static int lsqlite3_start_trans(struct ldb_module * module)
+static int lsql_start_trans(struct ldb_module * module)
{
int ret;
char *errmsg;
return 0;
}
-static int lsqlite3_end_trans(struct ldb_module *module)
+static int lsql_end_trans(struct ldb_module *module)
{
int ret;
char *errmsg;
return 0;
}
-static int lsqlite3_del_trans(struct ldb_module *module)
+static int lsql_del_trans(struct ldb_module *module)
{
struct lsqlite3_private *lsqlite3 = module->private_data;
return -1;
}
+static int destructor(struct lsqlite3_private *lsqlite3)
+{
+ if (lsqlite3->sqlite) {
+ sqlite3_close(lsqlite3->sqlite);
+ }
+ return 0;
+}
+
+static int lsql_request(struct ldb_module *module, struct ldb_request *req)
+{
+ return LDB_ERR_OPERATIONS_ERROR;
+}
+
+static int lsql_run_request(struct ldb_module *module, struct ldb_request *req)
+{
+ switch (req->operation) {
+ case LDB_SEARCH:
+ return lsql_search(module, req);
+ break;
+ case LDB_ADD:
+ return lsql_add(module, req);
+ break;
+ case LDB_MODIFY:
+ return lsql_modify(module, req);
+ break;
+ case LDB_DELETE:
+ return lsql_delete(module, req);
+ break;
+ case LDB_RENAME:
+ return lsql_rename(module, req);
+ break;
+/* TODO:
+ case LDB_SEQUENCE_NUMBER:
+ return lsql_sequence_number(module, req);
+ break;
+ */
+ default:
+ return lsql_request(module, req);
+ break;
+ }
+
+ return LDB_ERR_OPERATIONS_ERROR;
+}
+
+static int lsql_handle_request(struct ldb_module *module, struct ldb_request *req)
+{
+ struct lsql_context *ac;
+
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+
+ ac = talloc_zero(req, struct lsql_context);
+ if (ac == NULL) {
+ ldb_set_errstring(module->ldb, "Out of Memory");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->module = module;
+ ac->req = req;
+
+ req->handle = ldb_handle_new(req, lsql_run_request, ac);
+ if (req->handle == NULL) {
+ talloc_free(ac);
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ return LDB_SUCCESS;
+}
+
+/*
+ * Table of operations for the sqlite3 backend
+ */
+static const struct ldb_module_ops lsqlite3_ops = {
+ .name = "sqlite",
+ .search = lsql_handle_request,
+ .add = lsql_handle_request,
+ .modify = lsql_handle_request,
+ .del = lsql_handle_request,
+ .rename = lsql_handle_request,
+ .request = lsql_handle_request,
+ .start_transaction = lsql_start_trans,
+ .end_transaction = lsql_end_trans,
+ .del_transaction = lsql_del_trans,
+ /* TODO: .sequence_number = lsql_handle_request */
+};
+
/*
* Static functions
*/
" ('TOP', '0001');");
/* Skip protocol indicator of url */
- if (strncmp(url, "sqlite://", 9) != 0) {
+ if (strncmp(url, "sqlite3://", 10) != 0) {
return SQLITE_MISUSE;
}
/* Update pointer to just after the protocol indicator */
- url += 9;
+ url += 10;
/* Try to open the (possibly empty/non-existent) database */
if ((ret = sqlite3_open(url, &lsqlite3->sqlite)) != SQLITE_OK) {
return -1;
}
-static int
-destructor(void *p)
-{
- struct lsqlite3_private *lsqlite3 = p;
-
- if (lsqlite3->sqlite) {
- sqlite3_close(lsqlite3->sqlite);
- }
- return 0;
-}
-
-
-static int lsqlite3_request(struct ldb_module *module, struct ldb_request *req)
-{
- /* check for oustanding critical controls and return an error if found */
- if (check_critical_controls(req->controls)) {
- return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
- }
-
- switch (req->operation) {
-
- case LDB_REQ_SEARCH:
- return lsqlite3_search_bytree(module,
- req->op.search.base,
- req->op.search.scope,
- req->op.search.tree,
- req->op.search.attrs,
- &req->op.search.res);
-
- case LDB_REQ_ADD:
- return lsqlite3_add(module, req->op.add.message);
-
- case LDB_REQ_MODIFY:
- return lsqlite3_modify(module, req->op.mod.message);
-
- case LDB_REQ_DELETE:
- return lsqlite3_delete(module, req->op.del.dn);
-
- case LDB_REQ_RENAME:
- return lsqlite3_rename(module,
- req->op.rename.olddn,
- req->op.rename.newdn);
-
- default:
- return LDB_ERR_OPERATIONS_ERROR;
-
- }
-}
-
-
-/*
- * Table of operations for the sqlite3 backend
- */
-static const struct ldb_module_ops lsqlite3_ops = {
- .name = "sqlite",
- .request = lsqlite3_request,
- .start_transaction = lsqlite3_start_trans,
- .end_transaction = lsqlite3_end_trans,
- .del_transaction = lsqlite3_del_trans
-};
-
/*
* connect to the database
*/
-int lsqlite3_connect(struct ldb_context *ldb,
- const char *url,
- unsigned int flags,
- const char *options[])
+static int lsqlite3_connect(struct ldb_context *ldb,
+ const char *url,
+ unsigned int flags,
+ const char *options[],
+ struct ldb_module **module)
{
int i;
int ret;
talloc_set_destructor(lsqlite3, destructor);
- ldb->modules = talloc(ldb, struct ldb_module);
- if (!ldb->modules) {
+
+
+ *module = talloc(ldb, struct ldb_module);
+ if (!module) {
+ ldb_oom(ldb);
goto failed;
}
- ldb->modules->ldb = ldb;
- ldb->modules->prev = ldb->modules->next = NULL;
- ldb->modules->private_data = lsqlite3;
- ldb->modules->ops = &lsqlite3_ops;
-
+ talloc_set_name_const(*module, "ldb_sqlite3 backend");
+ (*module)->ldb = ldb;
+ (*module)->prev = (*module)->next = NULL;
+ (*module)->private_data = lsqlite3;
+ (*module)->ops = &lsqlite3_ops;
+
if (options) {
/*
* take a copy of the options array, so we don't have to rely
return -1;
}
+const struct ldb_backend_ops ldb_sqlite3_backend_ops = {
+ .name = "sqlite3",
+ .connect_fn = lsqlite3_connect
+};
git.samba.org / kai / samba-autobuild / .git / blobdiff