source: vendor/3.5.11/source4/smbd/server.c

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

Samba 3.5.0: Initial import
File size: 11.4 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3
4 Main SMB server routines
5
6 Copyright (C) Andrew Tridgell 1992-2005
7 Copyright (C) Martin Pool 2002
8 Copyright (C) Jelmer Vernooij 2002
9 Copyright (C) James J Myers 2003 <myersjj@samba.org>
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23*/
24
25#include "includes.h"
26#include "lib/events/events.h"
27#include "version.h"
28#include "lib/cmdline/popt_common.h"
29#include "system/dir.h"
30#include "system/filesys.h"
31#include "ntvfs/ntvfs.h"
32#include "ntptr/ntptr.h"
33#include "auth/gensec/gensec.h"
34#include "smbd/process_model.h"
35#include "param/secrets.h"
36#include "smbd/pidfile.h"
37#include "param/param.h"
38#include "dsdb/samdb/samdb.h"
39#include "auth/session.h"
40#include "lib/messaging/irpc.h"
41#include "librpc/gen_ndr/ndr_irpc.h"
42#include "cluster/cluster.h"
43
44/*
45 recursively delete a directory tree
46*/
47static void recursive_delete(const char *path)
48{
49 DIR *dir;
50 struct dirent *de;
51
52 dir = opendir(path);
53 if (!dir) {
54 return;
55 }
56
57 for (de=readdir(dir);de;de=readdir(dir)) {
58 char *fname;
59 struct stat st;
60
61 if (ISDOT(de->d_name) || ISDOTDOT(de->d_name)) {
62 continue;
63 }
64
65 fname = talloc_asprintf(path, "%s/%s", path, de->d_name);
66 if (stat(fname, &st) != 0) {
67 continue;
68 }
69 if (S_ISDIR(st.st_mode)) {
70 recursive_delete(fname);
71 talloc_free(fname);
72 continue;
73 }
74 if (unlink(fname) != 0) {
75 DEBUG(0,("Unabled to delete '%s' - %s\n",
76 fname, strerror(errno)));
77 smb_panic("unable to cleanup tmp files");
78 }
79 talloc_free(fname);
80 }
81 closedir(dir);
82}
83
84/*
85 cleanup temporary files. This is the new alternative to
86 TDB_CLEAR_IF_FIRST. Unfortunately TDB_CLEAR_IF_FIRST is not
87 efficient on unix systems due to the lack of scaling of the byte
88 range locking system. So instead of putting the burden on tdb to
89 cleanup tmp files, this function deletes them.
90*/
91static void cleanup_tmp_files(struct loadparm_context *lp_ctx)
92{
93 char *path;
94 TALLOC_CTX *mem_ctx = talloc_new(NULL);
95
96 path = smbd_tmp_path(mem_ctx, lp_ctx, NULL);
97
98 recursive_delete(path);
99 talloc_free(mem_ctx);
100}
101
102static void sig_hup(int sig)
103{
104 debug_schedule_reopen_logs();
105}
106
107static void sig_term(int sig)
108{
109#if HAVE_GETPGRP
110 static int done_sigterm;
111 if (done_sigterm == 0 && getpgrp() == getpid()) {
112 DEBUG(0,("SIGTERM: killing children\n"));
113 done_sigterm = 1;
114 kill(-getpgrp(), SIGTERM);
115 }
116#endif
117 DEBUG(0,("Exiting pid %d on SIGTERM\n", (int)getpid()));
118 exit(0);
119}
120
121/*
122 setup signal masks
123*/
124static void setup_signals(void)
125{
126 /* we are never interested in SIGPIPE */
127 BlockSignals(true,SIGPIPE);
128
129#if defined(SIGFPE)
130 /* we are never interested in SIGFPE */
131 BlockSignals(true,SIGFPE);
132#endif
133
134 /* We are no longer interested in USR1 */
135 BlockSignals(true, SIGUSR1);
136
137#if defined(SIGUSR2)
138 /* We are no longer interested in USR2 */
139 BlockSignals(true,SIGUSR2);
140#endif
141
142 /* POSIX demands that signals are inherited. If the invoking process has
143 * these signals masked, we will have problems, as we won't recieve them. */
144 BlockSignals(false, SIGHUP);
145 BlockSignals(false, SIGTERM);
146
147 CatchSignal(SIGHUP, sig_hup);
148 CatchSignal(SIGTERM, sig_term);
149}
150
151/*
152 handle io on stdin
153*/
154static void server_stdin_handler(struct tevent_context *event_ctx, struct tevent_fd *fde,
155 uint16_t flags, void *private_data)
156{
157 const char *binary_name = (const char *)private_data;
158 uint8_t c;
159 if (read(0, &c, 1) == 0) {
160 DEBUG(0,("%s: EOF on stdin - terminating\n", binary_name));
161#if HAVE_GETPGRP
162 if (getpgrp() == getpid()) {
163 DEBUG(0,("Sending SIGTERM from pid %d\n", (int)getpid()));
164 kill(-getpgrp(), SIGTERM);
165 }
166#endif
167 exit(0);
168 }
169}
170
171/*
172 die if the user selected maximum runtime is exceeded
173*/
174_NORETURN_ static void max_runtime_handler(struct tevent_context *ev,
175 struct tevent_timer *te,
176 struct timeval t, void *private_data)
177{
178 const char *binary_name = (const char *)private_data;
179 DEBUG(0,("%s: maximum runtime exceeded - terminating\n", binary_name));
180 exit(0);
181}
182
183/*
184 pre-open the sam ldb to ensure the schema has been loaded. This
185 saves a lot of time in child processes
186 */
187static void prime_samdb_schema(struct tevent_context *event_ctx)
188{
189 TALLOC_CTX *samdb_context;
190 samdb_context = talloc_new(event_ctx);
191 samdb_connect(samdb_context, event_ctx, cmdline_lp_ctx, system_session(samdb_context, cmdline_lp_ctx));
192 talloc_free(samdb_context);
193}
194
195
196/*
197 called when a fatal condition occurs in a child task
198 */
199static NTSTATUS samba_terminate(struct irpc_message *msg,
200 struct samba_terminate *r)
201{
202 DEBUG(0,("samba_terminate: %s\n", r->in.reason));
203 exit(1);
204}
205
206/*
207 setup messaging for the top level samba (parent) task
208 */
209static NTSTATUS setup_parent_messaging(struct tevent_context *event_ctx,
210 struct loadparm_context *lp_ctx)
211{
212 struct messaging_context *msg;
213 NTSTATUS status;
214
215 msg = messaging_init(talloc_autofree_context(),
216 lp_messaging_path(event_ctx, lp_ctx),
217 cluster_id(0, SAMBA_PARENT_TASKID),
218 lp_iconv_convenience(lp_ctx),
219 event_ctx);
220 NT_STATUS_HAVE_NO_MEMORY(msg);
221
222 irpc_add_name(msg, "samba");
223
224 status = IRPC_REGISTER(msg, irpc, SAMBA_TERMINATE,
225 samba_terminate, NULL);
226
227 return status;
228}
229
230
231
232/*
233 main server.
234*/
235static int binary_smbd_main(const char *binary_name, int argc, const char *argv[])
236{
237 bool opt_daemon = false;
238 bool opt_interactive = false;
239 int opt;
240 poptContext pc;
241 extern NTSTATUS server_service_wrepl_init(void);
242 extern NTSTATUS server_service_kdc_init(void);
243 extern NTSTATUS server_service_ldap_init(void);
244 extern NTSTATUS server_service_web_init(void);
245 extern NTSTATUS server_service_ldap_init(void);
246 extern NTSTATUS server_service_winbind_init(void);
247 extern NTSTATUS server_service_nbtd_init(void);
248 extern NTSTATUS server_service_auth_init(void);
249 extern NTSTATUS server_service_cldapd_init(void);
250 extern NTSTATUS server_service_smb_init(void);
251 extern NTSTATUS server_service_drepl_init(void);
252 extern NTSTATUS server_service_kcc_init(void);
253 extern NTSTATUS server_service_rpc_init(void);
254 extern NTSTATUS server_service_ntp_signd_init(void);
255 extern NTSTATUS server_service_samba3_smb_init(void);
256 init_module_fn static_init[] = { STATIC_service_MODULES };
257 init_module_fn *shared_init;
258 struct tevent_context *event_ctx;
259 uint16_t stdin_event_flags;
260 NTSTATUS status;
261 const char *model = "standard";
262 int max_runtime = 0;
263 enum {
264 OPT_DAEMON = 1000,
265 OPT_INTERACTIVE,
266 OPT_PROCESS_MODEL
267 };
268 struct poptOption long_options[] = {
269 POPT_AUTOHELP
270 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON,
271 "Become a daemon (default)", NULL },
272 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE,
273 "Run interactive (not a daemon)", NULL},
274 {"model", 'M', POPT_ARG_STRING, NULL, OPT_PROCESS_MODEL,
275 "Select process model", "MODEL"},
276 {"maximum-runtime",0, POPT_ARG_INT, &max_runtime, 0,
277 "set maximum runtime of the server process, till autotermination", "seconds"},
278 POPT_COMMON_SAMBA
279 POPT_COMMON_VERSION
280 { NULL }
281 };
282
283 pc = poptGetContext(binary_name, argc, argv, long_options, 0);
284 while((opt = poptGetNextOpt(pc)) != -1) {
285 switch(opt) {
286 case OPT_DAEMON:
287 opt_daemon = true;
288 break;
289 case OPT_INTERACTIVE:
290 opt_interactive = true;
291 break;
292 case OPT_PROCESS_MODEL:
293 model = poptGetOptArg(pc);
294 break;
295 default:
296 fprintf(stderr, "\nInvalid option %s: %s\n\n",
297 poptBadOption(pc, 0), poptStrerror(opt));
298 poptPrintUsage(pc, stderr, 0);
299 exit(1);
300 }
301 }
302
303 if (opt_daemon && opt_interactive) {
304 fprintf(stderr,"\nERROR: "
305 "Option -i|--interactive is not allowed together with -D|--daemon\n\n");
306 poptPrintUsage(pc, stderr, 0);
307 exit(1);
308 } else if (!opt_interactive) {
309 /* default is --daemon */
310 opt_daemon = true;
311 }
312
313 poptFreeContext(pc);
314
315 setup_logging(binary_name, opt_interactive?DEBUG_STDOUT:DEBUG_FILE);
316 setup_signals();
317
318 /* we want total control over the permissions on created files,
319 so set our umask to 0 */
320 umask(0);
321
322 DEBUG(0,("%s version %s started.\n", binary_name, SAMBA_VERSION_STRING));
323 DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team 1992-2009\n"));
324
325 if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4 || sizeof(uint64_t) < 8) {
326 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
327 DEBUGADD(0,("sizeof(uint16_t) = %u, sizeof(uint32_t) %u, sizeof(uint64_t) = %u\n",
328 (unsigned int)sizeof(uint16_t), (unsigned int)sizeof(uint32_t), (unsigned int)sizeof(uint64_t)));
329 exit(1);
330 }
331
332 if (opt_daemon) {
333 DEBUG(3,("Becoming a daemon.\n"));
334 become_daemon(true, false);
335 }
336
337 cleanup_tmp_files(cmdline_lp_ctx);
338
339 if (!directory_exist(lp_lockdir(cmdline_lp_ctx))) {
340 mkdir(lp_lockdir(cmdline_lp_ctx), 0755);
341 }
342
343 pidfile_create(lp_piddir(cmdline_lp_ctx), binary_name);
344
345 /* Do *not* remove this, until you have removed
346 * passdb/secrets.c, and proved that Samba still builds... */
347 /* Setup the SECRETS subsystem */
348 if (secrets_init(talloc_autofree_context(), cmdline_lp_ctx) == NULL) {
349 exit(1);
350 }
351
352 gensec_init(cmdline_lp_ctx); /* FIXME: */
353
354 ntptr_init(cmdline_lp_ctx); /* FIXME: maybe run this in the initialization function
355 of the spoolss RPC server instead? */
356
357 ntvfs_init(cmdline_lp_ctx); /* FIXME: maybe run this in the initialization functions
358 of the SMB[,2] server instead? */
359
360 process_model_init(cmdline_lp_ctx);
361
362 shared_init = load_samba_modules(NULL, cmdline_lp_ctx, "service");
363
364 run_init_functions(static_init);
365 run_init_functions(shared_init);
366
367 talloc_free(shared_init);
368
369 /* the event context is the top level structure in smbd. Everything else
370 should hang off that */
371 event_ctx = s4_event_context_init(talloc_autofree_context());
372
373 if (event_ctx == NULL) {
374 DEBUG(0,("Initializing event context failed\n"));
375 return 1;
376 }
377
378 if (opt_interactive) {
379 /* terminate when stdin goes away */
380 stdin_event_flags = TEVENT_FD_READ;
381 } else {
382 /* stay alive forever */
383 stdin_event_flags = 0;
384 }
385
386 /* catch EOF on stdin */
387#ifdef SIGTTIN
388 signal(SIGTTIN, SIG_IGN);
389#endif
390 tevent_add_fd(event_ctx, event_ctx, 0, stdin_event_flags,
391 server_stdin_handler,
392 discard_const(binary_name));
393
394 if (max_runtime) {
395 tevent_add_timer(event_ctx, event_ctx,
396 timeval_current_ofs(max_runtime, 0),
397 max_runtime_handler,
398 discard_const(binary_name));
399 }
400
401 prime_samdb_schema(event_ctx);
402
403 status = setup_parent_messaging(event_ctx, cmdline_lp_ctx);
404 if (!NT_STATUS_IS_OK(status)) {
405 DEBUG(0,("Failed to setup parent messaging - %s\n", nt_errstr(status)));
406 return 1;
407 }
408
409 DEBUG(0,("%s: using '%s' process model\n", binary_name, model));
410
411 status = server_service_startup(event_ctx, cmdline_lp_ctx, model,
412 lp_server_services(cmdline_lp_ctx));
413 if (!NT_STATUS_IS_OK(status)) {
414 DEBUG(0,("Starting Services failed - %s\n", nt_errstr(status)));
415 return 1;
416 }
417
418 /* wait for events - this is where smbd sits for most of its
419 life */
420 tevent_loop_wait(event_ctx);
421
422 /* as everything hangs off this event context, freeing it
423 should initiate a clean shutdown of all services */
424 talloc_free(event_ctx);
425
426 return 0;
427}
428
429int main(int argc, const char *argv[])
430{
431 return binary_smbd_main("samba", argc, argv);
432}
Note: See TracBrowser for help on using the repository browser.