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