NTSTATUS server_service_s3fs_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "s3fs", s3fs_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "s3fs", s3fs_task_init, &details);
}
*/
NTSTATUS server_service_cldapd_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "cldap", cldapd_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "cldap", cldapd_task_init,
+ &details);
}
&dns_tcp_stream_ops,
"ip", address, &port,
lpcfg_socket_options(dns->task->lp_ctx),
- dns_socket);
+ dns_socket,
+ dns->task->process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to bind to %s:%u TCP - %s\n",
address, port, nt_errstr(status)));
NTSTATUS server_service_dns_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "dns", dns_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true,
+ };
+ return register_server_service(ctx, "dns", dns_task_init, &details);
}
*/
NTSTATUS server_service_dnsupdate_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "dnsupdate", dnsupdate_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true,
+ };
+ return register_server_service(ctx, "dnsupdate", dnsupdate_task_init,
+ &details);
}
*/
NTSTATUS server_service_kcc_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "kcc", kccsrv_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "kcc", kccsrv_task_init, &details);
}
*/
NTSTATUS server_service_drepl_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "drepl", dreplsrv_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true,
+ };
+ return register_server_service(ctx, "drepl", dreplsrv_task_init,
+ &details);
}
*/
NTSTATUS server_service_echo_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "echo", echo_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "echo", echo_task_init, &details);
}
/* called at smbd startup - register ourselves as a server service */
NTSTATUS server_service_kdc_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "kdc", kdc_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ /*
+ * Need to prevent pre-forking on kdc.
+ * The task_init function is run on the master process only
+ * and the irpc process name is registered in it's event loop.
+ * The child worker processes initialise their event loops on
+ * fork, so are not listening for the irpc event.
+ *
+ * The master process does not wait on that event context
+ * the master process is responsible for managing the worker
+ * processes not performing work.
+ */
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "kdc", kdc_task_init, &details);
}
&kdc_tcp_stream_ops,
"ip", address, &port,
lpcfg_socket_options(kdc->task->lp_ctx),
- kdc_socket);
+ kdc_socket,
+ kdc->task->process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to bind to %s:%u TCP - %s\n",
address, port, nt_errstr(status)));
NTSTATUS server_service_mitkdc_init(TALLOC_CTX *mem_ctx)
{
- return register_server_service(mem_ctx, "kdc", mitkdc_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ /*
+ * Need to prevent pre-forking on kdc.
+ * The task_init function is run on the master process only
+ * and the irpc process name is registered in it's event loop.
+ * The child worker processes initialise their event loops on
+ * fork, so are not listening for the irpc event.
+ *
+ * The master process does not wait on that event context
+ * the master process is responsible for managing the worker
+ * processes not performing work.
+ */
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(mem_ctx, "kdc", mitkdc_task_init,
+ &details);
}
model_ops, &ldap_stream_nonpriv_ops,
"ip", address, &port,
lpcfg_socket_options(lp_ctx),
- ldap_service);
+ ldap_service, task->process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("ldapsrv failed to bind to %s:%u - %s\n",
address, port, nt_errstr(status)));
&ldap_stream_nonpriv_ops,
"ip", address, &port,
lpcfg_socket_options(lp_ctx),
- ldap_service);
+ ldap_service,
+ task->process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("ldapsrv failed to bind to %s:%u - %s\n",
address, port, nt_errstr(status)));
&ldap_stream_nonpriv_ops,
"ip", address, &port,
lpcfg_socket_options(lp_ctx),
- ldap_service);
+ ldap_service,
+ task->process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("ldapsrv failed to bind to %s:%u - %s\n",
address, port, nt_errstr(status)));
&ldap_stream_nonpriv_ops,
"ip", address, &port,
lpcfg_socket_options(lp_ctx),
- ldap_service);
+ ldap_service,
+ task->process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("ldapsrv failed to bind to %s:%u - %s\n",
address, port, nt_errstr(status)));
model_ops, &ldap_stream_nonpriv_ops,
"unix", ldapi_path, NULL,
lpcfg_socket_options(task->lp_ctx),
- ldap_service);
+ ldap_service, task->process_context);
talloc_free(ldapi_path);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("ldapsrv failed to bind to %s - %s\n",
model_ops, &ldap_stream_priv_ops,
"unix", ldapi_path, NULL,
lpcfg_socket_options(task->lp_ctx),
- ldap_service);
+ ldap_service,
+ task->process_context);
talloc_free(ldapi_path);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("ldapsrv failed to bind to %s - %s\n",
NTSTATUS server_service_ldap_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "ldap", ldapsrv_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = false,
+ .inhibit_pre_fork = false
+ };
+ return register_server_service(ctx, "ldap", ldapsrv_task_init,
+ &details);
}
*/
NTSTATUS server_service_nbtd_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "nbt", nbtd_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "nbt", nbtd_task_init, &details);
}
&ntp_signd_stream_ops,
"unix", address, NULL,
lpcfg_socket_options(ntp_signd->task->lp_ctx),
- ntp_signd);
+ ntp_signd,
+ ntp_signd->task->process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to bind to %s - %s\n",
address, nt_errstr(status)));
/* called at smbd startup - register ourselves as a server service */
NTSTATUS server_service_ntp_signd_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "ntp_signd", ntp_signd_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "ntp_signd", ntp_signd_task_init,
+ &details);
}
static NTSTATUS dcesrv_add_ep_unix(struct dcesrv_context *dce_ctx,
struct loadparm_context *lp_ctx,
struct dcesrv_endpoint *e,
- struct tevent_context *event_ctx, const struct model_ops *model_ops)
+ struct tevent_context *event_ctx,
+ const struct model_ops *model_ops,
+ void *process_context)
{
struct dcesrv_socket_context *dcesrv_sock;
uint16_t port = 1;
model_ops, &dcesrv_stream_ops,
"unix", endpoint, &port,
lpcfg_socket_options(lp_ctx),
- dcesrv_sock);
+ dcesrv_sock, process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("service_setup_stream_socket(path=%s) failed - %s\n",
endpoint, nt_errstr(status)));
static NTSTATUS dcesrv_add_ep_ncalrpc(struct dcesrv_context *dce_ctx,
struct loadparm_context *lp_ctx,
struct dcesrv_endpoint *e,
- struct tevent_context *event_ctx, const struct model_ops *model_ops)
+ struct tevent_context *event_ctx,
+ const struct model_ops *model_ops,
+ void *process_context)
{
struct dcesrv_socket_context *dcesrv_sock;
uint16_t port = 1;
model_ops, &dcesrv_stream_ops,
"unix", full_path, &port,
lpcfg_socket_options(lp_ctx),
- dcesrv_sock);
+ dcesrv_sock, process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("service_setup_stream_socket(identifier=%s,path=%s) failed - %s\n",
endpoint, full_path, nt_errstr(status)));
static NTSTATUS dcesrv_add_ep_np(struct dcesrv_context *dce_ctx,
struct loadparm_context *lp_ctx,
struct dcesrv_endpoint *e,
- struct tevent_context *event_ctx, const struct model_ops *model_ops)
+ struct tevent_context *event_ctx,
+ const struct model_ops *model_ops,
+ void *process_context)
{
struct dcesrv_socket_context *dcesrv_sock;
NTSTATUS status;
status = tstream_setup_named_pipe(dce_ctx, event_ctx, lp_ctx,
model_ops, &dcesrv_stream_ops,
endpoint,
- dcesrv_sock);
+ dcesrv_sock, process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("stream_setup_named_pipe(pipe=%s) failed - %s\n",
endpoint, nt_errstr(status)));
/*
add a socket address to the list of events, one event per dcerpc endpoint
*/
-static NTSTATUS add_socket_rpc_tcp_iface(struct dcesrv_context *dce_ctx, struct dcesrv_endpoint *e,
- struct tevent_context *event_ctx, const struct model_ops *model_ops,
- const char *address)
+static NTSTATUS add_socket_rpc_tcp_iface(struct dcesrv_context *dce_ctx,
+ struct dcesrv_endpoint *e,
+ struct tevent_context *event_ctx,
+ const struct model_ops *model_ops,
+ const char *address,
+ void *process_context)
{
struct dcesrv_socket_context *dcesrv_sock;
uint16_t port = 0;
model_ops, &dcesrv_stream_ops,
"ip", address, &port,
lpcfg_socket_options(dce_ctx->lp_ctx),
- dcesrv_sock);
+ dcesrv_sock, process_context);
if (!NT_STATUS_IS_OK(status)) {
struct dcesrv_if_list *iface;
DEBUG(0,("service_setup_stream_socket(address=%s,port=%u) for ",
static NTSTATUS dcesrv_add_ep_tcp(struct dcesrv_context *dce_ctx,
struct loadparm_context *lp_ctx,
struct dcesrv_endpoint *e,
- struct tevent_context *event_ctx, const struct model_ops *model_ops)
+ struct tevent_context *event_ctx,
+ const struct model_ops *model_ops,
+ void *process_context)
{
NTSTATUS status;
num_interfaces = iface_list_count(ifaces);
for(i = 0; i < num_interfaces; i++) {
const char *address = iface_list_n_ip(ifaces, i);
- status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops, address);
+ status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx,
+ model_ops, address,
+ process_context);
NT_STATUS_NOT_OK_RETURN(status);
}
} else {
wcard = iface_list_wildcard(dce_ctx);
NT_STATUS_HAVE_NO_MEMORY(wcard);
for (i=0; wcard[i]; i++) {
- status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops, wcard[i]);
+ status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx,
+ model_ops, wcard[i],
+ process_context);
if (NT_STATUS_IS_OK(status)) {
num_binds++;
}
struct loadparm_context *lp_ctx,
struct dcesrv_endpoint *e,
struct tevent_context *event_ctx,
- const struct model_ops *model_ops)
+ const struct model_ops *model_ops,
+ void *process_context)
{
enum dcerpc_transport_t transport =
dcerpc_binding_get_transport(e->ep_description);
switch (transport) {
case NCACN_UNIX_STREAM:
- return dcesrv_add_ep_unix(dce_ctx, lp_ctx, e, event_ctx, model_ops);
+ return dcesrv_add_ep_unix(dce_ctx, lp_ctx, e, event_ctx,
+ model_ops, process_context);
case NCALRPC:
- return dcesrv_add_ep_ncalrpc(dce_ctx, lp_ctx, e, event_ctx, model_ops);
+ return dcesrv_add_ep_ncalrpc(dce_ctx, lp_ctx, e, event_ctx,
+ model_ops, process_context);
case NCACN_IP_TCP:
- return dcesrv_add_ep_tcp(dce_ctx, lp_ctx, e, event_ctx, model_ops);
+ return dcesrv_add_ep_tcp(dce_ctx, lp_ctx, e, event_ctx,
+ model_ops, process_context);
case NCACN_NP:
- return dcesrv_add_ep_np(dce_ctx, lp_ctx, e, event_ctx, model_ops);
+ return dcesrv_add_ep_np(dce_ctx, lp_ctx, e, event_ctx,
+ model_ops, process_context);
default:
return NT_STATUS_NOT_SUPPORTED;
struct loadparm_context *lp_ctx,
struct dcesrv_endpoint *e,
struct tevent_context *event_ctx,
- const struct model_ops *model_ops);
+ const struct model_ops *model_ops,
+ void *process_context);
/**
* retrieve credentials from a dce_call
}
status = dcesrv_add_ep(dce_ctx, task->lp_ctx, e, task->event_ctx,
- this_model_ops);
+ this_model_ops, task->process_context);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
}
NTSTATUS server_service_rpc_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "rpc", dcesrv_task_init);
+ struct service_details details = {
+ /*
+ * This is a SNOWFLAKE, but sadly one that we
+ * will have to keep for now. The RPC server
+ * code above overstamps the SINGLE process model
+ * most of the time, but we need to be in forking
+ * mode by defult to get a forking NETLOGON server
+ */
+ .inhibit_fork_on_accept = false,
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "rpc", dcesrv_task_init, &details);
}
*/
for(i = 0; i < num_interfaces; i++) {
const char *address = iface_list_n_ip(ifaces, i);
- status = smbsrv_add_socket(task, task->event_ctx, task->lp_ctx, task->model_ops, address);
+ status = smbsrv_add_socket(task, task->event_ctx,
+ task->lp_ctx,
+ task->model_ops,
+ address,
+ task->process_context);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
} else {
goto failed;
}
for (i=0; wcard[i]; i++) {
- status = smbsrv_add_socket(task, task->event_ctx, task->lp_ctx, task->model_ops, wcard[i]);
+ status = smbsrv_add_socket(task, task->event_ctx,
+ task->lp_ctx,
+ task->model_ops,
+ wcard[i],
+ task->process_context);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
talloc_free(wcard);
/* called at smbd startup - register ourselves as a server service */
NTSTATUS server_service_smb_init(TALLOC_CTX *ctx)
{
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true
+ };
ntvfs_init(cmdline_lp_ctx);
share_init();
- return register_server_service(ctx, "smb", smbsrv_task_init);
+ return register_server_service(ctx, "smb", smbsrv_task_init, &details);
}
struct tevent_context *event_context,
struct loadparm_context *lp_ctx,
const struct model_ops *model_ops,
- const char *address)
+ const char *address,
+ void *process_context)
{
const char **ports = lpcfg_smb_ports(lp_ctx);
int i;
model_ops, &smb_stream_ops,
"ip", address, &port,
lpcfg_socket_options(lp_ctx),
- NULL);
+ NULL, process_context);
NT_STATUS_NOT_OK_RETURN(status);
}
struct tevent_context *event_context,
struct loadparm_context *lp_ctx,
const struct model_ops *model_ops,
- const char *address);
+ const char *address,
+ void *process_context);
struct loadparm_context;
void (*)(struct tevent_context *,
struct loadparm_context *,
struct socket_context *,
- struct server_id , void *),
- void *);
+ struct server_id , void *, void *),
+ void *, void *);
/* function to create a task */
void (*new_task)(struct tevent_context *,
const char *service_name,
void (*)(struct tevent_context *,
struct loadparm_context *, struct server_id,
- void *),
+ void *, void *),
void *,
- int);
+ const struct service_details*,
+ const int);
/* function to terminate a connection or task */
- void (*terminate)(struct tevent_context *, struct loadparm_context *lp_ctx,
- const char *reason);
+ void (*terminate)(struct tevent_context *,
+ struct loadparm_context *lp_ctx,
+ const char *reason,
+ void * process_context);
/* function to set a title for the connection or task */
void (*set_title)(struct tevent_context *, const char *title);
void (*new_conn)(struct tevent_context *,
struct loadparm_context *,
struct socket_context *,
- struct server_id , void *),
- void *private_data)
+ struct server_id, void *,
+ void *),
+ void *private_data,
+ void *process_context)
{
NTSTATUS status;
struct socket_context *connected_socket;
* combination of pid/fd should be unique system-wide
*/
new_conn(ev, lp_ctx, connected_socket,
- cluster_id(pid, socket_get_fd(connected_socket)), private_data);
+ cluster_id(pid, socket_get_fd(connected_socket)), private_data,
+ process_context);
}
/*
static void single_new_task(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
- void (*new_task)(struct tevent_context *, struct loadparm_context *, struct server_id, void *),
+ void (*new_task)(struct tevent_context *,
+ struct loadparm_context *,
+ struct server_id, void *, void *),
void *private_data,
+ const struct service_details *service_details,
int from_parent_fd)
{
pid_t pid = getpid();
* Using the pid unaltered makes debugging of which process
* owns the messaging socket easier.
*/
- new_task(ev, lp_ctx, cluster_id(pid, taskid++), private_data);
+ new_task(ev, lp_ctx, cluster_id(pid, taskid++), private_data, NULL);
}
/* called when a task goes down */
-static void single_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *reason)
+static void single_terminate(struct tevent_context *ev,
+ struct loadparm_context *lp_ctx,
+ const char *reason,
+ void *process_context)
{
DEBUG(3,("single_terminate: reason[%s]\n",reason));
}
/*
called when a listening socket becomes readable.
*/
-static void standard_accept_connection(struct tevent_context *ev,
- struct loadparm_context *lp_ctx,
- struct socket_context *sock,
- void (*new_conn)(struct tevent_context *,
- struct loadparm_context *, struct socket_context *,
- struct server_id , void *),
- void *private_data)
+static void standard_accept_connection(
+ struct tevent_context *ev,
+ struct loadparm_context *lp_ctx,
+ struct socket_context *sock,
+ void (*new_conn)(struct tevent_context *,
+ struct loadparm_context *,
+ struct socket_context *,
+ struct server_id,
+ void *,
+ void *),
+ void *private_data,
+ void *process_context)
{
NTSTATUS status;
struct socket_context *sock2;
talloc_free(s);
/* setup this new connection. Cluster ID is PID based for this process model */
- new_conn(ev, lp_ctx, sock2, cluster_id(pid, 0), private_data);
+ new_conn(ev, lp_ctx, sock2, cluster_id(pid, 0), private_data,
+ NULL);
/* we can't return to the top level here, as that event context is gone,
so we now process events in the new event context until there are no
static void standard_new_task(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *service_name,
- void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
+ void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *, void *),
void *private_data,
+ const struct service_details *service_details,
int new_from_parent_fd)
{
pid_t pid;
setproctitle("task %s server_id[%d]", service_name, (int)pid);
/* setup this new task. Cluster ID is PID based for this process model */
- new_task(ev, lp_ctx, cluster_id(pid, 0), private_data);
+ new_task(ev, lp_ctx, cluster_id(pid, 0), private_data, NULL);
/* we can't return to the top level here, as that event context is gone,
so we now process events in the new event context until there are no
- more to process */
+ more to process */
tevent_loop_wait(ev);
talloc_free(ev);
/* called when a task goes down */
_NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx,
- const char *reason)
+ const char *reason,
+ void *process_context)
{
DEBUG(2,("standard_terminate: reason[%s]\n",reason));
static struct registered_server {
struct registered_server *next, *prev;
const char *service_name;
+ struct service_details *service_details;
void (*task_init)(struct task_server *);
} *registered_servers;
*/
NTSTATUS register_server_service(TALLOC_CTX *ctx,
const char *name,
- void (*task_init)(struct task_server *))
+ void (*task_init) (struct task_server *),
+ struct service_details *details)
{
struct registered_server *srv;
srv = talloc(ctx, struct registered_server);
NT_STATUS_HAVE_NO_MEMORY(srv);
srv->service_name = name;
srv->task_init = task_init;
+ srv->service_details =
+ talloc_memdup(ctx, details, sizeof(struct service_details));
+ NT_STATUS_HAVE_NO_MEMORY(srv->service_details);
DLIST_ADD_END(registered_servers, srv);
return NT_STATUS_OK;
}
if (strcasecmp(name, srv->service_name) == 0) {
return task_server_startup(event_context, lp_ctx,
srv->service_name,
- model_ops, srv->task_init,
+ model_ops,
+ srv->task_init,
+ srv->service_details,
from_parent_fd);
}
}
#ifndef __SERVICE_H__
#define __SERVICE_H__
+
#include "smbd/service_stream.h"
#include "smbd/service_task.h"
+
+struct service_details {
+ /*
+ * Prevent the standard process model from forking a new worker
+ * process when accepting a new connection. Do this when the service
+ * relies on shared state, or the over-head of forking would be a
+ * significant part of the response time
+ */
+ bool inhibit_fork_on_accept;
+ /*
+ * Prevent the pre-fork process model from pre-forking any worker
+ * processes. In this mode pre-fork is equivalent to standard with
+ * inhibit_fork_on_accept set.
+ */
+ bool inhibit_pre_fork;
+};
+
#include "smbd/service_proto.h"
#endif /* __SERVICE_H__ */
const struct model_ops *model_ops,
const struct stream_server_ops *stream_ops,
const char *pipe_name,
- void *private_data)
+ void *private_data,
+ void *process_context)
{
char *dirname;
struct named_pipe_socket *pipe_sock;
pipe_sock->pipe_path,
NULL,
NULL,
- pipe_sock);
+ pipe_sock,
+ process_context);
if (!NT_STATUS_IS_OK(status)) {
goto fail;
}
const struct model_ops *model_ops;
struct socket_context *sock;
void *private_data;
+ void *process_context;
};
struct tevent_context *event_ctx = srv_conn->event.ctx;
const struct model_ops *model_ops = srv_conn->model_ops;
struct loadparm_context *lp_ctx = srv_conn->lp_ctx;
+ void *process_context = srv_conn->process_context;
TALLOC_CTX *frame = NULL;
if (!reason) reason = "unknown reason";
srv_conn->event.fde = NULL;
imessaging_cleanup(srv_conn->msg_ctx);
TALLOC_FREE(srv_conn);
- model_ops->terminate(event_ctx, lp_ctx, reason);
-
+ model_ops->terminate(event_ctx, lp_ctx, reason, process_context);
TALLOC_FREE(frame);
}
const struct stream_server_ops *stream_ops,
struct imessaging_context *msg_ctx,
void *private_data,
- struct stream_connection **_srv_conn)
+ struct stream_connection **_srv_conn,
+ void *process_context)
{
struct stream_connection *srv_conn;
srv_conn->event.ctx = ev;
srv_conn->lp_ctx = lp_ctx;
srv_conn->event.fde = NULL;
+ srv_conn->process_context = process_context;
*_srv_conn = srv_conn;
return NT_STATUS_OK;
static void stream_new_connection(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
struct socket_context *sock,
- struct server_id server_id, void *private_data)
+ struct server_id server_id,
+ void *private_data,
+ void *process_context)
{
struct stream_socket *stream_socket = talloc_get_type(private_data, struct stream_socket);
struct stream_connection *srv_conn;
srv_conn->ops = stream_socket->ops;
srv_conn->event.ctx = ev;
srv_conn->lp_ctx = lp_ctx;
+ srv_conn->process_context = process_context;
if (!socket_check_access(sock, "smbd", lpcfg_hosts_allow(NULL, lpcfg_default_service(lp_ctx)), lpcfg_hosts_deny(NULL, lpcfg_default_service(lp_ctx)))) {
stream_terminate_connection(srv_conn, "denied by access rules");
connection. When done, it calls stream_new_connection()
with the newly created socket */
stream_socket->model_ops->accept_connection(ev, stream_socket->lp_ctx,
- stream_socket->sock,
- stream_new_connection, stream_socket);
+ stream_socket->sock,
+ stream_new_connection, stream_socket,
+ stream_socket->process_context);
}
/*
const char *sock_addr,
uint16_t *port,
const char *socket_options,
- void *private_data)
+ void *private_data,
+ void *process_context)
{
NTSTATUS status;
struct stream_socket *stream_socket;
stream_socket->ops = stream_ops;
stream_socket->event_ctx = event_context;
stream_socket->model_ops = model_ops;
+ stream_socket->process_context = process_context;
return NT_STATUS_OK;
}
uint processing;
const char *terminate;
+ void *process_context;
};
imessaging_cleanup(task->msg_ctx);
- model_ops->terminate(event_ctx, task->lp_ctx, reason);
-
+ model_ops->terminate(event_ctx, task->lp_ctx, reason,
+ task->process_context);
/* don't free this above, it might contain the 'reason' being printed */
talloc_free(task);
}
called by the process model code when the new task starts up. This then calls
the server specific startup code
*/
-static void task_server_callback(struct tevent_context *event_ctx,
+static void task_server_callback(struct tevent_context *event_ctx,
struct loadparm_context *lp_ctx,
- struct server_id server_id, void *private_data)
+ struct server_id server_id,
+ void *private_data,
+ void *context)
{
struct task_state *state = talloc_get_type(private_data, struct task_state);
struct task_server *task;
task->model_ops = state->model_ops;
task->server_id = server_id;
task->lp_ctx = lp_ctx;
+ task->process_context = context;
task->msg_ctx = imessaging_init(task,
task->lp_ctx,
/*
startup a task based server
*/
-NTSTATUS task_server_startup(struct tevent_context *event_ctx,
+NTSTATUS task_server_startup(struct tevent_context *event_ctx,
struct loadparm_context *lp_ctx,
- const char *service_name,
- const struct model_ops *model_ops,
+ const char *service_name,
+ const struct model_ops *model_ops,
void (*task_init)(struct task_server *),
+ const struct service_details *service_details,
int from_parent_fd)
{
struct task_state *state;
state->model_ops = model_ops;
state->model_ops->new_task(event_ctx, lp_ctx, service_name,
- task_server_callback, state,
+ task_server_callback, state, service_details,
from_parent_fd);
return NT_STATUS_OK;
struct loadparm_context *lp_ctx;
struct server_id server_id;
void *private_data;
+ void *process_context;
};
torture_assert_ntstatus_ok(tctx, status,
"unable to initialize process models");
- status = smbsrv_add_socket(tctx, event_ctx, tctx->lp_ctx, process_model_startup("single"), address);
+ status = smbsrv_add_socket(tctx, event_ctx, tctx->lp_ctx,
+ process_model_startup("single"),
+ address, NULL);
torture_assert_ntstatus_ok(tctx, status, "starting smb server");
status = dcesrv_init_context(tctx, tctx->lp_ctx, endpoints, &dce_ctx);
for (e=dce_ctx->endpoint_list;e;e=e->next) {
status = dcesrv_add_ep(dce_ctx, tctx->lp_ctx,
- e, tctx->ev, process_model_startup("single"));
+ e, tctx->ev,
+ process_model_startup("single"), NULL);
torture_assert_ntstatus_ok(tctx, status,
"unable listen on dcerpc endpoint server");
}
task->lp_ctx, model_ops,
&web_stream_ops,
"ip", address,
- &port, lpcfg_socket_options(task->lp_ctx),
- task);
+ &port,
+ lpcfg_socket_options(task->lp_ctx),
+ task,
+ task->process_context);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
&web_stream_ops,
"ip", wcard[i],
&port, lpcfg_socket_options(task->lp_ctx),
- wdata);
+ wdata,
+ task->process_context);
if (!NT_STATUS_IS_OK(status)) goto failed;
}
talloc_free(wcard);
/* called at smbd startup - register ourselves as a server service */
NTSTATUS server_service_web_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "web", websrv_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "web", websrv_task_init, &details);
}
NTSTATUS server_service_winbindd_init(TALLOC_CTX *ctx)
{
- NTSTATUS status = register_server_service(ctx, "winbindd", winbindd_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true,
+ };
+
+ NTSTATUS status = register_server_service(ctx, "winbindd",
+ winbindd_task_init, &details);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
- return register_server_service(ctx, "winbind", winbindd_task_init);
+ return register_server_service(ctx, "winbind", winbindd_task_init,
+ &details);
}
NTSTATUS wreplsrv_in_connection_merge(struct wreplsrv_partner *partner,
uint32_t peer_assoc_ctx,
struct tstream_context **stream,
- struct wreplsrv_in_connection **_wrepl_in)
+ struct wreplsrv_in_connection **_wrepl_in,
+ void* process_context)
{
struct wreplsrv_service *service = partner->service;
struct wreplsrv_in_connection *wrepl_in;
&wreplsrv_stream_ops,
service->task->msg_ctx,
wrepl_in,
- &conn);
+ &conn,
+ process_context);
NT_STATUS_NOT_OK_RETURN(status);
/*
&wreplsrv_stream_ops,
"ipv4", address, &port,
lpcfg_socket_options(task->lp_ctx),
- service);
+ service, task->process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("stream_setup_socket(address=%s,port=%u) failed - %s\n",
address, port, nt_errstr(status)));
status = stream_setup_socket(task, task->event_ctx, task->lp_ctx,
model_ops, &wreplsrv_stream_ops,
"ipv4", address, &port, lpcfg_socket_options(task->lp_ctx),
- service);
+ service, task->process_context);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("stream_setup_socket(address=%s,port=%u) failed - %s\n",
address, port, nt_errstr(status)));
{
struct wreplsrv_in_connection *wrepl_in;
struct tstream_context *stream;
+ void *process_context = NULL;
NTSTATUS status;
status = wrepl_request_recv(state->subreq, state, NULL);
* NOTE: stream will be stolen by
* wreplsrv_in_connection_merge()
*/
+ process_context = state->io->in.partner->service->task->process_context;
status = wreplsrv_in_connection_merge(state->io->in.partner,
state->wreplconn->assoc_ctx.peer_ctx,
&stream,
- &wrepl_in);
+ &wrepl_in, process_context);
NT_STATUS_NOT_OK_RETURN(status);
/* now we can free the wreplsrv_out_connection */
*/
NTSTATUS server_service_wrepl_init(TALLOC_CTX *ctx)
{
- return register_server_service(ctx, "wrepl", wreplsrv_task_init);
+ struct service_details details = {
+ .inhibit_fork_on_accept = true,
+ .inhibit_pre_fork = true
+ };
+ return register_server_service(ctx, "wrepl", wreplsrv_task_init,
+ &details);
}
git.samba.org / amitay / samba.git / commitdiff