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