s4-server: call the ldb_wrap_fork_hook() after a fork()
[ira/wip.git] / source4 / smbd / process_prefork.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    process model: prefork (n client connections per process)
5
6    Copyright (C) Andrew Tridgell 1992-2005
7    Copyright (C) James J Myers 2003 <myersjj@samba.org>
8    Copyright (C) Stefan (metze) Metzmacher 2004
9    Copyright (C) Andrew Bartlett 2008 <abartlet@samba.org>
10    Copyright (C) David Disseldorp 2008 <ddiss@sgi.com>
11    
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 3 of the License, or
15    (at your option) any later version.
16    
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21    
22    You should have received a copy of the GNU General Public License
23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
24 */
25
26 #include "includes.h"
27 #include "lib/events/events.h"
28 #include "../tdb/include/tdb.h"
29 #include "lib/socket/socket.h"
30 #include "smbd/process_model.h"
31 #include "param/secrets.h"
32 #include "system/filesys.h"
33 #include "cluster/cluster.h"
34 #include "param/param.h"
35 #include "lib/ldb_wrap.h"
36
37 #ifdef HAVE_SETPROCTITLE
38 #ifdef HAVE_SETPROCTITLE_H
39 #include <setproctitle.h>
40 #endif
41 #else
42 #define setproctitle none_setproctitle
43 static int none_setproctitle(const char *fmt, ...) PRINTF_ATTRIBUTE(1, 2);
44 static int none_setproctitle(const char *fmt, ...)
45 {
46         return 0;
47 }
48 #endif
49
50 /*
51   called when the process model is selected
52 */
53 static void prefork_model_init(struct tevent_context *ev)
54 {
55         signal(SIGCHLD, SIG_IGN);
56 }
57
58 static void prefork_reload_after_fork(void)
59 {
60         /* tdb needs special fork handling */
61         if (tdb_reopen_all(1) == -1) {
62                 DEBUG(0,("prefork_reload_after_fork: tdb_reopen_all failed.\n"));
63         }
64         ldb_wrap_fork_hook();
65
66         /* Ensure that the forked children do not expose identical random streams */
67         set_need_random_reseed();
68 }
69
70 /*
71   called when a listening socket becomes readable. 
72 */
73 static void prefork_accept_connection(struct tevent_context *ev, 
74                                       struct loadparm_context *lp_ctx,
75                                       struct socket_context *listen_socket,
76                                        void (*new_conn)(struct tevent_context *,
77                                                         struct loadparm_context *, struct socket_context *, 
78                                                         struct server_id , void *), 
79                                        void *private_data)
80 {
81         NTSTATUS status;
82         struct socket_context *connected_socket;
83         pid_t pid = getpid();
84
85         /* accept an incoming connection. */
86         status = socket_accept(listen_socket, &connected_socket);
87         if (!NT_STATUS_IS_OK(status)) {
88                 return;
89         }
90
91         talloc_steal(private_data, connected_socket);
92
93         new_conn(ev, lp_ctx, connected_socket, cluster_id(pid, socket_get_fd(connected_socket)), private_data);
94 }
95
96 /*
97   called to create a new server task
98 */
99 static void prefork_new_task(struct tevent_context *ev, 
100                              struct loadparm_context *lp_ctx,
101                              const char *service_name,
102                              void (*new_task_fn)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *), 
103                              void *private_data)
104 {
105         pid_t pid;
106         int i, num_children;
107
108         struct tevent_context *ev2, *ev_parent;
109
110         pid = fork();
111
112         if (pid != 0) {
113                 /* parent or error code ... go back to the event loop */
114                 return;
115         }
116
117         pid = getpid();
118
119         /* This is now the child code. We need a completely new event_context to work with */
120         ev2 = s4_event_context_init(NULL);
121
122         /* the service has given us a private pointer that
123            encapsulates the context it needs for this new connection -
124            everything else will be freed */
125         talloc_steal(ev2, private_data);
126
127         /* this will free all the listening sockets and all state that
128            is not associated with this new connection */
129         talloc_free(ev);
130
131         setproctitle("task %s server_id[%d]", service_name, pid);
132
133         prefork_reload_after_fork();
134
135         /* setup this new connection: process will bind to it's sockets etc */
136         new_task_fn(ev2, lp_ctx, cluster_id(pid, 0), private_data);
137
138         num_children = lp_parm_int(lp_ctx, NULL, "prefork children", service_name, 0);
139         if (num_children == 0) {
140
141                 /* We don't want any kids hanging around for this one,
142                  * let the parent do all the work */
143                 event_loop_wait(ev2);
144                 
145                 talloc_free(ev2);
146                 exit(0);
147         }
148
149         /* We are now free to spawn some child proccesses */
150
151         for (i=0; i < num_children; i++) {
152
153                 pid = fork();
154                 if (pid > 0) {
155                         continue;
156                 } else if (pid == -1) {
157                         return;
158                 } else {
159                         pid = getpid();
160                         setproctitle("task %s server_id[%d]", service_name, pid);
161
162                         prefork_reload_after_fork();
163
164                         /* we can't return to the top level here, as that event context is gone,
165                            so we now process events in the new event context until there are no
166                            more to process */      
167                         event_loop_wait(ev2);
168                         
169                         talloc_free(ev2);
170                         exit(0);
171                 }
172         }
173
174         /* Don't listen on the sockets we just gave to the children */
175         talloc_free(ev2);
176         
177         /* But we need a events system to handle reaping children */
178         ev_parent = s4_event_context_init(NULL);
179         
180         /* TODO: Handle some events... */
181         
182         /* we can't return to the top level here, as that event context is gone,
183            so we now process events in the new event context until there are no
184            more to process */      
185         event_loop_wait(ev_parent);
186         
187         talloc_free(ev_parent);
188         exit(0);
189
190 }
191
192
193 /* called when a task goes down */
194 _NORETURN_ static void prefork_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *reason) 
195 {
196         DEBUG(2,("prefork_terminate: reason[%s]\n",reason));
197 }
198
199 /* called to set a title of a task or connection */
200 static void prefork_set_title(struct tevent_context *ev, const char *title) 
201 {
202         if (title) {
203                 setproctitle("%s", title);
204         } else {
205                 setproctitle(NULL);
206         }
207 }
208
209 static const struct model_ops prefork_ops = {
210         .name                   = "prefork",
211         .model_init             = prefork_model_init,
212         .accept_connection      = prefork_accept_connection,
213         .new_task               = prefork_new_task,
214         .terminate              = prefork_terminate,
215         .set_title              = prefork_set_title,
216 };
217
218 /*
219   initialise the prefork process model, registering ourselves with the process model subsystem
220  */
221 NTSTATUS process_model_prefork_init(void)
222 {
223         return register_process_model(&prefork_ops);
224 }