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