source4/smbd/server.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Main SMB server routines
   5
   6    Copyright (C) Andrew Tridgell                1992-2005
   7    Copyright (C) Martin Pool                    2002
   8    Copyright (C) Jelmer Vernooij                2002
   9    Copyright (C) James J Myers                  2003 <myersjj@samba.org>
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26 #include "lib/events/events.h"
  27 #include "version.h"
  28 #include "lib/cmdline/popt_common.h"
  29 #include "system/dir.h"
  30 #include "system/filesys.h"
  31 #include "auth/gensec/gensec.h"
  32 #include "libcli/auth/schannel.h"
  33 #include "smbd/process_model.h"
  34 #include "param/secrets.h"
  35 #include "lib/util/pidfile.h"
  36 #include "param/param.h"
  37 #include "dsdb/samdb/samdb.h"
  38 #include "auth/session.h"
  39 #include "lib/messaging/irpc.h"
  40 #include "librpc/gen_ndr/ndr_irpc.h"
  41 #include "cluster/cluster.h"
  42 #include "dynconfig/dynconfig.h"
  43 #include "lib/util/samba_modules.h"
  44 #include "nsswitch/winbind_client.h"
  45 #include "libds/common/roles.h"
  46 #include "lib/util/tfork.h"
  47 #include "dsdb/samdb/ldb_modules/util.h"
  48 #include "lib/util/server_id.h"
  49
  50 #ifdef HAVE_PTHREAD
  51 #include <pthread.h>
  52 #endif
  53
  54 struct server_state {
  55         struct tevent_context *event_ctx;
  56         const char *binary_name;
  57 };
  58
  59 /*
  60   recursively delete a directory tree
  61 */
  62 static void recursive_delete(const char *path)
  63 {
  64         DIR *dir;
  65         struct dirent *de;
  66
  67         dir = opendir(path);
  68         if (!dir) {
  69                 return;
  70         }
  71
  72         for (de=readdir(dir);de;de=readdir(dir)) {
  73                 char *fname;
  74                 struct stat st;
  75
  76                 if (ISDOT(de->d_name) || ISDOTDOT(de->d_name)) {
  77                         continue;
  78                 }
  79
  80                 fname = talloc_asprintf(path, "%s/%s", path, de->d_name);
  81                 if (stat(fname, &st) != 0) {
  82                         continue;
  83                 }
  84                 if (S_ISDIR(st.st_mode)) {
  85                         recursive_delete(fname);
  86                         talloc_free(fname);
  87                         continue;
  88                 }
  89                 if (unlink(fname) != 0) {
  90                         DBG_ERR("Unabled to delete '%s' - %s\n",
  91                                  fname, strerror(errno));
  92                         smb_panic("unable to cleanup tmp files");
  93                 }
  94                 talloc_free(fname);
  95         }
  96         closedir(dir);
  97 }
  98
  99 /*
 100   cleanup temporary files. This is the new alternative to
 101   TDB_CLEAR_IF_FIRST. Unfortunately TDB_CLEAR_IF_FIRST is not
 102   efficient on unix systems due to the lack of scaling of the byte
 103   range locking system. So instead of putting the burden on tdb to
 104   cleanup tmp files, this function deletes them.
 105 */
 106 static void cleanup_tmp_files(struct loadparm_context *lp_ctx)
 107 {
 108         char *path;
 109         TALLOC_CTX *mem_ctx = talloc_new(NULL);
 110         if (mem_ctx == NULL) {
 111                 exit_daemon("Failed to create memory context",
 112                             ENOMEM);
 113         }
 114
 115         path = smbd_tmp_path(mem_ctx, lp_ctx, NULL);
 116         if (path == NULL) {
 117                 exit_daemon("Failed to cleanup temporary files",
 118                             EINVAL);
 119         }
 120
 121         recursive_delete(path);
 122         talloc_free(mem_ctx);
 123 }
 124
 125 static void sig_hup(int sig)
 126 {
 127         debug_schedule_reopen_logs();
 128 }
 129
 130 static void sig_term(int sig)
 131 {
 132 #ifdef HAVE_GETPGRP
 133         if (getpgrp() == getpid()) {
 134                 /*
 135                  * We're the process group leader, send
 136                  * SIGTERM to our process group.
 137                  */
 138                 kill(-getpgrp(), SIGTERM);
 139         }
 140 #endif
 141         _exit(127);
 142 }
 143
 144 static void sigterm_signal_handler(struct tevent_context *ev,
 145                                 struct tevent_signal *se,
 146                                 int signum, int count, void *siginfo,
 147                                 void *private_data)
 148 {
 149         struct server_state *state = talloc_get_type_abort(
 150                 private_data, struct server_state);
 151
 152         DBG_DEBUG("Process %s got SIGTERM\n", state->binary_name);
 153         TALLOC_FREE(state);
 154         sig_term(SIGTERM);
 155 }
 156
 157 /*
 158   setup signal masks
 159 */
 160 static void setup_signals(void)
 161 {
 162         /* we are never interested in SIGPIPE */
 163         BlockSignals(true,SIGPIPE);
 164
 165 #if defined(SIGFPE)
 166         /* we are never interested in SIGFPE */
 167         BlockSignals(true,SIGFPE);
 168 #endif
 169
 170         /* We are no longer interested in USR1 */
 171         BlockSignals(true, SIGUSR1);
 172
 173 #if defined(SIGUSR2)
 174         /* We are no longer interested in USR2 */
 175         BlockSignals(true,SIGUSR2);
 176 #endif
 177
 178         /* POSIX demands that signals are inherited. If the invoking process has
 179          * these signals masked, we will have problems,
 180          * as we won't receive them. */
 181         BlockSignals(false, SIGHUP);
 182         BlockSignals(false, SIGTERM);
 183
 184         CatchSignal(SIGHUP, sig_hup);
 185         CatchSignal(SIGTERM, sig_term);
 186 }
 187
 188 /*
 189   handle io on stdin
 190 */
 191 static void server_stdin_handler(struct tevent_context *event_ctx,
 192                                 struct tevent_fd *fde,
 193                                 uint16_t flags,
 194                                 void *private_data)
 195 {
 196         struct server_state *state = talloc_get_type_abort(
 197                 private_data, struct server_state);
 198         uint8_t c;
 199         if (read(0, &c, 1) == 0) {
 200                 DBG_ERR("%s: EOF on stdin - PID %d terminating\n",
 201                         state->binary_name, (int)getpid());
 202 #ifdef HAVE_GETPGRP
 203                 if (getpgrp() == getpid()) {
 204                         DBG_ERR("Sending SIGTERM from pid %d\n",
 205                                 (int)getpid());
 206                         kill(-getpgrp(), SIGTERM);
 207                 }
 208 #endif
 209                 TALLOC_FREE(state);
 210                 exit(0);
 211         }
 212 }
 213
 214 /*
 215   die if the user selected maximum runtime is exceeded
 216 */
 217 _NORETURN_ static void max_runtime_handler(struct tevent_context *ev,
 218                                            struct tevent_timer *te,
 219                                            struct timeval t, void *private_data)
 220 {
 221         struct server_state *state = talloc_get_type_abort(
 222                 private_data, struct server_state);
 223         DBG_ERR("%s: maximum runtime exceeded - "
 224                 "terminating PID %d at %llu, current ts: %llu\n",
 225                  state->binary_name,
 226                 (int)getpid(),
 227                 (unsigned long long)t.tv_sec,
 228                 (unsigned long long)time(NULL));
 229         TALLOC_FREE(state);
 230         exit(0);
 231 }
 232
 233 /*
 234   pre-open the key databases. This saves a lot of time in child
 235   processes
 236  */
 237 static int prime_ldb_databases(struct tevent_context *event_ctx, bool *am_backup)
 238 {
 239         struct ldb_result *res = NULL;
 240         struct ldb_dn *samba_dsdb_dn = NULL;
 241         struct ldb_context *ldb_ctx = NULL;
 242         struct ldb_context *pdb = NULL;
 243         static const char *attrs[] = { "backupDate", NULL };
 244         const char *msg = NULL;
 245         int ret;
 246         TALLOC_CTX *db_context = talloc_new(event_ctx);
 247         if (db_context == NULL) {
 248                 return LDB_ERR_OPERATIONS_ERROR;
 249         }
 250
 251         *am_backup = false;
 252
 253         /* note we deliberately leave these open, which allows them to be
 254          * re-used in ldb_wrap_connect() */
 255         ldb_ctx = samdb_connect(db_context,
 256                                 event_ctx,
 257                                 cmdline_lp_ctx,
 258                                 system_session(cmdline_lp_ctx),
 259                                 NULL,
 260                                 0);
 261         if (ldb_ctx == NULL) {
 262                 talloc_free(db_context);
 263                 return LDB_ERR_OPERATIONS_ERROR;
 264         }
 265         pdb = privilege_connect(db_context, cmdline_lp_ctx);
 266         if (pdb == NULL) {
 267                 talloc_free(db_context);
 268                 return LDB_ERR_OPERATIONS_ERROR;
 269         }
 270
 271         /* check the root DB object to see if it's marked as a backup */
 272         samba_dsdb_dn = ldb_dn_new(db_context, ldb_ctx, "@SAMBA_DSDB");
 273         if (!samba_dsdb_dn) {
 274                 talloc_free(db_context);
 275                 return LDB_ERR_OPERATIONS_ERROR;
 276         }
 277
 278         ret = dsdb_search_dn(ldb_ctx, db_context, &res, samba_dsdb_dn, attrs,
 279                              DSDB_FLAG_AS_SYSTEM);
 280         if (ret != LDB_SUCCESS) {
 281                 talloc_free(db_context);
 282                 return ret;
 283         }
 284
 285         if (res->count > 0) {
 286                 msg = ldb_msg_find_attr_as_string(res->msgs[0], "backupDate",
 287                                                   NULL);
 288                 if (msg != NULL) {
 289                         *am_backup = true;
 290                 }
 291         }
 292         return LDB_SUCCESS;
 293 }
 294
 295 /*
 296   called from 'smbcontrol samba shutdown'
 297  */
 298 static void samba_parent_shutdown(struct imessaging_context *msg,
 299                                   void *private_data,
 300                                   uint32_t msg_type,
 301                                   struct server_id src,
 302                                   DATA_BLOB *data)
 303 {
 304         struct server_state *state =
 305                 talloc_get_type_abort(private_data,
 306                 struct server_state);
 307         struct server_id_buf src_buf;
 308         struct server_id dst = imessaging_get_server_id(msg);
 309         struct server_id_buf dst_buf;
 310
 311         DBG_ERR("samba_shutdown of %s %s: from %s\n",
 312                 state->binary_name,
 313                 server_id_str_buf(dst, &dst_buf),
 314                 server_id_str_buf(src, &src_buf));
 315
 316         TALLOC_FREE(state);
 317         exit(0);
 318 }
 319
 320 /*
 321   called when a fatal condition occurs in a child task
 322  */
 323 static NTSTATUS samba_terminate(struct irpc_message *msg,
 324                                 struct samba_terminate *r)
 325 {
 326         struct server_state *state = talloc_get_type(msg->private_data,
 327                                         struct server_state);
 328         DBG_ERR("samba_terminate of %s %d: %s\n",
 329                 state->binary_name, (int)getpid(), r->in.reason);
 330         TALLOC_FREE(state);
 331         exit(1);
 332 }
 333
 334 /*
 335   setup messaging for the top level samba (parent) task
 336  */
 337 static NTSTATUS setup_parent_messaging(struct server_state *state,
 338                                        struct loadparm_context *lp_ctx)
 339 {
 340         struct imessaging_context *msg;
 341         NTSTATUS status;
 342
 343         msg = imessaging_init(state->event_ctx,
 344                               lp_ctx,
 345                               cluster_id(getpid(), SAMBA_PARENT_TASKID),
 346                               state->event_ctx);
 347         NT_STATUS_HAVE_NO_MEMORY(msg);
 348
 349         status = irpc_add_name(msg, "samba");
 350         if (!NT_STATUS_IS_OK(status)) {
 351                 return status;
 352         }
 353
 354         status = imessaging_register(msg, state, MSG_SHUTDOWN,
 355                                      samba_parent_shutdown);
 356         if (!NT_STATUS_IS_OK(status)) {
 357                 return status;
 358         }
 359
 360         status = IRPC_REGISTER(msg, irpc, SAMBA_TERMINATE,
 361                                samba_terminate, state);
 362         if (!NT_STATUS_IS_OK(status)) {
 363                 return status;
 364         }
 365
 366         return NT_STATUS_OK;
 367 }
 368
 369
 370 /*
 371   show build info
 372  */
 373 static void show_build(void)
 374 {
 375 #define CONFIG_OPTION(n) { #n, dyn_ ## n }
 376         struct {
 377                 const char *name;
 378                 const char *value;
 379         } config_options[] = {
 380                 CONFIG_OPTION(BINDIR),
 381                 CONFIG_OPTION(SBINDIR),
 382                 CONFIG_OPTION(CONFIGFILE),
 383                 CONFIG_OPTION(NCALRPCDIR),
 384                 CONFIG_OPTION(LOGFILEBASE),
 385                 CONFIG_OPTION(LMHOSTSFILE),
 386                 CONFIG_OPTION(DATADIR),
 387                 CONFIG_OPTION(MODULESDIR),
 388                 CONFIG_OPTION(LOCKDIR),
 389                 CONFIG_OPTION(STATEDIR),
 390                 CONFIG_OPTION(CACHEDIR),
 391                 CONFIG_OPTION(PIDDIR),
 392                 CONFIG_OPTION(PRIVATE_DIR),
 393                 CONFIG_OPTION(CODEPAGEDIR),
 394                 CONFIG_OPTION(SETUPDIR),
 395                 CONFIG_OPTION(WINBINDD_SOCKET_DIR),
 396                 CONFIG_OPTION(NTP_SIGND_SOCKET_DIR),
 397                 { NULL, NULL}
 398         };
 399         int i;
 400
 401         printf("Samba version: %s\n", SAMBA_VERSION_STRING);
 402         printf("Build environment:\n");
 403
 404         printf("Paths:\n");
 405         for (i=0; config_options[i].name; i++) {
 406                 printf("   %s: %s\n",
 407                         config_options[i].name,
 408                         config_options[i].value);
 409         }
 410
 411         exit(0);
 412 }
 413
 414 static int event_ctx_destructor(struct tevent_context *event_ctx)
 415 {
 416         imessaging_dgm_unref_ev(event_ctx);
 417         return 0;
 418 }
 419
 420 #ifdef HAVE_PTHREAD
 421 static int to_children_fd = -1;
 422 static void atfork_prepare(void) {
 423 }
 424 static void atfork_parent(void) {
 425 }
 426 static void atfork_child(void) {
 427         if (to_children_fd != -1) {
 428                 close(to_children_fd);
 429                 to_children_fd = -1;
 430         }
 431 }
 432 #endif
 433
 434 /*
 435  main server.
 436 */
 437 static int binary_smbd_main(const char *binary_name,
 438                                 int argc,
 439                                 const char *argv[])
 440 {
 441         bool opt_daemon = false;
 442         bool opt_fork = true;
 443         bool opt_interactive = false;
 444         bool opt_no_process_group = false;
 445         bool db_is_backup = false;
 446         int opt;
 447         int ret;
 448         poptContext pc;
 449 #define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
 450         STATIC_service_MODULES_PROTO;
 451         init_module_fn static_init[] = { STATIC_service_MODULES };
 452         init_module_fn *shared_init;
 453         uint16_t stdin_event_flags;
 454         NTSTATUS status;
 455         const char *model = "standard";
 456         int max_runtime = 0;
 457         struct stat st;
 458         enum {
 459                 OPT_DAEMON = 1000,
 460                 OPT_FOREGROUND,
 461                 OPT_INTERACTIVE,
 462                 OPT_PROCESS_MODEL,
 463                 OPT_SHOW_BUILD,
 464                 OPT_NO_PROCESS_GROUP,
 465         };
 466         struct poptOption long_options[] = {
 467                 POPT_AUTOHELP
 468                 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON,
 469                  "Become a daemon (default)", NULL },
 470                 {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FOREGROUND,
 471                  "Run the daemon in foreground", NULL },
 472                 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE,
 473                  "Run interactive (not a daemon)", NULL},
 474                 {"model", 'M', POPT_ARG_STRING, NULL, OPT_PROCESS_MODEL,
 475                  "Select process model", "MODEL"},
 476                 {"maximum-runtime",0, POPT_ARG_INT, &max_runtime, 0,
 477                  "set maximum runtime of the server process, "
 478                         "till autotermination", "seconds"},
 479                 {"show-build", 'b', POPT_ARG_NONE, NULL, OPT_SHOW_BUILD,
 480                         "show build info", NULL },
 481                 {"no-process-group", '\0', POPT_ARG_NONE, NULL,
 482                   OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
 483                 POPT_COMMON_SAMBA
 484                 POPT_COMMON_VERSION
 485                 { NULL }
 486         };
 487         struct server_state *state = NULL;
 488         struct tevent_signal *se = NULL;
 489
 490         setproctitle("root process");
 491
 492         pc = poptGetContext(binary_name, argc, argv, long_options, 0);
 493         while((opt = poptGetNextOpt(pc)) != -1) {
 494                 switch(opt) {
 495                 case OPT_DAEMON:
 496                         opt_daemon = true;
 497                         break;
 498                 case OPT_FOREGROUND:
 499                         opt_fork = false;
 500                         break;
 501                 case OPT_INTERACTIVE:
 502                         opt_interactive = true;
 503                         break;
 504                 case OPT_PROCESS_MODEL:
 505                         model = poptGetOptArg(pc);
 506                         break;
 507                 case OPT_SHOW_BUILD:
 508                         show_build();
 509                         break;
 510                 case OPT_NO_PROCESS_GROUP:
 511                         opt_no_process_group = true;
 512                         break;
 513                 default:
 514                         fprintf(stderr, "\nInvalid option %s: %s\n\n",
 515                                   poptBadOption(pc, 0), poptStrerror(opt));
 516                         poptPrintUsage(pc, stderr, 0);
 517                         return 1;
 518                 }
 519         }
 520
 521         if (opt_daemon && opt_interactive) {
 522                 fprintf(stderr,"\nERROR: "
 523                         "Option -i|--interactive is "
 524                         "not allowed together with -D|--daemon\n\n");
 525                 poptPrintUsage(pc, stderr, 0);
 526                 return 1;
 527         } else if (!opt_interactive && opt_fork) {
 528                 /* default is --daemon */
 529                 opt_daemon = true;
 530         }
 531
 532         poptFreeContext(pc);
 533
 534         talloc_enable_null_tracking();
 535
 536         setup_logging(binary_name, opt_interactive?DEBUG_STDOUT:DEBUG_FILE);
 537         setup_signals();
 538
 539         /* we want total control over the permissions on created files,
 540            so set our umask to 0 */
 541         umask(0);
 542
 543         DEBUG(0,("%s version %s started.\n",
 544                 binary_name,
 545                 SAMBA_VERSION_STRING));
 546         DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team"
 547                 " 1992-2019\n"));
 548
 549         if (sizeof(uint16_t) < 2 ||
 550                         sizeof(uint32_t) < 4 ||
 551                         sizeof(uint64_t) < 8) {
 552                 DEBUG(0,("ERROR: Samba is not configured correctly "
 553                         "for the word size on your machine\n"));
 554                 DEBUGADD(0,("sizeof(uint16_t) = %u, sizeof(uint32_t) %u, "
 555                         "sizeof(uint64_t) = %u\n",
 556                         (unsigned int)sizeof(uint16_t),
 557                         (unsigned int)sizeof(uint32_t),
 558                         (unsigned int)sizeof(uint64_t)));
 559                 return 1;
 560         }
 561
 562         if (opt_daemon) {
 563                 DBG_NOTICE("Becoming a daemon.\n");
 564                 become_daemon(opt_fork, opt_no_process_group, false);
 565         }
 566
 567         /* Create the memory context to hang everything off. */
 568         state = talloc_zero(NULL, struct server_state);
 569         if (state == NULL) {
 570                 exit_daemon("Samba cannot create server state", ENOMEM);
 571         };
 572         state->binary_name = binary_name;
 573
 574         cleanup_tmp_files(cmdline_lp_ctx);
 575
 576         if (!directory_exist(lpcfg_lock_directory(cmdline_lp_ctx))) {
 577                 mkdir(lpcfg_lock_directory(cmdline_lp_ctx), 0755);
 578         }
 579
 580         if (!directory_exist(lpcfg_pid_directory(cmdline_lp_ctx))) {
 581                 mkdir(lpcfg_pid_directory(cmdline_lp_ctx), 0755);
 582         }
 583
 584         pidfile_create(lpcfg_pid_directory(cmdline_lp_ctx), binary_name);
 585
 586         if (lpcfg_server_role(cmdline_lp_ctx) == ROLE_ACTIVE_DIRECTORY_DC) {
 587                 if (!open_schannel_session_store(state,
 588                                 cmdline_lp_ctx)) {
 589                         TALLOC_FREE(state);
 590                         exit_daemon("Samba cannot open schannel store "
 591                                 "for secured NETLOGON operations.", EACCES);
 592                 }
 593         }
 594
 595         /* make sure we won't go through nss_winbind */
 596         if (!winbind_off()) {
 597                 TALLOC_FREE(state);
 598                 exit_daemon("Samba failed to disable recusive "
 599                         "winbindd calls.", EACCES);
 600         }
 601
 602         gensec_init(); /* FIXME: */
 603
 604         process_model_init(cmdline_lp_ctx);
 605
 606         shared_init = load_samba_modules(NULL, "service");
 607
 608         run_init_functions(NULL, static_init);
 609         run_init_functions(NULL, shared_init);
 610
 611         talloc_free(shared_init);
 612
 613         /* the event context is the top level structure in smbd. Everything else
 614            should hang off that */
 615         state->event_ctx = s4_event_context_init(state);
 616
 617         if (state->event_ctx == NULL) {
 618                 TALLOC_FREE(state);
 619                 exit_daemon("Initializing event context failed", EACCES);
 620         }
 621
 622         talloc_set_destructor(state->event_ctx, event_ctx_destructor);
 623
 624         if (opt_interactive) {
 625                 /* terminate when stdin goes away */
 626                 stdin_event_flags = TEVENT_FD_READ;
 627         } else {
 628                 /* stay alive forever */
 629                 stdin_event_flags = 0;
 630         }
 631
 632 #ifdef HAVE_SETPGID
 633         /*
 634          * If we're interactive we want to set our own process group for
 635          * signal management, unless --no-process-group specified.
 636          */
 637         if (opt_interactive && !opt_no_process_group)
 638                 setpgid((pid_t)0, (pid_t)0);
 639 #endif
 640
 641         /* catch EOF on stdin */
 642 #ifdef SIGTTIN
 643         signal(SIGTTIN, SIG_IGN);
 644 #endif
 645
 646         if (fstat(0, &st) != 0) {
 647                 TALLOC_FREE(state);
 648                 exit_daemon("Samba failed to set standard input handler",
 649                                 ENOTTY);
 650         }
 651
 652         if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
 653                 struct tevent_fd *fde = tevent_add_fd(state->event_ctx,
 654                                 state->event_ctx,
 655                                 0,
 656                                 stdin_event_flags,
 657                                 server_stdin_handler,
 658                                 state);
 659                 if (fde == NULL) {
 660                         TALLOC_FREE(state);
 661                         exit_daemon("Initializing stdin failed", ENOMEM);
 662                 }
 663         }
 664
 665         if (max_runtime) {
 666                 struct tevent_timer *te;
 667                 DBG_ERR("%s PID %d was called with maxruntime %d - "
 668                         "current ts %llu\n",
 669                         binary_name, (int)getpid(),
 670                         max_runtime, (unsigned long long) time(NULL));
 671                 te = tevent_add_timer(state->event_ctx, state->event_ctx,
 672                                  timeval_current_ofs(max_runtime, 0),
 673                                  max_runtime_handler,
 674                                  state);
 675                 if (te == NULL) {
 676                         TALLOC_FREE(state);
 677                         exit_daemon("Maxruntime handler failed", ENOMEM);
 678                 }
 679         }
 680
 681         se = tevent_add_signal(state->event_ctx,
 682                                 state->event_ctx,
 683                                 SIGTERM,
 684                                 0,
 685                                 sigterm_signal_handler,
 686                                 state);
 687         if (se == NULL) {
 688                 TALLOC_FREE(state);
 689                 exit_daemon("Initialize SIGTERM handler failed", ENOMEM);
 690         }
 691
 692         if (lpcfg_server_role(cmdline_lp_ctx) != ROLE_ACTIVE_DIRECTORY_DC
 693             && !lpcfg_parm_bool(cmdline_lp_ctx, NULL,
 694                         "server role check", "inhibit", false)
 695             && !str_list_check_ci(lpcfg_server_services(cmdline_lp_ctx), "smb")
 696             && !str_list_check_ci(lpcfg_dcerpc_endpoint_servers(cmdline_lp_ctx),
 697                         "remote")
 698             && !str_list_check_ci(lpcfg_dcerpc_endpoint_servers(cmdline_lp_ctx),
 699                         "mapiproxy")) {
 700                 DEBUG(0, ("At this time the 'samba' binary should only be used "
 701                         "for either:\n"));
 702                 DEBUGADD(0, ("'server role = active directory domain "
 703                         "controller' or to access the ntvfs file server "
 704                         "with 'server services = +smb' or the rpc proxy "
 705                         "with 'dcerpc endpoint servers = remote'\n"));
 706                 DEBUGADD(0, ("You should start smbd/nmbd/winbindd instead for "
 707                         "domain member and standalone file server tasks\n"));
 708                 exit_daemon("Samba detected misconfigured 'server role' "
 709                         "and exited. Check logs for details", EINVAL);
 710         };
 711
 712         ret = prime_ldb_databases(state->event_ctx, &db_is_backup);
 713         if (ret != LDB_SUCCESS) {
 714                 TALLOC_FREE(state);
 715                 exit_daemon("Samba failed to prime database", EINVAL);
 716         }
 717
 718         if (db_is_backup) {
 719                 TALLOC_FREE(state);
 720                 exit_daemon("Database is a backup. Please run samba-tool domain"
 721                             " backup restore", EINVAL);
 722         }
 723
 724         status = setup_parent_messaging(state, cmdline_lp_ctx);
 725         if (!NT_STATUS_IS_OK(status)) {
 726                 TALLOC_FREE(state);
 727                 exit_daemon("Samba failed to setup parent messaging",
 728                         NT_STATUS_V(status));
 729         }
 730
 731         DBG_ERR("%s: using '%s' process model\n", binary_name, model);
 732
 733         {
 734                 int child_pipe[2];
 735                 int rc;
 736                 bool start_services = false;
 737
 738                 rc = pipe(child_pipe);
 739                 if (rc < 0) {
 740                         TALLOC_FREE(state);
 741                         exit_daemon("Samba failed to open process control pipe",
 742                                     errno);
 743                 }
 744                 smb_set_close_on_exec(child_pipe[0]);
 745                 smb_set_close_on_exec(child_pipe[1]);
 746
 747 #ifdef HAVE_PTHREAD
 748                 to_children_fd = child_pipe[1];
 749                 pthread_atfork(atfork_prepare, atfork_parent,
 750                                atfork_child);
 751                 start_services = true;
 752 #else
 753                 pid_t pid;
 754                 struct tfork *t = NULL;
 755                 t = tfork_create();
 756                 if (t == NULL) {
 757                         exit_daemon(
 758                                 "Samba unable to fork master process",
 759                                 0);
 760                 }
 761                 pid = tfork_child_pid(t);
 762                 if (pid == 0) {
 763                         start_services = false;
 764                 } else {
 765                         /* In the child process */
 766                         start_services = true;
 767                         close(child_pipe[1]);
 768                 }
 769 #endif
 770                 if (start_services) {
 771                         status = server_service_startup(
 772                                 state->event_ctx, cmdline_lp_ctx, model,
 773                                 lpcfg_server_services(cmdline_lp_ctx),
 774                                 child_pipe[0]);
 775                         if (!NT_STATUS_IS_OK(status)) {
 776                                 TALLOC_FREE(state);
 777                                 exit_daemon("Samba failed to start services",
 778                                 NT_STATUS_V(status));
 779                         }
 780                 }
 781         }
 782
 783         if (opt_daemon) {
 784                 daemon_ready("samba");
 785         }
 786
 787         /* wait for events - this is where smbd sits for most of its
 788            life */
 789         tevent_loop_wait(state->event_ctx);
 790
 791         /* as everything hangs off this state->event context, freeing state
 792            will initiate a clean shutdown of all services */
 793         TALLOC_FREE(state);
 794
 795         return 0;
 796 }
 797
 798 int main(int argc, const char *argv[])
 799 {
 800         setproctitle_init(argc, discard_const(argv), environ);
 801
 802         return binary_smbd_main("samba", argc, argv);
 803 }