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