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(
 694                         messaging_ctdbd_connection(procid_self()));
 695         }
 696 #endif
 697
 698 #ifdef DEVELOPER
 699         messaging_register(smbd_messaging_context(), NULL,
 700                            MSG_SMB_INJECT_FAULT, msg_inject_fault);
 701 #endif
 702
 703         if (dns_port != 0) {
 704 #ifdef WITH_DNSSD_SUPPORT
 705                 smbd_setup_mdns_registration(smbd_event_context(),
 706                                              parent, dns_port);
 707 #endif
 708 #ifdef WITH_AVAHI_SUPPORT
 709                 void *avahi_conn;
 710
 711                 avahi_conn = avahi_start_register(
 712                         smbd_event_context(), smbd_event_context(), dns_port);
 713                 if (avahi_conn == NULL) {
 714                         DEBUG(10, ("avahi_start_register failed\n"));
 715                 }
 716 #endif
 717         }
 718
 719         return true;
 720 }
 721
 722 static void smbd_parent_loop(struct smbd_parent_context *parent)
 723 {
 724         /* now accept incoming connections - forking a new process
 725            for each incoming connection */
 726         DEBUG(2,("waiting for connections\n"));
 727         while (1) {
 728                 int ret;
 729                 TALLOC_CTX *frame = talloc_stackframe();
 730
 731                 ret = tevent_loop_once(smbd_event_context());
 732                 if (ret != 0) {
 733                         exit_server_cleanly("tevent_loop_once() error");
 734                 }
 735
 736                 TALLOC_FREE(frame);
 737         } /* end while 1 */
 738
 739 /* NOTREACHED   return True; */
 740 }
 741
 742
 743 /****************************************************************************
 744  Initialise connect, service and file structs.
 745 ****************************************************************************/
 746
 747 static bool init_structs(void )
 748 {
 749         /*
 750          * Set the machine NETBIOS name if not already
 751          * set from the config file.
 752          */
 753
 754         if (!init_names())
 755                 return False;
 756
 757         file_init();
 758
 759         if (!secrets_init())
 760                 return False;
 761
 762         return True;
 763 }
 764
 765 /****************************************************************************
 766  main program.
 767 ****************************************************************************/
 768
 769 /* Declare prototype for build_options() to avoid having to run it through
 770    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
 771    prototype generation system is too complicated. */
 772
 773 extern void build_options(bool screen);
 774
 775  int main(int argc,const char *argv[])
 776 {
 777         /* shall I run as a daemon */
 778         bool is_daemon = false;
 779         bool interactive = false;
 780         bool Fork = true;
 781         bool no_process_group = false;
 782         bool log_stdout = false;
 783         char *ports = NULL;
 784         char *profile_level = NULL;
 785         int opt;
 786         poptContext pc;
 787         bool print_build_options = False;
 788         enum {
 789                 OPT_DAEMON = 1000,
 790                 OPT_INTERACTIVE,
 791                 OPT_FORK,
 792                 OPT_NO_PROCESS_GROUP,
 793                 OPT_LOG_STDOUT
 794         };
 795         struct poptOption long_options[] = {
 796         POPT_AUTOHELP
 797         {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
 798         {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
 799         {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
 800         {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
 801         {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
 802         {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
 803         {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
 804         {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
 805         POPT_COMMON_SAMBA
 806         POPT_COMMON_DYNCONFIG
 807         POPT_TABLEEND
 808         };
 809         struct smbd_parent_context *parent = NULL;
 810         TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
 811         NTSTATUS status;
 812         uint64_t unique_id;
 813
 814         smbd_init_globals();
 815
 816         TimeInit();
 817
 818 #ifdef HAVE_SET_AUTH_PARAMETERS
 819         set_auth_parameters(argc,argv);
 820 #endif
 821
 822         pc = poptGetContext("smbd", argc, argv, long_options, 0);
 823         while((opt = poptGetNextOpt(pc)) != -1) {
 824                 switch (opt)  {
 825                 case OPT_DAEMON:
 826                         is_daemon = true;
 827                         break;
 828                 case OPT_INTERACTIVE:
 829                         interactive = true;
 830                         break;
 831                 case OPT_FORK:
 832                         Fork = false;
 833                         break;
 834                 case OPT_NO_PROCESS_GROUP:
 835                         no_process_group = true;
 836                         break;
 837                 case OPT_LOG_STDOUT:
 838                         log_stdout = true;
 839                         break;
 840                 case 'b':
 841                         print_build_options = True;
 842                         break;
 843                 default:
 844                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
 845                                   poptBadOption(pc, 0), poptStrerror(opt));
 846                         poptPrintUsage(pc, stderr, 0);
 847                         exit(1);
 848                 }
 849         }
 850         poptFreeContext(pc);
 851
 852         if (interactive) {
 853                 Fork = False;
 854                 log_stdout = True;
 855         }
 856
 857         setup_logging(argv[0],log_stdout);
 858
 859         if (print_build_options) {
 860                 build_options(True); /* Display output to screen as well as debug */
 861                 exit(0);
 862         }
 863
 864         load_case_tables();
 865
 866 #ifdef HAVE_SETLUID
 867         /* needed for SecureWare on SCO */
 868         setluid(0);
 869 #endif
 870
 871         sec_init();
 872
 873         set_remote_machine_name("smbd", False);
 874
 875         if (interactive && (DEBUGLEVEL >= 9)) {
 876                 talloc_enable_leak_report();
 877         }
 878
 879         if (log_stdout && Fork) {
 880                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 881                 exit(1);
 882         }
 883
 884         /* we want to re-seed early to prevent time delays causing
 885            client problems at a later date. (tridge) */
 886         generate_random_buffer(NULL, 0);
 887
 888         /* make absolutely sure we run as root - to handle cases where people
 889            are crazy enough to have it setuid */
 890
 891         gain_root_privilege();
 892         gain_root_group_privilege();
 893
 894         fault_setup((void (*)(void *))exit_server_fault);
 895         dump_core_setup("smbd");
 896
 897         /* we are never interested in SIGPIPE */
 898         BlockSignals(True,SIGPIPE);
 899
 900 #if defined(SIGFPE)
 901         /* we are never interested in SIGFPE */
 902         BlockSignals(True,SIGFPE);
 903 #endif
 904
 905 #if defined(SIGUSR2)
 906         /* We are no longer interested in USR2 */
 907         BlockSignals(True,SIGUSR2);
 908 #endif
 909
 910         /* POSIX demands that signals are inherited. If the invoking process has
 911          * these signals masked, we will have problems, as we won't recieve them. */
 912         BlockSignals(False, SIGHUP);
 913         BlockSignals(False, SIGUSR1);
 914         BlockSignals(False, SIGTERM);
 915
 916         /* Ensure we leave no zombies until we
 917          * correctly set up child handling below. */
 918
 919         CatchChild();
 920
 921         /* we want total control over the permissions on created files,
 922            so set our umask to 0 */
 923         umask(0);
 924
 925         init_sec_ctx();
 926
 927         reopen_logs();
 928
 929         DEBUG(0,("smbd version %s started.\n", samba_version_string()));
 930         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
 931
 932         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
 933                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
 934
 935         /* Output the build options to the debug log */
 936         build_options(False);
 937
 938         if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
 939                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
 940                 exit(1);
 941         }
 942
 943         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
 944                 DEBUG(0, ("error opening config file\n"));
 945                 exit(1);
 946         }
 947
 948         if (smbd_messaging_context() == NULL)
 949                 exit(1);
 950
 951         if (!reload_services(False))
 952                 return(-1);
 953
 954         init_structs();
 955
 956 #ifdef WITH_PROFILE
 957         if (!profile_setup(smbd_messaging_context(), False)) {
 958                 DEBUG(0,("ERROR: failed to setup profiling\n"));
 959                 return -1;
 960         }
 961         if (profile_level != NULL) {
 962                 int pl = atoi(profile_level);
 963                 struct server_id src;
 964
 965                 DEBUG(1, ("setting profiling level: %s\n",profile_level));
 966                 src.pid = getpid();
 967                 set_profile_level(pl, src);
 968         }
 969 #endif
 970
 971         DEBUG(3,( "loaded services\n"));
 972
 973         if (!is_daemon && !is_a_socket(0)) {
 974                 if (!interactive)
 975                         DEBUG(0,("standard input is not a socket, assuming -D option\n"));
 976
 977                 /*
 978                  * Setting is_daemon here prevents us from eventually calling
 979                  * the open_sockets_inetd()
 980                  */
 981
 982                 is_daemon = True;
 983         }
 984
 985         if (is_daemon && !interactive) {
 986                 DEBUG( 3, ( "Becoming a daemon.\n" ) );
 987                 become_daemon(Fork, no_process_group, log_stdout);
 988         }
 989
 990         generate_random_buffer((uint8_t *)&unique_id, sizeof(unique_id));
 991         set_my_unique_id(unique_id);
 992
 993 #if HAVE_SETPGID
 994         /*
 995          * If we're interactive we want to set our own process group for
 996          * signal management.
 997          */
 998         if (interactive && !no_process_group)
 999                 setpgid( (pid_t)0, (pid_t)0);
1000 #endif
1001
1002         if (!directory_exist(lp_lockdir()))
1003                 mkdir(lp_lockdir(), 0755);
1004
1005         if (is_daemon)
1006                 pidfile_create("smbd");
1007
1008         status = reinit_after_fork(smbd_messaging_context(),
1009                                    smbd_event_context(),
1010                                    procid_self(), false);
1011         if (!NT_STATUS_IS_OK(status)) {
1012                 DEBUG(0,("reinit_after_fork() failed\n"));
1013                 exit(1);
1014         }
1015
1016         smbd_server_conn->msg_ctx = smbd_messaging_context();
1017
1018         smbd_setup_sig_term_handler();
1019         smbd_setup_sig_hup_handler();
1020
1021         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1022
1023         if (smbd_memcache() == NULL) {
1024                 exit(1);
1025         }
1026
1027         memcache_set_global(smbd_memcache());
1028
1029         /* Initialise the password backed before the global_sam_sid
1030            to ensure that we fetch from ldap before we make a domain sid up */
1031
1032         if(!initialize_password_db(False, smbd_event_context()))
1033                 exit(1);
1034
1035         if (!secrets_init()) {
1036                 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1037                 exit(1);
1038         }
1039
1040         if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC) {
1041                 if (!open_schannel_session_store(NULL, lp_private_dir())) {
1042                         DEBUG(0,("ERROR: Samba cannot open schannel store for secured NETLOGON operations.\n"));
1043                         exit(1);
1044                 }
1045         }
1046
1047         if(!get_global_sam_sid()) {
1048                 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1049                 exit(1);
1050         }
1051
1052         if (!sessionid_init()) {
1053                 exit(1);
1054         }
1055
1056         if (!connections_init(True))
1057                 exit(1);
1058
1059         if (!locking_init())
1060                 exit(1);
1061
1062         if (!messaging_tdb_parent_init()) {
1063                 exit(1);
1064         }
1065
1066         if (!notify_internal_parent_init()) {
1067                 exit(1);
1068         }
1069
1070         if (!serverid_parent_init()) {
1071                 exit(1);
1072         }
1073
1074         if (!W_ERROR_IS_OK(registry_init_full()))
1075                 exit(1);
1076
1077 #if 0
1078         if (!init_svcctl_db())
1079                 exit(1);
1080 #endif
1081
1082         if (!init_system_info()) {
1083                 DEBUG(0,("ERROR: failed to setup system user info.\n"));
1084                 return -1;
1085         }
1086
1087         if (!print_backend_init(smbd_messaging_context()))
1088                 exit(1);
1089
1090         if (!init_guest_info()) {
1091                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1092                 return -1;
1093         }
1094
1095         /* Open the share_info.tdb here, so we don't have to open
1096            after the fork on every single connection.  This is a small
1097            performance improvment and reduces the total number of system
1098            fds used. */
1099         if (!share_info_db_init()) {
1100                 DEBUG(0,("ERROR: failed to load share info db.\n"));
1101                 exit(1);
1102         }
1103
1104         /* only start the background queue daemon if we are
1105            running as a daemon -- bad things will happen if
1106            smbd is launched via inetd and we fork a copy of
1107            ourselves here */
1108
1109         if (is_daemon && !interactive
1110             && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
1111                 start_background_queue();
1112         }
1113
1114         if (!is_daemon) {
1115                 /* inetd mode */
1116                 TALLOC_FREE(frame);
1117
1118                 /* Started from inetd. fd 0 is the socket. */
1119                 /* We will abort gracefully when the client or remote system
1120                    goes away */
1121                 smbd_set_server_fd(dup(0));
1122
1123                 /* close our standard file descriptors */
1124                 close_low_fds(False); /* Don't close stderr */
1125
1126 #ifdef HAVE_ATEXIT
1127                 atexit(killkids);
1128 #endif
1129
1130                 /* Stop zombies */
1131                 smbd_setup_sig_chld_handler();
1132
1133                 smbd_process();
1134
1135                 exit_server_cleanly(NULL);
1136                 return(0);
1137         }
1138
1139         parent = talloc_zero(smbd_event_context(), struct smbd_parent_context);
1140         if (!parent) {
1141                 exit_server("talloc(struct smbd_parent_context) failed");
1142         }
1143         parent->interactive = interactive;
1144
1145         if (!open_sockets_smbd(parent, ports))
1146                 exit_server("open_sockets_smbd() failed");
1147
1148         TALLOC_FREE(frame);
1149         /* make sure we always have a valid stackframe */
1150         frame = talloc_stackframe();
1151
1152         smbd_parent_loop(parent);
1153
1154         exit_server_cleanly(NULL);
1155         TALLOC_FREE(frame);
1156         return(0);
1157 }