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 "ldb/include/ldb.h"
  32 #include "registry/registry.h"
  33 #include "ntvfs/ntvfs.h"
  34 #include "ntptr/ntptr.h"
  35 #include "auth/gensec/gensec.h"
  36 #include "smbd/process_model.h"
  37 #include "smbd/service.h"
  38 #include "param/secrets.h"
  39 #include "smbd/pidfile.h"
  40 #include "param/param.h"
  41 #include "dsdb/samdb/samdb.h"
  42 #include "auth/session.h"
  43
  44 /*
  45   recursively delete a directory tree
  46 */
  47 static void recursive_delete(const char *path)
  48 {
  49         DIR *dir;
  50         struct dirent *de;
  51
  52         dir = opendir(path);
  53         if (!dir) {
  54                 return;
  55         }
  56
  57         for (de=readdir(dir);de;de=readdir(dir)) {
  58                 char *fname;
  59                 struct stat st;
  60
  61                 if (ISDOT(de->d_name) || ISDOTDOT(de->d_name)) {
  62                         continue;
  63                 }
  64
  65                 fname = talloc_asprintf(path, "%s/%s", path, de->d_name);
  66                 if (stat(fname, &st) != 0) {
  67                         continue;
  68                 }
  69                 if (S_ISDIR(st.st_mode)) {
  70                         recursive_delete(fname);
  71                         talloc_free(fname);
  72                         continue;
  73                 }
  74                 if (unlink(fname) != 0) {
  75                         DEBUG(0,("Unabled to delete '%s' - %s\n",
  76                                  fname, strerror(errno)));
  77                         smb_panic("unable to cleanup tmp files");
  78                 }
  79                 talloc_free(fname);
  80         }
  81         closedir(dir);
  82 }
  83
  84 /*
  85   cleanup temporary files. This is the new alternative to
  86   TDB_CLEAR_IF_FIRST. Unfortunately TDB_CLEAR_IF_FIRST is not
  87   efficient on unix systems due to the lack of scaling of the byte
  88   range locking system. So instead of putting the burden on tdb to
  89   cleanup tmp files, this function deletes them.
  90 */
  91 static void cleanup_tmp_files(struct loadparm_context *lp_ctx)
  92 {
  93         char *path;
  94         TALLOC_CTX *mem_ctx = talloc_new(NULL);
  95
  96         path = smbd_tmp_path(mem_ctx, lp_ctx, NULL);
  97
  98         recursive_delete(path);
  99         talloc_free(mem_ctx);
 100 }
 101
 102 static void sig_hup(int sig)
 103 {
 104         debug_schedule_reopen_logs();
 105 }
 106
 107 static void sig_term(int sig)
 108 {
 109 #if HAVE_GETPGRP
 110         static int done_sigterm;
 111         if (done_sigterm == 0 && getpgrp() == getpid()) {
 112                 DEBUG(0,("SIGTERM: killing children\n"));
 113                 done_sigterm = 1;
 114                 kill(-getpgrp(), SIGTERM);
 115         }
 116 #endif
 117         DEBUG(0,("Exiting pid %d on SIGTERM\n", (int)getpid()));
 118         exit(0);
 119 }
 120
 121 /*
 122   setup signal masks
 123 */
 124 static void setup_signals(void)
 125 {
 126         /* we are never interested in SIGPIPE */
 127         BlockSignals(true,SIGPIPE);
 128
 129 #if defined(SIGFPE)
 130         /* we are never interested in SIGFPE */
 131         BlockSignals(true,SIGFPE);
 132 #endif
 133
 134         /* We are no longer interested in USR1 */
 135         BlockSignals(true, SIGUSR1);
 136
 137 #if defined(SIGUSR2)
 138         /* We are no longer interested in USR2 */
 139         BlockSignals(true,SIGUSR2);
 140 #endif
 141
 142         /* POSIX demands that signals are inherited. If the invoking process has
 143          * these signals masked, we will have problems, as we won't recieve them. */
 144         BlockSignals(false, SIGHUP);
 145         BlockSignals(false, SIGTERM);
 146
 147         CatchSignal(SIGHUP, sig_hup);
 148         CatchSignal(SIGTERM, sig_term);
 149 }
 150
 151 /*
 152   handle io on stdin
 153 */
 154 static void server_stdin_handler(struct tevent_context *event_ctx, struct tevent_fd *fde,
 155                                  uint16_t flags, void *private_data)
 156 {
 157         const char *binary_name = (const char *)private_data;
 158         uint8_t c;
 159         if (read(0, &c, 1) == 0) {
 160                 DEBUG(0,("%s: EOF on stdin - terminating\n", binary_name));
 161 #if HAVE_GETPGRP
 162                 if (getpgrp() == getpid()) {
 163                         DEBUG(0,("Sending SIGTERM from pid %d\n", (int)getpid()));
 164                         kill(-getpgrp(), SIGTERM);
 165                 }
 166 #endif
 167                 exit(0);
 168         }
 169 }
 170
 171 /*
 172   die if the user selected maximum runtime is exceeded
 173 */
 174 _NORETURN_ static void max_runtime_handler(struct tevent_context *ev,
 175                                            struct tevent_timer *te,
 176                                            struct timeval t, void *private_data)
 177 {
 178         const char *binary_name = (const char *)private_data;
 179         DEBUG(0,("%s: maximum runtime exceeded - terminating\n", binary_name));
 180         exit(0);
 181 }
 182
 183 /*
 184   pre-open the sam ldb to ensure the schema has been loaded. This
 185   saves a lot of time in child processes
 186  */
 187 static void prime_samdb_schema(struct tevent_context *event_ctx)
 188 {
 189         TALLOC_CTX *samdb_context;
 190         samdb_context = talloc_new(event_ctx);
 191         samdb_connect(samdb_context, event_ctx, cmdline_lp_ctx, system_session(samdb_context, cmdline_lp_ctx));
 192         talloc_free(samdb_context);
 193 }
 194
 195 /*
 196  main server.
 197 */
 198 static int binary_smbd_main(const char *binary_name, int argc, const char *argv[])
 199 {
 200         bool opt_daemon = false;
 201         bool opt_interactive = false;
 202         int opt;
 203         poptContext pc;
 204         extern NTSTATUS server_service_wrepl_init(void);
 205         extern NTSTATUS server_service_kdc_init(void);
 206         extern NTSTATUS server_service_ldap_init(void);
 207         extern NTSTATUS server_service_web_init(void);
 208         extern NTSTATUS server_service_ldap_init(void);
 209         extern NTSTATUS server_service_winbind_init(void);
 210         extern NTSTATUS server_service_nbtd_init(void);
 211         extern NTSTATUS server_service_auth_init(void);
 212         extern NTSTATUS server_service_cldapd_init(void);
 213         extern NTSTATUS server_service_smb_init(void);
 214         extern NTSTATUS server_service_drepl_init(void);
 215         extern NTSTATUS server_service_rpc_init(void);
 216         extern NTSTATUS server_service_ntp_signd_init(void);
 217         extern NTSTATUS server_service_samba3_smb_init(void);
 218         init_module_fn static_init[] = { STATIC_service_MODULES };
 219         init_module_fn *shared_init;
 220         struct tevent_context *event_ctx;
 221         uint16_t stdin_event_flags;
 222         NTSTATUS status;
 223         const char *model = "standard";
 224         int max_runtime = 0;
 225         enum {
 226                 OPT_DAEMON = 1000,
 227                 OPT_INTERACTIVE,
 228                 OPT_PROCESS_MODEL
 229         };
 230         struct poptOption long_options[] = {
 231                 POPT_AUTOHELP
 232                 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON,
 233                  "Become a daemon (default)", NULL },
 234                 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE,
 235                  "Run interactive (not a daemon)", NULL},
 236                 {"model", 'M', POPT_ARG_STRING, NULL, OPT_PROCESS_MODEL,
 237                  "Select process model", "MODEL"},
 238                 {"maximum-runtime",0, POPT_ARG_INT, &max_runtime, 0,
 239                  "set maximum runtime of the server process, till autotermination", "seconds"},
 240                 POPT_COMMON_SAMBA
 241                 POPT_COMMON_VERSION
 242                 { NULL }
 243         };
 244
 245         pc = poptGetContext(binary_name, argc, argv, long_options, 0);
 246         while((opt = poptGetNextOpt(pc)) != -1) {
 247                 switch(opt) {
 248                 case OPT_DAEMON:
 249                         opt_daemon = true;
 250                         break;
 251                 case OPT_INTERACTIVE:
 252                         opt_interactive = true;
 253                         break;
 254                 case OPT_PROCESS_MODEL:
 255                         model = poptGetOptArg(pc);
 256                         break;
 257                 default:
 258                         fprintf(stderr, "\nInvalid option %s: %s\n\n",
 259                                   poptBadOption(pc, 0), poptStrerror(opt));
 260                         poptPrintUsage(pc, stderr, 0);
 261                         exit(1);
 262                 }
 263         }
 264
 265         if (opt_daemon && opt_interactive) {
 266                 fprintf(stderr,"\nERROR: "
 267                           "Option -i|--interactive is not allowed together with -D|--daemon\n\n");
 268                 poptPrintUsage(pc, stderr, 0);
 269                 exit(1);
 270         } else if (!opt_interactive) {
 271                 /* default is --daemon */
 272                 opt_daemon = true;
 273         }
 274
 275         poptFreeContext(pc);
 276
 277         setup_logging(binary_name, opt_interactive?DEBUG_STDOUT:DEBUG_FILE);
 278         setup_signals();
 279
 280         /* we want total control over the permissions on created files,
 281            so set our umask to 0 */
 282         umask(0);
 283
 284         DEBUG(0,("%s version %s started.\n", binary_name, SAMBA_VERSION_STRING));
 285         DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team 1992-2009\n"));
 286
 287         if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4 || sizeof(uint64_t) < 8) {
 288                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
 289                 DEBUGADD(0,("sizeof(uint16_t) = %u, sizeof(uint32_t) %u, sizeof(uint64_t) = %u\n",
 290                             (unsigned int)sizeof(uint16_t), (unsigned int)sizeof(uint32_t), (unsigned int)sizeof(uint64_t)));
 291                 exit(1);
 292         }
 293
 294         if (opt_daemon) {
 295                 DEBUG(3,("Becoming a daemon.\n"));
 296                 become_daemon(true, false);
 297         }
 298
 299         cleanup_tmp_files(cmdline_lp_ctx);
 300
 301         if (!directory_exist(lp_lockdir(cmdline_lp_ctx))) {
 302                 mkdir(lp_lockdir(cmdline_lp_ctx), 0755);
 303         }
 304
 305         pidfile_create(lp_piddir(cmdline_lp_ctx), binary_name);
 306
 307         /* Do *not* remove this, until you have removed
 308          * passdb/secrets.c, and proved that Samba still builds... */
 309         /* Setup the SECRETS subsystem */
 310         if (secrets_init(talloc_autofree_context(), cmdline_lp_ctx) == NULL) {
 311                 exit(1);
 312         }
 313
 314         gensec_init(cmdline_lp_ctx); /* FIXME: */
 315
 316         ntptr_init(cmdline_lp_ctx);     /* FIXME: maybe run this in the initialization function
 317                                                 of the spoolss RPC server instead? */
 318
 319         ntvfs_init(cmdline_lp_ctx);     /* FIXME: maybe run this in the initialization functions
 320                                                 of the SMB[,2] server instead? */
 321
 322         process_model_init(cmdline_lp_ctx);
 323
 324         shared_init = load_samba_modules(NULL, cmdline_lp_ctx, "service");
 325
 326         run_init_functions(static_init);
 327         run_init_functions(shared_init);
 328
 329         talloc_free(shared_init);
 330
 331         /* the event context is the top level structure in smbd. Everything else
 332            should hang off that */
 333         event_ctx = s4_event_context_init(talloc_autofree_context());
 334
 335         if (event_ctx == NULL) {
 336                 DEBUG(0,("Initializing event context failed\n"));
 337                 return 1;
 338         }
 339
 340         if (opt_interactive) {
 341                 /* terminate when stdin goes away */
 342                 stdin_event_flags = TEVENT_FD_READ;
 343         } else {
 344                 /* stay alive forever */
 345                 stdin_event_flags = 0;
 346         }
 347
 348         /* catch EOF on stdin */
 349 #ifdef SIGTTIN
 350         signal(SIGTTIN, SIG_IGN);
 351 #endif
 352         tevent_add_fd(event_ctx, event_ctx, 0, stdin_event_flags,
 353                       server_stdin_handler,
 354                       discard_const(binary_name));
 355
 356         if (max_runtime) {
 357                 tevent_add_timer(event_ctx, event_ctx,
 358                                  timeval_current_ofs(max_runtime, 0),
 359                                  max_runtime_handler,
 360                                  discard_const(binary_name));
 361         }
 362
 363         prime_samdb_schema(event_ctx);
 364
 365         DEBUG(0,("%s: using '%s' process model\n", binary_name, model));
 366         status = server_service_startup(event_ctx, cmdline_lp_ctx, model,
 367                                         lp_server_services(cmdline_lp_ctx));
 368         if (!NT_STATUS_IS_OK(status)) {
 369                 DEBUG(0,("Starting Services failed - %s\n", nt_errstr(status)));
 370                 return 1;
 371         }
 372
 373         /* wait for events - this is where smbd sits for most of its
 374            life */
 375         tevent_loop_wait(event_ctx);
 376
 377         /* as everything hangs off this event context, freeing it
 378            should initiate a clean shutdown of all services */
 379         talloc_free(event_ctx);
 380
 381         return 0;
 382 }
 383
 384  int main(int argc, const char *argv[])
 385 {
 386         return binary_smbd_main("samba", argc, argv);
 387 }