s4:lib/events: make use of samba_tevent_set_debug()
[Samba/gebeck_regimport.git] / source4 / smbd / process_standard.c
blobc5377b34e08516a7d2209b40ec5f2648d269cfae
1 /*
2 Unix SMB/CIFS implementation.
4 process model: standard (1 process per client connection)
6 Copyright (C) Andrew Tridgell 1992-2005
7 Copyright (C) James J Myers 2003 <myersjj@samba.org>
8 Copyright (C) Stefan (metze) Metzmacher 2004
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "includes.h"
25 #include "lib/events/events.h"
26 #include "smbd/process_model.h"
27 #include "system/filesys.h"
28 #include "cluster/cluster.h"
29 #include "param/param.h"
30 #include "ldb_wrap.h"
32 NTSTATUS process_model_standard_init(void);
34 /* we hold a pipe open in the parent, and the any child
35 processes wait for EOF on that pipe. This ensures that
36 children die when the parent dies */
37 static int child_pipe[2];
40 called when the process model is selected
42 static void standard_model_init(void)
44 pipe(child_pipe);
45 signal(SIGCHLD, SIG_IGN);
49 handle EOF on the child pipe
51 static void standard_pipe_handler(struct tevent_context *event_ctx, struct tevent_fd *fde,
52 uint16_t flags, void *private_data)
54 DEBUG(10,("Child %d exiting\n", (int)getpid()));
55 exit(0);
59 called when a listening socket becomes readable.
61 static void standard_accept_connection(struct tevent_context *ev,
62 struct loadparm_context *lp_ctx,
63 struct socket_context *sock,
64 void (*new_conn)(struct tevent_context *,
65 struct loadparm_context *, struct socket_context *,
66 struct server_id , void *),
67 void *private_data)
69 NTSTATUS status;
70 struct socket_context *sock2;
71 pid_t pid;
72 struct socket_address *c, *s;
74 /* accept an incoming connection. */
75 status = socket_accept(sock, &sock2);
76 if (!NT_STATUS_IS_OK(status)) {
77 DEBUG(0,("standard_accept_connection: accept: %s\n",
78 nt_errstr(status)));
79 /* this looks strange, but is correct. We need to throttle things until
80 the system clears enough resources to handle this new socket */
81 sleep(1);
82 return;
85 pid = fork();
87 if (pid != 0) {
88 /* parent or error code ... */
89 talloc_free(sock2);
90 /* go back to the event loop */
91 return;
94 pid = getpid();
96 /* This is now the child code. We need a completely new event_context to work with */
98 if (tevent_re_initialise(ev) != 0) {
99 smb_panic("Failed to re-initialise tevent after fork");
102 /* this will free all the listening sockets and all state that
103 is not associated with this new connection */
104 talloc_free(sock);
106 /* we don't care if the dup fails, as its only a select()
107 speed optimisation */
108 socket_dup(sock2);
110 /* tdb needs special fork handling */
111 ldb_wrap_fork_hook();
113 tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
114 standard_pipe_handler, NULL);
115 close(child_pipe[1]);
117 /* Ensure that the forked children do not expose identical random streams */
118 set_need_random_reseed();
120 /* setup the process title */
121 c = socket_get_peer_addr(sock2, ev);
122 s = socket_get_my_addr(sock2, ev);
123 if (s && c) {
124 setproctitle("conn c[%s:%u] s[%s:%u] server_id[%d]",
125 c->addr, c->port, s->addr, s->port, (int)pid);
127 talloc_free(c);
128 talloc_free(s);
130 /* setup this new connection. Cluster ID is PID based for this process model */
131 new_conn(ev, lp_ctx, sock2, cluster_id(pid, 0), private_data);
133 /* we can't return to the top level here, as that event context is gone,
134 so we now process events in the new event context until there are no
135 more to process */
136 tevent_loop_wait(ev);
138 talloc_free(ev);
139 exit(0);
143 called to create a new server task
145 static void standard_new_task(struct tevent_context *ev,
146 struct loadparm_context *lp_ctx,
147 const char *service_name,
148 void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
149 void *private_data)
151 pid_t pid;
153 pid = fork();
155 if (pid != 0) {
156 /* parent or error code ... go back to the event loop */
157 return;
160 pid = getpid();
162 /* this will free all the listening sockets and all state that
163 is not associated with this new connection */
164 if (tevent_re_initialise(ev) != 0) {
165 smb_panic("Failed to re-initialise tevent after fork");
168 /* ldb/tdb need special fork handling */
169 ldb_wrap_fork_hook();
171 tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
172 standard_pipe_handler, NULL);
173 close(child_pipe[1]);
175 /* Ensure that the forked children do not expose identical random streams */
176 set_need_random_reseed();
178 setproctitle("task %s server_id[%d]", service_name, (int)pid);
180 /* setup this new task. Cluster ID is PID based for this process model */
181 new_task(ev, lp_ctx, cluster_id(pid, 0), private_data);
183 /* we can't return to the top level here, as that event context is gone,
184 so we now process events in the new event context until there are no
185 more to process */
186 tevent_loop_wait(ev);
188 talloc_free(ev);
189 exit(0);
193 /* called when a task goes down */
194 _NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx,
195 const char *reason)
197 DEBUG(2,("standard_terminate: reason[%s]\n",reason));
199 talloc_free(ev);
201 /* this reload_charcnv() has the effect of freeing the iconv context memory,
202 which makes leak checking easier */
203 reload_charcnv(lp_ctx);
205 /* terminate this process */
206 exit(0);
209 /* called to set a title of a task or connection */
210 static void standard_set_title(struct tevent_context *ev, const char *title)
212 if (title) {
213 setproctitle("%s", title);
214 } else {
215 setproctitle(NULL);
219 static const struct model_ops standard_ops = {
220 .name = "standard",
221 .model_init = standard_model_init,
222 .accept_connection = standard_accept_connection,
223 .new_task = standard_new_task,
224 .terminate = standard_terminate,
225 .set_title = standard_set_title,
229 initialise the standard process model, registering ourselves with the process model subsystem
231 NTSTATUS process_model_standard_init(void)
233 return register_process_model(&standard_ops);