source3/smbd/server.c

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