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