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 "lib/util/server_id.h"
  27 #include "popt_common.h"
  28 #include "smbd/smbd.h"
  29 #include "smbd/globals.h"
  30 #include "registry/reg_init_full.h"
  31 #include "libcli/auth/schannel.h"
  32 #include "secrets.h"
  33 #include "../lib/util/memcache.h"
  34 #include "ctdbd_conn.h"
  35 #include "util_cluster.h"
  36 #include "printing/queue_process.h"
  37 #include "rpc_server/rpc_service_setup.h"
  38 #include "rpc_server/rpc_config.h"
  39 #include "passdb.h"
  40 #include "auth.h"
  41 #include "messages.h"
  42 #include "messages_ctdb.h"
  43 #include "smbprofile.h"
  44 #include "lib/id_cache.h"
  45 #include "lib/param/param.h"
  46 #include "lib/background.h"
  47 #include "../lib/util/pidfile.h"
  48 #include "lib/smbd_shim.h"
  49 #include "scavenger.h"
  50 #include "locking/leases_db.h"
  51 #include "smbd/notifyd/notifyd.h"
  52 #include "smbd/smbd_cleanupd.h"
  53 #include "lib/util/sys_rw.h"
  54 #include "cleanupdb.h"
  55 #include "g_lock.h"
  56 #include "rpc_server/epmd.h"
  57 #include "rpc_server/lsasd.h"
  58 #include "rpc_server/fssd.h"
  59 #include "rpc_server/mdssd.h"
  60
  61 #ifdef CLUSTER_SUPPORT
  62 #include "ctdb_protocol.h"
  63 #endif
  64
  65 struct smbd_open_socket;
  66 struct smbd_child_pid;
  67
  68 struct smbd_parent_context {
  69         bool interactive;
  70
  71         struct tevent_context *ev_ctx;
  72         struct messaging_context *msg_ctx;
  73
  74         /* the list of listening sockets */
  75         struct smbd_open_socket *sockets;
  76
  77         /* the list of current child processes */
  78         struct smbd_child_pid *children;
  79         size_t num_children;
  80
  81         struct server_id cleanupd;
  82         struct server_id notifyd;
  83
  84         struct tevent_timer *cleanup_te;
  85 };
  86
  87 struct smbd_open_socket {
  88         struct smbd_open_socket *prev, *next;
  89         struct smbd_parent_context *parent;
  90         int fd;
  91         struct tevent_fd *fde;
  92 };
  93
  94 struct smbd_child_pid {
  95         struct smbd_child_pid *prev, *next;
  96         pid_t pid;
  97 };
  98
  99 /*******************************************************************
 100  What to do when smb.conf is updated.
 101  ********************************************************************/
 102
 103 static void smbd_parent_conf_updated(struct messaging_context *msg,
 104                                      void *private_data,
 105                                      uint32_t msg_type,
 106                                      struct server_id server_id,
 107                                      DATA_BLOB *data)
 108 {
 109         struct tevent_context *ev_ctx =
 110                 talloc_get_type_abort(private_data, struct tevent_context);
 111         bool ok;
 112
 113         DEBUG(10,("smbd_parent_conf_updated: Got message saying smb.conf was "
 114                   "updated. Reloading.\n"));
 115         change_to_root_user();
 116         reload_services(NULL, NULL, false);
 117         printing_subsystem_update(ev_ctx, msg, false);
 118
 119         ok = reinit_guest_session_info(NULL);
 120         if (!ok) {
 121                 DBG_ERR("Failed to reinit guest info\n");
 122         }
 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         struct server_id_buf tmp;
 168
 169         if (data->length != sizeof(sig)) {
 170                 DEBUG(0, ("Process %s sent bogus signal injection request\n",
 171                           server_id_str_buf(src, &tmp)));
 172                 return;
 173         }
 174
 175         sig = *(int *)data->data;
 176         if (sig == -1) {
 177                 exit_server("internal error injected");
 178                 return;
 179         }
 180
 181 #ifdef HAVE_STRSIGNAL
 182         DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
 183                   server_id_str_buf(src, &tmp), sig, strsignal(sig)));
 184 #else
 185         DEBUG(0, ("Process %s requested injection of signal %d\n",
 186                   server_id_str_buf(src, &tmp), sig));
 187 #endif
 188
 189         kill(getpid(), sig);
 190 }
 191 #endif /* DEVELOPER */
 192
 193 #if defined(DEVELOPER) || defined(ENABLE_SELFTEST)
 194 /*
 195  * Sleep for the specified number of seconds.
 196  */
 197 static void msg_sleep(struct messaging_context *msg,
 198                       void *private_data,
 199                       uint32_t msg_type,
 200                       struct server_id src,
 201                       DATA_BLOB *data)
 202 {
 203         unsigned int seconds;
 204         struct server_id_buf tmp;
 205
 206         if (data->length != sizeof(seconds)) {
 207                 DBG_ERR("Process %s sent bogus sleep request\n",
 208                         server_id_str_buf(src, &tmp));
 209                 return;
 210         }
 211
 212         seconds = *(unsigned int *)data->data;
 213         DBG_ERR("Process %s request a sleep of %u seconds\n",
 214                 server_id_str_buf(src, &tmp),
 215                 seconds);
 216         sleep(seconds);
 217         DBG_ERR("Restarting after %u second sleep requested by process %s\n",
 218                 seconds,
 219                 server_id_str_buf(src, &tmp));
 220 }
 221 #endif /* DEVELOPER */
 222
 223 static NTSTATUS messaging_send_to_children(struct messaging_context *msg_ctx,
 224                                            uint32_t msg_type, DATA_BLOB* data)
 225 {
 226         NTSTATUS status;
 227         struct smbd_parent_context *parent = am_parent;
 228         struct smbd_child_pid *child;
 229
 230         if (parent == NULL) {
 231                 return NT_STATUS_INTERNAL_ERROR;
 232         }
 233
 234         for (child = parent->children; child != NULL; child = child->next) {
 235                 status = messaging_send(parent->msg_ctx,
 236                                         pid_to_procid(child->pid),
 237                                         msg_type, data);
 238                 if (!NT_STATUS_IS_OK(status)) {
 239                         DBG_DEBUG("messaging_send(%d) failed: %s\n",
 240                                   (int)child->pid, nt_errstr(status));
 241                 }
 242         }
 243         return NT_STATUS_OK;
 244 }
 245
 246 static void smb_parent_send_to_children(struct messaging_context *ctx,
 247                                         void* data,
 248                                         uint32_t msg_type,
 249                                         struct server_id srv_id,
 250                                         DATA_BLOB* msg_data)
 251 {
 252         messaging_send_to_children(ctx, msg_type, msg_data);
 253 }
 254
 255 /*
 256  * Parent smbd process sets its own debug level first and then
 257  * sends a message to all the smbd children to adjust their debug
 258  * level to that of the parent.
 259  */
 260
 261 static void smbd_msg_debug(struct messaging_context *msg_ctx,
 262                            void *private_data,
 263                            uint32_t msg_type,
 264                            struct server_id server_id,
 265                            DATA_BLOB *data)
 266 {
 267         debug_message(msg_ctx, private_data, MSG_DEBUG, server_id, data);
 268
 269         messaging_send_to_children(msg_ctx, MSG_DEBUG, data);
 270 }
 271
 272 static void smbd_parent_id_cache_kill(struct messaging_context *msg_ctx,
 273                                       void *private_data,
 274                                       uint32_t msg_type,
 275                                       struct server_id server_id,
 276                                       DATA_BLOB* data)
 277 {
 278         const char *msg = (data && data->data)
 279                 ? (const char *)data->data : "<NULL>";
 280         struct id_cache_ref id;
 281
 282         if (!id_cache_ref_parse(msg, &id)) {
 283                 DEBUG(0, ("Invalid ?ID: %s\n", msg));
 284                 return;
 285         }
 286
 287         id_cache_delete_from_cache(&id);
 288
 289         messaging_send_to_children(msg_ctx, msg_type, data);
 290 }
 291
 292 static void smbd_parent_id_cache_delete(struct messaging_context *ctx,
 293                                         void* data,
 294                                         uint32_t msg_type,
 295                                         struct server_id srv_id,
 296                                         DATA_BLOB* msg_data)
 297 {
 298         id_cache_delete_message(ctx, data, msg_type, srv_id, msg_data);
 299
 300         messaging_send_to_children(ctx, msg_type, msg_data);
 301 }
 302
 303 static void add_child_pid(struct smbd_parent_context *parent,
 304                           pid_t pid)
 305 {
 306         struct smbd_child_pid *child;
 307
 308         child = talloc_zero(parent, struct smbd_child_pid);
 309         if (child == NULL) {
 310                 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
 311                 return;
 312         }
 313         child->pid = pid;
 314         DLIST_ADD(parent->children, child);
 315         parent->num_children += 1;
 316 }
 317
 318 static void smb_tell_num_children(struct messaging_context *ctx, void *data,
 319                                   uint32_t msg_type, struct server_id srv_id,
 320                                   DATA_BLOB *msg_data)
 321 {
 322         uint8_t buf[sizeof(uint32_t)];
 323
 324         if (am_parent) {
 325                 SIVAL(buf, 0, am_parent->num_children);
 326                 messaging_send_buf(ctx, srv_id, MSG_SMB_NUM_CHILDREN,
 327                                    buf, sizeof(buf));
 328         }
 329 }
 330
 331 static void notifyd_stopped(struct tevent_req *req);
 332
 333 static struct tevent_req *notifyd_req(struct messaging_context *msg_ctx,
 334                                       struct tevent_context *ev)
 335 {
 336         struct tevent_req *req;
 337         sys_notify_watch_fn sys_notify_watch = NULL;
 338         struct sys_notify_context *sys_notify_ctx = NULL;
 339         struct ctdbd_connection *ctdbd_conn = NULL;
 340
 341         if (lp_kernel_change_notify()) {
 342
 343 #ifdef HAVE_INOTIFY
 344                 if (lp_parm_bool(-1, "notify", "inotify", true)) {
 345                         sys_notify_watch = inotify_watch;
 346                 }
 347 #endif
 348
 349 #ifdef HAVE_FAM
 350                 if (lp_parm_bool(-1, "notify", "fam",
 351                                  (sys_notify_watch == NULL))) {
 352                         sys_notify_watch = fam_watch;
 353                 }
 354 #endif
 355         }
 356
 357         if (sys_notify_watch != NULL) {
 358                 sys_notify_ctx = sys_notify_context_create(msg_ctx, ev);
 359                 if (sys_notify_ctx == NULL) {
 360                         return NULL;
 361                 }
 362         }
 363
 364         if (lp_clustering()) {
 365                 ctdbd_conn = messaging_ctdb_connection();
 366         }
 367
 368         req = notifyd_send(msg_ctx, ev, msg_ctx, ctdbd_conn,
 369                            sys_notify_watch, sys_notify_ctx);
 370         if (req == NULL) {
 371                 TALLOC_FREE(sys_notify_ctx);
 372                 return NULL;
 373         }
 374         tevent_req_set_callback(req, notifyd_stopped, msg_ctx);
 375
 376         return req;
 377 }
 378
 379 static void notifyd_stopped(struct tevent_req *req)
 380 {
 381         int ret;
 382
 383         ret = notifyd_recv(req);
 384         TALLOC_FREE(req);
 385         DEBUG(1, ("notifyd stopped: %s\n", strerror(ret)));
 386 }
 387
 388 static void notifyd_sig_hup_handler(struct tevent_context *ev,
 389                                     struct tevent_signal *se,
 390                                     int signum,
 391                                     int count,
 392                                     void *siginfo,
 393                                     void *pvt)
 394 {
 395         DBG_NOTICE("notifyd: Reloading services after SIGHUP\n");
 396         reload_services(NULL, NULL, false);
 397 }
 398
 399 static bool smbd_notifyd_init(struct messaging_context *msg, bool interactive,
 400                               struct server_id *ppid)
 401 {
 402         struct tevent_context *ev = messaging_tevent_context(msg);
 403         struct tevent_req *req;
 404         pid_t pid;
 405         NTSTATUS status;
 406         bool ok;
 407         struct tevent_signal *se;
 408
 409         if (interactive) {
 410                 req = notifyd_req(msg, ev);
 411                 return (req != NULL);
 412         }
 413
 414         pid = fork();
 415         if (pid == -1) {
 416                 DEBUG(1, ("%s: fork failed: %s\n", __func__,
 417                           strerror(errno)));
 418                 return false;
 419         }
 420
 421         if (pid != 0) {
 422                 if (am_parent != NULL) {
 423                         add_child_pid(am_parent, pid);
 424                 }
 425                 *ppid = pid_to_procid(pid);
 426                 return true;
 427         }
 428
 429         status = smbd_reinit_after_fork(msg, ev, true, "smbd-notifyd");
 430         if (!NT_STATUS_IS_OK(status)) {
 431                 DEBUG(1, ("%s: reinit_after_fork failed: %s\n",
 432                           __func__, nt_errstr(status)));
 433                 exit(1);
 434         }
 435
 436         reopen_logs();
 437
 438         /* Set up sighup handler for notifyd */
 439         se = tevent_add_signal(ev,
 440                                ev,
 441                                SIGHUP, 0,
 442                                notifyd_sig_hup_handler,
 443                                NULL);
 444         if (!se) {
 445                 DEBUG(0, ("failed to setup notifyd SIGHUP handler\n"));
 446                 exit(1);
 447         }
 448
 449         req = notifyd_req(msg, ev);
 450         if (req == NULL) {
 451                 exit(1);
 452         }
 453         tevent_req_set_callback(req, notifyd_stopped, msg);
 454
 455         /* Block those signals that we are not handling */
 456         BlockSignals(True, SIGUSR1);
 457
 458         messaging_send(msg, pid_to_procid(getppid()), MSG_SMB_NOTIFY_STARTED,
 459                        NULL);
 460
 461         ok = tevent_req_poll(req, ev);
 462         if (!ok) {
 463                 DBG_WARNING("tevent_req_poll returned %s\n", strerror(errno));
 464                 exit(1);
 465         }
 466         exit(0);
 467 }
 468
 469 static void notifyd_init_trigger(struct tevent_req *req);
 470
 471 struct notifyd_init_state {
 472         bool ok;
 473         struct tevent_context *ev;
 474         struct messaging_context *msg;
 475         struct server_id *ppid;
 476 };
 477
 478 static struct tevent_req *notifyd_init_send(struct tevent_context *ev,
 479                                             TALLOC_CTX *mem_ctx,
 480                                             struct messaging_context *msg,
 481                                             struct server_id *ppid)
 482 {
 483         struct tevent_req *req = NULL;
 484         struct tevent_req *subreq = NULL;
 485         struct notifyd_init_state *state = NULL;
 486
 487         req = tevent_req_create(mem_ctx, &state, struct notifyd_init_state);
 488         if (req == NULL) {
 489                 return NULL;
 490         }
 491
 492         *state = (struct notifyd_init_state) {
 493                 .msg = msg,
 494                 .ev = ev,
 495                 .ppid = ppid
 496         };
 497
 498         subreq = tevent_wakeup_send(state, ev, tevent_timeval_current_ofs(1, 0));
 499         if (tevent_req_nomem(subreq, req)) {
 500                 return tevent_req_post(req, ev);
 501         }
 502
 503         tevent_req_set_callback(subreq, notifyd_init_trigger, req);
 504         return req;
 505 }
 506
 507 static void notifyd_init_trigger(struct tevent_req *subreq)
 508 {
 509         struct tevent_req *req = tevent_req_callback_data(
 510                 subreq, struct tevent_req);
 511         struct notifyd_init_state *state = tevent_req_data(
 512                 req, struct notifyd_init_state);
 513         bool ok;
 514
 515         DBG_NOTICE("Triggering notifyd startup\n");
 516
 517         ok = tevent_wakeup_recv(subreq);
 518         TALLOC_FREE(subreq);
 519         if (!ok) {
 520                 tevent_req_error(req, ENOMEM);
 521                 return;
 522         }
 523
 524         state->ok = smbd_notifyd_init(state->msg, false, state->ppid);
 525         if (state->ok) {
 526                 DBG_WARNING("notifyd restarted\n");
 527                 tevent_req_done(req);
 528                 return;
 529         }
 530
 531         DBG_NOTICE("notifyd startup failed, rescheduling\n");
 532
 533         subreq = tevent_wakeup_send(state, state->ev,
 534                                     tevent_timeval_current_ofs(1, 0));
 535         if (tevent_req_nomem(subreq, req)) {
 536                 DBG_ERR("scheduling notifyd restart failed, giving up\n");
 537                 return;
 538         }
 539
 540         tevent_req_set_callback(subreq, notifyd_init_trigger, req);
 541         return;
 542 }
 543
 544 static bool notifyd_init_recv(struct tevent_req *req)
 545 {
 546         struct notifyd_init_state *state = tevent_req_data(
 547                 req, struct notifyd_init_state);
 548
 549         return state->ok;
 550 }
 551
 552 static void notifyd_started(struct tevent_req *req)
 553 {
 554         bool ok;
 555
 556         ok = notifyd_init_recv(req);
 557         TALLOC_FREE(req);
 558         if (!ok) {
 559                 DBG_ERR("Failed to restart notifyd, giving up\n");
 560                 return;
 561         }
 562 }
 563
 564 static void cleanupd_stopped(struct tevent_req *req);
 565
 566 static bool cleanupd_init(struct messaging_context *msg, bool interactive,
 567                           struct server_id *ppid)
 568 {
 569         struct tevent_context *ev = messaging_tevent_context(msg);
 570         struct server_id parent_id = messaging_server_id(msg);
 571         struct tevent_req *req;
 572         pid_t pid;
 573         NTSTATUS status;
 574         ssize_t rwret;
 575         int ret;
 576         bool ok;
 577         char c;
 578         int up_pipe[2];
 579
 580         if (interactive) {
 581                 req = smbd_cleanupd_send(msg, ev, msg, parent_id.pid);
 582                 *ppid = messaging_server_id(msg);
 583                 return (req != NULL);
 584         }
 585
 586         ret = pipe(up_pipe);
 587         if (ret == -1) {
 588                 DBG_WARNING("pipe failed: %s\n", strerror(errno));
 589                 return false;
 590         }
 591
 592         pid = fork();
 593         if (pid == -1) {
 594                 DBG_WARNING("fork failed: %s\n", strerror(errno));
 595                 close(up_pipe[0]);
 596                 close(up_pipe[1]);
 597                 return false;
 598         }
 599
 600         if (pid != 0) {
 601
 602                 close(up_pipe[1]);
 603                 rwret = sys_read(up_pipe[0], &c, 1);
 604                 close(up_pipe[0]);
 605
 606                 if (rwret == -1) {
 607                         DBG_WARNING("sys_read failed: %s\n", strerror(errno));
 608                         return false;
 609                 }
 610                 if (rwret == 0) {
 611                         DBG_WARNING("cleanupd could not start\n");
 612                         return false;
 613                 }
 614                 if (c != 0) {
 615                         DBG_WARNING("cleanupd returned %d\n", (int)c);
 616                         return false;
 617                 }
 618
 619                 DBG_DEBUG("Started cleanupd pid=%d\n", (int)pid);
 620
 621                 if (am_parent != NULL) {
 622                         add_child_pid(am_parent, pid);
 623                 }
 624
 625                 *ppid = pid_to_procid(pid);
 626                 return true;
 627         }
 628
 629         close(up_pipe[0]);
 630
 631         status = smbd_reinit_after_fork(msg, ev, true, "cleanupd");
 632         if (!NT_STATUS_IS_OK(status)) {
 633                 DBG_WARNING("reinit_after_fork failed: %s\n",
 634                             nt_errstr(status));
 635                 c = 1;
 636                 sys_write(up_pipe[1], &c, 1);
 637
 638                 exit(1);
 639         }
 640
 641         req = smbd_cleanupd_send(msg, ev, msg, parent_id.pid);
 642         if (req == NULL) {
 643                 DBG_WARNING("smbd_cleanupd_send failed\n");
 644                 c = 2;
 645                 sys_write(up_pipe[1], &c, 1);
 646
 647                 exit(1);
 648         }
 649
 650         tevent_req_set_callback(req, cleanupd_stopped, msg);
 651
 652         c = 0;
 653         rwret = sys_write(up_pipe[1], &c, 1);
 654         close(up_pipe[1]);
 655
 656         if (rwret == -1) {
 657                 DBG_WARNING("sys_write failed: %s\n", strerror(errno));
 658                 exit(1);
 659         }
 660         if (rwret != 1) {
 661                 DBG_WARNING("sys_write could not write result\n");
 662                 exit(1);
 663         }
 664
 665         ok = tevent_req_poll(req, ev);
 666         if (!ok) {
 667                 DBG_WARNING("tevent_req_poll returned %s\n", strerror(errno));
 668         }
 669         exit(0);
 670 }
 671
 672 static void cleanupd_stopped(struct tevent_req *req)
 673 {
 674         NTSTATUS status;
 675
 676         status = smbd_cleanupd_recv(req);
 677         DBG_WARNING("cleanupd stopped: %s\n", nt_errstr(status));
 678 }
 679
 680 static void cleanupd_init_trigger(struct tevent_req *req);
 681
 682 struct cleanup_init_state {
 683         bool ok;
 684         struct tevent_context *ev;
 685         struct messaging_context *msg;
 686         struct server_id *ppid;
 687 };
 688
 689 static struct tevent_req *cleanupd_init_send(struct tevent_context *ev,
 690                                              TALLOC_CTX *mem_ctx,
 691                                              struct messaging_context *msg,
 692                                              struct server_id *ppid)
 693 {
 694         struct tevent_req *req = NULL;
 695         struct tevent_req *subreq = NULL;
 696         struct cleanup_init_state *state = NULL;
 697
 698         req = tevent_req_create(mem_ctx, &state, struct cleanup_init_state);
 699         if (req == NULL) {
 700                 return NULL;
 701         }
 702
 703         *state = (struct cleanup_init_state) {
 704                 .msg = msg,
 705                 .ev = ev,
 706                 .ppid = ppid
 707         };
 708
 709         subreq = tevent_wakeup_send(state, ev, tevent_timeval_current_ofs(0, 0));
 710         if (tevent_req_nomem(subreq, req)) {
 711                 return tevent_req_post(req, ev);
 712         }
 713
 714         tevent_req_set_callback(subreq, cleanupd_init_trigger, req);
 715         return req;
 716 }
 717
 718 static void cleanupd_init_trigger(struct tevent_req *subreq)
 719 {
 720         struct tevent_req *req = tevent_req_callback_data(
 721                 subreq, struct tevent_req);
 722         struct cleanup_init_state *state = tevent_req_data(
 723                 req, struct cleanup_init_state);
 724         bool ok;
 725
 726         DBG_NOTICE("Triggering cleanupd startup\n");
 727
 728         ok = tevent_wakeup_recv(subreq);
 729         TALLOC_FREE(subreq);
 730         if (!ok) {
 731                 tevent_req_error(req, ENOMEM);
 732                 return;
 733         }
 734
 735         state->ok = cleanupd_init(state->msg, false, state->ppid);
 736         if (state->ok) {
 737                 DBG_WARNING("cleanupd restarted\n");
 738                 tevent_req_done(req);
 739                 return;
 740         }
 741
 742         DBG_NOTICE("cleanupd startup failed, rescheduling\n");
 743
 744         subreq = tevent_wakeup_send(state, state->ev,
 745                                     tevent_timeval_current_ofs(1, 0));
 746         if (tevent_req_nomem(subreq, req)) {
 747                 DBG_ERR("scheduling cleanupd restart failed, giving up\n");
 748                 return;
 749         }
 750
 751         tevent_req_set_callback(subreq, cleanupd_init_trigger, req);
 752         return;
 753 }
 754
 755 static bool cleanupd_init_recv(struct tevent_req *req)
 756 {
 757         struct cleanup_init_state *state = tevent_req_data(
 758                 req, struct cleanup_init_state);
 759
 760         return state->ok;
 761 }
 762
 763 static void cleanupd_started(struct tevent_req *req)
 764 {
 765         bool ok;
 766         NTSTATUS status;
 767         struct smbd_parent_context *parent = tevent_req_callback_data(
 768                 req, struct smbd_parent_context);
 769
 770         ok = cleanupd_init_recv(req);
 771         TALLOC_FREE(req);
 772         if (!ok) {
 773                 DBG_ERR("Failed to restart cleanupd, giving up\n");
 774                 return;
 775         }
 776
 777         status = messaging_send(parent->msg_ctx,
 778                                 parent->cleanupd,
 779                                 MSG_SMB_NOTIFY_CLEANUP,
 780                                 &data_blob_null);
 781         if (!NT_STATUS_IS_OK(status)) {
 782                 DBG_ERR("messaging_send returned %s\n",
 783                         nt_errstr(status));
 784         }
 785 }
 786
 787 static void remove_child_pid(struct smbd_parent_context *parent,
 788                              pid_t pid,
 789                              bool unclean_shutdown)
 790 {
 791         struct smbd_child_pid *child;
 792         NTSTATUS status;
 793         bool ok;
 794
 795         for (child = parent->children; child != NULL; child = child->next) {
 796                 if (child->pid == pid) {
 797                         struct smbd_child_pid *tmp = child;
 798                         DLIST_REMOVE(parent->children, child);
 799                         TALLOC_FREE(tmp);
 800                         parent->num_children -= 1;
 801                         break;
 802                 }
 803         }
 804
 805         if (child == NULL) {
 806                 /* not all forked child processes are added to the children list */
 807                 DEBUG(2, ("Could not find child %d -- ignoring\n", (int)pid));
 808                 return;
 809         }
 810
 811         if (pid == procid_to_pid(&parent->cleanupd)) {
 812                 struct tevent_req *req;
 813
 814                 server_id_set_disconnected(&parent->cleanupd);
 815
 816                 DBG_WARNING("Restarting cleanupd\n");
 817                 req = cleanupd_init_send(messaging_tevent_context(parent->msg_ctx),
 818                                          parent,
 819                                          parent->msg_ctx,
 820                                          &parent->cleanupd);
 821                 if (req == NULL) {
 822                         DBG_ERR("Failed to restart cleanupd\n");
 823                         return;
 824                 }
 825                 tevent_req_set_callback(req, cleanupd_started, parent);
 826                 return;
 827         }
 828
 829         if (pid == procid_to_pid(&parent->notifyd)) {
 830                 struct tevent_req *req;
 831                 struct tevent_context *ev = messaging_tevent_context(
 832                         parent->msg_ctx);
 833
 834                 server_id_set_disconnected(&parent->notifyd);
 835
 836                 DBG_WARNING("Restarting notifyd\n");
 837                 req = notifyd_init_send(ev,
 838                                         parent,
 839                                         parent->msg_ctx,
 840                                         &parent->notifyd);
 841                 if (req == NULL) {
 842                         DBG_ERR("Failed to restart notifyd\n");
 843                         return;
 844                 }
 845                 tevent_req_set_callback(req, notifyd_started, parent);
 846                 return;
 847         }
 848
 849         ok = cleanupdb_store_child(pid, unclean_shutdown);
 850         if (!ok) {
 851                 DBG_ERR("cleanupdb_store_child failed\n");
 852                 return;
 853         }
 854
 855         if (!server_id_is_disconnected(&parent->cleanupd)) {
 856                 status = messaging_send(parent->msg_ctx,
 857                                         parent->cleanupd,
 858                                         MSG_SMB_NOTIFY_CLEANUP,
 859                                         &data_blob_null);
 860                 if (!NT_STATUS_IS_OK(status)) {
 861                         DBG_ERR("messaging_send returned %s\n",
 862                                 nt_errstr(status));
 863                 }
 864         }
 865 }
 866
 867 /****************************************************************************
 868  Have we reached the process limit ?
 869 ****************************************************************************/
 870
 871 static bool allowable_number_of_smbd_processes(struct smbd_parent_context *parent)
 872 {
 873         int max_processes = lp_max_smbd_processes();
 874
 875         if (!max_processes)
 876                 return True;
 877
 878         return parent->num_children < max_processes;
 879 }
 880
 881 static void smbd_sig_chld_handler(struct tevent_context *ev,
 882                                   struct tevent_signal *se,
 883                                   int signum,
 884                                   int count,
 885                                   void *siginfo,
 886                                   void *private_data)
 887 {
 888         pid_t pid;
 889         int status;
 890         struct smbd_parent_context *parent =
 891                 talloc_get_type_abort(private_data,
 892                 struct smbd_parent_context);
 893
 894         while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
 895                 bool unclean_shutdown = False;
 896
 897                 /* If the child terminated normally, assume
 898                    it was an unclean shutdown unless the
 899                    status is 0
 900                 */
 901                 if (WIFEXITED(status)) {
 902                         unclean_shutdown = WEXITSTATUS(status);
 903                 }
 904                 /* If the child terminated due to a signal
 905                    we always assume it was unclean.
 906                 */
 907                 if (WIFSIGNALED(status)) {
 908                         unclean_shutdown = True;
 909                 }
 910                 remove_child_pid(parent, pid, unclean_shutdown);
 911         }
 912 }
 913
 914 static void smbd_setup_sig_chld_handler(struct smbd_parent_context *parent)
 915 {
 916         struct tevent_signal *se;
 917
 918         se = tevent_add_signal(parent->ev_ctx,
 919                                parent, /* mem_ctx */
 920                                SIGCHLD, 0,
 921                                smbd_sig_chld_handler,
 922                                parent);
 923         if (!se) {
 924                 exit_server("failed to setup SIGCHLD handler");
 925         }
 926 }
 927
 928 static void smbd_open_socket_close_fn(struct tevent_context *ev,
 929                                       struct tevent_fd *fde,
 930                                       int fd,
 931                                       void *private_data)
 932 {
 933         /* this might be the socket_wrapper swrap_close() */
 934         close(fd);
 935 }
 936
 937 static void smbd_accept_connection(struct tevent_context *ev,
 938                                    struct tevent_fd *fde,
 939                                    uint16_t flags,
 940                                    void *private_data)
 941 {
 942         struct smbd_open_socket *s = talloc_get_type_abort(private_data,
 943                                      struct smbd_open_socket);
 944         struct messaging_context *msg_ctx = s->parent->msg_ctx;
 945         struct sockaddr_storage addr;
 946         socklen_t in_addrlen = sizeof(addr);
 947         int fd;
 948         pid_t pid = 0;
 949
 950         fd = accept(s->fd, (struct sockaddr *)(void *)&addr,&in_addrlen);
 951         if (fd == -1 && errno == EINTR)
 952                 return;
 953
 954         if (fd == -1) {
 955                 DEBUG(0,("accept: %s\n",
 956                          strerror(errno)));
 957                 return;
 958         }
 959         smb_set_close_on_exec(fd);
 960
 961         if (s->parent->interactive) {
 962                 reinit_after_fork(msg_ctx, ev, true, NULL);
 963                 smbd_process(ev, msg_ctx, fd, true);
 964                 exit_server_cleanly("end of interactive mode");
 965                 return;
 966         }
 967
 968         if (!allowable_number_of_smbd_processes(s->parent)) {
 969                 close(fd);
 970                 return;
 971         }
 972
 973         pid = fork();
 974         if (pid == 0) {
 975                 NTSTATUS status = NT_STATUS_OK;
 976
 977                 /*
 978                  * Can't use TALLOC_FREE here. Nulling out the argument to it
 979                  * would overwrite memory we've just freed.
 980                  */
 981                 talloc_free(s->parent);
 982                 s = NULL;
 983
 984                 /* Stop zombies, the parent explicitly handles
 985                  * them, counting worker smbds. */
 986                 CatchChild();
 987
 988                 status = smbd_reinit_after_fork(msg_ctx, ev, true, NULL);
 989                 if (!NT_STATUS_IS_OK(status)) {
 990                         if (NT_STATUS_EQUAL(status,
 991                                             NT_STATUS_TOO_MANY_OPENED_FILES)) {
 992                                 DEBUG(0,("child process cannot initialize "
 993                                          "because too many files are open\n"));
 994                                 goto exit;
 995                         }
 996                         if (lp_clustering() &&
 997                             (NT_STATUS_EQUAL(
 998                                     status, NT_STATUS_INTERNAL_DB_ERROR) ||
 999                              NT_STATUS_EQUAL(
1000                                     status, NT_STATUS_CONNECTION_REFUSED))) {
1001                                 DEBUG(1, ("child process cannot initialize "
1002                                           "because connection to CTDB "
1003                                           "has failed: %s\n",
1004                                           nt_errstr(status)));
1005                                 goto exit;
1006                         }
1007
1008                         DEBUG(0,("reinit_after_fork() failed\n"));
1009                         smb_panic("reinit_after_fork() failed");
1010                 }
1011
1012                 smbd_process(ev, msg_ctx, fd, false);
1013          exit:
1014                 exit_server_cleanly("end of child");
1015                 return;
1016         }
1017
1018         if (pid < 0) {
1019                 DEBUG(0,("smbd_accept_connection: fork() failed: %s\n",
1020                          strerror(errno)));
1021         }
1022
1023         /* The parent doesn't need this socket */
1024         close(fd);
1025
1026         /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
1027                 Clear the closed fd info out of server_fd --
1028                 and more importantly, out of client_fd in
1029                 util_sock.c, to avoid a possible
1030                 getpeername failure if we reopen the logs
1031                 and use %I in the filename.
1032         */
1033
1034         if (pid != 0) {
1035                 add_child_pid(s->parent, pid);
1036         }
1037
1038         /* Force parent to check log size after
1039          * spawning child.  Fix from
1040          * klausr@ITAP.Physik.Uni-Stuttgart.De.  The
1041          * parent smbd will log to logserver.smb.  It
1042          * writes only two messages for each child
1043          * started/finished. But each child writes,
1044          * say, 50 messages also in logserver.smb,
1045          * begining with the debug_count of the
1046          * parent, before the child opens its own log
1047          * file logserver.client. In a worst case
1048          * scenario the size of logserver.smb would be
1049          * checked after about 50*50=2500 messages
1050          * (ca. 100kb).
1051          * */
1052         force_check_log_size();
1053 }
1054
1055 static bool smbd_open_one_socket(struct smbd_parent_context *parent,
1056                                  struct tevent_context *ev_ctx,
1057                                  const struct sockaddr_storage *ifss,
1058                                  uint16_t port)
1059 {
1060         struct smbd_open_socket *s;
1061
1062         s = talloc(parent, struct smbd_open_socket);
1063         if (!s) {
1064                 return false;
1065         }
1066
1067         s->parent = parent;
1068         s->fd = open_socket_in(SOCK_STREAM,
1069                                port,
1070                                parent->sockets == NULL ? 0 : 2,
1071                                ifss,
1072                                true);
1073         if (s->fd == -1) {
1074                 DEBUG(0,("smbd_open_one_socket: open_socket_in: "
1075                         "%s\n", strerror(errno)));
1076                 TALLOC_FREE(s);
1077                 /*
1078                  * We ignore an error here, as we've done before
1079                  */
1080                 return true;
1081         }
1082
1083         /* ready to listen */
1084         set_socket_options(s->fd, "SO_KEEPALIVE");
1085         set_socket_options(s->fd, lp_socket_options());
1086
1087         /* Set server socket to
1088          * non-blocking for the accept. */
1089         set_blocking(s->fd, False);
1090
1091         if (listen(s->fd, SMBD_LISTEN_BACKLOG) == -1) {
1092                 DEBUG(0,("smbd_open_one_socket: listen: "
1093                         "%s\n", strerror(errno)));
1094                         close(s->fd);
1095                 TALLOC_FREE(s);
1096                 return false;
1097         }
1098
1099         s->fde = tevent_add_fd(ev_ctx,
1100                                s,
1101                                s->fd, TEVENT_FD_READ,
1102                                smbd_accept_connection,
1103                                s);
1104         if (!s->fde) {
1105                 DEBUG(0,("smbd_open_one_socket: "
1106                          "tevent_add_fd: %s\n",
1107                          strerror(errno)));
1108                 close(s->fd);
1109                 TALLOC_FREE(s);
1110                 return false;
1111         }
1112         tevent_fd_set_close_fn(s->fde, smbd_open_socket_close_fn);
1113
1114         DLIST_ADD_END(parent->sockets, s);
1115
1116         return true;
1117 }
1118
1119 /****************************************************************************
1120  Open the socket communication.
1121 ****************************************************************************/
1122
1123 static bool open_sockets_smbd(struct smbd_parent_context *parent,
1124                               struct tevent_context *ev_ctx,
1125                               struct messaging_context *msg_ctx,
1126                               const char *smb_ports)
1127 {
1128         int num_interfaces = iface_count();
1129         int i,j;
1130         const char **ports;
1131         unsigned dns_port = 0;
1132
1133 #ifdef HAVE_ATEXIT
1134         atexit(killkids);
1135 #endif
1136
1137         /* Stop zombies */
1138         smbd_setup_sig_chld_handler(parent);
1139
1140         ports = lp_smb_ports();
1141
1142         /* use a reasonable default set of ports - listing on 445 and 139 */
1143         if (smb_ports) {
1144                 char **l;
1145                 l = str_list_make_v3(talloc_tos(), smb_ports, NULL);
1146                 ports = discard_const_p(const char *, l);
1147         }
1148
1149         for (j = 0; ports && ports[j]; j++) {
1150                 unsigned port = atoi(ports[j]);
1151
1152                 if (port == 0 || port > 0xffff) {
1153                         exit_server_cleanly("Invalid port in the config or on "
1154                                             "the commandline specified!");
1155                 }
1156         }
1157
1158         if (lp_interfaces() && lp_bind_interfaces_only()) {
1159                 /* We have been given an interfaces line, and been
1160                    told to only bind to those interfaces. Create a
1161                    socket per interface and bind to only these.
1162                 */
1163
1164                 /* Now open a listen socket for each of the
1165                    interfaces. */
1166                 for(i = 0; i < num_interfaces; i++) {
1167                         const struct sockaddr_storage *ifss =
1168                                         iface_n_sockaddr_storage(i);
1169                         if (ifss == NULL) {
1170                                 DEBUG(0,("open_sockets_smbd: "
1171                                         "interface %d has NULL IP address !\n",
1172                                         i));
1173                                 continue;
1174                         }
1175
1176                         for (j = 0; ports && ports[j]; j++) {
1177                                 unsigned port = atoi(ports[j]);
1178
1179                                 /* Keep the first port for mDNS service
1180                                  * registration.
1181                                  */
1182                                 if (dns_port == 0) {
1183                                         dns_port = port;
1184                                 }
1185
1186                                 if (!smbd_open_one_socket(parent,
1187                                                           ev_ctx,
1188                                                           ifss,
1189                                                           port)) {
1190                                         return false;
1191                                 }
1192                         }
1193                 }
1194         } else {
1195                 /* Just bind to 0.0.0.0 - accept connections
1196                    from anywhere. */
1197
1198                 const char *sock_addr;
1199                 char *sock_tok;
1200                 const char *sock_ptr;
1201
1202 #ifdef HAVE_IPV6
1203                 sock_addr = "::,0.0.0.0";
1204 #else
1205                 sock_addr = "0.0.0.0";
1206 #endif
1207
1208                 for (sock_ptr=sock_addr;
1209                      next_token_talloc(talloc_tos(), &sock_ptr, &sock_tok, " \t,"); ) {
1210                         for (j = 0; ports && ports[j]; j++) {
1211                                 struct sockaddr_storage ss;
1212                                 unsigned port = atoi(ports[j]);
1213
1214                                 /* Keep the first port for mDNS service
1215                                  * registration.
1216                                  */
1217                                 if (dns_port == 0) {
1218                                         dns_port = port;
1219                                 }
1220
1221                                 /* open an incoming socket */
1222                                 if (!interpret_string_addr(&ss, sock_tok,
1223                                                 AI_NUMERICHOST|AI_PASSIVE)) {
1224                                         continue;
1225                                 }
1226
1227                                 /*
1228                                  * If we fail to open any sockets
1229                                  * in this loop the parent-sockets == NULL
1230                                  * case below will prevent us from starting.
1231                                  */
1232
1233                                 (void)smbd_open_one_socket(parent,
1234                                                   ev_ctx,
1235                                                   &ss,
1236                                                   port);
1237                         }
1238                 }
1239         }
1240
1241         if (parent->sockets == NULL) {
1242                 DEBUG(0,("open_sockets_smbd: No "
1243                         "sockets available to bind to.\n"));
1244                 return false;
1245         }
1246
1247         /* Listen to messages */
1248
1249         messaging_register(msg_ctx, NULL, MSG_SHUTDOWN, msg_exit_server);
1250         messaging_register(msg_ctx, ev_ctx, MSG_SMB_CONF_UPDATED,
1251                            smbd_parent_conf_updated);
1252         messaging_register(msg_ctx, NULL, MSG_SMB_STAT_CACHE_DELETE,
1253                            smb_stat_cache_delete);
1254         messaging_register(msg_ctx, NULL, MSG_DEBUG, smbd_msg_debug);
1255         messaging_register(msg_ctx, NULL, MSG_SMB_FORCE_TDIS,
1256                            smb_parent_send_to_children);
1257         messaging_register(msg_ctx, NULL, MSG_SMB_FORCE_TDIS_DENIED,
1258                            smb_parent_send_to_children);
1259         messaging_register(msg_ctx, NULL, MSG_SMB_KILL_CLIENT_IP,
1260                            smb_parent_send_to_children);
1261         messaging_register(msg_ctx, NULL, MSG_SMB_TELL_NUM_CHILDREN,
1262                            smb_tell_num_children);
1263
1264         messaging_register(msg_ctx, NULL,
1265                            ID_CACHE_DELETE, smbd_parent_id_cache_delete);
1266         messaging_register(msg_ctx, NULL,
1267                            ID_CACHE_KILL, smbd_parent_id_cache_kill);
1268         messaging_register(msg_ctx, NULL, MSG_SMB_NOTIFY_STARTED,
1269                            smb_parent_send_to_children);
1270
1271 #ifdef DEVELOPER
1272         messaging_register(msg_ctx, NULL, MSG_SMB_INJECT_FAULT,
1273                            msg_inject_fault);
1274 #endif
1275
1276 #if defined(DEVELOPER) || defined(ENABLE_SELFTEST)
1277         messaging_register(msg_ctx, NULL, MSG_SMB_SLEEP, msg_sleep);
1278 #endif
1279
1280         if (lp_multicast_dns_register() && (dns_port != 0)) {
1281 #ifdef WITH_DNSSD_SUPPORT
1282                 smbd_setup_mdns_registration(ev_ctx,
1283                                              parent, dns_port);
1284 #endif
1285 #ifdef WITH_AVAHI_SUPPORT
1286                 void *avahi_conn;
1287
1288                 avahi_conn = avahi_start_register(ev_ctx,
1289                                                   ev_ctx,
1290                                                   dns_port);
1291                 if (avahi_conn == NULL) {
1292                         DEBUG(10, ("avahi_start_register failed\n"));
1293                 }
1294 #endif
1295         }
1296
1297         return true;
1298 }
1299
1300
1301 /*
1302   handle stdin becoming readable when we are in --foreground mode
1303  */
1304 static void smbd_stdin_handler(struct tevent_context *ev,
1305                                struct tevent_fd *fde,
1306                                uint16_t flags,
1307                                void *private_data)
1308 {
1309         char c;
1310         if (read(0, &c, 1) != 1) {
1311                 /* we have reached EOF on stdin, which means the
1312                    parent has exited. Shutdown the server */
1313                 exit_server_cleanly("EOF on stdin");
1314         }
1315 }
1316
1317 struct smbd_parent_tevent_trace_state {
1318         TALLOC_CTX *frame;
1319 };
1320
1321 static void smbd_parent_tevent_trace_callback(enum tevent_trace_point point,
1322                                               void *private_data)
1323 {
1324         struct smbd_parent_tevent_trace_state *state =
1325                 (struct smbd_parent_tevent_trace_state *)private_data;
1326
1327         switch (point) {
1328         case TEVENT_TRACE_BEFORE_WAIT:
1329                 break;
1330         case TEVENT_TRACE_AFTER_WAIT:
1331                 break;
1332         case TEVENT_TRACE_BEFORE_LOOP_ONCE:
1333                 TALLOC_FREE(state->frame);
1334                 state->frame = talloc_stackframe();
1335                 break;
1336         case TEVENT_TRACE_AFTER_LOOP_ONCE:
1337                 TALLOC_FREE(state->frame);
1338                 break;
1339         }
1340
1341         errno = 0;
1342 }
1343
1344 static void smbd_parent_loop(struct tevent_context *ev_ctx,
1345                              struct smbd_parent_context *parent)
1346 {
1347         struct smbd_parent_tevent_trace_state trace_state = {
1348                 .frame = NULL,
1349         };
1350         int ret = 0;
1351
1352         tevent_set_trace_callback(ev_ctx, smbd_parent_tevent_trace_callback,
1353                                   &trace_state);
1354
1355         /* now accept incoming connections - forking a new process
1356            for each incoming connection */
1357         DEBUG(2,("waiting for connections\n"));
1358
1359         ret = tevent_loop_wait(ev_ctx);
1360         if (ret != 0) {
1361                 DEBUG(0, ("tevent_loop_wait failed: %d, %s, exiting\n",
1362                           ret, strerror(errno)));
1363         }
1364
1365         TALLOC_FREE(trace_state.frame);
1366
1367 /* NOTREACHED   return True; */
1368 }
1369
1370
1371 /****************************************************************************
1372  Initialise connect, service and file structs.
1373 ****************************************************************************/
1374
1375 static bool init_structs(void )
1376 {
1377         /*
1378          * Set the machine NETBIOS name if not already
1379          * set from the config file.
1380          */
1381
1382         if (!init_names())
1383                 return False;
1384
1385         if (!secrets_init())
1386                 return False;
1387
1388         return True;
1389 }
1390
1391 static void smbd_parent_sig_term_handler(struct tevent_context *ev,
1392                                          struct tevent_signal *se,
1393                                          int signum,
1394                                          int count,
1395                                          void *siginfo,
1396                                          void *private_data)
1397 {
1398         exit_server_cleanly("termination signal");
1399 }
1400
1401 static void smbd_parent_sig_hup_handler(struct tevent_context *ev,
1402                                         struct tevent_signal *se,
1403                                         int signum,
1404                                         int count,
1405                                         void *siginfo,
1406                                         void *private_data)
1407 {
1408         struct smbd_parent_context *parent =
1409                 talloc_get_type_abort(private_data,
1410                 struct smbd_parent_context);
1411
1412         change_to_root_user();
1413         DEBUG(1,("parent: Reloading services after SIGHUP\n"));
1414         reload_services(NULL, NULL, false);
1415
1416         printing_subsystem_update(parent->ev_ctx, parent->msg_ctx, true);
1417 }
1418
1419 struct smbd_claim_version_state {
1420         TALLOC_CTX *mem_ctx;
1421         char *version;
1422 };
1423
1424 static void smbd_claim_version_parser(struct server_id exclusive,
1425                                       size_t num_shared,
1426                                       struct server_id *shared,
1427                                       const uint8_t *data,
1428                                       size_t datalen,
1429                                       void *private_data)
1430 {
1431         struct smbd_claim_version_state *state = private_data;
1432
1433         if (datalen == 0) {
1434                 state->version = NULL;
1435                 return;
1436         }
1437         if (data[datalen-1] != '\0') {
1438                 DBG_WARNING("Invalid samba version\n");
1439                 dump_data(DBGLVL_WARNING, data, datalen);
1440                 state->version = NULL;
1441                 return;
1442         }
1443         state->version = talloc_strdup(state->mem_ctx, (const char *)data);
1444 }
1445
1446 static NTSTATUS smbd_claim_version(struct messaging_context *msg,
1447                                    const char *version)
1448 {
1449         const char *name = "samba_version_string";
1450         struct smbd_claim_version_state state;
1451         struct g_lock_ctx *ctx;
1452         NTSTATUS status;
1453
1454         ctx = g_lock_ctx_init(msg, msg);
1455         if (ctx == NULL) {
1456                 DBG_WARNING("g_lock_ctx_init failed\n");
1457                 return NT_STATUS_UNSUCCESSFUL;
1458         }
1459
1460         status = g_lock_lock(ctx, string_term_tdb_data(name), G_LOCK_READ,
1461                              (struct timeval) { .tv_sec = 60 });
1462         if (!NT_STATUS_IS_OK(status)) {
1463                 DBG_WARNING("g_lock_lock(G_LOCK_READ) failed: %s\n",
1464                             nt_errstr(status));
1465                 TALLOC_FREE(ctx);
1466                 return status;
1467         }
1468
1469         state = (struct smbd_claim_version_state) { .mem_ctx = ctx };
1470
1471         status = g_lock_dump(ctx, string_term_tdb_data(name),
1472                              smbd_claim_version_parser, &state);
1473         if (!NT_STATUS_IS_OK(status) &&
1474             !NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
1475                 DBG_ERR("Could not read samba_version_string\n");
1476                 g_lock_unlock(ctx, string_term_tdb_data(name));
1477                 TALLOC_FREE(ctx);
1478                 return status;
1479         }
1480
1481         if ((state.version != NULL) && (strcmp(version, state.version) == 0)) {
1482                 /*
1483                  * Leave the read lock for us around. Someone else already
1484                  * set the version correctly
1485                  */
1486                 TALLOC_FREE(ctx);
1487                 return NT_STATUS_OK;
1488         }
1489
1490         status = g_lock_lock(ctx, string_term_tdb_data(name), G_LOCK_UPGRADE,
1491                              (struct timeval) { .tv_sec = 60 });
1492         if (!NT_STATUS_IS_OK(status)) {
1493                 DBG_WARNING("g_lock_lock(G_LOCK_WRITE) failed: %s\n",
1494                             nt_errstr(status));
1495                 DBG_ERR("smbd %s already running, refusing to start "
1496                         "version %s\n", state.version, version);
1497                 TALLOC_FREE(ctx);
1498                 return NT_STATUS_SXS_VERSION_CONFLICT;
1499         }
1500
1501         status = g_lock_write_data(ctx, string_term_tdb_data(name),
1502                                    (const uint8_t *)version,
1503                                    strlen(version)+1);
1504         if (!NT_STATUS_IS_OK(status)) {
1505                 DBG_WARNING("g_lock_write_data failed: %s\n",
1506                             nt_errstr(status));
1507                 TALLOC_FREE(ctx);
1508                 return status;
1509         }
1510
1511         status = g_lock_lock(ctx, string_term_tdb_data(name), G_LOCK_READ,
1512                              (struct timeval) { .tv_sec = 60 });
1513         if (!NT_STATUS_IS_OK(status)) {
1514                 DBG_WARNING("g_lock_lock(G_LOCK_READ) failed: %s\n",
1515                             nt_errstr(status));
1516                 TALLOC_FREE(ctx);
1517                 return status;
1518         }
1519
1520         /*
1521          * Leave "ctx" dangling so that g_lock.tdb keeps opened.
1522          */
1523         return NT_STATUS_OK;
1524 }
1525
1526 /****************************************************************************
1527  main program.
1528 ****************************************************************************/
1529
1530 /* Declare prototype for build_options() to avoid having to run it through
1531    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
1532    prototype generation system is too complicated. */
1533
1534 extern void build_options(bool screen);
1535
1536  int main(int argc,const char *argv[])
1537 {
1538         /* shall I run as a daemon */
1539         bool is_daemon = false;
1540         bool interactive = false;
1541         bool Fork = true;
1542         bool no_process_group = false;
1543         bool log_stdout = false;
1544         char *ports = NULL;
1545         char *profile_level = NULL;
1546         int opt;
1547         poptContext pc;
1548         bool print_build_options = False;
1549         struct server_id main_server_id = {0};
1550         enum {
1551                 OPT_DAEMON = 1000,
1552                 OPT_INTERACTIVE,
1553                 OPT_FORK,
1554                 OPT_NO_PROCESS_GROUP,
1555                 OPT_LOG_STDOUT
1556         };
1557         struct poptOption long_options[] = {
1558                 POPT_AUTOHELP
1559                 {
1560                         .longName   = "daemon",
1561                         .shortName  = 'D',
1562                         .argInfo    = POPT_ARG_NONE,
1563                         .arg        = NULL,
1564                         .val        = OPT_DAEMON,
1565                         .descrip    = "Become a daemon (default)" ,
1566                 },
1567                 {
1568                         .longName   = "interactive",
1569                         .shortName  = 'i',
1570                         .argInfo    = POPT_ARG_NONE,
1571                         .arg        = NULL,
1572                         .val        = OPT_INTERACTIVE,
1573                         .descrip    = "Run interactive (not a daemon) and log to stdout",
1574                 },
1575                 {
1576                         .longName   = "foreground",
1577                         .shortName  = 'F',
1578                         .argInfo    = POPT_ARG_NONE,
1579                         .arg        = NULL,
1580                         .val        = OPT_FORK,
1581                         .descrip    = "Run daemon in foreground (for daemontools, etc.)",
1582                 },
1583                 {
1584                         .longName   = "no-process-group",
1585                         .shortName  = '\0',
1586                         .argInfo    = POPT_ARG_NONE,
1587                         .arg        = NULL,
1588                         .val        = OPT_NO_PROCESS_GROUP,
1589                         .descrip    = "Don't create a new process group" ,
1590                 },
1591                 {
1592                         .longName   = "log-stdout",
1593                         .shortName  = 'S',
1594                         .argInfo    = POPT_ARG_NONE,
1595                         .arg        = NULL,
1596                         .val        = OPT_LOG_STDOUT,
1597                         .descrip    = "Log to stdout" ,
1598                 },
1599                 {
1600                         .longName   = "build-options",
1601                         .shortName  = 'b',
1602                         .argInfo    = POPT_ARG_NONE,
1603                         .arg        = NULL,
1604                         .val        = 'b',
1605                         .descrip    = "Print build options" ,
1606                 },
1607                 {
1608                         .longName   = "port",
1609                         .shortName  = 'p',
1610                         .argInfo    = POPT_ARG_STRING,
1611                         .arg        = &ports,
1612                         .val        = 0,
1613                         .descrip    = "Listen on the specified ports",
1614                 },
1615                 {
1616                         .longName   = "profiling-level",
1617                         .shortName  = 'P',
1618                         .argInfo    = POPT_ARG_STRING,
1619                         .arg        = &profile_level,
1620                         .val        = 0,
1621                         .descrip    = "Set profiling level","PROFILE_LEVEL",
1622                 },
1623                 POPT_COMMON_SAMBA
1624                 POPT_TABLEEND
1625         };
1626         struct smbd_parent_context *parent = NULL;
1627         TALLOC_CTX *frame;
1628         NTSTATUS status;
1629         struct tevent_context *ev_ctx;
1630         struct messaging_context *msg_ctx;
1631         struct server_id server_id;
1632         struct tevent_signal *se;
1633         int profiling_level;
1634         char *np_dir = NULL;
1635         const struct loadparm_substitution *lp_sub =
1636                 loadparm_s3_global_substitution();
1637         static const struct smbd_shim smbd_shim_fns =
1638         {
1639                 .send_stat_cache_delete_message = smbd_send_stat_cache_delete_message,
1640                 .change_to_root_user = smbd_change_to_root_user,
1641                 .become_authenticated_pipe_user = smbd_become_authenticated_pipe_user,
1642                 .unbecome_authenticated_pipe_user = smbd_unbecome_authenticated_pipe_user,
1643
1644                 .contend_level2_oplocks_begin = smbd_contend_level2_oplocks_begin,
1645                 .contend_level2_oplocks_end = smbd_contend_level2_oplocks_end,
1646
1647                 .become_root = smbd_become_root,
1648                 .unbecome_root = smbd_unbecome_root,
1649
1650                 .exit_server = smbd_exit_server,
1651                 .exit_server_cleanly = smbd_exit_server_cleanly,
1652         };
1653
1654         /*
1655          * Do this before any other talloc operation
1656          */
1657         talloc_enable_null_tracking();
1658         frame = talloc_stackframe();
1659
1660         setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
1661
1662         smb_init_locale();
1663
1664         set_smbd_shim(&smbd_shim_fns);
1665
1666         smbd_init_globals();
1667
1668         TimeInit();
1669
1670 #ifdef HAVE_SET_AUTH_PARAMETERS
1671         set_auth_parameters(argc,argv);
1672 #endif
1673
1674         pc = poptGetContext("smbd", argc, argv, long_options, 0);
1675         while((opt = poptGetNextOpt(pc)) != -1) {
1676                 switch (opt)  {
1677                 case OPT_DAEMON:
1678                         is_daemon = true;
1679                         break;
1680                 case OPT_INTERACTIVE:
1681                         interactive = true;
1682                         break;
1683                 case OPT_FORK:
1684                         Fork = false;
1685                         break;
1686                 case OPT_NO_PROCESS_GROUP:
1687                         no_process_group = true;
1688                         break;
1689                 case OPT_LOG_STDOUT:
1690                         log_stdout = true;
1691                         break;
1692                 case 'b':
1693                         print_build_options = True;
1694                         break;
1695                 default:
1696                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1697                                   poptBadOption(pc, 0), poptStrerror(opt));
1698                         poptPrintUsage(pc, stderr, 0);
1699                         exit(1);
1700                 }
1701         }
1702         poptFreeContext(pc);
1703
1704         if (interactive) {
1705                 Fork = False;
1706                 log_stdout = True;
1707         }
1708
1709         if (log_stdout) {
1710                 setup_logging(argv[0], DEBUG_STDOUT);
1711         } else {
1712                 setup_logging(argv[0], DEBUG_FILE);
1713         }
1714
1715         if (print_build_options) {
1716                 build_options(True); /* Display output to screen as well as debug */
1717                 exit(0);
1718         }
1719
1720 #ifdef HAVE_SETLUID
1721         /* needed for SecureWare on SCO */
1722         setluid(0);
1723 #endif
1724
1725         set_remote_machine_name("smbd", False);
1726
1727         if (interactive && (DEBUGLEVEL >= 9)) {
1728                 talloc_enable_leak_report();
1729         }
1730
1731         if (log_stdout && Fork) {
1732                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1733                 exit(1);
1734         }
1735
1736         /*
1737          * We want to die early if we can't open /dev/urandom
1738          */
1739         generate_random_buffer(NULL, 0);
1740
1741         /* get initial effective uid and gid */
1742         sec_init();
1743
1744         /* make absolutely sure we run as root - to handle cases where people
1745            are crazy enough to have it setuid */
1746         gain_root_privilege();
1747         gain_root_group_privilege();
1748
1749         fault_setup();
1750         dump_core_setup("smbd", lp_logfile(talloc_tos(), lp_sub));
1751
1752         /* we are never interested in SIGPIPE */
1753         BlockSignals(True,SIGPIPE);
1754
1755 #if defined(SIGFPE)
1756         /* we are never interested in SIGFPE */
1757         BlockSignals(True,SIGFPE);
1758 #endif
1759
1760 #if defined(SIGUSR2)
1761         /* We are no longer interested in USR2 */
1762         BlockSignals(True,SIGUSR2);
1763 #endif
1764
1765         /* POSIX demands that signals are inherited. If the invoking process has
1766          * these signals masked, we will have problems, as we won't recieve them. */
1767         BlockSignals(False, SIGHUP);
1768         BlockSignals(False, SIGUSR1);
1769         BlockSignals(False, SIGTERM);
1770
1771         /* Ensure we leave no zombies until we
1772          * correctly set up child handling below. */
1773
1774         CatchChild();
1775
1776         /* we want total control over the permissions on created files,
1777            so set our umask to 0 */
1778         umask(0);
1779
1780         reopen_logs();
1781
1782         DEBUG(0,("smbd version %s started.\n", samba_version_string()));
1783         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1784
1785         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1786                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1787
1788         /* Output the build options to the debug log */
1789         build_options(False);
1790
1791         if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4) {
1792                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1793                 exit(1);
1794         }
1795
1796         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1797                 DEBUG(0, ("error opening config file '%s'\n", get_dyn_CONFIGFILE()));
1798                 exit(1);
1799         }
1800
1801         /*
1802          * This calls unshare(CLONE_FS); on linux
1803          * in order to check if the running kernel/container
1804          * environment supports it.
1805          */
1806         per_thread_cwd_check();
1807
1808         if (!cluster_probe_ok()) {
1809                 exit(1);
1810         }
1811
1812         /* Init the security context and global current_user */
1813         init_sec_ctx();
1814
1815         /*
1816          * Initialize the event context. The event context needs to be
1817          * initialized before the messaging context, cause the messaging
1818          * context holds an event context.
1819          */
1820         ev_ctx = global_event_context();
1821         if (ev_ctx == NULL) {
1822                 exit(1);
1823         }
1824
1825         /*
1826          * Init the messaging context
1827          * FIXME: This should only call messaging_init()
1828          */
1829         msg_ctx = global_messaging_context();
1830         if (msg_ctx == NULL) {
1831                 exit(1);
1832         }
1833
1834         /*
1835          * Reloading of the printers will not work here as we don't have a
1836          * server info and rpc services set up. It will be called later.
1837          */
1838         if (!reload_services(NULL, NULL, false)) {
1839                 exit(1);
1840         }
1841
1842         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
1843             && !lp_parm_bool(-1, "server role check", "inhibit", false)) {
1844                 DEBUG(0, ("server role = 'active directory domain controller' not compatible with running smbd standalone. \n"));
1845                 DEBUGADD(0, ("You should start 'samba' instead, and it will control starting smbd if required\n"));
1846                 exit(1);
1847         }
1848
1849         /* ...NOTE... Log files are working from this point! */
1850
1851         DEBUG(3,("loaded services\n"));
1852
1853         init_structs();
1854
1855         if (!profile_setup(msg_ctx, False)) {
1856                 DEBUG(0,("ERROR: failed to setup profiling\n"));
1857                 return -1;
1858         }
1859
1860         if (profile_level != NULL) {
1861                 profiling_level = atoi(profile_level);
1862         } else {
1863                 profiling_level = lp_smbd_profiling_level();
1864         }
1865         main_server_id = messaging_server_id(msg_ctx);
1866         set_profile_level(profiling_level, &main_server_id);
1867
1868         if (!is_daemon && !is_a_socket(0)) {
1869                 if (!interactive) {
1870                         DEBUG(3, ("Standard input is not a socket, "
1871                                   "assuming -D option\n"));
1872                 }
1873
1874                 /*
1875                  * Setting is_daemon here prevents us from eventually calling
1876                  * the open_sockets_inetd()
1877                  */
1878
1879                 is_daemon = True;
1880         }
1881
1882         if (is_daemon && !interactive) {
1883                 DEBUG(3, ("Becoming a daemon.\n"));
1884                 become_daemon(Fork, no_process_group, log_stdout);
1885         }
1886
1887 #ifdef HAVE_SETPGID
1888         /*
1889          * If we're interactive we want to set our own process group for
1890          * signal management.
1891          */
1892         if (interactive && !no_process_group)
1893                 setpgid( (pid_t)0, (pid_t)0);
1894 #endif
1895
1896         if (!directory_exist(lp_lock_directory()))
1897                 mkdir(lp_lock_directory(), 0755);
1898
1899         if (!directory_exist(lp_pid_directory()))
1900                 mkdir(lp_pid_directory(), 0755);
1901
1902         if (is_daemon)
1903                 pidfile_create(lp_pid_directory(), "smbd");
1904
1905         status = reinit_after_fork(msg_ctx, ev_ctx, false, NULL);
1906         if (!NT_STATUS_IS_OK(status)) {
1907                 exit_daemon("reinit_after_fork() failed", map_errno_from_nt_status(status));
1908         }
1909
1910         if (!interactive) {
1911                 /*
1912                  * Do not initialize the parent-child-pipe before becoming a
1913                  * daemon: this is used to detect a died parent in the child
1914                  * process.
1915                  */
1916                 status = init_before_fork();
1917                 if (!NT_STATUS_IS_OK(status)) {
1918                         exit_daemon(nt_errstr(status), map_errno_from_nt_status(status));
1919                 }
1920         }
1921
1922         parent = talloc_zero(ev_ctx, struct smbd_parent_context);
1923         if (!parent) {
1924                 exit_server("talloc(struct smbd_parent_context) failed");
1925         }
1926         parent->interactive = interactive;
1927         parent->ev_ctx = ev_ctx;
1928         parent->msg_ctx = msg_ctx;
1929         am_parent = parent;
1930
1931         se = tevent_add_signal(parent->ev_ctx,
1932                                parent,
1933                                SIGTERM, 0,
1934                                smbd_parent_sig_term_handler,
1935                                parent);
1936         if (!se) {
1937                 exit_server("failed to setup SIGTERM handler");
1938         }
1939         se = tevent_add_signal(parent->ev_ctx,
1940                                parent,
1941                                SIGHUP, 0,
1942                                smbd_parent_sig_hup_handler,
1943                                parent);
1944         if (!se) {
1945                 exit_server("failed to setup SIGHUP handler");
1946         }
1947
1948         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1949
1950         if (smbd_memcache() == NULL) {
1951                 exit_daemon("no memcache available", EACCES);
1952         }
1953
1954         memcache_set_global(smbd_memcache());
1955
1956         /* Initialise the password backed before the global_sam_sid
1957            to ensure that we fetch from ldap before we make a domain sid up */
1958
1959         if(!initialize_password_db(false, ev_ctx))
1960                 exit(1);
1961
1962         if (!secrets_init()) {
1963                 exit_daemon("smbd can not open secrets.tdb", EACCES);
1964         }
1965
1966         if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC) {
1967                 struct loadparm_context *lp_ctx = loadparm_init_s3(NULL, loadparm_s3_helpers());
1968                 if (!open_schannel_session_store(NULL, lp_ctx)) {
1969                         exit_daemon("ERROR: Samba cannot open schannel store for secured NETLOGON operations.", EACCES);
1970                 }
1971                 TALLOC_FREE(lp_ctx);
1972         }
1973
1974         if(!get_global_sam_sid()) {
1975                 exit_daemon("Samba cannot create a SAM SID", EACCES);
1976         }
1977
1978         server_id = messaging_server_id(msg_ctx);
1979         status = smbXsrv_version_global_init(&server_id);
1980         if (!NT_STATUS_IS_OK(status)) {
1981                 exit_daemon("Samba cannot init server context", EACCES);
1982         }
1983
1984         status = smbXsrv_client_global_init();
1985         if (!NT_STATUS_IS_OK(status)) {
1986                 exit_daemon("Samba cannot init clients context", EACCES);
1987         }
1988
1989         status = smbXsrv_session_global_init(msg_ctx);
1990         if (!NT_STATUS_IS_OK(status)) {
1991                 exit_daemon("Samba cannot init session context", EACCES);
1992         }
1993
1994         status = smbXsrv_tcon_global_init();
1995         if (!NT_STATUS_IS_OK(status)) {
1996                 exit_daemon("Samba cannot init tcon context", EACCES);
1997         }
1998
1999         if (!locking_init())
2000                 exit_daemon("Samba cannot init locking", EACCES);
2001
2002         if (!leases_db_init(false)) {
2003                 exit_daemon("Samba cannot init leases", EACCES);
2004         }
2005
2006         if (!smbd_notifyd_init(msg_ctx, interactive, &parent->notifyd)) {
2007                 exit_daemon("Samba cannot init notification", EACCES);
2008         }
2009
2010         if (!cleanupd_init(msg_ctx, interactive, &parent->cleanupd)) {
2011                 exit_daemon("Samba cannot init the cleanupd", EACCES);
2012         }
2013
2014         if (!messaging_parent_dgm_cleanup_init(msg_ctx)) {
2015                 exit(1);
2016         }
2017
2018         if (!smbd_scavenger_init(NULL, msg_ctx, ev_ctx)) {
2019                 exit_daemon("Samba cannot init scavenging", EACCES);
2020         }
2021
2022         if (!W_ERROR_IS_OK(registry_init_full()))
2023                 exit_daemon("Samba cannot init registry", EACCES);
2024
2025         /* Open the share_info.tdb here, so we don't have to open
2026            after the fork on every single connection.  This is a small
2027            performance improvment and reduces the total number of system
2028            fds used. */
2029         status = share_info_db_init();
2030         if (!NT_STATUS_IS_OK(status)) {
2031                 exit_daemon("ERROR: failed to load share info db.", EACCES);
2032         }
2033
2034         status = init_system_session_info(NULL);
2035         if (!NT_STATUS_IS_OK(status)) {
2036                 DEBUG(1, ("ERROR: failed to setup system user info: %s.\n",
2037                           nt_errstr(status)));
2038                 return -1;
2039         }
2040
2041         if (!init_guest_session_info(NULL)) {
2042                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
2043                 return -1;
2044         }
2045
2046         if (!file_init_global()) {
2047                 DEBUG(0, ("ERROR: file_init_global() failed\n"));
2048                 return -1;
2049         }
2050         status = smbXsrv_open_global_init();
2051         if (!NT_STATUS_IS_OK(status)) {
2052                 exit_daemon("Samba cannot init global open", map_errno_from_nt_status(status));
2053         }
2054
2055         if (lp_clustering() && !lp_allow_unsafe_cluster_upgrade()) {
2056                 status = smbd_claim_version(msg_ctx, samba_version_string());
2057                 if (!NT_STATUS_IS_OK(status)) {
2058                         DBG_ERR("Could not claim version: %s\n",
2059                                     nt_errstr(status));
2060                         return -1;
2061                 }
2062         }
2063
2064         /* This MUST be done before start_epmd() because otherwise
2065          * start_epmd() forks and races against dcesrv_ep_setup() to
2066          * call directory_create_or_exist() */
2067         if (!directory_create_or_exist(lp_ncalrpc_dir(), 0755)) {
2068                 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
2069                           lp_ncalrpc_dir(), strerror(errno)));
2070                 return -1;
2071         }
2072
2073         np_dir = talloc_asprintf(talloc_tos(), "%s/np", lp_ncalrpc_dir());
2074         if (!np_dir) {
2075                 DEBUG(0, ("%s: Out of memory\n", __location__));
2076                 return -1;
2077         }
2078
2079         if (!directory_create_or_exist_strict(np_dir, geteuid(), 0700)) {
2080                 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
2081                           np_dir, strerror(errno)));
2082                 return -1;
2083         }
2084
2085         if (is_daemon && !interactive) {
2086                 if (rpc_epmapper_daemon() == RPC_DAEMON_FORK) {
2087                         start_epmd(ev_ctx, msg_ctx);
2088                 }
2089         }
2090
2091         status = dcesrv_ep_setup(ev_ctx, msg_ctx);
2092         if (!NT_STATUS_IS_OK(status)) {
2093                 DBG_ERR("Failed to setup RPC server: %s\n", nt_errstr(status));
2094                 exit_daemon("Samba cannot setup ep pipe", EACCES);
2095         }
2096
2097         if (is_daemon && !interactive) {
2098                 daemon_ready("smbd");
2099         }
2100
2101         /* only start other daemons if we are running as a daemon
2102          * -- bad things will happen if smbd is launched via inetd
2103          *  and we fork a copy of ourselves here */
2104         if (is_daemon && !interactive) {
2105
2106                 if (rpc_lsasd_daemon() == RPC_DAEMON_FORK) {
2107                         start_lsasd(ev_ctx, msg_ctx);
2108                 }
2109
2110                 if (rpc_fss_daemon() == RPC_DAEMON_FORK) {
2111                         start_fssd(ev_ctx, msg_ctx);
2112                 }
2113
2114                 if (!lp__disable_spoolss() &&
2115                     (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
2116                         bool bgq = lp_parm_bool(-1, "smbd", "backgroundqueue", true);
2117
2118                         if (!printing_subsystem_init(ev_ctx, msg_ctx, true, bgq)) {
2119                                 exit_daemon("Samba failed to init printing subsystem", EACCES);
2120                         }
2121                 }
2122
2123 #ifdef WITH_SPOTLIGHT
2124                 if ((rpc_mdssvc_mode() == RPC_SERVICE_MODE_EXTERNAL) &&
2125                     (rpc_mdssd_daemon() == RPC_DAEMON_FORK)) {
2126                         start_mdssd(ev_ctx, msg_ctx);
2127                 }
2128 #endif
2129         } else if (!lp__disable_spoolss() &&
2130                    (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
2131                 if (!printing_subsystem_init(ev_ctx, msg_ctx, false, false)) {
2132                         exit(1);
2133                 }
2134         }
2135
2136         if (!is_daemon) {
2137                 int sock;
2138
2139                 /* inetd mode */
2140                 TALLOC_FREE(frame);
2141
2142                 /* Started from inetd. fd 0 is the socket. */
2143                 /* We will abort gracefully when the client or remote system
2144                    goes away */
2145                 sock = dup(0);
2146
2147                 /* close stdin, stdout (if not logging to it), but not stderr */
2148                 close_low_fds(true, !debug_get_output_is_stdout(), false);
2149
2150 #ifdef HAVE_ATEXIT
2151                 atexit(killkids);
2152 #endif
2153
2154                 /* Stop zombies */
2155                 smbd_setup_sig_chld_handler(parent);
2156
2157                 smbd_process(ev_ctx, msg_ctx, sock, true);
2158
2159                 exit_server_cleanly(NULL);
2160                 return(0);
2161         }
2162
2163         if (!open_sockets_smbd(parent, ev_ctx, msg_ctx, ports))
2164                 exit_server("open_sockets_smbd() failed");
2165
2166         /* do a printer update now that all messaging has been set up,
2167          * before we allow clients to start connecting */
2168         if (!lp__disable_spoolss() &&
2169             (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
2170                 printing_subsystem_update(ev_ctx, msg_ctx, false);
2171         }
2172
2173         TALLOC_FREE(frame);
2174         /* make sure we always have a valid stackframe */
2175         frame = talloc_stackframe();
2176
2177         if (!Fork) {
2178                 /* if we are running in the foreground then look for
2179                    EOF on stdin, and exit if it happens. This allows
2180                    us to die if the parent process dies
2181                    Only do this on a pipe or socket, no other device.
2182                 */
2183                 struct stat st;
2184                 if (fstat(0, &st) != 0) {
2185                         return false;
2186                 }
2187                 if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
2188                         tevent_add_fd(ev_ctx,
2189                                         parent,
2190                                         0,
2191                                         TEVENT_FD_READ,
2192                                         smbd_stdin_handler,
2193                                         NULL);
2194                 }
2195         }
2196
2197         smbd_parent_loop(ev_ctx, parent);
2198
2199         exit_server_cleanly(NULL);
2200         TALLOC_FREE(frame);
2201         return(0);
2202 }