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
  47 /*
  48   recursively delete a directory tree
  49 */
  50 static void recursive_delete(const char *path)
  51 {
  52         DIR *dir;
  53         struct dirent *de;
  54
  55         dir = opendir(path);
  56         if (!dir) {
  57                 return;
  58         }
  59
  60         for (de=readdir(dir);de;de=readdir(dir)) {
  61                 char *fname;
  62                 struct stat st;
  63
  64                 if (ISDOT(de->d_name) || ISDOTDOT(de->d_name)) {
  65                         continue;
  66                 }
  67
  68                 fname = talloc_asprintf(path, "%s/%s", path, de->d_name);
  69                 if (stat(fname, &st) != 0) {
  70                         continue;
  71                 }
  72                 if (S_ISDIR(st.st_mode)) {
  73                         recursive_delete(fname);
  74                         talloc_free(fname);
  75                         continue;
  76                 }
  77                 if (unlink(fname) != 0) {
  78                         DEBUG(0,("Unabled to delete '%s' - %s\n",
  79                                  fname, strerror(errno)));
  80                         smb_panic("unable to cleanup tmp files");
  81                 }
  82                 talloc_free(fname);
  83         }
  84         closedir(dir);
  85 }
  86
  87 /*
  88   cleanup temporary files. This is the new alternative to
  89   TDB_CLEAR_IF_FIRST. Unfortunately TDB_CLEAR_IF_FIRST is not
  90   efficient on unix systems due to the lack of scaling of the byte
  91   range locking system. So instead of putting the burden on tdb to
  92   cleanup tmp files, this function deletes them.
  93 */
  94 static void cleanup_tmp_files(struct loadparm_context *lp_ctx)
  95 {
  96         char *path;
  97         TALLOC_CTX *mem_ctx = talloc_new(NULL);
  98
  99         path = smbd_tmp_path(mem_ctx, lp_ctx, NULL);
 100
 101         recursive_delete(path);
 102         talloc_free(mem_ctx);
 103 }
 104
 105 static void sig_hup(int sig)
 106 {
 107         debug_schedule_reopen_logs();
 108 }
 109
 110 static void sig_term(int sig)
 111 {
 112 #if HAVE_GETPGRP
 113         static int done_sigterm;
 114         if (done_sigterm == 0 && getpgrp() == getpid()) {
 115                 DEBUG(0,("SIGTERM: killing children\n"));
 116                 done_sigterm = 1;
 117                 kill(-getpgrp(), SIGTERM);
 118         }
 119 #endif
 120         DEBUG(0,("Exiting pid %d on SIGTERM\n", (int)getpid()));
 121         exit(127);
 122 }
 123
 124 /*
 125   setup signal masks
 126 */
 127 static void setup_signals(void)
 128 {
 129         /* we are never interested in SIGPIPE */
 130         BlockSignals(true,SIGPIPE);
 131
 132 #if defined(SIGFPE)
 133         /* we are never interested in SIGFPE */
 134         BlockSignals(true,SIGFPE);
 135 #endif
 136
 137         /* We are no longer interested in USR1 */
 138         BlockSignals(true, SIGUSR1);
 139
 140 #if defined(SIGUSR2)
 141         /* We are no longer interested in USR2 */
 142         BlockSignals(true,SIGUSR2);
 143 #endif
 144
 145         /* POSIX demands that signals are inherited. If the invoking process has
 146          * these signals masked, we will have problems,
 147          * as we won't receive them. */
 148         BlockSignals(false, SIGHUP);
 149         BlockSignals(false, SIGTERM);
 150
 151         CatchSignal(SIGHUP, sig_hup);
 152         CatchSignal(SIGTERM, sig_term);
 153 }
 154
 155 /*
 156   handle io on stdin
 157 */
 158 static void server_stdin_handler(struct tevent_context *event_ctx,
 159                                 struct tevent_fd *fde,
 160                                 uint16_t flags,
 161                                 void *private_data)
 162 {
 163         const char *binary_name = (const char *)private_data;
 164         uint8_t c;
 165         if (read(0, &c, 1) == 0) {
 166                 DEBUG(0,("%s: EOF on stdin - PID %d terminating\n",
 167                                 binary_name, (int)getpid()));
 168 #if HAVE_GETPGRP
 169                 if (getpgrp() == getpid()) {
 170                         DEBUG(0,("Sending SIGTERM from pid %d\n",
 171                                 (int)getpid()));
 172                         kill(-getpgrp(), SIGTERM);
 173                 }
 174 #endif
 175                 exit(0);
 176         }
 177 }
 178
 179 /*
 180   die if the user selected maximum runtime is exceeded
 181 */
 182 _NORETURN_ static void max_runtime_handler(struct tevent_context *ev,
 183                                            struct tevent_timer *te,
 184                                            struct timeval t, void *private_data)
 185 {
 186         const char *binary_name = (const char *)private_data;
 187         DEBUG(0,("%s: maximum runtime exceeded - "
 188                 "terminating PID %d at %llu, current ts: %llu\n",
 189                  binary_name,
 190                 (int)getpid(),
 191                 (unsigned long long)t.tv_sec,
 192                 (unsigned long long)time(NULL)));
 193         exit(0);
 194 }
 195
 196 /*
 197   pre-open the key databases. This saves a lot of time in child
 198   processes
 199  */
 200 static void prime_ldb_databases(struct tevent_context *event_ctx)
 201 {
 202         TALLOC_CTX *db_context;
 203         db_context = talloc_new(event_ctx);
 204
 205         samdb_connect(db_context,
 206                         event_ctx,
 207                         cmdline_lp_ctx,
 208                         system_session(cmdline_lp_ctx),
 209                         0);
 210         privilege_connect(db_context, cmdline_lp_ctx);
 211
 212         /* we deliberately leave these open, which allows them to be
 213          * re-used in ldb_wrap_connect() */
 214 }
 215
 216
 217 /*
 218   called when a fatal condition occurs in a child task
 219  */
 220 static NTSTATUS samba_terminate(struct irpc_message *msg,
 221                                 struct samba_terminate *r)
 222 {
 223         DEBUG(0,("samba_terminate of %d: %s\n",
 224                  (int)getpid(), r->in.reason));
 225         exit(1);
 226 }
 227
 228 /*
 229   setup messaging for the top level samba (parent) task
 230  */
 231 static NTSTATUS setup_parent_messaging(struct tevent_context *event_ctx,
 232                                        struct loadparm_context *lp_ctx)
 233 {
 234         struct imessaging_context *msg;
 235         NTSTATUS status;
 236
 237         msg = imessaging_init(talloc_autofree_context(),
 238                               lp_ctx,
 239                               cluster_id(0, SAMBA_PARENT_TASKID), event_ctx);
 240         NT_STATUS_HAVE_NO_MEMORY(msg);
 241
 242         status = irpc_add_name(msg, "samba");
 243         if (!NT_STATUS_IS_OK(status)) {
 244                 return status;
 245         }
 246
 247         status = IRPC_REGISTER(msg, irpc, SAMBA_TERMINATE,
 248                                samba_terminate, NULL);
 249
 250         return status;
 251 }
 252
 253
 254 /*
 255   show build info
 256  */
 257 static void show_build(void)
 258 {
 259 #define CONFIG_OPTION(n) { #n, dyn_ ## n }
 260         struct {
 261                 const char *name;
 262                 const char *value;
 263         } config_options[] = {
 264                 CONFIG_OPTION(BINDIR),
 265                 CONFIG_OPTION(SBINDIR),
 266                 CONFIG_OPTION(CONFIGFILE),
 267                 CONFIG_OPTION(NCALRPCDIR),
 268                 CONFIG_OPTION(LOGFILEBASE),
 269                 CONFIG_OPTION(LMHOSTSFILE),
 270                 CONFIG_OPTION(DATADIR),
 271                 CONFIG_OPTION(MODULESDIR),
 272                 CONFIG_OPTION(LOCKDIR),
 273                 CONFIG_OPTION(STATEDIR),
 274                 CONFIG_OPTION(CACHEDIR),
 275                 CONFIG_OPTION(PIDDIR),
 276                 CONFIG_OPTION(PRIVATE_DIR),
 277                 CONFIG_OPTION(CODEPAGEDIR),
 278                 CONFIG_OPTION(SETUPDIR),
 279                 CONFIG_OPTION(WINBINDD_SOCKET_DIR),
 280                 CONFIG_OPTION(NTP_SIGND_SOCKET_DIR),
 281                 { NULL, NULL}
 282         };
 283         int i;
 284
 285         printf("Samba version: %s\n", SAMBA_VERSION_STRING);
 286         printf("Build environment:\n");
 287 #ifdef BUILD_SYSTEM
 288         printf("   Build host:  %s\n", BUILD_SYSTEM);
 289 #endif
 290
 291         printf("Paths:\n");
 292         for (i=0; config_options[i].name; i++) {
 293                 printf("   %s: %s\n",
 294                         config_options[i].name,
 295                         config_options[i].value);
 296         }
 297
 298         exit(0);
 299 }
 300
 301 static int event_ctx_destructor(struct tevent_context *event_ctx)
 302 {
 303         imessaging_dgm_unref_all();
 304         return 0;
 305 }
 306
 307 /*
 308  main server.
 309 */
 310 static int binary_smbd_main(const char *binary_name,
 311                                 int argc,
 312                                 const char *argv[])
 313 {
 314         bool opt_daemon = false;
 315         bool opt_interactive = false;
 316         int opt;
 317         poptContext pc;
 318 #define _MODULE_PROTO(init) extern NTSTATUS init(void);
 319         STATIC_service_MODULES_PROTO;
 320         init_module_fn static_init[] = { STATIC_service_MODULES };
 321         init_module_fn *shared_init;
 322         struct tevent_context *event_ctx;
 323         uint16_t stdin_event_flags;
 324         NTSTATUS status;
 325         const char *model = "standard";
 326         int max_runtime = 0;
 327         struct stat st;
 328         enum {
 329                 OPT_DAEMON = 1000,
 330                 OPT_INTERACTIVE,
 331                 OPT_PROCESS_MODEL,
 332                 OPT_SHOW_BUILD
 333         };
 334         struct poptOption long_options[] = {
 335                 POPT_AUTOHELP
 336                 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON,
 337                  "Become a daemon (default)", NULL },
 338                 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE,
 339                  "Run interactive (not a daemon)", NULL},
 340                 {"model", 'M', POPT_ARG_STRING, NULL, OPT_PROCESS_MODEL,
 341                  "Select process model", "MODEL"},
 342                 {"maximum-runtime",0, POPT_ARG_INT, &max_runtime, 0,
 343                  "set maximum runtime of the server process, "
 344                         "till autotermination", "seconds"},
 345                 {"show-build", 'b', POPT_ARG_NONE, NULL, OPT_SHOW_BUILD,
 346                         "show build info", NULL },
 347                 POPT_COMMON_SAMBA
 348                 POPT_COMMON_VERSION
 349                 { NULL }
 350         };
 351
 352         pc = poptGetContext(binary_name, argc, argv, long_options, 0);
 353         while((opt = poptGetNextOpt(pc)) != -1) {
 354                 switch(opt) {
 355                 case OPT_DAEMON:
 356                         opt_daemon = true;
 357                         break;
 358                 case OPT_INTERACTIVE:
 359                         opt_interactive = true;
 360                         break;
 361                 case OPT_PROCESS_MODEL:
 362                         model = poptGetOptArg(pc);
 363                         break;
 364                 case OPT_SHOW_BUILD:
 365                         show_build();
 366                         break;
 367                 default:
 368                         fprintf(stderr, "\nInvalid option %s: %s\n\n",
 369                                   poptBadOption(pc, 0), poptStrerror(opt));
 370                         poptPrintUsage(pc, stderr, 0);
 371                         return 1;
 372                 }
 373         }
 374
 375         if (opt_daemon && opt_interactive) {
 376                 fprintf(stderr,"\nERROR: "
 377                         "Option -i|--interactive is "
 378                         "not allowed together with -D|--daemon\n\n");
 379                 poptPrintUsage(pc, stderr, 0);
 380                 return 1;
 381         } else if (!opt_interactive) {
 382                 /* default is --daemon */
 383                 opt_daemon = true;
 384         }
 385
 386         poptFreeContext(pc);
 387
 388         talloc_enable_null_tracking();
 389
 390         setup_logging(binary_name, opt_interactive?DEBUG_STDOUT:DEBUG_FILE);
 391         setup_signals();
 392
 393         /* we want total control over the permissions on created files,
 394            so set our umask to 0 */
 395         umask(0);
 396
 397         DEBUG(0,("%s version %s started.\n",
 398                 binary_name,
 399                 SAMBA_VERSION_STRING));
 400         DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team"
 401                 " 1992-2017\n"));
 402
 403         if (sizeof(uint16_t) < 2 ||
 404                         sizeof(uint32_t) < 4 ||
 405                         sizeof(uint64_t) < 8) {
 406                 DEBUG(0,("ERROR: Samba is not configured correctly "
 407                         "for the word size on your machine\n"));
 408                 DEBUGADD(0,("sizeof(uint16_t) = %u, sizeof(uint32_t) %u, "
 409                         "sizeof(uint64_t) = %u\n",
 410                         (unsigned int)sizeof(uint16_t),
 411                         (unsigned int)sizeof(uint32_t),
 412                         (unsigned int)sizeof(uint64_t)));
 413                 return 1;
 414         }
 415
 416         if (opt_daemon) {
 417                 DEBUG(3,("Becoming a daemon.\n"));
 418                 become_daemon(true, false, false);
 419         }
 420
 421         cleanup_tmp_files(cmdline_lp_ctx);
 422
 423         if (!directory_exist(lpcfg_lock_directory(cmdline_lp_ctx))) {
 424                 mkdir(lpcfg_lock_directory(cmdline_lp_ctx), 0755);
 425         }
 426
 427         pidfile_create(lpcfg_pid_directory(cmdline_lp_ctx), binary_name);
 428
 429         if (lpcfg_server_role(cmdline_lp_ctx) == ROLE_ACTIVE_DIRECTORY_DC) {
 430                 if (!open_schannel_session_store(talloc_autofree_context(),
 431                                 cmdline_lp_ctx)) {
 432                         exit_daemon("Samba cannot open schannel store "
 433                                 "for secured NETLOGON operations.", EACCES);
 434                 }
 435         }
 436
 437         /* make sure we won't go through nss_winbind */
 438         if (!winbind_off()) {
 439                 exit_daemon("Samba failed to disable recusive "
 440                         "winbindd calls.", EACCES);
 441         }
 442
 443         gensec_init(); /* FIXME: */
 444
 445         process_model_init(cmdline_lp_ctx);
 446
 447         shared_init = load_samba_modules(NULL, "service");
 448
 449         run_init_functions(static_init);
 450         run_init_functions(shared_init);
 451
 452         talloc_free(shared_init);
 453
 454         /* the event context is the top level structure in smbd. Everything else
 455            should hang off that */
 456         event_ctx = s4_event_context_init(talloc_autofree_context());
 457
 458         if (event_ctx == NULL) {
 459                 exit_daemon("Initializing event context failed", EACCES);
 460         }
 461
 462         talloc_set_destructor(event_ctx, event_ctx_destructor);
 463
 464         if (opt_interactive) {
 465                 /* terminate when stdin goes away */
 466                 stdin_event_flags = TEVENT_FD_READ;
 467         } else {
 468                 /* stay alive forever */
 469                 stdin_event_flags = 0;
 470         }
 471
 472         /* catch EOF on stdin */
 473 #ifdef SIGTTIN
 474         signal(SIGTTIN, SIG_IGN);
 475 #endif
 476
 477         if (fstat(0, &st) != 0) {
 478                 exit_daemon("Samba failed to set standard input handler",
 479                                 ENOTTY);
 480         }
 481
 482         if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
 483                 tevent_add_fd(event_ctx,
 484                                 event_ctx,
 485                                 0,
 486                                 stdin_event_flags,
 487                                 server_stdin_handler,
 488                                 discard_const(binary_name));
 489         }
 490
 491         if (max_runtime) {
 492                 DEBUG(0,("%s PID %d was called with maxruntime %d - "
 493                         "current ts %llu\n",
 494                         binary_name, (int)getpid(),
 495                         max_runtime, (unsigned long long) time(NULL)));
 496                 tevent_add_timer(event_ctx, event_ctx,
 497                                  timeval_current_ofs(max_runtime, 0),
 498                                  max_runtime_handler,
 499                                  discard_const(binary_name));
 500         }
 501
 502         if (lpcfg_server_role(cmdline_lp_ctx) != ROLE_ACTIVE_DIRECTORY_DC
 503             && !lpcfg_parm_bool(cmdline_lp_ctx, NULL,
 504                         "server role check", "inhibit", false)
 505             && !str_list_check_ci(lpcfg_server_services(cmdline_lp_ctx), "smb")
 506             && !str_list_check_ci(lpcfg_dcerpc_endpoint_servers(cmdline_lp_ctx),
 507                         "remote")
 508             && !str_list_check_ci(lpcfg_dcerpc_endpoint_servers(cmdline_lp_ctx),
 509                         "mapiproxy")) {
 510                 DEBUG(0, ("At this time the 'samba' binary should only be used "
 511                         "for either:\n"));
 512                 DEBUGADD(0, ("'server role = active directory domain "
 513                         "controller' or to access the ntvfs file server "
 514                         "with 'server services = +smb' or the rpc proxy "
 515                         "with 'dcerpc endpoint servers = remote'\n"));
 516                 DEBUGADD(0, ("You should start smbd/nmbd/winbindd instead for "
 517                         "domain member and standalone file server tasks\n"));
 518                 exit_daemon("Samba detected misconfigured 'server role' "
 519                         "and exited. Check logs for details", EINVAL);
 520         };
 521
 522         prime_ldb_databases(event_ctx);
 523
 524         status = setup_parent_messaging(event_ctx, cmdline_lp_ctx);
 525         if (!NT_STATUS_IS_OK(status)) {
 526                 exit_daemon("Samba failed to setup parent messaging",
 527                         NT_STATUS_V(status));
 528         }
 529
 530         DEBUG(0,("%s: using '%s' process model\n", binary_name, model));
 531
 532         status = server_service_startup(event_ctx, cmdline_lp_ctx, model,
 533                                         lpcfg_server_services(cmdline_lp_ctx));
 534         if (!NT_STATUS_IS_OK(status)) {
 535                 exit_daemon("Samba failed to start services",
 536                         NT_STATUS_V(status));
 537         }
 538
 539         if (opt_daemon) {
 540                 daemon_ready("samba");
 541         }
 542
 543         /* wait for events - this is where smbd sits for most of its
 544            life */
 545         tevent_loop_wait(event_ctx);
 546
 547         /* as everything hangs off this event context, freeing it
 548            should initiate a clean shutdown of all services */
 549         talloc_free(event_ctx);
 550
 551         return 0;
 552 }
 553
 554 int main(int argc, const char *argv[])
 555 {
 556         return binary_smbd_main("samba", argc, argv);
 557 }