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