source3/smbd/server.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Main SMB server routines
   4    Copyright (C) Andrew Tridgell                1992-1998
   5    Copyright (C) Martin Pool                    2002
   6    Copyright (C) Jelmer Vernooij                2002-2003
   7    Copyright (C) James Peach                    2007
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24
  25 static_decl_rpc;
  26
  27 static int am_parent = 1;
  28
  29 /* the last message the was processed */
  30 int last_message = -1;
  31
  32 /* a useful macro to debug the last message processed */
  33 #define LAST_MESSAGE() smb_fn_name(last_message)
  34
  35 extern struct auth_context *negprot_global_auth_context;
  36 extern pstring user_socket_options;
  37 extern SIG_ATOMIC_T got_sig_term;
  38 extern SIG_ATOMIC_T reload_after_sighup;
  39 static SIG_ATOMIC_T got_sig_cld;
  40
  41 #ifdef WITH_DFS
  42 extern int dcelogin_atmost_once;
  43 #endif /* WITH_DFS */
  44
  45 /* really we should have a top level context structure that has the
  46    client file descriptor as an element. That would require a major rewrite :(
  47
  48    the following 2 functions are an alternative - they make the file
  49    descriptor private to smbd
  50  */
  51 static int server_fd = -1;
  52
  53 int smbd_server_fd(void)
  54 {
  55         return server_fd;
  56 }
  57
  58 static void smbd_set_server_fd(int fd)
  59 {
  60         server_fd = fd;
  61         client_setfd(fd);
  62 }
  63
  64 struct event_context *smbd_event_context(void)
  65 {
  66         static struct event_context *ctx;
  67
  68         if (!ctx && !(ctx = event_context_init(NULL))) {
  69                 smb_panic("Could not init smbd event context");
  70         }
  71         return ctx;
  72 }
  73
  74 struct messaging_context *smbd_messaging_context(void)
  75 {
  76         static struct messaging_context *ctx;
  77
  78         if (!ctx && !(ctx = messaging_init(NULL, server_id_self(),
  79                                            smbd_event_context()))) {
  80                 smb_panic("Could not init smbd messaging context");
  81         }
  82         return ctx;
  83 }
  84
  85 /*******************************************************************
  86  What to do when smb.conf is updated.
  87  ********************************************************************/
  88
  89 static void smb_conf_updated(struct messaging_context *msg,
  90                              void *private_data,
  91                              uint32_t msg_type,
  92                              struct server_id server_id,
  93                              DATA_BLOB *data)
  94 {
  95         DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
  96                   "updated. Reloading.\n"));
  97         reload_services(False);
  98 }
  99
 100
 101 /*******************************************************************
 102  Delete a statcache entry.
 103  ********************************************************************/
 104
 105 static void smb_stat_cache_delete(struct messaging_context *msg,
 106                                   void *private_data,
 107                                   uint32_t msg_tnype,
 108                                   struct server_id server_id,
 109                                   DATA_BLOB *data)
 110 {
 111         const char *name = (const char *)data->data;
 112         DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
 113         stat_cache_delete(name);
 114 }
 115
 116 /****************************************************************************
 117  Terminate signal.
 118 ****************************************************************************/
 119
 120 static void sig_term(void)
 121 {
 122         got_sig_term = 1;
 123         sys_select_signal(SIGTERM);
 124 }
 125
 126 /****************************************************************************
 127  Catch a sighup.
 128 ****************************************************************************/
 129
 130 static void sig_hup(int sig)
 131 {
 132         reload_after_sighup = 1;
 133         sys_select_signal(SIGHUP);
 134 }
 135
 136 /****************************************************************************
 137  Catch a sigcld
 138 ****************************************************************************/
 139 static void sig_cld(int sig)
 140 {
 141         got_sig_cld = 1;
 142         sys_select_signal(SIGCLD);
 143 }
 144
 145 /****************************************************************************
 146   Send a SIGTERM to our process group.
 147 *****************************************************************************/
 148
 149 static void  killkids(void)
 150 {
 151         if(am_parent) kill(0,SIGTERM);
 152 }
 153
 154 /****************************************************************************
 155  Process a sam sync message - not sure whether to do this here or
 156  somewhere else.
 157 ****************************************************************************/
 158
 159 static void msg_sam_sync(struct messaging_context *msg,
 160                          void *private_data,
 161                          uint32_t msg_type,
 162                          struct server_id server_id,
 163                          DATA_BLOB *data)
 164 {
 165         DEBUG(10, ("** sam sync message received, ignoring\n"));
 166 }
 167
 168
 169 /****************************************************************************
 170  Open the socket communication - inetd.
 171 ****************************************************************************/
 172
 173 static BOOL open_sockets_inetd(void)
 174 {
 175         /* Started from inetd. fd 0 is the socket. */
 176         /* We will abort gracefully when the client or remote system
 177            goes away */
 178         smbd_set_server_fd(dup(0));
 179
 180         /* close our standard file descriptors */
 181         close_low_fds(False); /* Don't close stderr */
 182
 183         set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 184         set_socket_options(smbd_server_fd(), user_socket_options);
 185
 186         return True;
 187 }
 188
 189 static void msg_exit_server(struct messaging_context *msg,
 190                             void *private_data,
 191                             uint32_t msg_type,
 192                             struct server_id server_id,
 193                             DATA_BLOB *data)
 194 {
 195         DEBUG(3, ("got a SHUTDOWN message\n"));
 196         exit_server_cleanly(NULL);
 197 }
 198
 199 #ifdef DEVELOPER
 200 static void msg_inject_fault(struct messaging_context *msg,
 201                              void *private_data,
 202                              uint32_t msg_type,
 203                              struct server_id src,
 204                              DATA_BLOB *data)
 205 {
 206         int sig;
 207
 208         if (data->length != sizeof(sig)) {
 209
 210                 DEBUG(0, ("Process %s sent bogus signal injection request\n",
 211                           procid_str_static(&src)));
 212                 return;
 213         }
 214
 215         sig = *(int *)data->data;
 216         if (sig == -1) {
 217                 exit_server("internal error injected");
 218                 return;
 219         }
 220
 221 #if HAVE_STRSIGNAL
 222         DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
 223                   procid_str_static(&src), sig, strsignal(sig)));
 224 #else
 225         DEBUG(0, ("Process %s requested injection of signal %d\n",
 226                   procid_str_static(&src), sig));
 227 #endif
 228
 229         kill(sys_getpid(), sig);
 230 }
 231 #endif /* DEVELOPER */
 232
 233 struct child_pid {
 234         struct child_pid *prev, *next;
 235         pid_t pid;
 236 };
 237
 238 static struct child_pid *children;
 239 static int num_children;
 240
 241 static void add_child_pid(pid_t pid)
 242 {
 243         struct child_pid *child;
 244
 245         if (lp_max_smbd_processes() == 0) {
 246                 /* Don't bother with the child list if we don't care anyway */
 247                 return;
 248         }
 249
 250         child = SMB_MALLOC_P(struct child_pid);
 251         if (child == NULL) {
 252                 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
 253                 return;
 254         }
 255         child->pid = pid;
 256         DLIST_ADD(children, child);
 257         num_children += 1;
 258 }
 259
 260 static void remove_child_pid(pid_t pid)
 261 {
 262         struct child_pid *child;
 263
 264         if (lp_max_smbd_processes() == 0) {
 265                 /* Don't bother with the child list if we don't care anyway */
 266                 return;
 267         }
 268
 269         for (child = children; child != NULL; child = child->next) {
 270                 if (child->pid == pid) {
 271                         struct child_pid *tmp = child;
 272                         DLIST_REMOVE(children, child);
 273                         SAFE_FREE(tmp);
 274                         num_children -= 1;
 275                         return;
 276                 }
 277         }
 278
 279         DEBUG(0, ("Could not find child %d -- ignoring\n", (int)pid));
 280 }
 281
 282 /****************************************************************************
 283  Have we reached the process limit ?
 284 ****************************************************************************/
 285
 286 static BOOL allowable_number_of_smbd_processes(void)
 287 {
 288         int max_processes = lp_max_smbd_processes();
 289
 290         if (!max_processes)
 291                 return True;
 292
 293         return num_children < max_processes;
 294 }
 295
 296 /****************************************************************************
 297  Are we idle enough that we could safely exit?
 298 ****************************************************************************/
 299
 300 static BOOL smbd_is_idle(void)
 301 {
 302         /* Currently we define "idle" as having no client connections. */
 303         return count_all_current_connections() == 0;
 304 }
 305
 306 /****************************************************************************
 307  Open the socket communication.
 308 ****************************************************************************/
 309
 310 static BOOL open_sockets_smbd(enum smb_server_mode server_mode, const char *smb_ports)
 311 {
 312         int num_sockets = 0;
 313         int fd_listenset[FD_SETSIZE];
 314         fd_set listen_set;
 315         int s;
 316         int maxfd = 0;
 317         int i;
 318         struct timeval idle_timeout = timeval_zero();
 319
 320         if (server_mode == SERVER_MODE_INETD) {
 321                 return open_sockets_inetd();
 322         }
 323
 324 #ifdef HAVE_ATEXIT
 325         {
 326                 static int atexit_set;
 327                 if(atexit_set == 0) {
 328                         atexit_set=1;
 329                         atexit(killkids);
 330                 }
 331         }
 332 #endif
 333
 334         /* Stop zombies */
 335         CatchSignal(SIGCLD, sig_cld);
 336
 337         FD_ZERO(&listen_set);
 338
 339         /* At this point, it doesn't matter what daemon mode we are in, we
 340          * need some sockets to listen on.
 341          */
 342         num_sockets = smbd_sockinit(smb_ports, fd_listenset, &idle_timeout);
 343         if (num_sockets == 0) {
 344                 return False;
 345         }
 346
 347         for (i = 0; i < num_sockets; ++i) {
 348                 FD_SET(fd_listenset[i], &listen_set);
 349                 maxfd = MAX(maxfd, fd_listenset[i]);
 350         }
 351
 352
 353         /* Setup the main smbd so that we can get messages. Note that
 354            do this after starting listening. This is needed as when in
 355            clustered mode, ctdb won't allow us to start doing database
 356            operations until it has gone thru a full startup, which
 357            includes checking to see that smbd is listening. */
 358         claim_connection(NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_SMBD);
 359
 360         /* Listen to messages */
 361
 362         messaging_register(smbd_messaging_context(), NULL,
 363                            MSG_SMB_SAM_SYNC, msg_sam_sync);
 364         messaging_register(smbd_messaging_context(), NULL,
 365                            MSG_SHUTDOWN, msg_exit_server);
 366         messaging_register(smbd_messaging_context(), NULL,
 367                            MSG_SMB_FILE_RENAME, msg_file_was_renamed);
 368         messaging_register(smbd_messaging_context(), NULL,
 369                            MSG_SMB_CONF_UPDATED, smb_conf_updated);
 370         messaging_register(smbd_messaging_context(), NULL,
 371                            MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
 372         brl_register_msgs(smbd_messaging_context());
 373
 374 #ifdef DEVELOPER
 375         messaging_register(smbd_messaging_context(), NULL,
 376                            MSG_SMB_INJECT_FAULT, msg_inject_fault);
 377 #endif
 378
 379         /* now accept incoming connections - forking a new process
 380            for each incoming connection */
 381         DEBUG(2,("waiting for a connection\n"));
 382         while (1) {
 383                 struct timeval now;
 384                 fd_set r_fds, w_fds;
 385                 int num;
 386
 387                 /* Free up temporary memory from the main smbd. */
 388                 lp_TALLOC_FREE();
 389
 390                 /* Ensure we respond to PING and DEBUG messages from the main smbd. */
 391                 message_dispatch(smbd_messaging_context());
 392
 393                 if (got_sig_cld) {
 394                         pid_t pid;
 395                         got_sig_cld = False;
 396
 397                         while ((pid = sys_waitpid(-1, NULL, WNOHANG)) > 0) {
 398                                 remove_child_pid(pid);
 399                         }
 400                 }
 401
 402                 memcpy((char *)&r_fds, (char *)&listen_set,
 403                        sizeof(listen_set));
 404                 FD_ZERO(&w_fds);
 405                 GetTimeOfDay(&now);
 406
 407                 event_add_to_select_args(smbd_event_context(), &now,
 408                                          &r_fds, &w_fds, &idle_timeout,
 409                                          &maxfd);
 410
 411                 if (timeval_is_zero(&idle_timeout)) {
 412                         num = sys_select(maxfd + 1, &r_fds, &w_fds,
 413                                         NULL, NULL);
 414                 } else {
 415                         num = sys_select(maxfd + 1, &r_fds, &w_fds,
 416                                         NULL, &idle_timeout);
 417
 418                         /* If the idle timeout fired and we are idle, exit
 419                          * gracefully. We expect to be running under a process
 420                          * controller that will restart us if necessry.
 421                          */
 422                         if (num == 0 && smbd_is_idle()) {
 423                                 exit_server_cleanly("idle timeout");
 424                         }
 425                 }
 426
 427                 if (num == -1 && errno == EINTR) {
 428                         if (got_sig_term) {
 429                                 exit_server_cleanly(NULL);
 430                         }
 431
 432                         /* check for sighup processing */
 433                         if (reload_after_sighup) {
 434                                 change_to_root_user();
 435                                 DEBUG(1,("Reloading services after SIGHUP\n"));
 436                                 reload_services(False);
 437                                 reload_after_sighup = 0;
 438                         }
 439
 440                         continue;
 441                 }
 442
 443                 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
 444                         continue;
 445                 }
 446
 447                 /* check if we need to reload services */
 448                 check_reload(time(NULL));
 449
 450                 /* Find the sockets that are read-ready -
 451                    accept on these. */
 452                 for( ; num > 0; num--) {
 453                         struct sockaddr addr;
 454                         socklen_t in_addrlen = sizeof(addr);
 455                         pid_t child = 0;
 456
 457                         s = -1;
 458                         for(i = 0; i < num_sockets; i++) {
 459                                 if(FD_ISSET(fd_listenset[i],&r_fds)) {
 460                                         s = fd_listenset[i];
 461                                         /* Clear this so we don't look
 462                                            at it again. */
 463                                         FD_CLR(fd_listenset[i],&r_fds);
 464                                         break;
 465                                 }
 466                         }
 467
 468                         smbd_set_server_fd(accept(s,&addr,&in_addrlen));
 469
 470                         if (smbd_server_fd() == -1 && errno == EINTR)
 471                                 continue;
 472
 473                         if (smbd_server_fd() == -1) {
 474                                 DEBUG(0,("open_sockets_smbd: accept: %s\n",
 475                                          strerror(errno)));
 476                                 continue;
 477                         }
 478
 479                         /* Ensure child is set to blocking mode */
 480                         set_blocking(smbd_server_fd(),True);
 481
 482                         /* In interactive mode, return with a connected socket.
 483                          * Foreground and daemon modes should fork worker
 484                          * processes.
 485                          */
 486                         if (server_mode == SERVER_MODE_INTERACTIVE) {
 487                                 return True;
 488                         }
 489
 490                         if (allowable_number_of_smbd_processes() &&
 491                             smbd_server_fd() != -1 &&
 492                             ((child = sys_fork())==0)) {
 493                                 /* Child code ... */
 494
 495                                 /* Stop zombies, the parent explicitly handles
 496                                  * them, counting worker smbds. */
 497                                 CatchChild();
 498
 499                                 /* close the listening socket(s) */
 500                                 for(i = 0; i < num_sockets; i++)
 501                                         close(fd_listenset[i]);
 502
 503                                 /* close our standard file
 504                                    descriptors */
 505                                 close_low_fds(False);
 506                                 am_parent = 0;
 507
 508                                 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 509                                 set_socket_options(smbd_server_fd(),user_socket_options);
 510
 511                                 /* this is needed so that we get decent entries
 512                                    in smbstatus for port 445 connects */
 513                                 set_remote_machine_name(get_peer_addr(smbd_server_fd()),
 514                                                         False);
 515
 516                                 /* Reset the state of the random
 517                                  * number generation system, so
 518                                  * children do not get the same random
 519                                  * numbers as each other */
 520
 521                                 set_need_random_reseed();
 522                                 /* tdb needs special fork handling - remove
 523                                  * CLEAR_IF_FIRST flags */
 524                                 if (tdb_reopen_all(1) == -1) {
 525                                         DEBUG(0,("tdb_reopen_all failed.\n"));
 526                                         smb_panic("tdb_reopen_all failed");
 527                                 }
 528
 529                                 return True;
 530                         }
 531                         /* The parent doesn't need this socket */
 532                         close(smbd_server_fd());
 533
 534                         /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
 535                                 Clear the closed fd info out of server_fd --
 536                                 and more importantly, out of client_fd in
 537                                 util_sock.c, to avoid a possible
 538                                 getpeername failure if we reopen the logs
 539                                 and use %I in the filename.
 540                         */
 541
 542                         smbd_set_server_fd(-1);
 543
 544                         if (child != 0) {
 545                                 add_child_pid(child);
 546                         }
 547
 548                         /* Force parent to check log size after
 549                          * spawning child.  Fix from
 550                          * klausr@ITAP.Physik.Uni-Stuttgart.De.  The
 551                          * parent smbd will log to logserver.smb.  It
 552                          * writes only two messages for each child
 553                          * started/finished. But each child writes,
 554                          * say, 50 messages also in logserver.smb,
 555                          * begining with the debug_count of the
 556                          * parent, before the child opens its own log
 557                          * file logserver.client. In a worst case
 558                          * scenario the size of logserver.smb would be
 559                          * checked after about 50*50=2500 messages
 560                          * (ca. 100kb).
 561                          * */
 562                         force_check_log_size();
 563
 564                 } /* end for num */
 565         } /* end while 1 */
 566
 567 /* NOTREACHED   return True; */
 568 }
 569
 570 /****************************************************************************
 571  Reload printers
 572 **************************************************************************/
 573 void reload_printers(void)
 574 {
 575         int snum;
 576         int n_services = lp_numservices();
 577         int pnum = lp_servicenumber(PRINTERS_NAME);
 578         const char *pname;
 579
 580         pcap_cache_reload();
 581
 582         /* remove stale printers */
 583         for (snum = 0; snum < n_services; snum++) {
 584                 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
 585                 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
 586                                       lp_autoloaded(snum)))
 587                         continue;
 588
 589                 pname = lp_printername(snum);
 590                 if (!pcap_printername_ok(pname)) {
 591                         DEBUG(3, ("removing stale printer %s\n", pname));
 592
 593                         if (is_printer_published(NULL, snum, NULL))
 594                                 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
 595                         del_a_printer(pname);
 596                         lp_killservice(snum);
 597                 }
 598         }
 599
 600         load_printers();
 601 }
 602
 603 /****************************************************************************
 604  Reload the services file.
 605 **************************************************************************/
 606
 607 BOOL reload_services(BOOL test)
 608 {
 609         BOOL ret;
 610
 611         if (lp_loaded()) {
 612                 pstring fname;
 613                 pstrcpy(fname,lp_configfile());
 614                 if (file_exist(fname, NULL) &&
 615                     !strcsequal(fname, dyn_CONFIGFILE)) {
 616                         pstrcpy(dyn_CONFIGFILE, fname);
 617                         test = False;
 618                 }
 619         }
 620
 621         reopen_logs();
 622
 623         if (test && !lp_file_list_changed())
 624                 return(True);
 625
 626         lp_killunused(conn_snum_used);
 627
 628         ret = lp_load(dyn_CONFIGFILE, False, False, True, True);
 629
 630         reload_printers();
 631
 632         /* perhaps the config filename is now set */
 633         if (!test)
 634                 reload_services(True);
 635
 636         reopen_logs();
 637
 638         load_interfaces();
 639
 640         if (smbd_server_fd() != -1) {
 641                 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 642                 set_socket_options(smbd_server_fd(), user_socket_options);
 643         }
 644
 645         mangle_reset_cache();
 646         reset_stat_cache();
 647
 648         /* this forces service parameters to be flushed */
 649         set_current_service(NULL,0,True);
 650
 651         return(ret);
 652 }
 653
 654 /****************************************************************************
 655  Exit the server.
 656 ****************************************************************************/
 657
 658 /* Reasons for shutting down a server process. */
 659 enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
 660
 661 static void exit_server_common(enum server_exit_reason how,
 662         const char *const reason) NORETURN_ATTRIBUTE;
 663
 664 static void exit_server_common(enum server_exit_reason how,
 665         const char *const reason)
 666 {
 667         static int firsttime=1;
 668
 669         if (!firsttime)
 670                 exit(0);
 671         firsttime = 0;
 672
 673         change_to_root_user();
 674
 675         if (negprot_global_auth_context) {
 676                 (negprot_global_auth_context->free)(&negprot_global_auth_context);
 677         }
 678
 679         conn_close_all();
 680
 681         invalidate_all_vuids();
 682
 683         /* 3 second timeout. */
 684         print_notify_send_messages(smbd_messaging_context(), 3);
 685
 686         /* delete our entry in the connections database. */
 687         yield_connection(NULL,"");
 688
 689         respond_to_all_remaining_local_messages();
 690
 691 #ifdef WITH_DFS
 692         if (dcelogin_atmost_once) {
 693                 dfs_unlogin();
 694         }
 695 #endif
 696
 697         locking_end();
 698         printing_end();
 699
 700         server_encryption_shutdown();
 701
 702         if (how != SERVER_EXIT_NORMAL) {
 703                 int oldlevel = DEBUGLEVEL;
 704                 char *last_inbuf = get_InBuffer();
 705
 706                 DEBUGLEVEL = 10;
 707
 708                 DEBUGSEP(0);
 709                 DEBUG(0,("Abnormal server exit: %s\n",
 710                         reason ? reason : "no explanation provided"));
 711                 DEBUGSEP(0);
 712
 713                 log_stack_trace();
 714                 if (last_inbuf) {
 715                         DEBUG(0,("Last message was %s\n", LAST_MESSAGE()));
 716                         show_msg(last_inbuf);
 717                 }
 718
 719                 DEBUGLEVEL = oldlevel;
 720                 dump_core();
 721
 722         } else {
 723                 DEBUG(3,("Server exit (%s)\n",
 724                         (reason ? reason : "normal exit")));
 725         }
 726
 727         exit(0);
 728 }
 729
 730 void exit_server(const char *const explanation)
 731 {
 732         exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
 733 }
 734
 735 void exit_server_cleanly(const char *const explanation)
 736 {
 737         exit_server_common(SERVER_EXIT_NORMAL, explanation);
 738 }
 739
 740 void exit_server_fault(void)
 741 {
 742         exit_server("critical server fault");
 743 }
 744
 745 /****************************************************************************
 746  Initialise connect, service and file structs.
 747 ****************************************************************************/
 748
 749 static BOOL init_structs(void )
 750 {
 751         /*
 752          * Set the machine NETBIOS name if not already
 753          * set from the config file.
 754          */
 755
 756         if (!init_names())
 757                 return False;
 758
 759         conn_init();
 760
 761         file_init();
 762
 763         /* for RPC pipes */
 764         init_rpc_pipe_hnd();
 765
 766         init_dptrs();
 767
 768         secrets_init();
 769
 770         return True;
 771 }
 772
 773 /*
 774  * Send keepalive packets to our client
 775  */
 776 static BOOL keepalive_fn(const struct timeval *now, void *private_data)
 777 {
 778         if (!send_keepalive(smbd_server_fd())) {
 779                 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
 780                 return False;
 781         }
 782         return True;
 783 }
 784
 785 /*
 786  * Do the recurring check if we're idle
 787  */
 788 static BOOL deadtime_fn(const struct timeval *now, void *private_data)
 789 {
 790         if ((conn_num_open() == 0)
 791             || (conn_idle_all(now->tv_sec))) {
 792                 DEBUG( 2, ( "Closing idle connection\n" ) );
 793                 messaging_send(smbd_messaging_context(), procid_self(),
 794                                MSG_SHUTDOWN, &data_blob_null);
 795                 return False;
 796         }
 797
 798         return True;
 799 }
 800
 801
 802 /****************************************************************************
 803  main program.
 804 ****************************************************************************/
 805
 806 /* Declare prototype for build_options() to avoid having to run it through
 807    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
 808    prototype generation system is too complicated. */
 809
 810 extern void build_options(BOOL screen);
 811
 812  int main(int argc,const char *argv[])
 813 {
 814         /* shall I run as a daemon */
 815         BOOL no_process_group = False;
 816         BOOL log_stdout = False;
 817         const char *ports = NULL;
 818         const char *profile_level = NULL;
 819         int opt;
 820         poptContext pc;
 821
 822         enum smb_server_mode server_mode = SERVER_MODE_DAEMON;
 823
 824         struct poptOption long_options[] = {
 825         POPT_AUTOHELP
 826         {"daemon", 'D', POPT_ARG_VAL, &server_mode, SERVER_MODE_DAEMON,
 827                 "Become a daemon (default)" },
 828         {"interactive", 'i', POPT_ARG_VAL, &server_mode, SERVER_MODE_INTERACTIVE,
 829                 "Run interactive (not a daemon)"},
 830         {"foreground", 'F', POPT_ARG_VAL, &server_mode, SERVER_MODE_FOREGROUND,
 831                 "Run daemon in foreground (for daemontools, etc.)" },
 832         {"no-process-group", '\0', POPT_ARG_VAL, &no_process_group, True,
 833                 "Don't create a new process group" },
 834         {"log-stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" },
 835         {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
 836         {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
 837         {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
 838         POPT_COMMON_SAMBA
 839         POPT_COMMON_DYNCONFIG
 840         POPT_TABLEEND
 841         };
 842
 843         load_case_tables();
 844
 845         TimeInit();
 846
 847 #ifdef HAVE_SET_AUTH_PARAMETERS
 848         set_auth_parameters(argc,argv);
 849 #endif
 850
 851         pc = poptGetContext("smbd", argc, argv, long_options, 0);
 852
 853         while((opt = poptGetNextOpt(pc)) != -1) {
 854                 switch (opt)  {
 855                 case 'b':
 856                         build_options(True); /* Display output to screen as well as debug */
 857                         exit(0);
 858                         break;
 859                 }
 860         }
 861
 862         poptFreeContext(pc);
 863
 864 #ifdef HAVE_SETLUID
 865         /* needed for SecureWare on SCO */
 866         setluid(0);
 867 #endif
 868
 869         sec_init();
 870
 871         set_remote_machine_name("smbd", False);
 872
 873         if (server_mode == SERVER_MODE_INTERACTIVE) {
 874                 log_stdout = True;
 875                 if (DEBUGLEVEL >= 9) {
 876                         talloc_enable_leak_report();
 877                 }
 878         }
 879
 880         if (log_stdout && server_mode == SERVER_MODE_DAEMON) {
 881                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 882                 exit(1);
 883         }
 884
 885         setup_logging(argv[0],log_stdout);
 886
 887         /* we want to re-seed early to prevent time delays causing
 888            client problems at a later date. (tridge) */
 889         generate_random_buffer(NULL, 0);
 890
 891         /* make absolutely sure we run as root - to handle cases where people
 892            are crazy enough to have it setuid */
 893
 894         gain_root_privilege();
 895         gain_root_group_privilege();
 896
 897         fault_setup((void (*)(void *))exit_server_fault);
 898         dump_core_setup("smbd");
 899
 900         CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
 901         CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
 902
 903         /* we are never interested in SIGPIPE */
 904         BlockSignals(True,SIGPIPE);
 905
 906 #if defined(SIGFPE)
 907         /* we are never interested in SIGFPE */
 908         BlockSignals(True,SIGFPE);
 909 #endif
 910
 911 #if defined(SIGUSR2)
 912         /* We are no longer interested in USR2 */
 913         BlockSignals(True,SIGUSR2);
 914 #endif
 915
 916         /* POSIX demands that signals are inherited. If the invoking process has
 917          * these signals masked, we will have problems, as we won't recieve them. */
 918         BlockSignals(False, SIGHUP);
 919         BlockSignals(False, SIGUSR1);
 920         BlockSignals(False, SIGTERM);
 921
 922         /* we want total control over the permissions on created files,
 923            so set our umask to 0 */
 924         umask(0);
 925
 926         init_sec_ctx();
 927
 928         reopen_logs();
 929
 930         DEBUG(0,( "smbd version %s started.\n", SAMBA_VERSION_STRING));
 931         DEBUGADD( 0, ( "%s\n", COPYRIGHT_STARTUP_MESSAGE ) );
 932
 933         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
 934                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
 935
 936         /* Output the build options to the debug log */
 937         build_options(False);
 938
 939         if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
 940                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
 941                 exit(1);
 942         }
 943
 944         /*
 945          * Do this before reload_services.
 946          */
 947
 948         if (!reload_services(False))
 949                 return(-1);
 950
 951         init_structs();
 952
 953 #ifdef WITH_PROFILE
 954         if (!profile_setup(smbd_messaging_context(), False)) {
 955                 DEBUG(0,("ERROR: failed to setup profiling\n"));
 956                 return -1;
 957         }
 958         if (profile_level != NULL) {
 959                 int pl = atoi(profile_level);
 960                 struct server_id src;
 961
 962                 DEBUG(1, ("setting profiling level: %s\n",profile_level));
 963                 src.pid = getpid();
 964                 set_profile_level(pl, src);
 965         }
 966 #endif
 967
 968         DEBUG(3,( "loaded services\n"));
 969
 970         if (is_a_socket(0)) {
 971                 if (server_mode == SERVER_MODE_DAEMON) {
 972                         DEBUG(0,("standard input is a socket, "
 973                                     "assuming -F option\n"));
 974                 }
 975                 server_mode = SERVER_MODE_INETD;
 976         }
 977
 978         if (server_mode == SERVER_MODE_DAEMON) {
 979                 DEBUG( 3, ( "Becoming a daemon.\n" ) );
 980                 become_daemon(True, no_process_group);
 981         } else if (server_mode == SERVER_MODE_FOREGROUND) {
 982                 become_daemon(False, no_process_group);
 983         }
 984
 985 #if HAVE_SETPGID
 986         /*
 987          * If we're interactive we want to set our own process group for
 988          * signal management.
 989          */
 990         if (server_mode == SERVER_MODE_INTERACTIVE && !no_process_group) {
 991                 setpgid( (pid_t)0, (pid_t)0);
 992         }
 993 #endif
 994
 995         if (!directory_exist(lp_lockdir(), NULL))
 996                 mkdir(lp_lockdir(), 0755);
 997
 998         if (server_mode != SERVER_MODE_INETD &&
 999             server_mode != SERVER_MODE_INTERACTIVE) {
1000                 pidfile_create("smbd");
1001         }
1002
1003         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1004
1005         if (smbd_messaging_context() == NULL)
1006                 exit(1);
1007
1008         /* Initialise the password backed before the global_sam_sid
1009            to ensure that we fetch from ldap before we make a domain sid up */
1010
1011         if(!initialize_password_db(False, smbd_event_context()))
1012                 exit(1);
1013
1014         if (!secrets_init()) {
1015                 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1016                 exit(1);
1017         }
1018
1019         if(!get_global_sam_sid()) {
1020                 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1021                 exit(1);
1022         }
1023
1024         if (!session_init())
1025                 exit(1);
1026
1027         if (!connections_init(True))
1028                 exit(1);
1029
1030         if (!locking_init(0))
1031                 exit(1);
1032
1033         namecache_enable();
1034
1035         if (!init_registry())
1036                 exit(1);
1037
1038 #if 0
1039         if (!init_svcctl_db())
1040                 exit(1);
1041 #endif
1042
1043         if (!print_backend_init(smbd_messaging_context()))
1044                 exit(1);
1045
1046         if (!init_guest_info()) {
1047                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1048                 return -1;
1049         }
1050
1051         /* only start the background queue daemon if we are
1052            running as a daemon -- bad things will happen if
1053            smbd is launched via inetd and we fork a copy of
1054            ourselves here */
1055         if (server_mode != SERVER_MODE_INETD &&
1056             server_mode != SERVER_MODE_INTERACTIVE) {
1057                 start_background_queue();
1058         }
1059
1060         /* Always attempt to initialize DMAPI. We will only use it later if
1061          * lp_dmapi_support is set on the share, but we need a single global
1062          * session to work with.
1063          */
1064         dmapi_init_session();
1065
1066         if (!open_sockets_smbd(server_mode, ports)) {
1067                 exit(1);
1068         }
1069
1070         /*
1071          * everything after this point is run after the fork()
1072          */
1073
1074         static_init_rpc;
1075
1076         init_modules();
1077
1078         /* Possibly reload the services file. Only worth doing in
1079          * daemon mode. In inetd mode, we know we only just loaded this.
1080          */
1081         if (server_mode != SERVER_MODE_INETD &&
1082             server_mode != SERVER_MODE_INTERACTIVE) {
1083                 reload_services(True);
1084         }
1085
1086         if (!init_account_policy()) {
1087                 DEBUG(0,("Could not open account policy tdb.\n"));
1088                 exit(1);
1089         }
1090
1091         if (*lp_rootdir()) {
1092                 if (sys_chroot(lp_rootdir()) == 0)
1093                         DEBUG(2,("Changed root to %s\n", lp_rootdir()));
1094         }
1095
1096         /* Setup oplocks */
1097         if (!init_oplocks(smbd_messaging_context()))
1098                 exit(1);
1099
1100         /* Setup aio signal handler. */
1101         initialize_async_io_handler();
1102
1103         /*
1104          * For clustering, we need to re-init our ctdbd connection after the
1105          * fork
1106          */
1107         if (!NT_STATUS_IS_OK(messaging_reinit(smbd_messaging_context())))
1108                 exit(1);
1109
1110         /* register our message handlers */
1111         messaging_register(smbd_messaging_context(), NULL,
1112                            MSG_SMB_FORCE_TDIS, msg_force_tdis);
1113
1114         if ((lp_keepalive() != 0)
1115             && !(event_add_idle(smbd_event_context(), NULL,
1116                                 timeval_set(lp_keepalive(), 0),
1117                                 "keepalive", keepalive_fn,
1118                                 NULL))) {
1119                 DEBUG(0, ("Could not add keepalive event\n"));
1120                 exit(1);
1121         }
1122
1123         if (!(event_add_idle(smbd_event_context(), NULL,
1124                              timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1125                              "deadtime", deadtime_fn, NULL))) {
1126                 DEBUG(0, ("Could not add deadtime event\n"));
1127                 exit(1);
1128         }
1129
1130         smbd_process();
1131
1132         namecache_shutdown();
1133
1134         exit_server_cleanly(NULL);
1135         return(0);
1136 }