source: vendor/3.5.6/source4/smbd/process_standard.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 7.3 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3
4 process model: standard (1 process per client connection)
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
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.
14
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.
19
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/>.
22*/
23
24#include "includes.h"
25#include "lib/events/events.h"
26#include "../tdb/include/tdb.h"
27#include "smbd/process_model.h"
28#include "system/filesys.h"
29#include "cluster/cluster.h"
30#include "param/param.h"
31
32#ifdef HAVE_SETPROCTITLE
33#ifdef HAVE_SETPROCTITLE_H
34#include <setproctitle.h>
35#endif
36#else
37#define setproctitle none_setproctitle
38static int none_setproctitle(const char *fmt, ...) PRINTF_ATTRIBUTE(1, 2);
39static int none_setproctitle(const char *fmt, ...)
40{
41 return 0;
42}
43#endif
44
45/* we hold a pipe open in the parent, and the any child
46 processes wait for EOF on that pipe. This ensures that
47 children die when the parent dies */
48static int child_pipe[2];
49
50/*
51 called when the process model is selected
52*/
53static void standard_model_init(struct tevent_context *ev)
54{
55 pipe(child_pipe);
56 signal(SIGCHLD, SIG_IGN);
57}
58
59/*
60 handle EOF on the child pipe
61*/
62static void standard_pipe_handler(struct tevent_context *event_ctx, struct tevent_fd *fde,
63 uint16_t flags, void *private_data)
64{
65 DEBUG(10,("Child %d exiting\n", (int)getpid()));
66 exit(0);
67}
68
69/*
70 called when a listening socket becomes readable.
71*/
72static void standard_accept_connection(struct tevent_context *ev,
73 struct loadparm_context *lp_ctx,
74 struct socket_context *sock,
75 void (*new_conn)(struct tevent_context *,
76 struct loadparm_context *, struct socket_context *,
77 struct server_id , void *),
78 void *private_data)
79{
80 NTSTATUS status;
81 struct socket_context *sock2;
82 pid_t pid;
83 struct tevent_context *ev2;
84 struct socket_address *c, *s;
85
86 /* accept an incoming connection. */
87 status = socket_accept(sock, &sock2);
88 if (!NT_STATUS_IS_OK(status)) {
89 DEBUG(0,("standard_accept_connection: accept: %s\n",
90 nt_errstr(status)));
91 /* this looks strange, but is correct. We need to throttle things until
92 the system clears enough resources to handle this new socket */
93 sleep(1);
94 return;
95 }
96
97 pid = fork();
98
99 if (pid != 0) {
100 /* parent or error code ... */
101 talloc_free(sock2);
102 /* go back to the event loop */
103 return;
104 }
105
106 pid = getpid();
107
108 /* This is now the child code. We need a completely new event_context to work with */
109 ev2 = s4_event_context_init(NULL);
110
111 /* the service has given us a private pointer that
112 encapsulates the context it needs for this new connection -
113 everything else will be freed */
114 talloc_steal(ev2, private_data);
115 talloc_steal(private_data, sock2);
116
117 /* this will free all the listening sockets and all state that
118 is not associated with this new connection */
119 talloc_free(sock);
120 talloc_free(ev);
121
122 /* we don't care if the dup fails, as its only a select()
123 speed optimisation */
124 socket_dup(sock2);
125
126 /* tdb needs special fork handling */
127 if (tdb_reopen_all(1) == -1) {
128 DEBUG(0,("standard_accept_connection: tdb_reopen_all failed.\n"));
129 }
130
131 tevent_add_fd(ev2, ev2, child_pipe[0], TEVENT_FD_READ,
132 standard_pipe_handler, NULL);
133 close(child_pipe[1]);
134
135 /* Ensure that the forked children do not expose identical random streams */
136 set_need_random_reseed();
137
138 /* setup the process title */
139 c = socket_get_peer_addr(sock2, ev2);
140 s = socket_get_my_addr(sock2, ev2);
141 if (s && c) {
142 setproctitle("conn c[%s:%u] s[%s:%u] server_id[%d]",
143 c->addr, c->port, s->addr, s->port, pid);
144 }
145 talloc_free(c);
146 talloc_free(s);
147
148 /* setup this new connection. Cluster ID is PID based for this process modal */
149 new_conn(ev2, lp_ctx, sock2, cluster_id(pid, 0), private_data);
150
151 /* we can't return to the top level here, as that event context is gone,
152 so we now process events in the new event context until there are no
153 more to process */
154 event_loop_wait(ev2);
155
156 talloc_free(ev2);
157 exit(0);
158}
159
160/*
161 called to create a new server task
162*/
163static void standard_new_task(struct tevent_context *ev,
164 struct loadparm_context *lp_ctx,
165 const char *service_name,
166 void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
167 void *private_data)
168{
169 pid_t pid;
170 struct tevent_context *ev2;
171
172 pid = fork();
173
174 if (pid != 0) {
175 /* parent or error code ... go back to the event loop */
176 return;
177 }
178
179 pid = getpid();
180
181 /* This is now the child code. We need a completely new event_context to work with */
182 ev2 = s4_event_context_init(NULL);
183
184 /* the service has given us a private pointer that
185 encapsulates the context it needs for this new connection -
186 everything else will be freed */
187 talloc_steal(ev2, private_data);
188
189 /* this will free all the listening sockets and all state that
190 is not associated with this new connection */
191 talloc_free(ev);
192
193 /* tdb needs special fork handling */
194 if (tdb_reopen_all(1) == -1) {
195 DEBUG(0,("standard_accept_connection: tdb_reopen_all failed.\n"));
196 }
197
198 tevent_add_fd(ev2, ev2, child_pipe[0], TEVENT_FD_READ,
199 standard_pipe_handler, NULL);
200 close(child_pipe[1]);
201
202 /* Ensure that the forked children do not expose identical random streams */
203 set_need_random_reseed();
204
205 setproctitle("task %s server_id[%d]", service_name, pid);
206
207 /* setup this new task. Cluster ID is PID based for this process modal */
208 new_task(ev2, lp_ctx, cluster_id(pid, 0), private_data);
209
210 /* we can't return to the top level here, as that event context is gone,
211 so we now process events in the new event context until there are no
212 more to process */
213 event_loop_wait(ev2);
214
215 talloc_free(ev2);
216 exit(0);
217}
218
219
220/* called when a task goes down */
221_NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx,
222 const char *reason)
223{
224 DEBUG(2,("standard_terminate: reason[%s]\n",reason));
225
226 /* this reload_charcnv() has the effect of freeing the iconv context memory,
227 which makes leak checking easier */
228 reload_charcnv(lp_ctx);
229
230 talloc_free(ev);
231
232 /* terminate this process */
233 exit(0);
234}
235
236/* called to set a title of a task or connection */
237static void standard_set_title(struct tevent_context *ev, const char *title)
238{
239 if (title) {
240 setproctitle("%s", title);
241 } else {
242 setproctitle(NULL);
243 }
244}
245
246static const struct model_ops standard_ops = {
247 .name = "standard",
248 .model_init = standard_model_init,
249 .accept_connection = standard_accept_connection,
250 .new_task = standard_new_task,
251 .terminate = standard_terminate,
252 .set_title = standard_set_title,
253};
254
255/*
256 initialise the standard process model, registering ourselves with the process model subsystem
257 */
258NTSTATUS process_model_standard_init(void)
259{
260 return register_process_model(&standard_ops);
261}
Note: See TracBrowser for help on using the repository browser.