X-Git-Url: http://git.samba.org/samba.git/?p=jelmer%2Fsamba4-debian.git;a=blobdiff_plain;f=source%2Flib%2Fdb_wrap.c;h=c33786a1e43a8c0b83b8259c9972357e23ff33d6;hp=c0240aa62df1e201d8b5c12595cf5042b7ecc1c4;hb=3468952e771ab31f90b6c374ade01c5550810f42;hpb=c5bccbc366db144d3e1cb7b21f0e3284d841dd06 diff --git a/source/lib/db_wrap.c b/source/lib/db_wrap.c index c0240aa62..c33786a1e 100644 --- a/source/lib/db_wrap.c +++ b/source/lib/db_wrap.c @@ -7,7 +7,7 @@ This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,8 +16,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with this program. If not, see . */ /* @@ -28,19 +27,16 @@ */ #include "includes.h" -#include "dlinklist.h" +#include "lib/util/dlinklist.h" +#include "lib/events/events.h" #include "lib/tdb/include/tdb.h" #include "lib/ldb/include/ldb.h" +#include "lib/ldb/include/ldb_errors.h" +#include "lib/ldb-samba/ldif_handlers.h" #include "db_wrap.h" +#include "dsdb/samdb/samdb.h" +#include "param/param.h" -struct ldb_wrap { - struct ldb_context *ldb; - - const char *url; - struct ldb_wrap *next, *prev; -}; - -static struct ldb_wrap *ldb_list; static struct tdb_wrap *tdb_list; /* @@ -52,94 +48,145 @@ static void ldb_wrap_debug(void *context, enum ldb_debug_level level, static void ldb_wrap_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) { + int samba_level; char *s = NULL; - if (DEBUGLEVEL < 4 && level > LDB_DEBUG_WARNING) { - return; - } + switch (level) { + case LDB_DEBUG_FATAL: + samba_level = 0; + break; + case LDB_DEBUG_ERROR: + samba_level = 1; + break; + case LDB_DEBUG_WARNING: + samba_level = 2; + break; + case LDB_DEBUG_TRACE: + samba_level = 5; + break; + + }; vasprintf(&s, fmt, ap); if (!s) return; DEBUG(level, ("ldb: %s\n", s)); free(s); } -/* destroy the last connection to a ldb */ -static int ldb_wrap_destructor(void *ctx) +char *wrap_casefold(void *context, void *mem_ctx, const char *s) { - struct ldb_wrap *w = ctx; - DLIST_REMOVE(ldb_list, w); + return strupper_talloc(mem_ctx, s); +} + +/* check for memory leaks on the ldb context */ +static int ldb_wrap_destructor(struct ldb_context *ldb) +{ + size_t *startup_blocks = (size_t *)ldb_get_opaque(ldb, "startup_blocks"); + if (startup_blocks && + talloc_total_blocks(ldb) > *startup_blocks + 400) { + DEBUG(0,("WARNING: probable memory leak in ldb %s - %lu blocks (startup %lu) %lu bytes\n", + (char *)ldb_get_opaque(ldb, "wrap_url"), + (unsigned long)talloc_total_blocks(ldb), + (unsigned long)*startup_blocks, + (unsigned long)talloc_total_size(ldb))); +#if 0 + talloc_report_full(ldb, stdout); + call_backtrace(); + smb_panic("probable memory leak in ldb"); +#endif + } return 0; } /* wrapped connection to a ldb database to close just talloc_free() the returned ldb_context + + TODO: We need an error_string parameter */ struct ldb_context *ldb_wrap_connect(TALLOC_CTX *mem_ctx, + struct loadparm_context *lp_ctx, const char *url, + struct auth_session_info *session_info, + struct cli_credentials *credentials, unsigned int flags, const char *options[]) { struct ldb_context *ldb; - struct ldb_wrap *w; int ret; struct event_context *ev; char *real_url = NULL; + size_t *startup_blocks; - for (w = ldb_list; w; w = w->next) { - if (strcmp(url, w->url) == 0) { - return talloc_reference(mem_ctx, w->ldb); - } - } - - ldb = ldb_init(talloc_autofree_context()); + ldb = ldb_init(mem_ctx); if (ldb == NULL) { return NULL; } + ldb_set_modules_dir(ldb, + talloc_asprintf(ldb, "%s/ldb", lp_modulesdir(lp_ctx))); + /* we want to use the existing event context if possible. This relies on the fact that in smbd, everything is a child of the main event_context */ - ev = talloc_find_parent_bytype(mem_ctx, struct event_context); - if (ev) { - ldb_set_opaque(ldb, "EventContext", ev); - } else { - DEBUG(0,("WARNING: event_context not found\n")); - talloc_show_parents(mem_ctx, stdout); + ev = event_context_find(ldb); + + if (ldb_set_opaque(ldb, "EventContext", ev)) { + talloc_free(ldb); + return NULL; } - ret = ldb_register_samba_handlers(ldb); - if (ret == -1) { + if (ldb_set_opaque(ldb, "sessionInfo", session_info)) { talloc_free(ldb); return NULL; } - real_url = private_path(ldb, url); - if (real_url == NULL) { + if (ldb_set_opaque(ldb, "credentials", credentials)) { talloc_free(ldb); return NULL; } - ret = ldb_connect(ldb, real_url, flags, options); + if (strcmp(lp_sam_url(lp_ctx), url) == 0) { + dsdb_set_global_schema(ldb); + } + + ret = ldb_register_samba_handlers(ldb); if (ret == -1) { talloc_free(ldb); return NULL; } - talloc_free(real_url); + ldb_set_debug(ldb, ldb_wrap_debug, NULL); - w = talloc(ldb, struct ldb_wrap); - if (w == NULL) { + ldb_set_utf8_fns(ldb, NULL, wrap_casefold); + + real_url = private_path(ldb, lp_ctx, url); + if (real_url == NULL) { talloc_free(ldb); return NULL; } - w->ldb = ldb; - w->url = talloc_strdup(w, url); + /* allow admins to force non-sync ldb for all databases */ + if (lp_parm_bool(lp_ctx, NULL, "ldb", "nosync", false)) { + flags |= LDB_FLG_NOSYNC; + } - talloc_set_destructor(w, ldb_wrap_destructor); - ldb_set_debug(ldb, ldb_wrap_debug, NULL); + /* we usually want Samba databases to be private. If we later + find we need one public, we will need to add a parameter to + ldb_wrap_connect() */ + ldb_set_create_perms(ldb, 0600); + + ret = ldb_connect(ldb, real_url, flags, options); + if (ret != LDB_SUCCESS) { + talloc_free(ldb); + return NULL; + } - DLIST_ADD(ldb_list, w); + /* setup for leak detection */ + ldb_set_opaque(ldb, "wrap_url", real_url); + startup_blocks = talloc(ldb, size_t); + *startup_blocks = talloc_total_blocks(ldb); + ldb_set_opaque(ldb, "startup_blocks", startup_blocks); + + talloc_set_destructor(ldb, ldb_wrap_destructor); return ldb; } @@ -148,30 +195,48 @@ struct ldb_context *ldb_wrap_connect(TALLOC_CTX *mem_ctx, /* Log tdb messages via DEBUG(). */ -static void tdb_wrap_log(TDB_CONTEXT *tdb, int level, +static void tdb_wrap_log(TDB_CONTEXT *tdb, enum tdb_debug_level level, const char *format, ...) PRINTF_ATTRIBUTE(3,4); -static void tdb_wrap_log(TDB_CONTEXT *tdb, int level, +static void tdb_wrap_log(TDB_CONTEXT *tdb, enum tdb_debug_level level, const char *format, ...) { va_list ap; char *ptr = NULL; + int debug_level; va_start(ap, format); vasprintf(&ptr, format, ap); va_end(ap); + switch (level) { + case TDB_DEBUG_FATAL: + debug_level = 0; + break; + case TDB_DEBUG_ERROR: + debug_level = 1; + break; + case TDB_DEBUG_WARNING: + debug_level = 2; + break; + case TDB_DEBUG_TRACE: + debug_level = 5; + break; + default: + debug_level = 0; + } + if (ptr != NULL) { - DEBUG(level, ("tdb(%s): %s", tdb->name ? tdb->name : "unnamed", ptr)); + const char *name = tdb_name(tdb); + DEBUG(debug_level, ("tdb(%s): %s", name ? name : "unnamed", ptr)); free(ptr); } } /* destroy the last connection to a tdb */ -static int tdb_wrap_destructor(void *ctx) +static int tdb_wrap_destructor(struct tdb_wrap *w) { - struct tdb_wrap *w = ctx; tdb_close(w->tdb); DLIST_REMOVE(tdb_list, w); return 0; @@ -186,6 +251,8 @@ struct tdb_wrap *tdb_wrap_open(TALLOC_CTX *mem_ctx, int open_flags, mode_t mode) { struct tdb_wrap *w; + struct tdb_logging_context log_ctx; + log_ctx.log_fn = tdb_wrap_log; for (w=tdb_list;w;w=w->next) { if (strcmp(name, w->name) == 0) { @@ -201,7 +268,7 @@ struct tdb_wrap *tdb_wrap_open(TALLOC_CTX *mem_ctx, w->name = talloc_strdup(w, name); w->tdb = tdb_open_ex(name, hash_size, tdb_flags, - open_flags, mode, tdb_wrap_log, NULL); + open_flags, mode, &log_ctx, NULL); if (w->tdb == NULL) { talloc_free(w); return NULL;