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