source3/smbd/server.c

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