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