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 struct smbd_addrchanged_state {
1545         struct addrchange_context *ctx;
1546         struct tevent_context *ev;
1547         struct messaging_context *msg_ctx;
1548         struct smbd_parent_context *parent;
1549         char *ports;
1550 };
1551
1552 static void smbd_addr_changed(struct tevent_req *req);
1553
1554 static void smbd_init_addrchange(TALLOC_CTX *mem_ctx,
1555                                 struct tevent_context *ev,
1556                                 struct messaging_context *msg_ctx,
1557                                 struct smbd_parent_context *parent,
1558                                 char *ports)
1559 {
1560         struct smbd_addrchanged_state *state;
1561         struct tevent_req *req;
1562         NTSTATUS status;
1563
1564         state = talloc(mem_ctx, struct smbd_addrchanged_state);
1565         if (state == NULL) {
1566                 DBG_DEBUG("talloc failed\n");
1567                 return;
1568         }
1569         *state = (struct smbd_addrchanged_state) {
1570                 .ev = ev,
1571                 .msg_ctx = msg_ctx,
1572                 .parent = parent,
1573                 .ports = ports
1574         };
1575
1576         status = addrchange_context_create(state, &state->ctx);
1577         if (!NT_STATUS_IS_OK(status)) {
1578                 DBG_DEBUG("addrchange_context_create failed: %s\n",
1579                           nt_errstr(status));
1580                 TALLOC_FREE(state);
1581                 return;
1582         }
1583         req = addrchange_send(state, ev, state->ctx);
1584         if (req == NULL) {
1585                 DBG_ERR("addrchange_send failed\n");
1586                 TALLOC_FREE(state);
1587                 return;
1588         }
1589         tevent_req_set_callback(req, smbd_addr_changed, state);
1590 }
1591
1592 static void smbd_addr_changed(struct tevent_req *req)
1593 {
1594         struct smbd_addrchanged_state *state = tevent_req_callback_data(
1595                 req, struct smbd_addrchanged_state);
1596         enum addrchange_type type;
1597         struct sockaddr_storage addr;
1598         NTSTATUS status;
1599
1600         status = addrchange_recv(req, &type, &addr);
1601         TALLOC_FREE(req);
1602         if (!NT_STATUS_IS_OK(status)) {
1603                 DBG_DEBUG("addrchange_recv failed: %s, stop listening\n",
1604                           nt_errstr(status));
1605                 TALLOC_FREE(state);
1606                 return;
1607         }
1608
1609         if (type == ADDRCHANGE_DEL) {
1610                 char addrstr[INET6_ADDRSTRLEN];
1611
1612                 print_sockaddr(addrstr, sizeof(addrstr), &addr);
1613
1614                 DBG_NOTICE("smbd: kernel (AF_NETLINK) dropped ip %s\n",
1615                            addrstr);
1616
1617                 goto rearm;
1618         }
1619
1620         if (type == ADDRCHANGE_ADD) {
1621                 char addrstr[INET6_ADDRSTRLEN];
1622
1623                 print_sockaddr(addrstr, sizeof(addrstr), &addr);
1624
1625                 DBG_NOTICE("smbd: kernel (AF_NETLINK) added ip %s\n",
1626                            addrstr);
1627         }
1628 rearm:
1629         req = addrchange_send(state, state->ev, state->ctx);
1630         if (req == NULL) {
1631                 DBG_ERR("addrchange_send failed\n");
1632                 TALLOC_FREE(state);
1633                 return;
1634         }
1635         tevent_req_set_callback(req, smbd_addr_changed, state);
1636 }
1637
1638 /****************************************************************************
1639  main program.
1640 ****************************************************************************/
1641
1642 /* Declare prototype for build_options() to avoid having to run it through
1643    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
1644    prototype generation system is too complicated. */
1645
1646 extern void build_options(bool screen);
1647
1648  int main(int argc,const char *argv[])
1649 {
1650         /* shall I run as a daemon */
1651         struct samba_cmdline_daemon_cfg *cmdline_daemon_cfg = NULL;
1652         bool log_stdout = false;
1653         char *ports = NULL;
1654         char *profile_level = NULL;
1655         int opt;
1656         poptContext pc;
1657         struct server_id main_server_id = {0};
1658         struct poptOption long_options[] = {
1659                 POPT_AUTOHELP
1660                 {
1661                         .longName   = "build-options",
1662                         .shortName  = 'b',
1663                         .argInfo    = POPT_ARG_NONE,
1664                         .arg        = NULL,
1665                         .val        = 'b',
1666                         .descrip    = "Print build options" ,
1667                 },
1668                 {
1669                         .longName   = "port",
1670                         .shortName  = 'p',
1671                         .argInfo    = POPT_ARG_STRING,
1672                         .arg        = &ports,
1673                         .val        = 0,
1674                         .descrip    = "Listen on the specified ports",
1675                 },
1676                 {
1677                         .longName   = "profiling-level",
1678                         .shortName  = 'P',
1679                         .argInfo    = POPT_ARG_STRING,
1680                         .arg        = &profile_level,
1681                         .val        = 0,
1682                         .descrip    = "Set profiling level","PROFILE_LEVEL",
1683                 },
1684                 POPT_COMMON_SAMBA
1685                 POPT_COMMON_DAEMON
1686                 POPT_COMMON_VERSION
1687                 POPT_TABLEEND
1688         };
1689         struct smbd_parent_context *parent = NULL;
1690         TALLOC_CTX *frame;
1691         NTSTATUS status;
1692         struct tevent_context *ev_ctx;
1693         struct messaging_context *msg_ctx;
1694         struct server_id server_id;
1695         struct tevent_signal *se;
1696         int profiling_level;
1697         char *np_dir = NULL;
1698         const struct loadparm_substitution *lp_sub =
1699                 loadparm_s3_global_substitution();
1700         static const struct smbd_shim smbd_shim_fns =
1701         {
1702                 .change_to_root_user = smbd_change_to_root_user,
1703                 .become_authenticated_pipe_user = smbd_become_authenticated_pipe_user,
1704                 .unbecome_authenticated_pipe_user = smbd_unbecome_authenticated_pipe_user,
1705
1706                 .contend_level2_oplocks_begin = smbd_contend_level2_oplocks_begin,
1707                 .contend_level2_oplocks_end = smbd_contend_level2_oplocks_end,
1708
1709                 .become_root = smbd_become_root,
1710                 .unbecome_root = smbd_unbecome_root,
1711
1712                 .exit_server = smbd_exit_server,
1713                 .exit_server_cleanly = smbd_exit_server_cleanly,
1714         };
1715         bool ok;
1716
1717         setproctitle_init(argc, discard_const(argv), environ);
1718
1719         /*
1720          * Do this before any other talloc operation
1721          */
1722         talloc_enable_null_tracking();
1723         frame = talloc_stackframe();
1724
1725         smb_init_locale();
1726
1727         set_smbd_shim(&smbd_shim_fns);
1728
1729         smbd_init_globals();
1730
1731         TimeInit();
1732
1733 #ifdef HAVE_SET_AUTH_PARAMETERS
1734         set_auth_parameters(argc,argv);
1735 #endif
1736
1737         ok = samba_cmdline_init(frame,
1738                                 SAMBA_CMDLINE_CONFIG_SERVER,
1739                                 true /* require_smbconf */);
1740         if (!ok) {
1741                 DBG_ERR("Failed to setup cmdline parser!\n");
1742                 exit(ENOMEM);
1743         }
1744
1745         cmdline_daemon_cfg = samba_cmdline_get_daemon_cfg();
1746
1747         pc = samba_popt_get_context(getprogname(),
1748                                     argc,
1749                                     argv,
1750                                     long_options,
1751                                     0);
1752         if (pc == NULL) {
1753                 DBG_ERR("Failed to get popt context!\n");
1754                 exit(ENOMEM);
1755         }
1756
1757         while((opt = poptGetNextOpt(pc)) != -1) {
1758                 switch (opt)  {
1759                 case 'b':
1760                         build_options(true); /* Display output to screen as well as debug */
1761                         exit(0);
1762                         break;
1763                 default:
1764                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1765                                   poptBadOption(pc, 0), poptStrerror(opt));
1766                         poptPrintUsage(pc, stderr, 0);
1767                         exit(1);
1768                 }
1769         }
1770         poptFreeContext(pc);
1771
1772         log_stdout = (debug_get_log_type() == DEBUG_STDOUT);
1773
1774         if (cmdline_daemon_cfg->interactive) {
1775                 log_stdout = True;
1776         }
1777
1778 #ifdef HAVE_SETLUID
1779         /* needed for SecureWare on SCO */
1780         setluid(0);
1781 #endif
1782
1783         set_remote_machine_name("smbd", False);
1784
1785         if (cmdline_daemon_cfg->interactive && (DEBUGLEVEL >= 9)) {
1786                 talloc_enable_leak_report();
1787         }
1788
1789         if (log_stdout && cmdline_daemon_cfg->fork) {
1790                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1791                 exit(1);
1792         }
1793
1794         /*
1795          * We want to die early if we can't open /dev/urandom
1796          */
1797         generate_random_buffer(NULL, 0);
1798
1799         /* get initial effective uid and gid */
1800         sec_init();
1801
1802         /* make absolutely sure we run as root - to handle cases where people
1803            are crazy enough to have it setuid */
1804         gain_root_privilege();
1805         gain_root_group_privilege();
1806
1807         dump_core_setup("smbd", lp_logfile(talloc_tos(), lp_sub));
1808
1809         /* we are never interested in SIGPIPE */
1810         BlockSignals(True,SIGPIPE);
1811
1812 #if defined(SIGFPE)
1813         /* we are never interested in SIGFPE */
1814         BlockSignals(True,SIGFPE);
1815 #endif
1816
1817 #if defined(SIGUSR2)
1818         /* We are no longer interested in USR2 */
1819         BlockSignals(True,SIGUSR2);
1820 #endif
1821
1822         /*
1823          * POSIX demands that signals are inherited. If the invoking
1824          * process has these signals masked, we will have problems, as
1825          * we won't receive them.
1826          */
1827         BlockSignals(False, SIGHUP);
1828         BlockSignals(False, SIGUSR1);
1829         BlockSignals(False, SIGTERM);
1830
1831         /* Ensure we leave no zombies until we
1832          * correctly set up child handling below. */
1833
1834         CatchChild();
1835
1836         /* we want total control over the permissions on created files,
1837            so set our umask to 0 */
1838         umask(0);
1839
1840         reopen_logs();
1841
1842         DBG_STARTUP_NOTICE("smbd version %s started.\n%s\n",
1843                            samba_version_string(),
1844                            samba_copyright_string());
1845
1846         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1847                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1848
1849         /* Output the build options to the debug log */
1850         build_options(False);
1851
1852         if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4) {
1853                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1854                 exit(1);
1855         }
1856
1857         /*
1858          * This calls unshare(CLONE_FS); on linux
1859          * in order to check if the running kernel/container
1860          * environment supports it.
1861          */
1862         per_thread_cwd_check();
1863
1864         if (!cluster_probe_ok()) {
1865                 exit(1);
1866         }
1867
1868         /* Init the security context and global current_user */
1869         init_sec_ctx();
1870
1871         /*
1872          * Initialize the event context. The event context needs to be
1873          * initialized before the messaging context, cause the messaging
1874          * context holds an event context.
1875          */
1876         ev_ctx = global_event_context();
1877         if (ev_ctx == NULL) {
1878                 exit(1);
1879         }
1880
1881         /*
1882          * Init the messaging context
1883          * FIXME: This should only call messaging_init()
1884          */
1885         msg_ctx = global_messaging_context();
1886         if (msg_ctx == NULL) {
1887                 exit(1);
1888         }
1889
1890         /*
1891          * Reloading of the printers will not work here as we don't have a
1892          * server info and rpc services set up. It will be called later.
1893          */
1894         if (!reload_services(NULL, NULL, false)) {
1895                 exit(1);
1896         }
1897
1898         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC) {
1899                 if (!lp_parm_bool(-1, "server role check", "inhibit", false)) {
1900                         DBG_ERR("server role = 'active directory domain controller' not compatible with running smbd standalone. \n");
1901                         DEBUGADD(0, ("You should start 'samba' instead, and it will control starting smbd if required\n"));
1902                         exit(1);
1903                 }
1904                 /* Main 'samba' daemon will notify */
1905                 daemon_sd_notifications(false);
1906         }
1907
1908         /* ...NOTE... Log files are working from this point! */
1909
1910         DEBUG(3,("loaded services\n"));
1911
1912         init_structs();
1913
1914         if (!profile_setup(msg_ctx, False)) {
1915                 DEBUG(0,("ERROR: failed to setup profiling\n"));
1916                 return -1;
1917         }
1918
1919         if (profile_level != NULL) {
1920                 profiling_level = atoi(profile_level);
1921         } else {
1922                 profiling_level = lp_smbd_profiling_level();
1923         }
1924         main_server_id = messaging_server_id(msg_ctx);
1925         set_profile_level(profiling_level, &main_server_id);
1926
1927         if (!cmdline_daemon_cfg->daemon && !is_a_socket(0)) {
1928                 if (!cmdline_daemon_cfg->interactive) {
1929                         DEBUG(3, ("Standard input is not a socket, "
1930                                   "assuming -D option\n"));
1931                 }
1932
1933                 /*
1934                  * Setting "daemon" here prevents us from eventually calling
1935                  * the open_sockets_inetd()
1936                  */
1937
1938                 cmdline_daemon_cfg->daemon = true;
1939         }
1940
1941         if (cmdline_daemon_cfg->daemon && !cmdline_daemon_cfg->interactive) {
1942                 DEBUG(3, ("Becoming a daemon.\n"));
1943                 become_daemon(cmdline_daemon_cfg->fork,
1944                               cmdline_daemon_cfg->no_process_group,
1945                               log_stdout);
1946         } else {
1947                 daemon_status("smbd", "Starting process ...");
1948         }
1949
1950 #ifdef HAVE_SETPGID
1951         /*
1952          * If we're interactive we want to set our own process group for
1953          * signal management.
1954          */
1955         if (cmdline_daemon_cfg->interactive &&
1956             !cmdline_daemon_cfg->no_process_group)
1957         {
1958                 setpgid( (pid_t)0, (pid_t)0);
1959         }
1960 #endif
1961
1962         if (!directory_exist(lp_lock_directory()))
1963                 mkdir(lp_lock_directory(), 0755);
1964
1965         if (!directory_exist(lp_pid_directory()))
1966                 mkdir(lp_pid_directory(), 0755);
1967
1968         if (cmdline_daemon_cfg->daemon)
1969                 pidfile_create(lp_pid_directory(), "smbd");
1970
1971         status = reinit_after_fork(msg_ctx, ev_ctx, false);
1972         if (!NT_STATUS_IS_OK(status)) {
1973                 exit_daemon("reinit_after_fork() failed", map_errno_from_nt_status(status));
1974         }
1975
1976         if (!cmdline_daemon_cfg->interactive) {
1977                 /*
1978                  * Do not initialize the parent-child-pipe before becoming a
1979                  * daemon: this is used to detect a died parent in the child
1980                  * process.
1981                  */
1982                 status = init_before_fork();
1983                 if (!NT_STATUS_IS_OK(status)) {
1984                         exit_daemon(nt_errstr(status), map_errno_from_nt_status(status));
1985                 }
1986         }
1987
1988         parent = talloc_zero(ev_ctx, struct smbd_parent_context);
1989         if (!parent) {
1990                 exit_server("talloc(struct smbd_parent_context) failed");
1991         }
1992         parent->interactive = cmdline_daemon_cfg->interactive;
1993         parent->ev_ctx = ev_ctx;
1994         parent->msg_ctx = msg_ctx;
1995         am_parent = parent;
1996
1997         se = tevent_add_signal(parent->ev_ctx,
1998                                parent,
1999                                SIGTERM, 0,
2000                                smbd_parent_sig_term_handler,
2001                                parent);
2002         if (!se) {
2003                 exit_server("failed to setup SIGTERM handler");
2004         }
2005         se = tevent_add_signal(parent->ev_ctx,
2006                                parent,
2007                                SIGHUP, 0,
2008                                smbd_parent_sig_hup_handler,
2009                                parent);
2010         if (!se) {
2011                 exit_server("failed to setup SIGHUP handler");
2012         }
2013
2014         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
2015
2016         if (smbd_memcache() == NULL) {
2017                 exit_daemon("no memcache available", EACCES);
2018         }
2019
2020         memcache_set_global(smbd_memcache());
2021
2022         /* Initialise the password backed before the global_sam_sid
2023            to ensure that we fetch from ldap before we make a domain sid up */
2024
2025         if(!initialize_password_db(false, ev_ctx))
2026                 exit(1);
2027
2028         if (!secrets_init()) {
2029                 exit_daemon("smbd can not open secrets.tdb", EACCES);
2030         }
2031
2032         if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC || lp_server_role() == ROLE_IPA_DC) {
2033                 struct loadparm_context *lp_ctx = loadparm_init_s3(NULL, loadparm_s3_helpers());
2034                 if (!open_schannel_session_store(NULL, lp_ctx)) {
2035                         exit_daemon("ERROR: Samba cannot open schannel store for secured NETLOGON operations.", EACCES);
2036                 }
2037                 TALLOC_FREE(lp_ctx);
2038         }
2039
2040         if(!get_global_sam_sid()) {
2041                 exit_daemon("Samba cannot create a SAM SID", EACCES);
2042         }
2043
2044         server_id = messaging_server_id(msg_ctx);
2045         status = smbXsrv_version_global_init(&server_id);
2046         if (!NT_STATUS_IS_OK(status)) {
2047                 exit_daemon("Samba cannot init server context", EACCES);
2048         }
2049
2050         status = smbXsrv_client_global_init();
2051         if (!NT_STATUS_IS_OK(status)) {
2052                 exit_daemon("Samba cannot init clients context", EACCES);
2053         }
2054
2055         status = smbXsrv_session_global_init(msg_ctx);
2056         if (!NT_STATUS_IS_OK(status)) {
2057                 exit_daemon("Samba cannot init session context", EACCES);
2058         }
2059
2060         status = smbXsrv_tcon_global_init();
2061         if (!NT_STATUS_IS_OK(status)) {
2062                 exit_daemon("Samba cannot init tcon context", EACCES);
2063         }
2064
2065         if (!locking_init())
2066                 exit_daemon("Samba cannot init locking", EACCES);
2067
2068         if (!leases_db_init(false)) {
2069                 exit_daemon("Samba cannot init leases", EACCES);
2070         }
2071
2072         if (!smbd_notifyd_init(
2073                     msg_ctx,
2074                     cmdline_daemon_cfg->interactive,
2075                     &parent->notifyd)) {
2076                 exit_daemon("Samba cannot init notification", EACCES);
2077         }
2078
2079         if (!cleanupd_init(
2080                     msg_ctx,
2081                     cmdline_daemon_cfg->interactive,
2082                     &parent->cleanupd)) {
2083                 exit_daemon("Samba cannot init the cleanupd", EACCES);
2084         }
2085
2086         if (!messaging_parent_dgm_cleanup_init(msg_ctx)) {
2087                 exit(1);
2088         }
2089
2090         if (!smbd_scavenger_init(NULL, msg_ctx, ev_ctx)) {
2091                 exit_daemon("Samba cannot init scavenging", EACCES);
2092         }
2093
2094         if (!W_ERROR_IS_OK(registry_init_full()))
2095                 exit_daemon("Samba cannot init registry", EACCES);
2096
2097         /* Open the share_info.tdb here, so we don't have to open
2098            after the fork on every single connection.  This is a small
2099            performance improvement and reduces the total number of system
2100            fds used. */
2101         status = share_info_db_init();
2102         if (!NT_STATUS_IS_OK(status)) {
2103                 exit_daemon("ERROR: failed to load share info db.", EACCES);
2104         }
2105
2106         status = init_system_session_info(NULL);
2107         if (!NT_STATUS_IS_OK(status)) {
2108                 DEBUG(1, ("ERROR: failed to setup system user info: %s.\n",
2109                           nt_errstr(status)));
2110                 return -1;
2111         }
2112
2113         if (!init_guest_session_info(NULL)) {
2114                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
2115                 return -1;
2116         }
2117
2118         if (!file_init_global()) {
2119                 DEBUG(0, ("ERROR: file_init_global() failed\n"));
2120                 return -1;
2121         }
2122         status = smbXsrv_open_global_init();
2123         if (!NT_STATUS_IS_OK(status)) {
2124                 exit_daemon("Samba cannot init global open", map_errno_from_nt_status(status));
2125         }
2126
2127         if (lp_clustering() && !lp_allow_unsafe_cluster_upgrade()) {
2128                 status = smbd_claim_version(msg_ctx, samba_version_string());
2129                 if (!NT_STATUS_IS_OK(status)) {
2130                         DBG_ERR("Could not claim version: %s\n",
2131                                     nt_errstr(status));
2132                         return -1;
2133                 }
2134         }
2135
2136         /* This MUST be done before start_epmd() because otherwise
2137          * start_epmd() forks and races against dcesrv_ep_setup() to
2138          * call directory_create_or_exist() */
2139         if (!directory_create_or_exist(lp_ncalrpc_dir(), 0755)) {
2140                 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
2141                           lp_ncalrpc_dir(), strerror(errno)));
2142                 return -1;
2143         }
2144
2145         np_dir = talloc_asprintf(talloc_tos(), "%s/np", lp_ncalrpc_dir());
2146         if (!np_dir) {
2147                 DEBUG(0, ("%s: Out of memory\n", __location__));
2148                 return -1;
2149         }
2150
2151         if (!directory_create_or_exist_strict(np_dir, geteuid(), 0700)) {
2152                 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
2153                           np_dir, strerror(errno)));
2154                 return -1;
2155         }
2156
2157         if (!cmdline_daemon_cfg->interactive) {
2158                 daemon_ready("smbd");
2159         }
2160
2161         if (!cmdline_daemon_cfg->daemon) {
2162                 int ret, sock;
2163
2164                 /* inetd mode */
2165                 TALLOC_FREE(frame);
2166
2167                 /* Started from inetd. fd 0 is the socket. */
2168                 /* We will abort gracefully when the client or remote system
2169                    goes away */
2170                 sock = dup(0);
2171
2172                 /* close stdin, stdout (if not logging to it), but not stderr */
2173                 ret = close_low_fd(0);
2174                 if (ret != 0) {
2175                         DBG_ERR("close_low_fd(0) failed: %s\n", strerror(ret));
2176                         return 1;
2177                 }
2178                 if (!debug_get_output_is_stdout()) {
2179                         ret = close_low_fd(1);
2180                         if (ret != 0) {
2181                                 DBG_ERR("close_low_fd(1) failed: %s\n",
2182                                         strerror(ret));
2183                                 return 1;
2184                         }
2185                 }
2186
2187 #ifdef HAVE_ATEXIT
2188                 atexit(killkids);
2189 #endif
2190
2191                 /* Stop zombies */
2192                 smbd_setup_sig_chld_handler(parent);
2193
2194                 smbd_process(ev_ctx, msg_ctx, sock, true);
2195
2196                 exit_server_cleanly(NULL);
2197                 return(0);
2198         }
2199
2200         if (lp_interfaces() && lp_bind_interfaces_only()) {
2201                 smbd_init_addrchange(NULL, ev_ctx, msg_ctx, parent, ports);
2202         }
2203
2204         if (!open_sockets_smbd(parent, ev_ctx, msg_ctx, ports))
2205                 exit_server("open_sockets_smbd() failed");
2206
2207         TALLOC_FREE(frame);
2208         /* make sure we always have a valid stackframe */
2209         frame = talloc_stackframe();
2210
2211         if (!cmdline_daemon_cfg->fork) {
2212                 /* if we are running in the foreground then look for
2213                    EOF on stdin, and exit if it happens. This allows
2214                    us to die if the parent process dies
2215                    Only do this on a pipe or socket, no other device.
2216                 */
2217                 struct stat st;
2218                 if (fstat(0, &st) != 0) {
2219                         return 1;
2220                 }
2221                 if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
2222                         tevent_add_fd(ev_ctx,
2223                                         parent,
2224                                         0,
2225                                         TEVENT_FD_READ,
2226                                         smbd_stdin_handler,
2227                                         NULL);
2228                 }
2229         }
2230
2231         smbd_parent_loop(ev_ctx, parent);
2232
2233         exit_server_cleanly(NULL);
2234         TALLOC_FREE(frame);
2235         return(0);
2236 }