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_self(FLAG_MSG_GENERAL|FLAG_MSG_SMBD
 428                                             |FLAG_MSG_DBWRAP
 429                                             |FLAG_MSG_PRINT_GENERAL)) {
 430                         exit_server_cleanly("Could not register myself in "
 431                                             "serverid.tdb");
 432                 }
 433
 434                 smbd_process();
 435          exit:
 436                 exit_server_cleanly("end of child");
 437                 return;
 438         } else if (pid < 0) {
 439                 DEBUG(0,("smbd_accept_connection: sys_fork() failed: %s\n",
 440                          strerror(errno)));
 441         }
 442
 443         /* The parent doesn't need this socket */
 444         close(smbd_server_fd());
 445
 446         /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
 447                 Clear the closed fd info out of server_fd --
 448                 and more importantly, out of client_fd in
 449                 util_sock.c, to avoid a possible
 450                 getpeername failure if we reopen the logs
 451                 and use %I in the filename.
 452         */
 453
 454         smbd_set_server_fd(-1);
 455
 456         if (pid != 0) {
 457                 add_child_pid(pid);
 458         }
 459
 460         /* Force parent to check log size after
 461          * spawning child.  Fix from
 462          * klausr@ITAP.Physik.Uni-Stuttgart.De.  The
 463          * parent smbd will log to logserver.smb.  It
 464          * writes only two messages for each child
 465          * started/finished. But each child writes,
 466          * say, 50 messages also in logserver.smb,
 467          * begining with the debug_count of the
 468          * parent, before the child opens its own log
 469          * file logserver.client. In a worst case
 470          * scenario the size of logserver.smb would be
 471          * checked after about 50*50=2500 messages
 472          * (ca. 100kb).
 473          * */
 474         force_check_log_size();
 475 }
 476
 477 static bool smbd_open_one_socket(struct smbd_parent_context *parent,
 478                                  const struct sockaddr_storage *ifss,
 479                                  uint16_t port)
 480 {
 481         struct smbd_open_socket *s;
 482
 483         s = talloc(parent, struct smbd_open_socket);
 484         if (!s) {
 485                 return false;
 486         }
 487
 488         s->parent = parent;
 489         s->fd = open_socket_in(SOCK_STREAM,
 490                                port,
 491                                parent->sockets == NULL ? 0 : 2,
 492                                ifss,
 493                                true);
 494         if (s->fd == -1) {
 495                 DEBUG(0,("smbd_open_once_socket: open_socket_in: "
 496                         "%s\n", strerror(errno)));
 497                 TALLOC_FREE(s);
 498                 /*
 499                  * We ignore an error here, as we've done before
 500                  */
 501                 return true;
 502         }
 503
 504         /* ready to listen */
 505         set_socket_options(s->fd, "SO_KEEPALIVE");
 506         set_socket_options(s->fd, lp_socket_options());
 507
 508         /* Set server socket to
 509          * non-blocking for the accept. */
 510         set_blocking(s->fd, False);
 511
 512         if (listen(s->fd, SMBD_LISTEN_BACKLOG) == -1) {
 513                 DEBUG(0,("open_sockets_smbd: listen: "
 514                         "%s\n", strerror(errno)));
 515                         close(s->fd);
 516                 TALLOC_FREE(s);
 517                 return false;
 518         }
 519
 520         s->fde = tevent_add_fd(smbd_event_context(),
 521                                s,
 522                                s->fd, TEVENT_FD_READ,
 523                                smbd_accept_connection,
 524                                s);
 525         if (!s->fde) {
 526                 DEBUG(0,("open_sockets_smbd: "
 527                          "tevent_add_fd: %s\n",
 528                          strerror(errno)));
 529                 close(s->fd);
 530                 TALLOC_FREE(s);
 531                 return false;
 532         }
 533         tevent_fd_set_close_fn(s->fde, smbd_open_socket_close_fn);
 534
 535         DLIST_ADD_END(parent->sockets, s, struct smbd_open_socket *);
 536
 537         return true;
 538 }
 539
 540 /****************************************************************************
 541  Open the socket communication.
 542 ****************************************************************************/
 543
 544 static bool open_sockets_smbd(struct smbd_parent_context *parent,
 545                               const char *smb_ports)
 546 {
 547         int num_interfaces = iface_count();
 548         int i;
 549         char *ports;
 550         unsigned dns_port = 0;
 551
 552 #ifdef HAVE_ATEXIT
 553         atexit(killkids);
 554 #endif
 555
 556         /* Stop zombies */
 557         smbd_setup_sig_chld_handler();
 558
 559         /* use a reasonable default set of ports - listing on 445 and 139 */
 560         if (!smb_ports) {
 561                 ports = lp_smb_ports();
 562                 if (!ports || !*ports) {
 563                         ports = talloc_strdup(talloc_tos(), SMB_PORTS);
 564                 } else {
 565                         ports = talloc_strdup(talloc_tos(), ports);
 566                 }
 567         } else {
 568                 ports = talloc_strdup(talloc_tos(), smb_ports);
 569         }
 570
 571         if (lp_interfaces() && lp_bind_interfaces_only()) {
 572                 /* We have been given an interfaces line, and been
 573                    told to only bind to those interfaces. Create a
 574                    socket per interface and bind to only these.
 575                 */
 576
 577                 /* Now open a listen socket for each of the
 578                    interfaces. */
 579                 for(i = 0; i < num_interfaces; i++) {
 580                         const struct sockaddr_storage *ifss =
 581                                         iface_n_sockaddr_storage(i);
 582                         char *tok;
 583                         const char *ptr;
 584
 585                         if (ifss == NULL) {
 586                                 DEBUG(0,("open_sockets_smbd: "
 587                                         "interface %d has NULL IP address !\n",
 588                                         i));
 589                                 continue;
 590                         }
 591
 592                         for (ptr=ports;
 593                              next_token_talloc(talloc_tos(),&ptr, &tok, " \t,");) {
 594                                 unsigned port = atoi(tok);
 595                                 if (port == 0 || port > 0xffff) {
 596                                         continue;
 597                                 }
 598
 599                                 if (!smbd_open_one_socket(parent, ifss, port)) {
 600                                         return false;
 601                                 }
 602                         }
 603                 }
 604         } else {
 605                 /* Just bind to 0.0.0.0 - accept connections
 606                    from anywhere. */
 607
 608                 char *tok;
 609                 const char *ptr;
 610                 const char *sock_addr = lp_socket_address();
 611                 char *sock_tok;
 612                 const char *sock_ptr;
 613
 614                 if (strequal(sock_addr, "0.0.0.0") ||
 615                     strequal(sock_addr, "::")) {
 616 #if HAVE_IPV6
 617                         sock_addr = "::,0.0.0.0";
 618 #else
 619                         sock_addr = "0.0.0.0";
 620 #endif
 621                 }
 622
 623                 for (sock_ptr=sock_addr;
 624                      next_token_talloc(talloc_tos(), &sock_ptr, &sock_tok, " \t,"); ) {
 625                         for (ptr=ports; next_token_talloc(talloc_tos(), &ptr, &tok, " \t,"); ) {
 626                                 struct sockaddr_storage ss;
 627
 628                                 unsigned port = atoi(tok);
 629                                 if (port == 0 || port > 0xffff) {
 630                                         continue;
 631                                 }
 632
 633                                 /* Keep the first port for mDNS service
 634                                  * registration.
 635                                  */
 636                                 if (dns_port == 0) {
 637                                         dns_port = port;
 638                                 }
 639
 640                                 /* open an incoming socket */
 641                                 if (!interpret_string_addr(&ss, sock_tok,
 642                                                 AI_NUMERICHOST|AI_PASSIVE)) {
 643                                         continue;
 644                                 }
 645
 646                                 if (!smbd_open_one_socket(parent, &ss, port)) {
 647                                         return false;
 648                                 }
 649                         }
 650                 }
 651         }
 652
 653         if (parent->sockets == NULL) {
 654                 DEBUG(0,("open_sockets_smbd: No "
 655                         "sockets available to bind to.\n"));
 656                 return false;
 657         }
 658
 659         /* Setup the main smbd so that we can get messages. Note that
 660            do this after starting listening. This is needed as when in
 661            clustered mode, ctdb won't allow us to start doing database
 662            operations until it has gone thru a full startup, which
 663            includes checking to see that smbd is listening. */
 664
 665         if (!serverid_register_self(FLAG_MSG_GENERAL|FLAG_MSG_SMBD
 666                                     |FLAG_MSG_DBWRAP)) {
 667                 DEBUG(0, ("open_sockets_smbd: Failed to register "
 668                           "myself in serverid.tdb\n"));
 669                 return false;
 670         }
 671
 672         /* Listen to messages */
 673
 674         messaging_register(smbd_messaging_context(), NULL,
 675                            MSG_SMB_SAM_SYNC, msg_sam_sync);
 676         messaging_register(smbd_messaging_context(), NULL,
 677                            MSG_SHUTDOWN, msg_exit_server);
 678         messaging_register(smbd_messaging_context(), NULL,
 679                            MSG_SMB_FILE_RENAME, msg_file_was_renamed);
 680         messaging_register(smbd_messaging_context(), NULL,
 681                            MSG_SMB_CONF_UPDATED, smb_conf_updated);
 682         messaging_register(smbd_messaging_context(), NULL,
 683                            MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
 684         messaging_register(smbd_messaging_context(), NULL,
 685                            MSG_DEBUG, smbd_msg_debug);
 686         brl_register_msgs(smbd_messaging_context());
 687
 688 #ifdef CLUSTER_SUPPORT
 689         if (lp_clustering()) {
 690                 ctdbd_register_reconfigure(messaging_ctdbd_connection());
 691         }
 692 #endif
 693
 694 #ifdef DEVELOPER
 695         messaging_register(smbd_messaging_context(), NULL,
 696                            MSG_SMB_INJECT_FAULT, msg_inject_fault);
 697 #endif
 698
 699         if (dns_port != 0) {
 700 #ifdef WITH_DNSSD_SUPPORT
 701                 smbd_setup_mdns_registration(smbd_event_context(),
 702                                              parent, dns_port);
 703 #endif
 704 #ifdef WITH_AVAHI_SUPPORT
 705                 void *avahi_conn;
 706
 707                 avahi_conn = avahi_start_register(
 708                         smbd_event_context(), smbd_event_context(), dns_port);
 709                 if (avahi_conn == NULL) {
 710                         DEBUG(10, ("avahi_start_register failed\n"));
 711                 }
 712 #endif
 713         }
 714
 715         return true;
 716 }
 717
 718 static void smbd_parent_loop(struct smbd_parent_context *parent)
 719 {
 720         /* now accept incoming connections - forking a new process
 721            for each incoming connection */
 722         DEBUG(2,("waiting for connections\n"));
 723         while (1) {
 724                 int ret;
 725                 TALLOC_CTX *frame = talloc_stackframe();
 726
 727                 ret = tevent_loop_once(smbd_event_context());
 728                 if (ret != 0) {
 729                         exit_server_cleanly("tevent_loop_once() error");
 730                 }
 731
 732                 TALLOC_FREE(frame);
 733         } /* end while 1 */
 734
 735 /* NOTREACHED   return True; */
 736 }
 737
 738
 739 /****************************************************************************
 740  Initialise connect, service and file structs.
 741 ****************************************************************************/
 742
 743 static bool init_structs(void )
 744 {
 745         /*
 746          * Set the machine NETBIOS name if not already
 747          * set from the config file.
 748          */
 749
 750         if (!init_names())
 751                 return False;
 752
 753         file_init();
 754
 755         if (!secrets_init())
 756                 return False;
 757
 758         return True;
 759 }
 760
 761 /****************************************************************************
 762  main program.
 763 ****************************************************************************/
 764
 765 /* Declare prototype for build_options() to avoid having to run it through
 766    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
 767    prototype generation system is too complicated. */
 768
 769 extern void build_options(bool screen);
 770
 771  int main(int argc,const char *argv[])
 772 {
 773         /* shall I run as a daemon */
 774         bool is_daemon = false;
 775         bool interactive = false;
 776         bool Fork = true;
 777         bool no_process_group = false;
 778         bool log_stdout = false;
 779         char *ports = NULL;
 780         char *profile_level = NULL;
 781         int opt;
 782         poptContext pc;
 783         bool print_build_options = False;
 784         enum {
 785                 OPT_DAEMON = 1000,
 786                 OPT_INTERACTIVE,
 787                 OPT_FORK,
 788                 OPT_NO_PROCESS_GROUP,
 789                 OPT_LOG_STDOUT
 790         };
 791         struct poptOption long_options[] = {
 792         POPT_AUTOHELP
 793         {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
 794         {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
 795         {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
 796         {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
 797         {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
 798         {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
 799         {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
 800         {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
 801         POPT_COMMON_SAMBA
 802         POPT_COMMON_DYNCONFIG
 803         POPT_TABLEEND
 804         };
 805         struct smbd_parent_context *parent = NULL;
 806         TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
 807
 808         smbd_init_globals();
 809
 810         TimeInit();
 811
 812 #ifdef HAVE_SET_AUTH_PARAMETERS
 813         set_auth_parameters(argc,argv);
 814 #endif
 815
 816         pc = poptGetContext("smbd", argc, argv, long_options, 0);
 817         while((opt = poptGetNextOpt(pc)) != -1) {
 818                 switch (opt)  {
 819                 case OPT_DAEMON:
 820                         is_daemon = true;
 821                         break;
 822                 case OPT_INTERACTIVE:
 823                         interactive = true;
 824                         break;
 825                 case OPT_FORK:
 826                         Fork = false;
 827                         break;
 828                 case OPT_NO_PROCESS_GROUP:
 829                         no_process_group = true;
 830                         break;
 831                 case OPT_LOG_STDOUT:
 832                         log_stdout = true;
 833                         break;
 834                 case 'b':
 835                         print_build_options = True;
 836                         break;
 837                 default:
 838                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
 839                                   poptBadOption(pc, 0), poptStrerror(opt));
 840                         poptPrintUsage(pc, stderr, 0);
 841                         exit(1);
 842                 }
 843         }
 844         poptFreeContext(pc);
 845
 846         if (interactive) {
 847                 Fork = False;
 848                 log_stdout = True;
 849         }
 850
 851         setup_logging(argv[0],log_stdout);
 852
 853         if (print_build_options) {
 854                 build_options(True); /* Display output to screen as well as debug */
 855                 exit(0);
 856         }
 857
 858         load_case_tables();
 859
 860 #ifdef HAVE_SETLUID
 861         /* needed for SecureWare on SCO */
 862         setluid(0);
 863 #endif
 864
 865         sec_init();
 866
 867         set_remote_machine_name("smbd", False);
 868
 869         if (interactive && (DEBUGLEVEL >= 9)) {
 870                 talloc_enable_leak_report();
 871         }
 872
 873         if (log_stdout && Fork) {
 874                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 875                 exit(1);
 876         }
 877
 878         /* we want to re-seed early to prevent time delays causing
 879            client problems at a later date. (tridge) */
 880         generate_random_buffer(NULL, 0);
 881
 882         /* make absolutely sure we run as root - to handle cases where people
 883            are crazy enough to have it setuid */
 884
 885         gain_root_privilege();
 886         gain_root_group_privilege();
 887
 888         fault_setup((void (*)(void *))exit_server_fault);
 889         dump_core_setup("smbd");
 890
 891         /* we are never interested in SIGPIPE */
 892         BlockSignals(True,SIGPIPE);
 893
 894 #if defined(SIGFPE)
 895         /* we are never interested in SIGFPE */
 896         BlockSignals(True,SIGFPE);
 897 #endif
 898
 899 #if defined(SIGUSR2)
 900         /* We are no longer interested in USR2 */
 901         BlockSignals(True,SIGUSR2);
 902 #endif
 903
 904         /* POSIX demands that signals are inherited. If the invoking process has
 905          * these signals masked, we will have problems, as we won't recieve them. */
 906         BlockSignals(False, SIGHUP);
 907         BlockSignals(False, SIGUSR1);
 908         BlockSignals(False, SIGTERM);
 909
 910         /* Ensure we leave no zombies until we
 911          * correctly set up child handling below. */
 912
 913         CatchChild();
 914
 915         /* we want total control over the permissions on created files,
 916            so set our umask to 0 */
 917         umask(0);
 918
 919         init_sec_ctx();
 920
 921         reopen_logs();
 922
 923         DEBUG(0,("smbd version %s started.\n", samba_version_string()));
 924         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
 925
 926         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
 927                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
 928
 929         /* Output the build options to the debug log */
 930         build_options(False);
 931
 932         if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
 933                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
 934                 exit(1);
 935         }
 936
 937         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
 938                 DEBUG(0, ("error opening config file\n"));
 939                 exit(1);
 940         }
 941
 942         if (smbd_messaging_context() == NULL)
 943                 exit(1);
 944
 945         if (!reload_services(False))
 946                 return(-1);
 947
 948         init_structs();
 949
 950 #ifdef WITH_PROFILE
 951         if (!profile_setup(smbd_messaging_context(), False)) {
 952                 DEBUG(0,("ERROR: failed to setup profiling\n"));
 953                 return -1;
 954         }
 955         if (profile_level != NULL) {
 956                 int pl = atoi(profile_level);
 957                 struct server_id src;
 958
 959                 DEBUG(1, ("setting profiling level: %s\n",profile_level));
 960                 src.pid = getpid();
 961                 set_profile_level(pl, src);
 962         }
 963 #endif
 964
 965         DEBUG(3,( "loaded services\n"));
 966
 967         if (!is_daemon && !is_a_socket(0)) {
 968                 if (!interactive)
 969                         DEBUG(0,("standard input is not a socket, assuming -D option\n"));
 970
 971                 /*
 972                  * Setting is_daemon here prevents us from eventually calling
 973                  * the open_sockets_inetd()
 974                  */
 975
 976                 is_daemon = True;
 977         }
 978
 979         if (is_daemon && !interactive) {
 980                 DEBUG( 3, ( "Becoming a daemon.\n" ) );
 981                 become_daemon(Fork, no_process_group, log_stdout);
 982         }
 983
 984 #if HAVE_SETPGID
 985         /*
 986          * If we're interactive we want to set our own process group for
 987          * signal management.
 988          */
 989         if (interactive && !no_process_group)
 990                 setpgid( (pid_t)0, (pid_t)0);
 991 #endif
 992
 993         if (!directory_exist(lp_lockdir()))
 994                 mkdir(lp_lockdir(), 0755);
 995
 996         if (is_daemon)
 997                 pidfile_create("smbd");
 998
 999         if (!NT_STATUS_IS_OK(reinit_after_fork(smbd_messaging_context(),
1000                              smbd_event_context(), false))) {
1001                 DEBUG(0,("reinit_after_fork() failed\n"));
1002                 exit(1);
1003         }
1004
1005         smbd_setup_sig_term_handler();
1006         smbd_setup_sig_hup_handler();
1007
1008         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1009
1010         if (smbd_memcache() == NULL) {
1011                 exit(1);
1012         }
1013
1014         memcache_set_global(smbd_memcache());
1015
1016         /* Initialise the password backed before the global_sam_sid
1017            to ensure that we fetch from ldap before we make a domain sid up */
1018
1019         if(!initialize_password_db(False, smbd_event_context()))
1020                 exit(1);
1021
1022         if (!secrets_init()) {
1023                 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1024                 exit(1);
1025         }
1026
1027         if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC) {
1028                 if (!open_schannel_session_store(talloc_autofree_context(), lp_private_dir())) {
1029                         DEBUG(0,("ERROR: Samba cannot open schannel store for secured NETLOGON operations.\n"));
1030                         exit(1);
1031                 }
1032         }
1033
1034         if(!get_global_sam_sid()) {
1035                 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1036                 exit(1);
1037         }
1038
1039         if (!sessionid_init()) {
1040                 exit(1);
1041         }
1042
1043         if (!connections_init(True))
1044                 exit(1);
1045
1046         if (!locking_init())
1047                 exit(1);
1048
1049         if (!messaging_tdb_parent_init()) {
1050                 exit(1);
1051         }
1052
1053         if (!notify_internal_parent_init()) {
1054                 exit(1);
1055         }
1056
1057         if (!serverid_parent_init()) {
1058                 exit(1);
1059         }
1060
1061         if (!W_ERROR_IS_OK(registry_init_full()))
1062                 exit(1);
1063
1064 #if 0
1065         if (!init_svcctl_db())
1066                 exit(1);
1067 #endif
1068
1069         if (!init_system_info()) {
1070                 DEBUG(0,("ERROR: failed to setup system user info.\n"));
1071                 return -1;
1072         }
1073
1074         if (!print_backend_init(smbd_messaging_context()))
1075                 exit(1);
1076
1077         if (!init_guest_info()) {
1078                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1079                 return -1;
1080         }
1081
1082         /* Open the share_info.tdb here, so we don't have to open
1083            after the fork on every single connection.  This is a small
1084            performance improvment and reduces the total number of system
1085            fds used. */
1086         if (!share_info_db_init()) {
1087                 DEBUG(0,("ERROR: failed to load share info db.\n"));
1088                 exit(1);
1089         }
1090
1091         /* only start the background queue daemon if we are
1092            running as a daemon -- bad things will happen if
1093            smbd is launched via inetd and we fork a copy of
1094            ourselves here */
1095
1096         if (is_daemon && !interactive
1097             && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
1098                 start_background_queue();
1099         }
1100
1101         if (!is_daemon) {
1102                 /* inetd mode */
1103                 TALLOC_FREE(frame);
1104
1105                 /* Started from inetd. fd 0 is the socket. */
1106                 /* We will abort gracefully when the client or remote system
1107                    goes away */
1108                 smbd_set_server_fd(dup(0));
1109
1110                 /* close our standard file descriptors */
1111                 close_low_fds(False); /* Don't close stderr */
1112
1113 #ifdef HAVE_ATEXIT
1114                 atexit(killkids);
1115 #endif
1116
1117                 /* Stop zombies */
1118                 smbd_setup_sig_chld_handler();
1119
1120                 smbd_process();
1121
1122                 exit_server_cleanly(NULL);
1123                 return(0);
1124         }
1125
1126         parent = talloc_zero(smbd_event_context(), struct smbd_parent_context);
1127         if (!parent) {
1128                 exit_server("talloc(struct smbd_parent_context) failed");
1129         }
1130         parent->interactive = interactive;
1131
1132         if (!open_sockets_smbd(parent, ports))
1133                 exit_server("open_sockets_smbd() failed");
1134
1135         TALLOC_FREE(frame);
1136         /* make sure we always have a valid stackframe */
1137         frame = talloc_stackframe();
1138
1139         smbd_parent_loop(parent);
1140
1141         exit_server_cleanly(NULL);
1142         TALLOC_FREE(frame);
1143         return(0);
1144 }