source/smbd/server.c

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