e47187a6975bb0c43b8ea1adfe4c6acf9af03aef
[samba.git] / source3 / smbd / server.c
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 #include "system/filesys.h"
26 #include "popt_common.h"
27 #include "smbd/smbd.h"
28 #include "smbd/globals.h"
29 #include "registry/reg_init_full.h"
30 #include "libcli/auth/schannel.h"
31 #include "secrets.h"
32 #include "memcache.h"
33 #include "ctdbd_conn.h"
34 #include "printing/queue_process.h"
35 #include "rpc_server/rpc_service_setup.h"
36 #include "rpc_server/rpc_config.h"
37 #include "serverid.h"
38 #include "passdb.h"
39 #include "auth.h"
40 #include "messages.h"
41 #include "smbprofile.h"
42 #include "lib/id_cache.h"
43
44 extern void start_epmd(struct tevent_context *ev_ctx,
45                        struct messaging_context *msg_ctx);
46
47 extern void start_lsasd(struct event_context *ev_ctx,
48                         struct messaging_context *msg_ctx);
49
50 #ifdef WITH_DFS
51 extern int dcelogin_atmost_once;
52 #endif /* WITH_DFS */
53
54 /*******************************************************************
55  What to do when smb.conf is updated.
56  ********************************************************************/
57
58 static void smb_conf_updated(struct messaging_context *msg,
59                              void *private_data,
60                              uint32_t msg_type,
61                              struct server_id server_id,
62                              DATA_BLOB *data)
63 {
64         struct tevent_context *ev_ctx =
65                 talloc_get_type_abort(private_data, struct tevent_context);
66         struct smbd_server_connection *sconn = msg_ctx_to_sconn(msg);
67
68         DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
69                   "updated. Reloading.\n"));
70         change_to_root_user();
71         reload_services(msg, sconn->sock, False);
72         if (am_parent) {
73                 printing_subsystem_update(ev_ctx, msg, false);
74         }
75 }
76
77 /*******************************************************************
78  What to do when printcap is updated.
79  ********************************************************************/
80
81 static void smb_pcap_updated(struct messaging_context *msg,
82                              void *private_data,
83                              uint32_t msg_type,
84                              struct server_id server_id,
85                              DATA_BLOB *data)
86 {
87         struct tevent_context *ev_ctx =
88                 talloc_get_type_abort(private_data, struct tevent_context);
89
90         DEBUG(10,("Got message saying pcap was updated. Reloading.\n"));
91         change_to_root_user();
92         delete_and_reload_printers(ev_ctx, msg);
93 }
94
95 /*******************************************************************
96  Delete a statcache entry.
97  ********************************************************************/
98
99 static void smb_stat_cache_delete(struct messaging_context *msg,
100                                   void *private_data,
101                                   uint32_t msg_tnype,
102                                   struct server_id server_id,
103                                   DATA_BLOB *data)
104 {
105         const char *name = (const char *)data->data;
106         DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
107         stat_cache_delete(name);
108 }
109
110 /****************************************************************************
111   Send a SIGTERM to our process group.
112 *****************************************************************************/
113
114 static void  killkids(void)
115 {
116         if(am_parent) kill(0,SIGTERM);
117 }
118
119 /****************************************************************************
120  Process a sam sync message - not sure whether to do this here or
121  somewhere else.
122 ****************************************************************************/
123
124 static void msg_sam_sync(struct messaging_context *msg,
125                          void *private_data,
126                          uint32_t msg_type,
127                          struct server_id server_id,
128                          DATA_BLOB *data)
129 {
130         DEBUG(10, ("** sam sync message received, ignoring\n"));
131 }
132
133 static void msg_exit_server(struct messaging_context *msg,
134                             void *private_data,
135                             uint32_t msg_type,
136                             struct server_id server_id,
137                             DATA_BLOB *data)
138 {
139         DEBUG(3, ("got a SHUTDOWN message\n"));
140         exit_server_cleanly(NULL);
141 }
142
143 #ifdef DEVELOPER
144 static void msg_inject_fault(struct messaging_context *msg,
145                              void *private_data,
146                              uint32_t msg_type,
147                              struct server_id src,
148                              DATA_BLOB *data)
149 {
150         int sig;
151
152         if (data->length != sizeof(sig)) {
153                 DEBUG(0, ("Process %s sent bogus signal injection request\n",
154                           procid_str_static(&src)));
155                 return;
156         }
157
158         sig = *(int *)data->data;
159         if (sig == -1) {
160                 exit_server("internal error injected");
161                 return;
162         }
163
164 #if HAVE_STRSIGNAL
165         DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
166                   procid_str_static(&src), sig, strsignal(sig)));
167 #else
168         DEBUG(0, ("Process %s requested injection of signal %d\n",
169                   procid_str_static(&src), sig));
170 #endif
171
172         kill(sys_getpid(), sig);
173 }
174 #endif /* DEVELOPER */
175
176 NTSTATUS messaging_send_to_children(struct messaging_context *msg_ctx,
177                                     uint32_t msg_type, DATA_BLOB* data)
178 {
179         NTSTATUS status;
180         struct child_pid *child;
181
182         for (child = children; child != NULL; child = child->next) {
183                 status = messaging_send(msg_ctx, pid_to_procid(child->pid),
184                                         msg_type, data);
185                 if (!NT_STATUS_IS_OK(status)) {
186                         return status;
187                 }
188         }
189         return NT_STATUS_OK;
190 }
191
192 /*
193  * Parent smbd process sets its own debug level first and then
194  * sends a message to all the smbd children to adjust their debug
195  * level to that of the parent.
196  */
197
198 static void smbd_msg_debug(struct messaging_context *msg_ctx,
199                            void *private_data,
200                            uint32_t msg_type,
201                            struct server_id server_id,
202                            DATA_BLOB *data)
203 {
204         debug_message(msg_ctx, private_data, MSG_DEBUG, server_id, data);
205
206         messaging_send_to_children(msg_ctx, MSG_DEBUG, data);
207 }
208
209 static void add_child_pid(pid_t pid)
210 {
211         struct child_pid *child;
212
213         child = SMB_MALLOC_P(struct child_pid);
214         if (child == NULL) {
215                 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
216                 return;
217         }
218         child->pid = pid;
219         DLIST_ADD(children, child);
220         num_children += 1;
221 }
222
223 /*
224   at most every smbd:cleanuptime seconds (default 20), we scan the BRL
225   and locking database for entries to cleanup. As a side effect this
226   also cleans up dead entries in the connections database (due to the
227   traversal in message_send_all()
228
229   Using a timer for this prevents a flood of traversals when a large
230   number of clients disconnect at the same time (perhaps due to a
231   network outage).  
232 */
233
234 static void cleanup_timeout_fn(struct event_context *event_ctx,
235                                 struct timed_event *te,
236                                 struct timeval now,
237                                 void *private_data)
238 {
239         struct timed_event **cleanup_te = (struct timed_event **)private_data;
240
241         DEBUG(1,("Cleaning up brl and lock database after unclean shutdown\n"));
242         message_send_all(smbd_messaging_context(), MSG_SMB_UNLOCK, NULL, 0, NULL);
243         messaging_send_buf(smbd_messaging_context(), procid_self(),
244                                 MSG_SMB_BRL_VALIDATE, NULL, 0);
245         /* mark the cleanup as having been done */
246         (*cleanup_te) = NULL;
247 }
248
249 static void remove_child_pid(struct tevent_context *ev_ctx,
250                              pid_t pid,
251                              bool unclean_shutdown)
252 {
253         struct child_pid *child;
254         static struct timed_event *cleanup_te;
255         struct server_id child_id;
256
257         if (unclean_shutdown) {
258                 /* a child terminated uncleanly so tickle all
259                    processes to see if they can grab any of the
260                    pending locks
261                 */
262                 DEBUG(3,(__location__ " Unclean shutdown of pid %u\n",
263                         (unsigned int)pid));
264                 if (!cleanup_te) {
265                         /* call the cleanup timer, but not too often */
266                         int cleanup_time = lp_parm_int(-1, "smbd", "cleanuptime", 20);
267                         cleanup_te = event_add_timed(ev_ctx, NULL,
268                                                 timeval_current_ofs(cleanup_time, 0),
269                                                 cleanup_timeout_fn,
270                                                 &cleanup_te);
271                         DEBUG(1,("Scheduled cleanup of brl and lock database after unclean shutdown\n"));
272                 }
273         }
274
275         child_id = procid_self(); /* Just initialize pid and potentially vnn */
276         child_id.pid = pid;
277
278         if (!serverid_deregister(child_id)) {
279                 DEBUG(1, ("Could not remove pid %d from serverid.tdb\n",
280                           (int)pid));
281         }
282
283         for (child = children; child != NULL; child = child->next) {
284                 if (child->pid == pid) {
285                         struct child_pid *tmp = child;
286                         DLIST_REMOVE(children, child);
287                         SAFE_FREE(tmp);
288                         num_children -= 1;
289                         return;
290                 }
291         }
292
293         /* not all forked child processes are added to the children list */
294         DEBUG(1, ("Could not find child %d -- ignoring\n", (int)pid));
295 }
296
297 /****************************************************************************
298  Have we reached the process limit ?
299 ****************************************************************************/
300
301 static bool allowable_number_of_smbd_processes(void)
302 {
303         int max_processes = lp_max_smbd_processes();
304
305         if (!max_processes)
306                 return True;
307
308         return num_children < max_processes;
309 }
310
311 static void smbd_sig_chld_handler(struct tevent_context *ev,
312                                   struct tevent_signal *se,
313                                   int signum,
314                                   int count,
315                                   void *siginfo,
316                                   void *private_data)
317 {
318         pid_t pid;
319         int status;
320
321         while ((pid = sys_waitpid(-1, &status, WNOHANG)) > 0) {
322                 bool unclean_shutdown = False;
323
324                 /* If the child terminated normally, assume
325                    it was an unclean shutdown unless the
326                    status is 0
327                 */
328                 if (WIFEXITED(status)) {
329                         unclean_shutdown = WEXITSTATUS(status);
330                 }
331                 /* If the child terminated due to a signal
332                    we always assume it was unclean.
333                 */
334                 if (WIFSIGNALED(status)) {
335                         unclean_shutdown = True;
336                 }
337                 remove_child_pid(ev, pid, unclean_shutdown);
338         }
339 }
340
341 static void smbd_setup_sig_chld_handler(struct tevent_context *ev_ctx)
342 {
343         struct tevent_signal *se;
344
345         se = tevent_add_signal(ev_ctx,
346                                ev_ctx, /* mem_ctx */
347                                SIGCHLD, 0,
348                                smbd_sig_chld_handler,
349                                NULL);
350         if (!se) {
351                 exit_server("failed to setup SIGCHLD handler");
352         }
353 }
354
355 struct smbd_open_socket;
356
357 struct smbd_parent_context {
358         bool interactive;
359
360         /* the list of listening sockets */
361         struct smbd_open_socket *sockets;
362 };
363
364 struct smbd_open_socket {
365         struct smbd_open_socket *prev, *next;
366         struct smbd_parent_context *parent;
367         int fd;
368         struct tevent_fd *fde;
369         struct messaging_context *msg_ctx;
370 };
371
372 static void smbd_open_socket_close_fn(struct tevent_context *ev,
373                                       struct tevent_fd *fde,
374                                       int fd,
375                                       void *private_data)
376 {
377         /* this might be the socket_wrapper swrap_close() */
378         close(fd);
379 }
380
381 static void smbd_accept_connection(struct tevent_context *ev,
382                                    struct tevent_fd *fde,
383                                    uint16_t flags,
384                                    void *private_data)
385 {
386         struct smbd_open_socket *s = talloc_get_type_abort(private_data,
387                                      struct smbd_open_socket);
388         struct messaging_context *msg_ctx = s->msg_ctx;
389         struct smbd_server_connection *sconn = msg_ctx_to_sconn(msg_ctx);
390         struct sockaddr_storage addr;
391         socklen_t in_addrlen = sizeof(addr);
392         int fd;
393         pid_t pid = 0;
394         uint64_t unique_id;
395
396         fd = accept(s->fd, (struct sockaddr *)(void *)&addr,&in_addrlen);
397         sconn->sock = fd;
398         if (fd == -1 && errno == EINTR)
399                 return;
400
401         if (fd == -1) {
402                 DEBUG(0,("open_sockets_smbd: accept: %s\n",
403                          strerror(errno)));
404                 return;
405         }
406
407         if (s->parent->interactive) {
408                 smbd_process(ev, sconn);
409                 exit_server_cleanly("end of interactive mode");
410                 return;
411         }
412
413         if (!allowable_number_of_smbd_processes()) {
414                 close(fd);
415                 sconn->sock = -1;
416                 return;
417         }
418
419         /*
420          * Generate a unique id in the parent process so that we use
421          * the global random state in the parent.
422          */
423         generate_random_buffer((uint8_t *)&unique_id, sizeof(unique_id));
424
425         pid = sys_fork();
426         if (pid == 0) {
427                 NTSTATUS status = NT_STATUS_OK;
428
429                 /* Child code ... */
430                 am_parent = 0;
431
432                 set_my_unique_id(unique_id);
433
434                 /* Stop zombies, the parent explicitly handles
435                  * them, counting worker smbds. */
436                 CatchChild();
437
438                 /* close our standard file
439                    descriptors */
440                 if (!debug_get_output_is_stdout()) {
441                         close_low_fds(False); /* Don't close stderr */
442                 }
443
444                 /*
445                  * Can't use TALLOC_FREE here. Nulling out the argument to it
446                  * would overwrite memory we've just freed.
447                  */
448                 talloc_free(s->parent);
449                 s = NULL;
450
451                 status = reinit_after_fork(msg_ctx,
452                                            ev,
453                                            procid_self(),
454                                            true);
455                 if (!NT_STATUS_IS_OK(status)) {
456                         if (NT_STATUS_EQUAL(status,
457                                             NT_STATUS_TOO_MANY_OPENED_FILES)) {
458                                 DEBUG(0,("child process cannot initialize "
459                                          "because too many files are open\n"));
460                                 goto exit;
461                         }
462                         if (lp_clustering() &&
463                             NT_STATUS_EQUAL(status,
464                             NT_STATUS_INTERNAL_DB_ERROR)) {
465                                 DEBUG(1,("child process cannot initialize "
466                                          "because connection to CTDB "
467                                          "has failed\n"));
468                                 goto exit;
469                         }
470
471                         DEBUG(0,("reinit_after_fork() failed\n"));
472                         smb_panic("reinit_after_fork() failed");
473                 }
474
475                 smbd_setup_sig_term_handler();
476                 smbd_setup_sig_hup_handler(ev,
477                                            msg_ctx);
478
479                 if (!serverid_register(procid_self(),
480                                        FLAG_MSG_GENERAL|FLAG_MSG_SMBD
481                                        |FLAG_MSG_DBWRAP
482                                        |FLAG_MSG_PRINT_GENERAL)) {
483                         exit_server_cleanly("Could not register myself in "
484                                             "serverid.tdb");
485                 }
486
487                 smbd_process(ev, sconn);
488          exit:
489                 exit_server_cleanly("end of child");
490                 return;
491         }
492
493         if (pid < 0) {
494                 DEBUG(0,("smbd_accept_connection: sys_fork() failed: %s\n",
495                          strerror(errno)));
496         }
497
498         /* The parent doesn't need this socket */
499         close(fd);
500
501         /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
502                 Clear the closed fd info out of server_fd --
503                 and more importantly, out of client_fd in
504                 util_sock.c, to avoid a possible
505                 getpeername failure if we reopen the logs
506                 and use %I in the filename.
507         */
508         sconn->sock = -1;
509
510         if (pid != 0) {
511                 add_child_pid(pid);
512         }
513
514         /* Force parent to check log size after
515          * spawning child.  Fix from
516          * klausr@ITAP.Physik.Uni-Stuttgart.De.  The
517          * parent smbd will log to logserver.smb.  It
518          * writes only two messages for each child
519          * started/finished. But each child writes,
520          * say, 50 messages also in logserver.smb,
521          * begining with the debug_count of the
522          * parent, before the child opens its own log
523          * file logserver.client. In a worst case
524          * scenario the size of logserver.smb would be
525          * checked after about 50*50=2500 messages
526          * (ca. 100kb).
527          * */
528         force_check_log_size();
529 }
530
531 static bool smbd_open_one_socket(struct smbd_parent_context *parent,
532                                  struct tevent_context *ev_ctx,
533                                  struct messaging_context *msg_ctx,
534                                  const struct sockaddr_storage *ifss,
535                                  uint16_t port)
536 {
537         struct smbd_open_socket *s;
538
539         s = talloc(parent, struct smbd_open_socket);
540         if (!s) {
541                 return false;
542         }
543
544         s->parent = parent;
545         s->fd = open_socket_in(SOCK_STREAM,
546                                port,
547                                parent->sockets == NULL ? 0 : 2,
548                                ifss,
549                                true);
550         if (s->fd == -1) {
551                 DEBUG(0,("smbd_open_once_socket: open_socket_in: "
552                         "%s\n", strerror(errno)));
553                 TALLOC_FREE(s);
554                 /*
555                  * We ignore an error here, as we've done before
556                  */
557                 return true;
558         }
559
560         /* ready to listen */
561         set_socket_options(s->fd, "SO_KEEPALIVE");
562         set_socket_options(s->fd, lp_socket_options());
563
564         /* Set server socket to
565          * non-blocking for the accept. */
566         set_blocking(s->fd, False);
567
568         if (listen(s->fd, SMBD_LISTEN_BACKLOG) == -1) {
569                 DEBUG(0,("open_sockets_smbd: listen: "
570                         "%s\n", strerror(errno)));
571                         close(s->fd);
572                 TALLOC_FREE(s);
573                 return false;
574         }
575
576         s->msg_ctx = msg_ctx;
577         s->fde = tevent_add_fd(ev_ctx,
578                                s,
579                                s->fd, TEVENT_FD_READ,
580                                smbd_accept_connection,
581                                s);
582         if (!s->fde) {
583                 DEBUG(0,("open_sockets_smbd: "
584                          "tevent_add_fd: %s\n",
585                          strerror(errno)));
586                 close(s->fd);
587                 TALLOC_FREE(s);
588                 return false;
589         }
590         tevent_fd_set_close_fn(s->fde, smbd_open_socket_close_fn);
591
592         DLIST_ADD_END(parent->sockets, s, struct smbd_open_socket *);
593
594         return true;
595 }
596
597 /****************************************************************************
598  Open the socket communication.
599 ****************************************************************************/
600
601 static bool open_sockets_smbd(struct smbd_parent_context *parent,
602                               struct tevent_context *ev_ctx,
603                               struct messaging_context *msg_ctx,
604                               const char *smb_ports)
605 {
606         int num_interfaces = iface_count();
607         int i;
608         const char *ports;
609         unsigned dns_port = 0;
610
611 #ifdef HAVE_ATEXIT
612         atexit(killkids);
613 #endif
614
615         /* Stop zombies */
616         smbd_setup_sig_chld_handler(ev_ctx);
617
618         /* use a reasonable default set of ports - listing on 445 and 139 */
619         if (!smb_ports) {
620                 ports = lp_smb_ports();
621                 if (!ports || !*ports) {
622                         ports = talloc_strdup(talloc_tos(), SMB_PORTS);
623                 } else {
624                         ports = talloc_strdup(talloc_tos(), ports);
625                 }
626         } else {
627                 ports = talloc_strdup(talloc_tos(), smb_ports);
628         }
629
630         if (lp_interfaces() && lp_bind_interfaces_only()) {
631                 /* We have been given an interfaces line, and been
632                    told to only bind to those interfaces. Create a
633                    socket per interface and bind to only these.
634                 */
635
636                 /* Now open a listen socket for each of the
637                    interfaces. */
638                 for(i = 0; i < num_interfaces; i++) {
639                         const struct sockaddr_storage *ifss =
640                                         iface_n_sockaddr_storage(i);
641                         char *tok;
642                         const char *ptr;
643
644                         if (ifss == NULL) {
645                                 DEBUG(0,("open_sockets_smbd: "
646                                         "interface %d has NULL IP address !\n",
647                                         i));
648                                 continue;
649                         }
650
651                         for (ptr=ports;
652                              next_token_talloc(talloc_tos(),&ptr, &tok, " \t,");) {
653                                 unsigned port = atoi(tok);
654                                 if (port == 0 || port > 0xffff) {
655                                         continue;
656                                 }
657
658                                 /* Keep the first port for mDNS service
659                                  * registration.
660                                  */
661                                 if (dns_port == 0) {
662                                         dns_port = port;
663                                 }
664
665                                 if (!smbd_open_one_socket(parent,
666                                                           ev_ctx,
667                                                           msg_ctx,
668                                                           ifss,
669                                                           port)) {
670                                         return false;
671                                 }
672                         }
673                 }
674         } else {
675                 /* Just bind to 0.0.0.0 - accept connections
676                    from anywhere. */
677
678                 char *tok;
679                 const char *ptr;
680                 const char *sock_addr = lp_socket_address();
681                 char *sock_tok;
682                 const char *sock_ptr;
683
684                 if (strequal(sock_addr, "0.0.0.0") ||
685                     strequal(sock_addr, "::")) {
686 #if HAVE_IPV6
687                         sock_addr = "::,0.0.0.0";
688 #else
689                         sock_addr = "0.0.0.0";
690 #endif
691                 }
692
693                 for (sock_ptr=sock_addr;
694                      next_token_talloc(talloc_tos(), &sock_ptr, &sock_tok, " \t,"); ) {
695                         for (ptr=ports; next_token_talloc(talloc_tos(), &ptr, &tok, " \t,"); ) {
696                                 struct sockaddr_storage ss;
697
698                                 unsigned port = atoi(tok);
699                                 if (port == 0 || port > 0xffff) {
700                                         continue;
701                                 }
702
703                                 /* Keep the first port for mDNS service
704                                  * registration.
705                                  */
706                                 if (dns_port == 0) {
707                                         dns_port = port;
708                                 }
709
710                                 /* open an incoming socket */
711                                 if (!interpret_string_addr(&ss, sock_tok,
712                                                 AI_NUMERICHOST|AI_PASSIVE)) {
713                                         continue;
714                                 }
715
716                                 if (!smbd_open_one_socket(parent,
717                                                           ev_ctx,
718                                                           msg_ctx,
719                                                           &ss,
720                                                           port)) {
721                                         return false;
722                                 }
723                         }
724                 }
725         }
726
727         if (parent->sockets == NULL) {
728                 DEBUG(0,("open_sockets_smbd: No "
729                         "sockets available to bind to.\n"));
730                 return false;
731         }
732
733         /* Setup the main smbd so that we can get messages. Note that
734            do this after starting listening. This is needed as when in
735            clustered mode, ctdb won't allow us to start doing database
736            operations until it has gone thru a full startup, which
737            includes checking to see that smbd is listening. */
738
739         if (!serverid_register(procid_self(),
740                                FLAG_MSG_GENERAL|FLAG_MSG_SMBD
741                                |FLAG_MSG_DBWRAP)) {
742                 DEBUG(0, ("open_sockets_smbd: Failed to register "
743                           "myself in serverid.tdb\n"));
744                 return false;
745         }
746
747         /* Listen to messages */
748
749         messaging_register(msg_ctx, NULL, MSG_SMB_SAM_SYNC, msg_sam_sync);
750         messaging_register(msg_ctx, NULL, MSG_SHUTDOWN, msg_exit_server);
751         messaging_register(msg_ctx, NULL, MSG_SMB_FILE_RENAME,
752                            msg_file_was_renamed);
753         messaging_register(msg_ctx, ev_ctx, MSG_SMB_CONF_UPDATED,
754                            smb_conf_updated);
755         messaging_register(msg_ctx, NULL, MSG_SMB_STAT_CACHE_DELETE,
756                            smb_stat_cache_delete);
757         messaging_register(msg_ctx, NULL, MSG_DEBUG, smbd_msg_debug);
758         messaging_register(msg_ctx, ev_ctx, MSG_PRINTER_PCAP,
759                            smb_pcap_updated);
760         brl_register_msgs(msg_ctx);
761
762         msg_idmap_register_msg(msg_ctx);
763
764 #ifdef CLUSTER_SUPPORT
765         if (lp_clustering()) {
766                 ctdbd_register_reconfigure(messaging_ctdbd_connection());
767         }
768 #endif
769
770 #ifdef DEVELOPER
771         messaging_register(msg_ctx, NULL, MSG_SMB_INJECT_FAULT,
772                            msg_inject_fault);
773 #endif
774
775         if (lp_multicast_dns_register() && (dns_port != 0)) {
776 #ifdef WITH_DNSSD_SUPPORT
777                 smbd_setup_mdns_registration(ev_ctx,
778                                              parent, dns_port);
779 #endif
780 #ifdef WITH_AVAHI_SUPPORT
781                 void *avahi_conn;
782
783                 avahi_conn = avahi_start_register(ev_ctx,
784                                                   ev_ctx,
785                                                   dns_port);
786                 if (avahi_conn == NULL) {
787                         DEBUG(10, ("avahi_start_register failed\n"));
788                 }
789 #endif
790         }
791
792         return true;
793 }
794
795 static void smbd_parent_loop(struct tevent_context *ev_ctx,
796                              struct smbd_parent_context *parent)
797 {
798         /* now accept incoming connections - forking a new process
799            for each incoming connection */
800         DEBUG(2,("waiting for connections\n"));
801         while (1) {
802                 int ret;
803                 TALLOC_CTX *frame = talloc_stackframe();
804
805                 ret = tevent_loop_once(ev_ctx);
806                 if (ret != 0) {
807                         exit_server_cleanly("tevent_loop_once() error");
808                 }
809
810                 TALLOC_FREE(frame);
811         } /* end while 1 */
812
813 /* NOTREACHED   return True; */
814 }
815
816
817 /****************************************************************************
818  Initialise connect, service and file structs.
819 ****************************************************************************/
820
821 static bool init_structs(void )
822 {
823         /*
824          * Set the machine NETBIOS name if not already
825          * set from the config file.
826          */
827
828         if (!init_names())
829                 return False;
830
831         if (!secrets_init())
832                 return False;
833
834         return True;
835 }
836
837 /****************************************************************************
838  main program.
839 ****************************************************************************/
840
841 /* Declare prototype for build_options() to avoid having to run it through
842    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
843    prototype generation system is too complicated. */
844
845 extern void build_options(bool screen);
846
847  int main(int argc,const char *argv[])
848 {
849         /* shall I run as a daemon */
850         bool is_daemon = false;
851         bool interactive = false;
852         bool Fork = true;
853         bool no_process_group = false;
854         bool log_stdout = false;
855         char *ports = NULL;
856         char *profile_level = NULL;
857         int opt;
858         poptContext pc;
859         bool print_build_options = False;
860         enum {
861                 OPT_DAEMON = 1000,
862                 OPT_INTERACTIVE,
863                 OPT_FORK,
864                 OPT_NO_PROCESS_GROUP,
865                 OPT_LOG_STDOUT
866         };
867         struct poptOption long_options[] = {
868         POPT_AUTOHELP
869         {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
870         {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
871         {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
872         {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
873         {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
874         {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
875         {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
876         {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
877         POPT_COMMON_SAMBA
878         POPT_COMMON_DYNCONFIG
879         POPT_TABLEEND
880         };
881         struct smbd_parent_context *parent = NULL;
882         TALLOC_CTX *frame;
883         NTSTATUS status;
884         uint64_t unique_id;
885         struct tevent_context *ev_ctx;
886         struct messaging_context *msg_ctx;
887
888         /*
889          * Do this before any other talloc operation
890          */
891         talloc_enable_null_tracking();
892         frame = talloc_stackframe();
893
894         setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
895
896         load_case_tables();
897
898         smbd_init_globals();
899
900         TimeInit();
901
902 #ifdef HAVE_SET_AUTH_PARAMETERS
903         set_auth_parameters(argc,argv);
904 #endif
905
906         pc = poptGetContext("smbd", argc, argv, long_options, 0);
907         while((opt = poptGetNextOpt(pc)) != -1) {
908                 switch (opt)  {
909                 case OPT_DAEMON:
910                         is_daemon = true;
911                         break;
912                 case OPT_INTERACTIVE:
913                         interactive = true;
914                         break;
915                 case OPT_FORK:
916                         Fork = false;
917                         break;
918                 case OPT_NO_PROCESS_GROUP:
919                         no_process_group = true;
920                         break;
921                 case OPT_LOG_STDOUT:
922                         log_stdout = true;
923                         break;
924                 case 'b':
925                         print_build_options = True;
926                         break;
927                 default:
928                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
929                                   poptBadOption(pc, 0), poptStrerror(opt));
930                         poptPrintUsage(pc, stderr, 0);
931                         exit(1);
932                 }
933         }
934         poptFreeContext(pc);
935
936         if (interactive) {
937                 Fork = False;
938                 log_stdout = True;
939         }
940
941         if (log_stdout) {
942                 setup_logging(argv[0], DEBUG_STDOUT);
943         } else {
944                 setup_logging(argv[0], DEBUG_FILE);
945         }
946
947         if (print_build_options) {
948                 build_options(True); /* Display output to screen as well as debug */
949                 exit(0);
950         }
951
952 #ifdef HAVE_SETLUID
953         /* needed for SecureWare on SCO */
954         setluid(0);
955 #endif
956
957         set_remote_machine_name("smbd", False);
958
959         if (interactive && (DEBUGLEVEL >= 9)) {
960                 talloc_enable_leak_report();
961         }
962
963         if (log_stdout && Fork) {
964                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
965                 exit(1);
966         }
967
968         /* we want to re-seed early to prevent time delays causing
969            client problems at a later date. (tridge) */
970         generate_random_buffer(NULL, 0);
971
972         /* get initial effective uid and gid */
973         sec_init();
974
975         /* make absolutely sure we run as root - to handle cases where people
976            are crazy enough to have it setuid */
977         gain_root_privilege();
978         gain_root_group_privilege();
979
980         fault_setup();
981         dump_core_setup("smbd", lp_logfile());
982
983         /* we are never interested in SIGPIPE */
984         BlockSignals(True,SIGPIPE);
985
986 #if defined(SIGFPE)
987         /* we are never interested in SIGFPE */
988         BlockSignals(True,SIGFPE);
989 #endif
990
991 #if defined(SIGUSR2)
992         /* We are no longer interested in USR2 */
993         BlockSignals(True,SIGUSR2);
994 #endif
995
996         /* POSIX demands that signals are inherited. If the invoking process has
997          * these signals masked, we will have problems, as we won't recieve them. */
998         BlockSignals(False, SIGHUP);
999         BlockSignals(False, SIGUSR1);
1000         BlockSignals(False, SIGTERM);
1001
1002         /* Ensure we leave no zombies until we
1003          * correctly set up child handling below. */
1004
1005         CatchChild();
1006
1007         /* we want total control over the permissions on created files,
1008            so set our umask to 0 */
1009         umask(0);
1010
1011         reopen_logs();
1012
1013         DEBUG(0,("smbd version %s started.\n", samba_version_string()));
1014         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1015
1016         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1017                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1018
1019         /* Output the build options to the debug log */ 
1020         build_options(False);
1021
1022         if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1023                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1024                 exit(1);
1025         }
1026
1027         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1028                 DEBUG(0, ("error opening config file '%s'\n", get_dyn_CONFIGFILE()));
1029                 exit(1);
1030         }
1031
1032         /* Init the security context and global current_user */
1033         init_sec_ctx();
1034
1035         /*
1036          * Initialize the event context. The event context needs to be
1037          * initialized before the messaging context, cause the messaging
1038          * context holds an event context.
1039          * FIXME: This should be s3_tevent_context_init()
1040          */
1041         ev_ctx = server_event_context();
1042         if (ev_ctx == NULL) {
1043                 exit(1);
1044         }
1045
1046         /*
1047          * Init the messaging context
1048          * FIXME: This should only call messaging_init()
1049          */
1050         msg_ctx = server_messaging_context();
1051         if (msg_ctx == NULL) {
1052                 exit(1);
1053         }
1054
1055         /*
1056          * Reloading of the printers will not work here as we don't have a
1057          * server info and rpc services set up. It will be called later.
1058          */
1059         if (!reload_services(NULL, -1, False)) {
1060                 exit(1);
1061         }
1062
1063         /* ...NOTE... Log files are working from this point! */
1064
1065         DEBUG(3,("loaded services\n"));
1066
1067         init_structs();
1068
1069 #ifdef WITH_PROFILE
1070         if (!profile_setup(msg_ctx, False)) {
1071                 DEBUG(0,("ERROR: failed to setup profiling\n"));
1072                 return -1;
1073         }
1074         if (profile_level != NULL) {
1075                 int pl = atoi(profile_level);
1076                 struct server_id src;
1077
1078                 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1079                 src.pid = getpid();
1080                 set_profile_level(pl, src);
1081         }
1082 #endif
1083
1084         if (!is_daemon && !is_a_socket(0)) {
1085                 if (!interactive)
1086                         DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1087
1088                 /*
1089                  * Setting is_daemon here prevents us from eventually calling
1090                  * the open_sockets_inetd()
1091                  */
1092
1093                 is_daemon = True;
1094         }
1095
1096         if (is_daemon && !interactive) {
1097                 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1098                 become_daemon(Fork, no_process_group, log_stdout);
1099         }
1100
1101         generate_random_buffer((uint8_t *)&unique_id, sizeof(unique_id));
1102         set_my_unique_id(unique_id);
1103
1104 #if HAVE_SETPGID
1105         /*
1106          * If we're interactive we want to set our own process group for
1107          * signal management.
1108          */
1109         if (interactive && !no_process_group)
1110                 setpgid( (pid_t)0, (pid_t)0);
1111 #endif
1112
1113         if (!directory_exist(lp_lockdir()))
1114                 mkdir(lp_lockdir(), 0755);
1115
1116         if (is_daemon)
1117                 pidfile_create("smbd");
1118
1119         status = reinit_after_fork(msg_ctx,
1120                                    ev_ctx,
1121                                    procid_self(), false);
1122         if (!NT_STATUS_IS_OK(status)) {
1123                 DEBUG(0,("reinit_after_fork() failed\n"));
1124                 exit(1);
1125         }
1126
1127         smbd_server_conn->msg_ctx = msg_ctx;
1128
1129         smbd_setup_sig_term_handler();
1130         smbd_setup_sig_hup_handler(ev_ctx,
1131                                    msg_ctx);
1132
1133         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1134
1135         if (smbd_memcache() == NULL) {
1136                 exit(1);
1137         }
1138
1139         memcache_set_global(smbd_memcache());
1140
1141         /* Initialise the password backed before the global_sam_sid
1142            to ensure that we fetch from ldap before we make a domain sid up */
1143
1144         if(!initialize_password_db(false, ev_ctx))
1145                 exit(1);
1146
1147         if (!secrets_init()) {
1148                 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1149                 exit(1);
1150         }
1151
1152         if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC) {
1153                 if (!open_schannel_session_store(NULL, lp_private_dir())) {
1154                         DEBUG(0,("ERROR: Samba cannot open schannel store for secured NETLOGON operations.\n"));
1155                         exit(1);
1156                 }
1157         }
1158
1159         if(!get_global_sam_sid()) {
1160                 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1161                 exit(1);
1162         }
1163
1164         if (!sessionid_init()) {
1165                 exit(1);
1166         }
1167
1168         if (!connections_init(True))
1169                 exit(1);
1170
1171         if (!locking_init())
1172                 exit(1);
1173
1174         if (!messaging_tdb_parent_init(ev_ctx)) {
1175                 exit(1);
1176         }
1177
1178         if (!notify_internal_parent_init(ev_ctx)) {
1179                 exit(1);
1180         }
1181
1182         if (!serverid_parent_init(ev_ctx)) {
1183                 exit(1);
1184         }
1185
1186         if (!W_ERROR_IS_OK(registry_init_full()))
1187                 exit(1);
1188
1189         /* Open the share_info.tdb here, so we don't have to open
1190            after the fork on every single connection.  This is a small
1191            performance improvment and reduces the total number of system
1192            fds used. */
1193         if (!share_info_db_init()) {
1194                 DEBUG(0,("ERROR: failed to load share info db.\n"));
1195                 exit(1);
1196         }
1197
1198         status = init_system_info();
1199         if (!NT_STATUS_IS_OK(status)) {
1200                 DEBUG(1, ("ERROR: failed to setup system user info: %s.\n",
1201                           nt_errstr(status)));
1202                 return -1;
1203         }
1204
1205         if (!init_guest_info()) {
1206                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1207                 return -1;
1208         }
1209
1210         if (!file_init(smbd_server_conn)) {
1211                 DEBUG(0, ("ERROR: file_init failed\n"));
1212                 return -1;
1213         }
1214
1215         /* This MUST be done before start_epmd() because otherwise
1216          * start_epmd() forks and races against dcesrv_ep_setup() to
1217          * call directory_create_or_exist() */
1218         if (!directory_create_or_exist(lp_ncalrpc_dir(), geteuid(), 0755)) {
1219                 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
1220                           lp_ncalrpc_dir(), strerror(errno)));
1221                 return -1;
1222         }
1223
1224         if (is_daemon && !interactive) {
1225                 if (rpc_epmapper_daemon() == RPC_DAEMON_FORK) {
1226                         start_epmd(ev_ctx, msg_ctx);
1227                 }
1228         }
1229
1230         if (!dcesrv_ep_setup(ev_ctx, msg_ctx)) {
1231                 exit(1);
1232         }
1233
1234         /* only start other daemons if we are running as a daemon
1235          * -- bad things will happen if smbd is launched via inetd
1236          *  and we fork a copy of ourselves here */
1237         if (is_daemon && !interactive) {
1238
1239                 if (rpc_lsasd_daemon() == RPC_DAEMON_FORK) {
1240                         start_lsasd(ev_ctx, msg_ctx);
1241                 }
1242
1243                 if (!_lp_disable_spoolss() &&
1244                     (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
1245                         bool bgq = lp_parm_bool(-1, "smbd", "backgroundqueue", true);
1246
1247                         if (!printing_subsystem_init(ev_ctx, msg_ctx, true, bgq)) {
1248                                 exit(1);
1249                         }
1250                 }
1251         } else if (!_lp_disable_spoolss() &&
1252                    (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
1253                 if (!printing_subsystem_init(ev_ctx, msg_ctx, false, false)) {
1254                         exit(1);
1255                 }
1256         }
1257
1258         if (!is_daemon) {
1259                 /* inetd mode */
1260                 TALLOC_FREE(frame);
1261
1262                 /* Started from inetd. fd 0 is the socket. */
1263                 /* We will abort gracefully when the client or remote system
1264                    goes away */
1265                 smbd_server_conn->sock = dup(0);
1266
1267                 /* close our standard file descriptors */
1268                 if (!debug_get_output_is_stdout()) {
1269                         close_low_fds(False); /* Don't close stderr */
1270                 }
1271
1272 #ifdef HAVE_ATEXIT
1273                 atexit(killkids);
1274 #endif
1275
1276                 /* Stop zombies */
1277                 smbd_setup_sig_chld_handler(ev_ctx);
1278
1279                 smbd_process(ev_ctx, smbd_server_conn);
1280
1281                 exit_server_cleanly(NULL);
1282                 return(0);
1283         }
1284
1285         parent = talloc_zero(ev_ctx, struct smbd_parent_context);
1286         if (!parent) {
1287                 exit_server("talloc(struct smbd_parent_context) failed");
1288         }
1289         parent->interactive = interactive;
1290
1291         if (!open_sockets_smbd(parent, ev_ctx, msg_ctx, ports))
1292                 exit_server("open_sockets_smbd() failed");
1293
1294         /* do a printer update now that all messaging has been set up,
1295          * before we allow clients to start connecting */
1296         printing_subsystem_update(ev_ctx, msg_ctx, false);
1297
1298         TALLOC_FREE(frame);
1299         /* make sure we always have a valid stackframe */
1300         frame = talloc_stackframe();
1301
1302         smbd_parent_loop(ev_ctx, parent);
1303
1304         exit_server_cleanly(NULL);
1305         TALLOC_FREE(frame);
1306         return(0);
1307 }