source: trunk/server/source4/smbd/server.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 13.3 KB
RevLine 
[745]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 "libcli/auth/schannel.h"
35#include "smbd/process_model.h"
36#include "param/secrets.h"
37#include "smbd/pidfile.h"
38#include "param/param.h"
39#include "dsdb/samdb/samdb.h"
40#include "auth/session.h"
41#include "lib/messaging/irpc.h"
42#include "librpc/gen_ndr/ndr_irpc.h"
43#include "cluster/cluster.h"
44#include "dynconfig/dynconfig.h"
45
46/*
47 recursively delete a directory tree
48*/
49static void recursive_delete(const char *path)
50{
51 DIR *dir;
52 struct dirent *de;
53
54 dir = opendir(path);
55 if (!dir) {
56 return;
57 }
58
59 for (de=readdir(dir);de;de=readdir(dir)) {
60 char *fname;
61 struct stat st;
62
63 if (ISDOT(de->d_name) || ISDOTDOT(de->d_name)) {
64 continue;
65 }
66
67 fname = talloc_asprintf(path, "%s/%s", path, de->d_name);
68 if (stat(fname, &st) != 0) {
69 continue;
70 }
71 if (S_ISDIR(st.st_mode)) {
72 recursive_delete(fname);
73 talloc_free(fname);
74 continue;
75 }
76 if (unlink(fname) != 0) {
77 DEBUG(0,("Unabled to delete '%s' - %s\n",
78 fname, strerror(errno)));
79 smb_panic("unable to cleanup tmp files");
80 }
81 talloc_free(fname);
82 }
83 closedir(dir);
84}
85
86/*
87 cleanup temporary files. This is the new alternative to
88 TDB_CLEAR_IF_FIRST. Unfortunately TDB_CLEAR_IF_FIRST is not
89 efficient on unix systems due to the lack of scaling of the byte
90 range locking system. So instead of putting the burden on tdb to
91 cleanup tmp files, this function deletes them.
92*/
93static void cleanup_tmp_files(struct loadparm_context *lp_ctx)
94{
95 char *path;
96 TALLOC_CTX *mem_ctx = talloc_new(NULL);
97
98 path = smbd_tmp_path(mem_ctx, lp_ctx, NULL);
99
100 recursive_delete(path);
101 talloc_free(mem_ctx);
102}
103
104static void sig_hup(int sig)
105{
106 debug_schedule_reopen_logs();
107}
108
109static void sig_term(int sig)
110{
111#if HAVE_GETPGRP
112 static int done_sigterm;
113 if (done_sigterm == 0 && getpgrp() == getpid()) {
114 DEBUG(0,("SIGTERM: killing children\n"));
115 done_sigterm = 1;
116 kill(-getpgrp(), SIGTERM);
117 }
118#endif
119 DEBUG(0,("Exiting pid %d on SIGTERM\n", (int)getpid()));
120 exit(127);
121}
122
123/*
124 setup signal masks
125*/
126static void setup_signals(void)
127{
128 /* we are never interested in SIGPIPE */
129 BlockSignals(true,SIGPIPE);
130
131#if defined(SIGFPE)
132 /* we are never interested in SIGFPE */
133 BlockSignals(true,SIGFPE);
134#endif
135
136 /* We are no longer interested in USR1 */
137 BlockSignals(true, SIGUSR1);
138
139#if defined(SIGUSR2)
140 /* We are no longer interested in USR2 */
141 BlockSignals(true,SIGUSR2);
142#endif
143
144 /* POSIX demands that signals are inherited. If the invoking process has
145 * these signals masked, we will have problems, as we won't receive them. */
146 BlockSignals(false, SIGHUP);
147 BlockSignals(false, SIGTERM);
148
149 CatchSignal(SIGHUP, sig_hup);
150 CatchSignal(SIGTERM, sig_term);
151}
152
153/*
154 handle io on stdin
155*/
156static void server_stdin_handler(struct tevent_context *event_ctx, struct tevent_fd *fde,
157 uint16_t flags, void *private_data)
158{
159 const char *binary_name = (const char *)private_data;
160 uint8_t c;
161 if (read(0, &c, 1) == 0) {
162 DEBUG(0,("%s: EOF on stdin - terminating\n", binary_name));
163#if HAVE_GETPGRP
164 if (getpgrp() == getpid()) {
165 DEBUG(0,("Sending SIGTERM from pid %d\n", (int)getpid()));
166 kill(-getpgrp(), SIGTERM);
167 }
168#endif
169 exit(0);
170 }
171}
172
173/*
174 die if the user selected maximum runtime is exceeded
175*/
176_NORETURN_ static void max_runtime_handler(struct tevent_context *ev,
177 struct tevent_timer *te,
178 struct timeval t, void *private_data)
179{
180 const char *binary_name = (const char *)private_data;
181 struct timeval tv;
182 struct timezone tz;
183 if (gettimeofday(&tv, &tz) == 0) {
184 DEBUG(0,("%s: maximum runtime exceeded - terminating, current ts: %d\n", binary_name, (int)tv.tv_sec));
185 } else {
186 DEBUG(0,("%s: maximum runtime exceeded - terminating\n", binary_name));
187 }
188 exit(0);
189}
190
191/*
192 pre-open the key databases. This saves a lot of time in child
193 processes
194 */
195static void prime_ldb_databases(struct tevent_context *event_ctx)
196{
197 TALLOC_CTX *db_context;
198 db_context = talloc_new(event_ctx);
199
200 samdb_connect(db_context, event_ctx, cmdline_lp_ctx, system_session(cmdline_lp_ctx), 0);
201 privilege_connect(db_context, cmdline_lp_ctx);
202
203 /* we deliberately leave these open, which allows them to be
204 * re-used in ldb_wrap_connect() */
205}
206
207
208/*
209 called when a fatal condition occurs in a child task
210 */
211static NTSTATUS samba_terminate(struct irpc_message *msg,
212 struct samba_terminate *r)
213{
214 DEBUG(0,("samba_terminate: %s\n", r->in.reason));
215 exit(1);
216}
217
218/*
219 setup messaging for the top level samba (parent) task
220 */
221static NTSTATUS setup_parent_messaging(struct tevent_context *event_ctx,
222 struct loadparm_context *lp_ctx)
223{
224 struct messaging_context *msg;
225 NTSTATUS status;
226
227 msg = messaging_init(talloc_autofree_context(),
228 lpcfg_messaging_path(event_ctx, lp_ctx),
229 cluster_id(0, SAMBA_PARENT_TASKID), event_ctx);
230 NT_STATUS_HAVE_NO_MEMORY(msg);
231
232 irpc_add_name(msg, "samba");
233
234 status = IRPC_REGISTER(msg, irpc, SAMBA_TERMINATE,
235 samba_terminate, NULL);
236
237 return status;
238}
239
240
241/*
242 show build info
243 */
244static void show_build(void)
245{
246#define CONFIG_OPTION(n) { #n, dyn_ ## n }
247 struct {
248 const char *name;
249 const char *value;
250 } config_options[] = {
251 CONFIG_OPTION(BINDIR),
252 CONFIG_OPTION(SBINDIR),
253 CONFIG_OPTION(CONFIGFILE),
254 CONFIG_OPTION(NCALRPCDIR),
255 CONFIG_OPTION(LOGFILEBASE),
256 CONFIG_OPTION(LMHOSTSFILE),
257 CONFIG_OPTION(DATADIR),
258 CONFIG_OPTION(MODULESDIR),
259 CONFIG_OPTION(LOCKDIR),
260 CONFIG_OPTION(PIDDIR),
261 CONFIG_OPTION(PRIVATE_DIR),
262 CONFIG_OPTION(SWATDIR),
263 CONFIG_OPTION(CODEPAGEDIR),
264 CONFIG_OPTION(SETUPDIR),
265 CONFIG_OPTION(WINBINDD_SOCKET_DIR),
266 CONFIG_OPTION(WINBINDD_PRIVILEGED_SOCKET_DIR),
267 CONFIG_OPTION(NTP_SIGND_SOCKET_DIR),
268 { NULL, NULL}
269 };
270 int i;
271
272 printf("Samba version: %s\n", SAMBA_VERSION_STRING);
273 printf("Build environment:\n");
274#ifdef BUILD_SYSTEM
275 printf(" Build host: %s\n", BUILD_SYSTEM);
276#endif
277
278 printf("Paths:\n");
279 for (i=0; config_options[i].name; i++) {
280 printf(" %s: %s\n", config_options[i].name, config_options[i].value);
281 }
282
283 exit(0);
284}
285
286/*
287 main server.
288*/
289static int binary_smbd_main(const char *binary_name, int argc, const char *argv[])
290{
291 bool opt_daemon = false;
292 bool opt_interactive = false;
293 int opt;
294 poptContext pc;
295#define _MODULE_PROTO(init) extern NTSTATUS init(void);
296 STATIC_service_MODULES_PROTO;
297 init_module_fn static_init[] = { STATIC_service_MODULES };
298 init_module_fn *shared_init;
299 struct tevent_context *event_ctx;
300 uint16_t stdin_event_flags;
301 NTSTATUS status;
302 const char *model = "standard";
303 int max_runtime = 0;
304 enum {
305 OPT_DAEMON = 1000,
306 OPT_INTERACTIVE,
307 OPT_PROCESS_MODEL,
308 OPT_SHOW_BUILD
309 };
310 struct poptOption long_options[] = {
311 POPT_AUTOHELP
312 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON,
313 "Become a daemon (default)", NULL },
314 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE,
315 "Run interactive (not a daemon)", NULL},
316 {"model", 'M', POPT_ARG_STRING, NULL, OPT_PROCESS_MODEL,
317 "Select process model", "MODEL"},
318 {"maximum-runtime",0, POPT_ARG_INT, &max_runtime, 0,
319 "set maximum runtime of the server process, till autotermination", "seconds"},
320 {"show-build", 'b', POPT_ARG_NONE, NULL, OPT_SHOW_BUILD, "show build info", NULL },
321 POPT_COMMON_SAMBA
322 POPT_COMMON_VERSION
323 { NULL }
324 };
325
326 pc = poptGetContext(binary_name, argc, argv, long_options, 0);
327 while((opt = poptGetNextOpt(pc)) != -1) {
328 switch(opt) {
329 case OPT_DAEMON:
330 opt_daemon = true;
331 break;
332 case OPT_INTERACTIVE:
333 opt_interactive = true;
334 break;
335 case OPT_PROCESS_MODEL:
336 model = poptGetOptArg(pc);
337 break;
338 case OPT_SHOW_BUILD:
339 show_build();
340 break;
341 default:
342 fprintf(stderr, "\nInvalid option %s: %s\n\n",
343 poptBadOption(pc, 0), poptStrerror(opt));
344 poptPrintUsage(pc, stderr, 0);
345 return 1;
346 }
347 }
348
349 if (opt_daemon && opt_interactive) {
350 fprintf(stderr,"\nERROR: "
351 "Option -i|--interactive is not allowed together with -D|--daemon\n\n");
352 poptPrintUsage(pc, stderr, 0);
353 return 1;
354 } else if (!opt_interactive) {
355 /* default is --daemon */
356 opt_daemon = true;
357 }
358
359 poptFreeContext(pc);
360
361 setup_logging(binary_name, opt_interactive?DEBUG_STDOUT:DEBUG_FILE);
362 setup_signals();
363
364 /* we want total control over the permissions on created files,
365 so set our umask to 0 */
366 umask(0);
367
368 DEBUG(0,("%s version %s started.\n", binary_name, SAMBA_VERSION_STRING));
369 DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team 1992-2011\n"));
370
371 if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4 || sizeof(uint64_t) < 8) {
372 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
373 DEBUGADD(0,("sizeof(uint16_t) = %u, sizeof(uint32_t) %u, sizeof(uint64_t) = %u\n",
374 (unsigned int)sizeof(uint16_t), (unsigned int)sizeof(uint32_t), (unsigned int)sizeof(uint64_t)));
375 return 1;
376 }
377
378 if (opt_daemon) {
379 DEBUG(3,("Becoming a daemon.\n"));
380 become_daemon(true, false, false);
381 }
382
383 cleanup_tmp_files(cmdline_lp_ctx);
384
385 if (!directory_exist(lpcfg_lockdir(cmdline_lp_ctx))) {
386 mkdir(lpcfg_lockdir(cmdline_lp_ctx), 0755);
387 }
388
389 pidfile_create(lpcfg_piddir(cmdline_lp_ctx), binary_name);
390
391 /* Do *not* remove this, until you have removed
392 * passdb/secrets.c, and proved that Samba still builds... */
393 /* Setup the SECRETS subsystem */
394 if (secrets_init(talloc_autofree_context(), cmdline_lp_ctx) == NULL) {
395 return 1;
396 }
397
398 if (lpcfg_server_role(cmdline_lp_ctx) == ROLE_DOMAIN_CONTROLLER) {
399 if (!open_schannel_session_store(talloc_autofree_context(), lpcfg_private_dir(cmdline_lp_ctx))) {
400 DEBUG(0,("ERROR: Samba cannot open schannel store for secured NETLOGON operations.\n"));
401 exit(1);
402 }
403 }
404
405 gensec_init(cmdline_lp_ctx); /* FIXME: */
406
407 ntptr_init(cmdline_lp_ctx); /* FIXME: maybe run this in the initialization function
408 of the spoolss RPC server instead? */
409
410 ntvfs_init(cmdline_lp_ctx); /* FIXME: maybe run this in the initialization functions
411 of the SMB[,2] server instead? */
412
413 process_model_init(cmdline_lp_ctx);
414
415 shared_init = load_samba_modules(NULL, cmdline_lp_ctx, "service");
416
417 run_init_functions(static_init);
418 run_init_functions(shared_init);
419
420 talloc_free(shared_init);
421
422 /* the event context is the top level structure in smbd. Everything else
423 should hang off that */
424 event_ctx = s4_event_context_init(talloc_autofree_context());
425
426 if (event_ctx == NULL) {
427 DEBUG(0,("Initializing event context failed\n"));
428 return 1;
429 }
430
431 if (opt_interactive) {
432 /* terminate when stdin goes away */
433 stdin_event_flags = TEVENT_FD_READ;
434 } else {
435 /* stay alive forever */
436 stdin_event_flags = 0;
437 }
438
439 /* catch EOF on stdin */
440#ifdef SIGTTIN
441 signal(SIGTTIN, SIG_IGN);
442#endif
443 tevent_add_fd(event_ctx, event_ctx, 0, stdin_event_flags,
444 server_stdin_handler,
445 discard_const(binary_name));
446
447 if (max_runtime) {
448 struct timeval tv;
449 struct timezone tz;
450
451 if (gettimeofday(&tv, &tz) == 0) {
452 DEBUG(0,("Called with maxruntime %d - current ts %d\n", max_runtime, (int)tv.tv_sec));
453 } else {
454 DEBUG(0,("Called with maxruntime %d\n", max_runtime));
455 }
456 tevent_add_timer(event_ctx, event_ctx,
457 timeval_current_ofs(max_runtime, 0),
458 max_runtime_handler,
459 discard_const(binary_name));
460 }
461
462 prime_ldb_databases(event_ctx);
463
464 status = setup_parent_messaging(event_ctx, cmdline_lp_ctx);
465 if (!NT_STATUS_IS_OK(status)) {
466 DEBUG(0,("Failed to setup parent messaging - %s\n", nt_errstr(status)));
467 return 1;
468 }
469
470 DEBUG(0,("%s: using '%s' process model\n", binary_name, model));
471
472 status = server_service_startup(event_ctx, cmdline_lp_ctx, model,
473 lpcfg_server_services(cmdline_lp_ctx));
474 if (!NT_STATUS_IS_OK(status)) {
475 DEBUG(0,("Starting Services failed - %s\n", nt_errstr(status)));
476 return 1;
477 }
478
479 /* wait for events - this is where smbd sits for most of its
480 life */
481 tevent_loop_wait(event_ctx);
482
483 /* as everything hangs off this event context, freeing it
484 should initiate a clean shutdown of all services */
485 talloc_free(event_ctx);
486
487 return 0;
488}
489
490int main(int argc, const char *argv[])
491{
492 return binary_smbd_main("samba", argc, argv);
493}
Note: See TracBrowser for help on using the repository browser.