# define TRUE (! FALSE)
#endif
+#define FILTER_ATTR_TABLE "temp_filter_attrs"
+#define RESULT_ATTR_TABLE "temp_result_attrs"
+
#define QUERY_NOROWS(lsqlite3, bRollbackOnError, sql...) \
- do { \
- if (query_norows(lsqlite3, sql) != 0) { \
- if (bRollbackOnError) { \
- query_norows(lsqlite3, \
- "ROLLBACK;"); \
+ do { \
+ if (query_norows(lsqlite3, sql) != 0) { \
+ if (bRollbackOnError) { \
+ query_norows(lsqlite3, \
+ "ROLLBACK;"); \
+ } \
+ return -1; \
} \
- return -1; \
- } \
- } while (0)
+ } while (0)
#define QUERY_INT(lsqlite3, result_var, bRollbackOnError, sql...) \
- do { \
- if (query_int(lsqlite3, &result_var, sql) != 0) { \
- if (bRollbackOnError) { \
- query_norows(lsqlite3, \
- "ROLLBACK;"); \
- } \
- return -1; \
- } \
- } while (0)
+ do { \
+ if (query_int(lsqlite3, &result_var, sql) != 0) { \
+ if (bRollbackOnError) { \
+ query_norows(lsqlite3, \
+ "ROLLBACK;"); \
+ } \
+ return -1; \
+ } \
+ } while (0)
/*
lsqlite3_delete(struct ldb_module *module,
const char *dn);
+static int
+lsqlite3_search_bytree(struct ldb_module * module,
+ const char * pBaseDN,
+ enum ldb_scope scope,
+ struct ldb_parse_tree * pTree,
+ const char * const * attrs,
+ struct ldb_message *** pppRes);
+
static int
lsqlite3_search(struct ldb_module * module,
const char * pBaseDN,
enum ldb_scope scope,
const char * pExpression,
const char * const attrs[],
- struct ldb_message *** res);
+ struct ldb_message *** pppRes);
static int
lsqlite3_add(struct ldb_module *module,
static int case_fold_attr_required(void * hUserData,
char *attr);
+static int
+add_msg_attr(void * hTalloc,
+ long long eid,
+ const char * pDN,
+ const char * pAttrName,
+ const char * pAttrValue,
+ long long prevEID,
+ int * pAllocated,
+ struct ldb_message *** pppRes);
+
static char *
parsetree_to_sql(struct ldb_module *module,
- char * hTalloc,
+ char * hTalloc,
const struct ldb_parse_tree *t);
+static int
+parsetree_to_attrlist(struct lsqlite3_private * lsqlite3,
+ const struct ldb_parse_tree * t);
+
static char *
-parsetree_to_tablelist(struct ldb_module *module,
- char * hTalloc,
- const struct ldb_parse_tree *t);
+build_attr_table_list(void * hTalloc,
+ struct lsqlite3_private * lsqlite3);
static int
msg_to_sql(struct ldb_module * module,
int ret;
struct ldb_context * ldb = NULL;
struct lsqlite3_private * lsqlite3 = NULL;
-
+
ldb = talloc(NULL, struct ldb_context);
if (!ldb) {
- errno = ENOMEM;
goto failed;
}
-
+
lsqlite3 = talloc(ldb, struct lsqlite3_private);
if (!lsqlite3) {
- errno = ENOMEM;
goto failed;
}
-
+
lsqlite3->sqlite = NULL;
lsqlite3->options = NULL;
lsqlite3->lock_count = 0;
-
+
ret = initialize(lsqlite3, url);
if (ret != SQLITE_OK) {
goto failed;
}
-
+
talloc_set_destructor(lsqlite3, destructor);
-
+
ldb->modules = talloc(ldb, struct ldb_module);
if (!ldb->modules) {
- errno = ENOMEM;
goto failed;
}
ldb->modules->ldb = ldb;
ldb->modules->prev = ldb->modules->next = NULL;
ldb->modules->private_data = lsqlite3;
ldb->modules->ops = &lsqlite3_ops;
-
+
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]);
}
}
}
-
+
return ldb;
-
+
failed:
if (lsqlite3->sqlite != NULL) {
(void) sqlite3_close(lsqlite3->sqlite);
if (olddn[0] == '@' ||newdn[0] == '@') {
return 0;
}
-
+
#warning "lsqlite3_rename() is not yet supported"
return -1;
}
if (dn[0] == '@') {
return 0;
}
-
+
#warning "lsqlite3_delete() is not yet supported"
return -1;
}
-/* search for matching records */
+/* search for matching records, by tree */
static int
-lsqlite3_search(struct ldb_module * module,
- const char * pBaseDN,
- enum ldb_scope scope,
- const char * pExpression,
- const char * const attrs[],
- struct ldb_message *** res)
+lsqlite3_search_bytree(struct ldb_module * module,
+ const char * pBaseDN,
+ enum ldb_scope scope,
+ struct ldb_parse_tree * pTree,
+ const char * const * attrs,
+ struct ldb_message *** pppRes)
{
+ int i;
int ret;
+ int allocated;
int bLoop;
long long eid = 0;
long long prevEID;
char * pSql = NULL;
char * pSqlConstraints;
char * pTableList;
- char * hTalloc;
+ char * hTalloc = NULL;
const char * pDN;
const char * pAttrName;
const char * pAttrValue;
+ const char * const * pRequestedAttrs;
sqlite3_stmt * pStmt;
- struct ldb_parse_tree * pTree;
struct lsqlite3_private * lsqlite3 = module->private_data;
-
+
if (pBaseDN == NULL) {
pBaseDN = "";
}
-
+
/* Begin a transaction */
QUERY_NOROWS(lsqlite3, FALSE, "BEGIN IMMEDIATE;");
-
+
/*
* Obtain the eid of the base DN
*/
" FROM ldb_attr_dn "
" WHERE attr_value = %Q;",
pBaseDN);
-
- /* Parse the filter expression into a tree we can work with */
- if ((pTree = ldb_parse_tree(module->ldb, pExpression)) == NULL) {
- return -1;
- }
-
+
/* Allocate a temporary talloc context */
- hTalloc = talloc_new(module->ldb);
-
- /* Move the parse tree to our temporary context */
- talloc_steal(hTalloc, pTree);
-
- /* Convert filter into a series of SQL statements (constraints) */
+ if ((hTalloc = talloc_new(module->ldb)) == NULL) {
+ ret = -1;
+ talloc_free(pTree);
+ goto cleanup;
+ }
+
+ /* Convert filter into a series of SQL conditions (constraints) */
pSqlConstraints = parsetree_to_sql(module, hTalloc, pTree);
-
- /* Get the list of attribute names to use as our extra table list */
- pTableList = parsetree_to_tablelist(module, hTalloc, pTree);
-
+
+ /* Ensure we're starting with an empty result attribute table */
+ QUERY_NOROWS(lsqlite3,
+ FALSE,
+ "DELETE FROM " RESULT_ATTR_TABLE " "
+ " WHERE 1;");/* avoid a schema change with WHERE 1 */
+
+ /* Insert the list of requested attributes into this table */
+ for (pRequestedAttrs = (const char * const *) attrs;
+ pRequestedAttrs != NULL;
+ pRequestedAttrs++) {
+
+ QUERY_NOROWS(lsqlite3,
+ FALSE,
+ "INSERT OR IGNORE INTO " RESULT_ATTR_TABLE " "
+ " (attr_name) "
+ " VALUES "
+ " (%Q);",
+ *pRequestedAttrs);
+ }
+
+ /* Ensure we're starting with an empty filter attribute table */
+ QUERY_NOROWS(lsqlite3,
+ FALSE,
+ "DELETE FROM " FILTER_ATTR_TABLE " "
+ " WHERE 1;");/* avoid a schema change with WHERE 1 */
+
+ /*
+ * Create a table of unique attribute names for our extra table list
+ */
+ if (parsetree_to_attrlist(lsqlite3, pTree) != 0) {
+ ret = -1;
+ goto cleanup;
+ }
+
+ /*
+ * Build the attribute table list from the list of unique names.
+ */
+
+ if ((pTableList = build_attr_table_list(hTalloc, lsqlite3)) == NULL) {
+ ret = -1;
+ goto cleanup;
+ }
+
switch(scope) {
case LDB_SCOPE_DEFAULT:
case LDB_SCOPE_SUBTREE:
" AND ldap_entry.eid IN\n%s\n"
" ) "
" AND av.eid = entry.eid "
+ " AND av.attr_name IN "
+ " (SELECT attr_name "
+ " FROM " RESULT_ATTR_TABLE ") "
" ORDER BY av.eid, av.attr_name;",
pTableList,
eid,
pSqlConstraints);
break;
-
+
case LDB_SCOPE_BASE:
pSql = sqlite3_mprintf(
"SELECT entry.eid,\n"
" AND ldb_entry.eid IN\n%s\n"
" ) "
" AND av.eid = entry.eid "
+ " AND av.attr_name IN "
+ " (SELECT attr_name "
+ " FROM " RESULT_ATTR_TABLE ") "
" ORDER BY av.eid, av.attr_name;",
pTableList,
eid,
pSqlConstraints);
break;
-
+
case LDB_SCOPE_ONELEVEL:
pSql = sqlite3_mprintf(
"SELECT entry.eid,\n"
" AND ldb_entry.eid IN\n%s\n"
" ) "
" AND av.eid = entry.eid "
+ " AND av.attr_name IN "
+ " (SELECT attr_name "
+ " FROM " RESULT_ATTR_TABLE ") "
" ORDER BY av.eid, av.attr_name;",
pTableList,
eid,
pSqlConstraints);
break;
}
-
- /* Initially, we have no old eid */
- prevEID = -1;
-
+
/*
* 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; ) {
-
+ /* There are no allocate message structures yet */
+ allocated = 0;
+
+ for (i = 0; i < allocated; i++) {
+ (*pppRes)[i] = NULL;
+ }
+
/* Compile the SQL statement into sqlite virtual machine */
if ((ret = sqlite3_prepare(lsqlite3->sqlite,
pSql,
-1,
&pStmt,
NULL)) == SQLITE_SCHEMA) {
+ talloc_free(*pppRes);
continue;
} else if (ret != SQLITE_OK) {
ret = -1;
break;
}
+ /* Initially, we have no previous eid */
+ prevEID = -1;
+
/* Loop through the returned rows */
- do {
+ for (ret = SQLITE_ROW; ret == SQLITE_ROW; ) {
+
/* Get the next row */
if ((ret = sqlite3_step(pStmt)) == SQLITE_ROW) {
-
+
/* Get the values from this row */
eid = sqlite3_column_int64(pStmt, 0);
pDN = sqlite3_column_text(pStmt, 1);
pAttrName = sqlite3_column_text(pStmt, 2);
pAttrValue = sqlite3_column_text(pStmt, 3);
- /* Add this row data to the return results */
-#warning "finish returning the result set of the search here"
+ /* Add this result to the result set */
+ if ((ret = add_msg_attr(hTalloc,
+ eid,
+ pDN,
+ pAttrName,
+ pAttrValue,
+ prevEID,
+ &allocated,
+ pppRes)) != 0) {
+
+ (void) sqlite3_finalize(pStmt);
+ ret = -1;
+ break;
+ }
}
- } while (ret == SQLITE_ROW);
-
+#warning "finish returning the result set of the search here"
+ }
+
if (ret == SQLITE_SCHEMA) {
(void) sqlite3_finalize(pStmt);
+ talloc_free(*pppRes);
continue;
} else if (ret != SQLITE_DONE) {
(void) sqlite3_finalize(pStmt);
ret = -1;
break;
}
-
+
/* Free the virtual machine */
if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
(void) sqlite3_finalize(pStmt);
+ talloc_free(*pppRes);
continue;
} else if (ret != SQLITE_OK) {
(void) sqlite3_finalize(pStmt);
ret = -1;
break;
}
-
+
/*
* Normal condition is only one time through loop. Loop is
* rerun in error conditions, via "continue", above.
ret = 0;
bLoop = FALSE;
}
-
-
+
/* End the transaction */
QUERY_NOROWS(lsqlite3, FALSE, "END TRANSACTION;");
-
+
/* We're alll done with this query */
sqlite3_free(pSql);
+
+ /* Were there any results? */
+ if (ret != 0 || allocated == 0) {
+ /* Nope. We can free the results. */
+ talloc_free(pppRes);
+ }
+
+cleanup:
+ /* Clean up our temporary tables */
+ QUERY_NOROWS(lsqlite3,
+ FALSE,
+ "DELETE FROM " RESULT_ATTR_TABLE " "
+ " WHERE 1;");/* avoid a schema change with WHERE 1 */
+
+ QUERY_NOROWS(lsqlite3,
+ FALSE,
+ "DELETE FROM " FILTER_ATTR_TABLE " "
+ " WHERE 1;");/* avoid a schema change with WHERE 1 */
+
+
+ if (hTalloc != NULL) {
+ talloc_free(hTalloc);
+ }
+
+ /* If error, return error code; otherwise return number of results */
+ return ret == 0 ? allocated : ret;
+}
- return ret;
+/* search for matching records, by expression */
+static int
+lsqlite3_search(struct ldb_module * module,
+ const char * pBaseDN,
+ enum ldb_scope scope,
+ const char * pExpression,
+ const char * const * attrs,
+ struct ldb_message *** pppRes)
+{
+ int ret;
+ struct ldb_parse_tree * pTree;
+
+ /* Parse the filter expression into a tree we can work with */
+ if ((pTree = ldb_parse_tree(module->ldb, pExpression)) == NULL) {
+ return -1;
+ }
+
+ /* Now use the bytree function for the remainder of processing */
+ ret = lsqlite3_search_bytree(module, pBaseDN, scope,
+ pTree, attrs, pppRes);
+
+ /* Free the parse tree */
+ talloc_free(pTree);
+
+ /* All done. */
+ return ret;
}
{
long long eid;
struct lsqlite3_private * lsqlite3 = module->private_data;
-
+
/* ignore ltdb specials */
if (msg->dn[0] == '@') {
return 0;
}
-
+
/* Begin a transaction */
QUERY_NOROWS(lsqlite3, FALSE, "BEGIN EXCLUSIVE;");
-
+
/*
* Build any portions of the directory tree that don't exist. If the
* final component already exists, it's an error.
QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
return -1;
}
-
+
/* Add attributes to this new entry */
if (msg_to_sql(module, msg, eid, FALSE) != 0) {
QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
return -1;
}
-
+
/* Everything worked. Commit it! */
QUERY_NOROWS(lsqlite3, TRUE, "COMMIT;");
return 0;
const struct ldb_message *msg)
{
struct lsqlite3_private * lsqlite3 = module->private_data;
-
+
/* ignore ltdb specials */
if (msg->dn[0] == '@') {
return 0;
}
-
+
/* Begin a transaction */
QUERY_NOROWS(lsqlite3, FALSE, "BEGIN EXCLUSIVE;");
-
+
/* Everything worked. Commit it! */
QUERY_NOROWS(lsqlite3, TRUE, "COMMIT;");
return 0 ;
if (lockname == NULL) {
return -1;
}
-
+
/* TODO implement a local locking mechanism here */
-
+
return 0;
}
if (lockname == NULL) {
return -1;
}
-
+
/* TODO implement a local locking mechanism here */
-
+
return 0;
}
lsqlite3_errstring(struct ldb_module *module)
{
struct lsqlite3_private * lsqlite3 = module->private_data;
-
+
return sqlite3_errmsg(lsqlite3->sqlite);
}
sqlite3_stmt * stmt;
const char * schema =
"-- ------------------------------------------------------"
-
+
"PRAGMA auto_vacuum=1;"
-
+
"-- ------------------------------------------------------"
-
+
"BEGIN EXCLUSIVE;"
-
+
"-- ------------------------------------------------------"
-
+
"CREATE TABLE ldb_info AS"
" SELECT 'LDB' AS database_type,"
" '1.0' AS version;"
-
+
"-- ------------------------------------------------------"
"-- Schema"
-
+
"/*"
" * The entry table holds the information about an entry. "
" * This table is used to obtain the EID of the entry and to "
"("
" -- Unique identifier of this LDB entry"
" eid INTEGER PRIMARY KEY,"
-
+
" -- Unique identifier of the parent LDB entry"
" peid INTEGER REFERENCES ldb_entry,"
-
+
" -- Distinguished name of this entry"
" dn TEXT,"
-
+
" -- Time when the entry was created"
" create_timestamp INTEGER,"
-
+
" -- Time when the entry was last modified"
" modify_timestamp INTEGER"
");"
-
-
+
+
"/*"
" * The purpose of the descendant table is to support the"
" * subtree search feature. For each LDB entry with a unique"
"("
" -- The unique identifier of the ancestor LDB entry"
" aeid INTEGER REFERENCES ldb_entry,"
-
+
" -- The unique identifier of the descendant LDB entry"
" deid INTEGER REFERENCES ldb_entry"
");"
-
-
+
+
"CREATE TABLE ldb_object_classes"
"("
" -- Object classes are inserted into this table to track"
" -- their class hierarchy. 'top' is the top-level class"
" -- of which all other classes are subclasses."
" class_name TEXT PRIMARY KEY,"
-
+
" -- tree_key tracks the position of the class in"
" -- the hierarchy"
" tree_key TEXT UNIQUE"
");"
-
+
"/*"
" * We keep a full listing of attribute/value pairs here"
" */"
" attr_name TEXT, -- see ldb_attr_ATTRIBUTE_NAME"
" attr_value TEXT"
");"
-
+
"/*"
" * There is one attribute table per searchable attribute."
" */"
"("
" -- The unique identifier of the LDB entry"
" eid INTEGER REFERENCES ldb_entry,"
-
+
" -- Normalized attribute value"
" attr_value TEXT"
");"
"*/"
-
-
+
+
"-- ------------------------------------------------------"
"-- Indexes"
-
-
+
+
"-- ------------------------------------------------------"
"-- Triggers"
-
+
"CREATE TRIGGER ldb_entry_insert_tr"
" AFTER INSERT"
" ON ldb_entry"
" modify_timestamp = strftime('%s', 'now')"
" WHERE eid = new.eid;"
" END;"
-
+
"CREATE TRIGGER ldb_entry_update_tr"
" AFTER UPDATE"
" ON ldb_entry"
" SET modify_timestamp = strftime('%s', 'now')"
" WHERE eid = old.eid;"
" END;"
-
+
"-- ------------------------------------------------------"
"-- Table initialization"
-
+
"/* We need an implicit 'top' level object class */"
"INSERT INTO ldb_attributes (attr_name,"
" parent_tree_key)"
" SELECT 'top', '';"
-
+
"-- ------------------------------------------------------"
-
+
"COMMIT;"
-
+
"-- ------------------------------------------------------"
;
if (strncmp(url, "sqlite://", 9) != 0) {
return SQLITE_MISUSE;
}
-
+
/* Update pointer to just after the protocol indicator */
url += 9;
-
+
/* Try to open the (possibly empty/non-existent) database */
if ((ret = sqlite3_open(url, &lsqlite3->sqlite)) != SQLITE_OK) {
return ret;
}
-
+
/* Begin a transaction */
QUERY_NOROWS(lsqlite3, FALSE, "BEGIN EXCLUSIVE;");
-
+
/* Determine if this is a new database. No tables means it is. */
QUERY_INT(lsqlite3,
queryInt,
"SELECT COUNT(*) "
" FROM sqlite_master "
" WHERE type = 'table';");
-
+
if (queryInt == 0) {
/*
* Create the database schema
*/
for (pTail = discard_const_p(char, schema); pTail != NULL; ) {
-
+
if ((ret = sqlite3_prepare(
lsqlite3->sqlite,
pTail,
&pTail)) != SQLITE_OK ||
(ret = sqlite3_step(stmt)) != SQLITE_DONE ||
(ret = sqlite3_finalize(stmt)) != SQLITE_OK) {
-
+
QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
(void) sqlite3_close(lsqlite3->sqlite);
return ret;
" AND version = '1.0'"
" );") != 0 ||
queryInt != 1) {
-
+
/* It's not one that we created. See ya! */
QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
(void) sqlite3_close(lsqlite3->sqlite);
return SQLITE_MISUSE;
}
}
-
+
+ /*
+ * Create a temporary table to hold attributes requested in the result
+ * set of a search.
+ */
+ QUERY_NOROWS(lsqlite3,
+ FALSE,
+ "CREATE TEMPORARY TABLE " RESULT_ATTR_TABLE " "
+ " ("
+ " attr_name TEXT PRIMARY KEY "
+ " );");
+
+ /*
+ * Create a temporary table to hold the attributes used by filters
+ * during a search.
+ */
+ QUERY_NOROWS(lsqlite3,
+ FALSE,
+ "CREATE TEMPORARY TABLE " FILTER_ATTR_TABLE " "
+ " ("
+ " attr_name TEXT PRIMARY KEY "
+ " );");
+
/* Commit the transaction */
QUERY_NOROWS(lsqlite3, FALSE, "COMMIT;");
-
+
return SQLITE_OK;
}
destructor(void *p)
{
struct lsqlite3_private * lsqlite3 = p;
-
+
(void) sqlite3_close(lsqlite3->sqlite);
return 0;
}
/* Begin access to variable argument list */
va_start(args, pSql);
-
+
/* Format the query */
if ((p = sqlite3_vmprintf(pSql, args)) == NULL) {
return -1;
}
-
+
/*
* 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,
pTail,
ret = -1;
break;
}
-
+
/* Free the virtual machine */
if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
(void) sqlite3_finalize(pStmt);
ret = -1;
break;
}
-
+
/*
* Normal condition is only one time through loop. Loop is
* rerun in error conditions, via "continue", above.
ret = 0;
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;
}
/* Begin access to variable argument list */
va_start(args, pSql);
-
+
/* Format the query */
if ((p = sqlite3_vmprintf(pSql, args)) == NULL) {
return -1;
}
-
+
/*
* 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,
pTail,
ret = -1;
break;
}
-
+
/* Get the value to be returned */
*pRet = sqlite3_column_int64(pStmt, 0);
-
+
/* Free the virtual machine */
if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
(void) sqlite3_finalize(pStmt);
ret = -1;
break;
}
-
+
/*
* Normal condition is only one time through loop. Loop is
* rerun in error conditions, via "continue", above.
ret = 0;
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;
}
* add a single set of ldap message values to a ldb_message
*/
-#warning "add_msg_attr() not yet implemented or used"
-#if 0
static int
-add_msg_attr(struct ldb_context *ldb,
- struct ldb_message *msg,
- const char *attr,
- struct berval **bval)
+add_msg_attr(void * hTalloc,
+ long long eid,
+ const char * pDN,
+ const char * pAttrName,
+ const char * pAttrValue,
+ long long prevEID,
+ int * pAllocated,
+ struct ldb_message *** pppRes)
{
- int i;
- int count;
+ void * x;
+ struct ldb_message * msg;
struct ldb_message_element * el;
-
- count = ldap_count_values_len(bval);
-
- if (count <= 0) {
- return -1;
- }
-
- el = talloc_realloc(msg, msg->elements, struct ldb_message_element,
- msg->num_elements + 1);
- if (!el) {
- errno = ENOMEM;
- return -1;
- }
-
- msg->elements = el;
-
- el = &msg->elements[msg->num_elements];
-
- el->name = talloc_strdup(msg->elements, attr);
- if (!el->name) {
- errno = ENOMEM;
- return -1;
- }
- el->flags = 0;
-
- el->num_values = 0;
- el->values = talloc_array(msg->elements, struct ldb_val, count);
- if (!el->values) {
- errno = ENOMEM;
- return -1;
- }
-
- for (i=0;i<count;i++) {
- el->values[i].data = talloc_memdup(el->values, bval[i]->bv_val, bval[i]->bv_len);
- if (!el->values[i].data) {
- return -1;
- }
- el->values[i].length = bval[i]->bv_len;
- el->num_values++;
- }
-
- msg->num_elements++;
-
+
+ /* Is this a different EID than the previous one? */
+ if (eid != prevEID) {
+ /* Yup. Add another result to the result array */
+ if ((x = talloc_realloc(hTalloc,
+ *pAllocated == 0 ? NULL : pppRes,
+ struct ldb_message *,
+ *pAllocated + 1)) == NULL) {
+
+ return -1;
+ }
+
+ /* Save the new result list */
+ *pppRes = x;
+
+ /* We've allocated one more result */
+ *pAllocated++;
+
+ /* Ensure that the message is initialized */
+ msg = x;
+ msg->dn = NULL;
+ msg->num_elements = 0;
+ msg->elements = NULL;
+ msg->private_data = NULL;
+ } else {
+ /* Same EID. Point to the previous most-recent message */
+ msg = *pppRes[*pAllocated - 1];
+ }
+
+ /*
+ * Point to the most recent previous element. (If there are none,
+ * this will point to non-allocated memory, but the pointer will never
+ * be dereferenced.)
+ */
+ el = &msg->elements[msg->num_elements - 1];
+
+ /* See if the most recent previous element has the same attr_name */
+ if (msg->num_elements == 0 || strcmp(el->name, pAttrName) != 0) {
+
+ /* It's a new attr_name. Allocate another message element */
+ if ((el = talloc_realloc(msg,
+ msg->elements,
+ struct ldb_message_element,
+ msg->num_elements + 1)) == NULL) {
+ return -1;
+ }
+
+ /* Save the new element */
+ msg->elements = el;
+
+ /* There's now one additional element */
+ msg->num_elements++;
+
+ /* Save the attribute name */
+ if ((el->name =
+ talloc_strdup(msg->elements, pAttrName)) == NULL) {
+
+ return -1;
+ }
+
+ /* No flags */
+ el->flags = 0;
+
+ /* Initialize number of attribute values for this type */
+ el->num_values = 0;
+ el->values = NULL;
+ }
+
+ /* Increase the value array size by 1 */
+ if ((el->values =
+ talloc_realloc(el,
+ el->num_values == 0 ? NULL : el->values,
+ struct ldb_val,
+ el->num_values)) == NULL) {
+ return -1;
+ }
+
+ /* Save the new attribute value length */
+ el->values[el->num_values].length = strlen(pAttrValue) + 1;
+
+ /* Copy the new attribute value */
+ if (talloc_memdup(el->values[el->num_values].data,
+ pAttrValue,
+ el->values[el->num_values].length) == NULL) {
+ return -1;
+ }
+
+ /* We now have one additional value of this type */
+ el->num_values++;
+
return 0;
}
-#endif
static char *
parsetree_to_sql(struct ldb_module *module,
- char * hTalloc,
- const struct ldb_parse_tree *t)
+ char * hTalloc,
+ const struct ldb_parse_tree *t)
{
int i;
char * child;
char * p;
char * ret = NULL;
char * pAttrName;
-
-
+
+
switch(t->operation) {
- case LDB_OP_SIMPLE:
- break;
-
- case LDB_OP_EXTENDED:
-#warning "derrell, you'll need to work out how to handle bitops"
- return NULL;
-
- case LDB_OP_AND:
- ret = parsetree_to_sql(module,
- hTalloc,
- t->u.list.elements[0]);
-
- for (i = 1; i < t->u.list.num_elements; i++) {
- child =
- parsetree_to_sql(
- module,
- hTalloc,
- t->u.list.elements[i]);
- ret = talloc_asprintf_append(ret,
- "INTERSECT\n"
- "%s\n",
- child);
- talloc_free(child);
- }
-
- child = ret;
- ret = talloc_asprintf("(\n"
- "%s\n"
- ")\n",
- child);
- talloc_free(child);
- return ret;
-
- case LDB_OP_OR:
- child =
+ case LDB_OP_SIMPLE:
+ break;
+
+ case LDB_OP_EXTENDED:
+#warning "work out how to handle bitops"
+ return NULL;
+
+ case LDB_OP_AND:
+ ret = parsetree_to_sql(module,
+ hTalloc,
+ t->u.list.elements[0]);
+
+ for (i = 1; i < t->u.list.num_elements; i++) {
+ child =
parsetree_to_sql(
module,
hTalloc,
- t->u.list.elements[0]);
-
- for (i = 1; i < t->u.list.num_elements; i++) {
- child =
- parsetree_to_sql(
- module,
- hTalloc,
- t->u.list.elements[i]);
- ret = talloc_asprintf_append(ret,
- "UNION\n"
- "%s\n",
- child);
- talloc_free(child);
- }
- child = ret;
- ret = talloc_asprintf("(\n"
- "%s\n"
- ")\n",
- child);
+ t->u.list.elements[i]);
+ ret = talloc_asprintf_append(ret,
+ "INTERSECT\n"
+ "%s\n",
+ child);
talloc_free(child);
- return ret;
-
- case LDB_OP_NOT:
- child =
+ }
+
+ child = ret;
+ ret = talloc_asprintf("(\n"
+ "%s\n"
+ ")\n",
+ child);
+ talloc_free(child);
+ return ret;
+
+ case LDB_OP_OR:
+ child =
+ parsetree_to_sql(
+ module,
+ hTalloc,
+ t->u.list.elements[0]);
+
+ for (i = 1; i < t->u.list.num_elements; i++) {
+ child =
parsetree_to_sql(
module,
hTalloc,
- t->u.not.child);
- ret = talloc_asprintf(hTalloc,
- "(\n"
- " SELECT eid\n"
- " FROM ldb_entry\n"
- " WHERE eid NOT IN %s\n"
- ")\n",
- child);
- talloc_free(child);
- return ret;
-
- default:
- /* should never occur */
- abort();
+ t->u.list.elements[i]);
+ ret = talloc_asprintf_append(ret,
+ "UNION\n"
+ "%s\n",
+ child);
+ talloc_free(child);
+ }
+ child = ret;
+ ret = talloc_asprintf("(\n"
+ "%s\n"
+ ")\n",
+ child);
+ talloc_free(child);
+ return ret;
+
+ case LDB_OP_NOT:
+ child =
+ parsetree_to_sql(
+ module,
+ hTalloc,
+ t->u.not.child);
+ ret = talloc_asprintf(hTalloc,
+ "(\n"
+ " SELECT eid\n"
+ " FROM ldb_entry\n"
+ " WHERE eid NOT IN %s\n"
+ ")\n",
+ child);
+ talloc_free(child);
+ return ret;
+
+ default:
+ /* should never occur */
+ abort();
};
-
+
/* Get a case-folded copy of the attribute name */
pAttrName = ldb_casefold((struct ldb_context *) module,
t->u.simple.attr);
-
+
/*
* For simple searches, we want to retrieve the list of EIDs that
* match the criteria. We accomplish this by searching the
pAttrName)) == NULL) {
return NULL;
}
-
+
ret = talloc_strdup(hTalloc, p);
sqlite3_free(p);
-
+
} else if (strcasecmp(t->u.simple.attr, "objectclass") == 0) {
/*
* For object classes, we want to search for all objectclasses
t->u.simple.value.data)) == NULL) {
return NULL;
}
-
+
ret = talloc_strdup(hTalloc, p);
sqlite3_free(p);
-
+
} else {
/* A normal query. */
if ((p = sqlite3_mprintf("(\n"
t->u.simple.value.data)) == NULL) {
return NULL;
}
-
+
ret = talloc_strdup(hTalloc, p);
sqlite3_free(p);
}
}
+static int
+parsetree_to_attrlist(struct lsqlite3_private * lsqlite3,
+ const struct ldb_parse_tree * t)
+{
+ int i;
+
+ switch(t->operation) {
+ case LDB_OP_SIMPLE:
+ break;
+
+ case LDB_OP_EXTENDED:
+#warning "work out how to handle bitops"
+ return -1;
+
+ case LDB_OP_AND:
+ if (parsetree_to_attrlist(
+ lsqlite3,
+ t->u.list.elements[0]) != 0) {
+ return -1;
+ }
+
+ for (i = 1; i < t->u.list.num_elements; i++) {
+ if (parsetree_to_attrlist(
+ lsqlite3,
+ t->u.list.elements[i]) != 0) {
+ return -1;
+ }
+ }
+
+ return 0;
+
+ case LDB_OP_OR:
+ if (parsetree_to_attrlist(
+ lsqlite3,
+ t->u.list.elements[0]) != 0) {
+ return -1;
+ }
+
+ for (i = 1; i < t->u.list.num_elements; i++) {
+ if (parsetree_to_attrlist(
+ lsqlite3,
+ t->u.list.elements[i]) != 0) {
+ return -1;
+ }
+ }
+
+ return 0;
+
+ case LDB_OP_NOT:
+ if (parsetree_to_attrlist(lsqlite3,
+ t->u.not.child) != 0) {
+ return -1;
+ }
+
+ return 0;
+
+ default:
+ /* should never occur */
+ abort();
+ };
+
+ QUERY_NOROWS(lsqlite3,
+ FALSE,
+ "INSERT OR IGNORE INTO " FILTER_ATTR_TABLE " "
+ " (attr_name) "
+ " VALUES "
+ " (%Q);",
+ t->u.simple.attr);
+ return 0;
+}
+
+
+/*
+ * Use the already-generated FILTER_ATTR_TABLE to create a list of attribute
+ * table names that will be used in search queries.
+ */
static char *
-parsetree_to_tablelist(struct ldb_module *module,
- char * hTalloc,
- const struct ldb_parse_tree *t)
+build_attr_table_list(void * hTalloc,
+ struct lsqlite3_private * lsqlite3)
{
-#warning "obtain talloc'ed array of attribute names for table list"
- return NULL;
+ int ret;
+ int bLoop;
+ char * p;
+ char * pTableList;
+ sqlite3_stmt * pStmt;
+
+ /*
+ * 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; ) {
+ /* Initialize a string to which we'll append each table name */
+ if ((pTableList = talloc_strdup(hTalloc, "")) == NULL) {
+ return NULL;
+ }
+
+ /* Compile the SQL statement into sqlite virtual machine */
+ if ((ret = sqlite3_prepare(lsqlite3->sqlite,
+ "SELECT attr_name "
+ " FROM " FILTER_ATTR_TABLE ";",
+ -1,
+ &pStmt,
+ NULL)) == SQLITE_SCHEMA) {
+ continue;
+ } else if (ret != SQLITE_OK) {
+ ret = -1;
+ break;
+ }
+
+ /* Loop through the returned rows */
+ for (ret = SQLITE_ROW; ret == SQLITE_ROW; ) {
+
+ /* Get the next row */
+ if ((ret = sqlite3_step(pStmt)) == SQLITE_ROW) {
+
+ /*
+ * Get value from this row and append to table
+ * list
+ */
+ p = discard_const_p(char,
+ sqlite3_column_text(pStmt,
+ 0));
+
+ /* Append it to the table list */
+ if ((p = talloc_asprintf(
+ hTalloc,
+ "%s%s",
+ *pTableList == '\0' ? "" : ",",
+ sqlite3_column_text(pStmt,
+ 0))) == NULL) {
+
+ talloc_free(pTableList);
+ return NULL;
+ }
+
+ /* We have a new table list */
+ talloc_free(pTableList);
+ pTableList = p;
+ }
+ }
+
+ if (ret == SQLITE_SCHEMA) {
+ talloc_free(pTableList);
+ continue;
+ }
+
+ /* Free the virtual machine */
+ if ((ret = sqlite3_finalize(pStmt)) == SQLITE_SCHEMA) {
+ (void) sqlite3_finalize(pStmt);
+ continue;
+ } else if (ret != SQLITE_OK) {
+ (void) sqlite3_finalize(pStmt);
+ ret = -1;
+ break;
+ }
+
+ /*
+ * Normal condition is only one time through loop. Loop is
+ * rerun in error conditions, via "continue", above.
+ */
+ ret = 0;
+ bLoop = FALSE;
+ }
+
+ if (ret != 0) {
+ talloc_free(pTableList);
+ pTableList = NULL;
+ }
+
+ return pTableList;
}
unsigned int i;
unsigned int j;
struct lsqlite3_private * lsqlite3 = module->private_data;
-
+
for (i = 0; i < msg->num_elements; i++) {
const struct ldb_message_element *el = &msg->elements[i];
-
+
if (! use_flags) {
flags = LDB_FLAG_MOD_ADD;
} else {
flags = el->flags & LDB_FLAG_MOD_MASK;
}
-
+
/* Get a case-folded copy of the attribute name */
pAttrName = ldb_casefold((struct ldb_context *) module,
el->name);
-
+
if (flags == LDB_FLAG_MOD_ADD) {
/* Create the attribute table if it doesn't exist */
if (new_attr(module, pAttrName) != 0) {
return -1;
}
}
-
+
/* For each value of the specified attribute name... */
for (j = 0; j < el->num_values; j++) {
-
+
/* ... bind the attribute value, if necessary */
switch (flags) {
case LDB_FLAG_MOD_ADD:
" WHERE eid = %lld;",
el->name, el->values[j].data,
eid);
-
+
break;
-
+
case LDB_FLAG_MOD_REPLACE:
QUERY_NOROWS(lsqlite3,
FALSE,
el->name, el->values[j].data,
eid);
break;
-
+
case LDB_FLAG_MOD_DELETE:
/* No additional parameters to this query */
QUERY_NOROWS(lsqlite3,
}
}
}
-
+
return 0;
}
struct ldb_dn_component * pComponent;
struct ldb_context * ldb = module->ldb;
struct lsqlite3_private * lsqlite3 = module->private_data;
-
+
/* Explode and normalize the DN */
if ((pExplodedDN =
ldb_explode_dn(ldb,
case_fold_attr_required)) == NULL) {
return -1;
}
-
+
/* Allocate a string to hold the partial DN of each component */
if ((pPartialDN = talloc_strdup(ldb, "")) == NULL) {
return -1;
}
-
+
/* For each component of the DN (starting with the last one)... */
eid = 0;
for (nComponent = pExplodedDN->comp_num - 1, bFirst = TRUE;
/* Point to the component */
pComponent = pExplodedDN->components[nComponent];
-
+
/* Add this component on to the partial DN to date */
if ((p = talloc_asprintf(ldb,
"%s%s%s",
pPartialDN)) == NULL) {
return -1;
}
-
+
/* No need for the old partial DN any more */
talloc_free(pPartialDN);
-
+
/* Save the new partial DN */
pPartialDN = p;
-
+
/*
* Ensure that an entry is in the ldb_entry table for this
* component. Any component other than the last one
nComponent == 0 ? "" : "OR IGNORE",
eid, pPartialDN);
}
-
+
/* Get the EID of the just inserted row (the next parent) */
eid = sqlite3_last_insert_rowid(lsqlite3->sqlite);
}
-
+
/* Give 'em what they came for! */
*pEID = eid;
-
+
return 0;
}
static int
new_attr(struct ldb_module * module,
- char * pAttrName)
+ char * pAttrName)
{
long long bExists;
struct lsqlite3_private * lsqlite3 = module->private_data;
-
+
/*
* NOTE:
* pAttrName is assumed to already be case-folded here!
*/
-
+
/* See if the table already exists */
QUERY_INT(lsqlite3,
bExists,
" WHERE type = 'table' "
" AND tbl_name = %Q;",
pAttrName);
-
+
/* Did it exist? */
if (! bExists) {
/* Nope. Create the table */
");",
pAttrName);
}
-
+
return 0;
}
git.samba.org / jelmer / samba4-debian.git / commitdiff