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