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 #ifdef DEVELOPER
1288         messaging_register(msg_ctx, NULL, MSG_SMB_INJECT_FAULT,
1289                            msg_inject_fault);
1290 #endif
1291
1292 #if defined(DEVELOPER) || defined(ENABLE_SELFTEST)
1293         messaging_register(msg_ctx, NULL, MSG_SMB_SLEEP, msg_sleep);
1294 #endif
1295
1296         if (lp_multicast_dns_register() && (dns_port != 0)) {
1297 #ifdef WITH_DNSSD_SUPPORT
1298                 smbd_setup_mdns_registration(ev_ctx,
1299                                              parent, dns_port);
1300 #endif
1301 #ifdef WITH_AVAHI_SUPPORT
1302                 void *avahi_conn;
1303
1304                 avahi_conn = avahi_start_register(ev_ctx,
1305                                                   ev_ctx,
1306                                                   dns_port);
1307                 if (avahi_conn == NULL) {
1308                         DEBUG(10, ("avahi_start_register failed\n"));
1309                 }
1310 #endif
1311         }
1312
1313         return true;
1314 }
1315
1316
1317 /*
1318   handle stdin becoming readable when we are in --foreground mode
1319  */
1320 static void smbd_stdin_handler(struct tevent_context *ev,
1321                                struct tevent_fd *fde,
1322                                uint16_t flags,
1323                                void *private_data)
1324 {
1325         char c;
1326         if (read(0, &c, 1) != 1) {
1327                 /* we have reached EOF on stdin, which means the
1328                    parent has exited. Shutdown the server */
1329                 exit_server_cleanly("EOF on stdin");
1330         }
1331 }
1332
1333 struct smbd_parent_tevent_trace_state {
1334         TALLOC_CTX *frame;
1335 };
1336
1337 static void smbd_parent_tevent_trace_callback(enum tevent_trace_point point,
1338                                               void *private_data)
1339 {
1340         struct smbd_parent_tevent_trace_state *state =
1341                 (struct smbd_parent_tevent_trace_state *)private_data;
1342
1343         switch (point) {
1344         case TEVENT_TRACE_BEFORE_WAIT:
1345                 break;
1346         case TEVENT_TRACE_AFTER_WAIT:
1347                 break;
1348         case TEVENT_TRACE_BEFORE_LOOP_ONCE:
1349                 TALLOC_FREE(state->frame);
1350                 state->frame = talloc_stackframe();
1351                 break;
1352         case TEVENT_TRACE_AFTER_LOOP_ONCE:
1353                 TALLOC_FREE(state->frame);
1354                 break;
1355         }
1356
1357         errno = 0;
1358 }
1359
1360 static void smbd_parent_loop(struct tevent_context *ev_ctx,
1361                              struct smbd_parent_context *parent)
1362 {
1363         struct smbd_parent_tevent_trace_state trace_state = {
1364                 .frame = NULL,
1365         };
1366         int ret = 0;
1367
1368         tevent_set_trace_callback(ev_ctx, smbd_parent_tevent_trace_callback,
1369                                   &trace_state);
1370
1371         /* now accept incoming connections - forking a new process
1372            for each incoming connection */
1373         DEBUG(2,("waiting for connections\n"));
1374
1375         ret = tevent_loop_wait(ev_ctx);
1376         if (ret != 0) {
1377                 DEBUG(0, ("tevent_loop_wait failed: %d, %s, exiting\n",
1378                           ret, strerror(errno)));
1379         }
1380
1381         TALLOC_FREE(trace_state.frame);
1382
1383 /* NOTREACHED   return True; */
1384 }
1385
1386
1387 /****************************************************************************
1388  Initialise connect, service and file structs.
1389 ****************************************************************************/
1390
1391 static bool init_structs(void )
1392 {
1393         /*
1394          * Set the machine NETBIOS name if not already
1395          * set from the config file.
1396          */
1397
1398         if (!secrets_init())
1399                 return False;
1400
1401         return True;
1402 }
1403
1404 static void smbd_parent_sig_term_handler(struct tevent_context *ev,
1405                                          struct tevent_signal *se,
1406                                          int signum,
1407                                          int count,
1408                                          void *siginfo,
1409                                          void *private_data)
1410 {
1411         exit_server_cleanly("termination signal");
1412 }
1413
1414 static void smbd_parent_sig_hup_handler(struct tevent_context *ev,
1415                                         struct tevent_signal *se,
1416                                         int signum,
1417                                         int count,
1418                                         void *siginfo,
1419                                         void *private_data)
1420 {
1421         change_to_root_user();
1422         DEBUG(1,("parent: Reloading services after SIGHUP\n"));
1423         reload_services(NULL, NULL, false);
1424 }
1425
1426 struct smbd_claim_version_state {
1427         TALLOC_CTX *mem_ctx;
1428         char *version;
1429 };
1430
1431 static void smbd_claim_version_parser(struct server_id exclusive,
1432                                       size_t num_shared,
1433                                       const struct server_id *shared,
1434                                       const uint8_t *data,
1435                                       size_t datalen,
1436                                       void *private_data)
1437 {
1438         struct smbd_claim_version_state *state = private_data;
1439
1440         if (datalen == 0) {
1441                 state->version = NULL;
1442                 return;
1443         }
1444         if (data[datalen-1] != '\0') {
1445                 DBG_WARNING("Invalid samba version\n");
1446                 dump_data(DBGLVL_WARNING, data, datalen);
1447                 state->version = NULL;
1448                 return;
1449         }
1450         state->version = talloc_strdup(state->mem_ctx, (const char *)data);
1451 }
1452
1453 static NTSTATUS smbd_claim_version(struct messaging_context *msg,
1454                                    const char *version)
1455 {
1456         const char *name = "samba_version_string";
1457         const TDB_DATA key = string_term_tdb_data(name);
1458         struct smbd_claim_version_state state;
1459         struct g_lock_ctx *ctx;
1460         NTSTATUS status;
1461
1462         ctx = g_lock_ctx_init(msg, msg);
1463         if (ctx == NULL) {
1464                 DBG_WARNING("g_lock_ctx_init failed\n");
1465                 return NT_STATUS_UNSUCCESSFUL;
1466         }
1467
1468         status = g_lock_lock(ctx,
1469                              key,
1470                              G_LOCK_READ,
1471                              (struct timeval) { .tv_sec = 60 },
1472                              NULL,
1473                              NULL);
1474         if (!NT_STATUS_IS_OK(status)) {
1475                 DBG_WARNING("g_lock_lock(G_LOCK_READ) failed: %s\n",
1476                             nt_errstr(status));
1477                 TALLOC_FREE(ctx);
1478                 return status;
1479         }
1480
1481         state = (struct smbd_claim_version_state) { .mem_ctx = ctx };
1482
1483         status = g_lock_dump(ctx, key, smbd_claim_version_parser, &state);
1484         if (!NT_STATUS_IS_OK(status) &&
1485             !NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
1486                 DBG_ERR("Could not read samba_version_string\n");
1487                 g_lock_unlock(ctx, key);
1488                 TALLOC_FREE(ctx);
1489                 return status;
1490         }
1491
1492         if ((state.version != NULL) && (strcmp(version, state.version) == 0)) {
1493                 /*
1494                  * Leave the read lock for us around. Someone else already
1495                  * set the version correctly
1496                  */
1497                 TALLOC_FREE(ctx);
1498                 return NT_STATUS_OK;
1499         }
1500
1501         status = g_lock_lock(ctx,
1502                              key,
1503                              G_LOCK_UPGRADE,
1504                              (struct timeval) { .tv_sec = 60 },
1505                              NULL,
1506                              NULL);
1507         if (!NT_STATUS_IS_OK(status)) {
1508                 DBG_WARNING("g_lock_lock(G_LOCK_WRITE) failed: %s\n",
1509                             nt_errstr(status));
1510                 DBG_ERR("smbd %s already running, refusing to start "
1511                         "version %s\n", state.version, version);
1512                 TALLOC_FREE(ctx);
1513                 return NT_STATUS_SXS_VERSION_CONFLICT;
1514         }
1515
1516         status = g_lock_write_data(
1517                 ctx, key, (const uint8_t *)version, strlen(version)+1);
1518         if (!NT_STATUS_IS_OK(status)) {
1519                 DBG_WARNING("g_lock_write_data failed: %s\n",
1520                             nt_errstr(status));
1521                 TALLOC_FREE(ctx);
1522                 return status;
1523         }
1524
1525         status = g_lock_lock(ctx,
1526                              key,
1527                              G_LOCK_DOWNGRADE,
1528                              (struct timeval) { .tv_sec = 60 },
1529                              NULL,
1530                              NULL);
1531         if (!NT_STATUS_IS_OK(status)) {
1532                 DBG_WARNING("g_lock_lock(G_LOCK_READ) failed: %s\n",
1533                             nt_errstr(status));
1534                 TALLOC_FREE(ctx);
1535                 return status;
1536         }
1537
1538         /*
1539          * Leave "ctx" dangling so that g_lock.tdb keeps opened.
1540          */
1541         return NT_STATUS_OK;
1542 }
1543
1544 /****************************************************************************
1545  Open socket communication on given ip address
1546 ****************************************************************************/
1547
1548 static bool smbd_open_socket_for_ip(struct smbd_parent_context *parent,
1549                                     struct tevent_context *ev_ctx,
1550                                     struct messaging_context *msg_ctx,
1551                                     const char *smb_ports,
1552                                     const struct sockaddr_storage *ifss)
1553 {
1554         int j;
1555         const char **ports;
1556         unsigned dns_port = 0;
1557         TALLOC_CTX *ctx;
1558         bool status = true;
1559
1560         ports = lp_smb_ports();
1561         ctx = talloc_stackframe();
1562
1563         /* use a reasonable default set of ports - listing on 445 and 139 */
1564         if (smb_ports) {
1565                 char **l;
1566                 l = str_list_make_v3(ctx, smb_ports, NULL);
1567                 ports = discard_const_p(const char *, l);
1568         }
1569
1570         for (j = 0; ports && ports[j]; j++) {
1571                 unsigned port = atoi(ports[j]);
1572
1573                 /* Keep the first port for mDNS service
1574                  * registration.
1575                  */
1576                 if (dns_port == 0) {
1577                         dns_port = port;
1578                 }
1579
1580                 if (!smbd_open_one_socket(parent,
1581                                           ev_ctx,
1582                                           ifss,
1583                                           port)) {
1584                         status = false;
1585                         goto out_free;
1586                 }
1587         }
1588
1589 out_free:
1590         TALLOC_FREE(ctx);
1591         return status;
1592 }
1593
1594 struct smbd_addrchanged_state {
1595         struct addrchange_context *ctx;
1596         struct tevent_context *ev;
1597         struct messaging_context *msg_ctx;
1598         struct smbd_parent_context *parent;
1599         char *ports;
1600 };
1601
1602 static void smbd_addr_changed(struct tevent_req *req);
1603
1604 static void smbd_init_addrchange(TALLOC_CTX *mem_ctx,
1605                                 struct tevent_context *ev,
1606                                 struct messaging_context *msg_ctx,
1607                                 struct smbd_parent_context *parent,
1608                                 char *ports)
1609 {
1610         struct smbd_addrchanged_state *state;
1611         struct tevent_req *req;
1612         NTSTATUS status;
1613
1614         state = talloc(mem_ctx, struct smbd_addrchanged_state);
1615         if (state == NULL) {
1616                 DBG_DEBUG("talloc failed\n");
1617                 return;
1618         }
1619         *state = (struct smbd_addrchanged_state) {
1620                 .ev = ev,
1621                 .msg_ctx = msg_ctx,
1622                 .parent = parent,
1623                 .ports = ports
1624         };
1625
1626         status = addrchange_context_create(state, &state->ctx);
1627         if (!NT_STATUS_IS_OK(status)) {
1628                 DBG_DEBUG("addrchange_context_create failed: %s\n",
1629                           nt_errstr(status));
1630                 TALLOC_FREE(state);
1631                 return;
1632         }
1633         req = addrchange_send(state, ev, state->ctx);
1634         if (req == NULL) {
1635                 DBG_ERR("addrchange_send failed\n");
1636                 TALLOC_FREE(state);
1637                 return;
1638         }
1639         tevent_req_set_callback(req, smbd_addr_changed, state);
1640 }
1641
1642 static void smbd_close_socket_for_ip(struct smbd_parent_context *parent,
1643                                      struct sockaddr_storage *addr)
1644 {
1645         struct smbd_open_socket *s = NULL;
1646
1647         for (s = parent->sockets; s != NULL; s = s->next) {
1648                 struct sockaddr_storage a;
1649                 socklen_t addr_len = sizeof(a);
1650
1651                 if (getsockname(s->fd, (struct sockaddr *)&a, &addr_len) < 0) {
1652                         DBG_NOTICE("smbd: Unable to get address - skip\n");
1653                         continue;
1654                 }
1655                 if (sockaddr_equal((struct sockaddr *)&a,
1656                                    (struct sockaddr *)addr)) {
1657                         char addrstr[INET6_ADDRSTRLEN];
1658
1659                         DLIST_REMOVE(parent->sockets, s);
1660                         TALLOC_FREE(s);
1661                         print_sockaddr(addrstr, sizeof(addrstr), addr);
1662                         DBG_NOTICE("smbd: Closed listening socket for %s\n",
1663                                    addrstr);
1664                         return;
1665                 }
1666         }
1667 }
1668
1669 static void smbd_addr_changed(struct tevent_req *req)
1670 {
1671         struct smbd_addrchanged_state *state = tevent_req_callback_data(
1672                 req, struct smbd_addrchanged_state);
1673         enum addrchange_type type;
1674         struct sockaddr_storage addr;
1675         NTSTATUS status;
1676         uint32_t if_index;
1677
1678         status = addrchange_recv(req, &type, &addr, &if_index);
1679         TALLOC_FREE(req);
1680         if (!NT_STATUS_IS_OK(status)) {
1681                 DBG_DEBUG("addrchange_recv failed: %s, stop listening\n",
1682                           nt_errstr(status));
1683                 TALLOC_FREE(state);
1684                 return;
1685         }
1686
1687         if (type == ADDRCHANGE_DEL) {
1688                 char addrstr[INET6_ADDRSTRLEN];
1689
1690                 print_sockaddr(addrstr, sizeof(addrstr), &addr);
1691
1692                 DBG_NOTICE("smbd: kernel (AF_NETLINK) dropped ip %s "
1693                            "on if_index %u\n",
1694                            addrstr, if_index);
1695
1696                 smbd_close_socket_for_ip(state->parent, &addr);
1697
1698                 goto rearm;
1699         }
1700
1701         if (type == ADDRCHANGE_ADD) {
1702                 char addrstr[INET6_ADDRSTRLEN];
1703
1704                 print_sockaddr(addrstr, sizeof(addrstr), &addr);
1705
1706                 DBG_NOTICE("smbd: kernel (AF_NETLINK) added ip %s "
1707                            "on if_index %u\n",
1708                            addrstr, if_index);
1709
1710                 if (!interface_ifindex_exists(if_index)) {
1711                         DBG_NOTICE(
1712                                 "smbd: No interface present for if_index %u\n",
1713                                 if_index
1714                                 );
1715                         goto rearm;
1716                 }
1717
1718                 if (!smbd_open_socket_for_ip(state->parent,
1719                                              state->ev,
1720                                              state->msg_ctx,
1721                                              state->ports,
1722                                              &addr)) {
1723                         DBG_NOTICE("smbd: Unable to open socket on %s\n",
1724                                    addrstr);
1725                 }
1726         }
1727 rearm:
1728         req = addrchange_send(state, state->ev, state->ctx);
1729         if (req == NULL) {
1730                 DBG_ERR("addrchange_send failed\n");
1731                 TALLOC_FREE(state);
1732                 return;
1733         }
1734         tevent_req_set_callback(req, smbd_addr_changed, state);
1735 }
1736
1737 /****************************************************************************
1738  main program.
1739 ****************************************************************************/
1740
1741 /* Declare prototype for build_options() to avoid having to run it through
1742    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
1743    prototype generation system is too complicated. */
1744
1745 extern void build_options(bool screen);
1746
1747  int main(int argc,const char *argv[])
1748 {
1749         /* shall I run as a daemon */
1750         struct samba_cmdline_daemon_cfg *cmdline_daemon_cfg = NULL;
1751         bool log_stdout = false;
1752         char *ports = NULL;
1753         char *profile_level = NULL;
1754         int opt;
1755         poptContext pc;
1756         struct server_id main_server_id = {0};
1757         struct poptOption long_options[] = {
1758                 POPT_AUTOHELP
1759                 {
1760                         .longName   = "build-options",
1761                         .shortName  = 'b',
1762                         .argInfo    = POPT_ARG_NONE,
1763                         .arg        = NULL,
1764                         .val        = 'b',
1765                         .descrip    = "Print build options" ,
1766                 },
1767                 {
1768                         .longName   = "port",
1769                         .shortName  = 'p',
1770                         .argInfo    = POPT_ARG_STRING,
1771                         .arg        = &ports,
1772                         .val        = 0,
1773                         .descrip    = "Listen on the specified ports",
1774                 },
1775                 {
1776                         .longName   = "profiling-level",
1777                         .shortName  = 'P',
1778                         .argInfo    = POPT_ARG_STRING,
1779                         .arg        = &profile_level,
1780                         .val        = 0,
1781                         .descrip    = "Set profiling level","PROFILE_LEVEL",
1782                 },
1783                 POPT_COMMON_SAMBA
1784                 POPT_COMMON_DAEMON
1785                 POPT_COMMON_VERSION
1786                 POPT_TABLEEND
1787         };
1788         struct smbd_parent_context *parent = NULL;
1789         TALLOC_CTX *frame;
1790         NTSTATUS status;
1791         struct tevent_context *ev_ctx;
1792         struct messaging_context *msg_ctx;
1793         struct server_id server_id;
1794         struct tevent_signal *se;
1795         int profiling_level;
1796         char *np_dir = NULL;
1797         const struct loadparm_substitution *lp_sub =
1798                 loadparm_s3_global_substitution();
1799         static const struct smbd_shim smbd_shim_fns =
1800         {
1801                 .change_to_root_user = smbd_change_to_root_user,
1802                 .become_authenticated_pipe_user = smbd_become_authenticated_pipe_user,
1803                 .unbecome_authenticated_pipe_user = smbd_unbecome_authenticated_pipe_user,
1804
1805                 .contend_level2_oplocks_begin = smbd_contend_level2_oplocks_begin,
1806                 .contend_level2_oplocks_end = smbd_contend_level2_oplocks_end,
1807
1808                 .become_root = smbd_become_root,
1809                 .unbecome_root = smbd_unbecome_root,
1810
1811                 .exit_server = smbd_exit_server,
1812                 .exit_server_cleanly = smbd_exit_server_cleanly,
1813         };
1814         bool ok;
1815
1816         setproctitle_init(argc, discard_const(argv), environ);
1817
1818         /*
1819          * Do this before any other talloc operation
1820          */
1821         talloc_enable_null_tracking();
1822         frame = talloc_stackframe();
1823
1824         smb_init_locale();
1825
1826         set_smbd_shim(&smbd_shim_fns);
1827
1828         smbd_init_globals();
1829
1830         TimeInit();
1831
1832 #ifdef HAVE_SET_AUTH_PARAMETERS
1833         set_auth_parameters(argc,argv);
1834 #endif
1835
1836         ok = samba_cmdline_init(frame,
1837                                 SAMBA_CMDLINE_CONFIG_SERVER,
1838                                 true /* require_smbconf */);
1839         if (!ok) {
1840                 DBG_ERR("Failed to setup cmdline parser!\n");
1841                 exit(ENOMEM);
1842         }
1843
1844         cmdline_daemon_cfg = samba_cmdline_get_daemon_cfg();
1845
1846         pc = samba_popt_get_context(getprogname(),
1847                                     argc,
1848                                     argv,
1849                                     long_options,
1850                                     0);
1851         if (pc == NULL) {
1852                 DBG_ERR("Failed to get popt context!\n");
1853                 exit(ENOMEM);
1854         }
1855
1856         while((opt = poptGetNextOpt(pc)) != -1) {
1857                 switch (opt)  {
1858                 case 'b':
1859                         build_options(true); /* Display output to screen as well as debug */
1860                         exit(0);
1861                         break;
1862                 default:
1863                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1864                                   poptBadOption(pc, 0), poptStrerror(opt));
1865                         poptPrintUsage(pc, stderr, 0);
1866                         exit(1);
1867                 }
1868         }
1869         poptFreeContext(pc);
1870
1871         log_stdout = (debug_get_log_type() == DEBUG_STDOUT);
1872
1873         if (cmdline_daemon_cfg->interactive) {
1874                 log_stdout = True;
1875         }
1876
1877 #ifdef HAVE_SETLUID
1878         /* needed for SecureWare on SCO */
1879         setluid(0);
1880 #endif
1881
1882         set_remote_machine_name("smbd", False);
1883
1884         if (cmdline_daemon_cfg->interactive && (DEBUGLEVEL >= 9)) {
1885                 talloc_enable_leak_report();
1886         }
1887
1888         if (log_stdout && cmdline_daemon_cfg->fork) {
1889                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1890                 exit(1);
1891         }
1892
1893         /*
1894          * We want to die early if we can't open /dev/urandom
1895          */
1896         generate_random_buffer(NULL, 0);
1897
1898         /* get initial effective uid and gid */
1899         sec_init();
1900
1901         /* make absolutely sure we run as root - to handle cases where people
1902            are crazy enough to have it setuid */
1903         gain_root_privilege();
1904         gain_root_group_privilege();
1905
1906         dump_core_setup("smbd", lp_logfile(talloc_tos(), lp_sub));
1907
1908         /* we are never interested in SIGPIPE */
1909         BlockSignals(True,SIGPIPE);
1910
1911 #if defined(SIGFPE)
1912         /* we are never interested in SIGFPE */
1913         BlockSignals(True,SIGFPE);
1914 #endif
1915
1916 #if defined(SIGUSR2)
1917         /* We are no longer interested in USR2 */
1918         BlockSignals(True,SIGUSR2);
1919 #endif
1920
1921         /*
1922          * POSIX demands that signals are inherited. If the invoking
1923          * process has these signals masked, we will have problems, as
1924          * we won't receive them.
1925          */
1926         BlockSignals(False, SIGHUP);
1927         BlockSignals(False, SIGUSR1);
1928         BlockSignals(False, SIGTERM);
1929
1930         /* Ensure we leave no zombies until we
1931          * correctly set up child handling below. */
1932
1933         CatchChild();
1934
1935         /* we want total control over the permissions on created files,
1936            so set our umask to 0 */
1937         umask(0);
1938
1939         reopen_logs();
1940
1941         DBG_STARTUP_NOTICE("smbd version %s started.\n%s\n",
1942                            samba_version_string(),
1943                            samba_copyright_string());
1944
1945         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1946                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1947
1948         /* Output the build options to the debug log */
1949         build_options(False);
1950
1951         if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4) {
1952                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1953                 exit(1);
1954         }
1955
1956         /*
1957          * This calls unshare(CLONE_FS); on linux
1958          * in order to check if the running kernel/container
1959          * environment supports it.
1960          */
1961         per_thread_cwd_check();
1962
1963         if (!cluster_probe_ok()) {
1964                 exit(1);
1965         }
1966
1967         /* Init the security context and global current_user */
1968         init_sec_ctx();
1969
1970         /*
1971          * Initialize the event context. The event context needs to be
1972          * initialized before the messaging context, cause the messaging
1973          * context holds an event context.
1974          */
1975         ev_ctx = global_event_context();
1976         if (ev_ctx == NULL) {
1977                 exit(1);
1978         }
1979
1980         /*
1981          * Init the messaging context
1982          * FIXME: This should only call messaging_init()
1983          */
1984         msg_ctx = global_messaging_context();
1985         if (msg_ctx == NULL) {
1986                 exit(1);
1987         }
1988
1989         /*
1990          * Reloading of the printers will not work here as we don't have a
1991          * server info and rpc services set up. It will be called later.
1992          */
1993         if (!reload_services(NULL, NULL, false)) {
1994                 exit(1);
1995         }
1996
1997         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
1998                 if (!lp_parm_bool(-1, "server role check", "inhibit", false)) {
1999                         DBG_ERR("server role = 'active directory domain controller' not compatible with running smbd standalone. \n");
2000                         DEBUGADD(0, ("You should start 'samba' instead, and it will control starting smbd if required\n"));
2001                         exit(1);
2002                 }
2003                 /* Main 'samba' daemon will notify */
2004                 daemon_sd_notifications(false);
2005         }
2006
2007         /* ...NOTE... Log files are working from this point! */
2008
2009         DEBUG(3,("loaded services\n"));
2010
2011         init_structs();
2012
2013         if (!profile_setup(msg_ctx, False)) {
2014                 DEBUG(0,("ERROR: failed to setup profiling\n"));
2015                 return -1;
2016         }
2017
2018         if (profile_level != NULL) {
2019                 profiling_level = atoi(profile_level);
2020         } else {
2021                 profiling_level = lp_smbd_profiling_level();
2022         }
2023         main_server_id = messaging_server_id(msg_ctx);
2024         set_profile_level(profiling_level, &main_server_id);
2025
2026         if (!cmdline_daemon_cfg->daemon && !is_a_socket(0)) {
2027                 if (!cmdline_daemon_cfg->interactive) {
2028                         DEBUG(3, ("Standard input is not a socket, "
2029                                   "assuming -D option\n"));
2030                 }
2031
2032                 /*
2033                  * Setting "daemon" here prevents us from eventually calling
2034                  * the open_sockets_inetd()
2035                  */
2036
2037                 cmdline_daemon_cfg->daemon = true;
2038         }
2039
2040         if (cmdline_daemon_cfg->daemon && !cmdline_daemon_cfg->interactive) {
2041                 DEBUG(3, ("Becoming a daemon.\n"));
2042                 become_daemon(cmdline_daemon_cfg->fork,
2043                               cmdline_daemon_cfg->no_process_group,
2044                               log_stdout);
2045         } else {
2046                 daemon_status("smbd", "Starting process ...");
2047         }
2048
2049 #ifdef HAVE_SETPGID
2050         /*
2051          * If we're interactive we want to set our own process group for
2052          * signal management.
2053          */
2054         if (cmdline_daemon_cfg->interactive &&
2055             !cmdline_daemon_cfg->no_process_group)
2056         {
2057                 setpgid( (pid_t)0, (pid_t)0);
2058         }
2059 #endif
2060
2061         if (!directory_exist(lp_lock_directory()))
2062                 mkdir(lp_lock_directory(), 0755);
2063
2064         if (!directory_exist(lp_pid_directory()))
2065                 mkdir(lp_pid_directory(), 0755);
2066
2067         if (cmdline_daemon_cfg->daemon)
2068                 pidfile_create(lp_pid_directory(), "smbd");
2069
2070         status = reinit_after_fork(msg_ctx, ev_ctx, false);
2071         if (!NT_STATUS_IS_OK(status)) {
2072                 exit_daemon("reinit_after_fork() failed", map_errno_from_nt_status(status));
2073         }
2074
2075         if (!cmdline_daemon_cfg->interactive) {
2076                 /*
2077                  * Do not initialize the parent-child-pipe before becoming a
2078                  * daemon: this is used to detect a died parent in the child
2079                  * process.
2080                  */
2081                 status = init_before_fork();
2082                 if (!NT_STATUS_IS_OK(status)) {
2083                         exit_daemon(nt_errstr(status), map_errno_from_nt_status(status));
2084                 }
2085         }
2086
2087         parent = talloc_zero(ev_ctx, struct smbd_parent_context);
2088         if (!parent) {
2089                 exit_server("talloc(struct smbd_parent_context) failed");
2090         }
2091         parent->interactive = cmdline_daemon_cfg->interactive;
2092         parent->ev_ctx = ev_ctx;
2093         parent->msg_ctx = msg_ctx;
2094         am_parent = parent;
2095
2096         se = tevent_add_signal(parent->ev_ctx,
2097                                parent,
2098                                SIGTERM, 0,
2099                                smbd_parent_sig_term_handler,
2100                                parent);
2101         if (!se) {
2102                 exit_server("failed to setup SIGTERM handler");
2103         }
2104         se = tevent_add_signal(parent->ev_ctx,
2105                                parent,
2106                                SIGHUP, 0,
2107                                smbd_parent_sig_hup_handler,
2108                                parent);
2109         if (!se) {
2110                 exit_server("failed to setup SIGHUP handler");
2111         }
2112
2113         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
2114
2115         if (smbd_memcache() == NULL) {
2116                 exit_daemon("no memcache available", EACCES);
2117         }
2118
2119         memcache_set_global(smbd_memcache());
2120
2121         /* Initialise the password backed before the global_sam_sid
2122            to ensure that we fetch from ldap before we make a domain sid up */
2123
2124         if(!initialize_password_db(false, ev_ctx))
2125                 exit(1);
2126
2127         if (!secrets_init()) {
2128                 exit_daemon("smbd can not open secrets.tdb", EACCES);
2129         }
2130
2131         if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC || lp_server_role() == ROLE_IPA_DC) {
2132                 struct loadparm_context *lp_ctx = loadparm_init_s3(NULL, loadparm_s3_helpers());
2133                 if (!open_schannel_session_store(NULL, lp_ctx)) {
2134                         exit_daemon("ERROR: Samba cannot open schannel store for secured NETLOGON operations.", EACCES);
2135                 }
2136                 TALLOC_FREE(lp_ctx);
2137         }
2138
2139         if(!get_global_sam_sid()) {
2140                 exit_daemon("Samba cannot create a SAM SID", EACCES);
2141         }
2142
2143         server_id = messaging_server_id(msg_ctx);
2144         status = smbXsrv_version_global_init(&server_id);
2145         if (!NT_STATUS_IS_OK(status)) {
2146                 exit_daemon("Samba cannot init server context", EACCES);
2147         }
2148
2149         status = smbXsrv_client_global_init();
2150         if (!NT_STATUS_IS_OK(status)) {
2151                 exit_daemon("Samba cannot init clients context", EACCES);
2152         }
2153
2154         status = smbXsrv_session_global_init(msg_ctx);
2155         if (!NT_STATUS_IS_OK(status)) {
2156                 exit_daemon("Samba cannot init session context", EACCES);
2157         }
2158
2159         status = smbXsrv_tcon_global_init();
2160         if (!NT_STATUS_IS_OK(status)) {
2161                 exit_daemon("Samba cannot init tcon context", EACCES);
2162         }
2163
2164         if (!locking_init())
2165                 exit_daemon("Samba cannot init locking", EACCES);
2166
2167         if (!leases_db_init(false)) {
2168                 exit_daemon("Samba cannot init leases", EACCES);
2169         }
2170
2171         if (!smbd_notifyd_init(
2172                     msg_ctx,
2173                     cmdline_daemon_cfg->interactive,
2174                     &parent->notifyd)) {
2175                 exit_daemon("Samba cannot init notification", EACCES);
2176         }
2177
2178         if (!cleanupd_init(
2179                     msg_ctx,
2180                     cmdline_daemon_cfg->interactive,
2181                     &parent->cleanupd)) {
2182                 exit_daemon("Samba cannot init the cleanupd", EACCES);
2183         }
2184
2185         if (!messaging_parent_dgm_cleanup_init(msg_ctx)) {
2186                 exit(1);
2187         }
2188
2189         if (!smbd_scavenger_init(NULL, msg_ctx, ev_ctx)) {
2190                 exit_daemon("Samba cannot init scavenging", EACCES);
2191         }
2192
2193         if (!W_ERROR_IS_OK(registry_init_full()))
2194                 exit_daemon("Samba cannot init registry", EACCES);
2195
2196         /* Open the share_info.tdb here, so we don't have to open
2197            after the fork on every single connection.  This is a small
2198            performance improvement and reduces the total number of system
2199            fds used. */
2200         status = share_info_db_init();
2201         if (!NT_STATUS_IS_OK(status)) {
2202                 exit_daemon("ERROR: failed to load share info db.", EACCES);
2203         }
2204
2205         status = init_system_session_info(NULL);
2206         if (!NT_STATUS_IS_OK(status)) {
2207                 DEBUG(1, ("ERROR: failed to setup system user info: %s.\n",
2208                           nt_errstr(status)));
2209                 return -1;
2210         }
2211
2212         if (!init_guest_session_info(NULL)) {
2213                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
2214                 return -1;
2215         }
2216
2217         if (!file_init_global()) {
2218                 DEBUG(0, ("ERROR: file_init_global() failed\n"));
2219                 return -1;
2220         }
2221         status = smbXsrv_open_global_init();
2222         if (!NT_STATUS_IS_OK(status)) {
2223                 exit_daemon("Samba cannot init global open", map_errno_from_nt_status(status));
2224         }
2225
2226         if (lp_clustering() && !lp_allow_unsafe_cluster_upgrade()) {
2227                 status = smbd_claim_version(msg_ctx, samba_version_string());
2228                 if (!NT_STATUS_IS_OK(status)) {
2229                         DBG_ERR("Could not claim version: %s\n",
2230                                     nt_errstr(status));
2231                         return -1;
2232                 }
2233         }
2234
2235         /* This MUST be done before start_epmd() because otherwise
2236          * start_epmd() forks and races against dcesrv_ep_setup() to
2237          * call directory_create_or_exist() */
2238         if (!directory_create_or_exist(lp_ncalrpc_dir(), 0755)) {
2239                 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
2240                           lp_ncalrpc_dir(), strerror(errno)));
2241                 return -1;
2242         }
2243
2244         np_dir = talloc_asprintf(talloc_tos(), "%s/np", lp_ncalrpc_dir());
2245         if (!np_dir) {
2246                 DEBUG(0, ("%s: Out of memory\n", __location__));
2247                 return -1;
2248         }
2249
2250         if (!directory_create_or_exist_strict(np_dir, geteuid(), 0700)) {
2251                 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
2252                           np_dir, strerror(errno)));
2253                 return -1;
2254         }
2255
2256         if (!cmdline_daemon_cfg->interactive) {
2257                 daemon_ready("smbd");
2258         }
2259
2260         if (!cmdline_daemon_cfg->daemon) {
2261                 int ret, sock;
2262
2263                 /* inetd mode */
2264                 TALLOC_FREE(frame);
2265
2266                 /* Started from inetd. fd 0 is the socket. */
2267                 /* We will abort gracefully when the client or remote system
2268                    goes away */
2269                 sock = dup(0);
2270
2271                 /* close stdin, stdout (if not logging to it), but not stderr */
2272                 ret = close_low_fd(0);
2273                 if (ret != 0) {
2274                         DBG_ERR("close_low_fd(0) failed: %s\n", strerror(ret));
2275                         return 1;
2276                 }
2277                 if (!debug_get_output_is_stdout()) {
2278                         ret = close_low_fd(1);
2279                         if (ret != 0) {
2280                                 DBG_ERR("close_low_fd(1) failed: %s\n",
2281                                         strerror(ret));
2282                                 return 1;
2283                         }
2284                 }
2285
2286 #ifdef HAVE_ATEXIT
2287                 atexit(killkids);
2288 #endif
2289
2290                 /* Stop zombies */
2291                 smbd_setup_sig_chld_handler(parent);
2292
2293                 smbd_process(ev_ctx, msg_ctx, sock, true);
2294
2295                 exit_server_cleanly(NULL);
2296                 return(0);
2297         }
2298
2299         if (lp_interfaces() && lp_bind_interfaces_only()) {
2300                 smbd_init_addrchange(NULL, ev_ctx, msg_ctx, parent, ports);
2301         }
2302
2303         if (!open_sockets_smbd(parent, ev_ctx, msg_ctx, ports))
2304                 exit_server("open_sockets_smbd() failed");
2305
2306         TALLOC_FREE(frame);
2307         /* make sure we always have a valid stackframe */
2308         frame = talloc_stackframe();
2309
2310         if (!cmdline_daemon_cfg->fork) {
2311                 /* if we are running in the foreground then look for
2312                    EOF on stdin, and exit if it happens. This allows
2313                    us to die if the parent process dies
2314                    Only do this on a pipe or socket, no other device.
2315                 */
2316                 struct stat st;
2317                 if (fstat(0, &st) != 0) {
2318                         return 1;
2319                 }
2320                 if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
2321                         tevent_add_fd(ev_ctx,
2322                                         parent,
2323                                         0,
2324                                         TEVENT_FD_READ,
2325                                         smbd_stdin_handler,
2326                                         NULL);
2327                 }
2328         }
2329
2330         smbd_parent_loop(ev_ctx, parent);
2331
2332         exit_server_cleanly(NULL);
2333         TALLOC_FREE(frame);
2334         return(0);
2335 }