mirror of
https://github.com/samba-team/samba.git
synced 2025-06-24 15:17:06 +03:00
1971 lines
68 KiB
C
1971 lines
68 KiB
C
/*
|
|
ldb database library
|
|
|
|
Copyright (C) Derrell Lipman 2005
|
|
|
|
** NOTE! The following LGPL license applies to the ldb
|
|
** library. This does NOT imply that all of Samba is released
|
|
** under the LGPL
|
|
|
|
This 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.
|
|
|
|
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
|
|
*/
|
|
|
|
/*
|
|
* Name: ldb
|
|
*
|
|
* Component: ldb sqlite3 backend
|
|
*
|
|
* Description: core files for SQLITE3 backend
|
|
*
|
|
* 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_private.h"
|
|
#include "ldb/include/ldb_explode_dn.h"
|
|
#include "ldb/ldb_sqlite3/ldb_sqlite3.h"
|
|
|
|
/*
|
|
* Macros used throughout
|
|
*/
|
|
|
|
#ifndef FALSE
|
|
# define FALSE (0)
|
|
# 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;"); \
|
|
} \
|
|
return -1; \
|
|
} \
|
|
} 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)
|
|
|
|
|
|
/*
|
|
* Static variables
|
|
*/
|
|
static int lsqlite3_debug = TRUE;
|
|
|
|
|
|
/*
|
|
* Forward declarations
|
|
*/
|
|
static int
|
|
lsqlite3_rename(struct ldb_module * module,
|
|
const char * olddn,
|
|
const char * newdn);
|
|
|
|
static int
|
|
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 *** pppRes);
|
|
|
|
static int
|
|
lsqlite3_add(struct ldb_module *module,
|
|
const struct ldb_message *msg);
|
|
|
|
static int
|
|
lsqlite3_modify(struct ldb_module *module,
|
|
const struct ldb_message *msg);
|
|
|
|
static int
|
|
lsqlite3_lock(struct ldb_module *module,
|
|
const char *lockname);
|
|
|
|
static int
|
|
lsqlite3_unlock(struct ldb_module *module,
|
|
const char *lockname);
|
|
|
|
static const char *
|
|
lsqlite3_errstring(struct ldb_module *module);
|
|
|
|
static int
|
|
initialize(struct lsqlite3_private *lsqlite3,
|
|
const char *url);
|
|
|
|
static int
|
|
destructor(void *p);
|
|
|
|
static int
|
|
query_norows(const struct lsqlite3_private *lsqlite3,
|
|
const char *pSql,
|
|
...);
|
|
|
|
static int
|
|
query_int(const struct lsqlite3_private * lsqlite3,
|
|
long long * pRet,
|
|
const char * pSql,
|
|
...);
|
|
|
|
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,
|
|
const struct ldb_parse_tree *t);
|
|
|
|
static int
|
|
parsetree_to_attrlist(struct lsqlite3_private * lsqlite3,
|
|
const struct ldb_parse_tree * t);
|
|
|
|
static char *
|
|
build_attr_table_list(void * hTalloc,
|
|
struct lsqlite3_private * lsqlite3);
|
|
|
|
static int
|
|
msg_to_sql(struct ldb_module * module,
|
|
const struct ldb_message * msg,
|
|
long long eid,
|
|
int use_flags);
|
|
|
|
static int
|
|
new_dn(struct ldb_module * module,
|
|
char * pDN,
|
|
long long * pEID);
|
|
|
|
static int
|
|
new_attr(struct ldb_module * module,
|
|
char * pAttrName);
|
|
|
|
|
|
/*
|
|
* Table of operations for the sqlite3 backend
|
|
*/
|
|
static const struct ldb_module_ops lsqlite3_ops = {
|
|
.name = "sqlite",
|
|
.search = lsqlite3_search,
|
|
.search_bytree = lsqlite3_search_bytree,
|
|
.add_record = lsqlite3_add,
|
|
.modify_record = lsqlite3_modify,
|
|
.delete_record = lsqlite3_delete,
|
|
.rename_record = lsqlite3_rename,
|
|
.named_lock = lsqlite3_lock,
|
|
.named_unlock = lsqlite3_unlock,
|
|
.errstring = lsqlite3_errstring
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Public functions
|
|
*/
|
|
|
|
|
|
/*
|
|
* connect to the database
|
|
*/
|
|
struct ldb_context *
|
|
lsqlite3_connect(const char *url,
|
|
unsigned int flags,
|
|
const char *options[])
|
|
{
|
|
int i;
|
|
int ret;
|
|
struct ldb_context * ldb = NULL;
|
|
struct lsqlite3_private * lsqlite3 = NULL;
|
|
|
|
ldb = talloc(NULL, struct ldb_context);
|
|
if (!ldb) {
|
|
goto failed;
|
|
}
|
|
|
|
lsqlite3 = talloc(ldb, struct lsqlite3_private);
|
|
if (!lsqlite3) {
|
|
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) {
|
|
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]);
|
|
if (!lsqlite3->options[i]) {
|
|
goto failed;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ldb;
|
|
|
|
failed:
|
|
if (lsqlite3->sqlite != NULL) {
|
|
(void) sqlite3_close(lsqlite3->sqlite);
|
|
}
|
|
talloc_free(ldb);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*
|
|
* Interface functions referenced by lsqlite3_ops
|
|
*/
|
|
|
|
/* rename a record */
|
|
static int
|
|
lsqlite3_rename(struct ldb_module * module,
|
|
const char * olddn,
|
|
const char * newdn)
|
|
{
|
|
/* ignore ltdb specials */
|
|
if (olddn[0] == '@' ||newdn[0] == '@') {
|
|
return 0;
|
|
}
|
|
|
|
#warning "lsqlite3_rename() is not yet supported"
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* delete a record */
|
|
static int
|
|
lsqlite3_delete(struct ldb_module *module,
|
|
const char *dn)
|
|
{
|
|
struct lsqlite3_private * lsqlite3 = module->private_data;
|
|
|
|
/* ignore ltdb specials */
|
|
if (dn[0] == '@') {
|
|
return 0;
|
|
}
|
|
|
|
/* Begin a transaction */
|
|
QUERY_NOROWS(lsqlite3, FALSE, "BEGIN EXCLUSIVE;");
|
|
|
|
|
|
#warning "lsqlite3_delete() is not yet supported"
|
|
|
|
/* Commit the transaction */
|
|
QUERY_NOROWS(lsqlite3, TRUE, "COMMIT;");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* search for matching records, by tree */
|
|
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)
|
|
{
|
|
int ret;
|
|
int allocated;
|
|
int bLoop;
|
|
long long eid = 0;
|
|
long long prevEID;
|
|
char * pSql = NULL;
|
|
char * pSqlConstraints;
|
|
char * pTableList;
|
|
char * hTalloc = NULL;
|
|
const char * pDN;
|
|
const char * pAttrName;
|
|
const char * pAttrValue;
|
|
const char * pResultAttrList;
|
|
const char * const * pRequestedAttrs;
|
|
sqlite3_stmt * pStmt;
|
|
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
|
|
*/
|
|
if ((ret = query_int(lsqlite3,
|
|
&eid,
|
|
"SELECT eid\n"
|
|
" FROM ldb_attr_DN\n"
|
|
" WHERE attr_value = %Q;",
|
|
pBaseDN)) == SQLITE_DONE) {
|
|
QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
|
|
return 0;
|
|
} else if (ret != SQLITE_OK) {
|
|
QUERY_NOROWS(lsqlite3, FALSE, "ROLLBACK;");
|
|
return -1;
|
|
}
|
|
|
|
/* Allocate a temporary talloc context */
|
|
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);
|
|
|
|
/* Ensure we're starting with an empty result attribute table */
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"DELETE FROM " RESULT_ATTR_TABLE "\n"
|
|
" WHERE 1;");/* avoid a schema change with WHERE 1 */
|
|
|
|
/* Initially, we don't know what the requested attributes are */
|
|
if (attrs == NULL) {
|
|
/* but they didn't give us any so we'll retrieve all of 'em */
|
|
pResultAttrList = "";
|
|
} else {
|
|
/* Discover the list of attributes */
|
|
pResultAttrList = NULL;
|
|
}
|
|
|
|
/* Insert the list of requested attributes into this table */
|
|
for (pRequestedAttrs = (const char * const *) attrs;
|
|
pRequestedAttrs != NULL && *pRequestedAttrs != NULL;
|
|
pRequestedAttrs++) {
|
|
|
|
/* If any attribute in the list is "*" then... */
|
|
if (strcmp(*pRequestedAttrs, "*") == 0) {
|
|
/* we want all attribute types */
|
|
pResultAttrList = "";
|
|
break;
|
|
|
|
} else {
|
|
/* otherwise, add this name to the resuult list */
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"INSERT OR IGNORE\n"
|
|
" INTO " RESULT_ATTR_TABLE "\n"
|
|
" (attr_name)\n"
|
|
" VALUES\n"
|
|
" (%Q);",
|
|
*pRequestedAttrs);
|
|
}
|
|
}
|
|
|
|
/* If we didn't get a "*" for all attributes in the result list... */
|
|
if (pResultAttrList == NULL) {
|
|
/* ... then we'll use the result attribute table */
|
|
pResultAttrList =
|
|
" AND av.attr_name IN\n"
|
|
" (SELECT attr_name\n"
|
|
" FROM " RESULT_ATTR_TABLE ") ";
|
|
}
|
|
|
|
/* Ensure we're starting with an empty filter attribute table */
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"DELETE FROM " FILTER_ATTR_TABLE "\n"
|
|
" WHERE 1;");/* avoid a schema change with WHERE 1 */
|
|
|
|
/*
|
|
* Create a table of unique attribute names for our extra table list
|
|
*/
|
|
if ((ret = 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:
|
|
pSql = sqlite3_mprintf(
|
|
"SELECT entry.eid,\n"
|
|
" entry.dn,\n"
|
|
" av.attr_name,\n"
|
|
" av.attr_value\n"
|
|
" FROM ldb_entry AS entry,\n"
|
|
" ldb_attribute_values AS av\n"
|
|
" WHERE entry.eid IN\n"
|
|
" (SELECT DISTINCT ldb_entry.eid\n"
|
|
" FROM ldb_entry,\n"
|
|
" ldb_descendants\n"
|
|
" WHERE ldb_descendants.aeid = %lld\n"
|
|
" AND ldb_entry.eid = ldb_descendants.deid\n"
|
|
" AND ldb_entry.eid IN\n%s\n"
|
|
" )\n"
|
|
" AND av.eid = entry.eid\n"
|
|
" %s\n"
|
|
" ORDER BY av.eid, av.attr_name;",
|
|
eid,
|
|
pSqlConstraints,
|
|
pResultAttrList);
|
|
break;
|
|
|
|
case LDB_SCOPE_BASE:
|
|
pSql = sqlite3_mprintf(
|
|
"SELECT entry.eid,\n"
|
|
" entry.dn,\n"
|
|
" av.attr_name,\n"
|
|
" av.attr_value\n"
|
|
" FROM ldb_entry AS entry,\n"
|
|
" ldb_attribute_values AS av\n"
|
|
" WHERE entry.eid IN\n"
|
|
" (SELECT DISTINCT ldb_entry.eid\n"
|
|
" FROM ldb_entry\n"
|
|
" WHERE ldb_entry.eid = %lld\n"
|
|
" AND ldb_entry.eid IN\n%s\n"
|
|
" )\n"
|
|
" AND av.eid = entry.eid\n"
|
|
" %s\n"
|
|
" ORDER BY av.eid, av.attr_name;",
|
|
eid,
|
|
pSqlConstraints,
|
|
pResultAttrList);
|
|
break;
|
|
|
|
case LDB_SCOPE_ONELEVEL:
|
|
pSql = sqlite3_mprintf(
|
|
"SELECT entry.eid,\n"
|
|
" entry.dn,\n"
|
|
" av.attr_name,\n"
|
|
" av.attr_value\n"
|
|
" FROM ldb_entry AS entry,\n"
|
|
" ldb_attribute_values AS av\n"
|
|
" WHERE entry.eid IN\n"
|
|
" (SELECT DISTINCT ldb_entry.eid\n"
|
|
" FROM ldb_entry AS pchild\n"
|
|
" WHERE ldb_entry.eid = pchild.eid\n"
|
|
" AND pchild.peid = %lld\n"
|
|
" AND ldb_entry.eid IN\n%s\n"
|
|
" )\n"
|
|
" AND av.eid = entry.eid\n"
|
|
" %s\n"
|
|
" ORDER BY av.eid, av.attr_name;\n",
|
|
eid,
|
|
pSqlConstraints,
|
|
pResultAttrList);
|
|
break;
|
|
}
|
|
|
|
if (lsqlite3_debug) {
|
|
printf("%s\n", pSql);
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
if (pppRes != NULL) {
|
|
*pppRes = NULL;
|
|
}
|
|
|
|
/* Compile the SQL statement into sqlite virtual machine */
|
|
if ((ret = sqlite3_prepare(lsqlite3->sqlite,
|
|
pSql,
|
|
-1,
|
|
&pStmt,
|
|
NULL)) == SQLITE_SCHEMA) {
|
|
if (pppRes != NULL && *pppRes != NULL) {
|
|
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 */
|
|
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 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ret == SQLITE_SCHEMA) {
|
|
(void) sqlite3_finalize(pStmt);
|
|
if (pppRes != NULL && *pppRes != NULL) {
|
|
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);
|
|
if (pppRes != NULL && *pppRes != NULL) {
|
|
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. */
|
|
if (pppRes != NULL && *pppRes != NULL) {
|
|
talloc_free(*pppRes);
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
/* Clean up our temporary tables */
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"DELETE FROM " RESULT_ATTR_TABLE "\n"
|
|
" WHERE 1;");/* avoid a schema change with WHERE 1 */
|
|
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"DELETE FROM " FILTER_ATTR_TABLE "\n"
|
|
" 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;
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
|
|
/* add a record */
|
|
static int
|
|
lsqlite3_add(struct ldb_module *module,
|
|
const struct ldb_message *msg)
|
|
{
|
|
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.
|
|
*/
|
|
if (new_dn(module, msg->dn, &eid) != 0) {
|
|
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;
|
|
}
|
|
|
|
|
|
/* modify a record */
|
|
static int
|
|
lsqlite3_modify(struct ldb_module *module,
|
|
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;");
|
|
|
|
#warning "modify() not yet implemented"
|
|
|
|
/* Everything worked. Commit it! */
|
|
QUERY_NOROWS(lsqlite3, TRUE, "COMMIT;");
|
|
return 0 ;
|
|
}
|
|
|
|
/* obtain a named lock */
|
|
static int
|
|
lsqlite3_lock(struct ldb_module *module,
|
|
const char *lockname)
|
|
{
|
|
if (lockname == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
/* TODO implement a local locking mechanism here */
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* release a named lock */
|
|
static int
|
|
lsqlite3_unlock(struct ldb_module *module,
|
|
const char *lockname)
|
|
{
|
|
if (lockname == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
/* TODO implement a local locking mechanism here */
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* return extended error information */
|
|
static const char *
|
|
lsqlite3_errstring(struct ldb_module *module)
|
|
{
|
|
struct lsqlite3_private * lsqlite3 = module->private_data;
|
|
|
|
return sqlite3_errmsg(lsqlite3->sqlite);
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Static functions
|
|
*/
|
|
|
|
static int
|
|
initialize(struct lsqlite3_private *lsqlite3,
|
|
const char *url)
|
|
{
|
|
int ret;
|
|
long long queryInt;
|
|
const char * pTail;
|
|
sqlite3_stmt * stmt;
|
|
const char * schema =
|
|
|
|
|
|
"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
|
|
* 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.
|
|
*/
|
|
"CREATE TABLE ldb_entry "
|
|
"("
|
|
" eid INTEGER PRIMARY KEY,"
|
|
" peid INTEGER REFERENCES ldb_entry,"
|
|
" dn TEXT UNIQUE,"
|
|
" create_timestamp INTEGER,"
|
|
" modify_timestamp INTEGER"
|
|
");"
|
|
|
|
|
|
/*
|
|
* The purpose of the descendant table is to support the
|
|
* subtree search feature. For each LDB entry with a unique
|
|
* ID (AEID), this table contains the unique identifiers
|
|
* (DEID) of the descendant entries.
|
|
*
|
|
* For evern entry in the directory, a row exists in this
|
|
* table for each of its ancestors including itself. The
|
|
* size of the table depends on the depth of each entry. In
|
|
* the worst case, if all the entries were at the same
|
|
* depth, the number of rows in the table is O(nm) where
|
|
* n is the number of nodes in the directory and m is the
|
|
* depth of the tree.
|
|
*/
|
|
"CREATE TABLE ldb_descendants "
|
|
"( "
|
|
" aeid INTEGER REFERENCES ldb_entry,"
|
|
" deid INTEGER REFERENCES ldb_entry"
|
|
");"
|
|
|
|
|
|
"CREATE TABLE ldb_object_classes"
|
|
"("
|
|
" class_name TEXT PRIMARY KEY,"
|
|
" tree_key TEXT UNIQUE"
|
|
");"
|
|
|
|
/*
|
|
* We keep a full listing of attribute/value pairs here
|
|
*/
|
|
"CREATE TABLE ldb_attribute_values"
|
|
"("
|
|
" eid INTEGER REFERENCES ldb_entry,"
|
|
" attr_name TEXT,"
|
|
" attr_value TEXT"
|
|
");"
|
|
|
|
/*
|
|
* There is one attribute table per searchable attribute.
|
|
*/
|
|
/*
|
|
"CREATE TABLE ldb_attr_ATTRIBUTE_NAME"
|
|
"("
|
|
" eid INTEGER REFERENCES ldb_entry,"
|
|
" attr_value TEXT"
|
|
");"
|
|
*/
|
|
|
|
/*
|
|
* We pre-create the dn attribute table
|
|
*/
|
|
"CREATE TABLE ldb_attr_DN"
|
|
"("
|
|
" eid INTEGER REFERENCES ldb_entry,"
|
|
" attr_value TEXT"
|
|
");"
|
|
|
|
|
|
/*
|
|
* We pre-create the objectclass attribute table
|
|
*/
|
|
"CREATE TABLE ldb_attr_OBJECTCLASS"
|
|
"("
|
|
" eid INTEGER REFERENCES ldb_entry,"
|
|
" attr_value TEXT"
|
|
");"
|
|
|
|
|
|
/*
|
|
* Indexes
|
|
*/
|
|
|
|
|
|
/*
|
|
* Triggers
|
|
*/
|
|
|
|
"CREATE TRIGGER ldb_entry_insert_tr"
|
|
" AFTER INSERT"
|
|
" ON ldb_entry"
|
|
" FOR EACH ROW"
|
|
" BEGIN"
|
|
" UPDATE ldb_entry"
|
|
" SET create_timestamp = strftime('%s', 'now'),"
|
|
" modify_timestamp = strftime('%s', 'now')"
|
|
" WHERE eid = new.eid;"
|
|
" END;"
|
|
|
|
"CREATE TRIGGER ldb_entry_update_tr"
|
|
" AFTER UPDATE"
|
|
" ON ldb_entry"
|
|
" FOR EACH ROW"
|
|
" BEGIN"
|
|
" UPDATE ldb_entry"
|
|
" SET modify_timestamp = strftime('%s', 'now')"
|
|
" WHERE eid = old.eid;"
|
|
" END;"
|
|
|
|
/*
|
|
* Table initialization
|
|
*/
|
|
|
|
/* The root node */
|
|
"INSERT INTO ldb_entry "
|
|
" (eid, peid, dn) "
|
|
" VALUES "
|
|
" (0, NULL, '');"
|
|
|
|
/* And the root node "dn" attribute */
|
|
"INSERT INTO ldb_attr_DN "
|
|
" (eid, attr_value) "
|
|
" VALUES "
|
|
" (0, '');"
|
|
|
|
;
|
|
|
|
/* Skip protocol indicator of url */
|
|
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;
|
|
}
|
|
|
|
/* In case this is a new database, enable auto_vacuum */
|
|
QUERY_NOROWS(lsqlite3, FALSE, "PRAGMA auto_vacuum=1;");
|
|
|
|
/* 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,
|
|
TRUE,
|
|
"SELECT COUNT(*)\n"
|
|
" FROM sqlite_master\n"
|
|
" WHERE type = 'table';");
|
|
|
|
if (queryInt == 0) {
|
|
/*
|
|
* Create the database schema
|
|
*/
|
|
for (pTail = discard_const_p(char, schema);
|
|
pTail != NULL && *pTail != '\0';
|
|
) {
|
|
|
|
if (lsqlite3_debug) {
|
|
printf("Execute first query in:\n%s\n", pTail);
|
|
}
|
|
|
|
if ((ret = sqlite3_prepare(
|
|
lsqlite3->sqlite,
|
|
pTail,
|
|
-1,
|
|
&stmt,
|
|
&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;
|
|
}
|
|
}
|
|
} else {
|
|
/*
|
|
* Ensure that the database we opened is one of ours
|
|
*/
|
|
if (query_int(lsqlite3,
|
|
&queryInt,
|
|
"SELECT "
|
|
" (SELECT COUNT(*) = 3"
|
|
" FROM sqlite_master "
|
|
" WHERE type = 'table' "
|
|
" AND name IN "
|
|
" ("
|
|
" 'ldb_entry', "
|
|
" 'ldb_descendants', "
|
|
" 'ldb_object_classes' "
|
|
" ) "
|
|
" ) "
|
|
" AND "
|
|
" (SELECT 1 "
|
|
" FROM ldb_info "
|
|
" WHERE database_type = 'LDB' "
|
|
" 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 "\n"
|
|
" (\n"
|
|
" attr_name TEXT PRIMARY KEY\n"
|
|
" );");
|
|
|
|
/*
|
|
* Create a temporary table to hold the attributes used by filters
|
|
* during a search.
|
|
*/
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"CREATE TEMPORARY TABLE " FILTER_ATTR_TABLE "\n"
|
|
" (\n"
|
|
" attr_name TEXT PRIMARY KEY\n"
|
|
" );");
|
|
|
|
/* Commit the transaction */
|
|
QUERY_NOROWS(lsqlite3, FALSE, "COMMIT;");
|
|
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
static int
|
|
destructor(void *p)
|
|
{
|
|
struct lsqlite3_private * lsqlite3 = p;
|
|
|
|
(void) sqlite3_close(lsqlite3->sqlite);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* query_norows()
|
|
*
|
|
* This function is used for queries that are not expected to return any rows,
|
|
* e.g. BEGIN, COMMIT, ROLLBACK, CREATE TABLE, INSERT, UPDATE, DELETE, etc.
|
|
* There are no provisions here for returning data from rows in a table, so do
|
|
* not pass SELECT queries to this function.
|
|
*/
|
|
static int
|
|
query_norows(const struct lsqlite3_private *lsqlite3,
|
|
const char *pSql,
|
|
...)
|
|
{
|
|
int ret;
|
|
int bLoop;
|
|
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) {
|
|
return -1;
|
|
}
|
|
|
|
if (lsqlite3_debug) {
|
|
printf("%s\n", p);
|
|
}
|
|
|
|
/*
|
|
* 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,
|
|
-1,
|
|
&pStmt,
|
|
NULL)) == SQLITE_SCHEMA) {
|
|
continue;
|
|
} else if (ret != SQLITE_OK) {
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
/* No rows expected, so just step through machine code once */
|
|
if ((ret = sqlite3_step(pStmt)) == SQLITE_SCHEMA) {
|
|
(void) sqlite3_finalize(pStmt);
|
|
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);
|
|
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;
|
|
}
|
|
|
|
/* All done with variable argument list */
|
|
va_end(args);
|
|
|
|
/* Free the memory we allocated for our query string */
|
|
sqlite3_free(p);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/*
|
|
* query_int()
|
|
*
|
|
* This function is used for the common case of queries that return a single
|
|
* integer value.
|
|
*
|
|
* NOTE: If more than one value is returned by the query, all but the first
|
|
* one will be ignored.
|
|
*/
|
|
static int
|
|
query_int(const struct lsqlite3_private * lsqlite3,
|
|
long long * pRet,
|
|
const char * pSql,
|
|
...)
|
|
{
|
|
int ret;
|
|
int bLoop;
|
|
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) {
|
|
return SQLITE_NOMEM;
|
|
}
|
|
|
|
if (lsqlite3_debug) {
|
|
printf("%s\n", p);
|
|
}
|
|
|
|
/*
|
|
* 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,
|
|
-1,
|
|
&pStmt,
|
|
NULL)) == SQLITE_SCHEMA) {
|
|
continue;
|
|
} else if (ret != SQLITE_OK) {
|
|
break;
|
|
}
|
|
|
|
/* One row expected */
|
|
if ((ret = sqlite3_step(pStmt)) == SQLITE_SCHEMA) {
|
|
(void) sqlite3_finalize(pStmt);
|
|
continue;
|
|
} else if (ret != SQLITE_ROW) {
|
|
(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) {
|
|
(void) sqlite3_finalize(pStmt);
|
|
continue;
|
|
} else if (ret != SQLITE_OK) {
|
|
(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;
|
|
}
|
|
|
|
|
|
/*
|
|
callback function used in call to ldb_dn_fold() for determining whether an
|
|
attribute type requires case folding.
|
|
*/
|
|
static int
|
|
case_fold_attr_required(void * hUserData,
|
|
char *attr)
|
|
{
|
|
// struct ldb_module * module = hUserData;
|
|
|
|
#warning "currently, all attributes require case folding"
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* add a single set of ldap message values to a ldb_message
|
|
*/
|
|
|
|
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)
|
|
{
|
|
void * x;
|
|
struct ldb_message * msg;
|
|
struct ldb_message_element * el;
|
|
|
|
/* 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;
|
|
}
|
|
|
|
static char *
|
|
parsetree_to_sql(struct ldb_module *module,
|
|
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 "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 =
|
|
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);
|
|
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
|
|
* appropriate table, ldb_attr_<attributeName>, for the eid
|
|
* corresponding to all matching values.
|
|
*/
|
|
if (t->u.simple.value.length == 1 &&
|
|
(*(const char *) t->u.simple.value.data) == '*') {
|
|
/*
|
|
* Special case for "attr_name=*". In this case, we want the
|
|
* eid corresponding to all values in the specified attribute
|
|
* table.
|
|
*/
|
|
if ((p = sqlite3_mprintf("(\n"
|
|
" SELECT eid\n"
|
|
" FROM ldb_attr_%q\n"
|
|
")\n",
|
|
pAttrName)) == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (lsqlite3_debug) {
|
|
printf("%s\n", p);
|
|
}
|
|
|
|
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
|
|
* that are subclasses as well.
|
|
*/
|
|
if ((p = sqlite3_mprintf(
|
|
"(\n"
|
|
" SELECT eid\n"
|
|
" FROM ldb_attr_OBJECTCLASS\n"
|
|
" WHERE attr_name IN\n"
|
|
" (SELECT class_name\n"
|
|
" FROM ldb_objectclasses\n"
|
|
" WHERE tree_key GLOB\n"
|
|
" (SELECT tree_key\n"
|
|
" FROM ldb_objectclasses\n"
|
|
" WHERE class_name = %Q) || '*')\n"
|
|
")\n",
|
|
t->u.simple.value.data)) == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (lsqlite3_debug) {
|
|
printf("%s\n", p);
|
|
}
|
|
|
|
ret = talloc_strdup(hTalloc, p);
|
|
sqlite3_free(p);
|
|
|
|
} else {
|
|
/* A normal query. */
|
|
if ((p = sqlite3_mprintf("(\n"
|
|
" SELECT eid\n"
|
|
" FROM ldb_attr_%q\n"
|
|
" WHERE attr_value = %Q\n"
|
|
")\n",
|
|
pAttrName,
|
|
t->u.simple.value.data)) == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (lsqlite3_debug) {
|
|
printf("%s\n", p);
|
|
}
|
|
|
|
ret = talloc_strdup(hTalloc, p);
|
|
sqlite3_free(p);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
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 "\n"
|
|
" (attr_name)\n"
|
|
" VALUES\n"
|
|
" (%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 *
|
|
build_attr_table_list(void * hTalloc,
|
|
struct lsqlite3_private * lsqlite3)
|
|
{
|
|
int ret;
|
|
int bLoop;
|
|
char * p;
|
|
char * pAttrName;
|
|
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));
|
|
|
|
pAttrName =
|
|
ldb_casefold(
|
|
hTalloc,
|
|
sqlite3_column_text(pStmt, 0));
|
|
|
|
/* Append it to the table list */
|
|
if ((p = talloc_asprintf(
|
|
hTalloc,
|
|
"%sldb_attr_%s",
|
|
*pTableList == '\0' ? "" : ",",
|
|
pAttrName)) == 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;
|
|
}
|
|
|
|
|
|
/*
|
|
* Issue a series of SQL statements to implement the ADD/MODIFY/DELETE
|
|
* requests in the ldb_message
|
|
*/
|
|
static int
|
|
msg_to_sql(struct ldb_module * module,
|
|
const struct ldb_message * msg,
|
|
long long eid,
|
|
int use_flags)
|
|
{
|
|
int flags;
|
|
char * pAttrName;
|
|
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:
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"INSERT INTO ldb_attr_%q\n"
|
|
" (eid, attr_value)\n"
|
|
" VALUES\n"
|
|
" (%lld, %Q);",
|
|
pAttrName,
|
|
eid, el->values[j].data);
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"INSERT INTO ldb_attribute_values"
|
|
" (eid, attr_name, attr_value)"
|
|
" VALUES "
|
|
" (%lld, %Q, %Q);",
|
|
eid,
|
|
el->name,
|
|
el->values[j].data);
|
|
|
|
break;
|
|
|
|
case LDB_FLAG_MOD_REPLACE:
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"UPDATE ldb_attr_%q\n"
|
|
" SET attr_value = %Q\n"
|
|
" WHERE eid = %lld;",
|
|
pAttrName,
|
|
el->values[j].data,
|
|
eid);
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"UPDATE ldb_attribute_values "
|
|
" SET attr_value = %Q "
|
|
" WHERE eid = %lld "
|
|
" AND attr_name = %Q;",
|
|
el->values[j].data,
|
|
eid,
|
|
el->name);
|
|
break;
|
|
|
|
case LDB_FLAG_MOD_DELETE:
|
|
/* No additional parameters to this query */
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"DELETE FROM ldb_attr_%q\n"
|
|
" WHERE eid = %lld\n"
|
|
" AND attr_value = %Q;",
|
|
pAttrName,
|
|
eid,
|
|
el->values[j].data);
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"DELETE FROM ldb_attribute_values"
|
|
" WHERE eid = %lld "
|
|
" AND attr_name = %Q "
|
|
" AND attr_value = %Q;",
|
|
eid,
|
|
el->name,
|
|
el->values[j].data);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
new_dn(struct ldb_module * module,
|
|
char * pDN,
|
|
long long * pEID)
|
|
{
|
|
int nComponent;
|
|
int bFirst;
|
|
char * p;
|
|
char * pPartialDN;
|
|
long long eid;
|
|
struct ldb_dn * pExplodedDN;
|
|
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,
|
|
pDN,
|
|
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;
|
|
nComponent >= 0;
|
|
nComponent--, bFirst = FALSE) {
|
|
|
|
/* 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",
|
|
pComponent->component,
|
|
bFirst ? "" : ",",
|
|
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
|
|
* (component 0) may already exist. It is an error if
|
|
* component 0 (the full DN requested to be be inserted)
|
|
* already exists.
|
|
*/
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"INSERT %s INTO ldb_entry\n"
|
|
" (peid, dn)\n"
|
|
" VALUES\n"
|
|
" (%lld, %Q);",
|
|
nComponent == 0 ? "" : "OR IGNORE",
|
|
eid, pPartialDN);
|
|
|
|
/* Get the EID of the just inserted row (the next parent) */
|
|
eid = sqlite3_last_insert_rowid(lsqlite3->sqlite);
|
|
|
|
/* If this is the final component, also add DN attribute */
|
|
if (nComponent == 0) {
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"INSERT %s INTO ldb_attr_DN\n"
|
|
" (eid, attr_value) "
|
|
" VALUES "
|
|
" (%lld, %Q);",
|
|
nComponent == 0 ? "" : "OR IGNORE",
|
|
eid, pPartialDN);
|
|
}
|
|
}
|
|
|
|
/* Give 'em what they came for! */
|
|
*pEID = eid;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
new_attr(struct ldb_module * module,
|
|
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,
|
|
FALSE,
|
|
"SELECT COUNT(*) <> 0\n"
|
|
" FROM sqlite_master\n"
|
|
" WHERE type = 'table'\n"
|
|
" AND tbl_name = 'ldb_attr_%q';",
|
|
pAttrName);
|
|
|
|
/* Did it exist? */
|
|
if (! bExists) {
|
|
/* Nope. Create the table */
|
|
QUERY_NOROWS(lsqlite3,
|
|
FALSE,
|
|
"CREATE TABLE ldb_attr_%q\n"
|
|
"(\n"
|
|
" eid INTEGER REFERENCES ldb_entry,\n"
|
|
" attr_value TEXT\n"
|
|
");",
|
|
pAttrName);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|