-/*
+/*
ldb database library
-
+
Copyright (C) Derrell Lipman 2005
- Copyright (C) Simo Sorce 2005
-
+ Copyright (C) Simo Sorce 2005-2009
+
** NOTE! The following LGPL license applies to the ldb
** library. This does NOT imply that all of Samba is released
** under the LGPL
-
+
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
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, 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;
+
+ bool callback_failed;
+ struct tevent_timer *timeout_event;
+};
/*
* Macros used throughout
#define RESULT_ATTR_TABLE "temp_result_attrs"
-//#define TEMPTAB /* for testing, create non-temporary table */
+
+/* for testing, define to nothing, (create non-temporary table) */
#define TEMPTAB "TEMPORARY"
/*
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 */
val = sqlite3_value_int64(argv[0]);
for (i = 3; i >= 0; i--) {
-
+
result[i] = base160tab[val % 160];
val /= 160;
}
{
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;
+ struct ldb_context *ldb;
+ const struct ldb_schema_attribute *a;
struct ldb_val value, subval;
char *wild_card_string;
char *child, *tmp;
char *attr;
int i;
+ ldb = ldb_module_get_ctx(module);
switch(t->operation) {
case LDB_OP_AND:
ret = talloc_asprintf(mem_ctx, "SELECT * FROM ( %s )\n", tmp);
return ret;
-
+
case LDB_OP_OR:
tmp = parsetree_to_sql(module, mem_ctx, t->u.list.elements[0]);
* 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(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(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, 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(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(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(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(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(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(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(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(ldb, mem_ctx, &(t->u.equality.value), &value);
if (value.data == NULL) {
return NULL;
}
attr,
value.data,
attr);
-
+
case LDB_OP_EXTENDED:
#warning "work out how to handle bitops"
return NULL;
char * p;
sqlite3_stmt * pStmt;
va_list args;
-
+
/* Begin access to variable argument list */
va_start(args, pSql);
-
+
/* Format the query */
if ((p = sqlite3_vmprintf(pSql, args)) == NULL) {
+ va_end(args);
return SQLITE_NOMEM;
}
-
+
/*
* Prepare and execute the SQL statement. Loop allows retrying on
* certain errors, e.g. SQLITE_SCHEMA occurs if the schema changes,
* requiring retrying the operation.
*/
for (bLoop = TRUE; bLoop; ) {
-
+
/* Compile the SQL statement into sqlite virtual machine */
if ((ret = sqlite3_prepare(lsqlite3->sqlite,
p,
} else if (ret != SQLITE_OK) {
break;
}
-
+
/* One row expected */
if ((ret = sqlite3_step(pStmt)) == SQLITE_SCHEMA) {
if (stmtGetEID != NULL) {
(void) sqlite3_finalize(pStmt);
break;
}
-
+
/* Get the value to be returned */
*pRet = sqlite3_column_int64(pStmt, 0);
-
+
/* Free the virtual machine */
if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
if (stmtGetEID != NULL) {
(void) sqlite3_finalize(pStmt);
break;
}
-
+
/*
* Normal condition is only one time through loop. Loop is
* rerun in error conditions, via "continue", above.
*/
bLoop = FALSE;
}
-
+
/* All done with variable argument list */
va_end(args);
-
+
/* Free the memory we allocated for our query string */
sqlite3_free(p);
-
+
return ret;
}
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 = (uint8_t *)cmp;
valX.length = strlen(cmp);
- valY.data = val;
+ valY.data = (uint8_t *)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 = (uint8_t *)cmp;
valX.length = strlen(cmp);
- valY.data = val;
+ valY.data = (uint8_t *)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_context *ldb;
+ struct lsql_context *ac;
struct ldb_message *msg;
long long eid;
- int i;
+ int i, ret;
+
+ ac = talloc_get_type(result, struct lsql_context);
+ ldb = ldb_module_get_ctx(ac->module);
/* eid, dn, attr_name, attr_value */
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 (ac->ares) {
+ msg = ac->ares->message;
+ }
- msgs->msgs[msgs->count] = talloc(msgs->msgs, struct ldb_message);
- if (msgs->msgs[msgs->count] == NULL) return SQLITE_ABORT;
+ if (eid != ac->current_eid) { /* here begin a new entry */
- 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;
+ /* call the async callback for the last entry
+ * except the first time */
+ if (ac->current_eid != 0) {
+ msg = ldb_msg_canonicalize(ldb, msg);
+ if (!msg) return SQLITE_ABORT;
- msgs->count++;
- msgs->current_eid = eid;
- }
+ ret = ldb_module_send_entry(ac->req, msg, NULL);
+ if (ret != LDB_SUCCESS) {
+ ac->callback_failed = true;
+ return SQLITE_ABORT;
+ }
+ }
+
+ /* start over */
+ ac->ares = talloc_zero(ac, struct ldb_reply);
+ if (!ac->ares) return SQLITE_ABORT;
- msg = msgs->msgs[msgs->count -1];
+ msg = ldb_msg_new(ac->ares);
+ if (!msg) return SQLITE_ABORT;
+
+ ac->ares->type = LDB_REPLY_ENTRY;
+ ac->current_eid = eid;
+ }
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, 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) goto done;
}
- 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;
+ }
+done:
+ ac->ares->message = msg;
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 lsqlite3_private *lsqlite3,
+ struct ldb_dn *dn)
{
TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
long long eid = -1;
char *cdn;
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 lsql_context *ctx)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
- struct lsqlite3_msgs msgs;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ struct lsqlite3_private *lsqlite3;
+ struct ldb_context *ldb;
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;
+ ldb = ldb_module_get_ctx(module);
+ lsqlite3 = talloc_get_type(ldb_module_get_private(module),
+ struct lsqlite3_private);
+
+ 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(ctx, 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;
+ return LDB_ERR_OPERATIONS_ERROR;
}
+ } else norm_basedn = talloc_strdup(ctx, "");
/* Convert filter into a series of SQL conditions (constraints) */
- sqlfilter = parsetree_to_sql(module, local_ctx, tree);
-
- switch(scope) {
+ sqlfilter = parsetree_to_sql(module, ctx, req->op.search.tree);
+
+ 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(ctx,
"SELECT entry.eid,\n"
" entry.dn,\n"
" av.attr_name,\n"
norm_basedn,
sqlfilter);
} else {
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(ctx,
"SELECT entry.eid,\n"
" entry.dn,\n"
" av.attr_name,\n"
}
break;
-
+
case LDB_SCOPE_BASE:
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(ctx,
"SELECT entry.eid,\n"
" entry.dn,\n"
" av.attr_name,\n"
norm_basedn,
sqlfilter);
break;
-
+
case LDB_SCOPE_ONELEVEL:
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(ctx,
"SELECT entry.eid,\n"
" entry.dn,\n"
" av.attr_name,\n"
}
if (query == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
/* * /
printf ("%s\n", query);
/ * */
- msgs.msgs = NULL;
- msgs.count = 0;
- msgs.current_eid = 0;
- msgs.mem_ctx = local_ctx;
- msgs.attrs = attrs;
+ ctx->current_eid = 0;
+ ctx->attrs = req->op.search.attrs;
+ ctx->ares = NULL;
+
+ ldb_request_set_state(req, LDB_ASYNC_PENDING);
- ret = sqlite3_exec(lsqlite3->sqlite, query, lsqlite3_search_callback, &msgs, &errmsg);
+ ret = sqlite3_exec(lsqlite3->sqlite, query, lsqlite3_search_callback, ctx, &errmsg);
if (ret != SQLITE_OK) {
if (errmsg) {
- ldb_set_errstring(module, talloc_strdup(module, errmsg));
+ ldb_set_errstring(ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- for (i = 0; i < msgs.count; i++) {
- msgs.msgs[i] = ldb_msg_canonicalize(module->ldb, msgs.msgs[i]);
- if (msgs.msgs[i] == NULL) {
- goto failed;
+ /* complete the last message if any */
+ if (ctx->ares) {
+ ctx->ares->message = ldb_msg_canonicalize(ldb, ctx->ares->message);
+ if (ctx->ares->message == NULL) {
+ return LDB_ERR_OPERATIONS_ERROR;
}
- }
- *res = talloc(module, struct ldb_result);
- if (! *res) {
- goto failed;
+ ret = ldb_module_send_entry(req, ctx->ares->message, NULL);
+ if (ret != LDB_SUCCESS) {
+ return ret;
+ }
}
- (*res)->msgs = talloc_steal(*res, msgs.msgs);
- (*res)->count = msgs.count;
- 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;
}
-
/* add a record */
-static int lsqlite3_add(struct ldb_module *module, const struct ldb_message *msg)
+static int lsql_add(struct lsql_context *ctx)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ struct lsqlite3_private *lsqlite3;
+ struct ldb_context *ldb;
+ 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 = ldb_module_get_ctx(module);
+ lsqlite3 = talloc_get_type(ldb_module_get_private(module),
+ struct lsqlite3_private);
/* 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");
- if (ldb_dn_compare(module->ldb, msg->dn, c) == 0) {
+ struct ldb_dn *c;
+ c = ldb_dn_new(local_ctx, ldb, "@INDEXLIST");
+ if (ldb_dn_compare(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 */
+ return LDB_ERR_UNWILLING_TO_PERFORM;
}
/* 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(ctx, msg->dn);
+ ndn = ldb_dn_alloc_casefold(ctx, msg->dn);
if (dn == NULL || ndn == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(ctx,
/* Add new entry */
"INSERT OR ABORT INTO ldb_entry "
"('dn', 'norm_dn') "
"VALUES ('%q', '%q');",
dn, ndn);
if (query == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
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(ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, local_ctx, ndn);
+ eid = lsqlite3_get_eid_ndn(lsqlite3->sqlite, ctx, ndn);
if (eid == -1) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
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(ctx, el->name);
if (attr == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- h = ldb_attrib_handler(module->ldb, el->name);
+ a = ldb_schema_attribute_by_name(ldb, el->name);
+
+ if (el->num_value == 0) {
+ ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illegal)",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ return LDB_ERR_CONSTRAINT_VIOLATION;
+ }
+ if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+ if (el->num_values > 1) {
+ ldb_asprintf_errstring(ldb, "SINGLE-VALUED attribute %s on %s specified more than once",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ return LDB_ERR_CONSTRAINT_VIOLATION;
+ }
+ }
/* 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(ldb, ctx, &(el->values[j]), &value);
if (value.data == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- insert = lsqlite3_tprintf(local_ctx,
+ insert = lsqlite3_tprintf(ctx,
"INSERT OR ROLLBACK INTO ldb_attribute_values "
"('eid', 'attr_name', 'norm_attr_name',"
" 'attr_value', 'norm_attr_value') "
eid, el->name, attr,
el->values[j].data, value.data);
if (insert == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
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(ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
}
}
- talloc_free(local_ctx);
- return LDB_SUCCESS;
-
-failed:
- talloc_free(local_ctx);
- return ret;
+ return LDB_SUCCESS;
}
-
/* modify a record */
-static int lsqlite3_modify(struct ldb_module *module, const struct ldb_message *msg)
+static int lsql_modify(struct lsql_context *ctx)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ struct lsqlite3_private *lsqlite3;
+ struct ldb_context *ldb;
+ 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 = ldb_module_get_ctx(module);
+ lsqlite3 = talloc_get_type(ldb_module_get_private(module),
+ struct lsqlite3_private);
/* 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 */
+ return LDB_ERR_UNWILLING_TO_PERFORM;
}
- eid = lsqlite3_get_eid(module, msg->dn);
+ eid = lsqlite3_get_eid(lsqlite3, msg->dn);
if (eid == -1) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
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;
+ if (ldb_attr_cmp(el->name, "distinguishedName") == 0) {
+ ldb_asprintf_errstring(ldb, "it is not permitted to perform a modify on 'distinguishedName' (use rename instead): %s",
+ ldb_dn_get_linearized(msg->dn));
+ return LDB_ERR_CONSTRAINT_VIOLATION;
+ }
+
/* Get a case-folded copy of the attribute name */
- attr = ldb_casefold(local_ctx, el->name);
+ attr = ldb_attr_casefold(ctx, el->name);
if (attr == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- h = ldb_attrib_handler(module->ldb, el->name);
+ a = ldb_schema_attribute_by_name(ldb, el->name);
switch (flags) {
case LDB_FLAG_MOD_REPLACE:
-
+
+ if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+ if (el->num_values > 1) {
+ ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ return LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ }
+ }
+
+ for (j=0; j<el->num_values; j++) {
+ if (ldb_msg_find_val(el, &el->values[j]) != &el->values[j]) {
+ ldb_asprintf_errstring(ldb, "%s: value #%d provided more than once", el->name, j);
+ return LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ }
+ }
+
/* remove all attributes before adding the replacements */
- mod = lsqlite3_tprintf(local_ctx,
+ mod = lsqlite3_tprintf(ctx,
"DELETE FROM ldb_attribute_values "
"WHERE eid = '%lld' "
"AND norm_attr_name = '%q';",
eid, attr);
if (mod == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
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(ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
/* MISSING break is INTENTIONAL */
case LDB_FLAG_MOD_ADD:
+
+ if (el->num_values == 0) {
+ ldb_asprintf_errstring(ldb, "attribute %s on %s specified, but with 0 values (illigal)",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ return LDB_ERR_CONSTRAINT_VIOLATION;
+ }
+
+ if (a && a->flags & LDB_ATTR_FLAG_SINGLE_VALUE) {
+ if (el->num_values > 1) {
+ ldb_asprintf_errstring(ldb, "SINGLE-VALUE attribute %s on %s specified more than once",
+ el->name, ldb_dn_get_linearized(msg->dn));
+ return LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS;
+ }
+ }
+
#warning "We should throw an error if no value is provided!"
/* For each value of the specified attribute name... */
for (j = 0; j < el->num_values; j++) {
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(ldb, ctx, &(el->values[j]), &value);
if (value.data == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- mod = lsqlite3_tprintf(local_ctx,
+ mod = lsqlite3_tprintf(ctx,
"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 (mod == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
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(ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
}
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(ctx,
"DELETE FROM ldb_attribute_values "
"WHERE eid = '%lld' "
"AND norm_attr_name = '%q';",
eid, attr);
if (mod == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
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(ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
}
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(ldb, ctx, &(el->values[j]), &value);
if (value.data == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- mod = lsqlite3_tprintf(local_ctx,
+ mod = lsqlite3_tprintf(ctx,
"DELETE FROM ldb_attribute_values "
"WHERE eid = '%lld' "
"AND norm_attr_name = '%q' "
eid, attr, value.data);
if (mod == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
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(ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
}
}
}
- talloc_free(local_ctx);
- return LDB_SUCCESS;
-
-failed:
- talloc_free(local_ctx);
- return ret;
+ return LDB_SUCCESS;
}
/* delete a record */
-static int lsqlite3_delete(struct ldb_module *module, const struct ldb_dn *dn)
+static int lsql_delete(struct lsql_context *ctx)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ struct lsqlite3_private *lsqlite3;
+ struct ldb_context *ldb;
long long eid;
char *errmsg;
char *query;
int ret;
- /* 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;
- }
+ ldb = ldb_module_get_ctx(module);
+ lsqlite3 = talloc_get_type(ldb_module_get_private(module),
+ struct lsqlite3_private);
- eid = lsqlite3_get_eid(module, dn);
+ eid = lsqlite3_get_eid(lsqlite3, req->op.del.dn);
if (eid == -1) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(ctx,
/* Delete entry */
"DELETE FROM ldb_entry WHERE eid = %lld; "
/* Delete attributes */
"DELETE FROM ldb_attribute_values WHERE eid = %lld; ",
eid, eid);
if (query == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
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(ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- talloc_free(local_ctx);
- return LDB_SUCCESS;
-
-failed:
- talloc_free(local_ctx);
- return ret;
+ return LDB_SUCCESS;
}
/* 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 lsql_context *ctx)
{
- TALLOC_CTX *local_ctx;
- struct lsqlite3_private *lsqlite3 = module->private_data;
+ struct ldb_module *module = ctx->module;
+ struct ldb_request *req = ctx->req;
+ struct lsqlite3_private *lsqlite3;
+ struct ldb_context *ldb;
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;
- }
-
- /* create a local ctx */
- local_ctx = talloc_named(lsqlite3, 0, "lsqlite3_rename local context");
- if (local_ctx == NULL) {
- return LDB_ERR_OTHER;
- }
+ ldb = ldb_module_get_ctx(module);
+ lsqlite3 = talloc_get_type(ldb_module_get_private(module),
+ struct lsqlite3_private);
/* 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(ctx, req->op.rename.olddn);
+ new_cdn = ldb_dn_alloc_casefold(ctx, req->op.rename.newdn);
+ new_dn = ldb_dn_alloc_linearized(ctx, req->op.rename.newdn);
if (old_cdn == NULL || new_cdn == NULL || new_dn == NULL) {
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
/* build the SQL query */
- query = lsqlite3_tprintf(local_ctx,
+ query = lsqlite3_tprintf(ctx,
"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;
+ return LDB_ERR_OPERATIONS_ERROR;
}
/* 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(ldb, errmsg);
free(errmsg);
}
- ret = LDB_ERR_OTHER;
- goto failed;
+ return LDB_ERR_OPERATIONS_ERROR;
}
- /* clean up and exit */
- talloc_free(local_ctx);
- return LDB_SUCCESS;
-
-failed:
- talloc_free(local_ctx);
- return ret;
+ return LDB_SUCCESS;
}
-static int lsqlite3_start_trans(struct ldb_module * module)
+static int lsql_start_trans(struct ldb_module * module)
{
int ret;
char *errmsg;
- struct lsqlite3_private * lsqlite3 = module->private_data;
+ struct lsqlite3_private *lsqlite3;
+
+ lsqlite3 = talloc_get_type(ldb_module_get_private(module),
+ struct lsqlite3_private);
if (lsqlite3->trans_count == 0) {
ret = sqlite3_exec(lsqlite3->sqlite, "BEGIN IMMEDIATE;", NULL, NULL, &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;
- struct lsqlite3_private *lsqlite3 = module->private_data;
+ struct lsqlite3_private *lsqlite3;
+
+ lsqlite3 = talloc_get_type(ldb_module_get_private(module),
+ struct lsqlite3_private);
if (lsqlite3->trans_count > 0) {
lsqlite3->trans_count--;
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;
+ struct lsqlite3_private *lsqlite3;
+
+ lsqlite3 = talloc_get_type(ldb_module_get_private(module),
+ struct lsqlite3_private);
if (lsqlite3->trans_count > 0) {
lsqlite3->trans_count--;
return -1;
}
+static int destructor(struct lsqlite3_private *lsqlite3)
+{
+ if (lsqlite3->sqlite) {
+ sqlite3_close(lsqlite3->sqlite);
+ }
+ return 0;
+}
+
+static void lsql_request_done(struct lsql_context *ctx, int error)
+{
+ struct ldb_context *ldb;
+ struct ldb_request *req;
+ struct ldb_reply *ares;
+
+ ldb = ldb_module_get_ctx(ctx->module);
+ req = ctx->req;
+
+ /* if we already returned an error just return */
+ if (ldb_request_get_status(req) != LDB_SUCCESS) {
+ return;
+ }
+
+ ares = talloc_zero(req, struct ldb_reply);
+ if (!ares) {
+ ldb_oom(ldb);
+ req->callback(req, NULL);
+ return;
+ }
+ ares->type = LDB_REPLY_DONE;
+ ares->error = error;
+
+ req->callback(req, ares);
+}
+
+static void lsql_timeout(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t,
+ void *private_data)
+{
+ struct lsql_context *ctx;
+ ctx = talloc_get_type(private_data, struct lsql_context);
+
+ lsql_request_done(ctx, LDB_ERR_TIME_LIMIT_EXCEEDED);
+}
+
+static void lsql_callback(struct tevent_context *ev,
+ struct tevent_timer *te,
+ struct timeval t,
+ void *private_data)
+{
+ struct lsql_context *ctx;
+ int ret;
+
+ ctx = talloc_get_type(private_data, struct lsql_context);
+
+ switch (ctx->req->operation) {
+ case LDB_SEARCH:
+ ret = lsql_search(ctx);
+ break;
+ case LDB_ADD:
+ ret = lsql_add(ctx);
+ break;
+ case LDB_MODIFY:
+ ret = lsql_modify(ctx);
+ break;
+ case LDB_DELETE:
+ ret = lsql_delete(ctx);
+ break;
+ case LDB_RENAME:
+ ret = lsql_rename(ctx);
+ break;
+/* TODO:
+ case LDB_EXTENDED:
+ ret = lsql_extended(ctx);
+ break;
+ */
+ default:
+ /* no other op supported */
+ ret = LDB_ERR_UNWILLING_TO_PERFORM;
+ }
+
+ if (!ctx->callback_failed) {
+ /* Once we are done, we do not need timeout events */
+ talloc_free(ctx->timeout_event);
+ lsql_request_done(ctx, ret);
+ }
+}
+
+static int lsql_handle_request(struct ldb_module *module, struct ldb_request *req)
+{
+ struct ldb_context *ldb;
+ struct tevent_context *ev;
+ struct lsql_context *ac;
+ struct tevent_timer *te;
+ struct timeval tv;
+
+ if (check_critical_controls(req->controls)) {
+ return LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION;
+ }
+
+ if (req->starttime == 0 || req->timeout == 0) {
+ ldb_set_errstring(ldb, "Invalid timeout settings");
+ return LDB_ERR_TIME_LIMIT_EXCEEDED;
+ }
+
+ ldb = ldb_module_get_ctx(module);
+ ev = ldb_get_event_context(ldb);
+
+ ac = talloc_zero(req, struct lsql_context);
+ if (ac == NULL) {
+ ldb_set_errstring(ldb, "Out of Memory");
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ ac->module = module;
+ ac->req = req;
+
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ te = tevent_add_timer(ev, ac, tv, lsql_callback, ac);
+ if (NULL == te) {
+ return LDB_ERR_OPERATIONS_ERROR;
+ }
+
+ tv.tv_sec = req->starttime + req->timeout;
+ ac->timeout_event = tevent_add_timer(ev, ac, tv, lsql_timeout, ac);
+ if (NULL == ac->timeout_event) {
+ 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,
+ .extended = lsql_handle_request,
+ .start_transaction = lsql_start_trans,
+ .end_transaction = lsql_end_trans,
+ .del_transaction = lsql_del_trans,
+};
+
/*
* Static functions
*/
}
schema = lsqlite3_tprintf(local_ctx,
-
-
+
+
"CREATE TABLE ldb_info AS "
" SELECT 'LDB' AS database_type,"
" '1.0' AS version;"
-
+
/*
- * The entry table holds the information about an entry.
- * This table is used to obtain the EID of the entry and to
+ * The entry table holds the information about an entry.
+ * This table is used to obtain the EID of the entry and to
* support scope=one and scope=base. The parent and child
* table is included in the entry table since all the other
* attributes are dependent on EID.
" dn TEXT UNIQUE NOT NULL,"
" norm_dn TEXT UNIQUE NOT NULL"
");"
-
+
"CREATE TABLE ldb_object_classes"
"("
" tree_key TEXT UNIQUE,"
" max_child_num INTEGER DEFAULT 0"
");"
-
+
/*
* We keep a full listing of attribute/value pairs here
*/
" attr_value TEXT,"
" norm_attr_value TEXT "
");"
-
-
+
+
/*
* Indexes
*/
"CREATE INDEX ldb_attribute_values_eid_idx "
" ON ldb_attribute_values (eid);"
-
+
"CREATE INDEX ldb_attribute_values_name_value_idx "
" ON ldb_attribute_values (attr_name, norm_attr_value);"
-
-
+
+
/*
* Triggers
*/
-
+
"CREATE TRIGGER ldb_object_classes_insert_tr"
" AFTER INSERT"
" ON ldb_object_classes"
" (class_name, tree_key) "
" VALUES "
" ('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 ret;
}
-
+
/* In case this is a new database, enable auto_vacuum */
ret = sqlite3_exec(lsqlite3->sqlite, "PRAGMA auto_vacuum = 1;", NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
}
goto failed;
}
-
+
if (flags & LDB_FLG_NOSYNC) {
/* DANGEROUS */
ret = sqlite3_exec(lsqlite3->sqlite, "PRAGMA synchronous = OFF;", NULL, NULL, &errmsg);
goto failed;
}
}
-
+
/* */
-
+
/* Establish a busy timeout of 30 seconds */
if ((ret = sqlite3_busy_timeout(lsqlite3->sqlite,
30000)) != SQLITE_OK) {
goto failed;
}
rollback = 1;
-
+
/* Determine if this is a new database. No tables means it is. */
if (query_int(lsqlite3,
&queryInt,
" WHERE type = 'table';") != 0) {
goto failed;
}
-
+
if (queryInt == 0) {
/*
* Create the database schema
" AND version = '1.0'"
" );") != 0 ||
queryInt != 1) {
-
+
/* It's not one that we created. See ya! */
goto failed;
}
}
-
+
/* Commit the transaction */
ret = sqlite3_exec(lsqlite3->sqlite, "COMMIT;", NULL, NULL, &errmsg);
if (ret != SQLITE_OK) {
}
goto failed;
}
-
+
return SQLITE_OK;
failed:
- if (rollback) lsqlite3_safe_rollback(lsqlite3->sqlite);
+ if (rollback) lsqlite3_safe_rollback(lsqlite3->sqlite);
sqlite3_close(lsqlite3->sqlite);
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)
-{
- 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;
- struct lsqlite3_private * lsqlite3 = NULL;
-
- lsqlite3 = talloc(ldb, struct lsqlite3_private);
+ struct ldb_module *module;
+ struct lsqlite3_private *lsqlite3;
+ int i, ret;
+
+ module = ldb_module_new(ldb, ldb, "ldb_sqlite3 backend", &lsqlite3_ops);
+ if (!module) return -1;
+
+ lsqlite3 = talloc(module, struct lsqlite3_private);
if (!lsqlite3) {
goto failed;
}
-
+
lsqlite3->sqlite = NULL;
lsqlite3->options = NULL;
lsqlite3->trans_count = 0;
-
+
ret = initialize(lsqlite3, ldb, url, flags);
if (ret != SQLITE_OK) {
goto failed;
}
-
+
talloc_set_destructor(lsqlite3, destructor);
-
- ldb->modules = talloc(ldb, struct ldb_module);
- if (!ldb->modules) {
- goto failed;
- }
- ldb->modules->ldb = ldb;
- ldb->modules->prev = ldb->modules->next = NULL;
- ldb->modules->private_data = lsqlite3;
- ldb->modules->ops = &lsqlite3_ops;
-
+
+ ldb_module_set_private(module, lsqlite3);
+
if (options) {
/*
* take a copy of the options array, so we don't have to rely
* on the caller keeping it around (it might be dynamic)
*/
for (i=0;options[i];i++) ;
-
+
lsqlite3->options = talloc_array(lsqlite3, char *, i+1);
if (!lsqlite3->options) {
goto failed;
}
-
+
for (i=0;options[i];i++) {
-
+
lsqlite3->options[i+1] = NULL;
lsqlite3->options[i] =
talloc_strdup(lsqlite3->options, options[i]);
}
}
}
-
+
+ *_module = module;
return 0;
-
+
failed:
- if (lsqlite3->sqlite != NULL) {
+ if (lsqlite3 && lsqlite3->sqlite != NULL) {
(void) sqlite3_close(lsqlite3->sqlite);
}
talloc_free(lsqlite3);
return -1;
}
+const struct ldb_backend_ops ldb_sqlite3_backend_ops = {
+ .name = "sqlite3",
+ .connect_fn = lsqlite3_connect
+};
git.samba.org / ira / wip.git / blobdiff