lib: Remove sys_waitpid
[metze/samba/wip.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 "../lib/util/memcache.h"
33 #include "ctdbd_conn.h"
34 #include "util_cluster.h"
35 #include "printing/queue_process.h"
36 #include "rpc_server/rpc_service_setup.h"
37 #include "rpc_server/rpc_config.h"
38 #include "serverid.h"
39 #include "passdb.h"
40 #include "auth.h"
41 #include "messages.h"
42 #include "smbprofile.h"
43 #include "lib/id_cache.h"
44 #include "lib/param/param.h"
45 #include "lib/background.h"
46 #include "lib/conn_tdb.h"
47 #include "../lib/util/pidfile.h"
48 #include "lib/smbd_shim.h"
49 #include "scavenger.h"
50 #include "locking/leases_db.h"
51 #include "smbd/notifyd/notifyd.h"
52 #include "smbd/smbd_cleanupd.h"
53 #include "lib/util/sys_rw.h"
54
55 #ifdef CLUSTER_SUPPORT
56 #include "ctdb_protocol.h"
57 #endif
58
59 struct smbd_open_socket;
60 struct smbd_child_pid;
61
62 struct smbd_parent_context {
63         bool interactive;
64
65         struct tevent_context *ev_ctx;
66         struct messaging_context *msg_ctx;
67
68         /* the list of listening sockets */
69         struct smbd_open_socket *sockets;
70
71         /* the list of current child processes */
72         struct smbd_child_pid *children;
73         size_t num_children;
74
75         struct server_id cleanupd;
76
77         struct tevent_timer *cleanup_te;
78 };
79
80 struct smbd_open_socket {
81         struct smbd_open_socket *prev, *next;
82         struct smbd_parent_context *parent;
83         int fd;
84         struct tevent_fd *fde;
85 };
86
87 struct smbd_child_pid {
88         struct smbd_child_pid *prev, *next;
89         pid_t pid;
90 };
91
92 extern void start_epmd(struct tevent_context *ev_ctx,
93                        struct messaging_context *msg_ctx);
94
95 extern void start_lsasd(struct tevent_context *ev_ctx,
96                         struct messaging_context *msg_ctx);
97
98 extern void start_fssd(struct tevent_context *ev_ctx,
99                        struct messaging_context *msg_ctx);
100
101 extern void start_mdssd(struct tevent_context *ev_ctx,
102                         struct messaging_context *msg_ctx);
103
104 /*******************************************************************
105  What to do when smb.conf is updated.
106  ********************************************************************/
107
108 static void smbd_parent_conf_updated(struct messaging_context *msg,
109                                      void *private_data,
110                                      uint32_t msg_type,
111                                      struct server_id server_id,
112                                      DATA_BLOB *data)
113 {
114         struct tevent_context *ev_ctx =
115                 talloc_get_type_abort(private_data, struct tevent_context);
116
117         DEBUG(10,("smbd_parent_conf_updated: Got message saying smb.conf was "
118                   "updated. Reloading.\n"));
119         change_to_root_user();
120         reload_services(NULL, NULL, false);
121         printing_subsystem_update(ev_ctx, msg, false);
122 }
123
124 /*******************************************************************
125  Delete a statcache entry.
126  ********************************************************************/
127
128 static void smb_stat_cache_delete(struct messaging_context *msg,
129                                   void *private_data,
130                                   uint32_t msg_tnype,
131                                   struct server_id server_id,
132                                   DATA_BLOB *data)
133 {
134         const char *name = (const char *)data->data;
135         DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
136         stat_cache_delete(name);
137 }
138
139 /****************************************************************************
140   Send a SIGTERM to our process group.
141 *****************************************************************************/
142
143 static void  killkids(void)
144 {
145         if(am_parent) kill(0,SIGTERM);
146 }
147
148 static void msg_exit_server(struct messaging_context *msg,
149                             void *private_data,
150                             uint32_t msg_type,
151                             struct server_id server_id,
152                             DATA_BLOB *data)
153 {
154         DEBUG(3, ("got a SHUTDOWN message\n"));
155         exit_server_cleanly(NULL);
156 }
157
158 #ifdef DEVELOPER
159 static void msg_inject_fault(struct messaging_context *msg,
160                              void *private_data,
161                              uint32_t msg_type,
162                              struct server_id src,
163                              DATA_BLOB *data)
164 {
165         int sig;
166         struct server_id_buf tmp;
167
168         if (data->length != sizeof(sig)) {
169                 DEBUG(0, ("Process %s sent bogus signal injection request\n",
170                           server_id_str_buf(src, &tmp)));
171                 return;
172         }
173
174         sig = *(int *)data->data;
175         if (sig == -1) {
176                 exit_server("internal error injected");
177                 return;
178         }
179
180 #if HAVE_STRSIGNAL
181         DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
182                   server_id_str_buf(src, &tmp), sig, strsignal(sig)));
183 #else
184         DEBUG(0, ("Process %s requested injection of signal %d\n",
185                   server_id_str_buf(src, &tmp), sig));
186 #endif
187
188         kill(getpid(), sig);
189 }
190 #endif /* DEVELOPER */
191
192 static NTSTATUS messaging_send_to_children(struct messaging_context *msg_ctx,
193                                            uint32_t msg_type, DATA_BLOB* data)
194 {
195         NTSTATUS status;
196         struct smbd_parent_context *parent = am_parent;
197         struct smbd_child_pid *child;
198
199         if (parent == NULL) {
200                 return NT_STATUS_INTERNAL_ERROR;
201         }
202
203         for (child = parent->children; child != NULL; child = child->next) {
204                 status = messaging_send(parent->msg_ctx,
205                                         pid_to_procid(child->pid),
206                                         msg_type, data);
207                 if (!NT_STATUS_IS_OK(status)) {
208                         return status;
209                 }
210         }
211         return NT_STATUS_OK;
212 }
213
214 static void smb_parent_send_to_children(struct messaging_context *ctx,
215                                         void* data,
216                                         uint32_t msg_type,
217                                         struct server_id srv_id,
218                                         DATA_BLOB* msg_data)
219 {
220         messaging_send_to_children(ctx, msg_type, msg_data);
221 }
222
223 /*
224  * Parent smbd process sets its own debug level first and then
225  * sends a message to all the smbd children to adjust their debug
226  * level to that of the parent.
227  */
228
229 static void smbd_msg_debug(struct messaging_context *msg_ctx,
230                            void *private_data,
231                            uint32_t msg_type,
232                            struct server_id server_id,
233                            DATA_BLOB *data)
234 {
235         debug_message(msg_ctx, private_data, MSG_DEBUG, server_id, data);
236
237         messaging_send_to_children(msg_ctx, MSG_DEBUG, data);
238 }
239
240 static void smbd_parent_id_cache_kill(struct messaging_context *msg_ctx,
241                                       void *private_data,
242                                       uint32_t msg_type,
243                                       struct server_id server_id,
244                                       DATA_BLOB* data)
245 {
246         const char *msg = (data && data->data)
247                 ? (const char *)data->data : "<NULL>";
248         struct id_cache_ref id;
249
250         if (!id_cache_ref_parse(msg, &id)) {
251                 DEBUG(0, ("Invalid ?ID: %s\n", msg));
252                 return;
253         }
254
255         id_cache_delete_from_cache(&id);
256
257         messaging_send_to_children(msg_ctx, msg_type, data);
258 }
259
260 static void smbd_parent_id_cache_delete(struct messaging_context *ctx,
261                                         void* data,
262                                         uint32_t msg_type,
263                                         struct server_id srv_id,
264                                         DATA_BLOB* msg_data)
265 {
266         id_cache_delete_message(ctx, data, msg_type, srv_id, msg_data);
267
268         messaging_send_to_children(ctx, msg_type, msg_data);
269 }
270
271 #ifdef CLUSTER_SUPPORT
272 static int smbd_parent_ctdb_reconfigured(
273         uint32_t src_vnn, uint32_t dst_vnn, uint64_t dst_srvid,
274         const uint8_t *msg, size_t msglen, void *private_data)
275 {
276         struct messaging_context *msg_ctx = talloc_get_type_abort(
277                 private_data, struct messaging_context);
278
279         DEBUG(10, ("Got %s message\n", (dst_srvid == CTDB_SRVID_RECONFIGURE)
280                    ? "cluster reconfigure" : "SAMBA_NOTIFY"));
281
282         /*
283          * Someone from the family died, validate our locks
284          */
285
286         if (am_parent) {
287                 messaging_send_buf(msg_ctx, am_parent->cleanupd,
288                                    MSG_SMB_BRL_VALIDATE, NULL, 0);
289         }
290
291         return 0;
292 }
293 #endif
294
295 static void add_child_pid(struct smbd_parent_context *parent,
296                           pid_t pid)
297 {
298         struct smbd_child_pid *child;
299
300         child = talloc_zero(parent, struct smbd_child_pid);
301         if (child == NULL) {
302                 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
303                 return;
304         }
305         child->pid = pid;
306         DLIST_ADD(parent->children, child);
307         parent->num_children += 1;
308 }
309
310 static void smb_tell_num_children(struct messaging_context *ctx, void *data,
311                                   uint32_t msg_type, struct server_id srv_id,
312                                   DATA_BLOB *msg_data)
313 {
314         uint8_t buf[sizeof(uint32_t)];
315
316         if (am_parent) {
317                 SIVAL(buf, 0, am_parent->num_children);
318                 messaging_send_buf(ctx, srv_id, MSG_SMB_NUM_CHILDREN,
319                                    buf, sizeof(buf));
320         }
321 }
322
323 static void notifyd_stopped(struct tevent_req *req);
324
325 static struct tevent_req *notifyd_req(struct messaging_context *msg_ctx,
326                                       struct tevent_context *ev)
327 {
328         struct tevent_req *req;
329         sys_notify_watch_fn sys_notify_watch = NULL;
330         struct sys_notify_context *sys_notify_ctx = NULL;
331
332         if (lp_kernel_change_notify()) {
333
334 #ifdef HAVE_INOTIFY
335                 if (lp_parm_bool(-1, "notify", "inotify", true)) {
336                         sys_notify_watch = inotify_watch;
337                 }
338 #endif
339
340 #ifdef HAVE_FAM
341                 if (lp_parm_bool(-1, "notify", "fam",
342                                  (sys_notify_watch == NULL))) {
343                         sys_notify_watch = fam_watch;
344                 }
345 #endif
346         }
347
348         if (sys_notify_watch != NULL) {
349                 sys_notify_ctx = sys_notify_context_create(msg_ctx, ev);
350                 if (sys_notify_ctx == NULL) {
351                         return NULL;
352                 }
353         }
354
355         req = notifyd_send(msg_ctx, ev, msg_ctx,
356                            messaging_ctdbd_connection(),
357                            sys_notify_watch, sys_notify_ctx);
358         if (req == NULL) {
359                 TALLOC_FREE(sys_notify_ctx);
360                 return NULL;
361         }
362         tevent_req_set_callback(req, notifyd_stopped, msg_ctx);
363
364         return req;
365 }
366
367 static void notifyd_stopped(struct tevent_req *req)
368 {
369         int ret;
370
371         ret = notifyd_recv(req);
372         TALLOC_FREE(req);
373         DEBUG(1, ("notifyd stopped: %s\n", strerror(ret)));
374 }
375
376 static bool smbd_notifyd_init(struct messaging_context *msg, bool interactive)
377 {
378         struct tevent_context *ev = messaging_tevent_context(msg);
379         struct tevent_req *req;
380         pid_t pid;
381         NTSTATUS status;
382
383         if (interactive) {
384                 req = notifyd_req(msg, ev);
385                 return (req != NULL);
386         }
387
388         pid = fork();
389         if (pid == -1) {
390                 DEBUG(1, ("%s: fork failed: %s\n", __func__,
391                           strerror(errno)));
392                 return false;
393         }
394
395         if (pid != 0) {
396                 return true;
397         }
398
399         status = reinit_after_fork(msg, ev, true, "smbd-notifyd");
400         if (!NT_STATUS_IS_OK(status)) {
401                 DEBUG(1, ("%s: reinit_after_fork failed: %s\n",
402                           __func__, nt_errstr(status)));
403                 exit(1);
404         }
405
406         req = notifyd_req(msg, ev);
407         if (req == NULL) {
408                 exit(1);
409         }
410         tevent_req_set_callback(req, notifyd_stopped, msg);
411         return tevent_req_poll(req, ev);
412 }
413
414 static void cleanupd_stopped(struct tevent_req *req);
415
416 static bool cleanupd_init(struct messaging_context *msg, bool interactive,
417                           struct server_id *ppid)
418 {
419         struct tevent_context *ev = messaging_tevent_context(msg);
420         struct server_id parent_id = messaging_server_id(msg);
421         struct tevent_req *req;
422         pid_t pid;
423         NTSTATUS status;
424         ssize_t rwret;
425         int ret;
426         bool ok;
427         char c;
428         int up_pipe[2];
429
430         if (interactive) {
431                 req = smbd_cleanupd_send(msg, ev, msg, parent_id.pid);
432                 *ppid = messaging_server_id(msg);
433                 return (req != NULL);
434         }
435
436         ret = pipe(up_pipe);
437         if (ret == -1) {
438                 DBG_WARNING("pipe failed: %s\n", strerror(errno));
439                 return false;
440         }
441
442         pid = fork();
443         if (pid == -1) {
444                 DBG_WARNING("fork failed: %s\n", strerror(errno));
445                 close(up_pipe[0]);
446                 close(up_pipe[1]);
447                 return false;
448         }
449
450         if (pid != 0) {
451
452                 close(up_pipe[1]);
453                 rwret = sys_read(up_pipe[0], &c, 1);
454                 close(up_pipe[0]);
455
456                 if (rwret == -1) {
457                         DBG_WARNING("sys_read failed: %s\n", strerror(errno));
458                         return false;
459                 }
460                 if (rwret == 0) {
461                         DBG_WARNING("cleanupd could not start\n");
462                         return false;
463                 }
464                 if (c != 0) {
465                         DBG_WARNING("cleanupd returned %d\n", (int)c);
466                         return false;
467                 }
468
469                 DBG_DEBUG("Started cleanupd pid=%d\n", (int)pid);
470
471                 *ppid = pid_to_procid(pid);
472                 return true;
473         }
474
475         close(up_pipe[0]);
476
477         status = reinit_after_fork(msg, ev, true, "cleanupd");
478         if (!NT_STATUS_IS_OK(status)) {
479                 DBG_WARNING("reinit_after_fork failed: %s\n",
480                             nt_errstr(status));
481                 c = 1;
482                 sys_write(up_pipe[1], &c, 1);
483
484                 exit(1);
485         }
486
487         req = smbd_cleanupd_send(msg, ev, msg, parent_id.pid);
488         if (req == NULL) {
489                 DBG_WARNING("smbd_cleanupd_send failed\n");
490                 c = 2;
491                 sys_write(up_pipe[1], &c, 1);
492
493                 exit(1);
494         }
495
496         tevent_req_set_callback(req, cleanupd_stopped, msg);
497
498         c = 0;
499         rwret = sys_write(up_pipe[1], &c, 1);
500         close(up_pipe[1]);
501
502         if (rwret == -1) {
503                 DBG_WARNING("sys_write failed: %s\n", strerror(errno));
504                 exit(1);
505         }
506         if (rwret != 1) {
507                 DBG_WARNING("sys_write could not write result\n");
508                 exit(1);
509         }
510
511         ok = tevent_req_poll(req, ev);
512         if (!ok) {
513                 DBG_WARNING("tevent_req_poll returned %s\n", strerror(errno));
514         }
515         exit(0);
516 }
517
518 static void cleanupd_stopped(struct tevent_req *req)
519 {
520         NTSTATUS status;
521
522         status = smbd_cleanupd_recv(req);
523         DBG_WARNING("cleanupd stopped: %s\n", nt_errstr(status));
524 }
525
526 /*
527   at most every smbd:cleanuptime seconds (default 20), we scan the BRL
528   and locking database for entries to cleanup. As a side effect this
529   also cleans up dead entries in the connections database (due to the
530   traversal in message_send_all()
531
532   Using a timer for this prevents a flood of traversals when a large
533   number of clients disconnect at the same time (perhaps due to a
534   network outage).  
535 */
536
537 static void cleanup_timeout_fn(struct tevent_context *event_ctx,
538                                 struct tevent_timer *te,
539                                 struct timeval now,
540                                 void *private_data)
541 {
542         struct smbd_parent_context *parent =
543                 talloc_get_type_abort(private_data,
544                 struct smbd_parent_context);
545
546         parent->cleanup_te = NULL;
547
548         messaging_send_buf(parent->msg_ctx, parent->cleanupd,
549                            MSG_SMB_UNLOCK, NULL, 0);
550 }
551
552 static void remove_child_pid(struct smbd_parent_context *parent,
553                              pid_t pid,
554                              bool unclean_shutdown)
555 {
556         struct smbd_child_pid *child;
557         struct iovec iov[2];
558         NTSTATUS status;
559
560         iov[0] = (struct iovec) { .iov_base = (uint8_t *)&pid,
561                                   .iov_len = sizeof(pid) };
562         iov[1] = (struct iovec) { .iov_base = (uint8_t *)&unclean_shutdown,
563                                   .iov_len = sizeof(bool) };
564
565         status = messaging_send_iov(parent->msg_ctx, parent->cleanupd,
566                                     MSG_SMB_NOTIFY_CLEANUP,
567                                     iov, ARRAY_SIZE(iov), NULL, 0);
568         DEBUG(10, ("messaging_send_iov returned %s\n", nt_errstr(status)));
569
570         for (child = parent->children; child != NULL; child = child->next) {
571                 if (child->pid == pid) {
572                         struct smbd_child_pid *tmp = child;
573                         DLIST_REMOVE(parent->children, child);
574                         TALLOC_FREE(tmp);
575                         parent->num_children -= 1;
576                         break;
577                 }
578         }
579
580         if (child == NULL) {
581                 /* not all forked child processes are added to the children list */
582                 DEBUG(2, ("Could not find child %d -- ignoring\n", (int)pid));
583                 return;
584         }
585
586         if (unclean_shutdown) {
587                 /* a child terminated uncleanly so tickle all
588                    processes to see if they can grab any of the
589                    pending locks
590                 */
591                 DEBUG(3,(__location__ " Unclean shutdown of pid %u\n",
592                         (unsigned int)pid));
593                 if (parent->cleanup_te == NULL) {
594                         /* call the cleanup timer, but not too often */
595                         int cleanup_time = lp_parm_int(-1, "smbd", "cleanuptime", 20);
596                         parent->cleanup_te = tevent_add_timer(parent->ev_ctx,
597                                                 parent,
598                                                 timeval_current_ofs(cleanup_time, 0),
599                                                 cleanup_timeout_fn,
600                                                 parent);
601                         DEBUG(1,("Scheduled cleanup of brl and lock database after unclean shutdown\n"));
602                 }
603         }
604 }
605
606 /****************************************************************************
607  Have we reached the process limit ?
608 ****************************************************************************/
609
610 static bool allowable_number_of_smbd_processes(struct smbd_parent_context *parent)
611 {
612         int max_processes = lp_max_smbd_processes();
613
614         if (!max_processes)
615                 return True;
616
617         return parent->num_children < max_processes;
618 }
619
620 static void smbd_sig_chld_handler(struct tevent_context *ev,
621                                   struct tevent_signal *se,
622                                   int signum,
623                                   int count,
624                                   void *siginfo,
625                                   void *private_data)
626 {
627         pid_t pid;
628         int status;
629         struct smbd_parent_context *parent =
630                 talloc_get_type_abort(private_data,
631                 struct smbd_parent_context);
632
633         while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
634                 bool unclean_shutdown = False;
635
636                 /* If the child terminated normally, assume
637                    it was an unclean shutdown unless the
638                    status is 0
639                 */
640                 if (WIFEXITED(status)) {
641                         unclean_shutdown = WEXITSTATUS(status);
642                 }
643                 /* If the child terminated due to a signal
644                    we always assume it was unclean.
645                 */
646                 if (WIFSIGNALED(status)) {
647                         unclean_shutdown = True;
648                 }
649                 remove_child_pid(parent, pid, unclean_shutdown);
650         }
651 }
652
653 static void smbd_setup_sig_chld_handler(struct smbd_parent_context *parent)
654 {
655         struct tevent_signal *se;
656
657         se = tevent_add_signal(parent->ev_ctx,
658                                parent, /* mem_ctx */
659                                SIGCHLD, 0,
660                                smbd_sig_chld_handler,
661                                parent);
662         if (!se) {
663                 exit_server("failed to setup SIGCHLD handler");
664         }
665 }
666
667 static void smbd_open_socket_close_fn(struct tevent_context *ev,
668                                       struct tevent_fd *fde,
669                                       int fd,
670                                       void *private_data)
671 {
672         /* this might be the socket_wrapper swrap_close() */
673         close(fd);
674 }
675
676 static void smbd_accept_connection(struct tevent_context *ev,
677                                    struct tevent_fd *fde,
678                                    uint16_t flags,
679                                    void *private_data)
680 {
681         struct smbd_open_socket *s = talloc_get_type_abort(private_data,
682                                      struct smbd_open_socket);
683         struct messaging_context *msg_ctx = s->parent->msg_ctx;
684         struct sockaddr_storage addr;
685         socklen_t in_addrlen = sizeof(addr);
686         int fd;
687         pid_t pid = 0;
688
689         fd = accept(s->fd, (struct sockaddr *)(void *)&addr,&in_addrlen);
690         if (fd == -1 && errno == EINTR)
691                 return;
692
693         if (fd == -1) {
694                 DEBUG(0,("accept: %s\n",
695                          strerror(errno)));
696                 return;
697         }
698
699         if (s->parent->interactive) {
700                 reinit_after_fork(msg_ctx, ev, true, NULL);
701                 smbd_process(ev, msg_ctx, fd, true);
702                 exit_server_cleanly("end of interactive mode");
703                 return;
704         }
705
706         if (!allowable_number_of_smbd_processes(s->parent)) {
707                 close(fd);
708                 return;
709         }
710
711         pid = fork();
712         if (pid == 0) {
713                 NTSTATUS status = NT_STATUS_OK;
714
715                 /*
716                  * Can't use TALLOC_FREE here. Nulling out the argument to it
717                  * would overwrite memory we've just freed.
718                  */
719                 talloc_free(s->parent);
720                 s = NULL;
721
722                 /* Stop zombies, the parent explicitly handles
723                  * them, counting worker smbds. */
724                 CatchChild();
725
726                 status = smbd_reinit_after_fork(msg_ctx, ev, true, NULL);
727                 if (!NT_STATUS_IS_OK(status)) {
728                         if (NT_STATUS_EQUAL(status,
729                                             NT_STATUS_TOO_MANY_OPENED_FILES)) {
730                                 DEBUG(0,("child process cannot initialize "
731                                          "because too many files are open\n"));
732                                 goto exit;
733                         }
734                         if (lp_clustering() &&
735                             NT_STATUS_EQUAL(status,
736                             NT_STATUS_INTERNAL_DB_ERROR)) {
737                                 DEBUG(1,("child process cannot initialize "
738                                          "because connection to CTDB "
739                                          "has failed\n"));
740                                 goto exit;
741                         }
742
743                         DEBUG(0,("reinit_after_fork() failed\n"));
744                         smb_panic("reinit_after_fork() failed");
745                 }
746
747                 smbd_process(ev, msg_ctx, fd, false);
748          exit:
749                 exit_server_cleanly("end of child");
750                 return;
751         }
752
753         if (pid < 0) {
754                 DEBUG(0,("smbd_accept_connection: fork() failed: %s\n",
755                          strerror(errno)));
756         }
757
758         /* The parent doesn't need this socket */
759         close(fd);
760
761         /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
762                 Clear the closed fd info out of server_fd --
763                 and more importantly, out of client_fd in
764                 util_sock.c, to avoid a possible
765                 getpeername failure if we reopen the logs
766                 and use %I in the filename.
767         */
768
769         if (pid != 0) {
770                 add_child_pid(s->parent, pid);
771         }
772
773         /* Force parent to check log size after
774          * spawning child.  Fix from
775          * klausr@ITAP.Physik.Uni-Stuttgart.De.  The
776          * parent smbd will log to logserver.smb.  It
777          * writes only two messages for each child
778          * started/finished. But each child writes,
779          * say, 50 messages also in logserver.smb,
780          * begining with the debug_count of the
781          * parent, before the child opens its own log
782          * file logserver.client. In a worst case
783          * scenario the size of logserver.smb would be
784          * checked after about 50*50=2500 messages
785          * (ca. 100kb).
786          * */
787         force_check_log_size();
788 }
789
790 static bool smbd_open_one_socket(struct smbd_parent_context *parent,
791                                  struct tevent_context *ev_ctx,
792                                  const struct sockaddr_storage *ifss,
793                                  uint16_t port)
794 {
795         struct smbd_open_socket *s;
796
797         s = talloc(parent, struct smbd_open_socket);
798         if (!s) {
799                 return false;
800         }
801
802         s->parent = parent;
803         s->fd = open_socket_in(SOCK_STREAM,
804                                port,
805                                parent->sockets == NULL ? 0 : 2,
806                                ifss,
807                                true);
808         if (s->fd == -1) {
809                 DEBUG(0,("smbd_open_one_socket: open_socket_in: "
810                         "%s\n", strerror(errno)));
811                 TALLOC_FREE(s);
812                 /*
813                  * We ignore an error here, as we've done before
814                  */
815                 return true;
816         }
817
818         /* ready to listen */
819         set_socket_options(s->fd, "SO_KEEPALIVE");
820         set_socket_options(s->fd, lp_socket_options());
821
822         /* Set server socket to
823          * non-blocking for the accept. */
824         set_blocking(s->fd, False);
825
826         if (listen(s->fd, SMBD_LISTEN_BACKLOG) == -1) {
827                 DEBUG(0,("smbd_open_one_socket: listen: "
828                         "%s\n", strerror(errno)));
829                         close(s->fd);
830                 TALLOC_FREE(s);
831                 return false;
832         }
833
834         s->fde = tevent_add_fd(ev_ctx,
835                                s,
836                                s->fd, TEVENT_FD_READ,
837                                smbd_accept_connection,
838                                s);
839         if (!s->fde) {
840                 DEBUG(0,("smbd_open_one_socket: "
841                          "tevent_add_fd: %s\n",
842                          strerror(errno)));
843                 close(s->fd);
844                 TALLOC_FREE(s);
845                 return false;
846         }
847         tevent_fd_set_close_fn(s->fde, smbd_open_socket_close_fn);
848
849         DLIST_ADD_END(parent->sockets, s);
850
851         return true;
852 }
853
854 /****************************************************************************
855  Open the socket communication.
856 ****************************************************************************/
857
858 static bool open_sockets_smbd(struct smbd_parent_context *parent,
859                               struct tevent_context *ev_ctx,
860                               struct messaging_context *msg_ctx,
861                               const char *smb_ports)
862 {
863         int num_interfaces = iface_count();
864         int i,j;
865         const char **ports;
866         unsigned dns_port = 0;
867
868 #ifdef HAVE_ATEXIT
869         atexit(killkids);
870 #endif
871
872         /* Stop zombies */
873         smbd_setup_sig_chld_handler(parent);
874
875         ports = lp_smb_ports();
876
877         /* use a reasonable default set of ports - listing on 445 and 139 */
878         if (smb_ports) {
879                 char **l;
880                 l = str_list_make_v3(talloc_tos(), smb_ports, NULL);
881                 ports = discard_const_p(const char *, l);
882         }
883
884         for (j = 0; ports && ports[j]; j++) {
885                 unsigned port = atoi(ports[j]);
886
887                 if (port == 0 || port > 0xffff) {
888                         exit_server_cleanly("Invalid port in the config or on "
889                                             "the commandline specified!");
890                 }
891         }
892
893         if (lp_interfaces() && lp_bind_interfaces_only()) {
894                 /* We have been given an interfaces line, and been
895                    told to only bind to those interfaces. Create a
896                    socket per interface and bind to only these.
897                 */
898
899                 /* Now open a listen socket for each of the
900                    interfaces. */
901                 for(i = 0; i < num_interfaces; i++) {
902                         const struct sockaddr_storage *ifss =
903                                         iface_n_sockaddr_storage(i);
904                         if (ifss == NULL) {
905                                 DEBUG(0,("open_sockets_smbd: "
906                                         "interface %d has NULL IP address !\n",
907                                         i));
908                                 continue;
909                         }
910
911                         for (j = 0; ports && ports[j]; j++) {
912                                 unsigned port = atoi(ports[j]);
913
914                                 /* Keep the first port for mDNS service
915                                  * registration.
916                                  */
917                                 if (dns_port == 0) {
918                                         dns_port = port;
919                                 }
920
921                                 if (!smbd_open_one_socket(parent,
922                                                           ev_ctx,
923                                                           ifss,
924                                                           port)) {
925                                         return false;
926                                 }
927                         }
928                 }
929         } else {
930                 /* Just bind to 0.0.0.0 - accept connections
931                    from anywhere. */
932
933                 const char *sock_addr;
934                 char *sock_tok;
935                 const char *sock_ptr;
936
937 #if HAVE_IPV6
938                 sock_addr = "::,0.0.0.0";
939 #else
940                 sock_addr = "0.0.0.0";
941 #endif
942
943                 for (sock_ptr=sock_addr;
944                      next_token_talloc(talloc_tos(), &sock_ptr, &sock_tok, " \t,"); ) {
945                         for (j = 0; ports && ports[j]; j++) {
946                                 struct sockaddr_storage ss;
947                                 unsigned port = atoi(ports[j]);
948
949                                 /* Keep the first port for mDNS service
950                                  * registration.
951                                  */
952                                 if (dns_port == 0) {
953                                         dns_port = port;
954                                 }
955
956                                 /* open an incoming socket */
957                                 if (!interpret_string_addr(&ss, sock_tok,
958                                                 AI_NUMERICHOST|AI_PASSIVE)) {
959                                         continue;
960                                 }
961
962                                 /*
963                                  * If we fail to open any sockets
964                                  * in this loop the parent-sockets == NULL
965                                  * case below will prevent us from starting.
966                                  */
967
968                                 (void)smbd_open_one_socket(parent,
969                                                   ev_ctx,
970                                                   &ss,
971                                                   port);
972                         }
973                 }
974         }
975
976         if (parent->sockets == NULL) {
977                 DEBUG(0,("open_sockets_smbd: No "
978                         "sockets available to bind to.\n"));
979                 return false;
980         }
981
982         /* Setup the main smbd so that we can get messages. Note that
983            do this after starting listening. This is needed as when in
984            clustered mode, ctdb won't allow us to start doing database
985            operations until it has gone thru a full startup, which
986            includes checking to see that smbd is listening. */
987
988         if (!serverid_register(messaging_server_id(msg_ctx),
989                                FLAG_MSG_GENERAL|FLAG_MSG_SMBD
990                                |FLAG_MSG_PRINT_GENERAL
991                                |FLAG_MSG_DBWRAP)) {
992                 DEBUG(0, ("open_sockets_smbd: Failed to register "
993                           "myself in serverid.tdb\n"));
994                 return false;
995         }
996
997         /* Listen to messages */
998
999         messaging_register(msg_ctx, NULL, MSG_SHUTDOWN, msg_exit_server);
1000         messaging_register(msg_ctx, ev_ctx, MSG_SMB_CONF_UPDATED,
1001                            smbd_parent_conf_updated);
1002         messaging_register(msg_ctx, NULL, MSG_SMB_STAT_CACHE_DELETE,
1003                            smb_stat_cache_delete);
1004         messaging_register(msg_ctx, NULL, MSG_DEBUG, smbd_msg_debug);
1005         messaging_register(msg_ctx, NULL, MSG_SMB_FORCE_TDIS,
1006                            smb_parent_send_to_children);
1007         messaging_register(msg_ctx, NULL, MSG_SMB_KILL_CLIENT_IP,
1008                            smb_parent_send_to_children);
1009         messaging_register(msg_ctx, NULL, MSG_SMB_TELL_NUM_CHILDREN,
1010                            smb_tell_num_children);
1011
1012         messaging_register(msg_ctx, NULL,
1013                            ID_CACHE_DELETE, smbd_parent_id_cache_delete);
1014         messaging_register(msg_ctx, NULL,
1015                            ID_CACHE_KILL, smbd_parent_id_cache_kill);
1016
1017 #ifdef CLUSTER_SUPPORT
1018         if (lp_clustering()) {
1019                 struct ctdbd_connection *conn = messaging_ctdbd_connection();
1020
1021                 register_with_ctdbd(conn, CTDB_SRVID_RECONFIGURE,
1022                                     smbd_parent_ctdb_reconfigured, msg_ctx);
1023                 register_with_ctdbd(conn, CTDB_SRVID_SAMBA_NOTIFY,
1024                                     smbd_parent_ctdb_reconfigured, msg_ctx);
1025         }
1026 #endif
1027
1028 #ifdef DEVELOPER
1029         messaging_register(msg_ctx, NULL, MSG_SMB_INJECT_FAULT,
1030                            msg_inject_fault);
1031 #endif
1032
1033         if (lp_multicast_dns_register() && (dns_port != 0)) {
1034 #ifdef WITH_DNSSD_SUPPORT
1035                 smbd_setup_mdns_registration(ev_ctx,
1036                                              parent, dns_port);
1037 #endif
1038 #ifdef WITH_AVAHI_SUPPORT
1039                 void *avahi_conn;
1040
1041                 avahi_conn = avahi_start_register(ev_ctx,
1042                                                   ev_ctx,
1043                                                   dns_port);
1044                 if (avahi_conn == NULL) {
1045                         DEBUG(10, ("avahi_start_register failed\n"));
1046                 }
1047 #endif
1048         }
1049
1050         return true;
1051 }
1052
1053
1054 /*
1055   handle stdin becoming readable when we are in --foreground mode
1056  */
1057 static void smbd_stdin_handler(struct tevent_context *ev,
1058                                struct tevent_fd *fde,
1059                                uint16_t flags,
1060                                void *private_data)
1061 {
1062         char c;
1063         if (read(0, &c, 1) != 1) {
1064                 /* we have reached EOF on stdin, which means the
1065                    parent has exited. Shutdown the server */
1066                 exit_server_cleanly("EOF on stdin");
1067         }
1068 }
1069
1070 struct smbd_parent_tevent_trace_state {
1071         TALLOC_CTX *frame;
1072 };
1073
1074 static void smbd_parent_tevent_trace_callback(enum tevent_trace_point point,
1075                                               void *private_data)
1076 {
1077         struct smbd_parent_tevent_trace_state *state =
1078                 (struct smbd_parent_tevent_trace_state *)private_data;
1079
1080         switch (point) {
1081         case TEVENT_TRACE_BEFORE_WAIT:
1082                 break;
1083         case TEVENT_TRACE_AFTER_WAIT:
1084                 break;
1085         case TEVENT_TRACE_BEFORE_LOOP_ONCE:
1086                 TALLOC_FREE(state->frame);
1087                 state->frame = talloc_stackframe();
1088                 break;
1089         case TEVENT_TRACE_AFTER_LOOP_ONCE:
1090                 TALLOC_FREE(state->frame);
1091                 break;
1092         }
1093
1094         errno = 0;
1095 }
1096
1097 static void smbd_parent_loop(struct tevent_context *ev_ctx,
1098                              struct smbd_parent_context *parent)
1099 {
1100         struct smbd_parent_tevent_trace_state trace_state = {
1101                 .frame = NULL,
1102         };
1103         int ret = 0;
1104
1105         tevent_set_trace_callback(ev_ctx, smbd_parent_tevent_trace_callback,
1106                                   &trace_state);
1107
1108         /* now accept incoming connections - forking a new process
1109            for each incoming connection */
1110         DEBUG(2,("waiting for connections\n"));
1111
1112         ret = tevent_loop_wait(ev_ctx);
1113         if (ret != 0) {
1114                 DEBUG(0, ("tevent_loop_wait failed: %d, %s, exiting\n",
1115                           ret, strerror(errno)));
1116         }
1117
1118         TALLOC_FREE(trace_state.frame);
1119
1120 /* NOTREACHED   return True; */
1121 }
1122
1123
1124 /****************************************************************************
1125  Initialise connect, service and file structs.
1126 ****************************************************************************/
1127
1128 static bool init_structs(void )
1129 {
1130         /*
1131          * Set the machine NETBIOS name if not already
1132          * set from the config file.
1133          */
1134
1135         if (!init_names())
1136                 return False;
1137
1138         if (!secrets_init())
1139                 return False;
1140
1141         return True;
1142 }
1143
1144 static void smbd_parent_sig_term_handler(struct tevent_context *ev,
1145                                          struct tevent_signal *se,
1146                                          int signum,
1147                                          int count,
1148                                          void *siginfo,
1149                                          void *private_data)
1150 {
1151         exit_server_cleanly("termination signal");
1152 }
1153
1154 static void smbd_parent_sig_hup_handler(struct tevent_context *ev,
1155                                         struct tevent_signal *se,
1156                                         int signum,
1157                                         int count,
1158                                         void *siginfo,
1159                                         void *private_data)
1160 {
1161         struct smbd_parent_context *parent =
1162                 talloc_get_type_abort(private_data,
1163                 struct smbd_parent_context);
1164
1165         change_to_root_user();
1166         DEBUG(1,("parent: Reloading services after SIGHUP\n"));
1167         reload_services(NULL, NULL, false);
1168
1169         printing_subsystem_update(parent->ev_ctx, parent->msg_ctx, true);
1170 }
1171
1172 /****************************************************************************
1173  main program.
1174 ****************************************************************************/
1175
1176 /* Declare prototype for build_options() to avoid having to run it through
1177    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
1178    prototype generation system is too complicated. */
1179
1180 extern void build_options(bool screen);
1181
1182  int main(int argc,const char *argv[])
1183 {
1184         /* shall I run as a daemon */
1185         bool is_daemon = false;
1186         bool interactive = false;
1187         bool Fork = true;
1188         bool no_process_group = false;
1189         bool log_stdout = false;
1190         char *ports = NULL;
1191         char *profile_level = NULL;
1192         int opt;
1193         poptContext pc;
1194         bool print_build_options = False;
1195         enum {
1196                 OPT_DAEMON = 1000,
1197                 OPT_INTERACTIVE,
1198                 OPT_FORK,
1199                 OPT_NO_PROCESS_GROUP,
1200                 OPT_LOG_STDOUT
1201         };
1202         struct poptOption long_options[] = {
1203         POPT_AUTOHELP
1204         {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
1205         {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
1206         {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
1207         {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
1208         {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
1209         {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
1210         {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
1211         {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
1212         POPT_COMMON_SAMBA
1213         POPT_TABLEEND
1214         };
1215         struct smbd_parent_context *parent = NULL;
1216         TALLOC_CTX *frame;
1217         NTSTATUS status;
1218         struct tevent_context *ev_ctx;
1219         struct messaging_context *msg_ctx;
1220         struct server_id server_id;
1221         struct tevent_signal *se;
1222         int profiling_level;
1223         char *np_dir = NULL;
1224         static const struct smbd_shim smbd_shim_fns =
1225         {
1226                 .cancel_pending_lock_requests_by_fid = smbd_cancel_pending_lock_requests_by_fid,
1227                 .send_stat_cache_delete_message = smbd_send_stat_cache_delete_message,
1228                 .change_to_root_user = smbd_change_to_root_user,
1229                 .become_authenticated_pipe_user = smbd_become_authenticated_pipe_user,
1230                 .unbecome_authenticated_pipe_user = smbd_unbecome_authenticated_pipe_user,
1231
1232                 .contend_level2_oplocks_begin = smbd_contend_level2_oplocks_begin,
1233                 .contend_level2_oplocks_end = smbd_contend_level2_oplocks_end,
1234
1235                 .become_root = smbd_become_root,
1236                 .unbecome_root = smbd_unbecome_root,
1237
1238                 .exit_server = smbd_exit_server,
1239                 .exit_server_cleanly = smbd_exit_server_cleanly,
1240         };
1241
1242         /*
1243          * Do this before any other talloc operation
1244          */
1245         talloc_enable_null_tracking();
1246         frame = talloc_stackframe();
1247
1248         setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
1249
1250         smb_init_locale();
1251
1252         set_smbd_shim(&smbd_shim_fns);
1253
1254         smbd_init_globals();
1255
1256         TimeInit();
1257
1258 #ifdef HAVE_SET_AUTH_PARAMETERS
1259         set_auth_parameters(argc,argv);
1260 #endif
1261
1262         pc = poptGetContext("smbd", argc, argv, long_options, 0);
1263         while((opt = poptGetNextOpt(pc)) != -1) {
1264                 switch (opt)  {
1265                 case OPT_DAEMON:
1266                         is_daemon = true;
1267                         break;
1268                 case OPT_INTERACTIVE:
1269                         interactive = true;
1270                         break;
1271                 case OPT_FORK:
1272                         Fork = false;
1273                         break;
1274                 case OPT_NO_PROCESS_GROUP:
1275                         no_process_group = true;
1276                         break;
1277                 case OPT_LOG_STDOUT:
1278                         log_stdout = true;
1279                         break;
1280                 case 'b':
1281                         print_build_options = True;
1282                         break;
1283                 default:
1284                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1285                                   poptBadOption(pc, 0), poptStrerror(opt));
1286                         poptPrintUsage(pc, stderr, 0);
1287                         exit(1);
1288                 }
1289         }
1290         poptFreeContext(pc);
1291
1292         if (interactive) {
1293                 Fork = False;
1294                 log_stdout = True;
1295         }
1296
1297         if (log_stdout) {
1298                 setup_logging(argv[0], DEBUG_STDOUT);
1299         } else {
1300                 setup_logging(argv[0], DEBUG_FILE);
1301         }
1302
1303         if (print_build_options) {
1304                 build_options(True); /* Display output to screen as well as debug */
1305                 exit(0);
1306         }
1307
1308 #ifdef HAVE_SETLUID
1309         /* needed for SecureWare on SCO */
1310         setluid(0);
1311 #endif
1312
1313         set_remote_machine_name("smbd", False);
1314
1315         if (interactive && (DEBUGLEVEL >= 9)) {
1316                 talloc_enable_leak_report();
1317         }
1318
1319         if (log_stdout && Fork) {
1320                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1321                 exit(1);
1322         }
1323
1324         /*
1325          * We want to die early if we can't open /dev/urandom
1326          */
1327         generate_random_buffer(NULL, 0);
1328
1329         /* get initial effective uid and gid */
1330         sec_init();
1331
1332         /* make absolutely sure we run as root - to handle cases where people
1333            are crazy enough to have it setuid */
1334         gain_root_privilege();
1335         gain_root_group_privilege();
1336
1337         fault_setup();
1338         dump_core_setup("smbd", lp_logfile(talloc_tos()));
1339
1340         /* we are never interested in SIGPIPE */
1341         BlockSignals(True,SIGPIPE);
1342
1343 #if defined(SIGFPE)
1344         /* we are never interested in SIGFPE */
1345         BlockSignals(True,SIGFPE);
1346 #endif
1347
1348 #if defined(SIGUSR2)
1349         /* We are no longer interested in USR2 */
1350         BlockSignals(True,SIGUSR2);
1351 #endif
1352
1353         /* POSIX demands that signals are inherited. If the invoking process has
1354          * these signals masked, we will have problems, as we won't recieve them. */
1355         BlockSignals(False, SIGHUP);
1356         BlockSignals(False, SIGUSR1);
1357         BlockSignals(False, SIGTERM);
1358
1359         /* Ensure we leave no zombies until we
1360          * correctly set up child handling below. */
1361
1362         CatchChild();
1363
1364         /* we want total control over the permissions on created files,
1365            so set our umask to 0 */
1366         umask(0);
1367
1368         reopen_logs();
1369
1370         DEBUG(0,("smbd version %s started.\n", samba_version_string()));
1371         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1372
1373         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1374                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1375
1376         /* Output the build options to the debug log */ 
1377         build_options(False);
1378
1379         if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4) {
1380                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1381                 exit(1);
1382         }
1383
1384         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1385                 DEBUG(0, ("error opening config file '%s'\n", get_dyn_CONFIGFILE()));
1386                 exit(1);
1387         }
1388
1389         if (!cluster_probe_ok()) {
1390                 exit(1);
1391         }
1392
1393         /* Init the security context and global current_user */
1394         init_sec_ctx();
1395
1396         /*
1397          * Initialize the event context. The event context needs to be
1398          * initialized before the messaging context, cause the messaging
1399          * context holds an event context.
1400          * FIXME: This should be s3_tevent_context_init()
1401          */
1402         ev_ctx = server_event_context();
1403         if (ev_ctx == NULL) {
1404                 exit(1);
1405         }
1406
1407         /*
1408          * Init the messaging context
1409          * FIXME: This should only call messaging_init()
1410          */
1411         msg_ctx = server_messaging_context();
1412         if (msg_ctx == NULL) {
1413                 exit(1);
1414         }
1415
1416         /*
1417          * Reloading of the printers will not work here as we don't have a
1418          * server info and rpc services set up. It will be called later.
1419          */
1420         if (!reload_services(NULL, NULL, false)) {
1421                 exit(1);
1422         }
1423
1424         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
1425             && !lp_parm_bool(-1, "server role check", "inhibit", false)) {
1426                 DEBUG(0, ("server role = 'active directory domain controller' not compatible with running smbd standalone. \n"));
1427                 DEBUGADD(0, ("You should start 'samba' instead, and it will control starting smbd if required\n"));
1428                 exit(1);
1429         }
1430
1431         /* ...NOTE... Log files are working from this point! */
1432
1433         DEBUG(3,("loaded services\n"));
1434
1435         init_structs();
1436
1437         if (!profile_setup(msg_ctx, False)) {
1438                 DEBUG(0,("ERROR: failed to setup profiling\n"));
1439                 return -1;
1440         }
1441
1442         if (profile_level != NULL) {
1443                 profiling_level = atoi(profile_level);
1444         } else {
1445                 profiling_level = lp_smbd_profiling_level();
1446         }
1447         set_profile_level(profiling_level, messaging_server_id(msg_ctx));
1448
1449         if (!is_daemon && !is_a_socket(0)) {
1450                 if (!interactive) {
1451                         DEBUG(3, ("Standard input is not a socket, "
1452                                   "assuming -D option\n"));
1453                 }
1454
1455                 /*
1456                  * Setting is_daemon here prevents us from eventually calling
1457                  * the open_sockets_inetd()
1458                  */
1459
1460                 is_daemon = True;
1461         }
1462
1463         if (is_daemon && !interactive) {
1464                 DEBUG(3, ("Becoming a daemon.\n"));
1465                 become_daemon(Fork, no_process_group, log_stdout);
1466         }
1467
1468 #if HAVE_SETPGID
1469         /*
1470          * If we're interactive we want to set our own process group for
1471          * signal management.
1472          */
1473         if (interactive && !no_process_group)
1474                 setpgid( (pid_t)0, (pid_t)0);
1475 #endif
1476
1477         if (!directory_exist(lp_lock_directory()))
1478                 mkdir(lp_lock_directory(), 0755);
1479
1480         if (!directory_exist(lp_pid_directory()))
1481                 mkdir(lp_pid_directory(), 0755);
1482
1483         if (is_daemon)
1484                 pidfile_create(lp_pid_directory(), "smbd");
1485
1486         status = reinit_after_fork(msg_ctx, ev_ctx, false, NULL);
1487         if (!NT_STATUS_IS_OK(status)) {
1488                 exit_daemon("reinit_after_fork() failed", map_errno_from_nt_status(status));
1489         }
1490
1491         if (!interactive) {
1492                 /*
1493                  * Do not initialize the parent-child-pipe before becoming a
1494                  * daemon: this is used to detect a died parent in the child
1495                  * process.
1496                  */
1497                 status = init_before_fork();
1498                 if (!NT_STATUS_IS_OK(status)) {
1499                         exit_daemon(nt_errstr(status), map_errno_from_nt_status(status));
1500                 }
1501         }
1502
1503         parent = talloc_zero(ev_ctx, struct smbd_parent_context);
1504         if (!parent) {
1505                 exit_server("talloc(struct smbd_parent_context) failed");
1506         }
1507         parent->interactive = interactive;
1508         parent->ev_ctx = ev_ctx;
1509         parent->msg_ctx = msg_ctx;
1510         am_parent = parent;
1511
1512         se = tevent_add_signal(parent->ev_ctx,
1513                                parent,
1514                                SIGTERM, 0,
1515                                smbd_parent_sig_term_handler,
1516                                parent);
1517         if (!se) {
1518                 exit_server("failed to setup SIGTERM handler");
1519         }
1520         se = tevent_add_signal(parent->ev_ctx,
1521                                parent,
1522                                SIGHUP, 0,
1523                                smbd_parent_sig_hup_handler,
1524                                parent);
1525         if (!se) {
1526                 exit_server("failed to setup SIGHUP handler");
1527         }
1528
1529         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1530
1531         if (smbd_memcache() == NULL) {
1532                 exit_daemon("no memcache available", EACCES);
1533         }
1534
1535         memcache_set_global(smbd_memcache());
1536
1537         /* Initialise the password backed before the global_sam_sid
1538            to ensure that we fetch from ldap before we make a domain sid up */
1539
1540         if(!initialize_password_db(false, ev_ctx))
1541                 exit(1);
1542
1543         if (!secrets_init()) {
1544                 exit_daemon("smbd can not open secrets.tdb", EACCES);
1545         }
1546
1547         if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC) {
1548                 struct loadparm_context *lp_ctx = loadparm_init_s3(NULL, loadparm_s3_helpers());
1549                 if (!open_schannel_session_store(NULL, lp_ctx)) {
1550                         exit_daemon("ERROR: Samba cannot open schannel store for secured NETLOGON operations.", EACCES);
1551                 }
1552                 TALLOC_FREE(lp_ctx);
1553         }
1554
1555         if(!get_global_sam_sid()) {
1556                 exit_daemon("Samba cannot create a SAM SID", EACCES);
1557         }
1558
1559         server_id = messaging_server_id(msg_ctx);
1560         status = smbXsrv_version_global_init(&server_id);
1561         if (!NT_STATUS_IS_OK(status)) {
1562                 exit_daemon("Samba cannot init server context", EACCES);
1563         }
1564
1565         status = smbXsrv_session_global_init();
1566         if (!NT_STATUS_IS_OK(status)) {
1567                 exit_daemon("Samba cannot init session context", EACCES);
1568         }
1569
1570         status = smbXsrv_tcon_global_init();
1571         if (!NT_STATUS_IS_OK(status)) {
1572                 exit_daemon("Samba cannot init tcon context", EACCES);
1573         }
1574
1575         if (!locking_init())
1576                 exit_daemon("Samba cannot init locking", EACCES);
1577
1578         if (!leases_db_init(false)) {
1579                 exit_daemon("Samba cannot init leases", EACCES);
1580         }
1581
1582         if (!smbd_notifyd_init(msg_ctx, interactive)) {
1583                 exit_daemon("Samba cannot init notification", EACCES);
1584         }
1585
1586         if (!cleanupd_init(msg_ctx, interactive, &parent->cleanupd)) {
1587                 exit_daemon("Samba cannot init the cleanupd", EACCES);
1588         }
1589
1590         if (!messaging_parent_dgm_cleanup_init(msg_ctx)) {
1591                 exit(1);
1592         }
1593
1594         if (!smbd_scavenger_init(NULL, msg_ctx, ev_ctx)) {
1595                 exit_daemon("Samba cannot init scavenging", EACCES);
1596         }
1597
1598         if (!serverid_parent_init(ev_ctx)) {
1599                 exit_daemon("Samba cannot init server id", EACCES);
1600         }
1601
1602         if (!W_ERROR_IS_OK(registry_init_full()))
1603                 exit_daemon("Samba cannot init registry", EACCES);
1604
1605         /* Open the share_info.tdb here, so we don't have to open
1606            after the fork on every single connection.  This is a small
1607            performance improvment and reduces the total number of system
1608            fds used. */
1609         if (!share_info_db_init()) {
1610                 exit_daemon("ERROR: failed to load share info db.", EACCES);
1611         }
1612
1613         status = init_system_session_info();
1614         if (!NT_STATUS_IS_OK(status)) {
1615                 DEBUG(1, ("ERROR: failed to setup system user info: %s.\n",
1616                           nt_errstr(status)));
1617                 return -1;
1618         }
1619
1620         if (!init_guest_info()) {
1621                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1622                 return -1;
1623         }
1624
1625         if (!file_init_global()) {
1626                 DEBUG(0, ("ERROR: file_init_global() failed\n"));
1627                 return -1;
1628         }
1629         status = smbXsrv_open_global_init();
1630         if (!NT_STATUS_IS_OK(status)) {
1631                 exit_daemon("Samba cannot init global open", map_errno_from_nt_status(status));
1632         }
1633
1634         /* This MUST be done before start_epmd() because otherwise
1635          * start_epmd() forks and races against dcesrv_ep_setup() to
1636          * call directory_create_or_exist() */
1637         if (!directory_create_or_exist(lp_ncalrpc_dir(), 0755)) {
1638                 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
1639                           lp_ncalrpc_dir(), strerror(errno)));
1640                 return -1;
1641         }
1642
1643         np_dir = talloc_asprintf(talloc_tos(), "%s/np", lp_ncalrpc_dir());
1644         if (!np_dir) {
1645                 DEBUG(0, ("%s: Out of memory\n", __location__));
1646                 return -1;
1647         }
1648
1649         if (!directory_create_or_exist_strict(np_dir, geteuid(), 0700)) {
1650                 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
1651                           np_dir, strerror(errno)));
1652                 return -1;
1653         }
1654
1655         if (is_daemon && !interactive) {
1656                 if (rpc_epmapper_daemon() == RPC_DAEMON_FORK) {
1657                         start_epmd(ev_ctx, msg_ctx);
1658                 }
1659         }
1660
1661         if (!dcesrv_ep_setup(ev_ctx, msg_ctx)) {
1662                 exit_daemon("Samba cannot setup ep pipe", EACCES);
1663         }
1664
1665         if (is_daemon && !interactive) {
1666                 daemon_ready("smbd");
1667         }
1668
1669         /* only start other daemons if we are running as a daemon
1670          * -- bad things will happen if smbd is launched via inetd
1671          *  and we fork a copy of ourselves here */
1672         if (is_daemon && !interactive) {
1673
1674                 if (rpc_lsasd_daemon() == RPC_DAEMON_FORK) {
1675                         start_lsasd(ev_ctx, msg_ctx);
1676                 }
1677
1678                 if (rpc_fss_daemon() == RPC_DAEMON_FORK) {
1679                         start_fssd(ev_ctx, msg_ctx);
1680                 }
1681
1682                 if (!lp__disable_spoolss() &&
1683                     (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
1684                         bool bgq = lp_parm_bool(-1, "smbd", "backgroundqueue", true);
1685
1686                         if (!printing_subsystem_init(ev_ctx, msg_ctx, true, bgq)) {
1687                                 exit_daemon("Samba failed to init printing subsystem", EACCES);
1688                         }
1689                 }
1690
1691 #ifdef WITH_SPOTLIGHT
1692                 if ((rpc_mdssvc_mode() == RPC_SERVICE_MODE_EXTERNAL) &&
1693                     (rpc_mdssd_daemon() == RPC_DAEMON_FORK)) {
1694                         start_mdssd(ev_ctx, msg_ctx);
1695                 }
1696 #endif
1697         } else if (!lp__disable_spoolss() &&
1698                    (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
1699                 if (!printing_subsystem_init(ev_ctx, msg_ctx, false, false)) {
1700                         exit(1);
1701                 }
1702         }
1703
1704         if (!is_daemon) {
1705                 int sock;
1706
1707                 /* inetd mode */
1708                 TALLOC_FREE(frame);
1709
1710                 /* Started from inetd. fd 0 is the socket. */
1711                 /* We will abort gracefully when the client or remote system
1712                    goes away */
1713                 sock = dup(0);
1714
1715                 /* close stdin, stdout (if not logging to it), but not stderr */
1716                 close_low_fds(true, !debug_get_output_is_stdout(), false);
1717
1718 #ifdef HAVE_ATEXIT
1719                 atexit(killkids);
1720 #endif
1721
1722                 /* Stop zombies */
1723                 smbd_setup_sig_chld_handler(parent);
1724
1725                 smbd_process(ev_ctx, msg_ctx, sock, true);
1726
1727                 exit_server_cleanly(NULL);
1728                 return(0);
1729         }
1730
1731         if (!open_sockets_smbd(parent, ev_ctx, msg_ctx, ports))
1732                 exit_server("open_sockets_smbd() failed");
1733
1734         /* do a printer update now that all messaging has been set up,
1735          * before we allow clients to start connecting */
1736         if (!lp__disable_spoolss() &&
1737             (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
1738                 printing_subsystem_update(ev_ctx, msg_ctx, false);
1739         }
1740
1741         TALLOC_FREE(frame);
1742         /* make sure we always have a valid stackframe */
1743         frame = talloc_stackframe();
1744
1745         if (!Fork) {
1746                 /* if we are running in the foreground then look for
1747                    EOF on stdin, and exit if it happens. This allows
1748                    us to die if the parent process dies
1749                    Only do this on a pipe or socket, no other device.
1750                 */
1751                 struct stat st;
1752                 if (fstat(0, &st) != 0) {
1753                         return false;
1754                 }
1755                 if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
1756                         tevent_add_fd(ev_ctx,
1757                                         parent,
1758                                         0,
1759                                         TEVENT_FD_READ,
1760                                         smbd_stdin_handler,
1761                                         NULL);
1762                 }
1763         }
1764
1765         smbd_parent_loop(ev_ctx, parent);
1766
1767         exit_server_cleanly(NULL);
1768         TALLOC_FREE(frame);
1769         return(0);
1770 }