Not currently used - no logic changes inside.
This will make it possible to pass down a long-lived talloc
context from the loading function for modules to use instead
of having them internally all use talloc_autofree_context()
which is a hidden global.
Updated all known module interface numbers, and added a
WHATSNEW.
Signed-off-by: Jeremy Allison <jra@samba.org>
Signed-off-by: Ralph Böhme <slow@samba.org>
Autobuild-User(master): Jeremy Allison <jra@samba.org>
Autobuild-Date(master): Sat Apr 22 01:17:00 CEST 2017 on sn-devel-144
samba-technical@lists.samba.org in order to design a supported
way of obtaining the same functionality.
+Change of loadable module interface
+-----------------------------------
+
+The _init function of all loadable modules in Samba has changed
+from:
+
+NTSTATUS _init(void);
+
+to:
+
+NTSTATUS _init(TALLOC_CTX *);
+
+This allows a program loading a module to pass in a long-lived
+talloc context (which must be guaranteed to be alive for the
+lifetime of the module). This allows modules to avoid use of
+the talloc_autofree_context() (which is inherently thread-unsafe)
+and still be valgrind-clean on exit. Modules that don't need to
+free long-lived data on exist should use the NULL talloc context.
+
KNOWN ISSUES
============
* layer is already mutually authenticated.
*/
-NTSTATUS gensec_external_init(void);
+NTSTATUS gensec_external_init(TALLOC_CTX *ctx);
static NTSTATUS gensec_external_start(struct gensec_security *gensec_security)
{
};
-NTSTATUS gensec_external_init(void)
+NTSTATUS gensec_external_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct gensec_security_ops;
struct gensec_security_ops_wrapper;
-#define GENSEC_INTERFACE_VERSION 0
+/* Change to 1, loadable modules now take a TALLOC_CTX * init() parameter. */
+#define GENSEC_INTERFACE_VERSION 1
/* this structure is used by backends to determine the size of some critical types */
struct gensec_critical_sizes;
_PUBLIC_ NTSTATUS gensec_init(void)
{
static bool initialized = false;
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
#ifdef STATIC_gensec_MODULES
STATIC_gensec_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_gensec_MODULES };
shared_init = load_samba_modules(NULL, "gensec");
- run_init_functions(static_init);
- run_init_functions(shared_init);
+ run_init_functions(NULL, static_init);
+ run_init_functions(NULL, shared_init);
talloc_free(shared_init);
#include "lib/param/param.h"
#include "tsocket.h"
-_PUBLIC_ NTSTATUS gensec_ncalrpc_as_system_init(void);
+_PUBLIC_ NTSTATUS gensec_ncalrpc_as_system_init(TALLOC_CTX *ctx);
struct gensec_ncalrpc_state {
enum {
.priority = GENSEC_EXTERNAL,
};
-_PUBLIC_ NTSTATUS gensec_ncalrpc_as_system_init(void)
+_PUBLIC_ NTSTATUS gensec_ncalrpc_as_system_init(TALLOC_CTX *ctx)
{
NTSTATUS status;
return NT_STATUS_OK;
}
-_PUBLIC_ NTSTATUS gensec_schannel_init(void);
+_PUBLIC_ NTSTATUS gensec_schannel_init(TALLOC_CTX *ctx);
static size_t schannel_sig_size(struct gensec_security *gensec_security, size_t data_size)
{
.priority = GENSEC_SCHANNEL
};
-_PUBLIC_ NTSTATUS gensec_schannel_init(void)
+_PUBLIC_ NTSTATUS gensec_schannel_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
ret = gensec_register(&gensec_schannel_security_ops);
#undef strcasecmp
-_PUBLIC_ NTSTATUS gensec_spnego_init(void);
+_PUBLIC_ NTSTATUS gensec_spnego_init(TALLOC_CTX *ctx);
enum spnego_state_position {
SPNEGO_SERVER_START,
.priority = GENSEC_SPNEGO
};
-_PUBLIC_ NTSTATUS gensec_spnego_init(void)
+_PUBLIC_ NTSTATUS gensec_spnego_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
ret = gensec_register(&gensec_spnego_security_ops);
.priority = GENSEC_NTLMSSP
};
-_PUBLIC_ NTSTATUS gensec_ntlmssp_init(void)
+_PUBLIC_ NTSTATUS gensec_ntlmssp_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
/* The following definitions come from auth/ntlmssp/gensec_ntlmssp.c */
-NTSTATUS gensec_ntlmssp_init(void);
+NTSTATUS gensec_ntlmssp_init(TALLOC_CTX *ctx);
uint32_t gensec_ntlmssp_neg_flags(struct gensec_security *gensec_security);
const char *gensec_ntlmssp_server_domain(struct gensec_security *gensec_security);
keys_header_other.append(key)
else:
keys_option_have.append(key)
+ elif key.startswith("static_init_"):
+ l = key.split("(")
+ keys_misc.append(l[0])
else:
keys_misc.append(key)
</para>
<para><programlisting>
-NTSTATUS init_module(void);
+NTSTATUS init_module(TALLOC_CTX *);
</programlisting></para>
<para>This function should call one or more
<para>For example, pdb_ldap_init() contains: </para>
<para><programlisting>
-NTSTATUS pdb_ldap_init(void)
+NTSTATUS pdb_ldap_init(TALLOC_CTX *)
{
smb_register_passdb(PASSDB_INTERFACE_VERSION, "ldapsam", pdb_init_ldapsam);
smb_register_passdb(PASSDB_INTERFACE_VERSION, "ldapsam_nua", pdb_init_ldapsam_nua);
}
</programlisting></para>
+<para>
+The TALLOC_CTX pointer passed as a parameter must be a long-lived context,
+that will stay around for as long as the program that loads the module
+exists. It allows the caller to taloc_free any long lived data the
+module choses to place on this context on program exit (giving a cleaner
+valgrind trace). It should be used by modules in place of talloc_autofree_context(),
+use of which makes programs thread-unsafe. Modules that don't care about
+free on exist should use the NULL talloc context.
+</para>
+
<sect2>
<title>Static/Shared selection in configure.in</title>
};
static_decl_vfs;
-NTSTATUS vfs_shadow_copy_test_init(void)
+NTSTATUS vfs_shadow_copy_test_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"shadow_copy_test",
};
static_decl_vfs;
-NTSTATUS vfs_skel_opaque_init(void)
+NTSTATUS vfs_skel_opaque_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "skel_opaque",
&skel_opaque_fns);
};
static_decl_vfs;
-NTSTATUS vfs_skel_transparent_init(void)
+NTSTATUS vfs_skel_transparent_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "skel_transparent",
&skel_transparent_fns);
return NT_STATUS_OK;
}
-NTSTATUS auth_skel_init(void);
-NTSTATUS auth_skel_init(void)
+NTSTATUS auth_skel_init(TALLOC_CTX *ctx);
+NTSTATUS auth_skel_init(TALLOC_CTX *ctx)
{
return smb_register_auth(AUTH_INTERFACE_VERSION, "skel", auth_init_skel);
}
}
static_decl_pdb;
-NTSTATUS pdb_test_init(void)
+NTSTATUS pdb_test_init(TALLOC_CTX *ctx)
{
return smb_register_passdb(PASSDB_INTERFACE_VERSION, "testsam",
testsam_init);
}
/* called at smbd startup - register ourselves as a server service */
-NTSTATUS server_service_s3fs_init(void);
+NTSTATUS server_service_s3fs_init(TALLOC_CTX *);
-NTSTATUS server_service_s3fs_init(void)
+NTSTATUS server_service_s3fs_init(TALLOC_CTX *ctx)
{
return register_server_service("s3fs", s3fs_task_init);
}
*
* @return true if all functions ran successfully, false otherwise
*/
-bool run_init_functions(init_module_fn *fns)
+bool run_init_functions(TALLOC_CTX *ctx, 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]()); }
+ for (i = 0; fns[i]; i++) { ret &= (bool)NT_STATUS_IS_OK(fns[i](ctx)); }
return ret;
}
DEBUG(2, ("Module '%s' loaded\n", module_name));
- status = init();
+ status = init(NULL);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Module '%s' initialization failed: %s\n",
module_name, get_friendly_nt_error_msg(status)));
#define _SAMBA_MODULES_H
/* Module support */
-typedef NTSTATUS (*init_module_fn) (void);
+typedef NTSTATUS (*init_module_fn) (TALLOC_CTX *ctx);
-NTSTATUS samba_init_module(void);
+NTSTATUS samba_init_module(TALLOC_CTX *ctx);
/* this needs to be a string which is not in the C library. We
previously used "init_module", but that meant that modules which
*
* @return true if all functions ran successfully, false otherwise
*/
-bool run_init_functions(init_module_fn *fns);
+bool run_init_functions(TALLOC_CTX *ctx, init_module_fn *fns);
/**
* Load the initialization functions from DSO files for a specific subsystem.
#include "libcli/util/ntstatus.h"
#include "libcli/echo/libecho.h"
-NTSTATUS torture_libcli_echo_init(void);
+NTSTATUS torture_libcli_echo_init(TALLOC_CTX *);
/* Basic test function that sends an echo request and checks the reply */
static bool echo_udp_basic(struct torture_context *tctx, const char *address)
}
/* Test suite that bundles all the libecho tests */
-NTSTATUS torture_libcli_echo_init(void)
+NTSTATUS torture_libcli_echo_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite;
return false;
}
-NTSTATUS dcerpc_server_$name\_init(void)
+NTSTATUS dcerpc_server_$name\_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
static const struct dcesrv_endpoint_server ep_server = {
my($interface) = shift;
my $count = 0;
- $res .= "NTSTATUS dcerpc_server_$interface->{NAME}\_init(void);\n";
+ $res .= "NTSTATUS dcerpc_server_$interface->{NAME}\_init(TALLOC_CTX *);\n";
$res .= "\n";
if (!defined $interface->{PROPERTIES}->{uuid}) {
/* Initialise static modules if not done so yet */
if(!initialised_static_modules) {
- static_init_auth;
+ static_init_auth(NULL);
initialised_static_modules = True;
}
#endif /* DEVELOPER */
-NTSTATUS auth_builtin_init(void)
+NTSTATUS auth_builtin_init(TALLOC_CTX *mem_ctx)
{
smb_register_auth(AUTH_INTERFACE_VERSION, "guest", auth_init_guest);
#ifdef DEVELOPER
return NT_STATUS_OK;
}
-NTSTATUS auth_domain_init(void)
+NTSTATUS auth_domain_init(TALLOC_CTX *mem_ctx)
{
smb_register_auth(AUTH_INTERFACE_VERSION, "trustdomain", auth_init_trustdomain);
smb_register_auth(AUTH_INTERFACE_VERSION, "ntdomain", auth_init_ntdomain);
return NT_STATUS_OK;
}
-NTSTATUS auth_sam_init(void)
+NTSTATUS auth_sam_init(TALLOC_CTX *mem_ctx)
{
smb_register_auth(AUTH_INTERFACE_VERSION, "sam", auth_init_sam);
smb_register_auth(AUTH_INTERFACE_VERSION, "sam_ignoredomain", auth_init_sam_ignoredomain);
return NT_STATUS_OK;
}
-NTSTATUS auth_samba4_init(void);
-NTSTATUS auth_samba4_init(void)
+NTSTATUS auth_samba4_init(TALLOC_CTX *mem_ctx);
+NTSTATUS auth_samba4_init(TALLOC_CTX *mem_ctx)
{
smb_register_auth(AUTH_INTERFACE_VERSION, "samba4",
auth_init_samba4);
return NT_STATUS_OK;
}
-NTSTATUS auth_script_init(void);
-NTSTATUS auth_script_init(void)
+NTSTATUS auth_script_init(TALLOC_CTX *);
+NTSTATUS auth_script_init(TALLOC_CTX *ctx)
{
return smb_register_auth(AUTH_INTERFACE_VERSION, "script", auth_init_script);
}
return NT_STATUS_OK;
}
-NTSTATUS auth_unix_init(void)
+NTSTATUS auth_unix_init(TALLOC_CTX *mem_ctx)
{
return smb_register_auth(AUTH_INTERFACE_VERSION, "unix", auth_init_unix);
}
return NT_STATUS_OK;
}
-NTSTATUS auth_winbind_init(void)
+NTSTATUS auth_winbind_init(TALLOC_CTX *mem_ctx)
{
return smb_register_auth(AUTH_INTERFACE_VERSION, "winbind", auth_init_winbind);
}
/* The following definitions come from auth/auth_builtin.c */
-NTSTATUS auth_builtin_init(void);
+NTSTATUS auth_builtin_init(TALLOC_CTX *mem_ctx);
/* The following definitions come from auth/auth_domain.c */
void attempt_machine_password_change(void);
-NTSTATUS auth_domain_init(void);
+NTSTATUS auth_domain_init(TALLOC_CTX *mem_ctx);
/* The following definitions come from auth/auth_generic.c */
TALLOC_CTX *mem_ctx,
const struct auth_usersupplied_info *user_info,
struct netr_SamInfo3 **pinfo3);
-NTSTATUS auth_sam_init(void);
+NTSTATUS auth_sam_init(TALLOC_CTX *mem_ctx);
/* The following definitions come from auth/auth_unix.c */
-NTSTATUS auth_unix_init(void);
+NTSTATUS auth_unix_init(TALLOC_CTX *mem_ctx);
/* The following definitions come from auth/auth_util.c */
struct tsocket_address;
/* The following definitions come from auth/auth_winbind.c */
-NTSTATUS auth_winbind_init(void);
+NTSTATUS auth_winbind_init(TALLOC_CTX *mem_ctx);
/* The following definitions come from auth/server_info.c */
/* The following definitions come from auth/auth_samba4.c */
-NTSTATUS auth_samba4_init(void);
+NTSTATUS auth_samba4_init(TALLOC_CTX *mem_ctx);
#endif /* _AUTH_PROTO_H_ */
/* Changed from 1 -> 2 to add the logon_parameters field. */
/* Changed from 2 -> 3 when we reworked many auth structures to use IDL or be in common with Samba4 */
/* Changed from 3 -> 4 when we reworked added the flags */
-#define AUTH_INTERFACE_VERSION 4
+/* Changed from 4 -> 5 as module init functions now take a TALLOC_CTX * */
+#define AUTH_INTERFACE_VERSION 5
#include "auth/proto.h"
/* Updated to 4, completely new interface, SSS */
/* Updated to 5, simplified interface by Volker */
+/* Updated to 6, modules now take TALLOC_CTX * init parameter. */
-#define SMB_IDMAP_INTERFACE_VERSION 5
+#define SMB_IDMAP_INTERFACE_VERSION 6
#include "librpc/gen_ndr/idmap.h"
/* The following definitions come from winbindd/nss_info_template.c */
-NTSTATUS nss_info_template_init( void );
+NTSTATUS nss_info_template_init(TALLOC_CTX *mem_ctx);
#endif /* _IDMAP_NSS_H_ */
* Changed to 23, new idmap control functions
* Changed to 24, removed uid_to_sid and gid_to_sid, replaced with id_to_sid
* Leave at 24, add optional get_trusteddom_creds()
+ * Change to 25, loadable modules now have a TALLOC_CTX * parameter in init.
*/
-#define PASSDB_INTERFACE_VERSION 24
+#define PASSDB_INTERFACE_VERSION 25
struct pdb_methods
{
#ifndef _SMB_PERFCOUNT_H_
#define _SMB_PERFCOUNT_H_
-#define SMB_PERFCOUNTER_INTERFACE_VERSION 1
+/* Change to 2, loadable modules now take a TALLOC_CTX * parameter. */
+#define SMB_PERFCOUNTER_INTERFACE_VERSION 2
struct smb_perfcount_data{
struct smb_perfcount_handlers *handlers;
/* Version 35 - Add bool use_ofd_locks to struct files_struct */
/* Bump to version 36 - Samba 4.6 will ship with that */
/* Version 36 - Remove is_offline and set_offline */
+/* Version 37 - Module init functions now take a TALLOC_CTX * parameter. */
-#define SMB_VFS_INTERFACE_VERSION 36
+#define SMB_VFS_INTERFACE_VERSION 37
/*
All intercepted VFS operations must be declared as static functions inside module source
};
static_decl_perfcount;
-NTSTATUS perfcount_test_init(void)
+NTSTATUS perfcount_test_init(TALLOC_CTX *ctx)
{
return smb_register_perfcounter(SMB_PERFCOUNTER_INTERFACE_VERSION,
"pc_test", &perfcount_test_handlers);
};
static_decl_vfs;
-NTSTATUS vfs_acl_tdb_init(void)
+NTSTATUS vfs_acl_tdb_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "acl_tdb",
&vfs_acl_tdb_fns);
};
static_decl_vfs;
-NTSTATUS vfs_acl_xattr_init(void)
+NTSTATUS vfs_acl_xattr_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "acl_xattr",
&vfs_acl_xattr_fns);
.sys_acl_blob_get_fd_fn = afsacl_sys_acl_blob_get_fd
};
-NTSTATUS vfs_afsacl_init(void);
-NTSTATUS vfs_afsacl_init(void)
+NTSTATUS vfs_afsacl_init(TALLOC_CTX *);
+NTSTATUS vfs_afsacl_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "afsacl",
&vfs_afsacl_fns);
.fsync_recv_fn = aio_fork_fsync_recv,
};
-NTSTATUS vfs_aio_fork_init(void);
-NTSTATUS vfs_aio_fork_init(void)
+NTSTATUS vfs_aio_fork_init(TALLOC_CTX *);
+NTSTATUS vfs_aio_fork_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"aio_fork", &vfs_aio_fork_fns);
};
static_decl_vfs;
-NTSTATUS vfs_aio_linux_init(void)
+NTSTATUS vfs_aio_linux_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"aio_linux", &vfs_aio_linux_fns);
#endif
};
-NTSTATUS vfs_aio_pthread_init(void);
-NTSTATUS vfs_aio_pthread_init(void)
+NTSTATUS vfs_aio_pthread_init(TALLOC_CTX *);
+NTSTATUS vfs_aio_pthread_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"aio_pthread", &vfs_aio_pthread_fns);
.sys_acl_delete_def_file_fn = aixacl_sys_acl_delete_def_file,
};
-NTSTATUS vfs_aixacl_init(void);
-NTSTATUS vfs_aixacl_init(void)
+NTSTATUS vfs_aixacl_init(TALLOC_CTX *);
+NTSTATUS vfs_aixacl_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "aixacl",
&vfs_aixacl_fns);
.sys_acl_delete_def_file_fn = aixjfs2_sys_acl_delete_def_file
};
-NTSTATUS vfs_aixacl2_init(void);
-NTSTATUS vfs_aixacl2_init(void)
+NTSTATUS vfs_aixacl2_init(TALLOC_CTX *);
+NTSTATUS vfs_aixacl2_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, AIXACL2_MODULE_NAME,
&vfs_aixacl2_fns);
};
static_decl_vfs;
-NTSTATUS vfs_audit_init(void)
+NTSTATUS vfs_audit_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "audit",
&vfs_audit_fns);
.snap_delete_fn = btrfs_snap_delete,
};
-NTSTATUS vfs_btrfs_init(void);
-NTSTATUS vfs_btrfs_init(void)
+NTSTATUS vfs_btrfs_init(TALLOC_CTX *);
+NTSTATUS vfs_btrfs_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"btrfs", &btrfs_fns);
* -------------------------------------------------------------------------
*/
-NTSTATUS vfs_cacheprime_init(void);
-NTSTATUS vfs_cacheprime_init(void)
+NTSTATUS vfs_cacheprime_init(TALLOC_CTX *);
+NTSTATUS vfs_cacheprime_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, MODULE,
&vfs_cacheprime_fns);
.fsetxattr_fn = cap_fsetxattr
};
-NTSTATUS vfs_cap_init(void);
-NTSTATUS vfs_cap_init(void)
+NTSTATUS vfs_cap_init(TALLOC_CTX *);
+NTSTATUS vfs_cap_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "cap",
&vfs_cap_fns);
};
static_decl_vfs;
-NTSTATUS vfs_catia_init(void)
+NTSTATUS vfs_catia_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
.aio_force_fn = cephwrap_aio_force,
};
-NTSTATUS vfs_ceph_init(void);
-NTSTATUS vfs_ceph_init(void)
+NTSTATUS vfs_ceph_init(TALLOC_CTX *);
+NTSTATUS vfs_ceph_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"ceph", &ceph_fns);
.ftruncate_fn = commit_ftruncate
};
-NTSTATUS vfs_commit_init(void);
-NTSTATUS vfs_commit_init(void)
+NTSTATUS vfs_commit_init(TALLOC_CTX *);
+NTSTATUS vfs_commit_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, MODULE,
&vfs_commit_fns);
.rename_fn = crossrename_rename
};
-NTSTATUS vfs_crossrename_init(void);
-NTSTATUS vfs_crossrename_init(void)
+NTSTATUS vfs_crossrename_init(TALLOC_CTX *);
+NTSTATUS vfs_crossrename_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, MODULE,
&vfs_crossrename_fns);
.durable_reconnect_fn = vfswrap_durable_reconnect,
};
-NTSTATUS vfs_default_init(void);
-NTSTATUS vfs_default_init(void)
+NTSTATUS vfs_default_init(TALLOC_CTX *);
+NTSTATUS vfs_default_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
DEFAULT_VFS_MODULE_NAME, &vfs_default_fns);
.set_quota_fn = default_quota_set_quota
};
-NTSTATUS vfs_default_quota_init(void);
-NTSTATUS vfs_default_quota_init(void)
+NTSTATUS vfs_default_quota_init(TALLOC_CTX *);
+NTSTATUS vfs_default_quota_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, DEFAULT_QUOTA_NAME,
&vfs_default_quota_fns);
.get_dfs_referrals_fn = dfs_samba4_get_referrals,
};
-NTSTATUS vfs_dfs_samba4_init(void);
-NTSTATUS vfs_dfs_samba4_init(void)
+NTSTATUS vfs_dfs_samba4_init(TALLOC_CTX *);
+NTSTATUS vfs_dfs_samba4_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
};
static_decl_vfs;
-NTSTATUS vfs_dirsort_init(void)
+NTSTATUS vfs_dirsort_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "dirsort",
&vfs_dirsort_fns);
.readlink_fn = expand_msdfs_readlink
};
-NTSTATUS vfs_expand_msdfs_init(void);
-NTSTATUS vfs_expand_msdfs_init(void)
+NTSTATUS vfs_expand_msdfs_init(TALLOC_CTX *);
+NTSTATUS vfs_expand_msdfs_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "expand_msdfs",
&vfs_expand_msdfs_fns);
};
static_decl_vfs;
-NTSTATUS vfs_extd_audit_init(void)
+NTSTATUS vfs_extd_audit_init(TALLOC_CTX *ctx)
{
NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"extd_audit", &vfs_extd_audit_fns);
};
-NTSTATUS vfs_fake_acls_init(void);
-NTSTATUS vfs_fake_acls_init(void)
+NTSTATUS vfs_fake_acls_init(TALLOC_CTX *);
+NTSTATUS vfs_fake_acls_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fake_acls",
&vfs_fake_acls_fns);
};
static_decl_vfs;
-NTSTATUS vfs_fake_dfq_init(void)
+NTSTATUS vfs_fake_dfq_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fake_dfq",
&vfs_fake_dfq_fns);
.fstat_fn = fake_perms_fstat
};
-NTSTATUS vfs_fake_perms_init(void);
-NTSTATUS vfs_fake_perms_init(void)
+NTSTATUS vfs_fake_perms_init(TALLOC_CTX *);
+NTSTATUS vfs_fake_perms_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fake_perms",
&vfs_fake_perms_fns);
.file_id_create_fn = fileid_file_id_create
};
-NTSTATUS vfs_fileid_init(void);
-NTSTATUS vfs_fileid_init(void)
+NTSTATUS vfs_fileid_init(TALLOC_CTX *);
+NTSTATUS vfs_fileid_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
.fset_nt_acl_fn = fruit_fset_nt_acl,
};
-NTSTATUS vfs_fruit_init(void);
-NTSTATUS vfs_fruit_init(void)
+NTSTATUS vfs_fruit_init(TALLOC_CTX *);
+NTSTATUS vfs_fruit_init(TALLOC_CTX *ctx)
{
NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fruit",
&vfs_fruit_fns);
};
static_decl_vfs;
-NTSTATUS vfs_full_audit_init(void)
+NTSTATUS vfs_full_audit_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
.durable_reconnect_fn = NULL,
};
-NTSTATUS vfs_glusterfs_init(void);
-NTSTATUS vfs_glusterfs_init(void)
+NTSTATUS vfs_glusterfs_init(TALLOC_CTX *);
+NTSTATUS vfs_glusterfs_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"glusterfs", &glusterfs_fns);
.ftruncate_fn = vfs_gpfs_ftruncate
};
-NTSTATUS vfs_gpfs_init(void);
-NTSTATUS vfs_gpfs_init(void)
+NTSTATUS vfs_gpfs_init(TALLOC_CTX *);
+NTSTATUS vfs_gpfs_init(TALLOC_CTX *ctx)
{
int ret;
.sys_acl_delete_def_file_fn = hpuxacl_sys_acl_delete_def_file,
};
-NTSTATUS vfs_hpuxacl_init(void)
+NTSTATUS vfs_hpuxacl_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "hpuxacl",
&hpuxacl_fns);
.chmod_acl_fn = linux_xfs_sgid_chmod_acl,
};
-NTSTATUS vfs_linux_xfs_sgid_init(void);
-NTSTATUS vfs_linux_xfs_sgid_init(void)
+NTSTATUS vfs_linux_xfs_sgid_init(TALLOC_CTX *);
+NTSTATUS vfs_linux_xfs_sgid_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"linux_xfs_sgid", &linux_xfs_sgid_fns);
/* aio operations */
};
-NTSTATUS vfs_media_harmony_init(void);
-NTSTATUS vfs_media_harmony_init(void)
+NTSTATUS vfs_media_harmony_init(TALLOC_CTX *);
+NTSTATUS vfs_media_harmony_init(TALLOC_CTX *ctx)
{
NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"media_harmony", &vfs_mh_fns);
.lchown_fn = atalk_lchown,
};
-NTSTATUS vfs_netatalk_init(void);
-NTSTATUS vfs_netatalk_init(void)
+NTSTATUS vfs_netatalk_init(TALLOC_CTX *);
+NTSTATUS vfs_netatalk_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "netatalk",
&vfs_netatalk_fns);
.fset_nt_acl_fn = nfs4acl_xattr_fset_nt_acl,
};
-NTSTATUS vfs_nfs4acl_xattr_init(void);
-NTSTATUS vfs_nfs4acl_xattr_init(void)
+NTSTATUS vfs_nfs4acl_xattr_init(TALLOC_CTX *);
+NTSTATUS vfs_nfs4acl_xattr_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "nfs4acl_xattr",
&nfs4acl_xattr_fns);
.fget_dos_attributes_fn = offline_fget_dos_attributes,
};
-NTSTATUS vfs_offline_init(void);
-NTSTATUS vfs_offline_init(void)
+NTSTATUS vfs_offline_init(TALLOC_CTX *);
+NTSTATUS vfs_offline_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "offline",
&offline_fns);
};
static_decl_vfs;
-NTSTATUS vfs_posix_eadb_init(void)
+NTSTATUS vfs_posix_eadb_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "posix_eadb",
&vfs_posix_eadb_fns);
.sys_acl_delete_def_file_fn = posixacl_sys_acl_delete_def_file,
};
-NTSTATUS vfs_posixacl_init(void);
-NTSTATUS vfs_posixacl_init(void)
+NTSTATUS vfs_posixacl_init(TALLOC_CTX *);
+NTSTATUS vfs_posixacl_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "posixacl",
&posixacl_fns);
int posixacl_sys_acl_delete_def_file(vfs_handle_struct *handle,
const char *path);
-NTSTATUS vfs_posixacl_init(void);
+NTSTATUS vfs_posixacl_init(TALLOC_CTX *);
#endif
.connect_fn = prealloc_connect,
};
-NTSTATUS vfs_prealloc_init(void);
-NTSTATUS vfs_prealloc_init(void)
+NTSTATUS vfs_prealloc_init(TALLOC_CTX *);
+NTSTATUS vfs_prealloc_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
MODULE, &prealloc_fns);
.open_fn = preopen_open
};
-NTSTATUS vfs_preopen_init(void);
-NTSTATUS vfs_preopen_init(void)
+NTSTATUS vfs_preopen_init(TALLOC_CTX *);
+NTSTATUS vfs_preopen_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"preopen", &vfs_preopen_fns);
Module initialization boilerplate.
*******************************************************************/
-NTSTATUS vfs_readahead_init(void);
-NTSTATUS vfs_readahead_init(void)
+NTSTATUS vfs_readahead_init(TALLOC_CTX *);
+NTSTATUS vfs_readahead_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "readahead",
&vfs_readahead_fns);
.connect_fn = readonly_connect
};
-NTSTATUS vfs_readonly_init(void);
-NTSTATUS vfs_readonly_init(void)
+NTSTATUS vfs_readonly_init(TALLOC_CTX *);
+NTSTATUS vfs_readonly_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, MODULE_NAME,
&vfs_readonly_fns);
.unlink_fn = recycle_unlink
};
-NTSTATUS vfs_recycle_init(void);
-NTSTATUS vfs_recycle_init(void)
+NTSTATUS vfs_recycle_init(TALLOC_CTX *);
+NTSTATUS vfs_recycle_init(TALLOC_CTX *ctx)
{
NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "recycle",
&vfs_recycle_fns);
.get_shadow_copy_data_fn = shadow_copy_get_shadow_copy_data,
};
-NTSTATUS vfs_shadow_copy_init(void);
-NTSTATUS vfs_shadow_copy_init(void)
+NTSTATUS vfs_shadow_copy_init(TALLOC_CTX *);
+NTSTATUS vfs_shadow_copy_init(TALLOC_CTX *ctx)
{
NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"shadow_copy", &vfs_shadow_copy_fns);
.connectpath_fn = shadow_copy2_connectpath,
};
-NTSTATUS vfs_shadow_copy2_init(void);
-NTSTATUS vfs_shadow_copy2_init(void)
+NTSTATUS vfs_shadow_copy2_init(TALLOC_CTX *);
+NTSTATUS vfs_shadow_copy2_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"shadow_copy2", &vfs_shadow_copy2_fns);
.snap_delete_fn = shell_snap_delete,
};
-NTSTATUS vfs_shell_snap_init(void);
-NTSTATUS vfs_shell_snap_init(void)
+NTSTATUS vfs_shell_snap_init(TALLOC_CTX *);
+NTSTATUS vfs_shell_snap_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"shell_snap", &shell_snap_fns);
.get_real_filename_fn = snapper_gmt_get_real_filename,
};
-NTSTATUS vfs_snapper_init(void);
-NTSTATUS vfs_snapper_init(void)
+NTSTATUS vfs_snapper_init(TALLOC_CTX *);
+NTSTATUS vfs_snapper_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"snapper", &snapper_fns);
.sys_acl_delete_def_file_fn = solarisacl_sys_acl_delete_def_file,
};
-NTSTATUS vfs_solarisacl_init(void);
-NTSTATUS vfs_solarisacl_init(void)
+NTSTATUS vfs_solarisacl_init(TALLOC_CTX *);
+NTSTATUS vfs_solarisacl_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "solarisacl",
&solarisacl_fns);
.streaminfo_fn = streams_depot_streaminfo,
};
-NTSTATUS vfs_streams_depot_init(void);
-NTSTATUS vfs_streams_depot_init(void)
+NTSTATUS vfs_streams_depot_init(TALLOC_CTX *);
+NTSTATUS vfs_streams_depot_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "streams_depot",
&vfs_streams_depot_fns);
.streaminfo_fn = streams_xattr_streaminfo,
};
-NTSTATUS vfs_streams_xattr_init(void);
-NTSTATUS vfs_streams_xattr_init(void)
+NTSTATUS vfs_streams_xattr_init(TALLOC_CTX *);
+NTSTATUS vfs_streams_xattr_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "streams_xattr",
&vfs_streams_xattr_fns);
};
static_decl_vfs;
-NTSTATUS vfs_syncops_init(void)
+NTSTATUS vfs_syncops_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
};
-NTSTATUS vfs_time_audit_init(void);
-NTSTATUS vfs_time_audit_init(void)
+NTSTATUS vfs_time_audit_init(TALLOC_CTX *);
+NTSTATUS vfs_time_audit_init(TALLOC_CTX *ctx)
{
smb_vfs_assert_all_fns(&vfs_time_audit_fns, "time_audit");
.sys_acl_delete_def_file_fn = tru64acl_sys_acl_delete_def_file,
};
-NTSTATUS vfs_tru64acl_init(void);
-NTSTATUS vfs_tru64acl_init(void)
+NTSTATUS vfs_tru64acl_init(TALLOC_CTX *);
+NTSTATUS vfs_tru64acl_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "tru64acl",
&tru64acl_fns);
.fget_dos_attributes_fn = tsmsm_fget_dos_attributes,
};
-NTSTATUS vfs_tsmsm_init(void);
-NTSTATUS vfs_tsmsm_init(void)
+NTSTATUS vfs_tsmsm_init(TALLOC_CTX *);
+NTSTATUS vfs_tsmsm_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"tsmsm", &tsmsm_fns);
.setxattr_fn = um_setxattr,
};
-NTSTATUS vfs_unityed_media_init(void);
-NTSTATUS vfs_unityed_media_init(void)
+NTSTATUS vfs_unityed_media_init(TALLOC_CTX *);
+NTSTATUS vfs_unityed_media_init(TALLOC_CTX *ctx)
{
NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"unityed_media", &vfs_um_fns);
.fsetxattr_fn = vxfs_fset_xattr,
};
-NTSTATUS vfs_vxfs_init(void);
-NTSTATUS vfs_vxfs_init(void)
+NTSTATUS vfs_vxfs_init(TALLOC_CTX *);
+NTSTATUS vfs_vxfs_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "vxfs",
&vfs_vxfs_fns);
.create_file_fn = vfs_worm_create_file,
};
-NTSTATUS vfs_worm_init(void);
-NTSTATUS vfs_worm_init(void)
+NTSTATUS vfs_worm_init(TALLOC_CTX *);
+NTSTATUS vfs_worm_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
.connect_fn = xattr_tdb_connect,
};
-NTSTATUS vfs_xattr_tdb_init(void);
-NTSTATUS vfs_xattr_tdb_init(void)
+NTSTATUS vfs_xattr_tdb_init(TALLOC_CTX *);
+NTSTATUS vfs_xattr_tdb_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "xattr_tdb",
&vfs_xattr_tdb_fns);
.fset_nt_acl_fn = zfsacl_fset_nt_acl,
};
-NTSTATUS vfs_zfsacl_init(void);
-NTSTATUS vfs_zfsacl_init(void)
+NTSTATUS vfs_zfsacl_init(TALLOC_CTX *);
+NTSTATUS vfs_zfsacl_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "zfsacl",
&zfsacl_fns);
if(initialized) {
return;
}
- static_init_pdb;
+ static_init_pdb(NULL);
initialized = True;
}
return NT_STATUS_OK;
}
-NTSTATUS pdb_ldapsam_init(void)
+NTSTATUS pdb_ldapsam_init(TALLOC_CTX *ctx)
{
NTSTATUS nt_status;
}
/* Let pdb_nds register backends */
- pdb_nds_init();
+ pdb_nds_init(ctx);
return NT_STATUS_OK;
}
const char** get_userattr_list( TALLOC_CTX *mem_ctx, int schema_ver );
NTSTATUS pdb_ldapsam_init_common(struct pdb_methods **pdb_method, const char *location);
-NTSTATUS pdb_ldapsam_init(void);
+NTSTATUS pdb_ldapsam_init(TALLOC_CTX *);
int ldapsam_search_suffix_by_name(struct ldapsam_privates *ldap_state,
const char *user,
LDAPMessage ** result,
return nt_status;
}
-NTSTATUS pdb_nds_init(void)
+NTSTATUS pdb_nds_init(TALLOC_CTX *ctx)
{
NTSTATUS nt_status;
if (!NT_STATUS_IS_OK(nt_status = smb_register_passdb(PASSDB_INTERFACE_VERSION, "NDS_ldapsam", pdb_init_NDS_ldapsam)))
struct smbldap_state *ldap_state,
char *object_dn,
const char *pwd );
-NTSTATUS pdb_nds_init(void);
+NTSTATUS pdb_nds_init(TALLOC_CTX *);
#endif /* _PASSDB_PDB_NDS_H_ */
return status;
}
-NTSTATUS pdb_samba_dsdb_init(void);
-NTSTATUS pdb_samba_dsdb_init(void)
+NTSTATUS pdb_samba_dsdb_init(TALLOC_CTX *);
+NTSTATUS pdb_samba_dsdb_init(TALLOC_CTX *ctx)
{
NTSTATUS status = smb_register_passdb(PASSDB_INTERFACE_VERSION, "samba_dsdb",
pdb_init_samba_dsdb);
return NT_STATUS_OK;
}
-NTSTATUS pdb_smbpasswd_init(void)
+NTSTATUS pdb_smbpasswd_init(TALLOC_CTX *ctx)
{
return smb_register_passdb(PASSDB_INTERFACE_VERSION, "smbpasswd", pdb_init_smbpasswd);
}
/* The following definitions come from passdb/pdb_smbpasswd.c */
-NTSTATUS pdb_smbpasswd_init(void) ;
+NTSTATUS pdb_smbpasswd_init(TALLOC_CTX *) ;
#endif /* _PASSDB_PDB_SMBPASSWD_H_ */
return NT_STATUS_OK;
}
-NTSTATUS pdb_tdbsam_init(void)
+NTSTATUS pdb_tdbsam_init(TALLOC_CTX *ctx)
{
return smb_register_passdb(PASSDB_INTERFACE_VERSION, "tdbsam", pdb_init_tdbsam);
}
#ifndef _PASSDB_PDB_TDB_H_
#define _PASSDB_PDB_TDB_H_
-NTSTATUS pdb_tdbsam_init(void);
+NTSTATUS pdb_tdbsam_init(TALLOC_CTX *);
#endif /* _PASSDB_PDB_TDB_H_ */
};
static_decl_rpc;
-NTSTATUS rpc_mdssvc_module_init(void)
+NTSTATUS rpc_mdssvc_module_init(TALLOC_CTX *mem_ctx)
{
DBG_DEBUG("Registering mdsvc RPC service\n");
}
/* Initialize static subsystems */
- static_init_rpc;
+ static_init_rpc(NULL);
/* Initialize shared modules */
mod_init_fns = load_samba_modules(tmp_ctx, "rpc");
goto done;
}
- ok = run_init_functions(mod_init_fns);
+ ok = run_init_functions(NULL, mod_init_fns);
if (!ok) {
DBG_ERR("Initializing shared RPC modules failed\n");
goto done;
}
if(!backends) {
- static_init_vfs;
+ static_init_vfs(NULL);
}
DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object));
DEBUG(10, ("idmap_init(): calling static_init_idmap\n"));
- static_init_idmap;
+ static_init_idmap(NULL);
initialized = true;
};
static_decl_idmap;
-NTSTATUS idmap_ad_init(void)
+NTSTATUS idmap_ad_init(TALLOC_CTX *ctx)
{
NTSTATUS status;
return status;
}
- status = idmap_ad_nss_init();
+ status = idmap_ad_nss_init(ctx);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
Initialize the plugins
***********************************************************************/
-NTSTATUS idmap_ad_nss_init(void)
+NTSTATUS idmap_ad_nss_init(TALLOC_CTX *mem_ctx)
{
NTSTATUS status;
};
static_decl_idmap;
-NTSTATUS idmap_autorid_init(void)
+NTSTATUS idmap_autorid_init(TALLOC_CTX *ctx)
{
return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION,
"autorid", &autorid_methods);
**********************************************************************/
static_decl_idmap;
-NTSTATUS idmap_hash_init(void)
+NTSTATUS idmap_hash_init(TALLOC_CTX *ctx)
{
static NTSTATUS idmap_status = NT_STATUS_UNSUCCESSFUL;
static NTSTATUS nss_status = NT_STATUS_UNSUCCESSFUL;
.allocate_id = idmap_ldap_allocate_id,
};
-NTSTATUS idmap_ldap_init(void);
-NTSTATUS idmap_ldap_init(void)
+NTSTATUS idmap_ldap_init(TALLOC_CTX *);
+NTSTATUS idmap_ldap_init(TALLOC_CTX *ctx)
{
return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "ldap",
&idmap_ldap_methods);
.sids_to_unixids = idmap_nss_sids_to_unixids,
};
-NTSTATUS idmap_nss_init(void)
+NTSTATUS idmap_nss_init(TALLOC_CTX *mem_ctx)
{
return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "nss", &nss_methods);
}
.sids_to_unixids = idmap_pdb_sids_to_unixids,
};
-NTSTATUS idmap_passdb_init(void)
+NTSTATUS idmap_passdb_init(TALLOC_CTX *mem_ctx)
{
return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "passdb", &passdb_methods);
}
/* The following definitions come from winbindd/idmap_nss.c */
-NTSTATUS idmap_nss_init(void);
+NTSTATUS idmap_nss_init(TALLOC_CTX *mem_ctx);
/* The following definitions come from winbindd/idmap_passdb.c */
-NTSTATUS idmap_passdb_init(void);
+NTSTATUS idmap_passdb_init(TALLOC_CTX *mem_ctx);
/* The following definitions come from winbindd/idmap_tdb.c */
-NTSTATUS idmap_tdb_init(void);
+NTSTATUS idmap_tdb_init(TALLOC_CTX *mem_ctx);
/* The following definitions come from winbindd/idmap_util.c */
/* max number of ids requested per LDAP batch query */
#define IDMAP_LDAP_MAX_IDS 30
-NTSTATUS idmap_ad_nss_init(void);
+NTSTATUS idmap_ad_nss_init(TALLOC_CTX *mem_ctx);
#endif /* _WINBINDD_IDMAP_PROTO_H_ */
};
static_decl_idmap;
-NTSTATUS idmap_rfc2307_init(void)
+NTSTATUS idmap_rfc2307_init(TALLOC_CTX *ctx)
{
return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "rfc2307",
&rfc2307_methods);
};
static_decl_idmap;
-NTSTATUS idmap_rid_init(void)
+NTSTATUS idmap_rid_init(TALLOC_CTX *ctx)
{
return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "rid", &rid_methods);
}
};
static_decl_idmap;
-NTSTATUS idmap_script_init(void)
+NTSTATUS idmap_script_init(TALLOC_CTX *ctx)
{
return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "script", &db_methods);
}
.allocate_id = idmap_tdb_common_get_new_id,
};
-NTSTATUS idmap_tdb_init(void)
+NTSTATUS idmap_tdb_init(TALLOC_CTX *mem_ctx)
{
DEBUG(10, ("calling idmap_tdb_init\n"));
};
static_decl_idmap;
-NTSTATUS idmap_tdb2_init(void)
+NTSTATUS idmap_tdb2_init(TALLOC_CTX *ctx)
{
return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "tdb2", &db_methods);
}
nss_backend = nss_get_backend("template");
if (nss_backend == NULL) {
- static_init_nss_info;
+ static_init_nss_info(NULL);
}
/* Create the list of nss_domains (loading any shared plugins
.close_fn = nss_template_close
};
-NTSTATUS nss_info_template_init( void )
+NTSTATUS nss_info_template_init(TALLOC_CTX *mem_ctx)
{
return smb_register_idmap_nss(SMB_NSS_INFO_INTERFACE_VERSION,
"template",
if p in static_list:
decl_list=""
for entry in static_list[p]:
- decl_list += "extern NTSTATUS %s_init(void); " % entry
+ decl_list += "extern NTSTATUS %s_init(TALLOC_CTX *mem_ctx); " % entry
conf.env[static_env].append('%s' % entry)
decl_list = decl_list.rstrip()
conf.DEFINE('static_decl_%s' % p, decl_list)
- conf.DEFINE('static_init_%s' % p, '{ %s_init(); }' % '_init(); '.join(static_list[p]))
+ conf.DEFINE('static_init_%s(mem_ctx)' % p, '{ %s_init((mem_ctx)); }' % '_init((mem_ctx)); '.join(static_list[p]))
else:
conf.DEFINE('static_decl_%s' % p, '')
- conf.DEFINE('static_init_%s' % p, '{}')
+ conf.DEFINE('static_init_%s(mem_ctx)' % p, '{}')
if p in shared_list:
for entry in shared_list[p]:
conf.DEFINE('%s_init' % entry, 'samba_init_module')
uint8_t *pauthoritative);
NTSTATUS auth4_init(void);
NTSTATUS auth_register(const struct auth_operations *ops);
-NTSTATUS server_service_auth_init(void);
+NTSTATUS server_service_auth_init(TALLOC_CTX *ctx);
NTSTATUS authenticate_ldap_simple_bind(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
struct imessaging_context *msg,
#define gss_mech_spnego (&spnego_mech_oid_desc)
#endif
-_PUBLIC_ NTSTATUS gensec_gssapi_init(void);
+_PUBLIC_ NTSTATUS gensec_gssapi_init(TALLOC_CTX *);
static size_t gensec_gssapi_max_input_size(struct gensec_security *gensec_security);
static size_t gensec_gssapi_max_wrapped_size(struct gensec_security *gensec_security);
.priority = GENSEC_GSSAPI
};
-_PUBLIC_ NTSTATUS gensec_gssapi_init(void)
+_PUBLIC_ NTSTATUS gensec_gssapi_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
#include "auth/kerberos/pac_utils.h"
#include "gensec_krb5.h"
-_PUBLIC_ NTSTATUS gensec_krb5_init(void);
+_PUBLIC_ NTSTATUS gensec_krb5_init(TALLOC_CTX *);
enum GENSEC_KRB5_STATE {
GENSEC_KRB5_SERVER_START,
.priority = GENSEC_KRB5
};
-_PUBLIC_ NTSTATUS gensec_krb5_init(void)
+_PUBLIC_ NTSTATUS gensec_krb5_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
_PUBLIC_ NTSTATUS auth4_init(void)
{
static bool initialized = false;
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_auth4_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_auth4_MODULES };
if (initialized) return NT_STATUS_OK;
initialized = true;
- run_init_functions(static_init);
+ run_init_functions(NULL, static_init);
return NT_STATUS_OK;
}
#include "auth/ntlm/auth_proto.h"
#include "param/param.h"
-_PUBLIC_ NTSTATUS auth4_anonymous_init(void);
+_PUBLIC_ NTSTATUS auth4_anonymous_init(TALLOC_CTX *);
/**
* Return a anonymous logon for anonymous users (username = "")
.check_password = anonymous_check_password
};
-_PUBLIC_ NTSTATUS auth4_anonymous_init(void)
+_PUBLIC_ NTSTATUS auth4_anonymous_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
#include "auth/ntlm/auth_proto.h"
#include "libcli/security/security.h"
-_PUBLIC_ NTSTATUS auth4_developer_init(void);
+_PUBLIC_ NTSTATUS auth4_developer_init(TALLOC_CTX *);
static NTSTATUS name_to_ntstatus_want_check(struct auth_method_context *ctx,
TALLOC_CTX *mem_ctx,
.check_password = name_to_ntstatus_check_password
};
-_PUBLIC_ NTSTATUS auth4_developer_init(void)
+_PUBLIC_ NTSTATUS auth4_developer_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
.check_password = authsam_failtrusts_check_password,
};
-_PUBLIC_ NTSTATUS auth4_sam_init(void);
-_PUBLIC_ NTSTATUS auth4_sam_init(void)
+_PUBLIC_ NTSTATUS auth4_sam_init(TALLOC_CTX *);
+_PUBLIC_ NTSTATUS auth4_sam_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
#include "includes.h"
#include "auth/auth.h"
-NTSTATUS server_service_auth_init(void)
+NTSTATUS server_service_auth_init(TALLOC_CTX *ctx)
{
return auth4_init();
}
#include "../libcli/auth/pam_errors.h"
#include "param/param.h"
-_PUBLIC_ NTSTATUS auth4_unix_init(void);
+_PUBLIC_ NTSTATUS auth4_unix_init(TALLOC_CTX *);
/* TODO: look at how to best fill in parms retrieveing a struct passwd info
* except in case USER_INFO_DONT_CHECK_UNIX_ACCOUNT is set
.check_password = authunix_check_password
};
-_PUBLIC_ NTSTATUS auth4_unix_init(void)
+_PUBLIC_ NTSTATUS auth4_unix_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
#include "libcli/security/security.h"
#include "dsdb/samdb/samdb.h"
-_PUBLIC_ NTSTATUS auth4_winbind_init(void);
+_PUBLIC_ NTSTATUS auth4_winbind_init(TALLOC_CTX *);
static NTSTATUS winbind_want_check(struct auth_method_context *ctx,
TALLOC_CTX *mem_ctx,
.check_password = winbind_check_password_wbclient
};
-_PUBLIC_ NTSTATUS auth4_winbind_init(void)
+_PUBLIC_ NTSTATUS auth4_winbind_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
#include "../lib/tsocket/tsocket.h"
#include "libds/common/roles.h"
-NTSTATUS server_service_cldapd_init(void);
+NTSTATUS server_service_cldapd_init(TALLOC_CTX *);
/*
handle incoming cldap requests
/*
register ourselves as a available server
*/
-NTSTATUS server_service_cldapd_init(void)
+NTSTATUS server_service_cldapd_init(TALLOC_CTX *ctx)
{
return register_server_service("cldap", cldapd_task_init);
}
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_DNS
-NTSTATUS server_service_dns_init(void);
+NTSTATUS server_service_dns_init(TALLOC_CTX *);
/* hold information about one dns socket */
struct dns_socket {
}
}
-NTSTATUS server_service_dns_init(void)
+NTSTATUS server_service_dns_init(TALLOC_CTX *ctx)
{
return register_server_service("dns", dns_task_init);
}
#include "librpc/gen_ndr/ndr_irpc.h"
#include "libds/common/roles.h"
-NTSTATUS server_service_dnsupdate_init(void);
+NTSTATUS server_service_dnsupdate_init(TALLOC_CTX *);
struct dnsupdate_service {
struct task_server *task;
/*
register ourselves as a available server
*/
-NTSTATUS server_service_dnsupdate_init(void)
+NTSTATUS server_service_dnsupdate_init(TALLOC_CTX *ctx)
{
return register_server_service("dnsupdate", dnsupdate_task_init);
}
/*
register ourselves as a available server
*/
-NTSTATUS server_service_kcc_init(void)
+NTSTATUS server_service_kcc_init(TALLOC_CTX *ctx)
{
return register_server_service("kcc", kccsrv_task_init);
}
/*
register ourselves as a available server
*/
-NTSTATUS server_service_drepl_init(void)
+NTSTATUS server_service_drepl_init(TALLOC_CTX *ctx)
{
return register_server_service("drepl", dreplsrv_task_init);
}
#include "lib/tsocket/tsocket.h"
#include "libds/common/roles.h"
-NTSTATUS server_service_echo_init(void);
+NTSTATUS server_service_echo_init(TALLOC_CTX *);
/* Structure to hold an echo server socket */
struct echo_socket {
* This is the function you need to put into the wscript_build file as
* init_function. All the real work happens in "echo_task_init" above.
*/
-NTSTATUS server_service_echo_init(void)
+NTSTATUS server_service_echo_init(TALLOC_CTX *ctx)
{
return register_server_service("echo", echo_task_init);
}
#include <kdc.h>
#include <hdb.h>
-NTSTATUS server_service_kdc_init(void);
+NTSTATUS server_service_kdc_init(TALLOC_CTX *);
extern struct krb5plugin_windc_ftable windc_plugin_table;
/* called at smbd startup - register ourselves as a server service */
-NTSTATUS server_service_kdc_init(void)
+NTSTATUS server_service_kdc_init(TALLOC_CTX *ctx)
{
return register_server_service("kdc", kdc_task_init);
}
}
-NTSTATUS server_service_ldap_init(void)
+NTSTATUS server_service_ldap_init(TALLOC_CTX *ctx)
{
return register_server_service("ldap", ldapsrv_task_init);
}
#include "lib/com/com.h"
#include "librpc/gen_ndr/com_dcom.h"
-NTSTATUS com_simple_init(void);
+NTSTATUS com_simple_init(TALLOC_CTX *);
static struct IClassFactory_vtable simple_classobject_vtable;
static struct IStream_vtable simple_IStream_vtable;
simple_IStream_Write
};
-NTSTATUS com_simple_init(void)
+NTSTATUS com_simple_init(TALLOC_CTX *ctx)
{
struct GUID clsid;
struct IUnknown *class_object = talloc(talloc_autofree_context(), struct IUnknown);
#include "auth/credentials/credentials.h"
#include "lib/util/base64.h"
-_PUBLIC_ NTSTATUS gensec_http_basic_init(void);
+_PUBLIC_ NTSTATUS gensec_http_basic_init(TALLOC_CTX *);
struct gensec_http_basic_state {
enum {
.priority = GENSEC_EXTERNAL,
};
-_PUBLIC_ NTSTATUS gensec_http_basic_init(void)
+_PUBLIC_ NTSTATUS gensec_http_basic_init(TALLOC_CTX *ctx)
{
NTSTATUS status;
#include "auth/gensec/gensec_internal.h"
#include "lib/util/base64.h"
-_PUBLIC_ NTSTATUS gensec_http_ntlm_init(void);
+_PUBLIC_ NTSTATUS gensec_http_ntlm_init(TALLOC_CTX *);
struct gensec_http_ntlm_state {
struct gensec_security *sub;
.priority = GENSEC_EXTERNAL,
};
-_PUBLIC_ NTSTATUS gensec_http_ntlm_init(void)
+_PUBLIC_ NTSTATUS gensec_http_ntlm_init(TALLOC_CTX *ctx)
{
NTSTATUS status;
#include "dsdb/samdb/samdb.h"
#include "param/param.h"
-NTSTATUS server_service_nbtd_init(void);
+NTSTATUS server_service_nbtd_init(TALLOC_CTX *);
/*
startup the nbtd task
/*
register ourselves as a available server
*/
-NTSTATUS server_service_nbtd_init(void)
+NTSTATUS server_service_nbtd_init(TALLOC_CTX *ctx)
{
return register_server_service("nbt", nbtd_task_init);
}
#include "system/network.h"
#include "system/passwd.h"
-NTSTATUS server_service_ntp_signd_init(void);
+NTSTATUS server_service_ntp_signd_init(TALLOC_CTX *);
/*
top level context structure for the ntp_signd server
/* called at smbd startup - register ourselves as a server service */
-NTSTATUS server_service_ntp_signd_init(void)
+NTSTATUS server_service_ntp_signd_init(TALLOC_CTX *ctx)
{
return register_server_service("ntp_signd", ntp_signd_task_init);
}
void *parms;
};
-NTSTATUS ntvfs_cifs_init(void);
+NTSTATUS ntvfs_cifs_init(TALLOC_CTX *);
#define CHECK_UPSTREAM_OPEN do { \
if (!smbXcli_conn_is_connected(p->transport->conn)) { \
/*
initialise the CIFS->CIFS backend, registering ourselves with the ntvfs subsystem
*/
-NTSTATUS ntvfs_cifs_init(void)
+NTSTATUS ntvfs_cifs_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct ntvfs_ops ops;
/*
initialialise the POSIX disk backend, registering ourselves with the ntvfs subsystem
*/
-NTSTATUS ntvfs_cifs_posix_init(void)
+NTSTATUS ntvfs_cifs_posix_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct ntvfs_ops ops;
/*
initialialise the IPC backend, registering ourselves with the ntvfs subsystem
*/
-NTSTATUS ntvfs_ipc_init(void)
+NTSTATUS ntvfs_ipc_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct ntvfs_ops ops;
#include "system/filesys.h"
#include "lib/util/sys_rw.h"
-NTSTATUS ntvfs_nbench_init(void);
+NTSTATUS ntvfs_nbench_init(TALLOC_CTX *);
/* this is stored in ntvfs_private */
struct nbench_private {
/*
initialise the nbench backend, registering ourselves with the ntvfs subsystem
*/
-NTSTATUS ntvfs_nbench_init(void)
+NTSTATUS ntvfs_nbench_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct ntvfs_ops ops;
NTSTATUS ntvfs_init(struct loadparm_context *lp_ctx)
{
static bool initialized = false;
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_ntvfs_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_ntvfs_MODULES };
init_module_fn *shared_init;
shared_init = load_samba_modules(NULL, "ntvfs");
- run_init_functions(static_init);
- run_init_functions(shared_init);
+ run_init_functions(NULL, static_init);
+ run_init_functions(NULL, shared_init);
talloc_free(shared_init);
NTSTATUS pvfs_acl_init(void)
{
static bool initialized = false;
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_pvfs_acl_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_pvfs_acl_MODULES };
init_module_fn *shared_init;
shared_init = load_samba_modules(NULL, "pvfs_acl");
- run_init_functions(static_init);
- run_init_functions(shared_init);
+ run_init_functions(NULL, static_init);
+ run_init_functions(NULL, shared_init);
talloc_free(shared_init);
#include "librpc/gen_ndr/ndr_nfs4acl.h"
#include "libcli/security/security.h"
-NTSTATUS pvfs_acl_nfs4_init(void);
+NTSTATUS pvfs_acl_nfs4_init(TALLOC_CTX *);
#define ACE4_IDENTIFIER_GROUP 0x40
/*
initialise pvfs acl NFS4 backend
*/
-NTSTATUS pvfs_acl_nfs4_init(void)
+NTSTATUS pvfs_acl_nfs4_init(TALLOC_CTX *ctx)
{
struct pvfs_acl_ops ops = {
.name = "nfs4acl",
#include "../lib/util/unix_privs.h"
#include "librpc/gen_ndr/ndr_xattr.h"
-NTSTATUS pvfs_acl_xattr_init(void);
+NTSTATUS pvfs_acl_xattr_init(TALLOC_CTX *);
/*
load the current ACL from extended attributes
/*
initialise pvfs acl xattr backend
*/
-NTSTATUS pvfs_acl_xattr_init(void)
+NTSTATUS pvfs_acl_xattr_init(TALLOC_CTX *ctx)
{
struct pvfs_acl_ops ops = {
.name = "xattr",
/*
initialialise the POSIX disk backend, registering ourselves with the ntvfs subsystem
*/
-NTSTATUS ntvfs_posix_init(void)
+NTSTATUS ntvfs_posix_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct ntvfs_ops ops;
#include "ntvfs/ntvfs.h"
#include "param/param.h"
-NTSTATUS ntvfs_print_init(void);
+NTSTATUS ntvfs_print_init(TALLOC_CTX *);
/*
connect to a share - used when a tree_connect operation comes
/*
initialialise the print backend, registering ourselves with the ntvfs subsystem
*/
-NTSTATUS ntvfs_print_init(void)
+NTSTATUS ntvfs_print_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct ntvfs_ops ops;
/*
initialialise the POSIX disk backend, registering ourselves with the ntvfs subsystem
*/
-NTSTATUS ntvfs_simple_init(void)
+NTSTATUS ntvfs_simple_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct ntvfs_ops ops;
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
-NTSTATUS ntvfs_smb2_init(void);
+NTSTATUS ntvfs_smb2_init(TALLOC_CTX *);
struct cvfs_file {
struct cvfs_file *prev, *next;
/*
initialise the CIFS->CIFS backend, registering ourselves with the ntvfs subsystem
*/
-NTSTATUS ntvfs_smb2_init(void)
+NTSTATUS ntvfs_smb2_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct ntvfs_ops ops;
/*
initialialise the inotify module
*/
-NTSTATUS sys_notify_inotify_init(void);
-NTSTATUS sys_notify_inotify_init(void)
+NTSTATUS sys_notify_inotify_init(TALLOC_CTX *);
+NTSTATUS sys_notify_inotify_init(TALLOC_CTX *ctx)
{
/* register ourselves as a system inotify module */
return sys_notify_register(&inotify);
_PUBLIC_ NTSTATUS sys_lease_init(void)
{
static bool initialized = false;
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_sys_lease_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_sys_lease_MODULES };
if (initialized) return NT_STATUS_OK;
initialized = true;
- run_init_functions(static_init);
+ run_init_functions(NULL, static_init);
return NT_STATUS_OK;
}
#include "../lib/util/dlinklist.h"
#include "cluster/cluster.h"
-NTSTATUS sys_lease_linux_init(void);
+NTSTATUS sys_lease_linux_init(TALLOC_CTX *);
#define LINUX_LEASE_RT_SIGNAL (SIGRTMIN+1)
/*
initialialise the linux lease module
*/
-NTSTATUS sys_lease_linux_init(void)
+NTSTATUS sys_lease_linux_init(TALLOC_CTX *ctx)
{
/* register ourselves as a system lease module */
return sys_lease_register(&linux_lease_ops);
_PUBLIC_ NTSTATUS sys_notify_init(void)
{
static bool initialized = false;
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_sys_notify_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_sys_notify_MODULES };
if (initialized) return NT_STATUS_OK;
initialized = true;
- run_init_functions(static_init);
+ run_init_functions(NULL, static_init);
return NT_STATUS_OK;
}
#include <tevent.h>
#include "../lib/util/setid.h"
-NTSTATUS ntvfs_unixuid_init(void);
+NTSTATUS ntvfs_unixuid_init(TALLOC_CTX *);
struct unixuid_private {
struct security_unix_token *last_sec_ctx;
/*
initialise the unixuid backend, registering ourselves with the ntvfs subsystem
*/
-NTSTATUS ntvfs_unixuid_init(void)
+NTSTATUS ntvfs_unixuid_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
struct ntvfs_ops ops;
*/
NTSTATUS share_init(void)
{
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_share_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_share_MODULES };
- run_init_functions(static_init);
+ run_init_functions(NULL, static_init);
return NT_STATUS_OK;
}
#include "param/share.h"
#include "param/param.h"
-NTSTATUS share_classic_init(void);
+NTSTATUS share_classic_init(TALLOC_CTX *);
static NTSTATUS sclassic_init(TALLOC_CTX *mem_ctx,
const struct share_ops *ops,
.get_config = sclassic_get_config
};
-NTSTATUS share_classic_init(void)
+NTSTATUS share_classic_init(TALLOC_CTX *ctx)
{
return share_register(&ops);
}
#include "param/share.h"
#include "param/param.h"
-NTSTATUS share_ldb_init(void);
+NTSTATUS share_ldb_init(TALLOC_CTX *);
static NTSTATUS sldb_init(TALLOC_CTX *mem_ctx, const struct share_ops *ops,
struct tevent_context *ev_ctx,
.remove = sldb_remove
};
-NTSTATUS share_ldb_init(void)
+NTSTATUS share_ldb_init(TALLOC_CTX *ctx)
{
return share_register(&ops);
}
void dcerpc_server_init(struct loadparm_context *lp_ctx)
{
static bool initialized;
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_dcerpc_server_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_dcerpc_server_MODULES };
init_module_fn *shared_init;
shared_init = load_samba_modules(NULL, "dcerpc_server");
- run_init_functions(static_init);
- run_init_functions(shared_init);
+ run_init_functions(NULL, static_init);
+ run_init_functions(NULL, shared_init);
talloc_free(shared_init);
}
/* include the generated boilerplate */
#include "librpc/gen_ndr/ndr_dssetup_s.c"
-NTSTATUS dcerpc_server_lsa_init(void)
+NTSTATUS dcerpc_server_lsa_init(TALLOC_CTX *ctx)
{
NTSTATUS ret;
- ret = dcerpc_server_dssetup_init();
+ ret = dcerpc_server_dssetup_init(ctx);
if (!NT_STATUS_IS_OK(ret)) {
return ret;
}
- ret = dcerpc_server_lsarpc_init();
+ ret = dcerpc_server_lsarpc_init(ctx);
if (!NT_STATUS_IS_OK(ret)) {
return ret;
}
#include "../libcli/named_pipe_auth/npa_tstream.h"
#include "smbd/process_model.h"
-NTSTATUS server_service_rpc_init(void);
+NTSTATUS server_service_rpc_init(TALLOC_CTX *);
/*
open the dcerpc server sockets
task_server_terminate(task, "Failed to startup dcerpc server task", true);
}
-NTSTATUS server_service_rpc_init(void)
+NTSTATUS server_service_rpc_init(TALLOC_CTX *ctx)
{
return register_server_service("rpc", dcesrv_task_init);
}
}
/* called at smbd startup - register ourselves as a server service */
-NTSTATUS server_service_smb_init(void)
+NTSTATUS server_service_smb_init(TALLOC_CTX *ctx)
{
ntvfs_init(cmdline_lp_ctx);
share_init();
_PUBLIC_ NTSTATUS process_model_init(struct loadparm_context *lp_ctx)
{
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_process_model_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_process_model_MODULES };
init_module_fn *shared_init;
shared_init = load_samba_modules(NULL, "process_model");
- run_init_functions(static_init);
- run_init_functions(shared_init);
+ run_init_functions(NULL, static_init);
+ run_init_functions(NULL, shared_init);
talloc_free(shared_init);
#include "system/filesys.h"
#include "cluster/cluster.h"
-NTSTATUS process_model_single_init(void);
+NTSTATUS process_model_single_init(TALLOC_CTX *);
/*
called when the process model is selected
initialise the single process model, registering ourselves with the
process model subsystem
*/
-NTSTATUS process_model_single_init(void)
+NTSTATUS process_model_single_init(TALLOC_CTX *ctx)
{
return register_process_model(&single_ops);
}
struct tevent_fd *from_child_fde;
};
-NTSTATUS process_model_standard_init(void);
+NTSTATUS process_model_standard_init(TALLOC_CTX *);
/* we hold a pipe open in the parent, and the any child
processes wait for EOF on that pipe. This ensures that
/*
initialise the standard process model, registering ourselves with the process model subsystem
*/
-NTSTATUS process_model_standard_init(void)
+NTSTATUS process_model_standard_init(TALLOC_CTX *ctx)
{
return register_process_model(&standard_ops);
}
bool opt_interactive = false;
int opt;
poptContext pc;
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_service_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_service_MODULES };
init_module_fn *shared_init;
shared_init = load_samba_modules(NULL, "service");
- run_init_functions(static_init);
- run_init_functions(shared_init);
+ run_init_functions(NULL, static_init);
+ run_init_functions(NULL, shared_init);
talloc_free(shared_init);
}
-NTSTATUS torture_base_init(void)
+NTSTATUS torture_base_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "base");
return true;
}
-NTSTATUS torture_dfs_init(void)
+NTSTATUS torture_dfs_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "dfs");
struct torture_suite *suite_basic = torture_suite_create(suite, "domain");
/**
* DNS torture module initialization
*/
-NTSTATUS torture_bind_dns_init(void);
-NTSTATUS torture_bind_dns_init(void)
+NTSTATUS torture_bind_dns_init(TALLOC_CTX *);
+NTSTATUS torture_bind_dns_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite;
TALLOC_CTX *mem_ctx = talloc_autofree_context();
/* Silence silly compiler warning */
-NTSTATUS torture_internal_dns_init(void);
+NTSTATUS torture_internal_dns_init(TALLOC_CTX *);
/**
* DNS torture module initialization
*/
-NTSTATUS torture_internal_dns_init(void)
+NTSTATUS torture_internal_dns_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite;
TALLOC_CTX *mem_ctx = talloc_autofree_context();
/**
* DRSUAPI torture module initialization
*/
-NTSTATUS torture_drs_init(void)
+NTSTATUS torture_drs_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite;
TALLOC_CTX *mem_ctx = talloc_autofree_context();
TORTURE_KRB5_TEST_AES_RC4);
}
-NTSTATUS torture_krb5_init(void)
+NTSTATUS torture_krb5_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "krb5");
struct torture_suite *kdc_suite = torture_suite_create(suite, "kdc");
return true;
}
-NTSTATUS torture_krb5_init(void)
+NTSTATUS torture_krb5_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite =
torture_suite_create(talloc_autofree_context(), "krb5");
return NT_STATUS_OK;
}
-NTSTATUS torture_ldap_init(void)
+NTSTATUS torture_ldap_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "ldap");
torture_suite_add_simple_test(suite, "bench-cldap", torture_bench_cldap);
#include "libnet/libnet.h"
#include "torture/libnet/proto.h"
-NTSTATUS torture_net_init(void)
+NTSTATUS torture_net_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(
talloc_autofree_context(), "net");
return true;
}
-NTSTATUS torture_libnetapi_init(void)
+NTSTATUS torture_libnetapi_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite;
return true;
}
-NTSTATUS torture_libsmbclient_init(void)
+NTSTATUS torture_libsmbclient_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite;
NULL
};
-NTSTATUS torture_local_init(void)
+NTSTATUS torture_local_init(TALLOC_CTX *ctx)
{
int i;
struct torture_suite *suite = torture_suite_create(
return correct;
}
-NTSTATUS torture_nbench_init(void)
+NTSTATUS torture_nbench_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(
talloc_autofree_context(), "bench");
return true;
}
-NTSTATUS torture_nbt_init(void)
+NTSTATUS torture_nbt_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(
talloc_autofree_context(), "nbt");
return true;
}
-NTSTATUS torture_ntp_init(void)
+NTSTATUS torture_ntp_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "ntp");
struct torture_rpc_tcase *tcase;
return true;
}
-NTSTATUS torture_rap_init(void)
+NTSTATUS torture_rap_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "rap");
struct torture_suite *suite_basic = torture_suite_create(suite, "basic");
#include "torture/smbtorture.h"
#include "torture/raw/proto.h"
-NTSTATUS torture_raw_init(void)
+NTSTATUS torture_raw_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(
talloc_autofree_context(), "raw");
return test;
}
-NTSTATUS torture_rpc_init(void)
+NTSTATUS torture_rpc_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "rpc");
return test;
}
-NTSTATUS torture_smb2_init(void)
+NTSTATUS torture_smb2_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "smb2");
torture_suite_add_simple_test(suite, "connect", torture_smb2_connect);
if (fn == NULL)
d_printf("Unable to load module from %s\n", poptGetOptArg(pc));
else {
- status = fn();
+ status = fn(NULL);
if (NT_STATUS_IS_ERR(status)) {
d_printf("Error initializing module %s: %s\n",
poptGetOptArg(pc), nt_errstr(status));
_PUBLIC_ int torture_init(void)
{
-#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
STATIC_smbtorture_MODULES_PROTO;
init_module_fn static_init[] = { STATIC_smbtorture_MODULES };
init_module_fn *shared_init = load_samba_modules(NULL, "smbtorture");
- run_init_functions(static_init);
- run_init_functions(shared_init);
+ run_init_functions(NULL, static_init);
+ run_init_functions(NULL, shared_init);
talloc_free(shared_init);
#include "torture/smbtorture.h"
#include "torture/unix/proto.h"
-NTSTATUS torture_unix_init(void)
+NTSTATUS torture_unix_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite =
torture_suite_create(talloc_autofree_context(), "unix");
return test;
}
-NTSTATUS torture_vfs_init(void)
+NTSTATUS torture_vfs_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(
talloc_autofree_context(), "vfs");
return torture_winbind_pac(tctx, NULL, "krb5");
}
-NTSTATUS torture_winbind_init(void)
+NTSTATUS torture_winbind_init(TALLOC_CTX *ctx)
{
struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "winbind");
struct torture_suite *pac_suite;
#include "lib/socket/netif.h"
#include "param/param.h"
-NTSTATUS server_service_web_init(void);
+NTSTATUS server_service_web_init(TALLOC_CTX *);
/* don't allow connections to hang around forever */
#define HTTP_TIMEOUT 120
/* called at smbd startup - register ourselves as a server service */
-NTSTATUS server_service_web_init(void)
+NTSTATUS server_service_web_init(TALLOC_CTX *ctx)
{
return register_server_service("web", websrv_task_init);
}
}
/* called at winbindd startup - register ourselves as a server service */
-NTSTATUS server_service_winbindd_init(void);
+NTSTATUS server_service_winbindd_init(TALLOC_CTX *);
-NTSTATUS server_service_winbindd_init(void)
+NTSTATUS server_service_winbindd_init(TALLOC_CTX *ctx)
{
NTSTATUS status = register_server_service("winbindd", winbindd_task_init);
if (!NT_STATUS_IS_OK(status)) {
/*
register ourselves as a available server
*/
-NTSTATUS server_service_wrepl_init(void)
+NTSTATUS server_service_wrepl_init(TALLOC_CTX *ctx)
{
return register_server_service("wrepl", wreplsrv_task_init);
}