Load samba-3.4.0 into branches/samba/upstream.upstream/3.4.0

git-svn-id: svn://svn.debian.org/svn/pkg-samba/branches/samba/upstream@2934 fc4039ab-9d04-0410-8cac-899223bdd6b0

21 files changed, 6462 insertions, 0 deletions

diff --git a/source4/param/README b/source4/param/README
new file mode 100644
index 0000000000..403a217588
--- /dev/null
+++ b/source4/param/README
@@ -0,0 +1,4 @@
+This directory contains "libsamba-hostconfig". 
+
+The libsamba-hostconfig library provides access to all host-wide configuration
+such as the configured shares, default parameter values and host secret keys.
diff --git a/source4/param/config.mk b/source4/param/config.mk
new file mode 100644
index 0000000000..d420a3883c
--- /dev/null
+++ b/source4/param/config.mk
@@ -0,0 +1,64 @@
+[LIBRARY::LIBSAMBA-HOSTCONFIG]
+PUBLIC_DEPENDENCIES = LIBSAMBA-UTIL 
+PRIVATE_DEPENDENCIES = DYNCONFIG LIBREPLACE_EXT CHARSET
+
+LIBSAMBA-HOSTCONFIG_VERSION = 0.0.1
+LIBSAMBA-HOSTCONFIG_SOVERSION = 0
+
+LIBSAMBA-HOSTCONFIG_OBJ_FILES = $(addprefix $(paramsrcdir)/,  \
+			loadparm.o generic.o util.o) 
+
+PUBLIC_HEADERS += param/param.h
+
+PC_FILES += $(paramsrcdir)/samba-hostconfig.pc
+
+[SUBSYSTEM::PROVISION]
+PRIVATE_DEPENDENCIES = LIBPYTHON pyldb
+
+PROVISION_OBJ_FILES = $(paramsrcdir)/provision.o $(param_OBJ_FILES)
+
+#################################
+# Start SUBSYSTEM share
+[SUBSYSTEM::share]
+PRIVATE_DEPENDENCIES = LIBSAMBA-UTIL
+# End SUBSYSTEM share
+#################################
+
+share_OBJ_FILES = $(paramsrcdir)/share.o
+
+$(eval $(call proto_header_template,$(paramsrcdir)/share_proto.h,$(share_OBJ_FILES:.o=.c)))
+
+PUBLIC_HEADERS += param/share.h
+
+################################################
+# Start MODULE share_classic
+[MODULE::share_classic]
+SUBSYSTEM = share
+INIT_FUNCTION = share_classic_init
+PRIVATE_DEPENDENCIES = LIBSAMBA-UTIL
+# End MODULE share_classic
+################################################
+
+share_classic_OBJ_FILES = $(paramsrcdir)/share_classic.o 
+
+################################################
+# Start MODULE share_ldb
+[MODULE::share_ldb]
+SUBSYSTEM = share
+INIT_FUNCTION = share_ldb_init
+PRIVATE_DEPENDENCIES = LIBLDB LDB_WRAP
+# End MODULE share_ldb
+################################################
+
+share_ldb_OBJ_FILES = $(paramsrcdir)/share_ldb.o 
+
+[SUBSYSTEM::SECRETS]
+PRIVATE_DEPENDENCIES = LIBLDB TDB_WRAP UTIL_TDB NDR_SECURITY
+
+SECRETS_OBJ_FILES = $(paramsrcdir)/secrets.o
+
+[PYTHON::param]
+LIBRARY_REALNAME = samba/param.$(SHLIBEXT)
+PRIVATE_DEPENDENCIES = LIBSAMBA-HOSTCONFIG PYTALLOC
+
+param_OBJ_FILES = $(paramsrcdir)/pyparam.o
diff --git a/source4/param/generic.c b/source4/param/generic.c
new file mode 100644
index 0000000000..ba5464a0f0
--- /dev/null
+++ b/source4/param/generic.c
@@ -0,0 +1,294 @@
+/* 
+ *  Unix SMB/CIFS implementation.
+ *  Copyright (C) Jelmer Vernooij			2005
+ *  
+ *  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 3 of the License, or
+ *  (at your option) any later version.
+ *  
+ *  This program 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 General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "includes.h"
+#include "../lib/util/dlinklist.h"
+#include "param/param.h"
+#include "param/loadparm.h"
+#include "system/filesys.h"
+
+struct param_section *param_get_section(struct param_context *ctx, const char *name)
+{
+	struct param_section *sect;
+
+	if (name == NULL) 
+		name = GLOBAL_NAME;
+
+	for (sect = ctx->sections; sect; sect = sect->next) {
+		if (!strcasecmp_m(sect->name, name)) 
+			return sect;
+	}
+
+	return NULL;
+}
+
+struct param_opt *param_section_get(struct param_section *section, 
+				    const char *name)
+{
+	struct param_opt *p;
+
+	for (p = section->parameters; p; p = p->next) {
+		if (strcasecmp_m(p->key, name) == 0) 
+			return p;
+	}
+
+	return NULL;
+}
+
+struct param_opt *param_get (struct param_context *ctx, const char *name, const char *section_name)
+{
+	struct param_section *section = param_get_section(ctx, section_name);
+	if (section == NULL)
+		return NULL;
+
+	return param_section_get(section, name);
+}
+
+struct param_section *param_add_section(struct param_context *ctx, const char *section_name)
+{
+	struct param_section *section;
+	section = talloc_zero(ctx, struct param_section);
+	if (section == NULL)
+		return NULL;
+
+	section->name = talloc_strdup(section, section_name);
+	DLIST_ADD_END(ctx->sections, section, struct param_section *);
+	return section;
+}
+
+/* Look up parameter. If it is not found, add it */
+struct param_opt *param_get_add(struct param_context *ctx, const char *name, const char *section_name)
+{
+	struct param_section *section;
+	struct param_opt *p;
+
+	SMB_ASSERT(section_name != NULL);
+	SMB_ASSERT(name != NULL);
+
+	section = param_get_section(ctx, section_name);
+
+	if (section == NULL) {
+		section = param_add_section(ctx, section_name);
+	}
+
+	p = param_section_get(section, name);
+	if (p == NULL) {
+		p = talloc_zero(section, struct param_opt);
+		if (p == NULL)
+			return NULL;
+
+		p->key = talloc_strdup(p, name);
+		DLIST_ADD_END(section->parameters, p, struct param_opt *);
+	}
+	
+	return p;
+}
+
+const char *param_get_string(struct param_context *ctx, const char *param, const char *section)
+{
+	struct param_opt *p = param_get(ctx, param, section);
+
+	if (p == NULL)
+		return NULL;
+
+	return p->value;
+}
+
+int param_set_string(struct param_context *ctx, const char *param, const char *value, const char *section)
+{
+	struct param_opt *p = param_get_add(ctx, param, section);
+
+	if (p == NULL)
+		return -1;
+
+	p->value = talloc_strdup(p, value);
+
+	return 0;
+}
+
+const char **param_get_string_list(struct param_context *ctx, const char *param, const char *separator, const char *section)
+{
+	struct param_opt *p = param_get(ctx, param, section);
+	
+	if (p == NULL)
+		return NULL;
+
+	return (const char **)str_list_make(ctx, p->value, separator);
+}
+
+int param_set_string_list(struct param_context *ctx, const char *param, const char **list, const char *section)
+{
+	struct param_opt *p = param_get_add(ctx, param, section);	
+
+	p->value = str_list_join(p, list, ' ');
+
+	return 0;
+}
+
+int param_get_int(struct param_context *ctx, const char *param, int default_v, const char *section)
+{
+	const char *value = param_get_string(ctx, param, section);
+	
+	if (value)
+		return strtol(value, NULL, 0); 
+
+	return default_v;
+}
+
+void param_set_int(struct param_context *ctx, const char *param, int value, const char *section)
+{
+	struct param_opt *p = param_get_add(ctx, section, param);
+
+	if (!p) 
+		return;
+
+	p->value = talloc_asprintf(p, "%d", value);
+}
+
+unsigned long param_get_ulong(struct param_context *ctx, const char *param, unsigned long default_v, const char *section)
+{
+	const char *value = param_get_string(ctx, param, section);
+	
+	if (value)
+		return strtoul(value, NULL, 0);
+
+	return default_v;
+}
+
+void param_set_ulong(struct param_context *ctx, const char *name, unsigned long value, const char *section)
+{
+	struct param_opt *p = param_get_add(ctx, name, section);
+
+	if (!p)
+		return;
+
+	p->value = talloc_asprintf(p, "%lu", value);
+}
+
+static bool param_sfunc (const char *name, void *_ctx)
+{
+	struct param_context *ctx = (struct param_context *)_ctx;
+	struct param_section *section = param_get_section(ctx, name);
+
+	if (section == NULL) {
+		section = talloc_zero(ctx, struct param_section);
+		if (section == NULL)
+			return false;
+
+		section->name = talloc_strdup(section, name);
+
+		DLIST_ADD_END(ctx->sections, section, struct param_section *);
+	}
+
+	/* Make sure this section is on top of the list for param_pfunc */
+	DLIST_PROMOTE(ctx->sections, section);
+
+	return true;
+}
+
+static bool param_pfunc (const char *name, const char *value, void *_ctx)
+{
+	struct param_context *ctx = (struct param_context *)_ctx;
+	struct param_opt *p = param_section_get(ctx->sections, name);
+
+	if (!p) {
+		p = talloc_zero(ctx->sections, struct param_opt);
+		if (p == NULL)
+			return false;
+
+		p->key = talloc_strdup(p, name);
+		p->value = talloc_strdup(p, value);
+		DLIST_ADD(ctx->sections->parameters, p);
+	} else { /* Replace current value */
+		talloc_free(p->value);
+		p->value = talloc_strdup(p, value);
+	}
+
+	return true;
+}
+
+struct param_context *param_init(TALLOC_CTX *mem_ctx)
+{
+	return talloc_zero(mem_ctx, struct param_context);
+}
+
+
+int param_read(struct param_context *ctx, const char *fn)
+{
+	ctx->sections = talloc_zero(ctx, struct param_section);
+	if (ctx->sections == NULL)
+		return -1;
+
+	ctx->sections->name = talloc_strdup(ctx->sections, "global");
+	if (!pm_process( fn, param_sfunc, param_pfunc, ctx)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+int param_use(struct loadparm_context *lp_ctx, struct param_context *ctx)
+{
+	struct param_section *section;
+
+	for (section = ctx->sections; section; section = section->next) {
+		struct param_opt *param;
+		bool isglobal = strcmp(section->name, "global") == 0;
+		for (param = section->parameters; param; param = param->next) {
+			if (isglobal)
+				lp_do_global_parameter(lp_ctx, param->key,
+						       param->value);
+			else {
+				struct loadparm_service *service = 
+							lp_service(lp_ctx, section->name);
+				if (service == NULL)
+					service = lp_add_service(lp_ctx, lp_default_service(lp_ctx), section->name);
+				lp_do_service_parameter(lp_ctx, service, param->key, param->value);
+			}
+		}
+	}
+	return 0;
+}
+
+int param_write(struct param_context *ctx, const char *fn)
+{
+	int file;
+	struct param_section *section;
+
+	if (fn == NULL || ctx == NULL)
+		return -1;
+
+	file = open(fn, O_WRONLY|O_CREAT, 0755);
+
+	if (file == -1)
+		return -1;
+	
+	for (section = ctx->sections; section; section = section->next) {
+		struct param_opt *param;
+		
+		fdprintf(file, "[%s]\n", section->name);
+		for (param = section->parameters; param; param = param->next) {
+			fdprintf(file, "\t%s = %s\n", param->key, param->value);
+		}
+		fdprintf(file, "\n");
+	}
+
+	close(file);
+
+	return 0;
+}
diff --git a/source4/param/loadparm.c b/source4/param/loadparm.c
new file mode 100644
index 0000000000..6789aa1ac2
--- /dev/null
+++ b/source4/param/loadparm.c
@@ -0,0 +1,2724 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Parameter loading functions
+   Copyright (C) Karl Auer 1993-1998
+
+   Largely re-written by Andrew Tridgell, September 1994
+
+   Copyright (C) Simo Sorce 2001
+   Copyright (C) Alexander Bokovoy 2002
+   Copyright (C) Stefan (metze) Metzmacher 2002
+   Copyright (C) Jim McDonough (jmcd@us.ibm.com)  2003.
+   Copyright (C) James Myers 2003 <myersjj@samba.org>
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
+
+   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 3 of the License, or
+   (at your option) any later version.
+
+   This program 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 General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ *  Load parameters.
+ *
+ *  This module provides suitable callback functions for the params
+ *  module. It builds the internal table of service details which is
+ *  then used by the rest of the server.
+ *
+ * To add a parameter:
+ *
+ * 1) add it to the global or service structure definition
+ * 2) add it to the parm_table
+ * 3) add it to the list of available functions (eg: using FN_GLOBAL_STRING())
+ * 4) If it's a global then initialise it in init_globals. If a local
+ *    (ie. service) parameter then initialise it in the sDefault structure
+ *
+ *
+ * Notes:
+ *   The configuration file is processed sequentially for speed. It is NOT
+ *   accessed randomly as happens in 'real' Windows. For this reason, there
+ *   is a fair bit of sequence-dependent code here - ie., code which assumes
+ *   that certain things happen before others. In particular, the code which
+ *   happens at the boundary between sections is delicately poised, so be
+ *   careful!
+ *
+ */
+
+#include "includes.h"
+#include "version.h"
+#include "dynconfig/dynconfig.h"
+#include "system/time.h"
+#include "system/locale.h"
+#include "system/network.h" /* needed for TCP_NODELAY */
+#include "smb_server/smb_server.h"
+#include "libcli/raw/signing.h"
+#include "../lib/util/dlinklist.h"
+#include "param/param.h"
+#include "param/loadparm.h"
+#include "libcli/raw/libcliraw.h"
+#include "rpc_server/common/common.h"
+#include "lib/socket/socket.h"
+#include "auth/gensec/gensec.h"
+
+#define standard_sub_basic talloc_strdup
+
+static bool do_parameter(const char *, const char *, void *);
+static bool defaults_saved = false;
+
+/**
+ * This structure describes global (ie., server-wide) parameters.
+ */
+struct loadparm_global
+{
+	enum server_role server_role;
+
+	const char **smb_ports;
+	char *ncalrpc_dir;
+	char *dos_charset;
+	char *unix_charset;
+	char *display_charset;
+	char *szLockDir;
+	char *szModulesDir;
+	char *szPidDir;
+	char *szSetupDir;
+	char *szServerString;
+	char *szAutoServices;
+	char *szPasswdChat;
+	char *szShareBackend;
+	char *szSAM_URL;
+	char *szIDMAP_URL;
+	char *szSECRETS_URL;
+	char *szSPOOLSS_URL;
+	char *szWINS_CONFIG_URL;
+	char *szWINS_URL;
+	char *szPrivateDir;
+	const char **szPasswordServers;
+	char *szSocketOptions;
+	char *szRealm;
+	const char **szWINSservers;
+	const char **szInterfaces;
+	char *szSocketAddress;
+	char *szAnnounceVersion;	/* This is initialised in init_globals */
+	char *szWorkgroup;
+	char *szNetbiosName;
+	const char **szNetbiosAliases;
+	char *szNetbiosScope;
+	char *szDomainOtherSIDs;
+	const char **szNameResolveOrder;
+	const char **dcerpc_ep_servers;
+	const char **server_services;
+	char *ntptr_providor;
+	char *szWinbindSeparator;
+	char *szWinbinddPrivilegedSocketDirectory;
+	char *szWinbinddSocketDirectory;
+	char *szTemplateShell;
+	char *szTemplateHomedir;
+	int bWinbindSealedPipes;
+	int bIdmapTrustedOnly;
+	char *swat_directory;
+	int tls_enabled;
+	char *tls_keyfile;
+	char *tls_certfile;
+	char *tls_cafile;
+	char *tls_crlfile;
+	char *tls_dhpfile;
+	char *logfile;
+	char *panic_action;
+	int max_mux;
+	int debuglevel;
+	int max_xmit;
+	int pwordlevel;
+	int srv_maxprotocol;
+	int srv_minprotocol;
+	int cli_maxprotocol;
+	int cli_minprotocol;
+	int security;
+	int paranoid_server_security;
+	int max_wins_ttl;
+	int min_wins_ttl;
+	int announce_as;	/* This is initialised in init_globals */
+	int nbt_port;
+	int dgram_port;
+	int cldap_port;
+	int krb5_port;
+	int kpasswd_port;
+	int web_port;
+	char *socket_options;
+	int bWINSsupport;
+	int bWINSdnsProxy;
+	char *szWINSHook;
+	int bLocalMaster;
+	int bPreferredMaster;
+	int bEncryptPasswords;
+	int bNullPasswords;
+	int bObeyPamRestrictions;
+	int bLargeReadwrite;
+	int bReadRaw;
+	int bWriteRaw;
+	int bTimeServer;
+	int bBindInterfacesOnly;
+	int bNTSmbSupport;
+	int bNTStatusSupport;
+	int bLanmanAuth;
+	int bNTLMAuth;
+	int bUseSpnego;
+	int server_signing;
+	int client_signing;
+	int bClientPlaintextAuth;
+	int bClientLanManAuth;
+	int bClientNTLMv2Auth;
+	int client_use_spnego_principal;
+	int bHostMSDfs;
+	int bUnicode;
+	int bUnixExtensions;
+	int bDisableNetbios;
+	int bRpcBigEndian;
+	char *szNTPSignDSocketDirectory;
+	struct param_opt *param_opt;
+};
+
+
+/**
+ * This structure describes a single service.
+ */
+struct loadparm_service
+{
+	char *szService;
+	char *szPath;
+	char *szCopy;
+	char *szInclude;
+	char *szPrintername;
+	char **szHostsallow;
+	char **szHostsdeny;
+	char *comment;
+	char *volume;
+	char *fstype;
+	char **ntvfs_handler;
+	int iMaxPrintJobs;
+	int iMaxConnections;
+	int iCSCPolicy;
+	int bAvailable;
+	int bBrowseable;
+	int bRead_only;
+	int bPrint_ok;
+	int bMap_system;
+	int bMap_hidden;
+	int bMap_archive;
+	int bStrictLocking;
+	int bOplocks;
+	int iCreate_mask;
+	int iCreate_force_mode;
+	int iDir_mask;
+	int iDir_force_mode;
+	int *copymap;
+	int bMSDfsRoot;
+	int bStrictSync;
+	int bCIFileSystem;
+	struct param_opt *param_opt;
+
+	char dummy[3];		/* for alignment */
+};
+
+
+#define NUMPARAMETERS (sizeof(parm_table) / sizeof(struct parm_struct))
+
+
+/* prototypes for the special type handlers */
+static bool handle_include(struct loadparm_context *lp_ctx,
+			   const char *pszParmValue, char **ptr);
+static bool handle_copy(struct loadparm_context *lp_ctx,
+			const char *pszParmValue, char **ptr);
+static bool handle_debuglevel(struct loadparm_context *lp_ctx,
+			      const char *pszParmValue, char **ptr);
+static bool handle_logfile(struct loadparm_context *lp_ctx,
+			   const char *pszParmValue, char **ptr);
+
+static const struct enum_list enum_protocol[] = {
+	{PROTOCOL_SMB2, "SMB2"},
+	{PROTOCOL_NT1, "NT1"},
+	{PROTOCOL_LANMAN2, "LANMAN2"},
+	{PROTOCOL_LANMAN1, "LANMAN1"},
+	{PROTOCOL_CORE, "CORE"},
+	{PROTOCOL_COREPLUS, "COREPLUS"},
+	{PROTOCOL_COREPLUS, "CORE+"},
+	{-1, NULL}
+};
+
+static const struct enum_list enum_security[] = {
+	{SEC_SHARE, "SHARE"},
+	{SEC_USER, "USER"},
+	{-1, NULL}
+};
+
+static const struct enum_list enum_announce_as[] = {
+	{ANNOUNCE_AS_NT_SERVER, "NT"},
+	{ANNOUNCE_AS_NT_SERVER, "NT Server"},
+	{ANNOUNCE_AS_NT_WORKSTATION, "NT Workstation"},
+	{ANNOUNCE_AS_WIN95, "win95"},
+	{ANNOUNCE_AS_WFW, "WfW"},
+	{-1, NULL}
+};
+
+static const struct enum_list enum_bool_auto[] = {
+	{false, "No"},
+	{false, "False"},
+	{false, "0"},
+	{true, "Yes"},
+	{true, "True"},
+	{true, "1"},
+	{Auto, "Auto"},
+	{-1, NULL}
+};
+
+/* Client-side offline caching policy types */
+enum csc_policy {
+	CSC_POLICY_MANUAL=0,
+	CSC_POLICY_DOCUMENTS=1,
+	CSC_POLICY_PROGRAMS=2,
+	CSC_POLICY_DISABLE=3
+};
+
+static const struct enum_list enum_csc_policy[] = {
+	{CSC_POLICY_MANUAL, "manual"},
+	{CSC_POLICY_DOCUMENTS, "documents"},
+	{CSC_POLICY_PROGRAMS, "programs"},
+	{CSC_POLICY_DISABLE, "disable"},
+	{-1, NULL}
+};
+
+/* SMB signing types. */
+static const struct enum_list enum_smb_signing_vals[] = {
+	{SMB_SIGNING_OFF, "No"},
+	{SMB_SIGNING_OFF, "False"},
+	{SMB_SIGNING_OFF, "0"},
+	{SMB_SIGNING_OFF, "Off"},
+	{SMB_SIGNING_OFF, "disabled"},
+	{SMB_SIGNING_SUPPORTED, "Yes"},
+	{SMB_SIGNING_SUPPORTED, "True"},
+	{SMB_SIGNING_SUPPORTED, "1"},
+	{SMB_SIGNING_SUPPORTED, "On"},
+	{SMB_SIGNING_SUPPORTED, "enabled"},
+	{SMB_SIGNING_REQUIRED, "required"},
+	{SMB_SIGNING_REQUIRED, "mandatory"},
+	{SMB_SIGNING_REQUIRED, "force"},
+	{SMB_SIGNING_REQUIRED, "forced"},
+	{SMB_SIGNING_REQUIRED, "enforced"},
+	{SMB_SIGNING_AUTO, "auto"},
+	{-1, NULL}
+};
+
+static const struct enum_list enum_server_role[] = {
+	{ROLE_STANDALONE, "standalone"},
+	{ROLE_DOMAIN_MEMBER, "member server"},
+	{ROLE_DOMAIN_MEMBER, "member"},
+	{ROLE_DOMAIN_CONTROLLER, "domain controller"},
+	{ROLE_DOMAIN_CONTROLLER, "dc"},
+	{-1, NULL}
+};
+
+
+#define GLOBAL_VAR(name) offsetof(struct loadparm_global, name)
+#define LOCAL_VAR(name) offsetof(struct loadparm_service, name)
+
+static struct parm_struct parm_table[] = {
+	{"server role", P_ENUM, P_GLOBAL, GLOBAL_VAR(server_role), NULL, enum_server_role},
+
+	{"dos charset", P_STRING, P_GLOBAL, GLOBAL_VAR(dos_charset), NULL, NULL},
+	{"unix charset", P_STRING, P_GLOBAL, GLOBAL_VAR(unix_charset), NULL, NULL},
+	{"ncalrpc dir", P_STRING, P_GLOBAL, GLOBAL_VAR(ncalrpc_dir), NULL, NULL},
+	{"display charset", P_STRING, P_GLOBAL, GLOBAL_VAR(display_charset), NULL, NULL},
+	{"comment", P_STRING, P_LOCAL, LOCAL_VAR(comment), NULL, NULL},
+	{"path", P_STRING, P_LOCAL, LOCAL_VAR(szPath), NULL, NULL},
+	{"directory", P_STRING, P_LOCAL, LOCAL_VAR(szPath), NULL, NULL},
+	{"workgroup", P_USTRING, P_GLOBAL, GLOBAL_VAR(szWorkgroup), NULL, NULL},
+	{"realm", P_STRING, P_GLOBAL, GLOBAL_VAR(szRealm), NULL, NULL},
+	{"netbios name", P_USTRING, P_GLOBAL, GLOBAL_VAR(szNetbiosName), NULL, NULL},
+	{"netbios aliases", P_LIST, P_GLOBAL, GLOBAL_VAR(szNetbiosAliases), NULL, NULL},
+	{"netbios scope", P_USTRING, P_GLOBAL, GLOBAL_VAR(szNetbiosScope), NULL, NULL},
+	{"server string", P_STRING, P_GLOBAL, GLOBAL_VAR(szServerString), NULL, NULL},
+	{"interfaces", P_LIST, P_GLOBAL, GLOBAL_VAR(szInterfaces), NULL, NULL},
+	{"bind interfaces only", P_BOOL, P_GLOBAL, GLOBAL_VAR(bBindInterfacesOnly), NULL, NULL},
+	{"ntvfs handler", P_LIST, P_LOCAL, LOCAL_VAR(ntvfs_handler), NULL, NULL},
+	{"ntptr providor", P_STRING, P_GLOBAL, GLOBAL_VAR(ntptr_providor), NULL, NULL},
+	{"dcerpc endpoint servers", P_LIST, P_GLOBAL, GLOBAL_VAR(dcerpc_ep_servers), NULL, NULL},
+	{"server services", P_LIST, P_GLOBAL, GLOBAL_VAR(server_services), NULL, NULL},
+
+	{"security", P_ENUM, P_GLOBAL, GLOBAL_VAR(security), NULL, enum_security},
+	{"encrypt passwords", P_BOOL, P_GLOBAL, GLOBAL_VAR(bEncryptPasswords), NULL, NULL},
+	{"null passwords", P_BOOL, P_GLOBAL, GLOBAL_VAR(bNullPasswords), NULL, NULL},
+	{"obey pam restrictions", P_BOOL, P_GLOBAL, GLOBAL_VAR(bObeyPamRestrictions), NULL, NULL},
+	{"password server", P_LIST, P_GLOBAL, GLOBAL_VAR(szPasswordServers), NULL, NULL},
+	{"sam database", P_STRING, P_GLOBAL, GLOBAL_VAR(szSAM_URL), NULL, NULL},
+	{"idmap database", P_STRING, P_GLOBAL, GLOBAL_VAR(szIDMAP_URL), NULL, NULL},
+	{"secrets database", P_STRING, P_GLOBAL, GLOBAL_VAR(szSECRETS_URL), NULL, NULL},
+	{"spoolss database", P_STRING, P_GLOBAL, GLOBAL_VAR(szSPOOLSS_URL), NULL, NULL},
+	{"wins config database", P_STRING, P_GLOBAL, GLOBAL_VAR(szWINS_CONFIG_URL), NULL, NULL},
+	{"wins database", P_STRING, P_GLOBAL, GLOBAL_VAR(szWINS_URL), NULL, NULL},
+	{"private dir", P_STRING, P_GLOBAL, GLOBAL_VAR(szPrivateDir), NULL, NULL},
+	{"passwd chat", P_STRING, P_GLOBAL, GLOBAL_VAR(szPasswdChat), NULL, NULL},
+	{"password level", P_INTEGER, P_GLOBAL, GLOBAL_VAR(pwordlevel), NULL, NULL},
+	{"lanman auth", P_BOOL, P_GLOBAL, GLOBAL_VAR(bLanmanAuth), NULL, NULL},
+	{"ntlm auth", P_BOOL, P_GLOBAL, GLOBAL_VAR(bNTLMAuth), NULL, NULL},
+	{"client NTLMv2 auth", P_BOOL, P_GLOBAL, GLOBAL_VAR(bClientNTLMv2Auth), NULL, NULL},
+	{"client lanman auth", P_BOOL, P_GLOBAL, GLOBAL_VAR(bClientLanManAuth), NULL, NULL},
+	{"client plaintext auth", P_BOOL, P_GLOBAL, GLOBAL_VAR(bClientPlaintextAuth), NULL, NULL},
+	{"client use spnego principal", P_BOOL, P_GLOBAL, GLOBAL_VAR(client_use_spnego_principal), NULL, NULL},
+
+	{"read only", P_BOOL, P_LOCAL, LOCAL_VAR(bRead_only), NULL, NULL},
+
+	{"create mask", P_OCTAL, P_LOCAL, LOCAL_VAR(iCreate_mask), NULL, NULL},
+	{"force create mode", P_OCTAL, P_LOCAL, LOCAL_VAR(iCreate_force_mode), NULL, NULL}, 
+	{"directory mask", P_OCTAL, P_LOCAL, LOCAL_VAR(iDir_mask), NULL, NULL},
+	{"force directory mode", P_OCTAL, P_LOCAL, LOCAL_VAR(iDir_force_mode), NULL, NULL}, 
+
+	{"hosts allow", P_LIST, P_LOCAL, LOCAL_VAR(szHostsallow), NULL, NULL},
+	{"hosts deny", P_LIST, P_LOCAL, LOCAL_VAR(szHostsdeny), NULL, NULL},
+
+	{"log level", P_INTEGER, P_GLOBAL, GLOBAL_VAR(debuglevel), handle_debuglevel, NULL},
+	{"debuglevel", P_INTEGER, P_GLOBAL, GLOBAL_VAR(debuglevel), handle_debuglevel, NULL},
+	{"log file", P_STRING, P_GLOBAL, GLOBAL_VAR(logfile), handle_logfile, NULL},
+
+	{"smb ports", P_LIST, P_GLOBAL, GLOBAL_VAR(smb_ports), NULL, NULL},
+	{"nbt port", P_INTEGER, P_GLOBAL, GLOBAL_VAR(nbt_port), NULL, NULL},
+	{"dgram port", P_INTEGER, P_GLOBAL, GLOBAL_VAR(dgram_port), NULL, NULL},
+	{"cldap port", P_INTEGER, P_GLOBAL, GLOBAL_VAR(cldap_port), NULL, NULL},
+	{"krb5 port", P_INTEGER, P_GLOBAL, GLOBAL_VAR(krb5_port), NULL, NULL},
+	{"kpasswd port", P_INTEGER, P_GLOBAL, GLOBAL_VAR(kpasswd_port), NULL, NULL},
+	{"web port", P_INTEGER, P_GLOBAL, GLOBAL_VAR(web_port), NULL, NULL},
+	{"tls enabled", P_BOOL, P_GLOBAL, GLOBAL_VAR(tls_enabled), NULL, NULL},
+	{"tls keyfile", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_keyfile), NULL, NULL},
+	{"tls certfile", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_certfile), NULL, NULL},
+	{"tls cafile", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_cafile), NULL, NULL},
+	{"tls crlfile", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_crlfile), NULL, NULL},
+	{"tls dh params file", P_STRING, P_GLOBAL, GLOBAL_VAR(tls_dhpfile), NULL, NULL},
+	{"swat directory", P_STRING, P_GLOBAL, GLOBAL_VAR(swat_directory), NULL, NULL},
+	{"large readwrite", P_BOOL, P_GLOBAL, GLOBAL_VAR(bLargeReadwrite), NULL, NULL},
+	{"server max protocol", P_ENUM, P_GLOBAL, GLOBAL_VAR(srv_maxprotocol), NULL, enum_protocol},
+	{"server min protocol", P_ENUM, P_GLOBAL, GLOBAL_VAR(srv_minprotocol), NULL, enum_protocol},
+	{"client max protocol", P_ENUM, P_GLOBAL, GLOBAL_VAR(cli_maxprotocol), NULL, enum_protocol},
+	{"client min protocol", P_ENUM, P_GLOBAL, GLOBAL_VAR(cli_minprotocol), NULL, enum_protocol},
+	{"unicode", P_BOOL, P_GLOBAL, GLOBAL_VAR(bUnicode), NULL, NULL},
+	{"read raw", P_BOOL, P_GLOBAL, GLOBAL_VAR(bReadRaw), NULL, NULL},
+	{"write raw", P_BOOL, P_GLOBAL, GLOBAL_VAR(bWriteRaw), NULL, NULL},
+	{"disable netbios", P_BOOL, P_GLOBAL, GLOBAL_VAR(bDisableNetbios), NULL, NULL},
+
+	{"nt status support", P_BOOL, P_GLOBAL, GLOBAL_VAR(bNTStatusSupport), NULL, NULL},
+
+	{"announce version", P_STRING, P_GLOBAL, GLOBAL_VAR(szAnnounceVersion), NULL, NULL},
+	{"announce as", P_ENUM, P_GLOBAL, GLOBAL_VAR(announce_as), NULL, enum_announce_as},
+	{"max mux", P_INTEGER, P_GLOBAL, GLOBAL_VAR(max_mux), NULL, NULL},
+	{"max xmit", P_BYTES, P_GLOBAL, GLOBAL_VAR(max_xmit), NULL, NULL},
+
+	{"name resolve order", P_LIST, P_GLOBAL, GLOBAL_VAR(szNameResolveOrder), NULL, NULL},
+	{"max wins ttl", P_INTEGER, P_GLOBAL, GLOBAL_VAR(max_wins_ttl), NULL, NULL},
+	{"min wins ttl", P_INTEGER, P_GLOBAL, GLOBAL_VAR(min_wins_ttl), NULL, NULL},
+	{"time server", P_BOOL, P_GLOBAL, GLOBAL_VAR(bTimeServer), NULL, NULL},
+	{"unix extensions", P_BOOL, P_GLOBAL, GLOBAL_VAR(bUnixExtensions), NULL, NULL},
+	{"use spnego", P_BOOL, P_GLOBAL, GLOBAL_VAR(bUseSpnego), NULL, NULL},
+	{"server signing", P_ENUM, P_GLOBAL, GLOBAL_VAR(server_signing), NULL, enum_smb_signing_vals}, 
+	{"client signing", P_ENUM, P_GLOBAL, GLOBAL_VAR(client_signing), NULL, enum_smb_signing_vals}, 
+	{"rpc big endian", P_BOOL, P_GLOBAL, GLOBAL_VAR(bRpcBigEndian), NULL, NULL},
+
+	{"max connections", P_INTEGER, P_LOCAL, LOCAL_VAR(iMaxConnections), NULL, NULL},
+	{"paranoid server security", P_BOOL, P_GLOBAL, GLOBAL_VAR(paranoid_server_security), NULL, NULL},
+	{"socket options", P_STRING, P_GLOBAL, GLOBAL_VAR(socket_options), NULL, NULL},
+
+	{"strict sync", P_BOOL, P_LOCAL, LOCAL_VAR(bStrictSync), NULL, NULL},
+	{"case insensitive filesystem", P_BOOL, P_LOCAL, LOCAL_VAR(bCIFileSystem), NULL, NULL}, 
+
+	{"max print jobs", P_INTEGER, P_LOCAL, LOCAL_VAR(iMaxPrintJobs), NULL, NULL},
+	{"printable", P_BOOL, P_LOCAL, LOCAL_VAR(bPrint_ok), NULL, NULL},
+	{"print ok", P_BOOL, P_LOCAL, LOCAL_VAR(bPrint_ok), NULL, NULL},
+
+	{"printer name", P_STRING, P_LOCAL, LOCAL_VAR(szPrintername), NULL, NULL},
+	{"printer", P_STRING, P_LOCAL, LOCAL_VAR(szPrintername), NULL, NULL},
+
+	{"map system", P_BOOL, P_LOCAL, LOCAL_VAR(bMap_system), NULL, NULL},
+	{"map hidden", P_BOOL, P_LOCAL, LOCAL_VAR(bMap_hidden), NULL, NULL},
+	{"map archive", P_BOOL, P_LOCAL, LOCAL_VAR(bMap_archive), NULL, NULL},
+
+	{"preferred master", P_ENUM, P_GLOBAL, GLOBAL_VAR(bPreferredMaster), NULL, enum_bool_auto},
+	{"prefered master", P_ENUM, P_GLOBAL, GLOBAL_VAR(bPreferredMaster), NULL, enum_bool_auto},
+	{"local master", P_BOOL, P_GLOBAL, GLOBAL_VAR(bLocalMaster), NULL, NULL},
+	{"browseable", P_BOOL, P_LOCAL, LOCAL_VAR(bBrowseable), NULL, NULL},
+	{"browsable", P_BOOL, P_LOCAL, LOCAL_VAR(bBrowseable), NULL, NULL},
+
+	{"wins server", P_LIST, P_GLOBAL, GLOBAL_VAR(szWINSservers), NULL, NULL},
+	{"wins support", P_BOOL, P_GLOBAL, GLOBAL_VAR(bWINSsupport), NULL, NULL},
+	{"dns proxy", P_BOOL, P_GLOBAL, GLOBAL_VAR(bWINSdnsProxy), NULL, NULL},
+	{"wins hook", P_STRING, P_GLOBAL, GLOBAL_VAR(szWINSHook), NULL, NULL}, 
+
+	{"csc policy", P_ENUM, P_LOCAL, LOCAL_VAR(iCSCPolicy), NULL, enum_csc_policy},
+
+	{"strict locking", P_BOOL, P_LOCAL, LOCAL_VAR(bStrictLocking), NULL, NULL},
+	{"oplocks", P_BOOL, P_LOCAL, LOCAL_VAR(bOplocks), NULL, NULL},
+
+	{"share backend", P_STRING, P_GLOBAL, GLOBAL_VAR(szShareBackend), NULL, NULL},
+	{"preload", P_STRING, P_GLOBAL, GLOBAL_VAR(szAutoServices), NULL, NULL},
+	{"auto services", P_STRING, P_GLOBAL, GLOBAL_VAR(szAutoServices), NULL, NULL},
+	{"lock dir", P_STRING, P_GLOBAL, GLOBAL_VAR(szLockDir), NULL, NULL}, 
+	{"lock directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szLockDir), NULL, NULL},
+	{"modules dir", P_STRING, P_GLOBAL, GLOBAL_VAR(szModulesDir), NULL, NULL},
+	{"pid directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szPidDir), NULL, NULL}, 
+	{"setup directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szSetupDir), NULL, NULL},
+
+	{"socket address", P_STRING, P_GLOBAL, GLOBAL_VAR(szSocketAddress), NULL, NULL},
+	{"copy", P_STRING, P_LOCAL, LOCAL_VAR(szCopy), handle_copy, NULL},
+	{"include", P_STRING, P_LOCAL, LOCAL_VAR(szInclude), handle_include, NULL},
+
+	{"available", P_BOOL, P_LOCAL, LOCAL_VAR(bAvailable), NULL, NULL},
+	{"volume", P_STRING, P_LOCAL, LOCAL_VAR(volume), NULL, NULL },
+	{"fstype", P_STRING, P_LOCAL, LOCAL_VAR(fstype), NULL, NULL},
+
+	{"panic action", P_STRING, P_GLOBAL, GLOBAL_VAR(panic_action), NULL, NULL},
+
+	{"msdfs root", P_BOOL, P_LOCAL, LOCAL_VAR(bMSDfsRoot), NULL, NULL},
+	{"host msdfs", P_BOOL, P_GLOBAL, GLOBAL_VAR(bHostMSDfs), NULL, NULL},
+	{"winbind separator", P_STRING, P_GLOBAL, GLOBAL_VAR(szWinbindSeparator), NULL, NULL },
+	{"winbindd socket directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szWinbinddSocketDirectory), NULL, NULL },
+	{"winbindd privileged socket directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szWinbinddPrivilegedSocketDirectory), NULL, NULL },
+	{"winbind sealed pipes", P_BOOL, P_GLOBAL, GLOBAL_VAR(bWinbindSealedPipes), NULL, NULL },
+	{"template shell", P_STRING, P_GLOBAL, GLOBAL_VAR(szTemplateShell), NULL, NULL },
+	{"template homedir", P_STRING, P_GLOBAL, GLOBAL_VAR(szTemplateHomedir), NULL, NULL },
+	{"idmap trusted only", P_BOOL, P_GLOBAL, GLOBAL_VAR(bIdmapTrustedOnly), NULL, NULL},
+
+	{"ntp signd socket directory", P_STRING, P_GLOBAL, GLOBAL_VAR(szNTPSignDSocketDirectory), NULL, NULL },
+
+	{NULL, P_BOOL, P_NONE, 0, NULL, NULL}
+};
+
+
+/* local variables */
+struct loadparm_context {
+	const char *szConfigFile;
+	struct loadparm_global *globals;
+	struct loadparm_service **services;
+	struct loadparm_service *sDefault;
+	int iNumServices;
+	struct loadparm_service *currentService;
+	bool bInGlobalSection;
+	struct file_lists {
+		struct file_lists *next;
+		char *name;
+		char *subfname;
+		time_t modtime;
+	} *file_lists;
+	unsigned int flags[NUMPARAMETERS];
+	struct smb_iconv_convenience *iconv_convenience;
+};
+
+
+struct loadparm_service *lp_default_service(struct loadparm_context *lp_ctx)
+{
+	return lp_ctx->sDefault;
+}
+
+/*
+  return the parameter table
+*/
+struct parm_struct *lp_parm_table(void)
+{
+	return parm_table;
+}
+
+/**
+ * Convenience routine to grab string parameters into temporary memory
+ * and run standard_sub_basic on them.
+ *
+ * The buffers can be written to by
+ * callers without affecting the source string.
+ */
+
+static const char *lp_string(const char *s)
+{
+#if 0  /* until REWRITE done to make thread-safe */
+	size_t len = s ? strlen(s) : 0;
+	char *ret;
+#endif
+
+	/* The follow debug is useful for tracking down memory problems
+	   especially if you have an inner loop that is calling a lp_*()
+	   function that returns a string.  Perhaps this debug should be
+	   present all the time? */
+
+#if 0
+	DEBUG(10, ("lp_string(%s)\n", s));
+#endif
+
+#if 0  /* until REWRITE done to make thread-safe */
+	if (!lp_talloc)
+		lp_talloc = talloc_init("lp_talloc");
+
+	ret = talloc_array(lp_talloc, char, len + 100);	/* leave room for substitution */
+
+	if (!ret)
+		return NULL;
+
+	if (!s)
+		*ret = 0;
+	else
+		strlcpy(ret, s, len);
+
+	if (trim_string(ret, "\"", "\"")) {
+		if (strchr(ret,'"') != NULL)
+			strlcpy(ret, s, len);
+	}
+
+	standard_sub_basic(ret,len+100);
+	return (ret);
+#endif
+	return s;
+}
+
+/*
+   In this section all the functions that are used to access the
+   parameters from the rest of the program are defined
+*/
+
+#define FN_GLOBAL_STRING(fn_name,var_name) \
+ const char *fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_string(lp_ctx->globals->var_name) : "";}
+#define FN_GLOBAL_CONST_STRING(fn_name,var_name) \
+ const char *fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name ? lp_ctx->globals->var_name : "";}
+#define FN_GLOBAL_LIST(fn_name,var_name) \
+ const char **fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return NULL; return lp_ctx->globals->var_name;}
+#define FN_GLOBAL_BOOL(fn_name,var_name) \
+ bool fn_name(struct loadparm_context *lp_ctx) {if (lp_ctx == NULL) return false; return lp_ctx->globals->var_name;}
+#if 0 /* unused */
+#define FN_GLOBAL_CHAR(fn_name,ptr) \
+ char fn_name(void) {return(*(char *)(ptr));}
+#endif
+#define FN_GLOBAL_INTEGER(fn_name,var_name) \
+ int fn_name(struct loadparm_context *lp_ctx) {return lp_ctx->globals->var_name;}
+
+#define FN_LOCAL_STRING(fn_name,val) \
+ const char *fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return(lp_string((const char *)((service != NULL && service->val != NULL) ? service->val : sDefault->val)));}
+#define FN_LOCAL_LIST(fn_name,val) \
+ const char **fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return(const char **)(service != NULL && service->val != NULL? service->val : sDefault->val);}
+#define FN_LOCAL_BOOL(fn_name,val) \
+ bool fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
+#define FN_LOCAL_INTEGER(fn_name,val) \
+ int fn_name(struct loadparm_service *service, struct loadparm_service *sDefault) {return((service != NULL)? service->val : sDefault->val);}
+
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_role, server_role)
+_PUBLIC_ FN_GLOBAL_LIST(lp_smb_ports, smb_ports)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_nbt_port, nbt_port)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_dgram_port, dgram_port)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_cldap_port, cldap_port)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_krb5_port, krb5_port)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_kpasswd_port, kpasswd_port)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_web_port, web_port)
+_PUBLIC_ FN_GLOBAL_STRING(lp_swat_directory, swat_directory)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_tls_enabled, tls_enabled)
+_PUBLIC_ FN_GLOBAL_STRING(lp_share_backend, szShareBackend)
+_PUBLIC_ FN_GLOBAL_STRING(lp_sam_url, szSAM_URL)
+_PUBLIC_ FN_GLOBAL_STRING(lp_idmap_url, szIDMAP_URL)
+_PUBLIC_ FN_GLOBAL_STRING(lp_secrets_url, szSECRETS_URL)
+_PUBLIC_ FN_GLOBAL_STRING(lp_spoolss_url, szSPOOLSS_URL)
+_PUBLIC_ FN_GLOBAL_STRING(lp_wins_config_url, szWINS_CONFIG_URL)
+_PUBLIC_ FN_GLOBAL_STRING(lp_wins_url, szWINS_URL)
+_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbind_separator, szWinbindSeparator)
+_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_socket_directory, szWinbinddSocketDirectory)
+_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_winbindd_privileged_socket_directory, szWinbinddPrivilegedSocketDirectory)
+_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_shell, szTemplateShell)
+_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_template_homedir, szTemplateHomedir)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_winbind_sealed_pipes, bWinbindSealedPipes)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_idmap_trusted_only, bIdmapTrustedOnly)
+_PUBLIC_ FN_GLOBAL_STRING(lp_private_dir, szPrivateDir)
+_PUBLIC_ FN_GLOBAL_STRING(lp_serverstring, szServerString)
+_PUBLIC_ FN_GLOBAL_STRING(lp_lockdir, szLockDir)
+_PUBLIC_ FN_GLOBAL_STRING(lp_modulesdir, szModulesDir)
+_PUBLIC_ FN_GLOBAL_STRING(lp_setupdir, szSetupDir)
+_PUBLIC_ FN_GLOBAL_STRING(lp_ncalrpc_dir, ncalrpc_dir)
+_PUBLIC_ FN_GLOBAL_STRING(lp_dos_charset, dos_charset)
+_PUBLIC_ FN_GLOBAL_STRING(lp_unix_charset, unix_charset)
+_PUBLIC_ FN_GLOBAL_STRING(lp_display_charset, display_charset)
+_PUBLIC_ FN_GLOBAL_STRING(lp_piddir, szPidDir)
+_PUBLIC_ FN_GLOBAL_LIST(lp_dcerpc_endpoint_servers, dcerpc_ep_servers)
+_PUBLIC_ FN_GLOBAL_LIST(lp_server_services, server_services)
+_PUBLIC_ FN_GLOBAL_STRING(lp_ntptr_providor, ntptr_providor)
+_PUBLIC_ FN_GLOBAL_STRING(lp_auto_services, szAutoServices)
+_PUBLIC_ FN_GLOBAL_STRING(lp_passwd_chat, szPasswdChat)
+_PUBLIC_ FN_GLOBAL_LIST(lp_passwordserver, szPasswordServers)
+_PUBLIC_ FN_GLOBAL_LIST(lp_name_resolve_order, szNameResolveOrder)
+_PUBLIC_ FN_GLOBAL_STRING(lp_realm, szRealm)
+_PUBLIC_ FN_GLOBAL_STRING(lp_socket_options, socket_options)
+_PUBLIC_ FN_GLOBAL_STRING(lp_workgroup, szWorkgroup)
+_PUBLIC_ FN_GLOBAL_STRING(lp_netbios_name, szNetbiosName)
+_PUBLIC_ FN_GLOBAL_STRING(lp_netbios_scope, szNetbiosScope)
+_PUBLIC_ FN_GLOBAL_LIST(lp_wins_server_list, szWINSservers)
+_PUBLIC_ FN_GLOBAL_LIST(lp_interfaces, szInterfaces)
+_PUBLIC_ FN_GLOBAL_STRING(lp_socket_address, szSocketAddress)
+_PUBLIC_ FN_GLOBAL_LIST(lp_netbios_aliases, szNetbiosAliases)
+
+_PUBLIC_ FN_GLOBAL_BOOL(lp_disable_netbios, bDisableNetbios)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_wins_support, bWINSsupport)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_wins_dns_proxy, bWINSdnsProxy)
+_PUBLIC_ FN_GLOBAL_STRING(lp_wins_hook, szWINSHook)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_local_master, bLocalMaster)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_readraw, bReadRaw)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_large_readwrite, bLargeReadwrite)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_writeraw, bWriteRaw)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_null_passwords, bNullPasswords)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_obey_pam_restrictions, bObeyPamRestrictions)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_encrypted_passwords, bEncryptPasswords)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_time_server, bTimeServer)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_bind_interfaces_only, bBindInterfacesOnly)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_unicode, bUnicode)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_nt_status_support, bNTStatusSupport)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_lanman_auth, bLanmanAuth)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_ntlm_auth, bNTLMAuth)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_client_plaintext_auth, bClientPlaintextAuth)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_client_lanman_auth, bClientLanManAuth)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_client_ntlmv2_auth, bClientNTLMv2Auth)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_client_use_spnego_principal, client_use_spnego_principal)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_host_msdfs, bHostMSDfs)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_unix_extensions, bUnixExtensions)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_use_spnego, bUseSpnego)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_rpc_big_endian, bRpcBigEndian)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_max_wins_ttl, max_wins_ttl)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_min_wins_ttl, min_wins_ttl)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_maxmux, max_mux)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_max_xmit, max_xmit)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_passwordlevel, pwordlevel)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_maxprotocol, srv_maxprotocol)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_srv_minprotocol, srv_minprotocol)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_maxprotocol, cli_maxprotocol)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_cli_minprotocol, cli_minprotocol)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_security, security)
+_PUBLIC_ FN_GLOBAL_BOOL(lp_paranoid_server_security, paranoid_server_security)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_announce_as, announce_as)
+const char *lp_servicename(const struct loadparm_service *service)
+{
+	return lp_string((const char *)service->szService);
+}
+
+_PUBLIC_ FN_LOCAL_STRING(lp_pathname, szPath)
+static FN_LOCAL_STRING(_lp_printername, szPrintername)
+_PUBLIC_ FN_LOCAL_LIST(lp_hostsallow, szHostsallow)
+_PUBLIC_ FN_LOCAL_LIST(lp_hostsdeny, szHostsdeny)
+_PUBLIC_ FN_LOCAL_STRING(lp_comment, comment)
+_PUBLIC_ FN_LOCAL_STRING(lp_fstype, fstype)
+static FN_LOCAL_STRING(lp_volume, volume)
+_PUBLIC_ FN_LOCAL_LIST(lp_ntvfs_handler, ntvfs_handler)
+_PUBLIC_ FN_LOCAL_BOOL(lp_msdfs_root, bMSDfsRoot)
+_PUBLIC_ FN_LOCAL_BOOL(lp_browseable, bBrowseable)
+_PUBLIC_ FN_LOCAL_BOOL(lp_readonly, bRead_only)
+_PUBLIC_ FN_LOCAL_BOOL(lp_print_ok, bPrint_ok)
+_PUBLIC_ FN_LOCAL_BOOL(lp_map_hidden, bMap_hidden)
+_PUBLIC_ FN_LOCAL_BOOL(lp_map_archive, bMap_archive)
+_PUBLIC_ FN_LOCAL_BOOL(lp_strict_locking, bStrictLocking)
+_PUBLIC_ FN_LOCAL_BOOL(lp_oplocks, bOplocks)
+_PUBLIC_ FN_LOCAL_BOOL(lp_strict_sync, bStrictSync)
+_PUBLIC_ FN_LOCAL_BOOL(lp_ci_filesystem, bCIFileSystem)
+_PUBLIC_ FN_LOCAL_BOOL(lp_map_system, bMap_system)
+_PUBLIC_ FN_LOCAL_INTEGER(lp_max_connections, iMaxConnections)
+_PUBLIC_ FN_LOCAL_INTEGER(lp_csc_policy, iCSCPolicy)
+_PUBLIC_ FN_LOCAL_INTEGER(lp_create_mask, iCreate_mask)
+_PUBLIC_ FN_LOCAL_INTEGER(lp_force_create_mode, iCreate_force_mode)
+_PUBLIC_ FN_LOCAL_INTEGER(lp_dir_mask, iDir_mask)
+_PUBLIC_ FN_LOCAL_INTEGER(lp_force_dir_mode, iDir_force_mode)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_signing, server_signing)
+_PUBLIC_ FN_GLOBAL_INTEGER(lp_client_signing, client_signing)
+
+_PUBLIC_ FN_GLOBAL_CONST_STRING(lp_ntp_signd_socket_directory, szNTPSignDSocketDirectory)
+
+/* local prototypes */
+static int map_parameter(const char *pszParmName);
+static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx, 
+					const char *pszServiceName);
+static void copy_service(struct loadparm_service *pserviceDest,
+			 struct loadparm_service *pserviceSource,
+			 int *pcopymapDest);
+static bool service_ok(struct loadparm_service *service);
+static bool do_section(const char *pszSectionName, void *);
+static void init_copymap(struct loadparm_service *pservice);
+
+/* This is a helper function for parametrical options support. */
+/* It returns a pointer to parametrical option value if it exists or NULL otherwise */
+/* Actual parametrical functions are quite simple */
+const char *lp_get_parametric(struct loadparm_context *lp_ctx,
+			      struct loadparm_service *service,
+			      const char *type, const char *option)
+{
+	char *vfskey;
+        struct param_opt *data;
+
+	if (lp_ctx == NULL)
+		return NULL;
+
+	data = (service == NULL ? lp_ctx->globals->param_opt : service->param_opt);
+
+	asprintf(&vfskey, "%s:%s", type, option);
+	strlower(vfskey);
+
+	while (data) {
+		if (strcmp(data->key, vfskey) == 0) {
+			free(vfskey);
+			return data->value;
+		}
+		data = data->next;
+	}
+
+	if (service != NULL) {
+		/* Try to fetch the same option but from globals */
+		/* but only if we are not already working with globals */
+		for (data = lp_ctx->globals->param_opt; data;
+		     data = data->next) {
+			if (strcmp(data->key, vfskey) == 0) {
+				free(vfskey);
+				return data->value;
+			}
+		}
+	}
+
+	free(vfskey);
+
+	return NULL;
+}
+
+
+/**
+ * convenience routine to return int parameters.
+ */
+static int lp_int(const char *s)
+{
+
+	if (!s) {
+		DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
+		return -1;
+	}
+
+	return strtol(s, NULL, 0);
+}
+
+/**
+ * convenience routine to return unsigned long parameters.
+ */
+static int lp_ulong(const char *s)
+{
+
+	if (!s) {
+		DEBUG(0,("lp_int(%s): is called with NULL!\n",s));
+		return -1;
+	}
+
+	return strtoul(s, NULL, 0);
+}
+
+/**
+ * convenience routine to return unsigned long parameters.
+ */
+static double lp_double(const char *s)
+{
+
+	if (!s) {
+		DEBUG(0,("lp_double(%s): is called with NULL!\n",s));
+		return -1;
+	}
+
+	return strtod(s, NULL);
+}
+
+/**
+ * convenience routine to return boolean parameters.
+ */
+static bool lp_bool(const char *s)
+{
+	bool ret = false;
+
+	if (!s) {
+		DEBUG(0,("lp_bool(%s): is called with NULL!\n",s));
+		return false;
+	}
+
+	if (!set_boolean(s, &ret)) {
+		DEBUG(0,("lp_bool(%s): value is not boolean!\n",s));
+		return false;
+	}
+
+	return ret;
+}
+
+
+/**
+ * Return parametric option from a given service. Type is a part of option before ':'
+ * Parametric option has following syntax: 'Type: option = value'
+ * Returned value is allocated in 'lp_talloc' context
+ */
+
+const char *lp_parm_string(struct loadparm_context *lp_ctx,
+			   struct loadparm_service *service, const char *type,
+			   const char *option)
+{
+	const char *value = lp_get_parametric(lp_ctx, service, type, option);
+
+	if (value)
+		return lp_string(value);
+
+	return NULL;
+}
+
+/**
+ * Return parametric option from a given service. Type is a part of option before ':'
+ * Parametric option has following syntax: 'Type: option = value'
+ * Returned value is allocated in 'lp_talloc' context
+ */
+
+const char **lp_parm_string_list(TALLOC_CTX *mem_ctx,
+				 struct loadparm_context *lp_ctx,
+				 struct loadparm_service *service,
+				 const char *type,
+				 const char *option, const char *separator)
+{
+	const char *value = lp_get_parametric(lp_ctx, service, type, option);
+
+	if (value != NULL)
+		return (const char **)str_list_make(mem_ctx, value, separator);
+
+	return NULL;
+}
+
+/**
+ * Return parametric option from a given service. Type is a part of option before ':'
+ * Parametric option has following syntax: 'Type: option = value'
+ */
+
+int lp_parm_int(struct loadparm_context *lp_ctx,
+		struct loadparm_service *service, const char *type,
+		const char *option, int default_v)
+{
+	const char *value = lp_get_parametric(lp_ctx, service, type, option);
+
+	if (value)
+		return lp_int(value);
+
+	return default_v;
+}
+
+/**
+ * Return parametric option from a given service. Type is a part of
+ * option before ':'.
+ * Parametric option has following syntax: 'Type: option = value'.
+ */
+
+int lp_parm_bytes(struct loadparm_context *lp_ctx,
+		  struct loadparm_service *service, const char *type,
+		  const char *option, int default_v)
+{
+	uint64_t bval;
+
+	const char *value = lp_get_parametric(lp_ctx, service, type, option);
+
+	if (value && conv_str_size(value, &bval)) {
+		if (bval <= INT_MAX) {
+			return (int)bval;
+		}
+	}
+
+	return default_v;
+}
+
+/**
+ * Return parametric option from a given service.
+ * Type is a part of option before ':'
+ * Parametric option has following syntax: 'Type: option = value'
+ */
+unsigned long lp_parm_ulong(struct loadparm_context *lp_ctx,
+			    struct loadparm_service *service, const char *type,
+			    const char *option, unsigned long default_v)
+{
+	const char *value = lp_get_parametric(lp_ctx, service, type, option);
+
+	if (value)
+		return lp_ulong(value);
+
+	return default_v;
+}
+
+
+double lp_parm_double(struct loadparm_context *lp_ctx,
+		      struct loadparm_service *service, const char *type,
+		      const char *option, double default_v)
+{
+	const char *value = lp_get_parametric(lp_ctx, service, type, option);
+
+	if (value != NULL)
+		return lp_double(value);
+
+	return default_v;
+}
+
+/**
+ * Return parametric option from a given service. Type is a part of option before ':'
+ * Parametric option has following syntax: 'Type: option = value'
+ */
+
+bool lp_parm_bool(struct loadparm_context *lp_ctx,
+		  struct loadparm_service *service, const char *type,
+		  const char *option, bool default_v)
+{
+	const char *value = lp_get_parametric(lp_ctx, service, type, option);
+
+	if (value != NULL)
+		return lp_bool(value);
+
+	return default_v;
+}
+
+
+/**
+ * Initialise a service to the defaults.
+ */
+
+static struct loadparm_service *init_service(TALLOC_CTX *mem_ctx, struct loadparm_service *sDefault)
+{
+	struct loadparm_service *pservice =
+		talloc_zero(mem_ctx, struct loadparm_service);
+	copy_service(pservice, sDefault, NULL);
+	return pservice;
+}
+
+/**
+ * Set a string value, deallocating any existing space, and allocing the space
+ * for the string
+ */
+static bool string_set(TALLOC_CTX *mem_ctx, char **dest, const char *src)
+{
+	talloc_free(*dest);
+
+	if (src == NULL)
+		src = "";
+
+	*dest = talloc_strdup(mem_ctx, src);
+	if ((*dest) == NULL) {
+		DEBUG(0,("Out of memory in string_init\n"));
+		return false;
+	}
+
+	return true;
+}
+
+
+
+/**
+ * Add a new service to the services array initialising it with the given
+ * service.
+ */
+
+struct loadparm_service *lp_add_service(struct loadparm_context *lp_ctx,
+				     const struct loadparm_service *pservice,
+				     const char *name)
+{
+	int i;
+	struct loadparm_service tservice;
+	int num_to_alloc = lp_ctx->iNumServices + 1;
+	struct param_opt *data, *pdata;
+
+	tservice = *pservice;
+
+	/* it might already exist */
+	if (name) {
+		struct loadparm_service *service = getservicebyname(lp_ctx,
+								    name);
+		if (service != NULL) {
+			/* Clean all parametric options for service */
+			/* They will be added during parsing again */
+			data = service->param_opt;
+			while (data) {
+				pdata = data->next;
+				talloc_free(data);
+				data = pdata;
+			}
+			service->param_opt = NULL;
+			return service;
+		}
+	}
+
+	/* find an invalid one */
+	for (i = 0; i < lp_ctx->iNumServices; i++)
+		if (lp_ctx->services[i] == NULL)
+			break;
+
+	/* if not, then create one */
+	if (i == lp_ctx->iNumServices) {
+		struct loadparm_service **tsp;
+
+		tsp = talloc_realloc(lp_ctx, lp_ctx->services, struct loadparm_service *, num_to_alloc);
+
+		if (!tsp) {
+			DEBUG(0,("lp_add_service: failed to enlarge services!\n"));
+			return NULL;
+		} else {
+			lp_ctx->services = tsp;
+			lp_ctx->services[lp_ctx->iNumServices] = NULL;
+		}
+
+		lp_ctx->iNumServices++;
+	}
+
+	lp_ctx->services[i] = init_service(lp_ctx->services, lp_ctx->sDefault);
+	if (lp_ctx->services[i] == NULL) {
+		DEBUG(0,("lp_add_service: out of memory!\n"));
+		return NULL;
+	}
+	copy_service(lp_ctx->services[i], &tservice, NULL);
+	if (name != NULL)
+		string_set(lp_ctx->services[i], &lp_ctx->services[i]->szService, name);
+	return lp_ctx->services[i];
+}
+
+/**
+ * Add a new home service, with the specified home directory, defaults coming
+ * from service ifrom.
+ */
+
+bool lp_add_home(struct loadparm_context *lp_ctx,
+		 const char *pszHomename,
+		 struct loadparm_service *default_service,
+		 const char *user, const char *pszHomedir)
+{
+	struct loadparm_service *service;
+
+	service = lp_add_service(lp_ctx, default_service, pszHomename);
+
+	if (service == NULL)
+		return false;
+
+	if (!(*(default_service->szPath))
+	    || strequal(default_service->szPath, lp_ctx->sDefault->szPath)) {
+		service->szPath = talloc_strdup(service, pszHomedir);
+	} else {
+		service->szPath = string_sub_talloc(service, lp_pathname(default_service, lp_ctx->sDefault), "%H", pszHomedir); 
+	}
+
+	if (!(*(service->comment))) {
+		service->comment = talloc_asprintf(service, "Home directory of %s", user);
+	}
+	service->bAvailable = default_service->bAvailable;
+	service->bBrowseable = default_service->bBrowseable;
+
+	DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n",
+		  pszHomename, user, service->szPath));
+
+	return true;
+}
+
+/**
+ * Add the IPC service.
+ */
+
+static bool lp_add_hidden(struct loadparm_context *lp_ctx, const char *name,
+			  const char *fstype)
+{
+	struct loadparm_service *service = lp_add_service(lp_ctx, lp_ctx->sDefault, name);
+
+	if (service == NULL)
+		return false;
+
+	string_set(service, &service->szPath, tmpdir());
+
+	service->comment = talloc_asprintf(service, "%s Service (%s)",
+				fstype, lp_ctx->globals->szServerString);
+	string_set(service, &service->fstype, fstype);
+	service->iMaxConnections = -1;
+	service->bAvailable = true;
+	service->bRead_only = true;
+	service->bPrint_ok = false;
+	service->bBrowseable = false;
+
+	if (strcasecmp(fstype, "IPC") == 0) {
+		lp_do_service_parameter(lp_ctx, service, "ntvfs handler",
+					"default");
+	}
+
+	DEBUG(3, ("adding hidden service %s\n", name));
+
+	return true;
+}
+
+/**
+ * Add a new printer service, with defaults coming from service iFrom.
+ */
+
+bool lp_add_printer(struct loadparm_context *lp_ctx,
+		    const char *pszPrintername,
+		    struct loadparm_service *default_service)
+{
+	const char *comment = "From Printcap";
+	struct loadparm_service *service;
+	service = lp_add_service(lp_ctx, default_service, pszPrintername);
+
+	if (service == NULL)
+		return false;
+
+	/* note that we do NOT default the availability flag to True - */
+	/* we take it from the default service passed. This allows all */
+	/* dynamic printers to be disabled by disabling the [printers] */
+	/* entry (if/when the 'available' keyword is implemented!).    */
+
+	/* the printer name is set to the service name. */
+	string_set(service, &service->szPrintername, pszPrintername);
+	string_set(service, &service->comment, comment);
+	service->bBrowseable = default_service->bBrowseable;
+	/* Printers cannot be read_only. */
+	service->bRead_only = false;
+	/* Printer services must be printable. */
+	service->bPrint_ok = true;
+
+	DEBUG(3, ("adding printer service %s\n", pszPrintername));
+
+	return true;
+}
+
+/**
+ * Map a parameter's string representation to something we can use.
+ * Returns False if the parameter string is not recognised, else TRUE.
+ */
+
+static int map_parameter(const char *pszParmName)
+{
+	int iIndex;
+
+	if (*pszParmName == '-')
+		return -1;
+
+	for (iIndex = 0; parm_table[iIndex].label; iIndex++)
+		if (strwicmp(parm_table[iIndex].label, pszParmName) == 0)
+			return iIndex;
+
+	/* Warn only if it isn't parametric option */
+	if (strchr(pszParmName, ':') == NULL)
+		DEBUG(0, ("Unknown parameter encountered: \"%s\"\n", pszParmName));
+	/* We do return 'fail' for parametric options as well because they are
+	   stored in different storage
+	 */
+	return -1;
+}
+
+
+/**
+  return the parameter structure for a parameter
+*/
+struct parm_struct *lp_parm_struct(const char *name)
+{
+	int parmnum = map_parameter(name);
+	if (parmnum == -1) return NULL;
+	return &parm_table[parmnum];
+}
+
+/**
+  return the parameter pointer for a parameter
+*/
+void *lp_parm_ptr(struct loadparm_context *lp_ctx,
+		  struct loadparm_service *service, struct parm_struct *parm)
+{
+	if (service == NULL) {
+		if (parm->pclass == P_LOCAL)
+			return ((char *)lp_ctx->sDefault)+parm->offset;
+		else if (parm->pclass == P_GLOBAL)
+			return ((char *)lp_ctx->globals)+parm->offset;
+		else return NULL;
+	} else {
+		return ((char *)service) + parm->offset;
+	}
+}
+
+/**
+ * Find a service by name. Otherwise works like get_service.
+ */
+
+static struct loadparm_service *getservicebyname(struct loadparm_context *lp_ctx, 
+					const char *pszServiceName)
+{
+	int iService;
+
+	for (iService = lp_ctx->iNumServices - 1; iService >= 0; iService--)
+		if (lp_ctx->services[iService] != NULL &&
+		    strwicmp(lp_ctx->services[iService]->szService, pszServiceName) == 0) {
+			return lp_ctx->services[iService];
+		}
+
+	return NULL;
+}
+
+/**
+ * Copy a service structure to another.
+ * If pcopymapDest is NULL then copy all fields
+ */
+
+static void copy_service(struct loadparm_service *pserviceDest,
+			 struct loadparm_service *pserviceSource,
+			 int *pcopymapDest)
+{
+	int i;
+	bool bcopyall = (pcopymapDest == NULL);
+	struct param_opt *data, *pdata, *paramo;
+	bool not_added;
+
+	for (i = 0; parm_table[i].label; i++)
+		if (parm_table[i].offset != -1 && parm_table[i].pclass == P_LOCAL &&
+		    (bcopyall || pcopymapDest[i])) {
+			void *src_ptr =
+				((char *)pserviceSource) + parm_table[i].offset;
+			void *dest_ptr =
+				((char *)pserviceDest) + parm_table[i].offset;
+
+			switch (parm_table[i].type) {
+				case P_BOOL:
+					*(int *)dest_ptr = *(int *)src_ptr;
+					break;
+
+				case P_INTEGER:
+				case P_OCTAL:
+				case P_ENUM:
+					*(int *)dest_ptr = *(int *)src_ptr;
+					break;
+
+				case P_STRING:
+					string_set(pserviceDest,
+						   (char **)dest_ptr,
+						   *(char **)src_ptr);
+					break;
+
+				case P_USTRING:
+					string_set(pserviceDest,
+						   (char **)dest_ptr,
+						   *(char **)src_ptr);
+					strupper(*(char **)dest_ptr);
+					break;
+				case P_LIST:
+					*(const char ***)dest_ptr = (const char **)str_list_copy(pserviceDest, 
+										  *(const char ***)src_ptr);
+					break;
+				default:
+					break;
+			}
+		}
+
+	if (bcopyall) {
+		init_copymap(pserviceDest);
+		if (pserviceSource->copymap)
+			memcpy((void *)pserviceDest->copymap,
+			       (void *)pserviceSource->copymap,
+			       sizeof(int) * NUMPARAMETERS);
+	}
+
+	data = pserviceSource->param_opt;
+	while (data) {
+		not_added = true;
+		pdata = pserviceDest->param_opt;
+		/* Traverse destination */
+		while (pdata) {
+			/* If we already have same option, override it */
+			if (strcmp(pdata->key, data->key) == 0) {
+				talloc_free(pdata->value);
+				pdata->value = talloc_reference(pdata,
+							     data->value);
+				not_added = false;
+				break;
+			}
+			pdata = pdata->next;
+		}
+		if (not_added) {
+			paramo = talloc(pserviceDest, struct param_opt);
+			if (paramo == NULL)
+				smb_panic("OOM");
+			paramo->key = talloc_reference(paramo, data->key);
+			paramo->value = talloc_reference(paramo, data->value);
+			DLIST_ADD(pserviceDest->param_opt, paramo);
+		}
+		data = data->next;
+	}
+}
+
+/**
+ * Check a service for consistency. Return False if the service is in any way
+ * incomplete or faulty, else True.
+ */
+static bool service_ok(struct loadparm_service *service)
+{
+	bool bRetval;
+
+	bRetval = true;
+	if (service->szService[0] == '\0') {
+		DEBUG(0, ("The following message indicates an internal error:\n"));
+		DEBUG(0, ("No service name in service entry.\n"));
+		bRetval = false;
+	}
+
+	/* The [printers] entry MUST be printable. I'm all for flexibility, but */
+	/* I can't see why you'd want a non-printable printer service...        */
+	if (strwicmp(service->szService, PRINTERS_NAME) == 0) {
+		if (!service->bPrint_ok) {
+			DEBUG(0, ("WARNING: [%s] service MUST be printable!\n",
+			       service->szService));
+			service->bPrint_ok = true;
+		}
+		/* [printers] service must also be non-browsable. */
+		if (service->bBrowseable)
+			service->bBrowseable = false;
+	}
+
+	/* If a service is flagged unavailable, log the fact at level 0. */
+	if (!service->bAvailable)
+		DEBUG(1, ("NOTE: Service %s is flagged unavailable.\n",
+			  service->szService));
+
+	return bRetval;
+}
+
+
+/*******************************************************************
+ Keep a linked list of all config files so we know when one has changed
+ it's date and needs to be reloaded.
+********************************************************************/
+
+static void add_to_file_list(struct loadparm_context *lp_ctx,
+			     const char *fname, const char *subfname)
+{
+	struct file_lists *f = lp_ctx->file_lists;
+
+	while (f) {
+		if (f->name && !strcmp(f->name, fname))
+			break;
+		f = f->next;
+	}
+
+	if (!f) {
+		f = talloc(lp_ctx, struct file_lists);
+		if (!f)
+			return;
+		f->next = lp_ctx->file_lists;
+		f->name = talloc_strdup(f, fname);
+		if (!f->name) {
+			talloc_free(f);
+			return;
+		}
+		f->subfname = talloc_strdup(f, subfname);
+		if (!f->subfname) {
+			talloc_free(f);
+			return;
+		}
+		lp_ctx->file_lists = f;
+		f->modtime = file_modtime(subfname);
+	} else {
+		time_t t = file_modtime(subfname);
+		if (t)
+			f->modtime = t;
+	}
+}
+
+/*******************************************************************
+ Check if a config file has changed date.
+********************************************************************/
+bool lp_file_list_changed(struct loadparm_context *lp_ctx)
+{
+	struct file_lists *f;
+	DEBUG(6, ("lp_file_list_changed()\n"));
+
+	for (f = lp_ctx->file_lists; f != NULL; f = f->next) {
+		char *n2;
+		time_t mod_time;
+
+		n2 = standard_sub_basic(lp_ctx, f->name);
+
+		DEBUGADD(6, ("file %s -> %s  last mod_time: %s\n",
+			     f->name, n2, ctime(&f->modtime)));
+
+		mod_time = file_modtime(n2);
+
+		if (mod_time && ((f->modtime != mod_time) || (f->subfname == NULL) || (strcmp(n2, f->subfname) != 0))) {
+			DEBUGADD(6, ("file %s modified: %s\n", n2,
+				  ctime(&mod_time)));
+			f->modtime = mod_time;
+			talloc_free(f->subfname);
+			f->subfname = talloc_strdup(f, n2);
+			return true;
+		}
+	}
+	return false;
+}
+
+/***************************************************************************
+ Handle the include operation.
+***************************************************************************/
+
+static bool handle_include(struct loadparm_context *lp_ctx,
+			   const char *pszParmValue, char **ptr)
+{
+	char *fname = standard_sub_basic(lp_ctx, pszParmValue);
+
+	add_to_file_list(lp_ctx, pszParmValue, fname);
+
+	string_set(lp_ctx, ptr, fname);
+
+	if (file_exist(fname))
+		return pm_process(fname, do_section, do_parameter, lp_ctx);
+
+	DEBUG(2, ("Can't find include file %s\n", fname));
+
+	return false;
+}
+
+/***************************************************************************
+ Handle the interpretation of the copy parameter.
+***************************************************************************/
+
+static bool handle_copy(struct loadparm_context *lp_ctx,
+			const char *pszParmValue, char **ptr)
+{
+	bool bRetval;
+	struct loadparm_service *serviceTemp;
+
+	string_set(lp_ctx, ptr, pszParmValue);
+
+	bRetval = false;
+
+	DEBUG(3, ("Copying service from service %s\n", pszParmValue));
+
+	if ((serviceTemp = getservicebyname(lp_ctx, pszParmValue)) != NULL) {
+		if (serviceTemp == lp_ctx->currentService) {
+			DEBUG(0, ("Can't copy service %s - unable to copy self!\n", pszParmValue));
+		} else {
+			copy_service(lp_ctx->currentService,
+				     serviceTemp,
+				     lp_ctx->currentService->copymap);
+			bRetval = true;
+		}
+	} else {
+		DEBUG(0, ("Unable to copy service - source not found: %s\n",
+			  pszParmValue));
+		bRetval = false;
+	}
+
+	return bRetval;
+}
+
+static bool handle_debuglevel(struct loadparm_context *lp_ctx,
+			const char *pszParmValue, char **ptr)
+{
+	DEBUGLEVEL = atoi(pszParmValue);
+
+	return true;
+}
+
+static bool handle_logfile(struct loadparm_context *lp_ctx,
+			const char *pszParmValue, char **ptr)
+{
+	logfile = pszParmValue;
+	return true;
+}
+
+/***************************************************************************
+ Initialise a copymap.
+***************************************************************************/
+
+static void init_copymap(struct loadparm_service *pservice)
+{
+	int i;
+	talloc_free(pservice->copymap);
+	pservice->copymap = talloc_array(pservice, int, NUMPARAMETERS);
+	if (pservice->copymap == NULL) {
+		DEBUG(0,
+		      ("Couldn't allocate copymap!! (size %d)\n",
+		       (int)NUMPARAMETERS));
+		return;
+	}
+	for (i = 0; i < NUMPARAMETERS; i++)
+		pservice->copymap[i] = true;
+}
+
+/**
+ * Process a parametric option
+ */
+static bool lp_do_parameter_parametric(struct loadparm_context *lp_ctx,
+				       struct loadparm_service *service,
+				       const char *pszParmName,
+				       const char *pszParmValue, int flags)
+{
+	struct param_opt *paramo, *data;
+	char *name;
+	TALLOC_CTX *mem_ctx;
+
+	while (isspace((unsigned char)*pszParmName)) {
+		pszParmName++;
+	}
+
+	name = strdup(pszParmName);
+	if (!name) return false;
+
+	strlower(name);
+
+	if (service == NULL) {
+		data = lp_ctx->globals->param_opt;
+		mem_ctx = lp_ctx->globals;
+	} else {
+		data = service->param_opt;
+		mem_ctx = service;
+	}
+
+	/* Traverse destination */
+	for (paramo=data; paramo; paramo=paramo->next) {
+		/* If we already have the option set, override it unless
+		   it was a command line option and the new one isn't */
+		if (strcmp(paramo->key, name) == 0) {
+			if ((paramo->priority & FLAG_CMDLINE) &&
+			    !(flags & FLAG_CMDLINE)) {
+				return true;
+			}
+
+			talloc_free(paramo->value);
+			paramo->value = talloc_strdup(paramo, pszParmValue);
+			paramo->priority = flags;
+			free(name);
+			return true;
+		}
+	}
+
+	paramo = talloc(mem_ctx, struct param_opt);
+	if (!paramo)
+		smb_panic("OOM");
+	paramo->key = talloc_strdup(paramo, name);
+	paramo->value = talloc_strdup(paramo, pszParmValue);
+	paramo->priority = flags;
+	if (service == NULL) {
+		DLIST_ADD(lp_ctx->globals->param_opt, paramo);
+	} else {
+		DLIST_ADD(service->param_opt, paramo);
+	}
+
+	free(name);
+
+	return true;
+}
+
+static bool set_variable(TALLOC_CTX *mem_ctx, int parmnum, void *parm_ptr,
+			 const char *pszParmName, const char *pszParmValue,
+			 struct loadparm_context *lp_ctx)
+{
+	int i;
+	/* if it is a special case then go ahead */
+	if (parm_table[parmnum].special) {
+		parm_table[parmnum].special(lp_ctx, pszParmValue,
+					    (char **)parm_ptr);
+		return true;
+	}
+
+	/* now switch on the type of variable it is */
+	switch (parm_table[parmnum].type)
+	{
+		case P_BOOL: {
+			bool b;
+			if (!set_boolean(pszParmValue, &b)) {
+				DEBUG(0,("lp_do_parameter(%s): value is not boolean!\n", pszParmValue));
+				return false;
+			}
+			*(int *)parm_ptr = b;
+			}
+			break;
+
+		case P_INTEGER:
+			*(int *)parm_ptr = atoi(pszParmValue);
+			break;
+
+		case P_OCTAL:
+			*(int *)parm_ptr = strtol(pszParmValue, NULL, 8);
+			break;
+
+		case P_BYTES:
+		{
+			uint64_t val;
+			if (conv_str_size(pszParmValue, &val)) {
+				if (val <= INT_MAX) {
+					*(int *)parm_ptr = (int)val;
+					break;
+				}
+			}
+
+			DEBUG(0,("lp_do_parameter(%s): value is not "
+			    "a valid size specifier!\n", pszParmValue));
+			return false;
+		}
+
+		case P_LIST:
+			*(const char ***)parm_ptr = (const char **)str_list_make(mem_ctx,
+								  pszParmValue, NULL);
+			break;
+
+		case P_STRING:
+			string_set(mem_ctx, (char **)parm_ptr, pszParmValue);
+			break;
+
+		case P_USTRING:
+			string_set(mem_ctx, (char **)parm_ptr, pszParmValue);
+			strupper(*(char **)parm_ptr);
+			break;
+
+		case P_ENUM:
+			for (i = 0; parm_table[parmnum].enum_list[i].name; i++) {
+				if (strequal
+				    (pszParmValue,
+				     parm_table[parmnum].enum_list[i].name)) {
+					*(int *)parm_ptr =
+						parm_table[parmnum].
+						enum_list[i].value;
+					break;
+				}
+			}
+			if (!parm_table[parmnum].enum_list[i].name) {
+				DEBUG(0,("Unknown enumerated value '%s' for '%s'\n", 
+					 pszParmValue, pszParmName));
+				return false;
+			}
+			break;
+	}
+
+	if (lp_ctx->flags[parmnum] & FLAG_DEFAULT) {
+		lp_ctx->flags[parmnum] &= ~FLAG_DEFAULT;
+		/* we have to also unset FLAG_DEFAULT on aliases */
+		for (i=parmnum-1;i>=0 && parm_table[i].offset == parm_table[parmnum].offset;i--) {
+			lp_ctx->flags[i] &= ~FLAG_DEFAULT;
+		}
+		for (i=parmnum+1;i<NUMPARAMETERS && parm_table[i].offset == parm_table[parmnum].offset;i++) {
+			lp_ctx->flags[i] &= ~FLAG_DEFAULT;
+		}
+	}
+	return true;
+}
+
+
+bool lp_do_global_parameter(struct loadparm_context *lp_ctx,
+			    const char *pszParmName, const char *pszParmValue)
+{
+	int parmnum = map_parameter(pszParmName);
+	void *parm_ptr;
+
+	if (parmnum < 0) {
+		if (strchr(pszParmName, ':')) {
+			return lp_do_parameter_parametric(lp_ctx, NULL, pszParmName, pszParmValue, 0);
+		}
+		DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
+		return true;
+	}
+
+	/* if the flag has been set on the command line, then don't allow override,
+	   but don't report an error */
+	if (lp_ctx->flags[parmnum] & FLAG_CMDLINE) {
+		return true;
+	}
+
+	parm_ptr = lp_parm_ptr(lp_ctx, NULL, &parm_table[parmnum]);
+
+	return set_variable(lp_ctx, parmnum, parm_ptr,
+			    pszParmName, pszParmValue, lp_ctx);
+}
+
+bool lp_do_service_parameter(struct loadparm_context *lp_ctx,
+			     struct loadparm_service *service,
+			     const char *pszParmName, const char *pszParmValue)
+{
+	void *parm_ptr;
+	int i;
+	int parmnum = map_parameter(pszParmName);
+
+	if (parmnum < 0) {
+		if (strchr(pszParmName, ':')) {
+			return lp_do_parameter_parametric(lp_ctx, service, pszParmName, pszParmValue, 0);
+		}
+		DEBUG(0, ("Ignoring unknown parameter \"%s\"\n", pszParmName));
+		return true;
+	}
+
+	/* if the flag has been set on the command line, then don't allow override,
+	   but don't report an error */
+	if (lp_ctx->flags[parmnum] & FLAG_CMDLINE) {
+		return true;
+	}
+
+	if (parm_table[parmnum].pclass == P_GLOBAL) {
+		DEBUG(0,
+		      ("Global parameter %s found in service section!\n",
+		       pszParmName));
+		return true;
+	}
+	parm_ptr = ((char *)service) + parm_table[parmnum].offset;
+
+	if (!service->copymap)
+		init_copymap(service);
+
+	/* this handles the aliases - set the copymap for other
+	 * entries with the same data pointer */
+	for (i = 0; parm_table[i].label; i++)
+		if (parm_table[i].offset == parm_table[parmnum].offset &&
+		    parm_table[i].pclass == parm_table[parmnum].pclass)
+			service->copymap[i] = false;
+
+	return set_variable(service, parmnum, parm_ptr, pszParmName,
+			    pszParmValue, lp_ctx);
+}
+
+/**
+ * Process a parameter.
+ */
+
+static bool do_parameter(const char *pszParmName, const char *pszParmValue,
+			 void *userdata)
+{
+	struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
+
+	if (lp_ctx->bInGlobalSection)
+		return lp_do_global_parameter(lp_ctx, pszParmName,
+					      pszParmValue);
+	else
+		return lp_do_service_parameter(lp_ctx, lp_ctx->currentService,
+					       pszParmName, pszParmValue);
+}
+
+/*
+  variable argument do parameter
+*/
+bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx, const char *pszParmName, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
+bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx,
+				const char *pszParmName, const char *fmt, ...)
+{
+	char *s;
+	bool ret;
+	va_list ap;
+
+	va_start(ap, fmt);
+	s = talloc_vasprintf(NULL, fmt, ap);
+	va_end(ap);
+	ret = lp_do_global_parameter(lp_ctx, pszParmName, s);
+	talloc_free(s);
+	return ret;
+}
+
+
+/*
+  set a parameter from the commandline - this is called from command line parameter
+  parsing code. It sets the parameter then marks the parameter as unable to be modified
+  by smb.conf processing
+*/
+bool lp_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
+		    const char *pszParmValue)
+{
+	int parmnum = map_parameter(pszParmName);
+	int i;
+
+	while (isspace((unsigned char)*pszParmValue)) pszParmValue++;
+
+
+	if (parmnum < 0 && strchr(pszParmName, ':')) {
+		/* set a parametric option */
+		return lp_do_parameter_parametric(lp_ctx, NULL, pszParmName,
+						  pszParmValue, FLAG_CMDLINE);
+	}
+
+	if (parmnum < 0) {
+		DEBUG(0,("Unknown option '%s'\n", pszParmName));
+		return false;
+	}
+
+	/* reset the CMDLINE flag in case this has been called before */
+	lp_ctx->flags[parmnum] &= ~FLAG_CMDLINE;
+
+	if (!lp_do_global_parameter(lp_ctx, pszParmName, pszParmValue)) {
+		return false;
+	}
+
+	lp_ctx->flags[parmnum] |= FLAG_CMDLINE;
+
+	/* we have to also set FLAG_CMDLINE on aliases */
+	for (i=parmnum-1;i>=0 && parm_table[i].offset == parm_table[parmnum].offset;i--) {
+		lp_ctx->flags[i] |= FLAG_CMDLINE;
+	}
+	for (i=parmnum+1;i<NUMPARAMETERS && parm_table[i].offset == parm_table[parmnum].offset;i++) {
+		lp_ctx->flags[i] |= FLAG_CMDLINE;
+	}
+
+	return true;
+}
+
+/*
+  set a option from the commandline in 'a=b' format. Use to support --option
+*/
+bool lp_set_option(struct loadparm_context *lp_ctx, const char *option)
+{
+	char *p, *s;
+	bool ret;
+
+	s = strdup(option);
+	if (!s) {
+		return false;
+	}
+
+	p = strchr(s, '=');
+	if (!p) {
+		free(s);
+		return false;
+	}
+
+	*p = 0;
+
+	ret = lp_set_cmdline(lp_ctx, s, p+1);
+	free(s);
+	return ret;
+}
+
+
+#define BOOLSTR(b) ((b) ? "Yes" : "No")
+
+/**
+ * Print a parameter of the specified type.
+ */
+
+static void print_parameter(struct parm_struct *p, void *ptr, FILE * f)
+{
+	int i;
+	switch (p->type)
+	{
+		case P_ENUM:
+			for (i = 0; p->enum_list[i].name; i++) {
+				if (*(int *)ptr == p->enum_list[i].value) {
+					fprintf(f, "%s",
+						p->enum_list[i].name);
+					break;
+				}
+			}
+			break;
+
+		case P_BOOL:
+			fprintf(f, "%s", BOOLSTR((bool)*(int *)ptr));
+			break;
+
+		case P_INTEGER:
+		case P_BYTES:
+			fprintf(f, "%d", *(int *)ptr);
+			break;
+
+		case P_OCTAL:
+			fprintf(f, "0%o", *(int *)ptr);
+			break;
+
+		case P_LIST:
+			if ((char ***)ptr && *(char ***)ptr) {
+				char **list = *(char ***)ptr;
+
+				for (; *list; list++)
+					fprintf(f, "%s%s", *list,
+						((*(list+1))?", ":""));
+			}
+			break;
+
+		case P_STRING:
+		case P_USTRING:
+			if (*(char **)ptr) {
+				fprintf(f, "%s", *(char **)ptr);
+			}
+			break;
+	}
+}
+
+/**
+ * Check if two parameters are equal.
+ */
+
+static bool equal_parameter(parm_type type, void *ptr1, void *ptr2)
+{
+	switch (type) {
+		case P_BOOL:
+			return (*((int *)ptr1) == *((int *)ptr2));
+
+		case P_INTEGER:
+		case P_OCTAL:
+		case P_BYTES:
+		case P_ENUM:
+			return (*((int *)ptr1) == *((int *)ptr2));
+
+		case P_LIST:
+			return str_list_equal((const char **)(*(char ***)ptr1),
+					      (const char **)(*(char ***)ptr2));
+
+		case P_STRING:
+		case P_USTRING:
+		{
+			char *p1 = *(char **)ptr1, *p2 = *(char **)ptr2;
+			if (p1 && !*p1)
+				p1 = NULL;
+			if (p2 && !*p2)
+				p2 = NULL;
+			return (p1 == p2 || strequal(p1, p2));
+		}
+	}
+	return false;
+}
+
+/**
+ * Process a new section (service).
+ *
+ * At this stage all sections are services.
+ * Later we'll have special sections that permit server parameters to be set.
+ * Returns True on success, False on failure.
+ */
+
+static bool do_section(const char *pszSectionName, void *userdata)
+{
+	struct loadparm_context *lp_ctx = (struct loadparm_context *)userdata;
+	bool bRetval;
+	bool isglobal = ((strwicmp(pszSectionName, GLOBAL_NAME) == 0) ||
+			 (strwicmp(pszSectionName, GLOBAL_NAME2) == 0));
+	bRetval = false;
+
+	/* if we've just struck a global section, note the fact. */
+	lp_ctx->bInGlobalSection = isglobal;
+
+	/* check for multiple global sections */
+	if (lp_ctx->bInGlobalSection) {
+		DEBUG(3, ("Processing section \"[%s]\"\n", pszSectionName));
+		return true;
+	}
+
+	/* if we have a current service, tidy it up before moving on */
+	bRetval = true;
+
+	if (lp_ctx->currentService != NULL)
+		bRetval = service_ok(lp_ctx->currentService);
+
+	/* if all is still well, move to the next record in the services array */
+	if (bRetval) {
+		/* We put this here to avoid an odd message order if messages are */
+		/* issued by the post-processing of a previous section. */
+		DEBUG(2, ("Processing section \"[%s]\"\n", pszSectionName));
+
+		if ((lp_ctx->currentService = lp_add_service(lp_ctx, lp_ctx->sDefault,
+							     pszSectionName))
+		    == NULL) {
+			DEBUG(0, ("Failed to add a new service\n"));
+			return false;
+		}
+	}
+
+	return bRetval;
+}
+
+
+/**
+ * Determine if a particular base parameter is currently set to the default value.
+ */
+
+static bool is_default(struct loadparm_service *sDefault, int i)
+{
+	void *def_ptr = ((char *)sDefault) + parm_table[i].offset;
+	if (!defaults_saved)
+		return false;
+	switch (parm_table[i].type) {
+		case P_LIST:
+			return str_list_equal((const char **)parm_table[i].def.lvalue, 
+					      (const char **)def_ptr);
+		case P_STRING:
+		case P_USTRING:
+			return strequal(parm_table[i].def.svalue,
+					*(char **)def_ptr);
+		case P_BOOL:
+			return parm_table[i].def.bvalue ==
+				*(int *)def_ptr;
+		case P_INTEGER:
+		case P_OCTAL:
+		case P_BYTES:
+		case P_ENUM:
+			return parm_table[i].def.ivalue ==
+				*(int *)def_ptr;
+	}
+	return false;
+}
+
+/**
+ *Display the contents of the global structure.
+ */
+
+static void dump_globals(struct loadparm_context *lp_ctx, FILE *f,
+			 bool show_defaults)
+{
+	int i;
+	struct param_opt *data;
+
+	fprintf(f, "# Global parameters\n[global]\n");
+
+	for (i = 0; parm_table[i].label; i++)
+		if (parm_table[i].pclass == P_GLOBAL &&
+		    parm_table[i].offset != -1 &&
+		    (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
+			if (!show_defaults && (lp_ctx->flags[i] & FLAG_DEFAULT)) 
+				continue;
+			fprintf(f, "\t%s = ", parm_table[i].label);
+			print_parameter(&parm_table[i], lp_parm_ptr(lp_ctx, NULL, &parm_table[i]), f);
+			fprintf(f, "\n");
+	}
+	if (lp_ctx->globals->param_opt != NULL) {
+		for (data = lp_ctx->globals->param_opt; data;
+		     data = data->next) {
+			fprintf(f, "\t%s = %s\n", data->key, data->value);
+		}
+        }
+
+}
+
+/**
+ * Display the contents of a single services record.
+ */
+
+static void dump_a_service(struct loadparm_service * pService, struct loadparm_service *sDefault, FILE * f)
+{
+	int i;
+	struct param_opt *data;
+
+	if (pService != sDefault)
+		fprintf(f, "\n[%s]\n", pService->szService);
+
+	for (i = 0; parm_table[i].label; i++)
+		if (parm_table[i].pclass == P_LOCAL &&
+		    parm_table[i].offset != -1 &&
+		    (*parm_table[i].label != '-') &&
+		    (i == 0 || (parm_table[i].offset != parm_table[i - 1].offset))) {
+			if (pService == sDefault) {
+				if (defaults_saved && is_default(sDefault, i))
+					continue;
+			} else {
+				if (equal_parameter(parm_table[i].type,
+						    ((char *)pService) +
+						    parm_table[i].offset,
+						    ((char *)sDefault) +
+						    parm_table[i].offset))
+					continue;
+			}
+
+			fprintf(f, "\t%s = ", parm_table[i].label);
+			print_parameter(&parm_table[i],
+					((char *)pService) + parm_table[i].offset, f);
+			fprintf(f, "\n");
+	}
+	if (pService->param_opt != NULL) {
+		for (data = pService->param_opt; data; data = data->next) {
+			fprintf(f, "\t%s = %s\n", data->key, data->value);
+		}
+        }
+}
+
+bool lp_dump_a_parameter(struct loadparm_context *lp_ctx,
+			 struct loadparm_service *service,
+			 const char *parm_name, FILE * f)
+{
+	struct parm_struct *parm;
+	void *ptr;
+
+	parm = lp_parm_struct(parm_name);
+	if (!parm) {
+		return false;
+	}
+
+	ptr = lp_parm_ptr(lp_ctx, service,parm);
+
+	print_parameter(parm, ptr, f);
+	fprintf(f, "\n");
+	return true;
+}
+
+/**
+ * Return info about the next service  in a service. snum==-1 gives the globals.
+ * Return NULL when out of parameters.
+ */
+
+struct parm_struct *lp_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i, 
+				      int allparameters)
+{
+	if (snum == -1) {
+		/* do the globals */
+		for (; parm_table[*i].label; (*i)++) {
+			if (parm_table[*i].offset == -1
+			    || (*parm_table[*i].label == '-'))
+				continue;
+
+			if ((*i) > 0
+			    && (parm_table[*i].offset ==
+				parm_table[(*i) - 1].offset))
+				continue;
+
+			return &parm_table[(*i)++];
+		}
+	} else {
+		struct loadparm_service *pService = lp_ctx->services[snum];
+
+		for (; parm_table[*i].label; (*i)++) {
+			if (parm_table[*i].pclass == P_LOCAL &&
+			    parm_table[*i].offset != -1 &&
+			    (*parm_table[*i].label != '-') &&
+			    ((*i) == 0 ||
+			     (parm_table[*i].offset !=
+			      parm_table[(*i) - 1].offset)))
+			{
+				if (allparameters ||
+				    !equal_parameter(parm_table[*i].type,
+						     ((char *)pService) +
+						     parm_table[*i].offset,
+						     ((char *)lp_ctx->sDefault) +
+						     parm_table[*i].offset))
+				{
+					return &parm_table[(*i)++];
+				}
+			}
+		}
+	}
+
+	return NULL;
+}
+
+
+/**
+ * Auto-load some home services.
+ */
+static void lp_add_auto_services(struct loadparm_context *lp_ctx,
+				 const char *str)
+{
+	return;
+}
+
+
+/**
+ * Unload unused services.
+ */
+
+void lp_killunused(struct loadparm_context *lp_ctx,
+		   struct smbsrv_connection *smb,
+		   bool (*snumused) (struct smbsrv_connection *, int))
+{
+	int i;
+	for (i = 0; i < lp_ctx->iNumServices; i++) {
+		if (lp_ctx->services[i] == NULL)
+			continue;
+
+		if (!snumused || !snumused(smb, i)) {
+			talloc_free(lp_ctx->services[i]);
+			lp_ctx->services[i] = NULL;
+		}
+	}
+}
+
+
+static int lp_destructor(struct loadparm_context *lp_ctx)
+{
+	struct param_opt *data;
+
+	if (lp_ctx->globals->param_opt != NULL) {
+		struct param_opt *next;
+		for (data = lp_ctx->globals->param_opt; data; data=next) {
+			next = data->next;
+			if (data->priority & FLAG_CMDLINE) continue;
+			DLIST_REMOVE(lp_ctx->globals->param_opt, data);
+			talloc_free(data);
+		}
+	}
+
+	return 0;
+}
+
+/**
+ * Initialise the global parameter structure.
+ */
+struct loadparm_context *loadparm_init(TALLOC_CTX *mem_ctx)
+{
+	int i;
+	char *myname;
+	struct loadparm_context *lp_ctx;
+
+	lp_ctx = talloc_zero(mem_ctx, struct loadparm_context);
+	if (lp_ctx == NULL)
+		return NULL;
+
+	talloc_set_destructor(lp_ctx, lp_destructor);
+	lp_ctx->bInGlobalSection = true;
+	lp_ctx->globals = talloc_zero(lp_ctx, struct loadparm_global);
+	lp_ctx->sDefault = talloc_zero(lp_ctx, struct loadparm_service);
+
+	lp_ctx->sDefault->iMaxPrintJobs = 1000;
+	lp_ctx->sDefault->bAvailable = true;
+	lp_ctx->sDefault->bBrowseable = true;
+	lp_ctx->sDefault->bRead_only = true;
+	lp_ctx->sDefault->bMap_archive = true;
+	lp_ctx->sDefault->bStrictLocking = true;
+	lp_ctx->sDefault->bOplocks = true;
+	lp_ctx->sDefault->iCreate_mask = 0744;
+	lp_ctx->sDefault->iCreate_force_mode = 0000;
+	lp_ctx->sDefault->iDir_mask = 0755;
+	lp_ctx->sDefault->iDir_force_mode = 0000;
+
+	DEBUG(3, ("Initialising global parameters\n"));
+
+	for (i = 0; parm_table[i].label; i++) {
+		if ((parm_table[i].type == P_STRING ||
+		     parm_table[i].type == P_USTRING) &&
+		    parm_table[i].offset != -1 &&
+		    !(lp_ctx->flags[i] & FLAG_CMDLINE)) {
+			char **r;
+			if (parm_table[i].pclass == P_LOCAL) {
+				r = (char **)(((char *)lp_ctx->sDefault) + parm_table[i].offset);
+			} else {
+				r = (char **)(((char *)lp_ctx->globals) + parm_table[i].offset);
+			}
+			*r = talloc_strdup(lp_ctx, "");
+		}
+	}
+
+	lp_do_global_parameter(lp_ctx, "share backend", "classic");
+
+	lp_do_global_parameter(lp_ctx, "server role", "standalone");
+
+	/* options that can be set on the command line must be initialised via
+	   the slower lp_do_global_parameter() to ensure that FLAG_CMDLINE is obeyed */
+#ifdef TCP_NODELAY
+	lp_do_global_parameter(lp_ctx, "socket options", "TCP_NODELAY");
+#endif
+	lp_do_global_parameter(lp_ctx, "workgroup", DEFAULT_WORKGROUP);
+	myname = get_myname(lp_ctx);
+	lp_do_global_parameter(lp_ctx, "netbios name", myname);
+	talloc_free(myname);
+	lp_do_global_parameter(lp_ctx, "name resolve order", "wins host bcast");
+
+	lp_do_global_parameter(lp_ctx, "fstype", "NTFS");
+
+	lp_do_global_parameter(lp_ctx, "ntvfs handler", "unixuid default");
+	lp_do_global_parameter(lp_ctx, "max connections", "-1");
+
+	lp_do_global_parameter(lp_ctx, "dcerpc endpoint servers", "epmapper srvsvc wkssvc rpcecho samr netlogon lsarpc spoolss drsuapi winreg dssetup unixinfo browser");
+	lp_do_global_parameter(lp_ctx, "server services", "smb rpc nbt wrepl ldap cldap kdc drepl winbind ntp_signd");
+	lp_do_global_parameter(lp_ctx, "ntptr providor", "simple_ldb");
+	lp_do_global_parameter(lp_ctx, "auth methods:domain controller", "anonymous sam_ignoredomain");
+	lp_do_global_parameter(lp_ctx, "auth methods:member server", "anonymous sam winbind");
+	lp_do_global_parameter(lp_ctx, "auth methods:standalone", "anonymous sam_ignoredomain");
+	lp_do_global_parameter(lp_ctx, "private dir", dyn_PRIVATE_DIR);
+	lp_do_global_parameter(lp_ctx, "sam database", "sam.ldb");
+	lp_do_global_parameter(lp_ctx, "idmap database", "idmap.ldb");
+	lp_do_global_parameter(lp_ctx, "secrets database", "secrets.ldb");
+	lp_do_global_parameter(lp_ctx, "spoolss database", "spoolss.ldb");
+	lp_do_global_parameter(lp_ctx, "wins config database", "wins_config.ldb");
+	lp_do_global_parameter(lp_ctx, "wins database", "wins.ldb");
+	lp_do_global_parameter(lp_ctx, "registry:HKEY_LOCAL_MACHINE", "hklm.ldb");
+
+	/* This hive should be dynamically generated by Samba using
+	   data from the sam, but for the moment leave it in a tdb to
+	   keep regedt32 from popping up an annoying dialog. */
+	lp_do_global_parameter(lp_ctx, "registry:HKEY_USERS", "hku.ldb");
+
+	/* using UTF8 by default allows us to support all chars */
+	lp_do_global_parameter(lp_ctx, "unix charset", "UTF8");
+
+	/* Use codepage 850 as a default for the dos character set */
+	lp_do_global_parameter(lp_ctx, "dos charset", "CP850");
+
+	/*
+	 * Allow the default PASSWD_CHAT to be overridden in local.h.
+	 */
+	lp_do_global_parameter(lp_ctx, "passwd chat", DEFAULT_PASSWD_CHAT);
+
+	lp_do_global_parameter(lp_ctx, "pid directory", dyn_PIDDIR);
+	lp_do_global_parameter(lp_ctx, "lock dir", dyn_LOCKDIR);
+	lp_do_global_parameter(lp_ctx, "modules dir", dyn_MODULESDIR);
+	lp_do_global_parameter(lp_ctx, "ncalrpc dir", dyn_NCALRPCDIR);
+
+	lp_do_global_parameter(lp_ctx, "socket address", "0.0.0.0");
+	lp_do_global_parameter_var(lp_ctx, "server string",
+				   "Samba %s", SAMBA_VERSION_STRING);
+
+	lp_do_global_parameter_var(lp_ctx, "announce version", "%d.%d",
+			 DEFAULT_MAJOR_VERSION,
+			 DEFAULT_MINOR_VERSION);
+
+	lp_do_global_parameter(lp_ctx, "password server", "*");
+
+	lp_do_global_parameter(lp_ctx, "max mux", "50");
+	lp_do_global_parameter(lp_ctx, "max xmit", "12288");
+	lp_do_global_parameter(lp_ctx, "password level", "0");
+	lp_do_global_parameter(lp_ctx, "LargeReadwrite", "True");
+	lp_do_global_parameter(lp_ctx, "server min protocol", "CORE");
+	lp_do_global_parameter(lp_ctx, "server max protocol", "NT1");
+	lp_do_global_parameter(lp_ctx, "client min protocol", "CORE");
+	lp_do_global_parameter(lp_ctx, "client max protocol", "NT1");
+	lp_do_global_parameter(lp_ctx, "security", "USER");
+	lp_do_global_parameter(lp_ctx, "paranoid server security", "True");
+	lp_do_global_parameter(lp_ctx, "EncryptPasswords", "True");
+	lp_do_global_parameter(lp_ctx, "ReadRaw", "True");
+	lp_do_global_parameter(lp_ctx, "WriteRaw", "True");
+	lp_do_global_parameter(lp_ctx, "NullPasswords", "False");
+	lp_do_global_parameter(lp_ctx, "ObeyPamRestrictions", "False");
+	lp_do_global_parameter(lp_ctx, "announce as", "NT SERVER");
+
+	lp_do_global_parameter(lp_ctx, "TimeServer", "False");
+	lp_do_global_parameter(lp_ctx, "BindInterfacesOnly", "False");
+	lp_do_global_parameter(lp_ctx, "Unicode", "True");
+	lp_do_global_parameter(lp_ctx, "ClientLanManAuth", "False");
+	lp_do_global_parameter(lp_ctx, "LanmanAuth", "False");
+	lp_do_global_parameter(lp_ctx, "NTLMAuth", "True");
+	lp_do_global_parameter(lp_ctx, "client use spnego principal", "False");
+
+	lp_do_global_parameter(lp_ctx, "UnixExtensions", "False");
+
+	lp_do_global_parameter(lp_ctx, "PreferredMaster", "Auto");
+	lp_do_global_parameter(lp_ctx, "LocalMaster", "True");
+
+	lp_do_global_parameter(lp_ctx, "wins support", "False");
+	lp_do_global_parameter(lp_ctx, "dns proxy", "True");
+
+	lp_do_global_parameter(lp_ctx, "winbind separator", "\\");
+	lp_do_global_parameter(lp_ctx, "winbind sealed pipes", "True");
+	lp_do_global_parameter(lp_ctx, "winbindd socket directory", dyn_WINBINDD_SOCKET_DIR);
+	lp_do_global_parameter(lp_ctx, "winbindd privileged socket directory", dyn_WINBINDD_PRIVILEGED_SOCKET_DIR);
+	lp_do_global_parameter(lp_ctx, "template shell", "/bin/false");
+	lp_do_global_parameter(lp_ctx, "template homedir", "/home/%WORKGROUP%/%ACCOUNTNAME%");
+	lp_do_global_parameter(lp_ctx, "idmap trusted only", "False");
+
+	lp_do_global_parameter(lp_ctx, "client signing", "Yes");
+	lp_do_global_parameter(lp_ctx, "server signing", "auto");
+
+	lp_do_global_parameter(lp_ctx, "use spnego", "True");
+
+	lp_do_global_parameter(lp_ctx, "smb ports", "445 139");
+	lp_do_global_parameter(lp_ctx, "nbt port", "137");
+	lp_do_global_parameter(lp_ctx, "dgram port", "138");
+	lp_do_global_parameter(lp_ctx, "cldap port", "389");
+	lp_do_global_parameter(lp_ctx, "krb5 port", "88");
+	lp_do_global_parameter(lp_ctx, "kpasswd port", "464");
+	lp_do_global_parameter(lp_ctx, "web port", "901");
+	lp_do_global_parameter(lp_ctx, "swat directory", dyn_SWATDIR);
+
+	lp_do_global_parameter(lp_ctx, "nt status support", "True");
+
+	lp_do_global_parameter(lp_ctx, "max wins ttl", "518400"); /* 6 days */
+	lp_do_global_parameter(lp_ctx, "min wins ttl", "10");
+
+	lp_do_global_parameter(lp_ctx, "tls enabled", "True");
+	lp_do_global_parameter(lp_ctx, "tls keyfile", "tls/key.pem");
+	lp_do_global_parameter(lp_ctx, "tls certfile", "tls/cert.pem");
+	lp_do_global_parameter(lp_ctx, "tls cafile", "tls/ca.pem");
+	lp_do_global_parameter_var(lp_ctx, "setup directory", "%s",
+				   dyn_SETUPDIR);
+
+	lp_do_global_parameter(lp_ctx, "prefork children:smb", "4");
+
+	lp_do_global_parameter(lp_ctx, "ntp signd socket directory", dyn_NTP_SIGND_SOCKET_DIR);
+
+	for (i = 0; parm_table[i].label; i++) {
+		if (!(lp_ctx->flags[i] & FLAG_CMDLINE)) {
+			lp_ctx->flags[i] |= FLAG_DEFAULT;
+		}
+	}
+
+	return lp_ctx;
+}
+
+const char *lp_configfile(struct loadparm_context *lp_ctx)
+{
+	return lp_ctx->szConfigFile;
+}
+
+const char *lp_default_path(void)
+{
+    if (getenv("SMB_CONF_PATH"))
+        return getenv("SMB_CONF_PATH");
+    else
+        return dyn_CONFIGFILE;
+}
+
+/**
+ * Update the internal state of a loadparm context after settings 
+ * have changed.
+ */
+static bool lp_update(struct loadparm_context *lp_ctx)
+{
+	lp_add_auto_services(lp_ctx, lp_auto_services(lp_ctx));
+
+	lp_add_hidden(lp_ctx, "IPC$", "IPC");
+	lp_add_hidden(lp_ctx, "ADMIN$", "DISK");
+
+	if (!lp_ctx->globals->szWINSservers && lp_ctx->globals->bWINSsupport) {
+		lp_do_global_parameter(lp_ctx, "wins server", "127.0.0.1");
+	}
+
+	panic_action = lp_ctx->globals->panic_action;
+
+	reload_charcnv(lp_ctx);
+
+	/* FIXME: ntstatus_check_dos_mapping = lp_nt_status_support(lp_ctx); */
+
+	/* FIXME: This is a bit of a hack, but we can't use a global, since 
+	 * not everything that uses lp also uses the socket library */
+	if (lp_parm_bool(lp_ctx, NULL, "socket", "testnonblock", false)) {
+		setenv("SOCKET_TESTNONBLOCK", "1", 1);
+	} else {
+		unsetenv("SOCKET_TESTNONBLOCK");
+	}
+
+	/* FIXME: Check locale in environment for this: */
+	if (strcmp(lp_display_charset(lp_ctx), lp_unix_charset(lp_ctx)) != 0)
+		d_set_iconv(smb_iconv_open(lp_display_charset(lp_ctx), lp_unix_charset(lp_ctx)));
+	else
+		d_set_iconv((smb_iconv_t)-1);
+
+	return true;
+}
+
+bool lp_load_default(struct loadparm_context *lp_ctx)
+{
+    const char *path;
+
+    path = lp_default_path();
+
+    if (!file_exist(path)) {
+	    /* We allow the default smb.conf file to not exist, 
+	     * basically the equivalent of an empty file. */
+	    return lp_update(lp_ctx);
+    }
+
+    return lp_load(lp_ctx, path);
+}
+
+/**
+ * Load the services array from the services file.
+ *
+ * Return True on success, False on failure.
+ */
+bool lp_load(struct loadparm_context *lp_ctx, const char *filename)
+{
+	char *n2;
+	bool bRetval;
+
+	filename = talloc_strdup(lp_ctx, filename);
+
+	lp_ctx->szConfigFile = filename;
+
+	lp_ctx->bInGlobalSection = true;
+	n2 = standard_sub_basic(lp_ctx, lp_ctx->szConfigFile);
+	DEBUG(2, ("lp_load: refreshing parameters from %s\n", n2));
+
+	add_to_file_list(lp_ctx, lp_ctx->szConfigFile, n2);
+
+	/* We get sections first, so have to start 'behind' to make up */
+	lp_ctx->currentService = NULL;
+	bRetval = pm_process(n2, do_section, do_parameter, lp_ctx);
+
+	/* finish up the last section */
+	DEBUG(4, ("pm_process() returned %s\n", BOOLSTR(bRetval)));
+	if (bRetval)
+		if (lp_ctx->currentService != NULL)
+			bRetval = service_ok(lp_ctx->currentService);
+
+	bRetval = bRetval && lp_update(lp_ctx);
+
+	return bRetval;
+}
+
+/**
+ * Return the max number of services.
+ */
+
+int lp_numservices(struct loadparm_context *lp_ctx)
+{
+	return lp_ctx->iNumServices;
+}
+
+/**
+ * Display the contents of the services array in human-readable form.
+ */
+
+void lp_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
+	     int maxtoprint)
+{
+	int iService;
+
+	if (show_defaults)
+		defaults_saved = false;
+
+	dump_globals(lp_ctx, f, show_defaults);
+
+	dump_a_service(lp_ctx->sDefault, lp_ctx->sDefault, f);
+
+	for (iService = 0; iService < maxtoprint; iService++)
+		lp_dump_one(f, show_defaults, lp_ctx->services[iService], lp_ctx->sDefault);
+}
+
+/**
+ * Display the contents of one service in human-readable form.
+ */
+void lp_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault)
+{
+	if (service != NULL) {
+		if (service->szService[0] == '\0')
+			return;
+		dump_a_service(service, sDefault, f);
+	}
+}
+
+struct loadparm_service *lp_servicebynum(struct loadparm_context *lp_ctx,
+					 int snum)
+{
+	return lp_ctx->services[snum];
+}
+
+struct loadparm_service *lp_service(struct loadparm_context *lp_ctx,
+				    const char *service_name)
+{
+	int iService;
+        char *serviceName;
+
+	for (iService = lp_ctx->iNumServices - 1; iService >= 0; iService--) {
+		if (lp_ctx->services[iService] &&
+		    lp_ctx->services[iService]->szService) {
+			/*
+			 * The substitution here is used to support %U is
+			 * service names
+			 */
+			serviceName = standard_sub_basic(
+					lp_ctx->services[iService],
+					lp_ctx->services[iService]->szService);
+			if (strequal(serviceName, service_name))
+				return lp_ctx->services[iService];
+		}
+	}
+
+	DEBUG(7,("lp_servicenumber: couldn't find %s\n", service_name));
+	return NULL;
+}
+
+
+/**
+ * A useful volume label function.
+ */
+const char *volume_label(struct loadparm_service *service, struct loadparm_service *sDefault)
+{
+	const char *ret = lp_volume(service, sDefault);
+	if (!*ret)
+		return lp_servicename(service);
+	return ret;
+}
+
+
+/**
+ * If we are PDC then prefer us as DMB
+ */
+const char *lp_printername(struct loadparm_service *service, struct loadparm_service *sDefault)
+{
+	const char *ret = _lp_printername(service, sDefault);
+	if (ret == NULL || (ret != NULL && *ret == '\0'))
+		ret = lp_servicename(service);
+
+	return ret;
+}
+
+
+/**
+ * Return the max print jobs per queue.
+ */
+int lp_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault)
+{
+	int maxjobs = (service != NULL) ? service->iMaxPrintJobs : sDefault->iMaxPrintJobs;
+	if (maxjobs <= 0 || maxjobs >= PRINT_MAX_JOBID)
+		maxjobs = PRINT_MAX_JOBID - 1;
+
+	return maxjobs;
+}
+
+struct smb_iconv_convenience *lp_iconv_convenience(struct loadparm_context *lp_ctx)
+{
+	if (lp_ctx == NULL) {
+		static struct smb_iconv_convenience *fallback_ic = NULL;
+		if (fallback_ic == NULL)
+			fallback_ic = smb_iconv_convenience_init(talloc_autofree_context(), 
+						  "CP850", "UTF8", true);
+		return fallback_ic;
+	}
+	return lp_ctx->iconv_convenience;
+}
+
+_PUBLIC_ void reload_charcnv(struct loadparm_context *lp_ctx)
+{
+	talloc_free(lp_ctx->iconv_convenience);
+	global_iconv_convenience = lp_ctx->iconv_convenience = smb_iconv_convenience_init_lp(lp_ctx, lp_ctx);
+}
+
+void lp_smbcli_options(struct loadparm_context *lp_ctx,
+			 struct smbcli_options *options)
+{
+	options->max_xmit = lp_max_xmit(lp_ctx);
+	options->max_mux = lp_maxmux(lp_ctx);
+	options->use_spnego = lp_nt_status_support(lp_ctx) && lp_use_spnego(lp_ctx); 
+	options->signing = lp_client_signing(lp_ctx);
+	options->request_timeout = SMB_REQUEST_TIMEOUT;
+	options->ntstatus_support = lp_nt_status_support(lp_ctx);
+	options->max_protocol = lp_cli_maxprotocol(lp_ctx);
+	options->unicode = lp_unicode(lp_ctx);
+	options->use_oplocks = true;
+	options->use_level2_oplocks = true;
+}
+
+void lp_smbcli_session_options(struct loadparm_context *lp_ctx,
+				 struct smbcli_session_options *options)
+{
+	options->lanman_auth = lp_client_lanman_auth(lp_ctx);
+	options->ntlmv2_auth = lp_client_ntlmv2_auth(lp_ctx);
+	options->plaintext_auth = lp_client_plaintext_auth(lp_ctx);
+}
+
+_PUBLIC_ char *lp_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+{
+	return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_keyfile);
+}
+
+_PUBLIC_ char *lp_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+{
+	return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_certfile);
+}
+
+_PUBLIC_ char *lp_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+{
+	return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_cafile);
+}
+
+_PUBLIC_ char *lp_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+{
+	return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_crlfile);
+}
+
+_PUBLIC_ char *lp_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+{
+	return private_path(mem_ctx, lp_ctx, lp_ctx->globals->tls_dhpfile);
+}
+
+_PUBLIC_ struct dcerpc_server_info *lp_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+{
+	struct dcerpc_server_info *ret = talloc_zero(mem_ctx, struct dcerpc_server_info);
+
+	ret->domain_name = talloc_reference(mem_ctx, lp_workgroup(lp_ctx));
+	ret->version_major = lp_parm_int(lp_ctx, NULL, "server_info", "version_major", 5);
+	ret->version_minor = lp_parm_int(lp_ctx, NULL, "server_info", "version_minor", 2);
+	ret->version_build = lp_parm_int(lp_ctx, NULL, "server_info", "version_build", 3790);
+
+	return ret;
+}
+
+struct gensec_settings *lp_gensec_settings(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+{
+	struct gensec_settings *settings = talloc(mem_ctx, struct gensec_settings);
+	if (settings == NULL)
+		return NULL;
+	SMB_ASSERT(lp_ctx != NULL);
+	settings->lp_ctx = talloc_reference(settings, lp_ctx);
+	settings->iconv_convenience = lp_iconv_convenience(lp_ctx);
+	settings->target_hostname = lp_parm_string(lp_ctx, NULL, "gensec", "target_hostname");
+	return settings;
+}
diff --git a/source4/param/loadparm.h b/source4/param/loadparm.h
new file mode 100644
index 0000000000..454d3f8853
--- /dev/null
+++ b/source4/param/loadparm.h
@@ -0,0 +1,99 @@
+/* 
+   Unix SMB/CIFS implementation.
+   
+   type definitions for loadparm
+
+   Copyright (C) Karl Auer 1993-1998
+
+   Largely re-written by Andrew Tridgell, September 1994
+
+   Copyright (C) Simo Sorce 2001
+   Copyright (C) Alexander Bokovoy 2002
+   Copyright (C) Stefan (metze) Metzmacher 2002
+   Copyright (C) Jim McDonough (jmcd@us.ibm.com)  2003.
+   Copyright (C) James Myers 2003 <myersjj@samba.org>
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* the following are used by loadparm for option lists */
+typedef enum {
+	P_BOOL,P_INTEGER,P_OCTAL,P_BYTES,P_LIST,P_STRING,P_USTRING,P_ENUM
+} parm_type;
+
+typedef enum {
+	P_LOCAL,P_GLOBAL,P_NONE
+} parm_class;
+
+struct enum_list {
+	int value;
+	const char *name;
+};
+
+struct loadparm_context;
+
+struct parm_struct {
+	const char *label;
+	parm_type type;
+	parm_class pclass;
+	int offset;
+	bool (*special)(struct loadparm_context *, const char *, char **);
+	const struct enum_list *enum_list;
+	union {
+		int bvalue;
+		int ivalue;
+		char *svalue;
+		char cvalue;
+		const char **lvalue;
+	} def;
+};
+
+#define FLAG_DEFAULT    0x0001 /* this option was a default */
+#define FLAG_CMDLINE    0x0002 /* this option was set from the command line */
+
+#ifndef PRINTERS_NAME
+#define PRINTERS_NAME "printers"
+#endif
+
+#ifndef HOMES_NAME
+#define HOMES_NAME "homes"
+#endif
+
+/* This defines the section name in the configuration file that will contain */
+/* global parameters - that is, parameters relating to the whole server, not */
+/* just services. This name is then reserved, and may not be used as a       */
+/* a service name. It will default to "global" if not defined here.          */
+#ifndef GLOBAL_NAME
+#define GLOBAL_NAME "global"
+#define GLOBAL_NAME2 "globals"
+#endif
+
+/* The default workgroup - usually overridden in smb.conf */
+#ifndef DEFAULT_WORKGROUP
+#define DEFAULT_WORKGROUP "WORKGROUP"
+#endif
+
+/*
+ * Default passwd chat script.
+ */
+#ifndef DEFAULT_PASSWD_CHAT
+#define DEFAULT_PASSWD_CHAT "*new*password* %n\\n *new*password* %n\\n *changed*"
+#endif
+
+/* Max number of jobs per print queue. */
+#ifndef PRINT_MAX_JOBID
+#define PRINT_MAX_JOBID 10000
+#endif
+
+
diff --git a/source4/param/param.h b/source4/param/param.h
new file mode 100644
index 0000000000..3d257be062
--- /dev/null
+++ b/source4/param/param.h
@@ -0,0 +1,442 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Generic parameter parsing interface
+   Copyright (C) Jelmer Vernooij					  2005
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _PARAM_H /* _PARAM_H */
+#define _PARAM_H 
+
+struct param_opt {
+	struct param_opt *prev, *next;
+	char *key;
+	char *value;
+	int priority;
+};
+
+struct param_context {
+	struct param_section *sections;
+};
+
+struct param_section {
+	const char *name;
+	struct param_section *prev, *next;
+	struct param_opt *parameters;
+};
+
+struct param_context;
+struct smbsrv_connection;
+
+#define Auto (2)
+
+typedef NTSTATUS (*init_module_fn) (void);
+
+/* this needs to be a string which is not in the C library. We
+   previously used "init_module", but that meant that modules which
+   did not define this function ended up calling the C library
+   function init_module() which makes a system call */
+#define SAMBA_INIT_MODULE "samba_init_module"
+
+enum server_role {
+	ROLE_STANDALONE=0,
+	ROLE_DOMAIN_MEMBER=1,
+	ROLE_DOMAIN_CONTROLLER=2,
+};
+
+enum announce_as {/* Types of machine we can announce as. */
+	ANNOUNCE_AS_NT_SERVER=1,
+	ANNOUNCE_AS_WIN95=2,
+	ANNOUNCE_AS_WFW=3,
+	ANNOUNCE_AS_NT_WORKSTATION=4
+};
+
+struct loadparm_context;
+struct loadparm_service;
+struct smbcli_options;
+struct smbcli_session_options;
+struct gensec_settings;
+
+void reload_charcnv(struct loadparm_context *lp_ctx);
+
+struct loadparm_service *lp_default_service(struct loadparm_context *lp_ctx);
+struct parm_struct *lp_parm_table(void);
+int lp_server_role(struct loadparm_context *);
+const char **lp_smb_ports(struct loadparm_context *);
+int lp_nbt_port(struct loadparm_context *);
+int lp_dgram_port(struct loadparm_context *);
+int lp_cldap_port(struct loadparm_context *);
+int lp_krb5_port(struct loadparm_context *);
+int lp_kpasswd_port(struct loadparm_context *);
+int lp_web_port(struct loadparm_context *);
+const char *lp_swat_directory(struct loadparm_context *);
+bool lp_tls_enabled(struct loadparm_context *);
+char *lp_tls_keyfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+char *lp_tls_certfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+char *lp_tls_cafile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+char *lp_tls_crlfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+char *lp_tls_dhpfile(TALLOC_CTX *mem_ctx, struct loadparm_context *);
+const char *lp_share_backend(struct loadparm_context *);
+const char *lp_sam_url(struct loadparm_context *);
+const char *lp_idmap_url(struct loadparm_context *);
+const char *lp_secrets_url(struct loadparm_context *);
+const char *lp_spoolss_url(struct loadparm_context *);
+const char *lp_wins_config_url(struct loadparm_context *);
+const char *lp_wins_url(struct loadparm_context *);
+const char *lp_winbind_separator(struct loadparm_context *);
+const char *lp_winbindd_socket_directory(struct loadparm_context *);
+const char *lp_winbindd_privileged_socket_directory(struct loadparm_context *);
+const char *lp_template_shell(struct loadparm_context *);
+const char *lp_template_homedir(struct loadparm_context *);
+bool lp_winbind_sealed_pipes(struct loadparm_context *);
+bool lp_idmap_trusted_only(struct loadparm_context *);
+const char *lp_private_dir(struct loadparm_context *);
+const char *lp_serverstring(struct loadparm_context *);
+const char *lp_lockdir(struct loadparm_context *);
+const char *lp_modulesdir(struct loadparm_context *);
+const char *lp_setupdir(struct loadparm_context *);
+const char *lp_ncalrpc_dir(struct loadparm_context *);
+const char *lp_dos_charset(struct loadparm_context *);
+const char *lp_unix_charset(struct loadparm_context *);
+const char *lp_display_charset(struct loadparm_context *);
+const char *lp_piddir(struct loadparm_context *);
+const char **lp_dcerpc_endpoint_servers(struct loadparm_context *);
+const char **lp_server_services(struct loadparm_context *);
+const char *lp_ntptr_providor(struct loadparm_context *);
+const char *lp_auto_services(struct loadparm_context *);
+const char *lp_passwd_chat(struct loadparm_context *);
+const char **lp_passwordserver(struct loadparm_context *);
+const char **lp_name_resolve_order(struct loadparm_context *);
+const char *lp_realm(struct loadparm_context *);
+const char *lp_socket_options(struct loadparm_context *);
+const char *lp_workgroup(struct loadparm_context *);
+const char *lp_netbios_name(struct loadparm_context *);
+const char *lp_netbios_scope(struct loadparm_context *);
+const char **lp_wins_server_list(struct loadparm_context *);
+const char **lp_interfaces(struct loadparm_context *);
+const char *lp_socket_address(struct loadparm_context *);
+const char **lp_netbios_aliases(struct loadparm_context *);
+bool lp_disable_netbios(struct loadparm_context *);
+bool lp_wins_support(struct loadparm_context *);
+bool lp_wins_dns_proxy(struct loadparm_context *);
+const char *lp_wins_hook(struct loadparm_context *);
+bool lp_local_master(struct loadparm_context *);
+bool lp_readraw(struct loadparm_context *);
+bool lp_large_readwrite(struct loadparm_context *);
+bool lp_writeraw(struct loadparm_context *);
+bool lp_null_passwords(struct loadparm_context *);
+bool lp_obey_pam_restrictions(struct loadparm_context *);
+bool lp_encrypted_passwords(struct loadparm_context *);
+bool lp_time_server(struct loadparm_context *);
+bool lp_bind_interfaces_only(struct loadparm_context *);
+bool lp_unicode(struct loadparm_context *);
+bool lp_nt_status_support(struct loadparm_context *);
+bool lp_lanman_auth(struct loadparm_context *);
+bool lp_ntlm_auth(struct loadparm_context *);
+bool lp_client_plaintext_auth(struct loadparm_context *);
+bool lp_client_lanman_auth(struct loadparm_context *);
+bool lp_client_ntlmv2_auth(struct loadparm_context *);
+bool lp_client_use_spnego_principal(struct loadparm_context *);
+bool lp_host_msdfs(struct loadparm_context *);
+bool lp_unix_extensions(struct loadparm_context *);
+bool lp_use_spnego(struct loadparm_context *);
+bool lp_rpc_big_endian(struct loadparm_context *);
+int lp_max_wins_ttl(struct loadparm_context *);
+int lp_min_wins_ttl(struct loadparm_context *);
+int lp_maxmux(struct loadparm_context *);
+int lp_max_xmit(struct loadparm_context *);
+int lp_passwordlevel(struct loadparm_context *);
+int lp_srv_maxprotocol(struct loadparm_context *);
+int lp_srv_minprotocol(struct loadparm_context *);
+int lp_cli_maxprotocol(struct loadparm_context *);
+int lp_cli_minprotocol(struct loadparm_context *);
+int lp_security(struct loadparm_context *);
+bool lp_paranoid_server_security(struct loadparm_context *);
+int lp_announce_as(struct loadparm_context *);
+
+const char *lp_servicename(const struct loadparm_service *service);
+const char *lp_pathname(struct loadparm_service *, struct loadparm_service *);
+const char **lp_hostsallow(struct loadparm_service *, struct loadparm_service *);
+const char **lp_hostsdeny(struct loadparm_service *, struct loadparm_service *);
+const char *lp_comment(struct loadparm_service *, struct loadparm_service *);
+const char *lp_fstype(struct loadparm_service *, struct loadparm_service *);
+const char **lp_ntvfs_handler(struct loadparm_service *, struct loadparm_service *);
+bool lp_msdfs_root(struct loadparm_service *, struct loadparm_service *);
+bool lp_browseable(struct loadparm_service *, struct loadparm_service *);
+bool lp_readonly(struct loadparm_service *, struct loadparm_service *);
+bool lp_print_ok(struct loadparm_service *, struct loadparm_service *);
+bool lp_map_hidden(struct loadparm_service *, struct loadparm_service *);
+bool lp_map_archive(struct loadparm_service *, struct loadparm_service *);
+bool lp_strict_locking(struct loadparm_service *, struct loadparm_service *);
+bool lp_oplocks(struct loadparm_service *, struct loadparm_service *);
+bool lp_strict_sync(struct loadparm_service *, struct loadparm_service *);
+bool lp_ci_filesystem(struct loadparm_service *, struct loadparm_service *);
+bool lp_map_system(struct loadparm_service *, struct loadparm_service *);
+int lp_max_connections(struct loadparm_service *, struct loadparm_service *);
+int lp_csc_policy(struct loadparm_service *, struct loadparm_service *);
+int lp_create_mask(struct loadparm_service *, struct loadparm_service *);
+int lp_force_create_mode(struct loadparm_service *, struct loadparm_service *);
+int lp_dir_mask(struct loadparm_service *, struct loadparm_service *);
+int lp_force_dir_mode(struct loadparm_service *, struct loadparm_service *);
+int lp_server_signing(struct loadparm_context *);
+int lp_client_signing(struct loadparm_context *);
+const char *lp_ntp_signd_socket_directory(struct loadparm_context *);
+
+
+const char *lp_get_parametric(struct loadparm_context *lp_ctx,
+			      struct loadparm_service *service,
+			      const char *type, const char *option);
+
+const char *lp_parm_string(struct loadparm_context *lp_ctx,
+			   struct loadparm_service *service, const char *type,
+			   const char *option);
+const char **lp_parm_string_list(TALLOC_CTX *mem_ctx,
+				 struct loadparm_context *lp_ctx,
+				 struct loadparm_service *service,
+				 const char *type,
+				 const char *option, const char *separator);
+int lp_parm_int(struct loadparm_context *lp_ctx,
+		struct loadparm_service *service, const char *type,
+		const char *option, int default_v);
+int lp_parm_bytes(struct loadparm_context *lp_ctx,
+		  struct loadparm_service *service, const char *type,
+		  const char *option, int default_v);
+unsigned long lp_parm_ulong(struct loadparm_context *lp_ctx,
+			    struct loadparm_service *service, const char *type,
+			    const char *option, unsigned long default_v);
+double lp_parm_double(struct loadparm_context *lp_ctx,
+		      struct loadparm_service *service, const char *type,
+		      const char *option, double default_v);
+bool lp_parm_bool(struct loadparm_context *lp_ctx,
+		  struct loadparm_service *service, const char *type,
+		  const char *option, bool default_v);
+struct loadparm_service *lp_add_service(struct loadparm_context *lp_ctx,
+				     const struct loadparm_service *pservice,
+				     const char *name);
+bool lp_add_home(struct loadparm_context *lp_ctx,
+		 const char *pszHomename,
+		 struct loadparm_service *default_service,
+		 const char *user, const char *pszHomedir);
+bool lp_add_printer(struct loadparm_context *lp_ctx,
+		    const char *pszPrintername,
+		    struct loadparm_service *default_service);
+struct parm_struct *lp_parm_struct(const char *name);
+void *lp_parm_ptr(struct loadparm_context *lp_ctx,
+		  struct loadparm_service *service, struct parm_struct *parm);
+bool lp_file_list_changed(struct loadparm_context *lp_ctx);
+
+bool lp_do_global_parameter(struct loadparm_context *lp_ctx,
+			    const char *pszParmName, const char *pszParmValue);
+bool lp_do_service_parameter(struct loadparm_context *lp_ctx,
+			     struct loadparm_service *service,
+			     const char *pszParmName, const char *pszParmValue);
+
+/**
+ * Process a parameter.
+ */
+bool lp_do_global_parameter_var(struct loadparm_context *lp_ctx,
+				const char *pszParmName, const char *fmt, ...);
+bool lp_set_cmdline(struct loadparm_context *lp_ctx, const char *pszParmName,
+		    const char *pszParmValue);
+bool lp_set_option(struct loadparm_context *lp_ctx, const char *option);
+
+/**
+ * Display the contents of a single services record.
+ */
+bool lp_dump_a_parameter(struct loadparm_context *lp_ctx,
+			 struct loadparm_service *service,
+			 const char *parm_name, FILE * f);
+
+/**
+ * Return info about the next service  in a service. snum==-1 gives the globals.
+ * Return NULL when out of parameters.
+ */
+struct parm_struct *lp_next_parameter(struct loadparm_context *lp_ctx, int snum, int *i, 
+				      int allparameters);
+
+/**
+ * Unload unused services.
+ */
+void lp_killunused(struct loadparm_context *lp_ctx,
+		   struct smbsrv_connection *smb,
+		   bool (*snumused) (struct smbsrv_connection *, int));
+
+/**
+ * Initialise the global parameter structure.
+ */
+struct loadparm_context *loadparm_init(TALLOC_CTX *mem_ctx);
+const char *lp_configfile(struct loadparm_context *lp_ctx);
+bool lp_load_default(struct loadparm_context *lp_ctx);
+const char *lp_default_path(void);
+
+/**
+ * Load the services array from the services file.
+ *
+ * Return True on success, False on failure.
+ */
+bool lp_load(struct loadparm_context *lp_ctx, const char *filename);
+
+/**
+ * Return the max number of services.
+ */
+int lp_numservices(struct loadparm_context *lp_ctx);
+
+/**
+ * Display the contents of the services array in human-readable form.
+ */
+void lp_dump(struct loadparm_context *lp_ctx, FILE *f, bool show_defaults,
+	     int maxtoprint);
+
+/**
+ * Display the contents of one service in human-readable form.
+ */
+void lp_dump_one(FILE *f, bool show_defaults, struct loadparm_service *service, struct loadparm_service *sDefault);
+struct loadparm_service *lp_servicebynum(struct loadparm_context *lp_ctx,
+					 int snum);
+struct loadparm_service *lp_service(struct loadparm_context *lp_ctx,
+				    const char *service_name);
+
+/**
+ * A useful volume label function.
+ */
+const char *volume_label(struct loadparm_service *service, struct loadparm_service *sDefault);
+
+/**
+ * If we are PDC then prefer us as DMB
+ */
+const char *lp_printername(struct loadparm_service *service, struct loadparm_service *sDefault);
+
+/**
+ * Return the max print jobs per queue.
+ */
+int lp_maxprintjobs(struct loadparm_service *service, struct loadparm_service *sDefault);
+struct smb_iconv_convenience *lp_iconv_convenience(struct loadparm_context *lp_ctx);
+void lp_smbcli_options(struct loadparm_context *lp_ctx,
+			 struct smbcli_options *options);
+void lp_smbcli_session_options(struct loadparm_context *lp_ctx,
+				 struct smbcli_session_options *options);
+struct dcerpc_server_info *lp_dcerpc_server_info(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx);
+struct gensec_settings *lp_gensec_settings(TALLOC_CTX *, struct loadparm_context *);
+
+
+/* The following definitions come from param/generic.c  */
+
+struct param_section *param_get_section(struct param_context *ctx, const char *name);
+struct param_opt *param_section_get(struct param_section *section, 
+				    const char *name);
+struct param_opt *param_get (struct param_context *ctx, const char *name, const char *section_name);
+struct param_section *param_add_section(struct param_context *ctx, const char *section_name);
+struct param_opt *param_get_add(struct param_context *ctx, const char *name, const char *section_name);
+const char *param_get_string(struct param_context *ctx, const char *param, const char *section);
+int param_set_string(struct param_context *ctx, const char *param, const char *value, const char *section);
+const char **param_get_string_list(struct param_context *ctx, const char *param, const char *separator, const char *section);
+int param_set_string_list(struct param_context *ctx, const char *param, const char **list, const char *section);
+int param_get_int(struct param_context *ctx, const char *param, int default_v, const char *section);
+void param_set_int(struct param_context *ctx, const char *param, int value, const char *section);
+unsigned long param_get_ulong(struct param_context *ctx, const char *param, unsigned long default_v, const char *section);
+void param_set_ulong(struct param_context *ctx, const char *name, unsigned long value, const char *section);
+struct param_context *param_init(TALLOC_CTX *mem_ctx);
+int param_read(struct param_context *ctx, const char *fn);
+int param_use(struct loadparm_context *lp_ctx, struct param_context *ctx);
+int param_write(struct param_context *ctx, const char *fn);
+
+/* The following definitions come from param/util.c  */
+
+
+/**
+ * @file
+ * @brief Misc utility functions
+ */
+bool lp_is_mydomain(struct loadparm_context *lp_ctx, 
+			     const char *domain);
+
+/**
+  see if a string matches either our primary or one of our secondary 
+  netbios aliases. do a case insensitive match
+*/
+bool lp_is_myname(struct loadparm_context *lp_ctx, const char *name);
+
+/**
+ A useful function for returning a path in the Samba lock directory.
+**/
+char *lock_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
+			 const char *name);
+
+/**
+ * @brief Returns an absolute path to a file in the directory containing the current config file
+ *
+ * @param name File to find, relative to the config file directory.
+ *
+ * @retval Pointer to a talloc'ed string containing the full path.
+ **/
+char *config_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
+			   const char *name);
+
+/**
+ * @brief Returns an absolute path to a file in the Samba private directory.
+ *
+ * @param name File to find, relative to PRIVATEDIR.
+ * if name is not relative, then use it as-is
+ *
+ * @retval Pointer to a talloc'ed string containing the full path.
+ **/
+char *private_path(TALLOC_CTX* mem_ctx, 
+			    struct loadparm_context *lp_ctx,
+			    const char *name);
+
+/**
+  return a path in the smbd.tmp directory, where all temporary file
+  for smbd go. If NULL is passed for name then return the directory 
+  path itself
+*/
+char *smbd_tmp_path(TALLOC_CTX *mem_ctx, 
+			     struct loadparm_context *lp_ctx, 
+			     const char *name);
+
+/**
+ * Obtain the init function from a shared library file
+ */
+init_module_fn load_module(TALLOC_CTX *mem_ctx, const char *path);
+
+/**
+ * Obtain list of init functions from the modules in the specified
+ * directory
+ */
+init_module_fn *load_modules(TALLOC_CTX *mem_ctx, const char *path);
+
+/**
+ * Run the specified init functions.
+ *
+ * @return true if all functions ran successfully, false otherwise
+ */
+bool run_init_functions(init_module_fn *fns);
+
+/**
+ * Load the initialization functions from DSO files for a specific subsystem.
+ *
+ * Will return an array of function pointers to initialization functions
+ */
+init_module_fn *load_samba_modules(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx, const char *subsystem);
+const char *lp_messaging_path(TALLOC_CTX *mem_ctx, 
+				       struct loadparm_context *lp_ctx);
+struct smb_iconv_convenience *smb_iconv_convenience_init_lp(TALLOC_CTX *mem_ctx,
+							 struct loadparm_context *lp_ctx);
+
+/* The following definitions come from lib/version.c  */
+
+const char *samba_version_string(void);
+
+
+#endif /* _PARAM_H */
diff --git a/source4/param/provision.c b/source4/param/provision.c
new file mode 100644
index 0000000000..c8bff59deb
--- /dev/null
+++ b/source4/param/provision.c
@@ -0,0 +1,143 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "auth/auth.h"
+#include "lib/ldb_wrap.h"
+#include "libcli/raw/libcliraw.h"
+#include "librpc/ndr/libndr.h"
+
+#include "param/param.h"
+#include "param/provision.h"
+#include <Python.h>
+#include "scripting/python/modules.h"
+#include "lib/ldb/pyldb.h"
+#include "param/pyparam.h"
+
+NTSTATUS provision_bare(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx,
+			struct provision_settings *settings, 
+			struct provision_result *result)
+{
+	char *configfile;
+	PyObject *provision_mod, *provision_dict, *provision_fn, *py_result, *parameters;
+	
+	DEBUG(0,("Provision for Become-DC test using python\n"));
+
+	py_load_samba_modules();
+	Py_Initialize();
+	py_update_path("bin"); /* FIXME: Can't assume this is always the case */
+
+	provision_mod = PyImport_Import(PyString_FromString("samba.provision"));
+
+	if (provision_mod == NULL) {
+		PyErr_Print();
+		DEBUG(0, ("Unable to import provision Python module.\n"));
+	      	return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	provision_dict = PyModule_GetDict(provision_mod);
+
+	if (provision_dict == NULL) {
+		DEBUG(0, ("Unable to get dictionary for provision module\n"));
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	provision_fn = PyDict_GetItemString(provision_dict, "provision_become_dc");
+	if (provision_fn == NULL) {
+		PyErr_Print();
+		DEBUG(0, ("Unable to get provision_become_dc function\n"));
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+	
+	DEBUG(0,("New Server in Site[%s]\n", 
+		 settings->site_name));
+
+	DEBUG(0,("DSA Instance [%s]\n"
+		"\tinvocationId[%s]\n",
+		settings->ntds_dn_str,
+		settings->invocation_id == NULL?"None":GUID_string(mem_ctx, settings->invocation_id)));
+
+	DEBUG(0,("Pathes under targetdir[%s]\n",
+		 settings->targetdir));
+	parameters = PyDict_New();
+
+	configfile = lp_configfile(lp_ctx);
+	if (configfile != NULL) {
+		PyDict_SetItemString(parameters, "smbconf", 
+				     PyString_FromString(configfile));
+	}
+
+	PyDict_SetItemString(parameters, "rootdn", 
+						 PyString_FromString(settings->root_dn_str));
+	if (settings->targetdir != NULL)
+		PyDict_SetItemString(parameters, "targetdir", 
+							 PyString_FromString(settings->targetdir));
+	PyDict_SetItemString(parameters, "setup_dir", 
+			     PyString_FromString("setup"));
+	PyDict_SetItemString(parameters, "hostname", 
+						 PyString_FromString(settings->netbios_name));
+	PyDict_SetItemString(parameters, "domain", 
+						 PyString_FromString(settings->domain));
+	PyDict_SetItemString(parameters, "realm", 
+						 PyString_FromString(settings->realm));
+	if (settings->root_dn_str)
+		PyDict_SetItemString(parameters, "rootdn", 
+				     PyString_FromString(settings->root_dn_str));
+
+	if (settings->domain_dn_str) 
+		PyDict_SetItemString(parameters, "domaindn", 
+				     PyString_FromString(settings->domain_dn_str));
+
+	if (settings->schema_dn_str) 
+		PyDict_SetItemString(parameters, "schemadn", 
+				     PyString_FromString(settings->schema_dn_str));
+	
+	if (settings->config_dn_str) 
+		PyDict_SetItemString(parameters, "configdn", 
+				     PyString_FromString(settings->config_dn_str));
+	
+	if (settings->server_dn_str) 
+		PyDict_SetItemString(parameters, "serverdn", 
+				     PyString_FromString(settings->server_dn_str));
+	
+	if (settings->site_name) 
+		PyDict_SetItemString(parameters, "sitename", 
+				     PyString_FromString(settings->site_name));
+
+	PyDict_SetItemString(parameters, "machinepass", 
+			     PyString_FromString(settings->machine_password));
+
+	py_result = PyEval_CallObjectWithKeywords(provision_fn, NULL, parameters);
+
+	Py_DECREF(parameters);
+
+	if (py_result == NULL) {
+		PyErr_Print();
+		PyErr_Clear();
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	result->domaindn = talloc_strdup(mem_ctx, PyString_AsString(PyObject_GetAttrString(py_result, "domaindn")));
+
+	/* FIXME paths */
+	result->lp_ctx = lp_from_py_object(PyObject_GetAttrString(py_result, "lp"));
+	result->samdb = PyLdb_AsLdbContext(PyObject_GetAttrString(py_result, "samdb"));
+
+	return NT_STATUS_OK;
+}
diff --git a/source4/param/provision.h b/source4/param/provision.h
new file mode 100644
index 0000000000..af9685d292
--- /dev/null
+++ b/source4/param/provision.h
@@ -0,0 +1,51 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _PROVISION_H_
+#define _PROVISION_H_
+
+struct provision_settings {
+	const char *site_name;
+	const char *root_dn_str; 
+	const char *domain_dn_str;
+	const char *config_dn_str;
+	const char *schema_dn_str;
+	const char *server_dn_str;
+	const struct GUID *invocation_id;
+	const char *netbios_name;
+	const char *host_ip;
+	const char *realm;
+	const char *domain;
+	const char *ntds_dn_str;
+	const char *machine_password;
+	const char *targetdir;
+};
+
+/* FIXME: Rename this to hostconfig ? */
+struct provision_result {
+	const char *domaindn;
+        struct ldb_context *samdb;
+        struct loadparm_context *lp_ctx;
+};
+
+NTSTATUS provision_bare(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx,
+						struct provision_settings *settings,
+						struct provision_result *result);
+
+#endif /* _PROVISION_H_ */
diff --git a/source4/param/pyparam.c b/source4/param/pyparam.c
new file mode 100644
index 0000000000..efaedf7b41
--- /dev/null
+++ b/source4/param/pyparam.c
@@ -0,0 +1,385 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007-2008
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "includes.h"
+#include "param/param.h"
+#include "param/loadparm.h"
+#include <Python.h>
+#include "pytalloc.h"
+
+/* There's no Py_ssize_t in 2.4, apparently */
+#if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 5
+typedef int Py_ssize_t;
+typedef inquiry lenfunc;
+#endif
+
+#ifndef Py_RETURN_NONE
+#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
+#endif
+
+#define PyLoadparmContext_AsLoadparmContext(obj) py_talloc_get_type(obj, struct loadparm_context)
+
+PyAPI_DATA(PyTypeObject) PyLoadparmContext;
+PyAPI_DATA(PyTypeObject) PyLoadparmService;
+
+PyObject *PyLoadparmService_FromService(struct loadparm_service *service)
+{
+	return py_talloc_import(&PyLoadparmService, service);
+}
+
+static PyObject *py_lp_ctx_get_helper(struct loadparm_context *lp_ctx, const char *service_name, const char *param_name)
+{
+    struct parm_struct *parm = NULL;
+    void *parm_ptr = NULL;
+    int i;
+
+    if (service_name != NULL) {
+	struct loadparm_service *service;
+	/* its a share parameter */
+	service = lp_service(lp_ctx, service_name);
+	if (service == NULL) {
+	    return NULL;
+	}
+	if (strchr(param_name, ':')) {
+	    /* its a parametric option on a share */
+	    const char *type = talloc_strndup(lp_ctx, 
+			      param_name, 
+			      strcspn(param_name, ":"));
+	    const char *option = strchr(param_name, ':') + 1;
+	    const char *value;
+	    if (type == NULL || option == NULL) {
+		return NULL;
+	    }
+	    value = lp_get_parametric(lp_ctx, service, type, option);
+	    if (value == NULL) {
+		return NULL;
+	    }
+	    return PyString_FromString(value);
+	}
+
+	parm = lp_parm_struct(param_name);
+	if (parm == NULL || parm->pclass == P_GLOBAL) {
+	    return NULL;
+	}
+	parm_ptr = lp_parm_ptr(lp_ctx, service, parm);
+    } else if (strchr(param_name, ':')) {
+	/* its a global parametric option */
+	const char *type = talloc_strndup(lp_ctx, 
+			  param_name, strcspn(param_name, ":"));
+	const char *option = strchr(param_name, ':') + 1;
+	const char *value;
+	if (type == NULL || option == NULL) {
+	    return NULL;
+	}
+	value = lp_get_parametric(lp_ctx, NULL, type, option);
+	if (value == NULL)
+	    return NULL;
+	return PyString_FromString(value);
+    } else {
+	/* its a global parameter */
+	parm = lp_parm_struct(param_name);
+	if (parm == NULL) {
+	    return NULL;
+	}
+	parm_ptr = lp_parm_ptr(lp_ctx, NULL, parm);
+    }
+
+    if (parm == NULL || parm_ptr == NULL) {
+	return NULL;
+    }
+
+    /* construct and return the right type of python object */
+    switch (parm->type) {
+    case P_STRING:
+    case P_USTRING:
+	return PyString_FromString(*(char **)parm_ptr);
+    case P_BOOL:
+	return PyBool_FromLong(*(bool *)parm_ptr);
+    case P_INTEGER:
+    case P_OCTAL:
+    case P_BYTES:
+	return PyLong_FromLong(*(int *)parm_ptr);
+    case P_ENUM:
+	for (i=0; parm->enum_list[i].name; i++) {
+	    if (*(int *)parm_ptr == parm->enum_list[i].value) {
+		return PyString_FromString(parm->enum_list[i].name);
+	    }
+	}
+	return NULL;
+    case P_LIST: 
+	{
+	    int j;
+	    const char **strlist = *(const char ***)parm_ptr;
+	    PyObject *pylist = PyList_New(str_list_length(strlist));
+	    for (j = 0; strlist[j]; j++) 
+		PyList_SetItem(pylist, j, 
+			       PyString_FromString(strlist[j]));
+	    return pylist;
+	}
+
+	break;
+    }
+    return NULL;
+
+}
+
+static PyObject *py_lp_ctx_load(py_talloc_Object *self, PyObject *args)
+{
+	char *filename;
+	bool ret;
+	if (!PyArg_ParseTuple(args, "s", &filename))
+		return NULL;
+
+	ret = lp_load(PyLoadparmContext_AsLoadparmContext(self), filename);
+
+	if (!ret) {
+		PyErr_Format(PyExc_RuntimeError, "Unable to load file %s", filename);
+		return NULL;
+	}
+	Py_RETURN_NONE;
+}
+
+static PyObject *py_lp_ctx_load_default(py_talloc_Object *self)
+{
+	bool ret;
+        ret = lp_load_default(PyLoadparmContext_AsLoadparmContext(self));
+
+	if (!ret) {
+		PyErr_SetString(PyExc_RuntimeError, "Unable to load default file");
+		return NULL;
+	}
+	Py_RETURN_NONE;
+}
+
+static PyObject *py_lp_ctx_get(py_talloc_Object *self, PyObject *args)
+{
+	char *param_name;
+	char *section_name = NULL;
+	PyObject *ret;
+	if (!PyArg_ParseTuple(args, "s|s", &param_name, &section_name))
+		return NULL;
+
+	ret = py_lp_ctx_get_helper(PyLoadparmContext_AsLoadparmContext(self), section_name, param_name);
+	if (ret == NULL)
+		Py_RETURN_NONE;
+	return ret;
+}
+
+static PyObject *py_lp_ctx_is_myname(py_talloc_Object *self, PyObject *args)
+{
+	char *name;
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return NULL;
+
+	return PyBool_FromLong(lp_is_myname(PyLoadparmContext_AsLoadparmContext(self), name));
+}
+
+static PyObject *py_lp_ctx_is_mydomain(py_talloc_Object *self, PyObject *args)
+{
+	char *name;
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return NULL;
+
+	return PyBool_FromLong(lp_is_mydomain(PyLoadparmContext_AsLoadparmContext(self), name));
+}
+
+static PyObject *py_lp_ctx_set(py_talloc_Object *self, PyObject *args)
+{
+	char *name, *value;
+	bool ret;
+	if (!PyArg_ParseTuple(args, "ss", &name, &value))
+		return NULL;
+
+	ret = lp_set_cmdline(PyLoadparmContext_AsLoadparmContext(self), name, value);
+	if (!ret) {
+		PyErr_SetString(PyExc_RuntimeError, "Unable to set parameter");
+		return NULL;
+        }
+
+	Py_RETURN_NONE;
+}
+
+static PyObject *py_lp_ctx_private_path(py_talloc_Object *self, PyObject *args)
+{
+	char *name, *path;
+	PyObject *ret;
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return NULL;
+
+	path = private_path(NULL, PyLoadparmContext_AsLoadparmContext(self), name);
+	ret = PyString_FromString(path);
+	talloc_free(path);
+
+	return ret;
+}
+
+static PyMethodDef py_lp_ctx_methods[] = {
+	{ "load", (PyCFunction)py_lp_ctx_load, METH_VARARGS, 
+		"S.load(filename) -> None\n"
+		"Load specified file." },
+	{ "load_default", (PyCFunction)py_lp_ctx_load_default, METH_NOARGS,
+        	"S.load_default() -> None\n"
+		"Load default smb.conf file." },
+	{ "is_myname", (PyCFunction)py_lp_ctx_is_myname, METH_VARARGS,
+		"S.is_myname(name) -> bool\n"
+		"Check whether the specified name matches one of our netbios names." },
+	{ "is_mydomain", (PyCFunction)py_lp_ctx_is_mydomain, METH_VARARGS,
+		"S.is_mydomain(name) -> bool\n"
+		"Check whether the specified name matches our domain name." },
+	{ "get", (PyCFunction)py_lp_ctx_get, METH_VARARGS,
+        	"S.get(name, service_name) -> value\n"
+		"Find specified parameter." },
+	{ "set", (PyCFunction)py_lp_ctx_set, METH_VARARGS,
+		"S.set(name, value) -> bool\n"
+		"Change a parameter." },
+	{ "private_path", (PyCFunction)py_lp_ctx_private_path, METH_VARARGS,
+		"S.private_path(name) -> path\n" },
+	{ NULL }
+};
+
+static PyObject *py_lp_ctx_default_service(py_talloc_Object *self, void *closure)
+{
+	return PyLoadparmService_FromService(lp_default_service(PyLoadparmContext_AsLoadparmContext(self)));
+}
+
+static PyObject *py_lp_ctx_config_file(py_talloc_Object *self, void *closure)
+{
+	const char *configfile = lp_configfile(PyLoadparmContext_AsLoadparmContext(self));
+	if (configfile == NULL)
+		Py_RETURN_NONE;
+	else
+		return PyString_FromString(configfile);
+}
+
+static PyGetSetDef py_lp_ctx_getset[] = {
+	{ discard_const_p(char, "default_service"), (getter)py_lp_ctx_default_service, NULL, NULL },
+	{ discard_const_p(char, "configfile"), (getter)py_lp_ctx_config_file, NULL,
+	  discard_const_p(char, "Name of last config file that was loaded.") },
+	{ NULL }
+};
+
+static PyObject *py_lp_ctx_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+	return py_talloc_import(type, loadparm_init(NULL));
+}
+
+static Py_ssize_t py_lp_ctx_len(py_talloc_Object *self)
+{
+	return lp_numservices(PyLoadparmContext_AsLoadparmContext(self));
+}
+
+static PyObject *py_lp_ctx_getitem(py_talloc_Object *self, PyObject *name)
+{
+	struct loadparm_service *service;
+	if (!PyString_Check(name)) {
+		PyErr_SetString(PyExc_TypeError, "Only string subscripts are supported");
+		return NULL;
+	}
+	service = lp_service(PyLoadparmContext_AsLoadparmContext(self), PyString_AsString(name));
+	if (service == NULL) {
+		PyErr_SetString(PyExc_KeyError, "No such section");
+		return NULL;
+	}
+	return PyLoadparmService_FromService(service);
+}
+
+static PyMappingMethods py_lp_ctx_mapping = {
+	.mp_length = (lenfunc)py_lp_ctx_len,
+	.mp_subscript = (binaryfunc)py_lp_ctx_getitem,
+};
+
+PyTypeObject PyLoadparmContext = {
+	.tp_name = "LoadParm",
+	.tp_basicsize = sizeof(py_talloc_Object),
+	.tp_dealloc = py_talloc_dealloc,
+	.tp_getset = py_lp_ctx_getset,
+	.tp_methods = py_lp_ctx_methods,
+	.tp_new = py_lp_ctx_new,
+	.tp_as_mapping = &py_lp_ctx_mapping,
+	.tp_flags = Py_TPFLAGS_DEFAULT,
+};
+
+PyTypeObject PyLoadparmService = {
+	.tp_name = "LoadparmService",
+	.tp_dealloc = py_talloc_dealloc,
+	.tp_basicsize = sizeof(py_talloc_Object),
+	.tp_flags = Py_TPFLAGS_DEFAULT,
+};
+
+_PUBLIC_ struct loadparm_context *lp_from_py_object(PyObject *py_obj)
+{
+    struct loadparm_context *lp_ctx;
+    if (PyString_Check(py_obj)) {
+        lp_ctx = loadparm_init(NULL);
+        if (!lp_load(lp_ctx, PyString_AsString(py_obj))) {
+            talloc_free(lp_ctx);
+	    PyErr_Format(PyExc_RuntimeError, 
+			 "Unable to load %s", PyString_AsString(py_obj));
+            return NULL;
+        }
+        return lp_ctx;
+    }
+
+    if (py_obj == Py_None) {
+        lp_ctx = loadparm_init(NULL);
+	/* We're not checking that loading the file succeeded *on purpose */
+        lp_load_default(lp_ctx);
+        return lp_ctx;
+    }
+
+    return PyLoadparmContext_AsLoadparmContext(py_obj);
+}
+
+struct loadparm_context *py_default_loadparm_context(TALLOC_CTX *mem_ctx)
+{
+    struct loadparm_context *ret;
+    ret = loadparm_init(mem_ctx);
+    if (!lp_load_default(ret))
+        return NULL;
+    return ret;
+}
+
+static PyObject *py_default_path(PyObject *self)
+{
+    return PyString_FromString(lp_default_path());
+}
+
+static PyMethodDef pyparam_methods[] = {
+    { "default_path", (PyCFunction)py_default_path, METH_NOARGS, 
+        "Returns the default smb.conf path." },
+    { NULL }
+};
+
+void initparam(void)
+{
+	PyObject *m;
+
+	if (PyType_Ready(&PyLoadparmContext) < 0)
+		return;
+
+	m = Py_InitModule3("param", pyparam_methods, "Parsing and writing Samba configuration files.");
+	if (m == NULL)
+		return;
+
+	Py_INCREF(&PyLoadparmContext);
+	PyModule_AddObject(m, "LoadParm", (PyObject *)&PyLoadparmContext);
+}
diff --git a/source4/param/pyparam.h b/source4/param/pyparam.h
new file mode 100644
index 0000000000..1cda8f1dba
--- /dev/null
+++ b/source4/param/pyparam.h
@@ -0,0 +1,25 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _PYPARAM_H_
+#define _PYPARAM_H_
+
+_PUBLIC_ struct loadparm_context *lp_from_py_object(PyObject *py_obj);
+
+#endif /* _PYPARAM_H_ */
diff --git a/source4/param/samba-hostconfig.pc.in b/source4/param/samba-hostconfig.pc.in
new file mode 100644
index 0000000000..b8ba24096d
--- /dev/null
+++ b/source4/param/samba-hostconfig.pc.in
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: samba-hostconfig
+Description: Host-wide Samba configuration
+Version: 0.0.1
+Libs: -L${libdir} -lsamba-hostconfig 
+Cflags: -I${includedir}  -DHAVE_IMMEDIATE_STRUCTURES=1
diff --git a/source4/param/secrets.c b/source4/param/secrets.c
new file mode 100644
index 0000000000..6c6f7c28f0
--- /dev/null
+++ b/source4/param/secrets.c
@@ -0,0 +1,196 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Copyright (C) Andrew Tridgell 1992-2001
+   Copyright (C) Andrew Bartlett      2002
+   Copyright (C) Rafal Szczesniak     2002
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* the Samba secrets database stores any generated, private information
+   such as the local SID and machine trust password */
+
+#include "includes.h"
+#include "secrets.h"
+#include "param/param.h"
+#include "system/filesys.h"
+#include "tdb_wrap.h"
+#include "lib/ldb/include/ldb.h"
+#include "../tdb/include/tdb.h"
+#include "../lib/util/util_tdb.h"
+#include "../lib/util/util_ldb.h"
+#include "librpc/gen_ndr/ndr_security.h"
+
+/**
+ * Use a TDB to store an incrementing random seed.
+ *
+ * Initialised to the current pid, the very first time Samba starts,
+ * and incremented by one each time it is needed.  
+ * 
+ * @note Not called by systems with a working /dev/urandom.
+ */
+static void get_rand_seed(struct tdb_wrap *secretsdb, int *new_seed) 
+{
+	*new_seed = getpid();
+	if (secretsdb != NULL) {
+		tdb_change_int32_atomic(secretsdb->tdb, "INFO/random_seed", new_seed, 1);
+	}
+}
+
+/**
+ * open up the secrets database
+ */
+struct tdb_wrap *secrets_init(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx)
+{
+	char *fname;
+	uint8_t dummy;
+	struct tdb_wrap *tdb;
+
+	fname = private_path(mem_ctx, lp_ctx, "secrets.tdb");
+
+	tdb = tdb_wrap_open(mem_ctx, fname, 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
+
+	if (!tdb) {
+		DEBUG(0,("Failed to open %s\n", fname));
+		talloc_free(fname);
+		return NULL;
+	}
+	talloc_free(fname);
+
+	/**
+	 * Set a reseed function for the crypto random generator 
+	 * 
+	 * This avoids a problem where systems without /dev/urandom
+	 * could send the same challenge to multiple clients
+	 */
+	set_rand_reseed_callback((void (*) (void *, int *))get_rand_seed, tdb);
+
+	/* Ensure that the reseed is done now, while we are root, etc */
+	generate_random_buffer(&dummy, sizeof(dummy));
+
+	return tdb;
+}
+
+/**
+  connect to the secrets ldb
+*/
+struct ldb_context *secrets_db_connect(TALLOC_CTX *mem_ctx,
+					struct tevent_context *ev_ctx,
+					struct loadparm_context *lp_ctx)
+{
+	char *path;
+	const char *url;
+	struct ldb_context *ldb;
+
+	url = lp_secrets_url(lp_ctx);
+	if (!url || !url[0]) {
+		return NULL;
+	}
+
+	path = private_path(mem_ctx, lp_ctx, url);
+	if (!path) {
+		return NULL;
+	}
+
+	/* Secrets.ldb *must* always be local.  If we call for a
+	 * system_session() we will recurse */
+	ldb = ldb_init(mem_ctx, ev_ctx);
+	if (!ldb) {
+		talloc_free(path);
+		return NULL;
+	}
+
+	ldb_set_modules_dir(ldb, 
+			    talloc_asprintf(ldb, "%s/ldb", lp_modulesdir(lp_ctx)));
+
+	if (ldb_connect(ldb, path, 0, NULL) != 0) {
+		talloc_free(path);
+		return NULL;
+	}
+
+	talloc_free(path);
+	
+	return ldb;
+}
+
+/**
+ * Retrieve the domain SID from the secrets database.
+ * @return pointer to a SID object if the SID could be obtained, NULL otherwise
+ */
+struct dom_sid *secrets_get_domain_sid(TALLOC_CTX *mem_ctx,
+				       struct tevent_context *ev_ctx,
+				       struct loadparm_context *lp_ctx,
+				       const char *domain)
+{
+	struct ldb_context *ldb;
+	struct ldb_message **msgs;
+	int ldb_ret;
+	const char *attrs[] = { "objectSid", NULL };
+	struct dom_sid *result = NULL;
+	const struct ldb_val *v;
+	enum ndr_err_code ndr_err;
+
+	ldb = secrets_db_connect(mem_ctx, ev_ctx, lp_ctx);
+	if (ldb == NULL) {
+		DEBUG(5, ("secrets_db_connect failed\n"));
+		return NULL;
+	}
+
+	ldb_ret = gendb_search(ldb, ldb,
+			       ldb_dn_new(mem_ctx, ldb, SECRETS_PRIMARY_DOMAIN_DN), 
+			       &msgs, attrs,
+			       SECRETS_PRIMARY_DOMAIN_FILTER, domain);
+
+	if (ldb_ret == -1) {
+		DEBUG(5, ("Error searching for domain SID for %s: %s", 
+			  domain, ldb_errstring(ldb))); 
+		talloc_free(ldb);
+		return NULL;
+	}
+
+	if (ldb_ret == 0) {
+		DEBUG(5, ("Did not find domain record for %s\n", domain));
+		talloc_free(ldb);
+		return NULL;
+	}
+
+	if (ldb_ret > 1) {
+		DEBUG(5, ("Found more than one (%d) domain records for %s\n",
+			  ldb_ret, domain));
+		talloc_free(ldb);
+		return NULL;
+	}
+
+	v = ldb_msg_find_ldb_val(msgs[0], "objectSid");
+	if (v == NULL) {
+		DEBUG(0, ("Domain object for %s does not contain a SID!\n",
+			  domain));
+		return NULL;
+	}
+	result = talloc(mem_ctx, struct dom_sid);
+	if (result == NULL) {
+		talloc_free(ldb);
+		return NULL;
+	}
+
+	ndr_err = ndr_pull_struct_blob(v, result, NULL, result,
+				       (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		talloc_free(result);
+		talloc_free(ldb);
+		return NULL;
+	}
+
+	return result;
+}
diff --git a/source4/param/secrets.h b/source4/param/secrets.h
new file mode 100644
index 0000000000..743cf684a9
--- /dev/null
+++ b/source4/param/secrets.h
@@ -0,0 +1,46 @@
+/*
+ * Unix SMB/CIFS implementation. 
+ * secrets.tdb file format info
+ * Copyright (C) Andrew Tridgell              2000
+ * 
+ * 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 3 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program 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 General Public License for
+ * more details.
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, see <http://www.gnu.org/licenses/>.  
+ */
+
+#ifndef _SECRETS_H
+#define _SECRETS_H
+
+#define SECRETS_PRIMARY_DOMAIN_DN "cn=Primary Domains"
+#define SECRETS_PRINCIPALS_DN "cn=Principals"
+#define SECRETS_PRIMARY_DOMAIN_FILTER "(&(flatname=%s)(objectclass=primaryDomain))"
+#define SECRETS_PRIMARY_REALM_FILTER "(&(realm=%s)(objectclass=primaryDomain))"
+#define SECRETS_KRBTGT_SEARCH "(&((|(realm=%s)(flatname=%s))(samAccountName=krbtgt)))"
+#define SECRETS_PRINCIPAL_SEARCH "(&(|(realm=%s)(flatname=%s))(servicePrincipalName=%s))"
+#define SECRETS_LDAP_FILTER "(objectclass=ldapSecret)"
+
+/**
+ * Use a TDB to store an incrementing random seed.
+ *
+ * Initialised to the current pid, the very first time Samba starts,
+ * and incremented by one each time it is needed.  
+ * 
+ * @note Not called by systems with a working /dev/urandom.
+ */
+struct loadparm_context;
+struct tevent_context;
+struct tdb_wrap *secrets_init(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx);
+struct ldb_context *secrets_db_connect(TALLOC_CTX *mem_ctx, struct tevent_context *ev_ctx, struct loadparm_context *lp_ctx);
+struct dom_sid *secrets_get_domain_sid(TALLOC_CTX *mem_ctx, struct tevent_context *ev_ctx, struct loadparm_context *lp_ctx, const char *domain);
+
+
+#endif /* _SECRETS_H */
diff --git a/source4/param/share.c b/source4/param/share.c
new file mode 100644
index 0000000000..13d591ec1b
--- /dev/null
+++ b/source4/param/share.c
@@ -0,0 +1,156 @@
+/* 
+   Unix SMB/CIFS implementation.
+   
+   Modular shares configuration system
+   
+   Copyright (C) Simo Sorce	2006
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "param/share.h"
+#include "param/param.h"
+
+const char *share_string_option(struct share_config *scfg, const char *opt_name, const char *defval)
+{
+	return scfg->ctx->ops->string_option(scfg, opt_name, defval);
+}
+
+int share_int_option(struct share_config *scfg, const char *opt_name, int defval)
+{
+	return scfg->ctx->ops->int_option(scfg, opt_name, defval);
+}
+
+bool share_bool_option(struct share_config *scfg, const char *opt_name, bool defval)
+{
+	return scfg->ctx->ops->bool_option(scfg, opt_name, defval);
+}
+
+const char **share_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
+{
+	return scfg->ctx->ops->string_list_option(mem_ctx, scfg, opt_name);
+}
+
+NTSTATUS share_list_all(TALLOC_CTX *mem_ctx, struct share_context *sctx, int *count, const char ***names)
+{
+	return sctx->ops->list_all(mem_ctx, sctx, count, names);
+}
+
+NTSTATUS share_get_config(TALLOC_CTX *mem_ctx, struct share_context *sctx, const char *name, struct share_config **scfg)
+{
+	return sctx->ops->get_config(mem_ctx, sctx, name, scfg);
+}
+
+NTSTATUS share_create(struct share_context *sctx, const char *name, struct share_info *info, int count)
+{
+	if (sctx->ops->create) {
+		return sctx->ops->create(sctx, name, info, count);
+	}
+	return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+NTSTATUS share_set(struct share_context *sctx, const char *name, struct share_info *info, int count)
+{
+	if (sctx->ops->set) {
+		return sctx->ops->set(sctx, name, info, count);
+	}
+	return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+NTSTATUS share_remove(struct share_context *sctx, const char *name)
+{
+	if (sctx->ops->remove) {
+		return sctx->ops->remove(sctx, name);
+	}
+	return NT_STATUS_NOT_IMPLEMENTED;
+}
+
+/* List of currently available share backends */
+static struct share_ops **backends = NULL;
+
+static const struct share_ops *share_backend_by_name(const char *name)
+{
+	int i;
+
+	for (i = 0; backends && backends[i]; i++) {
+		if (strcmp(backends[i]->name, name) == 0) {
+			return backends[i];
+		}
+	}
+
+	return NULL;
+}
+
+/*
+  Register the share backend
+*/
+NTSTATUS share_register(const struct share_ops *ops)
+{
+	int i;
+
+	if (share_backend_by_name(ops->name) != NULL) {
+		DEBUG(0,("SHARE backend [%s] already registered\n", ops->name));
+		return NT_STATUS_OBJECT_NAME_COLLISION;
+	}
+
+	i = 0;
+	while (backends && backends[i]) {
+		i++;
+	}
+
+	backends = realloc_p(backends, struct share_ops *, i + 2);
+	if (!backends) {
+		smb_panic("out of memory in share_register");
+	}
+
+	backends[i] = (struct share_ops *)smb_xmemdup(ops, sizeof(*ops));
+	backends[i]->name = smb_xstrdup(ops->name);
+
+	backends[i + 1] = NULL;
+
+	DEBUG(3, ("SHARE backend [%s] registered.\n", ops->name));
+
+	return NT_STATUS_OK;
+}
+
+NTSTATUS share_get_context_by_name(TALLOC_CTX *mem_ctx, const char *backend_name,
+				   struct tevent_context *event_ctx, 
+				   struct loadparm_context *lp_ctx,
+				   struct share_context **ctx)
+{
+	const struct share_ops *ops;
+
+	ops = share_backend_by_name(backend_name);
+	if (!ops) {
+		DEBUG(0, ("share_init_connection: share backend [%s] not found!\n", backend_name));
+		return NT_STATUS_INTERNAL_ERROR;
+	}
+
+	return ops->init(mem_ctx, ops, event_ctx, lp_ctx, ctx);
+}
+
+/*
+  initialise the SHARE subsystem
+*/
+NTSTATUS share_init(void)
+{
+	extern NTSTATUS share_ldb_init(void);
+	extern NTSTATUS share_classic_init(void);
+	init_module_fn static_init[] = { STATIC_share_MODULES };
+
+	run_init_functions(static_init);
+
+	return NT_STATUS_OK;
+}
diff --git a/source4/param/share.h b/source4/param/share.h
new file mode 100644
index 0000000000..755d19e337
--- /dev/null
+++ b/source4/param/share.h
@@ -0,0 +1,137 @@
+/* 
+   Unix SMB/CIFS implementation.
+   
+   Modular services configuration
+   
+   Copyright (C) Simo Sorce	2006
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _SHARE_H
+#define _SHARE_H
+
+struct share_ops;
+
+struct share_context {
+	const struct share_ops *ops;
+	void *priv_data;
+};
+
+struct share_config {
+	const char *name;
+	struct share_context *ctx;
+	void *opaque;
+};
+
+enum share_info_type {
+	SHARE_INFO_STRING,
+	SHARE_INFO_INT,
+	SHARE_INFO_BLOB
+};
+
+struct share_info {
+	enum share_info_type type;
+	const char *name;
+	void *value;
+};
+
+struct tevent_context;
+
+struct share_ops {
+	const char *name;
+	NTSTATUS (*init)(TALLOC_CTX *, const struct share_ops*, struct tevent_context *ev_ctx,
+			 struct loadparm_context *lp_ctx,
+			 struct share_context **);
+	const char *(*string_option)(struct share_config *, const char *, const char *);
+	int (*int_option)(struct share_config *, const char *, int);
+	bool (*bool_option)(struct share_config *, const char *, bool);
+	const char **(*string_list_option)(TALLOC_CTX *, struct share_config *, const char *);
+	NTSTATUS (*list_all)(TALLOC_CTX *, struct share_context *, int *, const char ***);
+	NTSTATUS (*get_config)(TALLOC_CTX *, struct share_context *, const char *, struct share_config **);
+	NTSTATUS (*create)(struct share_context *, const char *, struct share_info *, int);
+	NTSTATUS (*set)(struct share_context *, const char *, struct share_info *, int);
+	NTSTATUS (*remove)(struct share_context *, const char *);
+};
+
+struct loadparm_context;
+
+#include "param/share_proto.h"
+
+/* list of shares options */
+
+#define SHARE_NAME		"name"
+#define SHARE_PATH		"path"
+#define SHARE_COMMENT		"comment"
+#define SHARE_PASSWORD		"password"
+#define SHARE_HOSTS_ALLOW	"hosts-allow"
+#define SHARE_HOSTS_DENY	"hosts-deny"
+#define SHARE_NTVFS_HANDLER	"ntvfs-handler"
+#define SHARE_TYPE		"type"
+#define SHARE_VOLUME		"volume"
+#define SHARE_CSC_POLICY	"csc-policy"
+#define SHARE_AVAILABLE		"available"
+#define SHARE_BROWSEABLE	"browseable"
+#define SHARE_MAX_CONNECTIONS	"max-connections"
+
+/* I'd like to see the following options go away
+ * and always use EAs and SECDESCs */
+#define SHARE_READONLY		"readonly"
+#define SHARE_MAP_SYSTEM	"map-system"
+#define SHARE_MAP_HIDDEN	"map-hidden"
+#define SHARE_MAP_ARCHIVE	"map-archive"
+
+#define SHARE_STRICT_LOCKING	"strict-locking"
+#define SHARE_OPLOCKS	        "oplocks"
+#define SHARE_STRICT_SYNC	"strict-sync"
+#define SHARE_MSDFS_ROOT	"msdfs-root"
+#define SHARE_CI_FILESYSTEM	"ci-filesystem"
+
+#define SHARE_DIR_MASK             "directory mask"
+#define SHARE_CREATE_MASK          "create mask"
+#define SHARE_FORCE_CREATE_MODE    "force create mode"
+#define SHARE_FORCE_DIR_MODE       "force directory mode"
+
+/* defaults */
+
+#define SHARE_HOST_ALLOW_DEFAULT	NULL
+#define SHARE_HOST_DENY_DEFAULT		NULL
+#define SHARE_VOLUME_DEFAULT		NULL
+#define SHARE_TYPE_DEFAULT		"DISK"	
+#define SHARE_CSC_POLICY_DEFAULT	0
+#define SHARE_AVAILABLE_DEFAULT		true
+#define SHARE_BROWSEABLE_DEFAULT	true
+#define SHARE_MAX_CONNECTIONS_DEFAULT	0
+
+#define SHARE_DIR_MASK_DEFAULT                   0755
+#define SHARE_CREATE_MASK_DEFAULT                0744
+#define SHARE_FORCE_CREATE_MODE_DEFAULT          0000
+#define SHARE_FORCE_DIR_MODE_DEFAULT             0000
+
+
+
+/* I'd like to see the following options go away
+ * and always use EAs and SECDESCs */
+#define SHARE_READONLY_DEFAULT		true
+#define SHARE_MAP_SYSTEM_DEFAULT	false
+#define SHARE_MAP_HIDDEN_DEFAULT	false
+#define SHARE_MAP_ARCHIVE_DEFAULT	true
+
+#define SHARE_STRICT_LOCKING_DEFAULT	true
+#define SHARE_OPLOCKS_DEFAULT	true
+#define SHARE_STRICT_SYNC_DEFAULT	false
+#define SHARE_MSDFS_ROOT_DEFAULT	false
+#define SHARE_CI_FILESYSTEM_DEFAULT	false
+
+#endif /* _SHARE_H */
diff --git a/source4/param/share_classic.c b/source4/param/share_classic.c
new file mode 100644
index 0000000000..d732372f45
--- /dev/null
+++ b/source4/param/share_classic.c
@@ -0,0 +1,362 @@
+/* 
+   Unix SMB/CIFS implementation.
+   
+   Classic file based shares configuration
+   
+   Copyright (C) Simo Sorce	2006
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "param/share.h"
+#include "param/param.h"
+
+static NTSTATUS sclassic_init(TALLOC_CTX *mem_ctx, 
+			      const struct share_ops *ops, 
+			      struct tevent_context *event_ctx,
+			      struct loadparm_context *lp_ctx,
+			      struct share_context **ctx)
+{
+	*ctx = talloc(mem_ctx, struct share_context);
+	if (!*ctx) {
+		DEBUG(0, ("ERROR: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	(*ctx)->ops = ops;
+	(*ctx)->priv_data = lp_ctx;
+
+	return NT_STATUS_OK;
+}
+
+static const char *sclassic_string_option(struct share_config *scfg, 
+					  const char *opt_name, 
+					  const char *defval)
+{
+	struct loadparm_service *s = talloc_get_type(scfg->opaque, 
+						     struct loadparm_service);
+	struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data, 
+							  struct loadparm_context);
+	char *parm, *val;
+	const char *ret;
+
+	if (strchr(opt_name, ':')) {
+		parm = talloc_strdup(scfg, opt_name);
+		if (!parm) {
+			return NULL;
+		}
+		val = strchr(parm, ':');
+		*val = '\0';
+		val++;
+
+		ret = lp_parm_string(lp_ctx, s, parm, val);
+		if (!ret) {
+			ret = defval;
+		}
+		talloc_free(parm);
+		return ret;
+	}
+
+	if (strcmp(opt_name, SHARE_NAME) == 0) {
+		return scfg->name;
+	}
+
+	if (strcmp(opt_name, SHARE_PATH) == 0) {
+		return lp_pathname(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_COMMENT) == 0) {
+		return lp_comment(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_VOLUME) == 0) {
+		return volume_label(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_TYPE) == 0) {
+		if (lp_print_ok(s, lp_default_service(lp_ctx))) {
+			return "PRINTER";
+		}
+		if (strcmp("NTFS", lp_fstype(s, lp_default_service(lp_ctx))) == 0) {
+			return "DISK";
+		}
+		return lp_fstype(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_PASSWORD) == 0) {
+		return defval;
+	}
+
+	DEBUG(0,("request for unknown share string option '%s'\n",
+		 opt_name));
+
+	return defval;
+}
+
+static int sclassic_int_option(struct share_config *scfg, const char *opt_name, int defval)
+{
+	struct loadparm_service *s = talloc_get_type(scfg->opaque, 
+						     struct loadparm_service);
+	struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data, 
+							  struct loadparm_context);
+	char *parm, *val;
+	int ret;
+
+	if (strchr(opt_name, ':')) {
+		parm = talloc_strdup(scfg, opt_name);
+		if (!parm) {
+			return -1;
+		}
+		val = strchr(parm, ':');
+		*val = '\0';
+		val++;
+
+		ret = lp_parm_int(lp_ctx, s, parm, val, defval);
+		if (!ret) {
+			ret = defval;
+		}
+		talloc_free(parm);
+		return ret;
+	}
+
+	if (strcmp(opt_name, SHARE_CSC_POLICY) == 0) {
+		return lp_csc_policy(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_MAX_CONNECTIONS) == 0) {
+		return lp_max_connections(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_CREATE_MASK) == 0) {
+		return lp_create_mask(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_DIR_MASK) == 0) {
+		return lp_dir_mask(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_FORCE_DIR_MODE) == 0) {
+		return lp_force_dir_mode(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_FORCE_CREATE_MODE) == 0) {
+		return lp_force_create_mode(s, lp_default_service(lp_ctx));
+	}
+
+
+	DEBUG(0,("request for unknown share int option '%s'\n",
+		 opt_name));
+
+	return defval;
+}
+
+static bool sclassic_bool_option(struct share_config *scfg, const char *opt_name, 
+			  bool defval)
+{
+	struct loadparm_service *s = talloc_get_type(scfg->opaque, 
+						     struct loadparm_service);
+	struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data, 
+							  struct loadparm_context);
+	char *parm, *val;
+	bool ret;
+
+	if (strchr(opt_name, ':')) {
+		parm = talloc_strdup(scfg, opt_name);
+		if(!parm) {
+			return false;
+		}
+		val = strchr(parm, ':');
+		*val = '\0';
+		val++;
+
+		ret = lp_parm_bool(lp_ctx, s, parm, val, defval);
+		talloc_free(parm);
+		return ret;
+	}
+
+	if (strcmp(opt_name, SHARE_AVAILABLE) == 0) {
+		return s != NULL;
+	}
+
+	if (strcmp(opt_name, SHARE_BROWSEABLE) == 0) {
+		return lp_browseable(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_READONLY) == 0) {
+		return lp_readonly(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_MAP_SYSTEM) == 0) {
+		return lp_map_system(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_MAP_HIDDEN) == 0) {
+		return lp_map_hidden(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_MAP_ARCHIVE) == 0) {
+		return lp_map_archive(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_STRICT_LOCKING) == 0) {
+		return lp_strict_locking(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_OPLOCKS) == 0) {
+		return lp_oplocks(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_STRICT_SYNC) == 0) {
+		return lp_strict_sync(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_MSDFS_ROOT) == 0) {
+		return lp_msdfs_root(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_CI_FILESYSTEM) == 0) {
+		return lp_ci_filesystem(s, lp_default_service(lp_ctx));
+	}
+
+	DEBUG(0,("request for unknown share bool option '%s'\n",
+		 opt_name));
+
+	return defval;
+}
+
+static const char **sclassic_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
+{
+	struct loadparm_service *s = talloc_get_type(scfg->opaque, 
+						     struct loadparm_service);
+	struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data, 
+							  struct loadparm_context);
+	char *parm, *val;
+	const char **ret;
+
+	if (strchr(opt_name, ':')) {
+		parm = talloc_strdup(scfg, opt_name);
+		if (!parm) {
+			return NULL;
+		}
+		val = strchr(parm, ':');
+		*val = '\0';
+		val++;
+
+		ret = lp_parm_string_list(mem_ctx, lp_ctx, s, parm, val, ",;");
+		talloc_free(parm);
+		return ret;
+	}
+
+	if (strcmp(opt_name, SHARE_HOSTS_ALLOW) == 0) {
+		return lp_hostsallow(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_HOSTS_DENY) == 0) {
+		return lp_hostsdeny(s, lp_default_service(lp_ctx));
+	}
+
+	if (strcmp(opt_name, SHARE_NTVFS_HANDLER) == 0) {
+		return lp_ntvfs_handler(s, lp_default_service(lp_ctx));
+	}
+
+	DEBUG(0,("request for unknown share list option '%s'\n",
+		 opt_name));
+
+	return NULL;
+}
+
+static NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx,
+				  struct share_context *ctx,
+				  int *count,
+				  const char ***names)
+{
+	int i;
+	int num_services;
+	const char **n;
+       
+	num_services = lp_numservices((struct loadparm_context *)ctx->priv_data);
+
+	n = talloc_array(mem_ctx, const char *, num_services);
+	if (!n) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	for (i = 0; i < num_services; i++) {
+		n[i] = talloc_strdup(n, lp_servicename(lp_servicebynum((struct loadparm_context *)ctx->priv_data, i)));
+		if (!n[i]) {
+			DEBUG(0,("ERROR: Out of memory!\n"));
+			talloc_free(n);
+			return NT_STATUS_NO_MEMORY;
+		}
+	}
+
+	*names = n;
+	*count = num_services;
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS sclassic_get_config(TALLOC_CTX *mem_ctx,
+				    struct share_context *ctx,
+				    const char *name,
+				    struct share_config **scfg)
+{
+	struct share_config *s;
+	struct loadparm_service *service;
+
+	service = lp_service((struct loadparm_context *)ctx->priv_data, name);
+
+	if (service == NULL) {
+		return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+	}
+
+	s = talloc(mem_ctx, struct share_config);
+	if (!s) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	s->name = talloc_strdup(s, lp_servicename(service));
+	if (!s->name) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		talloc_free(s);
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	s->opaque = (void *)service;
+	s->ctx = ctx;
+	
+	*scfg = s;
+
+	return NT_STATUS_OK;
+}
+
+static const struct share_ops ops = {
+	.name = "classic",
+	.init = sclassic_init,
+	.string_option = sclassic_string_option,
+	.int_option = sclassic_int_option,
+	.bool_option = sclassic_bool_option,
+	.string_list_option = sclassic_string_list_option,
+	.list_all = sclassic_list_all,
+	.get_config = sclassic_get_config
+};
+
+NTSTATUS share_classic_init(void)
+{
+	return share_register(&ops);
+}
+
diff --git a/source4/param/share_ldb.c b/source4/param/share_ldb.c
new file mode 100644
index 0000000000..0944ba30fc
--- /dev/null
+++ b/source4/param/share_ldb.c
@@ -0,0 +1,592 @@
+/* 
+   Unix SMB/CIFS implementation.
+   
+   LDB based shares configuration
+   
+   Copyright (C) Simo Sorce	2006
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "ldb/include/ldb.h"
+#include "ldb/include/ldb_errors.h"
+#include "auth/auth.h"
+#include "ldb_wrap.h"
+#include "param/share.h"
+#include "param/param.h"
+
+static NTSTATUS sldb_init(TALLOC_CTX *mem_ctx, const struct share_ops *ops, 
+			  struct tevent_context *ev_ctx,
+			  struct loadparm_context *lp_ctx,
+			  struct share_context **ctx)
+{
+	struct ldb_context *sdb;
+
+	*ctx = talloc(mem_ctx, struct share_context);
+	if (!*ctx) {
+		DEBUG(0, ("ERROR: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+	
+	sdb = ldb_wrap_connect(*ctx, ev_ctx, lp_ctx, 
+			       private_path(*ctx, lp_ctx, "share.ldb"),
+			       system_session(*ctx, lp_ctx),
+			       NULL, 0, NULL);
+
+	if (!sdb) {
+		talloc_free(*ctx);
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	(*ctx)->ops = ops;
+	(*ctx)->priv_data = (void *)sdb;
+
+	return NT_STATUS_OK;
+}
+
+static const char *sldb_string_option(struct share_config *scfg, const char *opt_name, const char *defval)
+{
+	struct ldb_message *msg;
+	struct ldb_message_element *el;
+
+	if (scfg == NULL) return defval;
+
+	msg = talloc_get_type(scfg->opaque, struct ldb_message);
+
+	if (strchr(opt_name, ':')) {
+		char *name, *p;
+
+		name = talloc_strdup(scfg, opt_name);
+		if (!name) {
+			return NULL;
+		}
+		p = strchr(name, ':');
+		*p = '-';
+
+		el = ldb_msg_find_element(msg, name);
+	} else {
+		el = ldb_msg_find_element(msg, opt_name);
+	}
+
+	if (el == NULL) {
+		return defval;
+	}
+
+	return (const char *)(el->values[0].data);
+}
+
+static int sldb_int_option(struct share_config *scfg, const char *opt_name, int defval)
+{
+	const char *val;
+	int ret;
+
+       	val = sldb_string_option(scfg, opt_name, NULL);
+	if (val == NULL) return defval;
+
+	errno = 0;
+	ret = (int)strtol(val, NULL, 10);
+	if (errno) return -1;
+
+	return ret;
+}
+
+static bool sldb_bool_option(struct share_config *scfg, const char *opt_name, bool defval)
+{
+	const char *val;
+
+       	val = sldb_string_option(scfg, opt_name, NULL);
+	if (val == NULL) return defval;
+
+	if (strcasecmp(val, "true") == 0) return true;
+
+	return false;
+}
+
+static const char **sldb_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
+{
+	struct ldb_message *msg;
+	struct ldb_message_element *el;
+	const char **list;
+	int i;
+
+	if (scfg == NULL) return NULL;
+
+	msg = talloc_get_type(scfg->opaque, struct ldb_message);
+
+	if (strchr(opt_name, ':')) {
+		char *name, *p;
+
+		name = talloc_strdup(scfg, opt_name);
+		if (!name) {
+			return NULL;
+		}
+		p = strchr(name, ':');
+		*p = '-';
+
+		el = ldb_msg_find_element(msg, name);
+	} else {
+		el = ldb_msg_find_element(msg, opt_name);
+	}
+
+	if (el == NULL) {
+		return NULL;
+	}
+
+	list = talloc_array(mem_ctx, const char *, el->num_values + 1);
+	if (!list) return NULL;
+
+	for (i = 0; i < el->num_values; i++) {
+		list[i] = (const char *)(el->values[i].data);
+	}
+	list[i] = NULL;
+
+	return list;
+}
+
+static NTSTATUS sldb_list_all(TALLOC_CTX *mem_ctx,
+				 struct share_context *ctx,
+				 int *count,
+				 const char ***names)
+{
+	int ret, i, j;
+	const char **n;
+	struct ldb_context *ldb;
+	struct ldb_result *res;
+	TALLOC_CTX *tmp_ctx;
+
+	tmp_ctx = talloc_new(mem_ctx);
+	if (!tmp_ctx) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
+
+	ret = ldb_search(ldb, tmp_ctx, &res, ldb_dn_new(tmp_ctx, ldb, "CN=SHARES"),
+			 LDB_SCOPE_SUBTREE, NULL, "(name=*)");
+	if (ret != LDB_SUCCESS) {
+		talloc_free(tmp_ctx);
+		return NT_STATUS_INTERNAL_DB_CORRUPTION;
+	}
+
+	n = talloc_array(mem_ctx, const char *, res->count);
+	if (!n) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	for (i = 0, j = 0; i < res->count; i++) {
+		n[j] = talloc_strdup(n, ldb_msg_find_attr_as_string(res->msgs[i], "name", NULL));
+		if (!n[j]) {
+			DEBUG(0,("WARNING: Malformed share object in share database\n!"));
+			continue;
+		}
+		j++;
+	}
+
+	*names = n;
+	*count = j;
+	talloc_free(tmp_ctx);
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS sldb_get_config(TALLOC_CTX *mem_ctx,
+			 struct share_context *ctx,
+			 const char *name,
+			 struct share_config **scfg)
+{
+	int ret;
+	struct share_config *s;
+	struct ldb_context *ldb;
+	struct ldb_result *res;
+	TALLOC_CTX *tmp_ctx;
+
+	tmp_ctx = talloc_new(mem_ctx);
+	if (!tmp_ctx) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
+
+	ret = ldb_search(ldb, tmp_ctx, &res,
+				 ldb_dn_new(tmp_ctx, ldb, "CN=SHARES"), LDB_SCOPE_SUBTREE, NULL,
+				 "(name=%s)", name);
+	if (ret != LDB_SUCCESS || res->count > 1) {
+		talloc_free(tmp_ctx);
+		return NT_STATUS_INTERNAL_DB_CORRUPTION;
+	} else if (res->count != 1) {
+		talloc_free(tmp_ctx);
+		return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+	}
+
+	s = talloc(tmp_ctx, struct share_config);
+	if (!s) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	s->name = talloc_strdup(s, ldb_msg_find_attr_as_string(res->msgs[0], "name", NULL));
+	if (!s->name) {
+		DEBUG(0,("ERROR: Invalid share object!\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	s->opaque = talloc_steal(s, res->msgs[0]);
+	if (!s->opaque) {
+		DEBUG(0,("ERROR: Invalid share object!\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	s->ctx = ctx;
+
+	*scfg = talloc_steal(mem_ctx, s);
+
+	talloc_free(tmp_ctx);
+	return NT_STATUS_OK;
+}
+
+#define SHARE_ADD_STRING(name, value) do { \
+	err = ldb_msg_add_string(msg, name, value); \
+	if (err != LDB_SUCCESS) { \
+		DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
+		ret = NT_STATUS_UNSUCCESSFUL; \
+		goto done; \
+	} } while(0)
+
+#define SHARE_ADD_INT(name, value) do { \
+	err = ldb_msg_add_fmt(msg, name, "%d", value); \
+	if (err != LDB_SUCCESS) { \
+		DEBUG(2,("ERROR: unable to add integer share option %s to ldb msg\n", name)); \
+		ret = NT_STATUS_UNSUCCESSFUL; \
+		goto done; \
+	} } while(0)
+
+#define SHARE_ADD_BLOB(name, value) do { \
+	err = ldb_msg_add_value(msg, name, value, NULL); \
+	if (err != LDB_SUCCESS) { \
+		DEBUG(2,("ERROR: unable to add blob share option %s to ldb msg\n", name)); \
+		ret = NT_STATUS_UNSUCCESSFUL; \
+		goto done; \
+	} } while(0)
+
+static NTSTATUS sldb_create(struct share_context *ctx, const char *name, struct share_info *info, int count)
+{
+	struct ldb_context *ldb;
+	struct ldb_message *msg;
+	TALLOC_CTX *tmp_ctx;
+	NTSTATUS ret;
+	int err, i, j;
+
+	for (i = 0, j = 0; i < count && j != 0x03; i++) {
+		if (strcasecmp(info[i].name, SHARE_TYPE) == 0) j |= 0x02;
+		if (strcasecmp(info[i].name, SHARE_PATH) == 0) j |= 0x01;
+		if (strcasecmp(info[i].name, SHARE_NAME) == 0) {
+			if (strcasecmp(name, (char *)info[i].value) != 0) {
+				return NT_STATUS_INVALID_PARAMETER;
+			}
+		}
+	}
+	if (!name || j != 0x03) {
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+	
+	tmp_ctx = talloc_new(NULL);
+	if (!tmp_ctx) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
+
+	msg = ldb_msg_new(tmp_ctx);
+	if (!msg) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		ret = NT_STATUS_NO_MEMORY;
+		goto done;
+	}
+
+	/* TODO: escape info->name */
+	msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", name);
+	if (!msg->dn) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		ret = NT_STATUS_NO_MEMORY;
+		goto done;
+	}
+
+	SHARE_ADD_STRING("objectClass", "top");
+	SHARE_ADD_STRING("objectClass", "share");
+	SHARE_ADD_STRING("cn", name);
+	SHARE_ADD_STRING(SHARE_NAME, name);
+
+	for (i = 0; i < count; i++) {
+		if (strcasecmp(info[i].name, SHARE_NAME) == 0) continue;
+
+		switch (info[i].type) {
+		case SHARE_INFO_STRING:
+			SHARE_ADD_STRING(info[i].name, (char *)info[i].value);
+			break;
+		case SHARE_INFO_INT:
+			SHARE_ADD_INT(info[i].name, *((int *)info[i].value));
+			break;
+		case SHARE_INFO_BLOB:
+			SHARE_ADD_BLOB(info[i].name, (DATA_BLOB *)info[i].value);
+			break;
+		default:
+			DEBUG(2,("ERROR: Invalid share info type for %s\n", info[i].name));
+			ret = NT_STATUS_INVALID_PARAMETER;
+			goto done;
+		}
+	}
+
+	/* TODO: Security Descriptor */
+
+	SHARE_ADD_STRING(SHARE_AVAILABLE, "true");
+	SHARE_ADD_STRING(SHARE_BROWSEABLE, "true");
+	SHARE_ADD_STRING(SHARE_READONLY, "false");
+	SHARE_ADD_STRING(SHARE_NTVFS_HANDLER, "unixuid");
+	SHARE_ADD_STRING(SHARE_NTVFS_HANDLER, "posix");
+
+	err = ldb_add(ldb, msg);
+	if (err != LDB_SUCCESS) {
+		DEBUG(2,("ERROR: unable to add share %s to share.ldb\n"
+			 "       err=%d [%s]\n", name, err, ldb_errstring(ldb)));
+		if (err == LDB_ERR_NO_SUCH_OBJECT) {
+			ret = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+		} else if (err == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+			ret = NT_STATUS_OBJECT_NAME_COLLISION;
+		} else {
+			ret = NT_STATUS_UNSUCCESSFUL;
+		}
+		goto done;
+	}
+
+	ret = NT_STATUS_OK;
+done:
+	talloc_free(tmp_ctx);
+	return ret;
+}
+
+#define SHARE_MOD_STRING(name, value) do { \
+	err = ldb_msg_add_empty(msg, name, LDB_FLAG_MOD_REPLACE, NULL); \
+	if (err != LDB_SUCCESS) { \
+		DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
+		ret = NT_STATUS_UNSUCCESSFUL; \
+		goto done; \
+	} \
+	err = ldb_msg_add_string(msg, name, value); \
+	if (err != LDB_SUCCESS) { \
+		DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
+		ret = NT_STATUS_UNSUCCESSFUL; \
+		goto done; \
+	} } while(0)
+
+#define SHARE_MOD_INT(name, value) do { \
+	err = ldb_msg_add_empty(msg, name, LDB_FLAG_MOD_REPLACE, NULL); \
+	if (err != LDB_SUCCESS) { \
+		DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
+		ret = NT_STATUS_UNSUCCESSFUL; \
+		goto done; \
+	} \
+	err = ldb_msg_add_fmt(msg, name, "%d", value); \
+	if (err != LDB_SUCCESS) { \
+		DEBUG(2,("ERROR: unable to add integer share option %s to ldb msg\n", name)); \
+		ret = NT_STATUS_UNSUCCESSFUL; \
+		goto done; \
+	} } while(0)
+
+#define SHARE_MOD_BLOB(name, value) do { \
+	err = ldb_msg_add_empty(msg, name, LDB_FLAG_MOD_REPLACE, NULL); \
+	if (err != LDB_SUCCESS) { \
+		DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
+		ret = NT_STATUS_UNSUCCESSFUL; \
+		goto done; \
+	} \
+	err = ldb_msg_add_value(msg, name, value, NULL); \
+	if (err != LDB_SUCCESS) { \
+		DEBUG(2,("ERROR: unable to add blob share option %s to ldb msg\n", name)); \
+		ret = NT_STATUS_UNSUCCESSFUL; \
+		goto done; \
+	} } while(0)
+
+static NTSTATUS sldb_set(struct share_context *ctx, const char *name, struct share_info *info, int count)
+{
+	struct ldb_context *ldb;
+	struct ldb_message *msg;
+	TALLOC_CTX *tmp_ctx;
+	NTSTATUS ret;
+	bool do_rename = false;
+	char *newname;
+	int err, i;
+
+	if (!name) {
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+	
+	tmp_ctx = talloc_new(NULL);
+	if (!tmp_ctx) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
+
+	msg = ldb_msg_new(tmp_ctx);
+	if (!msg) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		ret = NT_STATUS_NO_MEMORY;
+		goto done;
+	}
+
+	/* TODO: escape name */
+	msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", name);
+	if (!msg->dn) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		ret = NT_STATUS_NO_MEMORY;
+		goto done;
+	}
+
+	for (i = 0; i < count; i++) {
+		if (strcasecmp(info[i].name, SHARE_NAME) == 0) {
+			if (strcasecmp(name, (char *)info[i].value) != 0) {
+				do_rename = true;
+				newname = (char *)info[i].value;
+				SHARE_MOD_STRING("cn", (char *)info[i].value);
+			}
+		}
+
+		switch (info[i].type) {
+		case SHARE_INFO_STRING:
+			SHARE_MOD_STRING(info[i].name, (char *)info[i].value);
+			break;
+		case SHARE_INFO_INT:
+			SHARE_MOD_INT(info[i].name, *((int *)info[i].value));
+			break;
+		case SHARE_INFO_BLOB:
+			SHARE_MOD_BLOB(info[i].name, (DATA_BLOB *)info[i].value);
+			break;
+		default:
+			DEBUG(2,("ERROR: Invalid share info type for %s\n", info[i].name));
+			ret = NT_STATUS_INVALID_PARAMETER;
+			goto done;
+		}
+	}
+
+	if (do_rename) {
+		struct ldb_dn *olddn, *newdn;
+
+		olddn = msg->dn;
+
+		/* TODO: escape newname */
+		newdn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", newname);
+		if (!newdn) {
+			DEBUG(0,("ERROR: Out of memory!\n"));
+			ret = NT_STATUS_NO_MEMORY;
+			goto done;
+		}
+
+		err = ldb_rename(ldb, olddn, newdn);
+		if (err != LDB_SUCCESS) {
+			DEBUG(2,("ERROR: unable to rename share %s (to %s)\n"
+				 "       err=%d [%s]\n", name, newname, err, ldb_errstring(ldb)));
+			if (err == LDB_ERR_NO_SUCH_OBJECT) {
+				ret = NT_STATUS_OBJECT_NAME_COLLISION;
+			} else {
+				ret = NT_STATUS_UNSUCCESSFUL;
+			}
+			goto done;
+		}
+
+		msg->dn = newdn;
+	}
+
+	err = ldb_modify(ldb, msg);
+	if (err != LDB_SUCCESS) {
+		DEBUG(2,("ERROR: unable to add share %s to share.ldb\n"
+			 "       err=%d [%s]\n", name, err, ldb_errstring(ldb)));
+		if (err == LDB_ERR_NO_SUCH_OBJECT) {
+			ret = NT_STATUS_OBJECT_NAME_COLLISION;
+		} else {
+			ret = NT_STATUS_UNSUCCESSFUL;
+		}
+		goto done;
+	}
+
+	ret = NT_STATUS_OK;
+done:
+	talloc_free(tmp_ctx);
+	return ret;
+}
+
+static NTSTATUS sldb_remove(struct share_context *ctx, const char *name)
+{
+	struct ldb_context *ldb;
+	struct ldb_dn *dn;
+	TALLOC_CTX *tmp_ctx;
+	NTSTATUS ret;
+	int err;
+
+	tmp_ctx = talloc_new(NULL);
+	if (!tmp_ctx) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
+
+	dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", name);
+	if (!dn) {
+		DEBUG(0,("ERROR: Out of memory!\n"));
+		ret = NT_STATUS_NO_MEMORY;
+		goto done;
+	}
+
+	err = ldb_delete(ldb, dn);
+	if (err != LDB_SUCCESS) {
+		DEBUG(2,("ERROR: unable to remove share %s from share.ldb\n"
+			 "       err=%d [%s]\n", name, err, ldb_errstring(ldb)));
+		ret = NT_STATUS_UNSUCCESSFUL;
+		goto done;
+	}
+
+	ret = NT_STATUS_OK;
+done:
+	talloc_free(tmp_ctx);
+	return ret;
+}
+
+static const struct share_ops ops = {
+	.name = "ldb",
+	.init = sldb_init,
+	.string_option = sldb_string_option,
+	.int_option = sldb_int_option,
+	.bool_option = sldb_bool_option,
+	.string_list_option = sldb_string_list_option,
+	.list_all = sldb_list_all,
+	.get_config = sldb_get_config,
+	.create = sldb_create,
+	.set = sldb_set,
+	.remove = sldb_remove
+};
+
+NTSTATUS share_ldb_init(void)
+{
+	return share_register(&ops);
+}
diff --git a/source4/param/tests/bindings.py b/source4/param/tests/bindings.py
new file mode 100644
index 0000000000..41a67f93fc
--- /dev/null
+++ b/source4/param/tests/bindings.py
@@ -0,0 +1,52 @@
+#!/usr/bin/python
+
+# Unix SMB/CIFS implementation.
+# Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
+#   
+# 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 3 of the License, or
+# (at your option) any later version.
+#   
+# This program 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 General Public License for more details.
+#   
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from samba import param
+import unittest
+
+class LoadParmTestCase(unittest.TestCase):
+    def test_init(self):
+        file = param.LoadParm()
+        self.assertTrue(file is not None)
+
+    def test_length(self):
+        file = param.LoadParm()
+        self.assertEquals(0, len(file))
+
+    def test_set_workgroup(self):
+        file = param.LoadParm()
+        file.set("workgroup", "bla")
+        self.assertEquals("BLA", file.get("workgroup"))
+
+    def test_is_mydomain(self):
+        file = param.LoadParm()
+        file.set("workgroup", "bla")
+        self.assertTrue(file.is_mydomain("BLA"))
+        self.assertFalse(file.is_mydomain("FOOBAR"))
+
+    def test_is_myname(self):
+        file = param.LoadParm()
+        file.set("netbios name", "bla")
+        self.assertTrue(file.is_myname("BLA"))
+        self.assertFalse(file.is_myname("FOOBAR"))
+
+    def test_load_default(self):
+        file = param.LoadParm()
+        file.load_default()
+
diff --git a/source4/param/tests/loadparm.c b/source4/param/tests/loadparm.c
new file mode 100644
index 0000000000..49fcdf7249
--- /dev/null
+++ b/source4/param/tests/loadparm.c
@@ -0,0 +1,167 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "param/share.h"
+#include "param/param.h"
+#include "torture/torture.h"
+
+static bool test_create(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_ctx != NULL, "lp_ctx");
+	return true;
+}
+
+static bool test_set_option(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_set_option(lp_ctx, "workgroup=werkgroep"), "lp_set_option failed");
+	torture_assert_str_equal(tctx, "WERKGROEP", lp_workgroup(lp_ctx), "workgroup");
+	return true;
+}
+
+static bool test_set_cmdline(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_set_cmdline(lp_ctx, "workgroup", "werkgroep"), "lp_set_cmdline failed");
+	torture_assert(tctx, lp_do_global_parameter(lp_ctx, "workgroup", "barbla"), "lp_set_option failed");
+	torture_assert_str_equal(tctx, "WERKGROEP", lp_workgroup(lp_ctx), "workgroup");
+	return true;
+}
+
+static bool test_do_global_parameter(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_do_global_parameter(lp_ctx, "workgroup", "werkgroep42"), 
+		       "lp_set_cmdline failed");
+	torture_assert_str_equal(tctx, lp_workgroup(lp_ctx), "WERKGROEP42", "workgroup");
+	return true;
+}
+
+
+static bool test_do_global_parameter_var(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_do_global_parameter_var(lp_ctx, "workgroup", "werk%s%d", "groep", 42), 
+		       "lp_set_cmdline failed");
+	torture_assert_str_equal(tctx, lp_workgroup(lp_ctx), "WERKGROEP42", "workgroup");
+	return true;
+}
+
+
+static bool test_set_option_invalid(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, !lp_set_option(lp_ctx, "workgroup"), "lp_set_option succeeded");
+	return true;
+}
+
+static bool test_set_option_parametric(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=blaat"), "lp_set_option failed");
+	torture_assert_str_equal(tctx, lp_parm_string(lp_ctx, NULL, "some", "thing"), "blaat", 
+				 "invalid parametric option");
+	return true;
+}
+
+static bool test_lp_parm_double(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=3.4"), "lp_set_option failed");
+	torture_assert(tctx, lp_parm_double(lp_ctx, NULL, "some", "thing", 2.0) == 3.4, 
+				 "invalid parametric option");
+	torture_assert(tctx, lp_parm_double(lp_ctx, NULL, "some", "bla", 2.0) == 2.0, 
+				 "invalid parametric option");
+	return true;
+}
+
+static bool test_lp_parm_bool(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=true"), "lp_set_option failed");
+	torture_assert(tctx, lp_parm_bool(lp_ctx, NULL, "some", "thing", false) == true, 
+				 "invalid parametric option");
+	torture_assert(tctx, lp_parm_bool(lp_ctx, NULL, "some", "bla", true) == true, 
+				 "invalid parametric option");
+	return true;
+}
+
+static bool test_lp_parm_int(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=34"), "lp_set_option failed");
+	torture_assert_int_equal(tctx, lp_parm_int(lp_ctx, NULL, "some", "thing", 20), 34, 
+				 "invalid parametric option");
+	torture_assert_int_equal(tctx, lp_parm_int(lp_ctx, NULL, "some", "bla", 42), 42, 
+				 "invalid parametric option");
+	return true;
+}
+
+static bool test_lp_parm_bytes(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	torture_assert(tctx, lp_set_option(lp_ctx, "some:thing=16K"), "lp_set_option failed");
+	torture_assert_int_equal(tctx, lp_parm_bytes(lp_ctx, NULL, "some", "thing", 20), 16 * 1024, 
+				 "invalid parametric option");
+	torture_assert_int_equal(tctx, lp_parm_bytes(lp_ctx, NULL, "some", "bla", 42), 42, 
+				 "invalid parametric option");
+	return true;
+}
+
+static bool test_lp_do_service_parameter(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	struct loadparm_service *service = lp_add_service(lp_ctx, lp_default_service(lp_ctx), "foo");
+	torture_assert(tctx, lp_do_service_parameter(lp_ctx, service, 
+						     "some:thing", "foo"), "lp_set_option failed");
+	torture_assert_str_equal(tctx, lp_parm_string(lp_ctx, service, "some", "thing"), "foo",
+				 "invalid parametric option");
+	return true;
+}
+
+static bool test_lp_service(struct torture_context *tctx)
+{
+	struct loadparm_context *lp_ctx = loadparm_init(tctx);
+	struct loadparm_service *service = lp_add_service(lp_ctx, lp_default_service(lp_ctx), "foo");
+	torture_assert(tctx, service == lp_service(lp_ctx, "foo"), "invalid service");
+	return true;
+}
+
+struct torture_suite *torture_local_loadparm(TALLOC_CTX *mem_ctx)
+{
+	struct torture_suite *suite = torture_suite_create(mem_ctx, "LOADPARM");
+
+	torture_suite_add_simple_test(suite, "create", test_create);
+	torture_suite_add_simple_test(suite, "set_option", test_set_option);
+	torture_suite_add_simple_test(suite, "set_cmdline", test_set_cmdline);
+	torture_suite_add_simple_test(suite, "set_option_invalid", test_set_option_invalid);
+	torture_suite_add_simple_test(suite, "set_option_parametric", test_set_option_parametric);
+	torture_suite_add_simple_test(suite, "set_lp_parm_double", test_lp_parm_double);
+	torture_suite_add_simple_test(suite, "set_lp_parm_bool", test_lp_parm_bool);
+	torture_suite_add_simple_test(suite, "set_lp_parm_int", test_lp_parm_int);
+	torture_suite_add_simple_test(suite, "set_lp_parm_bytes", test_lp_parm_bytes);
+	torture_suite_add_simple_test(suite, "service_parameter", test_lp_do_service_parameter);
+	torture_suite_add_simple_test(suite, "lp_service", test_lp_service);
+	torture_suite_add_simple_test(suite, "do_global_parameter_var", test_do_global_parameter_var);
+	torture_suite_add_simple_test(suite, "do_global_parameter", test_do_global_parameter);
+
+	return suite;
+}
diff --git a/source4/param/tests/share.c b/source4/param/tests/share.c
new file mode 100644
index 0000000000..c64b5c607a
--- /dev/null
+++ b/source4/param/tests/share.c
@@ -0,0 +1,215 @@
+/* 
+   Unix SMB/CIFS implementation.
+
+   local testing of share code
+
+   Copyright (C) Jelmer Vernooij 2007
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "param/share.h"
+#include "param/param.h"
+#include "torture/torture.h"
+
+static bool test_list_empty(struct torture_context *tctx, 
+			    const void *tcase_data, 
+			    const void *test_data)
+{
+	struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
+	int count;
+	const char **names;
+
+	torture_assert_ntstatus_ok(tctx, share_list_all(tctx, ctx, &count, &names),
+							   "share_list_all failed");
+
+	return true;
+}
+
+static bool test_create(struct torture_context *tctx, 
+			const void *tcase_data, 
+			const void *test_data)
+{
+	struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
+	int count;
+	const char **names;
+	int i;
+	bool found = false;
+	struct share_info inf[] = { 
+		{ SHARE_INFO_STRING, SHARE_TYPE, discard_const_p(void *, "IPC$") },
+		{ SHARE_INFO_STRING, SHARE_PATH, discard_const_p(void *, "/tmp/bla") }
+	};
+	NTSTATUS status;
+
+	status = share_create(ctx, "bloe", inf, 2);
+
+	if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED))
+		torture_skip(tctx, "Not supported by backend");
+
+	torture_assert_ntstatus_ok(tctx, status, "create_share failed");
+
+	torture_assert_ntstatus_ok(tctx, share_list_all(tctx, ctx, &count, &names),
+							   "share_list_all failed");
+
+	torture_assert(tctx, count >= 1, "creating share failed");
+
+
+	for (i = 0; i < count; i++) {
+		found |= strcmp(names[i], "bloe") == 0;
+	}
+
+	torture_assert(tctx, found, "created share found");
+
+	return true;
+}
+
+
+static bool test_create_invalid(struct torture_context *tctx, 
+				const void *tcase_data, 
+				const void *test_data)
+{
+	struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
+	NTSTATUS status;
+
+	status = share_create(ctx, "bla", NULL, 0);
+
+	if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED))
+		torture_skip(tctx, "Not supported by backend");
+
+	torture_assert_ntstatus_equal(tctx, NT_STATUS_INVALID_PARAMETER, 
+				      status,
+				      "create_share failed");
+
+	torture_assert_ntstatus_equal(tctx, NT_STATUS_INVALID_PARAMETER, 
+				      share_create(ctx, NULL, NULL, 0),
+				      "create_share failed");
+
+	return true;
+}
+
+static bool test_share_remove_invalid(struct torture_context *tctx, 
+				      const void *tcase_data, 
+				      const void *test_data)
+{
+	struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
+	NTSTATUS status;
+
+	status = share_remove(ctx, "nonexistant");
+
+	if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED))
+		torture_skip(tctx, "Not supported by backend");
+
+	torture_assert_ntstatus_equal(tctx, status, NT_STATUS_UNSUCCESSFUL, "remove fails");
+
+	return true;
+}
+
+
+
+static bool test_share_remove(struct torture_context *tctx, 
+			      const void *tcase_data, 
+			      const void *test_data)
+{
+	struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
+	struct share_info inf[] = { 
+		{ SHARE_INFO_STRING, SHARE_TYPE, discard_const_p(void *, "IPC$") },
+		{ SHARE_INFO_STRING, SHARE_PATH, discard_const_p(void *, "/tmp/bla") }
+	};
+	NTSTATUS status;
+
+	status = share_create(ctx, "blie", inf, 2);
+
+	if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED))
+		torture_skip(tctx, "Not supported by backend");
+
+	torture_assert_ntstatus_ok(tctx, status, "create_share failed");
+
+	torture_assert_ntstatus_ok(tctx, share_remove(ctx, "blie"), "remove failed");
+
+	return true;
+}
+
+static bool test_double_create(struct torture_context *tctx, 
+			       const void *tcase_data, 
+			       const void *test_data)
+{
+	struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
+	struct share_info inf[] = { 
+		{ SHARE_INFO_STRING, SHARE_TYPE, discard_const_p(void *, "IPC$") },
+		{ SHARE_INFO_STRING, SHARE_PATH, discard_const_p(void *, "/tmp/bla") }
+	};
+	NTSTATUS status;
+
+	status = share_create(ctx, "bla", inf, 2);
+
+	if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED))
+		torture_skip(tctx, "Not supported by backend");
+
+	torture_assert_ntstatus_ok(tctx, status, "create_share failed");
+
+	torture_assert_ntstatus_equal(tctx, NT_STATUS_OBJECT_NAME_COLLISION,
+				      share_create(ctx, "bla", inf, 2),
+				      "create_share failed");
+
+	return true;
+}
+
+static void tcase_add_share_tests(struct torture_tcase *tcase)
+{
+	torture_tcase_add_test_const(tcase, "list_empty", test_list_empty,NULL);
+	torture_tcase_add_test_const(tcase, "share_create", test_create, NULL);
+	torture_tcase_add_test_const(tcase, "share_remove", test_share_remove,
+			NULL);
+	torture_tcase_add_test_const(tcase, "share_remove_invalid",
+			test_share_remove_invalid, NULL);
+	torture_tcase_add_test_const(tcase, "share_create_invalid",
+			test_create_invalid, NULL);
+	torture_tcase_add_test_const(tcase, "share_double_create",
+			test_double_create, NULL);
+}
+
+static bool setup_ldb(struct torture_context *tctx, void **data)
+{
+	return NT_STATUS_IS_OK(share_get_context_by_name(tctx, "ldb", tctx->ev, tctx->lp_ctx, (struct share_context **)data));
+}
+
+static bool setup_classic(struct torture_context *tctx, void **data)
+{
+	return NT_STATUS_IS_OK(share_get_context_by_name(tctx, "classic", tctx->ev, tctx->lp_ctx, (struct share_context **)data));
+}
+
+static bool teardown(struct torture_context *tctx, void *data)
+{
+	talloc_free(data);
+	return true;
+}
+
+struct torture_suite *torture_local_share(TALLOC_CTX *mem_ctx)
+{
+	struct torture_suite *suite = torture_suite_create(mem_ctx, "SHARE");
+	struct torture_tcase *tcase;
+
+	share_init();
+
+	tcase = torture_suite_add_tcase(suite, "ldb");
+	torture_tcase_set_fixture(tcase, setup_ldb, teardown);
+	tcase_add_share_tests(tcase);
+
+	tcase = torture_suite_add_tcase(suite, "classic");
+	torture_tcase_set_fixture(tcase, setup_classic, teardown);
+	tcase_add_share_tests(tcase);
+
+	return suite;
+}
diff --git a/source4/param/util.c b/source4/param/util.c
new file mode 100644
index 0000000000..3881107cbc
--- /dev/null
+++ b/source4/param/util.c
@@ -0,0 +1,298 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) Jeremy Allison 2001-2002
+   Copyright (C) Simo Sorce 2001
+   Copyright (C) Jim McDonough (jmcd@us.ibm.com)  2003.
+   Copyright (C) James J Myers 2003
+   Copyright (C) Jelmer Vernooij 2005-2007
+   
+   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 3 of the License, or
+   (at your option) any later version.
+   
+   This program 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 General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "dynconfig/dynconfig.h"
+#include "system/network.h"
+#include "system/filesys.h"
+#include "system/dir.h"
+#include "param/param.h"
+
+/**
+ * @file
+ * @brief Misc utility functions
+ */
+
+
+bool lp_is_mydomain(struct loadparm_context *lp_ctx, 
+			     const char *domain)
+{
+	return strequal(lp_workgroup(lp_ctx), domain);
+}
+
+/**
+  see if a string matches either our primary or one of our secondary 
+  netbios aliases. do a case insensitive match
+*/
+bool lp_is_myname(struct loadparm_context *lp_ctx, const char *name)
+{
+	const char **aliases;
+	int i;
+
+	if (strcasecmp(name, lp_netbios_name(lp_ctx)) == 0) {
+		return true;
+	}
+
+	aliases = lp_netbios_aliases(lp_ctx);
+	for (i=0; aliases && aliases[i]; i++) {
+		if (strcasecmp(name, aliases[i]) == 0) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+/**
+ A useful function for returning a path in the Samba lock directory.
+**/
+char *lock_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
+			 const char *name)
+{
+	char *fname, *dname;
+	if (name == NULL) {
+		return NULL;
+	}
+	if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
+		return talloc_strdup(mem_ctx, name);
+	}
+
+	dname = talloc_strdup(mem_ctx, lp_lockdir(lp_ctx));
+	trim_string(dname,"","/");
+	
+	if (!directory_exist(dname)) {
+		mkdir(dname,0755);
+	}
+	
+	fname = talloc_asprintf(mem_ctx, "%s/%s", dname, name);
+
+	talloc_free(dname);
+
+	return fname;
+}
+
+/**
+ * @brief Returns an absolute path to a file in the directory containing the current config file
+ *
+ * @param name File to find, relative to the config file directory.
+ *
+ * @retval Pointer to a talloc'ed string containing the full path.
+ **/
+
+char *config_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
+			   const char *name)
+{
+	char *fname, *config_dir, *p;
+	config_dir = talloc_strdup(mem_ctx, lp_configfile(lp_ctx));
+	if (config_dir == NULL) {
+		config_dir = talloc_strdup(mem_ctx, lp_default_path());
+	}
+	p = strrchr(config_dir, '/');
+	if (p == NULL) {
+		return NULL;
+	}
+	p[0] = '\0';
+	fname = talloc_asprintf(mem_ctx, "%s/%s", config_dir, name);
+	talloc_free(config_dir);
+	return fname;
+}
+
+/**
+ * @brief Returns an absolute path to a file in the Samba private directory.
+ *
+ * @param name File to find, relative to PRIVATEDIR.
+ * if name is not relative, then use it as-is
+ *
+ * @retval Pointer to a talloc'ed string containing the full path.
+ **/
+char *private_path(TALLOC_CTX* mem_ctx, 
+			    struct loadparm_context *lp_ctx,
+			    const char *name)
+{
+	char *fname;
+	if (name == NULL) {
+		return NULL;
+	}
+	if (name[0] == 0 || name[0] == '/' || strstr(name, ":/")) {
+		return talloc_strdup(mem_ctx, name);
+	}
+	fname = talloc_asprintf(mem_ctx, "%s/%s", lp_private_dir(lp_ctx), name);
+	return fname;
+}
+
+/**
+  return a path in the smbd.tmp directory, where all temporary file
+  for smbd go. If NULL is passed for name then return the directory 
+  path itself
+*/
+char *smbd_tmp_path(TALLOC_CTX *mem_ctx, 
+			     struct loadparm_context *lp_ctx, 
+			     const char *name)
+{
+	char *fname, *dname;
+
+	dname = private_path(mem_ctx, lp_ctx, "smbd.tmp");
+	if (!directory_exist(dname)) {
+		mkdir(dname,0755);
+	}
+
+	if (name == NULL) {
+		return dname;
+	}
+
+	fname = talloc_asprintf(mem_ctx, "%s/%s", dname, name);
+	talloc_free(dname);
+
+	return fname;
+}
+
+/**
+ * Obtain the init function from a shared library file
+ */
+init_module_fn load_module(TALLOC_CTX *mem_ctx, const char *path)
+{
+	void *handle;
+	void *init_fn;
+
+	handle = dlopen(path, RTLD_NOW);
+	if (handle == NULL) {
+		DEBUG(0, ("Unable to open %s: %s\n", path, dlerror()));
+		return NULL;
+	}
+
+	init_fn = dlsym(handle, SAMBA_INIT_MODULE);
+
+	if (init_fn == NULL) {
+		DEBUG(0, ("Unable to find %s() in %s: %s\n", 
+			  SAMBA_INIT_MODULE, path, dlerror()));
+		DEBUG(1, ("Loading module '%s' failed\n", path));
+		dlclose(handle);
+		return NULL;
+	}
+
+	return (init_module_fn)init_fn;
+}
+
+/**
+ * Obtain list of init functions from the modules in the specified
+ * directory
+ */
+init_module_fn *load_modules(TALLOC_CTX *mem_ctx, const char *path)
+{
+	DIR *dir;
+	struct dirent *entry;
+	char *filename;
+	int success = 0;
+	init_module_fn *ret = talloc_array(mem_ctx, init_module_fn, 2);
+
+	ret[0] = NULL;
+	
+	dir = opendir(path);
+	if (dir == NULL) {
+		talloc_free(ret);
+		return NULL;
+	}
+
+	while((entry = readdir(dir))) {
+		if (ISDOT(entry->d_name) || ISDOTDOT(entry->d_name))
+			continue;
+
+		filename = talloc_asprintf(mem_ctx, "%s/%s", path, entry->d_name);
+
+		ret[success] = load_module(mem_ctx, filename);
+		if (ret[success]) {
+			ret = talloc_realloc(mem_ctx, ret, init_module_fn, success+2);
+			success++;
+			ret[success] = NULL;
+		}
+
+		talloc_free(filename);
+	}
+
+	closedir(dir);
+
+	return ret;
+}
+
+/**
+ * Run the specified init functions.
+ *
+ * @return true if all functions ran successfully, false otherwise
+ */
+bool run_init_functions(init_module_fn *fns)
+{
+	int i;
+	bool ret = true;
+	
+	if (fns == NULL)
+		return true;
+	
+	for (i = 0; fns[i]; i++) { ret &= (bool)NT_STATUS_IS_OK(fns[i]()); }
+
+	return ret;
+}
+
+static char *modules_path(TALLOC_CTX* mem_ctx, struct loadparm_context *lp_ctx,
+			  const char *name)
+{
+	const char *env_moduledir = getenv("LD_SAMBA_MODULE_PATH");
+	return talloc_asprintf(mem_ctx, "%s/%s", 
+			       env_moduledir?env_moduledir:lp_modulesdir(lp_ctx), 
+			       name);
+}
+
+/**
+ * Load the initialization functions from DSO files for a specific subsystem.
+ *
+ * Will return an array of function pointers to initialization functions
+ */
+
+init_module_fn *load_samba_modules(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx, const char *subsystem)
+{
+	char *path = modules_path(mem_ctx, lp_ctx, subsystem);
+	init_module_fn *ret;
+
+	ret = load_modules(mem_ctx, path);
+
+	talloc_free(path);
+
+	return ret;
+}
+
+const char *lp_messaging_path(TALLOC_CTX *mem_ctx, 
+				       struct loadparm_context *lp_ctx)
+{
+	return smbd_tmp_path(mem_ctx, lp_ctx, "messaging");
+}
+
+struct smb_iconv_convenience *smb_iconv_convenience_init_lp(TALLOC_CTX *mem_ctx,
+							 struct loadparm_context *lp_ctx)
+{
+	return smb_iconv_convenience_init(mem_ctx, lp_dos_charset(lp_ctx),
+					  lp_unix_charset(lp_ctx),
+		lp_parm_bool(lp_ctx, NULL, "iconv", "native", true));
+}
+
+