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