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

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

Update 3.3 to 3.3.7
File size: 38.8 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 event_add_to_select_args(smbd_event_context(), &now,
656 &r_fds, &w_fds, &idle_timeout,
657 &maxfd);
658
659 num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
660 timeval_is_zero(&idle_timeout) ?
661 NULL : &idle_timeout);
662
663 if (num == -1 && errno == EINTR) {
664 if (got_sig_term) {
665 exit_server_cleanly(NULL);
666 }
667
668 /* check for sighup processing */
669 if (reload_after_sighup) {
670 change_to_root_user();
671 DEBUG(1,("Reloading services after SIGHUP\n"));
672 reload_services(False);
673 reload_after_sighup = 0;
674 }
675
676 continue;
677 }
678
679
680 /* If the idle timeout fired and we don't have any connected
681 * users, exit gracefully. We should be running under a process
682 * controller that will restart us if necessry.
683 */
684 if (num == 0 && count_all_current_connections() == 0) {
685 exit_server_cleanly("idle timeout");
686 }
687
688 /* process pending nDNS responses */
689 if (dns_register_smbd_reply(dns_reg, &r_fds, &idle_timeout)) {
690 --num;
691 }
692
693 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
694 continue;
695 }
696
697 /* check if we need to reload services */
698 check_reload(time(NULL));
699
700 /* Find the sockets that are read-ready -
701 accept on these. */
702 for( ; num > 0; num--) {
703 struct sockaddr addr;
704 socklen_t in_addrlen = sizeof(addr);
705 pid_t child = 0;
706
707 s = -1;
708 for(i = 0; i < num_sockets; i++) {
709 if(FD_ISSET(fd_listenset[i],&r_fds)) {
710 s = fd_listenset[i];
711 /* Clear this so we don't look
712 at it again. */
713 FD_CLR(fd_listenset[i],&r_fds);
714 break;
715 }
716 }
717
718 smbd_set_server_fd(accept(s,&addr,&in_addrlen));
719
720 if (smbd_server_fd() == -1 && errno == EINTR)
721 continue;
722
723 if (smbd_server_fd() == -1) {
724 DEBUG(2,("open_sockets_smbd: accept: %s\n",
725 strerror(errno)));
726 continue;
727 }
728
729 /* Ensure child is set to blocking mode */
730 set_blocking(smbd_server_fd(),True);
731
732 if (smbd_server_fd() != -1 && interactive)
733 return True;
734
735 if (allowable_number_of_smbd_processes() &&
736 smbd_server_fd() != -1 &&
737 ((child = sys_fork())==0)) {
738 char remaddr[INET6_ADDRSTRLEN];
739
740 /* Child code ... */
741
742 /* Stop zombies, the parent explicitly handles
743 * them, counting worker smbds. */
744 CatchChild();
745
746 /* close the listening socket(s) */
747 for(i = 0; i < num_sockets; i++)
748 close(fd_listenset[i]);
749
750 /* close our mDNS daemon handle */
751 dns_register_close(&dns_reg);
752
753 /* close our standard file
754 descriptors */
755 close_low_fds(False);
756 am_parent = 0;
757
758 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
759 set_socket_options(smbd_server_fd(),
760 lp_socket_options());
761
762 /* this is needed so that we get decent entries
763 in smbstatus for port 445 connects */
764 set_remote_machine_name(get_peer_addr(smbd_server_fd(),
765 remaddr,
766 sizeof(remaddr)),
767 false);
768
769 if (!reinit_after_fork(
770 smbd_messaging_context(),
771 smbd_event_context(),
772 true)) {
773 DEBUG(0,("reinit_after_fork() failed\n"));
774 smb_panic("reinit_after_fork() failed");
775 }
776
777 return True;
778 }
779 /* The parent doesn't need this socket */
780 close(smbd_server_fd());
781
782 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
783 Clear the closed fd info out of server_fd --
784 and more importantly, out of client_fd in
785 util_sock.c, to avoid a possible
786 getpeername failure if we reopen the logs
787 and use %I in the filename.
788 */
789
790 smbd_set_server_fd(-1);
791
792 if (child != 0) {
793 add_child_pid(child);
794 }
795
796 /* Force parent to check log size after
797 * spawning child. Fix from
798 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
799 * parent smbd will log to logserver.smb. It
800 * writes only two messages for each child
801 * started/finished. But each child writes,
802 * say, 50 messages also in logserver.smb,
803 * begining with the debug_count of the
804 * parent, before the child opens its own log
805 * file logserver.client. In a worst case
806 * scenario the size of logserver.smb would be
807 * checked after about 50*50=2500 messages
808 * (ca. 100kb).
809 * */
810 force_check_log_size();
811
812 } /* end for num */
813 } /* end while 1 */
814
815/* NOTREACHED return True; */
816}
817
818/****************************************************************************
819 Reload printers
820**************************************************************************/
821void reload_printers(void)
822{
823 int snum;
824 int n_services = lp_numservices();
825 int pnum = lp_servicenumber(PRINTERS_NAME);
826 const char *pname;
827
828 pcap_cache_reload();
829
830 /* remove stale printers */
831 for (snum = 0; snum < n_services; snum++) {
832 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
833 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
834 lp_autoloaded(snum)))
835 continue;
836
837 pname = lp_printername(snum);
838 if (!pcap_printername_ok(pname)) {
839 DEBUG(3, ("removing stale printer %s\n", pname));
840
841 if (is_printer_published(NULL, snum, NULL))
842 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
843 del_a_printer(pname);
844 lp_killservice(snum);
845 }
846 }
847
848 load_printers();
849}
850
851/****************************************************************************
852 Reload the services file.
853**************************************************************************/
854
855bool reload_services(bool test)
856{
857 bool ret;
858
859 if (lp_loaded()) {
860 char *fname = lp_configfile();
861 if (file_exist(fname, NULL) &&
862 !strcsequal(fname, get_dyn_CONFIGFILE())) {
863 set_dyn_CONFIGFILE(fname);
864 test = False;
865 }
866 }
867
868 reopen_logs();
869
870 if (test && !lp_file_list_changed())
871 return(True);
872
873 lp_killunused(conn_snum_used);
874
875 ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
876
877 reload_printers();
878
879 /* perhaps the config filename is now set */
880 if (!test)
881 reload_services(True);
882
883 reopen_logs();
884
885 load_interfaces();
886
887 if (smbd_server_fd() != -1) {
888 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
889 set_socket_options(smbd_server_fd(), lp_socket_options());
890 }
891
892 mangle_reset_cache();
893 reset_stat_cache();
894
895 /* this forces service parameters to be flushed */
896 set_current_service(NULL,0,True);
897
898 return(ret);
899}
900
901/****************************************************************************
902 Exit the server.
903****************************************************************************/
904
905/* Reasons for shutting down a server process. */
906enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
907
908static void exit_server_common(enum server_exit_reason how,
909 const char *const reason) NORETURN_ATTRIBUTE;
910
911static void exit_server_common(enum server_exit_reason how,
912 const char *const reason)
913{
914 static int firsttime=1;
915 bool had_open_conn;
916
917 if (!firsttime)
918 exit(0);
919 firsttime = 0;
920
921 change_to_root_user();
922
923 if (negprot_global_auth_context) {
924 (negprot_global_auth_context->free)(&negprot_global_auth_context);
925 }
926
927 had_open_conn = conn_close_all();
928
929 invalidate_all_vuids();
930
931 /* 3 second timeout. */
932 print_notify_send_messages(smbd_messaging_context(), 3);
933
934 /* delete our entry in the connections database. */
935 yield_connection(NULL,"");
936
937 respond_to_all_remaining_local_messages();
938
939#ifdef WITH_DFS
940 if (dcelogin_atmost_once) {
941 dfs_unlogin();
942 }
943#endif
944
945#ifdef USE_DMAPI
946 /* Destroy Samba DMAPI session only if we are master smbd process */
947 if (am_parent) {
948 if (!dmapi_destroy_session()) {
949 DEBUG(0,("Unable to close Samba DMAPI session\n"));
950 }
951 }
952#endif
953
954 locking_end();
955 printing_end();
956
957#ifdef __OS2__
958 /* On OS/2 - we need to remove the PID file on server exit otherwise we may not be able to restart Samba */
959 char pidFile[1024];
960 slprintf(pidFile, sizeof(pidFile)-1, "%s/%s.pid", lp_piddir(), "smbd");
961 unlink(pidFile);
962#endif
963
964 if (how != SERVER_EXIT_NORMAL) {
965 int oldlevel = DEBUGLEVEL;
966
967 DEBUGLEVEL = 10;
968
969 DEBUGSEP(0);
970 DEBUG(0,("Abnormal server exit: %s\n",
971 reason ? reason : "no explanation provided"));
972 DEBUGSEP(0);
973
974 log_stack_trace();
975
976 DEBUGLEVEL = oldlevel;
977 dump_core();
978
979 } else {
980 DEBUG(3,("Server exit (%s)\n",
981 (reason ? reason : "normal exit")));
982 }
983
984 /* if we had any open SMB connections when we exited then we
985 need to tell the parent smbd so that it can trigger a retry
986 of any locks we may have been holding or open files we were
987 blocking */
988 if (had_open_conn) {
989 exit(1);
990 } else {
991 exit(0);
992 }
993}
994
995void exit_server(const char *const explanation)
996{
997 exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
998}
999
1000void exit_server_cleanly(const char *const explanation)
1001{
1002 exit_server_common(SERVER_EXIT_NORMAL, explanation);
1003}
1004
1005void exit_server_fault(void)
1006{
1007 exit_server("critical server fault");
1008}
1009
1010
1011/****************************************************************************
1012received when we should release a specific IP
1013****************************************************************************/
1014static void release_ip(const char *ip, void *priv)
1015{
1016 char addr[INET6_ADDRSTRLEN];
1017
1018 if (strcmp(client_socket_addr(get_client_fd(),addr,sizeof(addr)), ip) == 0) {
1019 /* we can't afford to do a clean exit - that involves
1020 database writes, which would potentially mean we
1021 are still running after the failover has finished -
1022 we have to get rid of this process ID straight
1023 away */
1024 DEBUG(0,("Got release IP message for our IP %s - exiting immediately\n",
1025 ip));
1026 /* note we must exit with non-zero status so the unclean handler gets
1027 called in the parent, so that the brl database is tickled */
1028 _exit(1);
1029 }
1030}
1031
1032static void msg_release_ip(struct messaging_context *msg_ctx, void *private_data,
1033 uint32_t msg_type, struct server_id server_id, DATA_BLOB *data)
1034{
1035 release_ip((char *)data->data, NULL);
1036}
1037
1038/****************************************************************************
1039 Initialise connect, service and file structs.
1040****************************************************************************/
1041
1042static bool init_structs(void )
1043{
1044 /*
1045 * Set the machine NETBIOS name if not already
1046 * set from the config file.
1047 */
1048
1049 if (!init_names())
1050 return False;
1051
1052 conn_init();
1053
1054 file_init();
1055
1056 /* for RPC pipes */
1057 init_rpc_pipe_hnd();
1058
1059 init_dptrs();
1060
1061 if (!secrets_init())
1062 return False;
1063
1064 return True;
1065}
1066
1067/*
1068 * Send keepalive packets to our client
1069 */
1070static bool keepalive_fn(const struct timeval *now, void *private_data)
1071{
1072 if (!send_keepalive(smbd_server_fd())) {
1073 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
1074 return False;
1075 }
1076 return True;
1077}
1078
1079/*
1080 * Do the recurring check if we're idle
1081 */
1082static bool deadtime_fn(const struct timeval *now, void *private_data)
1083{
1084 if ((conn_num_open() == 0)
1085 || (conn_idle_all(now->tv_sec))) {
1086 DEBUG( 2, ( "Closing idle connection\n" ) );
1087 messaging_send(smbd_messaging_context(), procid_self(),
1088 MSG_SHUTDOWN, &data_blob_null);
1089 return False;
1090 }
1091
1092 return True;
1093}
1094
1095/*
1096 * Do the recurring log file and smb.conf reload checks.
1097 */
1098
1099static bool housekeeping_fn(const struct timeval *now, void *private_data)
1100{
1101 change_to_root_user();
1102
1103 /* update printer queue caches if necessary */
1104 update_monitored_printq_cache();
1105
1106 /* check if we need to reload services */
1107 check_reload(time(NULL));
1108
1109 /* Change machine password if neccessary. */
1110 attempt_machine_password_change();
1111
1112 /*
1113 * Force a log file check.
1114 */
1115 force_check_log_size();
1116 check_log_size();
1117 return true;
1118}
1119
1120/****************************************************************************
1121 main program.
1122****************************************************************************/
1123
1124/* Declare prototype for build_options() to avoid having to run it through
1125 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
1126 prototype generation system is too complicated. */
1127
1128extern void build_options(bool screen);
1129
1130 int main(int argc,const char *argv[])
1131{
1132 /* shall I run as a daemon */
1133 static bool is_daemon = False;
1134 static bool interactive = False;
1135 static bool Fork = True;
1136 static bool no_process_group = False;
1137 static bool log_stdout = False;
1138 static char *ports = NULL;
1139 static char *profile_level = NULL;
1140 int opt;
1141 poptContext pc;
1142 bool print_build_options = False;
1143 enum {
1144 OPT_DAEMON = 1000,
1145 OPT_INTERACTIVE,
1146 OPT_FORK,
1147 OPT_NO_PROCESS_GROUP,
1148 OPT_LOG_STDOUT
1149 };
1150 struct poptOption long_options[] = {
1151 POPT_AUTOHELP
1152 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
1153 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
1154 {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
1155 {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
1156 {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
1157 {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
1158 {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
1159 {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
1160 POPT_COMMON_SAMBA
1161 POPT_COMMON_DYNCONFIG
1162 POPT_TABLEEND
1163 };
1164 TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
1165
1166 TimeInit();
1167
1168#ifdef HAVE_SET_AUTH_PARAMETERS
1169 set_auth_parameters(argc,argv);
1170#endif
1171
1172 pc = poptGetContext("smbd", argc, argv, long_options, 0);
1173 while((opt = poptGetNextOpt(pc)) != -1) {
1174 switch (opt) {
1175 case OPT_DAEMON:
1176 is_daemon = true;
1177 break;
1178 case OPT_INTERACTIVE:
1179 interactive = true;
1180 break;
1181 case OPT_FORK:
1182 Fork = false;
1183 break;
1184 case OPT_NO_PROCESS_GROUP:
1185 no_process_group = true;
1186 break;
1187 case OPT_LOG_STDOUT:
1188 log_stdout = true;
1189 break;
1190 case 'b':
1191 print_build_options = True;
1192 break;
1193 default:
1194 d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1195 poptBadOption(pc, 0), poptStrerror(opt));
1196 poptPrintUsage(pc, stderr, 0);
1197 exit(1);
1198 }
1199 }
1200 poptFreeContext(pc);
1201
1202 if (interactive) {
1203 Fork = False;
1204 log_stdout = True;
1205 }
1206
1207 setup_logging(argv[0],log_stdout);
1208
1209 if (print_build_options) {
1210 build_options(True); /* Display output to screen as well as debug */
1211 exit(0);
1212 }
1213
1214 load_case_tables();
1215
1216#ifdef HAVE_SETLUID
1217 /* needed for SecureWare on SCO */
1218 setluid(0);
1219#endif
1220
1221 sec_init();
1222
1223 set_remote_machine_name("smbd", False);
1224
1225 if (interactive && (DEBUGLEVEL >= 9)) {
1226 talloc_enable_leak_report();
1227 }
1228
1229 if (log_stdout && Fork) {
1230 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1231 exit(1);
1232 }
1233
1234 /* we want to re-seed early to prevent time delays causing
1235 client problems at a later date. (tridge) */
1236 generate_random_buffer(NULL, 0);
1237
1238 /* make absolutely sure we run as root - to handle cases where people
1239 are crazy enough to have it setuid */
1240
1241 gain_root_privilege();
1242 gain_root_group_privilege();
1243
1244 fault_setup((void (*)(void *))exit_server_fault);
1245 dump_core_setup("smbd");
1246
1247 CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
1248 CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
1249
1250 /* we are never interested in SIGPIPE */
1251 BlockSignals(True,SIGPIPE);
1252
1253#if defined(SIGFPE)
1254 /* we are never interested in SIGFPE */
1255 BlockSignals(True,SIGFPE);
1256#endif
1257
1258#if defined(SIGUSR2)
1259 /* We are no longer interested in USR2 */
1260 BlockSignals(True,SIGUSR2);
1261#endif
1262
1263 /* POSIX demands that signals are inherited. If the invoking process has
1264 * these signals masked, we will have problems, as we won't recieve them. */
1265 BlockSignals(False, SIGHUP);
1266 BlockSignals(False, SIGUSR1);
1267 BlockSignals(False, SIGTERM);
1268
1269 /* Ensure we leave no zombies until we
1270 * correctly set up child handling below. */
1271 CatchChild();
1272
1273 /* we want total control over the permissions on created files,
1274 so set our umask to 0 */
1275 umask(0);
1276
1277 init_sec_ctx();
1278
1279 reopen_logs();
1280
1281#ifdef __OS2__
1282 unsigned long _System DosSetPriority (unsigned long ulScope, unsigned long ulClass, long lDelta, unsigned long ulID);
1283 int rc;
1284 rc = DosSetPriority(
1285 0, /* Scope: only one process */
1286 4, /* set to PRTYC_FOREGROUNDSERVER */
1287 0, /* set delta - was 0 */
1288 0); /* Assume current process */
1289 DEBUG(0,( "Server priority set to PRTYC_FOREGROUNDSERVER\n"));
1290#endif
1291
1292 DEBUG(0,("smbd version %s started.\n", SAMBA_VERSION_STRING));
1293 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1294
1295 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1296 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1297
1298 /* Output the build options to the debug log */
1299 build_options(False);
1300
1301 if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1302 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1303 exit(1);
1304 }
1305
1306 if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1307 DEBUG(0, ("error opening config file\n"));
1308 exit(1);
1309 }
1310
1311 if (smbd_messaging_context() == NULL)
1312 exit(1);
1313
1314 if (!reload_services(False))
1315 return(-1);
1316
1317 init_structs();
1318
1319#ifdef WITH_PROFILE
1320 if (!profile_setup(smbd_messaging_context(), False)) {
1321 DEBUG(0,("ERROR: failed to setup profiling\n"));
1322 return -1;
1323 }
1324 if (profile_level != NULL) {
1325 int pl = atoi(profile_level);
1326 struct server_id src;
1327
1328 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1329 src.pid = getpid();
1330 set_profile_level(pl, src);
1331 }
1332#endif
1333
1334 DEBUG(3,( "loaded services\n"));
1335
1336 if (!is_daemon && !is_a_socket(0)) {
1337 if (!interactive)
1338 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1339
1340 /*
1341 * Setting is_daemon here prevents us from eventually calling
1342 * the open_sockets_inetd()
1343 */
1344
1345 is_daemon = True;
1346 }
1347
1348 if (is_daemon && !interactive) {
1349 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1350 become_daemon(Fork, no_process_group);
1351 }
1352
1353#if HAVE_SETPGID
1354 /*
1355 * If we're interactive we want to set our own process group for
1356 * signal management.
1357 */
1358 if (interactive && !no_process_group)
1359 setpgid( (pid_t)0, (pid_t)0);
1360#endif
1361
1362 if (!directory_exist(lp_lockdir(), NULL))
1363 mkdir(lp_lockdir(), 0755);
1364
1365 if (is_daemon)
1366 pidfile_create("smbd");
1367
1368 if (!reinit_after_fork(smbd_messaging_context(),
1369 smbd_event_context(), false)) {
1370 DEBUG(0,("reinit_after_fork() failed\n"));
1371 exit(1);
1372 }
1373
1374 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1375
1376 if (smbd_memcache() == NULL) {
1377 exit(1);
1378 }
1379
1380 memcache_set_global(smbd_memcache());
1381
1382 /* Initialise the password backed before the global_sam_sid
1383 to ensure that we fetch from ldap before we make a domain sid up */
1384
1385 if(!initialize_password_db(False, smbd_event_context()))
1386 exit(1);
1387
1388 if (!secrets_init()) {
1389 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1390 exit(1);
1391 }
1392
1393 if(!get_global_sam_sid()) {
1394 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1395 exit(1);
1396 }
1397
1398 if (!session_init())
1399 exit(1);
1400
1401 if (!connections_init(True))
1402 exit(1);
1403
1404 if (!locking_init())
1405 exit(1);
1406
1407 namecache_enable();
1408
1409 if (!W_ERROR_IS_OK(registry_init_full()))
1410 exit(1);
1411
1412#if 0
1413 if (!init_svcctl_db())
1414 exit(1);
1415#endif
1416
1417 if (!print_backend_init(smbd_messaging_context()))
1418 exit(1);
1419
1420 if (!init_guest_info()) {
1421 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1422 return -1;
1423 }
1424
1425 /* only start the background queue daemon if we are
1426 running as a daemon -- bad things will happen if
1427 smbd is launched via inetd and we fork a copy of
1428 ourselves here */
1429
1430 if (is_daemon && !interactive
1431 && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
1432 start_background_queue();
1433 }
1434
1435 if (!open_sockets_smbd(is_daemon, interactive, ports))
1436 exit(1);
1437
1438 /*
1439 * everything after this point is run after the fork()
1440 */
1441
1442 static_init_rpc;
1443
1444 init_modules();
1445
1446 /* Possibly reload the services file. Only worth doing in
1447 * daemon mode. In inetd mode, we know we only just loaded this.
1448 */
1449 if (is_daemon) {
1450 reload_services(True);
1451 }
1452
1453 if (!init_account_policy()) {
1454 DEBUG(0,("Could not open account policy tdb.\n"));
1455 exit(1);
1456 }
1457
1458 if (*lp_rootdir()) {
1459 if (sys_chroot(lp_rootdir()) != 0) {
1460 DEBUG(0,("Failed to change root to %s\n", lp_rootdir()));
1461 exit(1);
1462 }
1463 if (chdir("/") == -1) {
1464 DEBUG(0,("Failed to chdir to / on chroot to %s\n", lp_rootdir()));
1465 exit(1);
1466 }
1467 DEBUG(0,("Changed root to %s\n", lp_rootdir()));
1468 }
1469
1470 /* Setup oplocks */
1471 if (!init_oplocks(smbd_messaging_context()))
1472 exit(1);
1473
1474 /* Setup aio signal handler. */
1475 initialize_async_io_handler();
1476
1477 /* register our message handlers */
1478 messaging_register(smbd_messaging_context(), NULL,
1479 MSG_SMB_FORCE_TDIS, msg_force_tdis);
1480 messaging_register(smbd_messaging_context(), NULL,
1481 MSG_SMB_RELEASE_IP, msg_release_ip);
1482 messaging_register(smbd_messaging_context(), NULL,
1483 MSG_SMB_CLOSE_FILE, msg_close_file);
1484
1485 if ((lp_keepalive() != 0)
1486 && !(event_add_idle(smbd_event_context(), NULL,
1487 timeval_set(lp_keepalive(), 0),
1488 "keepalive", keepalive_fn,
1489 NULL))) {
1490 DEBUG(0, ("Could not add keepalive event\n"));
1491 exit(1);
1492 }
1493
1494 if (!(event_add_idle(smbd_event_context(), NULL,
1495 timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1496 "deadtime", deadtime_fn, NULL))) {
1497 DEBUG(0, ("Could not add deadtime event\n"));
1498 exit(1);
1499 }
1500
1501 if (!(event_add_idle(smbd_event_context(), NULL,
1502 timeval_set(SMBD_SELECT_TIMEOUT, 0),
1503 "housekeeping", housekeeping_fn, NULL))) {
1504 DEBUG(0, ("Could not add housekeeping event\n"));
1505 exit(1);
1506 }
1507
1508#ifdef CLUSTER_SUPPORT
1509
1510 if (lp_clustering()) {
1511 /*
1512 * We need to tell ctdb about our client's TCP
1513 * connection, so that for failover ctdbd can send
1514 * tickle acks, triggering a reconnection by the
1515 * client.
1516 */
1517
1518 struct sockaddr_storage srv, clnt;
1519
1520 if (client_get_tcp_info(&srv, &clnt) == 0) {
1521
1522 NTSTATUS status;
1523
1524 status = ctdbd_register_ips(
1525 messaging_ctdbd_connection(),
1526 &srv, &clnt, release_ip, NULL);
1527
1528 if (!NT_STATUS_IS_OK(status)) {
1529 DEBUG(0, ("ctdbd_register_ips failed: %s\n",
1530 nt_errstr(status)));
1531 }
1532 } else
1533 {
1534 DEBUG(0,("Unable to get tcp info for "
1535 "CTDB_CONTROL_TCP_CLIENT: %s\n",
1536 strerror(errno)));
1537 }
1538 }
1539
1540#endif
1541
1542 TALLOC_FREE(frame);
1543
1544 smbd_process();
1545
1546 namecache_shutdown();
1547
1548 exit_server_cleanly(NULL);
1549 return(0);
1550}
Note: See TracBrowser for help on using the repository browser.