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_kcc_init(void);
 216         extern NTSTATUS server_service_rpc_init(void);
 217         extern NTSTATUS server_service_ntp_signd_init(void);
 218         extern NTSTATUS server_service_samba3_smb_init(void);
 219         init_module_fn static_init[] = { STATIC_service_MODULES };
 220         init_module_fn *shared_init;
 221         struct tevent_context *event_ctx;
 222         uint16_t stdin_event_flags;
 223         NTSTATUS status;
 224         const char *model = "standard";
 225         int max_runtime = 0;
 226         enum {
 227                 OPT_DAEMON = 1000,
 228                 OPT_INTERACTIVE,
 229                 OPT_PROCESS_MODEL
 230         };
 231         struct poptOption long_options[] = {
 232                 POPT_AUTOHELP
 233                 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON,
 234                  "Become a daemon (default)", NULL },
 235                 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE,
 236                  "Run interactive (not a daemon)", NULL},
 237                 {"model", 'M', POPT_ARG_STRING, NULL, OPT_PROCESS_MODEL,
 238                  "Select process model", "MODEL"},
 239                 {"maximum-runtime",0, POPT_ARG_INT, &max_runtime, 0,
 240                  "set maximum runtime of the server process, till autotermination", "seconds"},
 241                 POPT_COMMON_SAMBA
 242                 POPT_COMMON_VERSION
 243                 { NULL }
 244         };
 245
 246         pc = poptGetContext(binary_name, argc, argv, long_options, 0);
 247         while((opt = poptGetNextOpt(pc)) != -1) {
 248                 switch(opt) {
 249                 case OPT_DAEMON:
 250                         opt_daemon = true;
 251                         break;
 252                 case OPT_INTERACTIVE:
 253                         opt_interactive = true;
 254                         break;
 255                 case OPT_PROCESS_MODEL:
 256                         model = poptGetOptArg(pc);
 257                         break;
 258                 default:
 259                         fprintf(stderr, "\nInvalid option %s: %s\n\n",
 260                                   poptBadOption(pc, 0), poptStrerror(opt));
 261                         poptPrintUsage(pc, stderr, 0);
 262                         exit(1);
 263                 }
 264         }
 265
 266         if (opt_daemon && opt_interactive) {
 267                 fprintf(stderr,"\nERROR: "
 268                           "Option -i|--interactive is not allowed together with -D|--daemon\n\n");
 269                 poptPrintUsage(pc, stderr, 0);
 270                 exit(1);
 271         } else if (!opt_interactive) {
 272                 /* default is --daemon */
 273                 opt_daemon = true;
 274         }
 275
 276         poptFreeContext(pc);
 277
 278         setup_logging(binary_name, opt_interactive?DEBUG_STDOUT:DEBUG_FILE);
 279         setup_signals();
 280
 281         /* we want total control over the permissions on created files,
 282            so set our umask to 0 */
 283         umask(0);
 284
 285         DEBUG(0,("%s version %s started.\n", binary_name, SAMBA_VERSION_STRING));
 286         DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team 1992-2009\n"));
 287
 288         if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4 || sizeof(uint64_t) < 8) {
 289                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
 290                 DEBUGADD(0,("sizeof(uint16_t) = %u, sizeof(uint32_t) %u, sizeof(uint64_t) = %u\n",
 291                             (unsigned int)sizeof(uint16_t), (unsigned int)sizeof(uint32_t), (unsigned int)sizeof(uint64_t)));
 292                 exit(1);
 293         }
 294
 295         if (opt_daemon) {
 296                 DEBUG(3,("Becoming a daemon.\n"));
 297                 become_daemon(true, false);
 298         }
 299
 300         cleanup_tmp_files(cmdline_lp_ctx);
 301
 302         if (!directory_exist(lp_lockdir(cmdline_lp_ctx))) {
 303                 mkdir(lp_lockdir(cmdline_lp_ctx), 0755);
 304         }
 305
 306         pidfile_create(lp_piddir(cmdline_lp_ctx), binary_name);
 307
 308         /* Do *not* remove this, until you have removed
 309          * passdb/secrets.c, and proved that Samba still builds... */
 310         /* Setup the SECRETS subsystem */
 311         if (secrets_init(talloc_autofree_context(), cmdline_lp_ctx) == NULL) {
 312                 exit(1);
 313         }
 314
 315         gensec_init(cmdline_lp_ctx); /* FIXME: */
 316
 317         ntptr_init(cmdline_lp_ctx);     /* FIXME: maybe run this in the initialization function
 318                                                 of the spoolss RPC server instead? */
 319
 320         ntvfs_init(cmdline_lp_ctx);     /* FIXME: maybe run this in the initialization functions
 321                                                 of the SMB[,2] server instead? */
 322
 323         process_model_init(cmdline_lp_ctx);
 324
 325         shared_init = load_samba_modules(NULL, cmdline_lp_ctx, "service");
 326
 327         run_init_functions(static_init);
 328         run_init_functions(shared_init);
 329
 330         talloc_free(shared_init);
 331
 332         /* the event context is the top level structure in smbd. Everything else
 333            should hang off that */
 334         event_ctx = s4_event_context_init(talloc_autofree_context());
 335
 336         if (event_ctx == NULL) {
 337                 DEBUG(0,("Initializing event context failed\n"));
 338                 return 1;
 339         }
 340
 341         if (opt_interactive) {
 342                 /* terminate when stdin goes away */
 343                 stdin_event_flags = TEVENT_FD_READ;
 344         } else {
 345                 /* stay alive forever */
 346                 stdin_event_flags = 0;
 347         }
 348
 349         /* catch EOF on stdin */
 350 #ifdef SIGTTIN
 351         signal(SIGTTIN, SIG_IGN);
 352 #endif
 353         tevent_add_fd(event_ctx, event_ctx, 0, stdin_event_flags,
 354                       server_stdin_handler,
 355                       discard_const(binary_name));
 356
 357         if (max_runtime) {
 358                 tevent_add_timer(event_ctx, event_ctx,
 359                                  timeval_current_ofs(max_runtime, 0),
 360                                  max_runtime_handler,
 361                                  discard_const(binary_name));
 362         }
 363
 364         prime_samdb_schema(event_ctx);
 365
 366         DEBUG(0,("%s: using '%s' process model\n", binary_name, model));
 367         status = server_service_startup(event_ctx, cmdline_lp_ctx, model,
 368                                         lp_server_services(cmdline_lp_ctx));
 369         if (!NT_STATUS_IS_OK(status)) {
 370                 DEBUG(0,("Starting Services failed - %s\n", nt_errstr(status)));
 371                 return 1;
 372         }
 373
 374         /* wait for events - this is where smbd sits for most of its
 375            life */
 376         tevent_loop_wait(event_ctx);
 377
 378         /* as everything hangs off this event context, freeing it
 379            should initiate a clean shutdown of all services */
 380         talloc_free(event_ctx);
 381
 382         return 0;
 383 }
 384
 385  int main(int argc, const char *argv[])
 386 {
 387         return binary_smbd_main("samba", argc, argv);
 388 }