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