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