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