source: branches/samba-3.3.x/source/smbd/server.c@ 411

Last change on this file since 411 was 411, checked in by Herwig Bauernfeind, 15 years ago

Update Samba 3.3.x to 3.3.11
File size: 39.3 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Main SMB server routines
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Martin Pool 2002
6 Copyright (C) Jelmer Vernooij 2002-2003
7 Copyright (C) Volker Lendecke 1993-2007
8 Copyright (C) Jeremy Allison 1993-2007
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
26static_decl_rpc;
27
28static int am_parent = 1;
29
30extern struct auth_context *negprot_global_auth_context;
31extern SIG_ATOMIC_T got_sig_term;
32extern SIG_ATOMIC_T reload_after_sighup;
33static SIG_ATOMIC_T got_sig_cld;
34
35#ifdef WITH_DFS
36extern int dcelogin_atmost_once;
37#endif /* WITH_DFS */
38
39/* really we should have a top level context structure that has the
40 client file descriptor as an element. That would require a major rewrite :(
41
42 the following 2 functions are an alternative - they make the file
43 descriptor private to smbd
44 */
45static int server_fd = -1;
46
47int smbd_server_fd(void)
48{
49 return server_fd;
50}
51
52static void smbd_set_server_fd(int fd)
53{
54 server_fd = fd;
55}
56
57int get_client_fd(void)
58{
59 return server_fd;
60}
61
62#ifdef CLUSTER_SUPPORT
63static int client_get_tcp_info(struct sockaddr_storage *server,
64 struct sockaddr_storage *client)
65{
66 socklen_t length;
67 if (server_fd == -1) {
68 return -1;
69 }
70 length = sizeof(*server);
71 if (getsockname(server_fd, (struct sockaddr *)server, &length) != 0) {
72 return -1;
73 }
74 length = sizeof(*client);
75 if (getpeername(server_fd, (struct sockaddr *)client, &length) != 0) {
76 return -1;
77 }
78 return 0;
79}
80#endif
81
82struct event_context *smbd_event_context(void)
83{
84 static struct event_context *ctx;
85
86 if (!ctx && !(ctx = event_context_init(talloc_autofree_context()))) {
87 smb_panic("Could not init smbd event context");
88 }
89 return ctx;
90}
91
92struct messaging_context *smbd_messaging_context(void)
93{
94 static struct messaging_context *ctx;
95
96 if (ctx == NULL) {
97 ctx = messaging_init(talloc_autofree_context(), server_id_self(),
98 smbd_event_context());
99 }
100 if (ctx == NULL) {
101 DEBUG(0, ("Could not init smbd messaging context.\n"));
102 }
103 return ctx;
104}
105
106struct memcache *smbd_memcache(void)
107{
108 static struct memcache *cache;
109
110 if (!cache
111 && !(cache = memcache_init(talloc_autofree_context(),
112 lp_max_stat_cache_size()*1024))) {
113
114 smb_panic("Could not init smbd memcache");
115 }
116 return cache;
117}
118
119/*******************************************************************
120 What to do when smb.conf is updated.
121 ********************************************************************/
122
123static void smb_conf_updated(struct messaging_context *msg,
124 void *private_data,
125 uint32_t msg_type,
126 struct server_id server_id,
127 DATA_BLOB *data)
128{
129 DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
130 "updated. Reloading.\n"));
131 reload_services(False);
132}
133
134
135/*******************************************************************
136 Delete a statcache entry.
137 ********************************************************************/
138
139static void smb_stat_cache_delete(struct messaging_context *msg,
140 void *private_data,
141 uint32_t msg_tnype,
142 struct server_id server_id,
143 DATA_BLOB *data)
144{
145 const char *name = (const char *)data->data;
146 DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
147 stat_cache_delete(name);
148}
149
150/****************************************************************************
151 Terminate signal.
152****************************************************************************/
153
154static void sig_term(void)
155{
156 got_sig_term = 1;
157 sys_select_signal(SIGTERM);
158}
159
160/****************************************************************************
161 Catch a sighup.
162****************************************************************************/
163
164static void sig_hup(int sig)
165{
166 reload_after_sighup = 1;
167 sys_select_signal(SIGHUP);
168}
169
170/****************************************************************************
171 Catch a sigcld
172****************************************************************************/
173static void sig_cld(int sig)
174{
175 got_sig_cld = 1;
176 sys_select_signal(SIGCLD);
177}
178
179/****************************************************************************
180 Send a SIGTERM to our process group.
181*****************************************************************************/
182
183static void killkids(void)
184{
185 if(am_parent) kill(0,SIGTERM);
186}
187
188/****************************************************************************
189 Process a sam sync message - not sure whether to do this here or
190 somewhere else.
191****************************************************************************/
192
193static void msg_sam_sync(struct messaging_context *msg,
194 void *private_data,
195 uint32_t msg_type,
196 struct server_id server_id,
197 DATA_BLOB *data)
198{
199 DEBUG(10, ("** sam sync message received, ignoring\n"));
200}
201
202
203/****************************************************************************
204 Open the socket communication - inetd.
205****************************************************************************/
206
207static bool open_sockets_inetd(void)
208{
209 /* Started from inetd. fd 0 is the socket. */
210 /* We will abort gracefully when the client or remote system
211 goes away */
212 smbd_set_server_fd(dup(0));
213
214 /* close our standard file descriptors */
215 close_low_fds(False); /* Don't close stderr */
216
217 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
218 set_socket_options(smbd_server_fd(), lp_socket_options());
219
220 return True;
221}
222
223static void msg_exit_server(struct messaging_context *msg,
224 void *private_data,
225 uint32_t msg_type,
226 struct server_id server_id,
227 DATA_BLOB *data)
228{
229 DEBUG(3, ("got a SHUTDOWN message\n"));
230 exit_server_cleanly(NULL);
231}
232
233#ifdef DEVELOPER
234static void msg_inject_fault(struct messaging_context *msg,
235 void *private_data,
236 uint32_t msg_type,
237 struct server_id src,
238 DATA_BLOB *data)
239{
240 int sig;
241
242 if (data->length != sizeof(sig)) {
243
244 DEBUG(0, ("Process %s sent bogus signal injection request\n",
245 procid_str_static(&src)));
246 return;
247 }
248
249 sig = *(int *)data->data;
250 if (sig == -1) {
251 exit_server("internal error injected");
252 return;
253 }
254
255#if HAVE_STRSIGNAL
256 DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
257 procid_str_static(&src), sig, strsignal(sig)));
258#else
259 DEBUG(0, ("Process %s requested injection of signal %d\n",
260 procid_str_static(&src), sig));
261#endif
262
263 kill(sys_getpid(), sig);
264}
265#endif /* DEVELOPER */
266
267struct child_pid {
268 struct child_pid *prev, *next;
269 pid_t pid;
270};
271
272static struct child_pid *children;
273static int num_children;
274
275static void add_child_pid(pid_t pid)
276{
277 struct child_pid *child;
278
279 if (lp_max_smbd_processes() == 0) {
280 /* Don't bother with the child list if we don't care anyway */
281 return;
282 }
283
284 child = SMB_MALLOC_P(struct child_pid);
285 if (child == NULL) {
286 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
287 return;
288 }
289 child->pid = pid;
290 DLIST_ADD(children, child);
291 num_children += 1;
292}
293
294static void remove_child_pid(pid_t pid, bool unclean_shutdown)
295{
296 struct child_pid *child;
297
298 if (unclean_shutdown) {
299 /* a child terminated uncleanly so tickle all processes to see
300 if they can grab any of the pending locks
301 */
302 DEBUG(3,(__location__ " Unclean shutdown of pid %u\n", (unsigned int)pid));
303 messaging_send_buf(smbd_messaging_context(), procid_self(),
304 MSG_SMB_BRL_VALIDATE, NULL, 0);
305 message_send_all(smbd_messaging_context(),
306 MSG_SMB_UNLOCK, NULL, 0, NULL);
307 }
308
309 if (lp_max_smbd_processes() == 0) {
310 /* Don't bother with the child list if we don't care anyway */
311 return;
312 }
313
314 for (child = children; child != NULL; child = child->next) {
315 if (child->pid == pid) {
316 struct child_pid *tmp = child;
317 DLIST_REMOVE(children, child);
318 SAFE_FREE(tmp);
319 num_children -= 1;
320 return;
321 }
322 }
323
324 DEBUG(0, ("Could not find child %d -- ignoring\n", (int)pid));
325}
326
327/****************************************************************************
328 Have we reached the process limit ?
329****************************************************************************/
330
331static bool allowable_number_of_smbd_processes(void)
332{
333 int max_processes = lp_max_smbd_processes();
334
335 if (!max_processes)
336 return True;
337
338 return num_children < max_processes;
339}
340
341/****************************************************************************
342 Open the socket communication.
343****************************************************************************/
344
345static bool open_sockets_smbd(bool is_daemon, bool interactive, const char *smb_ports)
346{
347 int num_interfaces = iface_count();
348 int num_sockets = 0;
349 int fd_listenset[FD_SETSIZE];
350 fd_set listen_set;
351 int s;
352 int maxfd = 0;
353 int i;
354 char *ports;
355 struct dns_reg_state * dns_reg = NULL;
356 unsigned dns_port = 0;
357
358#ifdef HAVE_ATEXIT
359 {
360 static int atexit_set;
361 if(atexit_set == 0) {
362 atexit_set=1;
363 atexit(killkids);
364 }
365 }
366#endif
367
368 if (!is_daemon) {
369 /*
370 * Stop zombies the old way.
371 * We aren't forking any new
372 * 'normal' connections when
373 * run from [x]inetd.
374 */
375 CatchChild();
376 return open_sockets_inetd();
377 }
378
379 /* Stop zombies */
380 CatchSignal(SIGCLD, sig_cld);
381
382 FD_ZERO(&listen_set);
383
384 /* use a reasonable default set of ports - listing on 445 and 139 */
385 if (!smb_ports) {
386 ports = lp_smb_ports();
387 if (!ports || !*ports) {
388 ports = smb_xstrdup(SMB_PORTS);
389 } else {
390 ports = smb_xstrdup(ports);
391 }
392 } else {
393 ports = smb_xstrdup(smb_ports);
394 }
395
396 if (lp_interfaces() && lp_bind_interfaces_only()) {
397 /* We have been given an interfaces line, and been
398 told to only bind to those interfaces. Create a
399 socket per interface and bind to only these.
400 */
401
402 /* Now open a listen socket for each of the
403 interfaces. */
404 for(i = 0; i < num_interfaces; i++) {
405 TALLOC_CTX *frame = NULL;
406 const struct sockaddr_storage *ifss =
407 iface_n_sockaddr_storage(i);
408 char *tok;
409 const char *ptr;
410
411 if (ifss == NULL) {
412 DEBUG(0,("open_sockets_smbd: "
413 "interface %d has NULL IP address !\n",
414 i));
415 continue;
416 }
417
418 frame = talloc_stackframe();
419 for (ptr=ports;
420 next_token_talloc(frame,&ptr, &tok, " \t,");) {
421 unsigned port = atoi(tok);
422 if (port == 0 || port > 0xffff) {
423 continue;
424 }
425
426 /* Keep the first port for mDNS service
427 * registration.
428 */
429 if (dns_port == 0) {
430 dns_port = port;
431 }
432
433 s = fd_listenset[num_sockets] =
434 open_socket_in(SOCK_STREAM,
435 port,
436 num_sockets == 0 ? 0 : 2,
437 ifss,
438 true);
439 if(s == -1) {
440 continue;
441 }
442
443 /* ready to listen */
444 set_socket_options(s,"SO_KEEPALIVE");
445 set_socket_options(s,lp_socket_options());
446
447 /* Set server socket to
448 * non-blocking for the accept. */
449 set_blocking(s,False);
450
451 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
452 DEBUG(0,("open_sockets_smbd: listen: "
453 "%s\n", strerror(errno)));
454 close(s);
455 TALLOC_FREE(frame);
456 return False;
457 }
458 FD_SET(s,&listen_set);
459 maxfd = MAX( maxfd, s);
460
461 num_sockets++;
462 if (num_sockets >= FD_SETSIZE) {
463 DEBUG(0,("open_sockets_smbd: Too "
464 "many sockets to bind to\n"));
465 TALLOC_FREE(frame);
466 return False;
467 }
468 }
469 TALLOC_FREE(frame);
470 }
471 } else {
472 /* Just bind to 0.0.0.0 - accept connections
473 from anywhere. */
474
475 TALLOC_CTX *frame = talloc_stackframe();
476 char *tok;
477 const char *ptr;
478 const char *sock_addr = lp_socket_address();
479 char *sock_tok;
480 const char *sock_ptr;
481
482 if (strequal(sock_addr, "0.0.0.0") ||
483 strequal(sock_addr, "::")) {
484#if HAVE_IPV6
485 sock_addr = "::,0.0.0.0";
486#else
487 sock_addr = "0.0.0.0";
488#endif
489 }
490
491 for (sock_ptr=sock_addr;
492 next_token_talloc(frame, &sock_ptr, &sock_tok, " \t,"); ) {
493 for (ptr=ports; next_token_talloc(frame, &ptr, &tok, " \t,"); ) {
494 struct sockaddr_storage ss;
495
496 unsigned port = atoi(tok);
497 if (port == 0 || port > 0xffff) {
498 continue;
499 }
500
501 /* Keep the first port for mDNS service
502 * registration.
503 */
504 if (dns_port == 0) {
505 dns_port = port;
506 }
507
508 /* open an incoming socket */
509 if (!interpret_string_addr(&ss, sock_tok,
510 AI_NUMERICHOST|AI_PASSIVE)) {
511 continue;
512 }
513
514 s = open_socket_in(SOCK_STREAM,
515 port,
516 num_sockets == 0 ? 0 : 2,
517 &ss,
518 true);
519 if (s == -1) {
520 continue;
521 }
522
523 /* ready to listen */
524 set_socket_options(s,"SO_KEEPALIVE");
525 set_socket_options(s,lp_socket_options());
526
527 /* Set server socket to non-blocking
528 * for the accept. */
529 set_blocking(s,False);
530
531 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
532 DEBUG(0,("open_sockets_smbd: "
533 "listen: %s\n",
534 strerror(errno)));
535 close(s);
536 TALLOC_FREE(frame);
537 return False;
538 }
539
540 fd_listenset[num_sockets] = s;
541 FD_SET(s,&listen_set);
542 maxfd = MAX( maxfd, s);
543
544 num_sockets++;
545
546 if (num_sockets >= FD_SETSIZE) {
547 DEBUG(0,("open_sockets_smbd: Too "
548 "many sockets to bind to\n"));
549 TALLOC_FREE(frame);
550 return False;
551 }
552 }
553 }
554 TALLOC_FREE(frame);
555 }
556
557 SAFE_FREE(ports);
558
559 if (num_sockets == 0) {
560 DEBUG(0,("open_sockets_smbd: No "
561 "sockets available to bind to.\n"));
562 return false;
563 }
564
565 /* Setup the main smbd so that we can get messages. Note that
566 do this after starting listening. This is needed as when in
567 clustered mode, ctdb won't allow us to start doing database
568 operations until it has gone thru a full startup, which
569 includes checking to see that smbd is listening. */
570 claim_connection(NULL,"",
571 FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_DBWRAP);
572
573 /* Listen to messages */
574
575 messaging_register(smbd_messaging_context(), NULL,
576 MSG_SMB_SAM_SYNC, msg_sam_sync);
577 messaging_register(smbd_messaging_context(), NULL,
578 MSG_SHUTDOWN, msg_exit_server);
579 messaging_register(smbd_messaging_context(), NULL,
580 MSG_SMB_FILE_RENAME, msg_file_was_renamed);
581 messaging_register(smbd_messaging_context(), NULL,
582 MSG_SMB_CONF_UPDATED, smb_conf_updated);
583 messaging_register(smbd_messaging_context(), NULL,
584 MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
585 brl_register_msgs(smbd_messaging_context());
586
587#ifdef CLUSTER_SUPPORT
588 if (lp_clustering()) {
589 ctdbd_register_reconfigure(messaging_ctdbd_connection());
590 }
591#endif
592
593#ifdef DEVELOPER
594 messaging_register(smbd_messaging_context(), NULL,
595 MSG_SMB_INJECT_FAULT, msg_inject_fault);
596#endif
597
598 /* Kick off our mDNS registration. */
599 if (dns_port != 0) {
600#ifdef WITH_AVAHI_SUPPORT
601 void *avahi_conn;
602 avahi_conn = avahi_start_register(
603 smbd_event_context(), smbd_event_context(),
604 dns_port);
605 if (avahi_conn == NULL) {
606 DEBUG(10, ("avahi_start_register failed\n"));
607 }
608#endif
609 }
610
611 /* now accept incoming connections - forking a new process
612 for each incoming connection */
613 DEBUG(2,("waiting for a connection\n"));
614 while (1) {
615 struct timeval now, idle_timeout;
616 fd_set r_fds, w_fds;
617 int num;
618
619 /* Ensure we respond to PING and DEBUG messages from the main smbd. */
620 message_dispatch(smbd_messaging_context());
621
622 if (got_sig_cld) {
623 pid_t pid;
624 int status;
625
626 got_sig_cld = False;
627
628 while ((pid = sys_waitpid(-1, &status, WNOHANG)) > 0) {
629 bool unclean_shutdown = False;
630
631 /* If the child terminated normally, assume
632 it was an unclean shutdown unless the
633 status is 0
634 */
635 if (WIFEXITED(status)) {
636 unclean_shutdown = WEXITSTATUS(status);
637 }
638 /* If the child terminated due to a signal
639 we always assume it was unclean.
640 */
641 if (WIFSIGNALED(status)) {
642 unclean_shutdown = True;
643 }
644 remove_child_pid(pid, unclean_shutdown);
645 }
646 }
647
648 idle_timeout = timeval_zero();
649
650 memcpy((char *)&r_fds, (char *)&listen_set,
651 sizeof(listen_set));
652 FD_ZERO(&w_fds);
653 GetTimeOfDay(&now);
654
655 /* Kick off our mDNS registration. */
656 if (dns_port != 0) {
657 dns_register_smbd(&dns_reg, dns_port, &maxfd,
658 &r_fds, &idle_timeout);
659 }
660
661 event_add_to_select_args(smbd_event_context(), &now,
662 &r_fds, &w_fds, &idle_timeout,
663 &maxfd);
664
665 num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
666 timeval_is_zero(&idle_timeout) ?
667 NULL : &idle_timeout);
668
669 if (num == -1 && errno == EINTR) {
670 if (got_sig_term) {
671 exit_server_cleanly(NULL);
672 }
673
674 /* check for sighup processing */
675 if (reload_after_sighup) {
676 change_to_root_user();
677 DEBUG(1,("Reloading services after SIGHUP\n"));
678 reload_services(False);
679 reload_after_sighup = 0;
680 }
681
682 continue;
683 }
684
685
686 /* If the idle timeout fired and we don't have any connected
687 * users, exit gracefully. We should be running under a process
688 * controller that will restart us if necessry.
689 */
690 if (num == 0 && count_all_current_connections() == 0) {
691 exit_server_cleanly("idle timeout");
692 }
693
694 /* process pending nDNS responses */
695 if (dns_register_smbd_reply(dns_reg, &r_fds, &idle_timeout)) {
696 --num;
697 }
698
699 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
700 continue;
701 }
702
703 /* check if we need to reload services */
704 check_reload(time(NULL));
705
706 /* Find the sockets that are read-ready -
707 accept on these. */
708 for( ; num > 0; num--) {
709 struct sockaddr addr;
710 socklen_t in_addrlen = sizeof(addr);
711 pid_t child = 0;
712
713 s = -1;
714 for(i = 0; i < num_sockets; i++) {
715 if(FD_ISSET(fd_listenset[i],&r_fds)) {
716 s = fd_listenset[i];
717 /* Clear this so we don't look
718 at it again. */
719 FD_CLR(fd_listenset[i],&r_fds);
720 break;
721 }
722 }
723
724 smbd_set_server_fd(accept(s,&addr,&in_addrlen));
725
726 if (smbd_server_fd() == -1 && errno == EINTR)
727 continue;
728
729 if (smbd_server_fd() == -1) {
730 DEBUG(2,("open_sockets_smbd: accept: %s\n",
731 strerror(errno)));
732 continue;
733 }
734
735 /* Ensure child is set to blocking mode */
736 set_blocking(smbd_server_fd(),True);
737
738 if (smbd_server_fd() != -1 && interactive)
739 return True;
740
741 if (allowable_number_of_smbd_processes() &&
742 smbd_server_fd() != -1 &&
743 ((child = sys_fork())==0)) {
744 char remaddr[INET6_ADDRSTRLEN];
745
746 /* Child code ... */
747
748 /* Stop zombies, the parent explicitly handles
749 * them, counting worker smbds. */
750 CatchChild();
751
752 /* close the listening socket(s) */
753 for(i = 0; i < num_sockets; i++)
754 close(fd_listenset[i]);
755
756 /* close our mDNS daemon handle */
757 dns_register_close(&dns_reg);
758
759 /* close our standard file
760 descriptors */
761 close_low_fds(False);
762 am_parent = 0;
763
764 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
765 set_socket_options(smbd_server_fd(),
766 lp_socket_options());
767
768 /* this is needed so that we get decent entries
769 in smbstatus for port 445 connects */
770 set_remote_machine_name(get_peer_addr(smbd_server_fd(),
771 remaddr,
772 sizeof(remaddr)),
773 false);
774
775 if (!reinit_after_fork(
776 smbd_messaging_context(),
777 smbd_event_context(),
778 true)) {
779 DEBUG(0,("reinit_after_fork() failed\n"));
780 smb_panic("reinit_after_fork() failed");
781 }
782
783 return True;
784 }
785 /* The parent doesn't need this socket */
786 close(smbd_server_fd());
787
788 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
789 Clear the closed fd info out of server_fd --
790 and more importantly, out of client_fd in
791 util_sock.c, to avoid a possible
792 getpeername failure if we reopen the logs
793 and use %I in the filename.
794 */
795
796 smbd_set_server_fd(-1);
797
798 if (child != 0) {
799 add_child_pid(child);
800 }
801
802 /* Force parent to check log size after
803 * spawning child. Fix from
804 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
805 * parent smbd will log to logserver.smb. It
806 * writes only two messages for each child
807 * started/finished. But each child writes,
808 * say, 50 messages also in logserver.smb,
809 * begining with the debug_count of the
810 * parent, before the child opens its own log
811 * file logserver.client. In a worst case
812 * scenario the size of logserver.smb would be
813 * checked after about 50*50=2500 messages
814 * (ca. 100kb).
815 * */
816 force_check_log_size();
817
818 } /* end for num */
819 } /* end while 1 */
820
821/* NOTREACHED return True; */
822}
823
824/****************************************************************************
825 Reload printers
826**************************************************************************/
827void reload_printers(void)
828{
829 int snum;
830 int n_services = lp_numservices();
831 int pnum = lp_servicenumber(PRINTERS_NAME);
832 const char *pname;
833
834 pcap_cache_reload();
835
836 /* remove stale printers */
837 for (snum = 0; snum < n_services; snum++) {
838 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
839 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
840 lp_autoloaded(snum)))
841 continue;
842
843 pname = lp_printername(snum);
844 if (!pcap_printername_ok(pname)) {
845 DEBUG(3, ("removing stale printer %s\n", pname));
846
847 if (is_printer_published(NULL, snum, NULL))
848 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
849 del_a_printer(pname);
850 lp_killservice(snum);
851 }
852 }
853
854 load_printers();
855}
856
857/****************************************************************************
858 Reload the services file.
859**************************************************************************/
860
861bool reload_services(bool test)
862{
863 bool ret;
864
865 if (lp_loaded()) {
866 char *fname = lp_configfile();
867 if (file_exist(fname, NULL) &&
868 !strcsequal(fname, get_dyn_CONFIGFILE())) {
869 set_dyn_CONFIGFILE(fname);
870 test = False;
871 }
872 }
873
874 reopen_logs();
875
876 if (test && !lp_file_list_changed())
877 return(True);
878
879 lp_killunused(conn_snum_used);
880
881 ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
882
883 reload_printers();
884
885 /* perhaps the config filename is now set */
886 if (!test)
887 reload_services(True);
888
889 reopen_logs();
890
891 load_interfaces();
892
893 if (smbd_server_fd() != -1) {
894 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
895 set_socket_options(smbd_server_fd(), lp_socket_options());
896 }
897
898 mangle_reset_cache();
899 reset_stat_cache();
900
901 /* this forces service parameters to be flushed */
902 set_current_service(NULL,0,True);
903
904 return(ret);
905}
906
907/****************************************************************************
908 Exit the server.
909****************************************************************************/
910
911/* Reasons for shutting down a server process. */
912enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
913
914static void exit_server_common(enum server_exit_reason how,
915 const char *const reason) NORETURN_ATTRIBUTE;
916
917static void exit_server_common(enum server_exit_reason how,
918 const char *const reason)
919{
920 static int firsttime=1;
921 bool had_open_conn;
922
923 if (!firsttime)
924 exit(0);
925 firsttime = 0;
926
927 change_to_root_user();
928
929 if (negprot_global_auth_context) {
930 (negprot_global_auth_context->free)(&negprot_global_auth_context);
931 }
932
933 had_open_conn = conn_close_all();
934
935 invalidate_all_vuids();
936
937 /* 3 second timeout. */
938 print_notify_send_messages(smbd_messaging_context(), 3);
939
940 /* delete our entry in the connections database. */
941 yield_connection(NULL,"");
942
943 respond_to_all_remaining_local_messages();
944
945#ifdef WITH_DFS
946 if (dcelogin_atmost_once) {
947 dfs_unlogin();
948 }
949#endif
950
951#ifdef USE_DMAPI
952 /* Destroy Samba DMAPI session only if we are master smbd process */
953 if (am_parent) {
954 if (!dmapi_destroy_session()) {
955 DEBUG(0,("Unable to close Samba DMAPI session\n"));
956 }
957 }
958#endif
959
960 locking_end();
961 printing_end();
962
963#ifdef __OS2__
964 /* On OS/2 - we need to remove the PID file on server exit otherwise we may not be able to restart Samba */
965 char pidFile[1024];
966 slprintf(pidFile, sizeof(pidFile)-1, "%s/%s.pid", lp_piddir(), "smbd");
967 unlink(pidFile);
968#endif
969
970 if (how != SERVER_EXIT_NORMAL) {
971 int oldlevel = DEBUGLEVEL;
972
973 DEBUGLEVEL = 10;
974
975 DEBUGSEP(0);
976 DEBUG(0,("Abnormal server exit: %s\n",
977 reason ? reason : "no explanation provided"));
978 DEBUGSEP(0);
979
980 log_stack_trace();
981
982 DEBUGLEVEL = oldlevel;
983 dump_core();
984
985 } else {
986 DEBUG(3,("Server exit (%s)\n",
987 (reason ? reason : "normal exit")));
988 }
989
990 /* if we had any open SMB connections when we exited then we
991 need to tell the parent smbd so that it can trigger a retry
992 of any locks we may have been holding or open files we were
993 blocking */
994 if (had_open_conn) {
995 exit(1);
996 } else {
997 exit(0);
998 }
999}
1000
1001void exit_server(const char *const explanation)
1002{
1003 exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
1004}
1005
1006void exit_server_cleanly(const char *const explanation)
1007{
1008 exit_server_common(SERVER_EXIT_NORMAL, explanation);
1009}
1010
1011void exit_server_fault(void)
1012{
1013 exit_server("critical server fault");
1014}
1015
1016
1017/****************************************************************************
1018received when we should release a specific IP
1019****************************************************************************/
1020static void release_ip(const char *ip, void *priv)
1021{
1022 char addr[INET6_ADDRSTRLEN];
1023
1024 if (strcmp(client_socket_addr(get_client_fd(),addr,sizeof(addr)), ip) == 0) {
1025 /* we can't afford to do a clean exit - that involves
1026 database writes, which would potentially mean we
1027 are still running after the failover has finished -
1028 we have to get rid of this process ID straight
1029 away */
1030 DEBUG(0,("Got release IP message for our IP %s - exiting immediately\n",
1031 ip));
1032 /* note we must exit with non-zero status so the unclean handler gets
1033 called in the parent, so that the brl database is tickled */
1034 _exit(1);
1035 }
1036}
1037
1038static void msg_release_ip(struct messaging_context *msg_ctx, void *private_data,
1039 uint32_t msg_type, struct server_id server_id, DATA_BLOB *data)
1040{
1041 release_ip((char *)data->data, NULL);
1042}
1043
1044/****************************************************************************
1045 Initialise connect, service and file structs.
1046****************************************************************************/
1047
1048static bool init_structs(void )
1049{
1050 /*
1051 * Set the machine NETBIOS name if not already
1052 * set from the config file.
1053 */
1054
1055 if (!init_names())
1056 return False;
1057
1058 conn_init();
1059
1060 file_init();
1061
1062 /* for RPC pipes */
1063 init_rpc_pipe_hnd();
1064
1065 init_dptrs();
1066
1067 if (!secrets_init())
1068 return False;
1069
1070 return True;
1071}
1072
1073/*
1074 * Send keepalive packets to our client
1075 */
1076static bool keepalive_fn(const struct timeval *now, void *private_data)
1077{
1078 if (!send_keepalive(smbd_server_fd())) {
1079 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
1080 return False;
1081 }
1082 return True;
1083}
1084
1085/*
1086 * Do the recurring check if we're idle
1087 */
1088static bool deadtime_fn(const struct timeval *now, void *private_data)
1089{
1090 if ((conn_num_open() == 0)
1091 || (conn_idle_all(now->tv_sec))) {
1092 DEBUG( 2, ( "Closing idle connection\n" ) );
1093 messaging_send(smbd_messaging_context(), procid_self(),
1094 MSG_SHUTDOWN, &data_blob_null);
1095 return False;
1096 }
1097
1098 return True;
1099}
1100
1101/*
1102 * Do the recurring log file and smb.conf reload checks.
1103 */
1104
1105static bool housekeeping_fn(const struct timeval *now, void *private_data)
1106{
1107 change_to_root_user();
1108
1109 /* update printer queue caches if necessary */
1110 update_monitored_printq_cache();
1111
1112 /* check if we need to reload services */
1113 check_reload(time(NULL));
1114
1115 /* Change machine password if neccessary. */
1116 attempt_machine_password_change();
1117
1118 /*
1119 * Force a log file check.
1120 */
1121 force_check_log_size();
1122 check_log_size();
1123 return true;
1124}
1125
1126/****************************************************************************
1127 main program.
1128****************************************************************************/
1129
1130/* Declare prototype for build_options() to avoid having to run it through
1131 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
1132 prototype generation system is too complicated. */
1133
1134extern void build_options(bool screen);
1135
1136 int main(int argc,const char *argv[])
1137{
1138 /* shall I run as a daemon */
1139 static bool is_daemon = False;
1140 static bool interactive = False;
1141 static bool Fork = True;
1142 static bool no_process_group = False;
1143 static bool log_stdout = False;
1144 static char *ports = NULL;
1145 static char *profile_level = NULL;
1146 int opt;
1147 poptContext pc;
1148 bool print_build_options = False;
1149 enum {
1150 OPT_DAEMON = 1000,
1151 OPT_INTERACTIVE,
1152 OPT_FORK,
1153 OPT_NO_PROCESS_GROUP,
1154 OPT_LOG_STDOUT
1155 };
1156 struct poptOption long_options[] = {
1157 POPT_AUTOHELP
1158 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
1159 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
1160 {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
1161 {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
1162 {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
1163 {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
1164 {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
1165 {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
1166 POPT_COMMON_SAMBA
1167 POPT_COMMON_DYNCONFIG
1168 POPT_TABLEEND
1169 };
1170 TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
1171
1172 TimeInit();
1173
1174#ifdef HAVE_SET_AUTH_PARAMETERS
1175 set_auth_parameters(argc,argv);
1176#endif
1177
1178 pc = poptGetContext("smbd", argc, argv, long_options, 0);
1179 while((opt = poptGetNextOpt(pc)) != -1) {
1180 switch (opt) {
1181 case OPT_DAEMON:
1182 is_daemon = true;
1183 break;
1184 case OPT_INTERACTIVE:
1185 interactive = true;
1186 break;
1187 case OPT_FORK:
1188 Fork = false;
1189 break;
1190 case OPT_NO_PROCESS_GROUP:
1191 no_process_group = true;
1192 break;
1193 case OPT_LOG_STDOUT:
1194 log_stdout = true;
1195 break;
1196 case 'b':
1197 print_build_options = True;
1198 break;
1199 default:
1200 d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1201 poptBadOption(pc, 0), poptStrerror(opt));
1202 poptPrintUsage(pc, stderr, 0);
1203 exit(1);
1204 }
1205 }
1206 poptFreeContext(pc);
1207
1208 if (interactive) {
1209 Fork = False;
1210 log_stdout = True;
1211 }
1212
1213 setup_logging(argv[0],log_stdout);
1214
1215 if (print_build_options) {
1216 build_options(True); /* Display output to screen as well as debug */
1217 exit(0);
1218 }
1219
1220 load_case_tables();
1221
1222#ifdef HAVE_SETLUID
1223 /* needed for SecureWare on SCO */
1224 setluid(0);
1225#endif
1226
1227 sec_init();
1228
1229 set_remote_machine_name("smbd", False);
1230
1231 if (interactive && (DEBUGLEVEL >= 9)) {
1232 talloc_enable_leak_report();
1233 }
1234
1235 if (log_stdout && Fork) {
1236 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1237 exit(1);
1238 }
1239
1240 /* we want to re-seed early to prevent time delays causing
1241 client problems at a later date. (tridge) */
1242 generate_random_buffer(NULL, 0);
1243
1244 /* make absolutely sure we run as root - to handle cases where people
1245 are crazy enough to have it setuid */
1246
1247 gain_root_privilege();
1248 gain_root_group_privilege();
1249
1250 /*
1251 * Ensure we have CAP_KILL capability set on Linux,
1252 * where we need this to communicate with threads.
1253 * This is inherited by new threads, but not by new
1254 * processes across exec().
1255 */
1256 set_effective_capability(KILL_CAPABILITY);
1257
1258 fault_setup((void (*)(void *))exit_server_fault);
1259 dump_core_setup("smbd");
1260
1261 CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
1262 CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
1263
1264 /* we are never interested in SIGPIPE */
1265 BlockSignals(True,SIGPIPE);
1266
1267#if defined(SIGFPE)
1268 /* we are never interested in SIGFPE */
1269 BlockSignals(True,SIGFPE);
1270#endif
1271
1272#if defined(SIGUSR2)
1273 /* We are no longer interested in USR2 */
1274 BlockSignals(True,SIGUSR2);
1275#endif
1276
1277 /* POSIX demands that signals are inherited. If the invoking process has
1278 * these signals masked, we will have problems, as we won't recieve them. */
1279 BlockSignals(False, SIGHUP);
1280 BlockSignals(False, SIGUSR1);
1281 BlockSignals(False, SIGTERM);
1282
1283 /* Ensure we leave no zombies until we
1284 * correctly set up child handling below. */
1285 CatchChild();
1286
1287 /* we want total control over the permissions on created files,
1288 so set our umask to 0 */
1289 umask(0);
1290
1291 init_sec_ctx();
1292
1293 reopen_logs();
1294
1295#ifdef __OS2__
1296 unsigned long _System DosSetPriority (unsigned long ulScope, unsigned long ulClass, long lDelta, unsigned long ulID);
1297 int rc;
1298 rc = DosSetPriority(
1299 0, /* Scope: only one process */
1300 4, /* set to PRTYC_FOREGROUNDSERVER */
1301 0, /* set delta - was 0 */
1302 0); /* Assume current process */
1303 DEBUG(0,( "Server priority set to PRTYC_FOREGROUNDSERVER\n"));
1304#endif
1305
1306 DEBUG(0,("smbd version %s started.\n", SAMBA_VERSION_STRING));
1307 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1308
1309 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1310 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1311
1312 /* Output the build options to the debug log */
1313 build_options(False);
1314
1315 if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1316 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1317 exit(1);
1318 }
1319
1320 if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1321 DEBUG(0, ("error opening config file\n"));
1322 exit(1);
1323 }
1324
1325 if (smbd_messaging_context() == NULL)
1326 exit(1);
1327
1328 if (!reload_services(False))
1329 return(-1);
1330
1331 init_structs();
1332
1333#ifdef WITH_PROFILE
1334 if (!profile_setup(smbd_messaging_context(), False)) {
1335 DEBUG(0,("ERROR: failed to setup profiling\n"));
1336 return -1;
1337 }
1338 if (profile_level != NULL) {
1339 int pl = atoi(profile_level);
1340 struct server_id src;
1341
1342 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1343 src.pid = getpid();
1344 set_profile_level(pl, src);
1345 }
1346#endif
1347
1348 DEBUG(3,( "loaded services\n"));
1349
1350 if (!is_daemon && !is_a_socket(0)) {
1351 if (!interactive)
1352 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1353
1354 /*
1355 * Setting is_daemon here prevents us from eventually calling
1356 * the open_sockets_inetd()
1357 */
1358
1359 is_daemon = True;
1360 }
1361
1362 if (is_daemon && !interactive) {
1363 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1364 become_daemon(Fork, no_process_group);
1365 }
1366
1367#if HAVE_SETPGID
1368 /*
1369 * If we're interactive we want to set our own process group for
1370 * signal management.
1371 */
1372 if (interactive && !no_process_group)
1373 setpgid( (pid_t)0, (pid_t)0);
1374#endif
1375
1376 if (!directory_exist(lp_lockdir(), NULL))
1377 mkdir(lp_lockdir(), 0755);
1378
1379 if (is_daemon)
1380 pidfile_create("smbd");
1381
1382 if (!reinit_after_fork(smbd_messaging_context(),
1383 smbd_event_context(), false)) {
1384 DEBUG(0,("reinit_after_fork() failed\n"));
1385 exit(1);
1386 }
1387
1388 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1389
1390 if (smbd_memcache() == NULL) {
1391 exit(1);
1392 }
1393
1394 memcache_set_global(smbd_memcache());
1395
1396 /* Initialise the password backed before the global_sam_sid
1397 to ensure that we fetch from ldap before we make a domain sid up */
1398
1399 if(!initialize_password_db(False, smbd_event_context()))
1400 exit(1);
1401
1402 if (!secrets_init()) {
1403 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1404 exit(1);
1405 }
1406
1407 if(!get_global_sam_sid()) {
1408 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1409 exit(1);
1410 }
1411
1412 if (!session_init())
1413 exit(1);
1414
1415 if (!connections_init(True))
1416 exit(1);
1417
1418 if (!locking_init())
1419 exit(1);
1420
1421 namecache_enable();
1422
1423 if (!W_ERROR_IS_OK(registry_init_full()))
1424 exit(1);
1425
1426#if 0
1427 if (!init_svcctl_db())
1428 exit(1);
1429#endif
1430
1431 if (!print_backend_init(smbd_messaging_context()))
1432 exit(1);
1433
1434 if (!init_guest_info()) {
1435 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1436 return -1;
1437 }
1438
1439 /* only start the background queue daemon if we are
1440 running as a daemon -- bad things will happen if
1441 smbd is launched via inetd and we fork a copy of
1442 ourselves here */
1443
1444 if (is_daemon && !interactive
1445 && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
1446 start_background_queue();
1447 }
1448
1449 if (!open_sockets_smbd(is_daemon, interactive, ports))
1450 exit(1);
1451
1452 /*
1453 * everything after this point is run after the fork()
1454 */
1455
1456 static_init_rpc;
1457
1458 init_modules();
1459
1460 /* Possibly reload the services file. Only worth doing in
1461 * daemon mode. In inetd mode, we know we only just loaded this.
1462 */
1463 if (is_daemon) {
1464 reload_services(True);
1465 }
1466
1467 if (!init_account_policy()) {
1468 DEBUG(0,("Could not open account policy tdb.\n"));
1469 exit(1);
1470 }
1471
1472 if (*lp_rootdir()) {
1473 if (sys_chroot(lp_rootdir()) != 0) {
1474 DEBUG(0,("Failed to change root to %s\n", lp_rootdir()));
1475 exit(1);
1476 }
1477 if (chdir("/") == -1) {
1478 DEBUG(0,("Failed to chdir to / on chroot to %s\n", lp_rootdir()));
1479 exit(1);
1480 }
1481 DEBUG(0,("Changed root to %s\n", lp_rootdir()));
1482 }
1483
1484 /* Setup oplocks */
1485 if (!init_oplocks(smbd_messaging_context()))
1486 exit(1);
1487
1488 /* Setup aio signal handler. */
1489 initialize_async_io_handler();
1490
1491 /* register our message handlers */
1492 messaging_register(smbd_messaging_context(), NULL,
1493 MSG_SMB_FORCE_TDIS, msg_force_tdis);
1494 messaging_register(smbd_messaging_context(), NULL,
1495 MSG_SMB_RELEASE_IP, msg_release_ip);
1496 messaging_register(smbd_messaging_context(), NULL,
1497 MSG_SMB_CLOSE_FILE, msg_close_file);
1498
1499 if ((lp_keepalive() != 0)
1500 && !(event_add_idle(smbd_event_context(), NULL,
1501 timeval_set(lp_keepalive(), 0),
1502 "keepalive", keepalive_fn,
1503 NULL))) {
1504 DEBUG(0, ("Could not add keepalive event\n"));
1505 exit(1);
1506 }
1507
1508 if (!(event_add_idle(smbd_event_context(), NULL,
1509 timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1510 "deadtime", deadtime_fn, NULL))) {
1511 DEBUG(0, ("Could not add deadtime event\n"));
1512 exit(1);
1513 }
1514
1515 if (!(event_add_idle(smbd_event_context(), NULL,
1516 timeval_set(SMBD_SELECT_TIMEOUT, 0),
1517 "housekeeping", housekeeping_fn, NULL))) {
1518 DEBUG(0, ("Could not add housekeeping event\n"));
1519 exit(1);
1520 }
1521
1522#ifdef CLUSTER_SUPPORT
1523
1524 if (lp_clustering()) {
1525 /*
1526 * We need to tell ctdb about our client's TCP
1527 * connection, so that for failover ctdbd can send
1528 * tickle acks, triggering a reconnection by the
1529 * client.
1530 */
1531
1532 struct sockaddr_storage srv, clnt;
1533
1534 if (client_get_tcp_info(&srv, &clnt) == 0) {
1535
1536 NTSTATUS status;
1537
1538 status = ctdbd_register_ips(
1539 messaging_ctdbd_connection(),
1540 &srv, &clnt, release_ip, NULL);
1541
1542 if (!NT_STATUS_IS_OK(status)) {
1543 DEBUG(0, ("ctdbd_register_ips failed: %s\n",
1544 nt_errstr(status)));
1545 }
1546 } else
1547 {
1548 DEBUG(0,("Unable to get tcp info for "
1549 "CTDB_CONTROL_TCP_CLIENT: %s\n",
1550 strerror(errno)));
1551 }
1552 }
1553
1554#endif
1555
1556 TALLOC_FREE(frame);
1557
1558 smbd_process();
1559
1560 namecache_shutdown();
1561
1562 exit_server_cleanly(NULL);
1563 return(0);
1564}
Note: See TracBrowser for help on using the repository browser.