source3/smbd/server.c

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