source3/smbd/server.c

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