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                                 char remaddr[INET6_ADDRSTRLEN];
 606
 607                                 /* Child code ... */
 608
 609                                 /* Stop zombies, the parent explicitly handles
 610                                  * them, counting worker smbds. */
 611                                 CatchChild();
 612
 613                                 /* close the listening socket(s) */
 614                                 for(i = 0; i < num_sockets; i++)
 615                                         close(fd_listenset[i]);
 616
 617                                 /* close our standard file
 618                                    descriptors */
 619                                 close_low_fds(False);
 620                                 am_parent = 0;
 621
 622                                 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 623                                 set_socket_options(smbd_server_fd(),user_socket_options);
 624
 625                                 /* this is needed so that we get decent entries
 626                                    in smbstatus for port 445 connects */
 627                                 set_remote_machine_name(get_peer_addr(smbd_server_fd(),remaddr),
 628                                                         False);
 629
 630                                 /* Reset the state of the random
 631                                  * number generation system, so
 632                                  * children do not get the same random
 633                                  * numbers as each other */
 634
 635                                 set_need_random_reseed();
 636                                 /* tdb needs special fork handling - remove
 637                                  * CLEAR_IF_FIRST flags */
 638                                 if (tdb_reopen_all(1) == -1) {
 639                                         DEBUG(0,("tdb_reopen_all failed.\n"));
 640                                         smb_panic("tdb_reopen_all failed");
 641                                 }
 642
 643                                 return True;
 644                         }
 645                         /* The parent doesn't need this socket */
 646                         close(smbd_server_fd());
 647
 648                         /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
 649                                 Clear the closed fd info out of server_fd --
 650                                 and more importantly, out of client_fd in
 651                                 util_sock.c, to avoid a possible
 652                                 getpeername failure if we reopen the logs
 653                                 and use %I in the filename.
 654                         */
 655
 656                         smbd_set_server_fd(-1);
 657
 658                         if (child != 0) {
 659                                 add_child_pid(child);
 660                         }
 661
 662                         /* Force parent to check log size after
 663                          * spawning child.  Fix from
 664                          * klausr@ITAP.Physik.Uni-Stuttgart.De.  The
 665                          * parent smbd will log to logserver.smb.  It
 666                          * writes only two messages for each child
 667                          * started/finished. But each child writes,
 668                          * say, 50 messages also in logserver.smb,
 669                          * begining with the debug_count of the
 670                          * parent, before the child opens its own log
 671                          * file logserver.client. In a worst case
 672                          * scenario the size of logserver.smb would be
 673                          * checked after about 50*50=2500 messages
 674                          * (ca. 100kb).
 675                          * */
 676                         force_check_log_size();
 677
 678                 } /* end for num */
 679         } /* end while 1 */
 680
 681 /* NOTREACHED   return True; */
 682 }
 683
 684 /****************************************************************************
 685  Reload printers
 686 **************************************************************************/
 687 void reload_printers(void)
 688 {
 689         int snum;
 690         int n_services = lp_numservices();
 691         int pnum = lp_servicenumber(PRINTERS_NAME);
 692         const char *pname;
 693
 694         pcap_cache_reload();
 695
 696         /* remove stale printers */
 697         for (snum = 0; snum < n_services; snum++) {
 698                 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
 699                 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
 700                                       lp_autoloaded(snum)))
 701                         continue;
 702
 703                 pname = lp_printername(snum);
 704                 if (!pcap_printername_ok(pname)) {
 705                         DEBUG(3, ("removing stale printer %s\n", pname));
 706
 707                         if (is_printer_published(NULL, snum, NULL))
 708                                 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
 709                         del_a_printer(pname);
 710                         lp_killservice(snum);
 711                 }
 712         }
 713
 714         load_printers();
 715 }
 716
 717 /****************************************************************************
 718  Reload the services file.
 719 **************************************************************************/
 720
 721 bool reload_services(bool test)
 722 {
 723         bool ret;
 724
 725         if (lp_loaded()) {
 726                 pstring fname;
 727                 pstrcpy(fname,lp_configfile());
 728                 if (file_exist(fname, NULL) &&
 729                     !strcsequal(fname, dyn_CONFIGFILE)) {
 730                         pstrcpy(dyn_CONFIGFILE, fname);
 731                         test = False;
 732                 }
 733         }
 734
 735         reopen_logs();
 736
 737         if (test && !lp_file_list_changed())
 738                 return(True);
 739
 740         lp_killunused(conn_snum_used);
 741
 742         ret = lp_load(dyn_CONFIGFILE, False, False, True, True);
 743
 744         reload_printers();
 745
 746         /* perhaps the config filename is now set */
 747         if (!test)
 748                 reload_services(True);
 749
 750         reopen_logs();
 751
 752         load_interfaces();
 753
 754         if (smbd_server_fd() != -1) {
 755                 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 756                 set_socket_options(smbd_server_fd(), user_socket_options);
 757         }
 758
 759         mangle_reset_cache();
 760         reset_stat_cache();
 761
 762         /* this forces service parameters to be flushed */
 763         set_current_service(NULL,0,True);
 764
 765         return(ret);
 766 }
 767
 768 /****************************************************************************
 769  Exit the server.
 770 ****************************************************************************/
 771
 772 /* Reasons for shutting down a server process. */
 773 enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
 774
 775 static void exit_server_common(enum server_exit_reason how,
 776         const char *const reason) NORETURN_ATTRIBUTE;
 777
 778 static void exit_server_common(enum server_exit_reason how,
 779         const char *const reason)
 780 {
 781         static int firsttime=1;
 782
 783         if (!firsttime)
 784                 exit(0);
 785         firsttime = 0;
 786
 787         change_to_root_user();
 788
 789         if (negprot_global_auth_context) {
 790                 (negprot_global_auth_context->free)(&negprot_global_auth_context);
 791         }
 792
 793         conn_close_all();
 794
 795         invalidate_all_vuids();
 796
 797         /* 3 second timeout. */
 798         print_notify_send_messages(smbd_messaging_context(), 3);
 799
 800         /* delete our entry in the connections database. */
 801         yield_connection(NULL,"");
 802
 803         respond_to_all_remaining_local_messages();
 804
 805 #ifdef WITH_DFS
 806         if (dcelogin_atmost_once) {
 807                 dfs_unlogin();
 808         }
 809 #endif
 810
 811         locking_end();
 812         printing_end();
 813
 814         if (how != SERVER_EXIT_NORMAL) {
 815                 int oldlevel = DEBUGLEVEL;
 816
 817                 DEBUGLEVEL = 10;
 818
 819                 DEBUGSEP(0);
 820                 DEBUG(0,("Abnormal server exit: %s\n",
 821                         reason ? reason : "no explanation provided"));
 822                 DEBUGSEP(0);
 823
 824                 log_stack_trace();
 825
 826                 DEBUGLEVEL = oldlevel;
 827                 dump_core();
 828
 829         } else {
 830                 DEBUG(3,("Server exit (%s)\n",
 831                         (reason ? reason : "normal exit")));
 832         }
 833
 834         exit(0);
 835 }
 836
 837 void exit_server(const char *const explanation)
 838 {
 839         exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
 840 }
 841
 842 void exit_server_cleanly(const char *const explanation)
 843 {
 844         exit_server_common(SERVER_EXIT_NORMAL, explanation);
 845 }
 846
 847 void exit_server_fault(void)
 848 {
 849         exit_server("critical server fault");
 850 }
 851
 852 /****************************************************************************
 853  Initialise connect, service and file structs.
 854 ****************************************************************************/
 855
 856 static bool init_structs(void )
 857 {
 858         /*
 859          * Set the machine NETBIOS name if not already
 860          * set from the config file.
 861          */
 862
 863         if (!init_names())
 864                 return False;
 865
 866         conn_init();
 867
 868         file_init();
 869
 870         /* for RPC pipes */
 871         init_rpc_pipe_hnd();
 872
 873         init_dptrs();
 874
 875         secrets_init();
 876
 877         return True;
 878 }
 879
 880 /*
 881  * Send keepalive packets to our client
 882  */
 883 static bool keepalive_fn(const struct timeval *now, void *private_data)
 884 {
 885         if (!send_keepalive(smbd_server_fd())) {
 886                 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
 887                 return False;
 888         }
 889         return True;
 890 }
 891
 892 /*
 893  * Do the recurring check if we're idle
 894  */
 895 static bool deadtime_fn(const struct timeval *now, void *private_data)
 896 {
 897         if ((conn_num_open() == 0)
 898             || (conn_idle_all(now->tv_sec))) {
 899                 DEBUG( 2, ( "Closing idle connection\n" ) );
 900                 messaging_send(smbd_messaging_context(), procid_self(),
 901                                MSG_SHUTDOWN, &data_blob_null);
 902                 return False;
 903         }
 904
 905         return True;
 906 }
 907
 908
 909 /****************************************************************************
 910  main program.
 911 ****************************************************************************/
 912
 913 /* Declare prototype for build_options() to avoid having to run it through
 914    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
 915    prototype generation system is too complicated. */
 916
 917 extern void build_options(bool screen);
 918
 919  int main(int argc,const char *argv[])
 920 {
 921         /* shall I run as a daemon */
 922         static bool is_daemon = False;
 923         static bool interactive = False;
 924         static bool Fork = True;
 925         static bool no_process_group = False;
 926         static bool log_stdout = False;
 927         static char *ports = NULL;
 928         static char *profile_level = NULL;
 929         int opt;
 930         poptContext pc;
 931         bool print_build_options = False;
 932         enum {
 933                 OPT_DAEMON = 1000,
 934                 OPT_INTERACTIVE,
 935                 OPT_FORK,
 936                 OPT_NO_PROCESS_GROUP,
 937                 OPT_LOG_STDOUT
 938         };
 939         struct poptOption long_options[] = {
 940         POPT_AUTOHELP
 941         {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
 942         {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
 943         {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
 944         {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
 945         {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
 946         {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
 947         {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
 948         {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
 949         POPT_COMMON_SAMBA
 950         POPT_COMMON_DYNCONFIG
 951         POPT_TABLEEND
 952         };
 953
 954         load_case_tables();
 955
 956         TimeInit();
 957
 958 #ifdef HAVE_SET_AUTH_PARAMETERS
 959         set_auth_parameters(argc,argv);
 960 #endif
 961
 962         pc = poptGetContext("smbd", argc, argv, long_options, 0);
 963         while((opt = poptGetNextOpt(pc)) != -1) {
 964                 switch (opt)  {
 965                 case OPT_DAEMON:
 966                         is_daemon = true;
 967                         break;
 968                 case OPT_INTERACTIVE:
 969                         interactive = true;
 970                         break;
 971                 case OPT_FORK:
 972                         Fork = false;
 973                         break;
 974                 case OPT_NO_PROCESS_GROUP:
 975                         no_process_group = true;
 976                         break;
 977                 case OPT_LOG_STDOUT:
 978                         log_stdout = true;
 979                         break;
 980                 case 'b':
 981                         print_build_options = True;
 982                         break;
 983                 default:
 984                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
 985                                   poptBadOption(pc, 0), poptStrerror(opt));
 986                         poptPrintUsage(pc, stderr, 0);
 987                         exit(1);
 988                 }
 989         }
 990         poptFreeContext(pc);
 991
 992         if (print_build_options) {
 993                 build_options(True); /* Display output to screen as well as debug */
 994                 exit(0);
 995         }
 996
 997 #ifdef HAVE_SETLUID
 998         /* needed for SecureWare on SCO */
 999         setluid(0);
1000 #endif
1001
1002         sec_init();
1003
1004         set_remote_machine_name("smbd", False);
1005
1006         if (interactive) {
1007                 Fork = False;
1008                 log_stdout = True;
1009         }
1010
1011         if (interactive && (DEBUGLEVEL >= 9)) {
1012                 talloc_enable_leak_report();
1013         }
1014
1015         if (log_stdout && Fork) {
1016                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1017                 exit(1);
1018         }
1019
1020         setup_logging(argv[0],log_stdout);
1021
1022         /* we want to re-seed early to prevent time delays causing
1023            client problems at a later date. (tridge) */
1024         generate_random_buffer(NULL, 0);
1025
1026         /* make absolutely sure we run as root - to handle cases where people
1027            are crazy enough to have it setuid */
1028
1029         gain_root_privilege();
1030         gain_root_group_privilege();
1031
1032         fault_setup((void (*)(void *))exit_server_fault);
1033         dump_core_setup("smbd");
1034
1035         CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
1036         CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
1037
1038         /* we are never interested in SIGPIPE */
1039         BlockSignals(True,SIGPIPE);
1040
1041 #if defined(SIGFPE)
1042         /* we are never interested in SIGFPE */
1043         BlockSignals(True,SIGFPE);
1044 #endif
1045
1046 #if defined(SIGUSR2)
1047         /* We are no longer interested in USR2 */
1048         BlockSignals(True,SIGUSR2);
1049 #endif
1050
1051         /* POSIX demands that signals are inherited. If the invoking process has
1052          * these signals masked, we will have problems, as we won't recieve them. */
1053         BlockSignals(False, SIGHUP);
1054         BlockSignals(False, SIGUSR1);
1055         BlockSignals(False, SIGTERM);
1056
1057         /* we want total control over the permissions on created files,
1058            so set our umask to 0 */
1059         umask(0);
1060
1061         init_sec_ctx();
1062
1063         reopen_logs();
1064
1065         DEBUG(0,("smbd version %s started.\n", SAMBA_VERSION_STRING));
1066         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1067
1068         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1069                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1070
1071         /* Output the build options to the debug log */
1072         build_options(False);
1073
1074         if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1075                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1076                 exit(1);
1077         }
1078
1079         /*
1080          * Do this before reload_services.
1081          */
1082
1083         if (!reload_services(False))
1084                 return(-1);
1085
1086         init_structs();
1087
1088 #ifdef WITH_PROFILE
1089         if (!profile_setup(smbd_messaging_context(), False)) {
1090                 DEBUG(0,("ERROR: failed to setup profiling\n"));
1091                 return -1;
1092         }
1093         if (profile_level != NULL) {
1094                 int pl = atoi(profile_level);
1095                 struct server_id src;
1096
1097                 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1098                 src.pid = getpid();
1099                 set_profile_level(pl, src);
1100         }
1101 #endif
1102
1103         DEBUG(3,( "loaded services\n"));
1104
1105         if (!is_daemon && !is_a_socket(0)) {
1106                 if (!interactive)
1107                         DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1108
1109                 /*
1110                  * Setting is_daemon here prevents us from eventually calling
1111                  * the open_sockets_inetd()
1112                  */
1113
1114                 is_daemon = True;
1115         }
1116
1117         if (is_daemon && !interactive) {
1118                 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1119                 become_daemon(Fork, no_process_group);
1120         }
1121
1122 #if HAVE_SETPGID
1123         /*
1124          * If we're interactive we want to set our own process group for
1125          * signal management.
1126          */
1127         if (interactive && !no_process_group)
1128                 setpgid( (pid_t)0, (pid_t)0);
1129 #endif
1130
1131         if (!directory_exist(lp_lockdir(), NULL))
1132                 mkdir(lp_lockdir(), 0755);
1133
1134         if (is_daemon)
1135                 pidfile_create("smbd");
1136
1137         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1138
1139         if (smbd_messaging_context() == NULL)
1140                 exit(1);
1141
1142         /* Initialise the password backed before the global_sam_sid
1143            to ensure that we fetch from ldap before we make a domain sid up */
1144
1145         if(!initialize_password_db(False, smbd_event_context()))
1146                 exit(1);
1147
1148         if (!secrets_init()) {
1149                 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1150                 exit(1);
1151         }
1152
1153         if(!get_global_sam_sid()) {
1154                 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1155                 exit(1);
1156         }
1157
1158         if (!session_init())
1159                 exit(1);
1160
1161         if (!connections_init(True))
1162                 exit(1);
1163
1164         if (!locking_init(0))
1165                 exit(1);
1166
1167         namecache_enable();
1168
1169         if (!init_registry())
1170                 exit(1);
1171
1172 #if 0
1173         if (!init_svcctl_db())
1174                 exit(1);
1175 #endif
1176
1177         if (!print_backend_init(smbd_messaging_context()))
1178                 exit(1);
1179
1180         if (!init_guest_info()) {
1181                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1182                 return -1;
1183         }
1184
1185         /* only start the background queue daemon if we are
1186            running as a daemon -- bad things will happen if
1187            smbd is launched via inetd and we fork a copy of
1188            ourselves here */
1189
1190         if ( is_daemon && !interactive )
1191                 start_background_queue();
1192
1193         /* Always attempt to initialize DMAPI. We will only use it later if
1194          * lp_dmapi_support is set on the share, but we need a single global
1195          * session to work with.
1196          */
1197         dmapi_init_session();
1198
1199         if (!open_sockets_smbd(is_daemon, interactive, ports))
1200                 exit(1);
1201
1202         /*
1203          * everything after this point is run after the fork()
1204          */
1205
1206         static_init_rpc;
1207
1208         init_modules();
1209
1210         /* Possibly reload the services file. Only worth doing in
1211          * daemon mode. In inetd mode, we know we only just loaded this.
1212          */
1213         if (is_daemon) {
1214                 reload_services(True);
1215         }
1216
1217         if (!init_account_policy()) {
1218                 DEBUG(0,("Could not open account policy tdb.\n"));
1219                 exit(1);
1220         }
1221
1222         if (*lp_rootdir()) {
1223                 if (sys_chroot(lp_rootdir()) == 0)
1224                         DEBUG(2,("Changed root to %s\n", lp_rootdir()));
1225         }
1226
1227         /* Setup oplocks */
1228         if (!init_oplocks(smbd_messaging_context()))
1229                 exit(1);
1230
1231         /* Setup aio signal handler. */
1232         initialize_async_io_handler();
1233
1234         /*
1235          * For clustering, we need to re-init our ctdbd connection after the
1236          * fork
1237          */
1238         if (!NT_STATUS_IS_OK(messaging_reinit(smbd_messaging_context())))
1239                 exit(1);
1240
1241         /* register our message handlers */
1242         messaging_register(smbd_messaging_context(), NULL,
1243                            MSG_SMB_FORCE_TDIS, msg_force_tdis);
1244
1245         if ((lp_keepalive() != 0)
1246             && !(event_add_idle(smbd_event_context(), NULL,
1247                                 timeval_set(lp_keepalive(), 0),
1248                                 "keepalive", keepalive_fn,
1249                                 NULL))) {
1250                 DEBUG(0, ("Could not add keepalive event\n"));
1251                 exit(1);
1252         }
1253
1254         if (!(event_add_idle(smbd_event_context(), NULL,
1255                              timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1256                              "deadtime", deadtime_fn, NULL))) {
1257                 DEBUG(0, ("Could not add deadtime event\n"));
1258                 exit(1);
1259         }
1260
1261         smbd_process();
1262
1263         namecache_shutdown();
1264
1265         exit_server_cleanly(NULL);
1266         return(0);
1267 }