source3/smbd/server.c

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