source/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 extern struct auth_context *negprot_global_auth_context;
  31 extern SIG_ATOMIC_T got_sig_term;
  32 extern SIG_ATOMIC_T reload_after_sighup;
  33 static SIG_ATOMIC_T got_sig_cld;
  34
  35 #ifdef WITH_DFS
  36 extern int dcelogin_atmost_once;
  37 #endif /* WITH_DFS */
  38
  39 /* really we should have a top level context structure that has the
  40    client file descriptor as an element. That would require a major rewrite :(
  41
  42    the following 2 functions are an alternative - they make the file
  43    descriptor private to smbd
  44  */
  45 static int server_fd = -1;
  46
  47 int smbd_server_fd(void)
  48 {
  49         return server_fd;
  50 }
  51
  52 static void smbd_set_server_fd(int fd)
  53 {
  54         server_fd = fd;
  55 }
  56
  57 int get_client_fd(void)
  58 {
  59         return server_fd;
  60 }
  61
  62 #ifdef CLUSTER_SUPPORT
  63 static int client_get_tcp_info(struct sockaddr_storage *server,
  64                                struct sockaddr_storage *client)
  65 {
  66         socklen_t length;
  67         if (server_fd == -1) {
  68                 return -1;
  69         }
  70         length = sizeof(*server);
  71         if (getsockname(server_fd, (struct sockaddr *)server, &length) != 0) {
  72                 return -1;
  73         }
  74         length = sizeof(*client);
  75         if (getpeername(server_fd, (struct sockaddr *)client, &length) != 0) {
  76                 return -1;
  77         }
  78         return 0;
  79 }
  80 #endif
  81
  82 struct event_context *smbd_event_context(void)
  83 {
  84         static struct event_context *ctx;
  85
  86         if (!ctx && !(ctx = event_context_init(talloc_autofree_context()))) {
  87                 smb_panic("Could not init smbd event context");
  88         }
  89         return ctx;
  90 }
  91
  92 struct messaging_context *smbd_messaging_context(void)
  93 {
  94         static struct messaging_context *ctx;
  95
  96         if (ctx == NULL) {
  97                 ctx = messaging_init(talloc_autofree_context(), server_id_self(),
  98                                      smbd_event_context());
  99         }
 100         if (ctx == NULL) {
 101                 DEBUG(0, ("Could not init smbd messaging context.\n"));
 102         }
 103         return ctx;
 104 }
 105
 106 struct memcache *smbd_memcache(void)
 107 {
 108         static struct memcache *cache;
 109
 110         if (!cache
 111             && !(cache = memcache_init(talloc_autofree_context(),
 112                                        lp_max_stat_cache_size()*1024))) {
 113
 114                 smb_panic("Could not init smbd memcache");
 115         }
 116         return cache;
 117 }
 118
 119 /*******************************************************************
 120  What to do when smb.conf is updated.
 121  ********************************************************************/
 122
 123 static void smb_conf_updated(struct messaging_context *msg,
 124                              void *private_data,
 125                              uint32_t msg_type,
 126                              struct server_id server_id,
 127                              DATA_BLOB *data)
 128 {
 129         DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
 130                   "updated. Reloading.\n"));
 131         reload_services(False);
 132 }
 133
 134
 135 /*******************************************************************
 136  Delete a statcache entry.
 137  ********************************************************************/
 138
 139 static void smb_stat_cache_delete(struct messaging_context *msg,
 140                                   void *private_data,
 141                                   uint32_t msg_tnype,
 142                                   struct server_id server_id,
 143                                   DATA_BLOB *data)
 144 {
 145         const char *name = (const char *)data->data;
 146         DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
 147         stat_cache_delete(name);
 148 }
 149
 150 /****************************************************************************
 151  Terminate signal.
 152 ****************************************************************************/
 153
 154 static void sig_term(void)
 155 {
 156         got_sig_term = 1;
 157         sys_select_signal(SIGTERM);
 158 }
 159
 160 /****************************************************************************
 161  Catch a sighup.
 162 ****************************************************************************/
 163
 164 static void sig_hup(int sig)
 165 {
 166         reload_after_sighup = 1;
 167         sys_select_signal(SIGHUP);
 168 }
 169
 170 /****************************************************************************
 171  Catch a sigcld
 172 ****************************************************************************/
 173 static void sig_cld(int sig)
 174 {
 175         got_sig_cld = 1;
 176         sys_select_signal(SIGCLD);
 177 }
 178
 179 /****************************************************************************
 180   Send a SIGTERM to our process group.
 181 *****************************************************************************/
 182
 183 static void  killkids(void)
 184 {
 185         if(am_parent) kill(0,SIGTERM);
 186 }
 187
 188 /****************************************************************************
 189  Process a sam sync message - not sure whether to do this here or
 190  somewhere else.
 191 ****************************************************************************/
 192
 193 static void msg_sam_sync(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(10, ("** sam sync message received, ignoring\n"));
 200 }
 201
 202
 203 /****************************************************************************
 204  Open the socket communication - inetd.
 205 ****************************************************************************/
 206
 207 static bool open_sockets_inetd(void)
 208 {
 209         /* Started from inetd. fd 0 is the socket. */
 210         /* We will abort gracefully when the client or remote system
 211            goes away */
 212         smbd_set_server_fd(dup(0));
 213
 214         /* close our standard file descriptors */
 215         close_low_fds(False); /* Don't close stderr */
 216
 217         set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 218         set_socket_options(smbd_server_fd(), lp_socket_options());
 219
 220         return True;
 221 }
 222
 223 static void msg_exit_server(struct messaging_context *msg,
 224                             void *private_data,
 225                             uint32_t msg_type,
 226                             struct server_id server_id,
 227                             DATA_BLOB *data)
 228 {
 229         DEBUG(3, ("got a SHUTDOWN message\n"));
 230         exit_server_cleanly(NULL);
 231 }
 232
 233 #ifdef DEVELOPER
 234 static void msg_inject_fault(struct messaging_context *msg,
 235                              void *private_data,
 236                              uint32_t msg_type,
 237                              struct server_id src,
 238                              DATA_BLOB *data)
 239 {
 240         int sig;
 241
 242         if (data->length != sizeof(sig)) {
 243
 244                 DEBUG(0, ("Process %s sent bogus signal injection request\n",
 245                           procid_str_static(&src)));
 246                 return;
 247         }
 248
 249         sig = *(int *)data->data;
 250         if (sig == -1) {
 251                 exit_server("internal error injected");
 252                 return;
 253         }
 254
 255 #if HAVE_STRSIGNAL
 256         DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
 257                   procid_str_static(&src), sig, strsignal(sig)));
 258 #else
 259         DEBUG(0, ("Process %s requested injection of signal %d\n",
 260                   procid_str_static(&src), sig));
 261 #endif
 262
 263         kill(sys_getpid(), sig);
 264 }
 265 #endif /* DEVELOPER */
 266
 267 struct child_pid {
 268         struct child_pid *prev, *next;
 269         pid_t pid;
 270 };
 271
 272 static struct child_pid *children;
 273 static int num_children;
 274
 275 static void add_child_pid(pid_t pid)
 276 {
 277         struct child_pid *child;
 278
 279         if (lp_max_smbd_processes() == 0) {
 280                 /* Don't bother with the child list if we don't care anyway */
 281                 return;
 282         }
 283
 284         child = SMB_MALLOC_P(struct child_pid);
 285         if (child == NULL) {
 286                 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
 287                 return;
 288         }
 289         child->pid = pid;
 290         DLIST_ADD(children, child);
 291         num_children += 1;
 292 }
 293
 294 static void remove_child_pid(pid_t pid, bool unclean_shutdown)
 295 {
 296         struct child_pid *child;
 297
 298         if (unclean_shutdown) {
 299                 /* a child terminated uncleanly so tickle all processes to see
 300                    if they can grab any of the pending locks
 301                 */
 302                 DEBUG(3,(__location__ " Unclean shutdown of pid %u\n", (unsigned int)pid));
 303                 messaging_send_buf(smbd_messaging_context(), procid_self(),
 304                                    MSG_SMB_BRL_VALIDATE, NULL, 0);
 305                 message_send_all(smbd_messaging_context(),
 306                                  MSG_SMB_UNLOCK, NULL, 0, NULL);
 307         }
 308
 309         if (lp_max_smbd_processes() == 0) {
 310                 /* Don't bother with the child list if we don't care anyway */
 311                 return;
 312         }
 313
 314         for (child = children; child != NULL; child = child->next) {
 315                 if (child->pid == pid) {
 316                         struct child_pid *tmp = child;
 317                         DLIST_REMOVE(children, child);
 318                         SAFE_FREE(tmp);
 319                         num_children -= 1;
 320                         return;
 321                 }
 322         }
 323
 324         DEBUG(0, ("Could not find child %d -- ignoring\n", (int)pid));
 325 }
 326
 327 /****************************************************************************
 328  Have we reached the process limit ?
 329 ****************************************************************************/
 330
 331 static bool allowable_number_of_smbd_processes(void)
 332 {
 333         int max_processes = lp_max_smbd_processes();
 334
 335         if (!max_processes)
 336                 return True;
 337
 338         return num_children < max_processes;
 339 }
 340
 341 /****************************************************************************
 342  Open the socket communication.
 343 ****************************************************************************/
 344
 345 static bool open_sockets_smbd(bool is_daemon, bool interactive, const char *smb_ports)
 346 {
 347         int num_interfaces = iface_count();
 348         int num_sockets = 0;
 349         int fd_listenset[FD_SETSIZE];
 350         fd_set listen_set;
 351         int s;
 352         int maxfd = 0;
 353         int i;
 354         char *ports;
 355         struct dns_reg_state * dns_reg = NULL;
 356         unsigned dns_port = 0;
 357
 358 #ifdef HAVE_ATEXIT
 359         {
 360                 static int atexit_set;
 361                 if(atexit_set == 0) {
 362                         atexit_set=1;
 363                         atexit(killkids);
 364                 }
 365         }
 366 #endif
 367
 368         if (!is_daemon) {
 369                 /*
 370                  * Stop zombies the old way.
 371                  * We aren't forking any new
 372                  * 'normal' connections when
 373                  * run from [x]inetd.
 374                  */
 375                 CatchChild();
 376                 return open_sockets_inetd();
 377         }
 378
 379         /* Stop zombies */
 380         CatchSignal(SIGCLD, sig_cld);
 381
 382         FD_ZERO(&listen_set);
 383
 384         /* use a reasonable default set of ports - listing on 445 and 139 */
 385         if (!smb_ports) {
 386                 ports = lp_smb_ports();
 387                 if (!ports || !*ports) {
 388                         ports = smb_xstrdup(SMB_PORTS);
 389                 } else {
 390                         ports = smb_xstrdup(ports);
 391                 }
 392         } else {
 393                 ports = smb_xstrdup(smb_ports);
 394         }
 395
 396         if (lp_interfaces() && lp_bind_interfaces_only()) {
 397                 /* We have been given an interfaces line, and been
 398                    told to only bind to those interfaces. Create a
 399                    socket per interface and bind to only these.
 400                 */
 401
 402                 /* Now open a listen socket for each of the
 403                    interfaces. */
 404                 for(i = 0; i < num_interfaces; i++) {
 405                         TALLOC_CTX *frame = NULL;
 406                         const struct sockaddr_storage *ifss =
 407                                         iface_n_sockaddr_storage(i);
 408                         char *tok;
 409                         const char *ptr;
 410
 411                         if (ifss == NULL) {
 412                                 DEBUG(0,("open_sockets_smbd: "
 413                                         "interface %d has NULL IP address !\n",
 414                                         i));
 415                                 continue;
 416                         }
 417
 418                         frame = talloc_stackframe();
 419                         for (ptr=ports;
 420                                         next_token_talloc(frame,&ptr, &tok, " \t,");) {
 421                                 unsigned port = atoi(tok);
 422                                 if (port == 0 || port > 0xffff) {
 423                                         continue;
 424                                 }
 425
 426                                 /* Keep the first port for mDNS service
 427                                  * registration.
 428                                  */
 429                                 if (dns_port == 0) {
 430                                         dns_port = port;
 431                                 }
 432
 433                                 s = fd_listenset[num_sockets] =
 434                                         open_socket_in(SOCK_STREAM,
 435                                                         port,
 436                                                         num_sockets == 0 ? 0 : 2,
 437                                                         ifss,
 438                                                         true);
 439                                 if(s == -1) {
 440                                         continue;
 441                                 }
 442
 443                                 /* ready to listen */
 444                                 set_socket_options(s,"SO_KEEPALIVE");
 445                                 set_socket_options(s,lp_socket_options());
 446
 447                                 /* Set server socket to
 448                                  * non-blocking for the accept. */
 449                                 set_blocking(s,False);
 450
 451                                 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
 452                                         DEBUG(0,("open_sockets_smbd: listen: "
 453                                                 "%s\n", strerror(errno)));
 454                                         close(s);
 455                                         TALLOC_FREE(frame);
 456                                         return False;
 457                                 }
 458                                 FD_SET(s,&listen_set);
 459                                 maxfd = MAX( maxfd, s);
 460
 461                                 num_sockets++;
 462                                 if (num_sockets >= FD_SETSIZE) {
 463                                         DEBUG(0,("open_sockets_smbd: Too "
 464                                                 "many sockets to bind to\n"));
 465                                         TALLOC_FREE(frame);
 466                                         return False;
 467                                 }
 468                         }
 469                         TALLOC_FREE(frame);
 470                 }
 471         } else {
 472                 /* Just bind to 0.0.0.0 - accept connections
 473                    from anywhere. */
 474
 475                 TALLOC_CTX *frame = talloc_stackframe();
 476                 char *tok;
 477                 const char *ptr;
 478                 const char *sock_addr = lp_socket_address();
 479                 char *sock_tok;
 480                 const char *sock_ptr;
 481
 482                 if (strequal(sock_addr, "0.0.0.0") ||
 483                     strequal(sock_addr, "::")) {
 484 #if HAVE_IPV6
 485                         sock_addr = "::,0.0.0.0";
 486 #else
 487                         sock_addr = "0.0.0.0";
 488 #endif
 489                 }
 490
 491                 for (sock_ptr=sock_addr;
 492                                 next_token_talloc(frame, &sock_ptr, &sock_tok, " \t,"); ) {
 493                         for (ptr=ports; next_token_talloc(frame, &ptr, &tok, " \t,"); ) {
 494                                 struct sockaddr_storage ss;
 495
 496                                 unsigned port = atoi(tok);
 497                                 if (port == 0 || port > 0xffff) {
 498                                         continue;
 499                                 }
 500
 501                                 /* Keep the first port for mDNS service
 502                                  * registration.
 503                                  */
 504                                 if (dns_port == 0) {
 505                                         dns_port = port;
 506                                 }
 507
 508                                 /* open an incoming socket */
 509                                 if (!interpret_string_addr(&ss, sock_tok,
 510                                                 AI_NUMERICHOST|AI_PASSIVE)) {
 511                                         continue;
 512                                 }
 513
 514                                 s = open_socket_in(SOCK_STREAM,
 515                                                 port,
 516                                                 num_sockets == 0 ? 0 : 2,
 517                                                 &ss,
 518                                                 true);
 519                                 if (s == -1) {
 520                                         continue;
 521                                 }
 522
 523                                 /* ready to listen */
 524                                 set_socket_options(s,"SO_KEEPALIVE");
 525                                 set_socket_options(s,lp_socket_options());
 526
 527                                 /* Set server socket to non-blocking
 528                                  * for the accept. */
 529                                 set_blocking(s,False);
 530
 531                                 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
 532                                         DEBUG(0,("open_sockets_smbd: "
 533                                                 "listen: %s\n",
 534                                                  strerror(errno)));
 535                                         close(s);
 536                                         TALLOC_FREE(frame);
 537                                         return False;
 538                                 }
 539
 540                                 fd_listenset[num_sockets] = s;
 541                                 FD_SET(s,&listen_set);
 542                                 maxfd = MAX( maxfd, s);
 543
 544                                 num_sockets++;
 545
 546                                 if (num_sockets >= FD_SETSIZE) {
 547                                         DEBUG(0,("open_sockets_smbd: Too "
 548                                                 "many sockets to bind to\n"));
 549                                         TALLOC_FREE(frame);
 550                                         return False;
 551                                 }
 552                         }
 553                 }
 554                 TALLOC_FREE(frame);
 555         }
 556
 557         SAFE_FREE(ports);
 558
 559         if (num_sockets == 0) {
 560                 DEBUG(0,("open_sockets_smbd: No "
 561                         "sockets available to bind to.\n"));
 562                 return false;
 563         }
 564
 565         /* Setup the main smbd so that we can get messages. Note that
 566            do this after starting listening. This is needed as when in
 567            clustered mode, ctdb won't allow us to start doing database
 568            operations until it has gone thru a full startup, which
 569            includes checking to see that smbd is listening. */
 570         claim_connection(NULL,"",
 571                          FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_DBWRAP);
 572
 573         /* Listen to messages */
 574
 575         messaging_register(smbd_messaging_context(), NULL,
 576                            MSG_SMB_SAM_SYNC, msg_sam_sync);
 577         messaging_register(smbd_messaging_context(), NULL,
 578                            MSG_SHUTDOWN, msg_exit_server);
 579         messaging_register(smbd_messaging_context(), NULL,
 580                            MSG_SMB_FILE_RENAME, msg_file_was_renamed);
 581         messaging_register(smbd_messaging_context(), NULL,
 582                            MSG_SMB_CONF_UPDATED, smb_conf_updated);
 583         messaging_register(smbd_messaging_context(), NULL,
 584                            MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
 585         brl_register_msgs(smbd_messaging_context());
 586
 587 #ifdef CLUSTER_SUPPORT
 588         if (lp_clustering()) {
 589                 ctdbd_register_reconfigure(messaging_ctdbd_connection());
 590         }
 591 #endif
 592
 593 #ifdef DEVELOPER
 594         messaging_register(smbd_messaging_context(), NULL,
 595                            MSG_SMB_INJECT_FAULT, msg_inject_fault);
 596 #endif
 597
 598         /* Kick off our mDNS registration. */
 599         if (dns_port != 0) {
 600 #ifdef WITH_AVAHI_SUPPORT
 601                 void *avahi_conn;
 602                 avahi_conn = avahi_start_register(
 603                         smbd_event_context(), smbd_event_context(),
 604                         dns_port);
 605                 if (avahi_conn == NULL) {
 606                         DEBUG(10, ("avahi_start_register failed\n"));
 607                 }
 608 #endif
 609         }
 610
 611         /* now accept incoming connections - forking a new process
 612            for each incoming connection */
 613         DEBUG(2,("waiting for a connection\n"));
 614         while (1) {
 615                 struct timeval now, idle_timeout;
 616                 fd_set r_fds, w_fds;
 617                 int num;
 618
 619                 /* Ensure we respond to PING and DEBUG messages from the main smbd. */
 620                 message_dispatch(smbd_messaging_context());
 621
 622                 if (got_sig_cld) {
 623                         pid_t pid;
 624                         int status;
 625
 626                         got_sig_cld = False;
 627
 628                         while ((pid = sys_waitpid(-1, &status, WNOHANG)) > 0) {
 629                                 bool unclean_shutdown = False;
 630
 631                                 /* If the child terminated normally, assume
 632                                    it was an unclean shutdown unless the
 633                                    status is 0
 634                                 */
 635                                 if (WIFEXITED(status)) {
 636                                         unclean_shutdown = WEXITSTATUS(status);
 637                                 }
 638                                 /* If the child terminated due to a signal
 639                                    we always assume it was unclean.
 640                                 */
 641                                 if (WIFSIGNALED(status)) {
 642                                         unclean_shutdown = True;
 643                                 }
 644                                 remove_child_pid(pid, unclean_shutdown);
 645                         }
 646                 }
 647
 648                 idle_timeout = timeval_zero();
 649
 650                 memcpy((char *)&r_fds, (char *)&listen_set,
 651                        sizeof(listen_set));
 652                 FD_ZERO(&w_fds);
 653                 GetTimeOfDay(&now);
 654
 655                 /* Kick off our mDNS registration. */
 656                 if (dns_port != 0) {
 657                         dns_register_smbd(&dns_reg, dns_port, &maxfd,
 658                                         &r_fds, &idle_timeout);
 659                 }
 660
 661                 event_add_to_select_args(smbd_event_context(), &now,
 662                                          &r_fds, &w_fds, &idle_timeout,
 663                                          &maxfd);
 664
 665                 num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
 666                                  timeval_is_zero(&idle_timeout) ?
 667                                  NULL : &idle_timeout);
 668
 669                 if (num == -1 && errno == EINTR) {
 670                         if (got_sig_term) {
 671                                 exit_server_cleanly(NULL);
 672                         }
 673
 674                         /* check for sighup processing */
 675                         if (reload_after_sighup) {
 676                                 change_to_root_user();
 677                                 DEBUG(1,("Reloading services after SIGHUP\n"));
 678                                 reload_services(False);
 679                                 reload_after_sighup = 0;
 680                         }
 681
 682                         continue;
 683                 }
 684
 685
 686                 /* If the idle timeout fired and we don't have any connected
 687                  * users, exit gracefully. We should be running under a process
 688                  * controller that will restart us if necessry.
 689                  */
 690                 if (num == 0 && count_all_current_connections() == 0) {
 691                         exit_server_cleanly("idle timeout");
 692                 }
 693
 694                 /* process pending nDNS responses */
 695                 if (dns_register_smbd_reply(dns_reg, &r_fds, &idle_timeout)) {
 696                         --num;
 697                 }
 698
 699                 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
 700                         continue;
 701                 }
 702
 703                 /* check if we need to reload services */
 704                 check_reload(time(NULL));
 705
 706                 /* Find the sockets that are read-ready -
 707                    accept on these. */
 708                 for( ; num > 0; num--) {
 709                         struct sockaddr addr;
 710                         socklen_t in_addrlen = sizeof(addr);
 711                         pid_t child = 0;
 712
 713                         s = -1;
 714                         for(i = 0; i < num_sockets; i++) {
 715                                 if(FD_ISSET(fd_listenset[i],&r_fds)) {
 716                                         s = fd_listenset[i];
 717                                         /* Clear this so we don't look
 718                                            at it again. */
 719                                         FD_CLR(fd_listenset[i],&r_fds);
 720                                         break;
 721                                 }
 722                         }
 723
 724                         smbd_set_server_fd(accept(s,&addr,&in_addrlen));
 725
 726                         if (smbd_server_fd() == -1 && errno == EINTR)
 727                                 continue;
 728
 729                         if (smbd_server_fd() == -1) {
 730                                 DEBUG(2,("open_sockets_smbd: accept: %s\n",
 731                                          strerror(errno)));
 732                                 continue;
 733                         }
 734
 735                         /* Ensure child is set to blocking mode */
 736                         set_blocking(smbd_server_fd(),True);
 737
 738                         if (smbd_server_fd() != -1 && interactive)
 739                                 return True;
 740
 741                         if (allowable_number_of_smbd_processes() &&
 742                             smbd_server_fd() != -1 &&
 743                             ((child = sys_fork())==0)) {
 744                                 char remaddr[INET6_ADDRSTRLEN];
 745
 746                                 /* Child code ... */
 747
 748                                 /* Stop zombies, the parent explicitly handles
 749                                  * them, counting worker smbds. */
 750                                 CatchChild();
 751
 752                                 /* close the listening socket(s) */
 753                                 for(i = 0; i < num_sockets; i++)
 754                                         close(fd_listenset[i]);
 755
 756                                 /* close our mDNS daemon handle */
 757                                 dns_register_close(&dns_reg);
 758
 759                                 /* close our standard file
 760                                    descriptors */
 761                                 close_low_fds(False);
 762                                 am_parent = 0;
 763
 764                                 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 765                                 set_socket_options(smbd_server_fd(),
 766                                                    lp_socket_options());
 767
 768                                 /* this is needed so that we get decent entries
 769                                    in smbstatus for port 445 connects */
 770                                 set_remote_machine_name(get_peer_addr(smbd_server_fd(),
 771                                                                 remaddr,
 772                                                                 sizeof(remaddr)),
 773                                                                 false);
 774
 775                                 if (!reinit_after_fork(
 776                                             smbd_messaging_context(),
 777                                             smbd_event_context(),
 778                                             true)) {
 779                                         DEBUG(0,("reinit_after_fork() failed\n"));
 780                                         smb_panic("reinit_after_fork() failed");
 781                                 }
 782
 783                                 return True;
 784                         }
 785                         /* The parent doesn't need this socket */
 786                         close(smbd_server_fd());
 787
 788                         /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
 789                                 Clear the closed fd info out of server_fd --
 790                                 and more importantly, out of client_fd in
 791                                 util_sock.c, to avoid a possible
 792                                 getpeername failure if we reopen the logs
 793                                 and use %I in the filename.
 794                         */
 795
 796                         smbd_set_server_fd(-1);
 797
 798                         if (child != 0) {
 799                                 add_child_pid(child);
 800                         }
 801
 802                         /* Force parent to check log size after
 803                          * spawning child.  Fix from
 804                          * klausr@ITAP.Physik.Uni-Stuttgart.De.  The
 805                          * parent smbd will log to logserver.smb.  It
 806                          * writes only two messages for each child
 807                          * started/finished. But each child writes,
 808                          * say, 50 messages also in logserver.smb,
 809                          * begining with the debug_count of the
 810                          * parent, before the child opens its own log
 811                          * file logserver.client. In a worst case
 812                          * scenario the size of logserver.smb would be
 813                          * checked after about 50*50=2500 messages
 814                          * (ca. 100kb).
 815                          * */
 816                         force_check_log_size();
 817
 818                 } /* end for num */
 819         } /* end while 1 */
 820
 821 /* NOTREACHED   return True; */
 822 }
 823
 824 /****************************************************************************
 825  Reload printers
 826 **************************************************************************/
 827 void reload_printers(void)
 828 {
 829         int snum;
 830         int n_services = lp_numservices();
 831         int pnum = lp_servicenumber(PRINTERS_NAME);
 832         const char *pname;
 833
 834         pcap_cache_reload();
 835
 836         /* remove stale printers */
 837         for (snum = 0; snum < n_services; snum++) {
 838                 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
 839                 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
 840                                       lp_autoloaded(snum)))
 841                         continue;
 842
 843                 pname = lp_printername(snum);
 844                 if (!pcap_printername_ok(pname)) {
 845                         DEBUG(3, ("removing stale printer %s\n", pname));
 846
 847                         if (is_printer_published(NULL, snum, NULL))
 848                                 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
 849                         del_a_printer(pname);
 850                         lp_killservice(snum);
 851                 }
 852         }
 853
 854         load_printers();
 855 }
 856
 857 /****************************************************************************
 858  Reload the services file.
 859 **************************************************************************/
 860
 861 bool reload_services(bool test)
 862 {
 863         bool ret;
 864
 865         if (lp_loaded()) {
 866                 char *fname = lp_configfile();
 867                 if (file_exist(fname, NULL) &&
 868                     !strcsequal(fname, get_dyn_CONFIGFILE())) {
 869                         set_dyn_CONFIGFILE(fname);
 870                         test = False;
 871                 }
 872         }
 873
 874         reopen_logs();
 875
 876         if (test && !lp_file_list_changed())
 877                 return(True);
 878
 879         lp_killunused(conn_snum_used);
 880
 881         ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
 882
 883         reload_printers();
 884
 885         /* perhaps the config filename is now set */
 886         if (!test)
 887                 reload_services(True);
 888
 889         reopen_logs();
 890
 891         load_interfaces();
 892
 893         if (smbd_server_fd() != -1) {
 894                 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 895                 set_socket_options(smbd_server_fd(), lp_socket_options());
 896         }
 897
 898         mangle_reset_cache();
 899         reset_stat_cache();
 900
 901         /* this forces service parameters to be flushed */
 902         set_current_service(NULL,0,True);
 903
 904         return(ret);
 905 }
 906
 907 /****************************************************************************
 908  Exit the server.
 909 ****************************************************************************/
 910
 911 /* Reasons for shutting down a server process. */
 912 enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
 913
 914 static void exit_server_common(enum server_exit_reason how,
 915         const char *const reason) NORETURN_ATTRIBUTE;
 916
 917 static void exit_server_common(enum server_exit_reason how,
 918         const char *const reason)
 919 {
 920         static int firsttime=1;
 921         bool had_open_conn;
 922
 923         if (!firsttime)
 924                 exit(0);
 925         firsttime = 0;
 926
 927         change_to_root_user();
 928
 929         if (negprot_global_auth_context) {
 930                 (negprot_global_auth_context->free)(&negprot_global_auth_context);
 931         }
 932
 933         had_open_conn = conn_close_all();
 934
 935         invalidate_all_vuids();
 936
 937         /* 3 second timeout. */
 938         print_notify_send_messages(smbd_messaging_context(), 3);
 939
 940         /* delete our entry in the connections database. */
 941         yield_connection(NULL,"");
 942
 943         respond_to_all_remaining_local_messages();
 944
 945 #ifdef WITH_DFS
 946         if (dcelogin_atmost_once) {
 947                 dfs_unlogin();
 948         }
 949 #endif
 950
 951 #ifdef USE_DMAPI
 952         /* Destroy Samba DMAPI session only if we are master smbd process */
 953         if (am_parent) {
 954                 if (!dmapi_destroy_session()) {
 955                         DEBUG(0,("Unable to close Samba DMAPI session\n"));
 956                 }
 957         }
 958 #endif
 959
 960         locking_end();
 961         printing_end();
 962
 963         if (how != SERVER_EXIT_NORMAL) {
 964                 int oldlevel = DEBUGLEVEL;
 965
 966                 DEBUGLEVEL = 10;
 967
 968                 DEBUGSEP(0);
 969                 DEBUG(0,("Abnormal server exit: %s\n",
 970                         reason ? reason : "no explanation provided"));
 971                 DEBUGSEP(0);
 972
 973                 log_stack_trace();
 974
 975                 DEBUGLEVEL = oldlevel;
 976                 dump_core();
 977
 978         } else {
 979                 DEBUG(3,("Server exit (%s)\n",
 980                         (reason ? reason : "normal exit")));
 981         }
 982
 983         /* if we had any open SMB connections when we exited then we
 984            need to tell the parent smbd so that it can trigger a retry
 985            of any locks we may have been holding or open files we were
 986            blocking */
 987         if (had_open_conn) {
 988                 exit(1);
 989         } else {
 990                 exit(0);
 991         }
 992 }
 993
 994 void exit_server(const char *const explanation)
 995 {
 996         exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
 997 }
 998
 999 void exit_server_cleanly(const char *const explanation)
1000 {
1001         exit_server_common(SERVER_EXIT_NORMAL, explanation);
1002 }
1003
1004 void exit_server_fault(void)
1005 {
1006         exit_server("critical server fault");
1007 }
1008
1009
1010 /****************************************************************************
1011 received when we should release a specific IP
1012 ****************************************************************************/
1013 static void release_ip(const char *ip, void *priv)
1014 {
1015         char addr[INET6_ADDRSTRLEN];
1016
1017         if (strcmp(client_socket_addr(get_client_fd(),addr,sizeof(addr)), ip) == 0) {
1018                 /* we can't afford to do a clean exit - that involves
1019                    database writes, which would potentially mean we
1020                    are still running after the failover has finished -
1021                    we have to get rid of this process ID straight
1022                    away */
1023                 DEBUG(0,("Got release IP message for our IP %s - exiting immediately\n",
1024                         ip));
1025                 /* note we must exit with non-zero status so the unclean handler gets
1026                    called in the parent, so that the brl database is tickled */
1027                 _exit(1);
1028         }
1029 }
1030
1031 static void msg_release_ip(struct messaging_context *msg_ctx, void *private_data,
1032                            uint32_t msg_type, struct server_id server_id, DATA_BLOB *data)
1033 {
1034         release_ip((char *)data->data, NULL);
1035 }
1036
1037 /****************************************************************************
1038  Initialise connect, service and file structs.
1039 ****************************************************************************/
1040
1041 static bool init_structs(void )
1042 {
1043         /*
1044          * Set the machine NETBIOS name if not already
1045          * set from the config file.
1046          */
1047
1048         if (!init_names())
1049                 return False;
1050
1051         conn_init();
1052
1053         file_init();
1054
1055         /* for RPC pipes */
1056         init_rpc_pipe_hnd();
1057
1058         init_dptrs();
1059
1060         if (!secrets_init())
1061                 return False;
1062
1063         return True;
1064 }
1065
1066 /*
1067  * Send keepalive packets to our client
1068  */
1069 static bool keepalive_fn(const struct timeval *now, void *private_data)
1070 {
1071         if (!send_keepalive(smbd_server_fd())) {
1072                 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
1073                 return False;
1074         }
1075         return True;
1076 }
1077
1078 /*
1079  * Do the recurring check if we're idle
1080  */
1081 static bool deadtime_fn(const struct timeval *now, void *private_data)
1082 {
1083         if ((conn_num_open() == 0)
1084             || (conn_idle_all(now->tv_sec))) {
1085                 DEBUG( 2, ( "Closing idle connection\n" ) );
1086                 messaging_send(smbd_messaging_context(), procid_self(),
1087                                MSG_SHUTDOWN, &data_blob_null);
1088                 return False;
1089         }
1090
1091         return True;
1092 }
1093
1094 /*
1095  * Do the recurring log file and smb.conf reload checks.
1096  */
1097
1098 static bool housekeeping_fn(const struct timeval *now, void *private_data)
1099 {
1100         change_to_root_user();
1101
1102         /* update printer queue caches if necessary */
1103         update_monitored_printq_cache();
1104
1105         /* check if we need to reload services */
1106         check_reload(time(NULL));
1107
1108         /* Change machine password if neccessary. */
1109         attempt_machine_password_change();
1110
1111         /*
1112          * Force a log file check.
1113          */
1114         force_check_log_size();
1115         check_log_size();
1116         return true;
1117 }
1118
1119 /****************************************************************************
1120  main program.
1121 ****************************************************************************/
1122
1123 /* Declare prototype for build_options() to avoid having to run it through
1124    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
1125    prototype generation system is too complicated. */
1126
1127 extern void build_options(bool screen);
1128
1129  int main(int argc,const char *argv[])
1130 {
1131         /* shall I run as a daemon */
1132         static bool is_daemon = False;
1133         static bool interactive = False;
1134         static bool Fork = True;
1135         static bool no_process_group = False;
1136         static bool log_stdout = False;
1137         static char *ports = NULL;
1138         static char *profile_level = NULL;
1139         int opt;
1140         poptContext pc;
1141         bool print_build_options = False;
1142         enum {
1143                 OPT_DAEMON = 1000,
1144                 OPT_INTERACTIVE,
1145                 OPT_FORK,
1146                 OPT_NO_PROCESS_GROUP,
1147                 OPT_LOG_STDOUT
1148         };
1149         struct poptOption long_options[] = {
1150         POPT_AUTOHELP
1151         {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
1152         {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
1153         {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
1154         {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
1155         {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
1156         {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
1157         {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
1158         {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
1159         POPT_COMMON_SAMBA
1160         POPT_COMMON_DYNCONFIG
1161         POPT_TABLEEND
1162         };
1163         TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
1164
1165         TimeInit();
1166
1167 #ifdef HAVE_SET_AUTH_PARAMETERS
1168         set_auth_parameters(argc,argv);
1169 #endif
1170
1171         pc = poptGetContext("smbd", argc, argv, long_options, 0);
1172         while((opt = poptGetNextOpt(pc)) != -1) {
1173                 switch (opt)  {
1174                 case OPT_DAEMON:
1175                         is_daemon = true;
1176                         break;
1177                 case OPT_INTERACTIVE:
1178                         interactive = true;
1179                         break;
1180                 case OPT_FORK:
1181                         Fork = false;
1182                         break;
1183                 case OPT_NO_PROCESS_GROUP:
1184                         no_process_group = true;
1185                         break;
1186                 case OPT_LOG_STDOUT:
1187                         log_stdout = true;
1188                         break;
1189                 case 'b':
1190                         print_build_options = True;
1191                         break;
1192                 default:
1193                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1194                                   poptBadOption(pc, 0), poptStrerror(opt));
1195                         poptPrintUsage(pc, stderr, 0);
1196                         exit(1);
1197                 }
1198         }
1199         poptFreeContext(pc);
1200
1201         if (interactive) {
1202                 Fork = False;
1203                 log_stdout = True;
1204         }
1205
1206         setup_logging(argv[0],log_stdout);
1207
1208         if (print_build_options) {
1209                 build_options(True); /* Display output to screen as well as debug */
1210                 exit(0);
1211         }
1212
1213         load_case_tables();
1214
1215 #ifdef HAVE_SETLUID
1216         /* needed for SecureWare on SCO */
1217         setluid(0);
1218 #endif
1219
1220         sec_init();
1221
1222         set_remote_machine_name("smbd", False);
1223
1224         if (interactive && (DEBUGLEVEL >= 9)) {
1225                 talloc_enable_leak_report();
1226         }
1227
1228         if (log_stdout && Fork) {
1229                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1230                 exit(1);
1231         }
1232
1233         /* we want to re-seed early to prevent time delays causing
1234            client problems at a later date. (tridge) */
1235         generate_random_buffer(NULL, 0);
1236
1237         /* make absolutely sure we run as root - to handle cases where people
1238            are crazy enough to have it setuid */
1239
1240         gain_root_privilege();
1241         gain_root_group_privilege();
1242
1243         fault_setup((void (*)(void *))exit_server_fault);
1244         dump_core_setup("smbd");
1245
1246         CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
1247         CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
1248
1249         /* we are never interested in SIGPIPE */
1250         BlockSignals(True,SIGPIPE);
1251
1252 #if defined(SIGFPE)
1253         /* we are never interested in SIGFPE */
1254         BlockSignals(True,SIGFPE);
1255 #endif
1256
1257 #if defined(SIGUSR2)
1258         /* We are no longer interested in USR2 */
1259         BlockSignals(True,SIGUSR2);
1260 #endif
1261
1262         /* POSIX demands that signals are inherited. If the invoking process has
1263          * these signals masked, we will have problems, as we won't recieve them. */
1264         BlockSignals(False, SIGHUP);
1265         BlockSignals(False, SIGUSR1);
1266         BlockSignals(False, SIGTERM);
1267
1268         /* Ensure we leave no zombies until we
1269          * correctly set up child handling below. */
1270         CatchChild();
1271
1272         /* we want total control over the permissions on created files,
1273            so set our umask to 0 */
1274         umask(0);
1275
1276         init_sec_ctx();
1277
1278         reopen_logs();
1279
1280         DEBUG(0,("smbd version %s started.\n", SAMBA_VERSION_STRING));
1281         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1282
1283         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1284                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1285
1286         /* Output the build options to the debug log */
1287         build_options(False);
1288
1289         if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1290                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1291                 exit(1);
1292         }
1293
1294         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1295                 DEBUG(0, ("error opening config file\n"));
1296                 exit(1);
1297         }
1298
1299         if (smbd_messaging_context() == NULL)
1300                 exit(1);
1301
1302         if (!reload_services(False))
1303                 return(-1);
1304
1305         init_structs();
1306
1307 #ifdef WITH_PROFILE
1308         if (!profile_setup(smbd_messaging_context(), False)) {
1309                 DEBUG(0,("ERROR: failed to setup profiling\n"));
1310                 return -1;
1311         }
1312         if (profile_level != NULL) {
1313                 int pl = atoi(profile_level);
1314                 struct server_id src;
1315
1316                 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1317                 src.pid = getpid();
1318                 set_profile_level(pl, src);
1319         }
1320 #endif
1321
1322         DEBUG(3,( "loaded services\n"));
1323
1324         if (!is_daemon && !is_a_socket(0)) {
1325                 if (!interactive)
1326                         DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1327
1328                 /*
1329                  * Setting is_daemon here prevents us from eventually calling
1330                  * the open_sockets_inetd()
1331                  */
1332
1333                 is_daemon = True;
1334         }
1335
1336         if (is_daemon && !interactive) {
1337                 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1338                 become_daemon(Fork, no_process_group);
1339         }
1340
1341 #if HAVE_SETPGID
1342         /*
1343          * If we're interactive we want to set our own process group for
1344          * signal management.
1345          */
1346         if (interactive && !no_process_group)
1347                 setpgid( (pid_t)0, (pid_t)0);
1348 #endif
1349
1350         if (!directory_exist(lp_lockdir(), NULL))
1351                 mkdir(lp_lockdir(), 0755);
1352
1353         if (is_daemon)
1354                 pidfile_create("smbd");
1355
1356         if (!reinit_after_fork(smbd_messaging_context(),
1357                                smbd_event_context(), false)) {
1358                 DEBUG(0,("reinit_after_fork() failed\n"));
1359                 exit(1);
1360         }
1361
1362         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1363
1364         if (smbd_memcache() == NULL) {
1365                 exit(1);
1366         }
1367
1368         memcache_set_global(smbd_memcache());
1369
1370         /* Initialise the password backed before the global_sam_sid
1371            to ensure that we fetch from ldap before we make a domain sid up */
1372
1373         if(!initialize_password_db(False, smbd_event_context()))
1374                 exit(1);
1375
1376         if (!secrets_init()) {
1377                 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1378                 exit(1);
1379         }
1380
1381         if(!get_global_sam_sid()) {
1382                 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1383                 exit(1);
1384         }
1385
1386         if (!session_init())
1387                 exit(1);
1388
1389         if (!connections_init(True))
1390                 exit(1);
1391
1392         if (!locking_init())
1393                 exit(1);
1394
1395         namecache_enable();
1396
1397         if (!W_ERROR_IS_OK(registry_init_full()))
1398                 exit(1);
1399
1400 #if 0
1401         if (!init_svcctl_db())
1402                 exit(1);
1403 #endif
1404
1405         if (!print_backend_init(smbd_messaging_context()))
1406                 exit(1);
1407
1408         if (!init_guest_info()) {
1409                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1410                 return -1;
1411         }
1412
1413         /* only start the background queue daemon if we are
1414            running as a daemon -- bad things will happen if
1415            smbd is launched via inetd and we fork a copy of
1416            ourselves here */
1417
1418         if (is_daemon && !interactive
1419             && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
1420                 start_background_queue();
1421         }
1422
1423         if (!open_sockets_smbd(is_daemon, interactive, ports))
1424                 exit(1);
1425
1426         /*
1427          * everything after this point is run after the fork()
1428          */
1429
1430         static_init_rpc;
1431
1432         init_modules();
1433
1434         /* Possibly reload the services file. Only worth doing in
1435          * daemon mode. In inetd mode, we know we only just loaded this.
1436          */
1437         if (is_daemon) {
1438                 reload_services(True);
1439         }
1440
1441         if (!init_account_policy()) {
1442                 DEBUG(0,("Could not open account policy tdb.\n"));
1443                 exit(1);
1444         }
1445
1446         if (*lp_rootdir()) {
1447                 if (sys_chroot(lp_rootdir()) != 0) {
1448                         DEBUG(0,("Failed to change root to %s\n", lp_rootdir()));
1449                         exit(1);
1450                 }
1451                 if (chdir("/") == -1) {
1452                         DEBUG(0,("Failed to chdir to / on chroot to %s\n", lp_rootdir()));
1453                         exit(1);
1454                 }
1455                 DEBUG(0,("Changed root to %s\n", lp_rootdir()));
1456         }
1457
1458         /* Setup oplocks */
1459         if (!init_oplocks(smbd_messaging_context()))
1460                 exit(1);
1461
1462         /* Setup aio signal handler. */
1463         initialize_async_io_handler();
1464
1465         /* register our message handlers */
1466         messaging_register(smbd_messaging_context(), NULL,
1467                            MSG_SMB_FORCE_TDIS, msg_force_tdis);
1468         messaging_register(smbd_messaging_context(), NULL,
1469                            MSG_SMB_RELEASE_IP, msg_release_ip);
1470         messaging_register(smbd_messaging_context(), NULL,
1471                            MSG_SMB_CLOSE_FILE, msg_close_file);
1472
1473         if ((lp_keepalive() != 0)
1474             && !(event_add_idle(smbd_event_context(), NULL,
1475                                 timeval_set(lp_keepalive(), 0),
1476                                 "keepalive", keepalive_fn,
1477                                 NULL))) {
1478                 DEBUG(0, ("Could not add keepalive event\n"));
1479                 exit(1);
1480         }
1481
1482         if (!(event_add_idle(smbd_event_context(), NULL,
1483                              timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1484                              "deadtime", deadtime_fn, NULL))) {
1485                 DEBUG(0, ("Could not add deadtime event\n"));
1486                 exit(1);
1487         }
1488
1489         if (!(event_add_idle(smbd_event_context(), NULL,
1490                              timeval_set(SMBD_SELECT_TIMEOUT, 0),
1491                              "housekeeping", housekeeping_fn, NULL))) {
1492                 DEBUG(0, ("Could not add housekeeping event\n"));
1493                 exit(1);
1494         }
1495
1496 #ifdef CLUSTER_SUPPORT
1497
1498         if (lp_clustering()) {
1499                 /*
1500                  * We need to tell ctdb about our client's TCP
1501                  * connection, so that for failover ctdbd can send
1502                  * tickle acks, triggering a reconnection by the
1503                  * client.
1504                  */
1505
1506                 struct sockaddr_storage srv, clnt;
1507
1508                 if (client_get_tcp_info(&srv, &clnt) == 0) {
1509
1510                         NTSTATUS status;
1511
1512                         status = ctdbd_register_ips(
1513                                 messaging_ctdbd_connection(),
1514                                 &srv, &clnt, release_ip, NULL);
1515
1516                         if (!NT_STATUS_IS_OK(status)) {
1517                                 DEBUG(0, ("ctdbd_register_ips failed: %s\n",
1518                                           nt_errstr(status)));
1519                         }
1520                 } else
1521                 {
1522                         DEBUG(0,("Unable to get tcp info for "
1523                                  "CTDB_CONTROL_TCP_CLIENT: %s\n",
1524                                  strerror(errno)));
1525                 }
1526         }
1527
1528 #endif
1529
1530         TALLOC_FREE(frame);
1531
1532         smbd_process();
1533
1534         namecache_shutdown();
1535
1536         exit_server_cleanly(NULL);
1537         return(0);
1538 }