source3/smbd/server.c

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