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                         const struct sockaddr_storage *ifss =
 352                                         iface_n_sockaddr_storage(i);
 353                         const struct in_addr *ifip;
 354                         fstring tok;
 355                         const char *ptr;
 356
 357                         if (ifss == NULL) {
 358                                 DEBUG(0,("open_sockets_smbd: interface %d has NULL IP address !\n", i));
 359                                 continue;
 360                         }
 361
 362                         /* For now only deal with IPv4. */
 363                         if (ifss->ss_family != AF_INET) {
 364                                 continue;
 365                         }
 366
 367                         ifip = &((const struct sockaddr_in *)ifss)->sin_addr;
 368
 369                         for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
 370                                 unsigned port = atoi(tok);
 371                                 if (port == 0 || port > 0xffff) {
 372                                         continue;
 373                                 }
 374                                 s = fd_listenset[num_sockets] = open_socket_in(SOCK_STREAM, port, 0, ifip->s_addr, True);
 375                                 if(s == -1)
 376                                         return False;
 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 non-blocking for the accept. */
 383                                 set_blocking(s,False);
 384
 385                                 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
 386                                         DEBUG(0,("listen: %s\n",strerror(errno)));
 387                                         close(s);
 388                                         return False;
 389                                 }
 390                                 FD_SET(s,&listen_set);
 391                                 maxfd = MAX( maxfd, s);
 392
 393                                 num_sockets++;
 394                                 if (num_sockets >= FD_SETSIZE) {
 395                                         DEBUG(0,("open_sockets_smbd: Too many sockets to bind to\n"));
 396                                         return False;
 397                                 }
 398                         }
 399                 }
 400         } else {
 401                 /* Just bind to 0.0.0.0 - accept connections
 402                    from anywhere. */
 403
 404                 fstring tok;
 405                 const char *ptr;
 406
 407                 num_interfaces = 1;
 408
 409                 for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
 410                         unsigned port = atoi(tok);
 411                         if (port == 0 || port > 0xffff) continue;
 412                         /* open an incoming socket */
 413                         s = open_socket_in(SOCK_STREAM, port, 0,
 414                                            interpret_addr(lp_socket_address()),True);
 415                         if (s == -1)
 416                                 return(False);
 417
 418                         /* ready to listen */
 419                         set_socket_options(s,"SO_KEEPALIVE");
 420                         set_socket_options(s,user_socket_options);
 421
 422                         /* Set server socket to non-blocking for the accept. */
 423                         set_blocking(s,False);
 424
 425                         if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
 426                                 DEBUG(0,("open_sockets_smbd: listen: %s\n",
 427                                          strerror(errno)));
 428                                 close(s);
 429                                 return False;
 430                         }
 431
 432                         fd_listenset[num_sockets] = s;
 433                         FD_SET(s,&listen_set);
 434                         maxfd = MAX( maxfd, s);
 435
 436                         num_sockets++;
 437
 438                         if (num_sockets >= FD_SETSIZE) {
 439                                 DEBUG(0,("open_sockets_smbd: Too many sockets to bind to\n"));
 440                                 return False;
 441                         }
 442                 }
 443         }
 444
 445         SAFE_FREE(ports);
 446
 447
 448         /* Setup the main smbd so that we can get messages. Note that
 449            do this after starting listening. This is needed as when in
 450            clustered mode, ctdb won't allow us to start doing database
 451            operations until it has gone thru a full startup, which
 452            includes checking to see that smbd is listening. */
 453         claim_connection(NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_SMBD);
 454
 455         /* Listen to messages */
 456
 457         messaging_register(smbd_messaging_context(), NULL,
 458                            MSG_SMB_SAM_SYNC, msg_sam_sync);
 459         messaging_register(smbd_messaging_context(), NULL,
 460                            MSG_SHUTDOWN, msg_exit_server);
 461         messaging_register(smbd_messaging_context(), NULL,
 462                            MSG_SMB_FILE_RENAME, msg_file_was_renamed);
 463         messaging_register(smbd_messaging_context(), NULL,
 464                            MSG_SMB_CONF_UPDATED, smb_conf_updated);
 465         messaging_register(smbd_messaging_context(), NULL,
 466                            MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
 467         brl_register_msgs(smbd_messaging_context());
 468
 469 #ifdef DEVELOPER
 470         messaging_register(smbd_messaging_context(), NULL,
 471                            MSG_SMB_INJECT_FAULT, msg_inject_fault);
 472 #endif
 473
 474         /* now accept incoming connections - forking a new process
 475            for each incoming connection */
 476         DEBUG(2,("waiting for a connection\n"));
 477         while (1) {
 478                 struct timeval now, idle_timeout;
 479                 fd_set r_fds, w_fds;
 480                 int num;
 481
 482                 /* Ensure we respond to PING and DEBUG messages from the main smbd. */
 483                 message_dispatch(smbd_messaging_context());
 484
 485                 if (got_sig_cld) {
 486                         pid_t pid;
 487                         got_sig_cld = False;
 488
 489                         while ((pid = sys_waitpid(-1, NULL, WNOHANG)) > 0) {
 490                                 remove_child_pid(pid);
 491                         }
 492                 }
 493
 494                 idle_timeout = timeval_zero();
 495
 496                 memcpy((char *)&r_fds, (char *)&listen_set,
 497                        sizeof(listen_set));
 498                 FD_ZERO(&w_fds);
 499                 GetTimeOfDay(&now);
 500
 501                 event_add_to_select_args(smbd_event_context(), &now,
 502                                          &r_fds, &w_fds, &idle_timeout,
 503                                          &maxfd);
 504
 505                 num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
 506                                  timeval_is_zero(&idle_timeout) ?
 507                                  NULL : &idle_timeout);
 508
 509                 if (num == -1 && errno == EINTR) {
 510                         if (got_sig_term) {
 511                                 exit_server_cleanly(NULL);
 512                         }
 513
 514                         /* check for sighup processing */
 515                         if (reload_after_sighup) {
 516                                 change_to_root_user();
 517                                 DEBUG(1,("Reloading services after SIGHUP\n"));
 518                                 reload_services(False);
 519                                 reload_after_sighup = 0;
 520                         }
 521
 522                         continue;
 523                 }
 524
 525                 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
 526                         continue;
 527                 }
 528
 529                 /* check if we need to reload services */
 530                 check_reload(time(NULL));
 531
 532                 /* Find the sockets that are read-ready -
 533                    accept on these. */
 534                 for( ; num > 0; num--) {
 535                         struct sockaddr addr;
 536                         socklen_t in_addrlen = sizeof(addr);
 537                         pid_t child = 0;
 538
 539                         s = -1;
 540                         for(i = 0; i < num_sockets; i++) {
 541                                 if(FD_ISSET(fd_listenset[i],&r_fds)) {
 542                                         s = fd_listenset[i];
 543                                         /* Clear this so we don't look
 544                                            at it again. */
 545                                         FD_CLR(fd_listenset[i],&r_fds);
 546                                         break;
 547                                 }
 548                         }
 549
 550                         smbd_set_server_fd(accept(s,&addr,&in_addrlen));
 551
 552                         if (smbd_server_fd() == -1 && errno == EINTR)
 553                                 continue;
 554
 555                         if (smbd_server_fd() == -1) {
 556                                 DEBUG(0,("open_sockets_smbd: accept: %s\n",
 557                                          strerror(errno)));
 558                                 continue;
 559                         }
 560
 561                         /* Ensure child is set to blocking mode */
 562                         set_blocking(smbd_server_fd(),True);
 563
 564                         if (smbd_server_fd() != -1 && interactive)
 565                                 return True;
 566
 567                         if (allowable_number_of_smbd_processes() &&
 568                             smbd_server_fd() != -1 &&
 569                             ((child = sys_fork())==0)) {
 570                                 /* Child code ... */
 571
 572                                 /* Stop zombies, the parent explicitly handles
 573                                  * them, counting worker smbds. */
 574                                 CatchChild();
 575
 576                                 /* close the listening socket(s) */
 577                                 for(i = 0; i < num_sockets; i++)
 578                                         close(fd_listenset[i]);
 579
 580                                 /* close our standard file
 581                                    descriptors */
 582                                 close_low_fds(False);
 583                                 am_parent = 0;
 584
 585                                 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 586                                 set_socket_options(smbd_server_fd(),user_socket_options);
 587
 588                                 /* this is needed so that we get decent entries
 589                                    in smbstatus for port 445 connects */
 590                                 set_remote_machine_name(get_peer_addr(smbd_server_fd()),
 591                                                         False);
 592
 593                                 /* Reset the state of the random
 594                                  * number generation system, so
 595                                  * children do not get the same random
 596                                  * numbers as each other */
 597
 598                                 set_need_random_reseed();
 599                                 /* tdb needs special fork handling - remove
 600                                  * CLEAR_IF_FIRST flags */
 601                                 if (tdb_reopen_all(1) == -1) {
 602                                         DEBUG(0,("tdb_reopen_all failed.\n"));
 603                                         smb_panic("tdb_reopen_all failed");
 604                                 }
 605
 606                                 return True;
 607                         }
 608                         /* The parent doesn't need this socket */
 609                         close(smbd_server_fd());
 610
 611                         /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
 612                                 Clear the closed fd info out of server_fd --
 613                                 and more importantly, out of client_fd in
 614                                 util_sock.c, to avoid a possible
 615                                 getpeername failure if we reopen the logs
 616                                 and use %I in the filename.
 617                         */
 618
 619                         smbd_set_server_fd(-1);
 620
 621                         if (child != 0) {
 622                                 add_child_pid(child);
 623                         }
 624
 625                         /* Force parent to check log size after
 626                          * spawning child.  Fix from
 627                          * klausr@ITAP.Physik.Uni-Stuttgart.De.  The
 628                          * parent smbd will log to logserver.smb.  It
 629                          * writes only two messages for each child
 630                          * started/finished. But each child writes,
 631                          * say, 50 messages also in logserver.smb,
 632                          * begining with the debug_count of the
 633                          * parent, before the child opens its own log
 634                          * file logserver.client. In a worst case
 635                          * scenario the size of logserver.smb would be
 636                          * checked after about 50*50=2500 messages
 637                          * (ca. 100kb).
 638                          * */
 639                         force_check_log_size();
 640
 641                 } /* end for num */
 642         } /* end while 1 */
 643
 644 /* NOTREACHED   return True; */
 645 }
 646
 647 /****************************************************************************
 648  Reload printers
 649 **************************************************************************/
 650 void reload_printers(void)
 651 {
 652         int snum;
 653         int n_services = lp_numservices();
 654         int pnum = lp_servicenumber(PRINTERS_NAME);
 655         const char *pname;
 656
 657         pcap_cache_reload();
 658
 659         /* remove stale printers */
 660         for (snum = 0; snum < n_services; snum++) {
 661                 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
 662                 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
 663                                       lp_autoloaded(snum)))
 664                         continue;
 665
 666                 pname = lp_printername(snum);
 667                 if (!pcap_printername_ok(pname)) {
 668                         DEBUG(3, ("removing stale printer %s\n", pname));
 669
 670                         if (is_printer_published(NULL, snum, NULL))
 671                                 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
 672                         del_a_printer(pname);
 673                         lp_killservice(snum);
 674                 }
 675         }
 676
 677         load_printers();
 678 }
 679
 680 /****************************************************************************
 681  Reload the services file.
 682 **************************************************************************/
 683
 684 bool reload_services(bool test)
 685 {
 686         bool ret;
 687
 688         if (lp_loaded()) {
 689                 pstring fname;
 690                 pstrcpy(fname,lp_configfile());
 691                 if (file_exist(fname, NULL) &&
 692                     !strcsequal(fname, dyn_CONFIGFILE)) {
 693                         pstrcpy(dyn_CONFIGFILE, fname);
 694                         test = False;
 695                 }
 696         }
 697
 698         reopen_logs();
 699
 700         if (test && !lp_file_list_changed())
 701                 return(True);
 702
 703         lp_killunused(conn_snum_used);
 704
 705         ret = lp_load(dyn_CONFIGFILE, False, False, True, True);
 706
 707         reload_printers();
 708
 709         /* perhaps the config filename is now set */
 710         if (!test)
 711                 reload_services(True);
 712
 713         reopen_logs();
 714
 715         load_interfaces();
 716
 717         if (smbd_server_fd() != -1) {
 718                 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
 719                 set_socket_options(smbd_server_fd(), user_socket_options);
 720         }
 721
 722         mangle_reset_cache();
 723         reset_stat_cache();
 724
 725         /* this forces service parameters to be flushed */
 726         set_current_service(NULL,0,True);
 727
 728         return(ret);
 729 }
 730
 731 /****************************************************************************
 732  Exit the server.
 733 ****************************************************************************/
 734
 735 /* Reasons for shutting down a server process. */
 736 enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
 737
 738 static void exit_server_common(enum server_exit_reason how,
 739         const char *const reason) NORETURN_ATTRIBUTE;
 740
 741 static void exit_server_common(enum server_exit_reason how,
 742         const char *const reason)
 743 {
 744         static int firsttime=1;
 745
 746         if (!firsttime)
 747                 exit(0);
 748         firsttime = 0;
 749
 750         change_to_root_user();
 751
 752         if (negprot_global_auth_context) {
 753                 (negprot_global_auth_context->free)(&negprot_global_auth_context);
 754         }
 755
 756         conn_close_all();
 757
 758         invalidate_all_vuids();
 759
 760         /* 3 second timeout. */
 761         print_notify_send_messages(smbd_messaging_context(), 3);
 762
 763         /* delete our entry in the connections database. */
 764         yield_connection(NULL,"");
 765
 766         respond_to_all_remaining_local_messages();
 767
 768 #ifdef WITH_DFS
 769         if (dcelogin_atmost_once) {
 770                 dfs_unlogin();
 771         }
 772 #endif
 773
 774         locking_end();
 775         printing_end();
 776
 777         if (how != SERVER_EXIT_NORMAL) {
 778                 int oldlevel = DEBUGLEVEL;
 779
 780                 DEBUGLEVEL = 10;
 781
 782                 DEBUGSEP(0);
 783                 DEBUG(0,("Abnormal server exit: %s\n",
 784                         reason ? reason : "no explanation provided"));
 785                 DEBUGSEP(0);
 786
 787                 log_stack_trace();
 788
 789                 DEBUGLEVEL = oldlevel;
 790                 dump_core();
 791
 792         } else {
 793                 DEBUG(3,("Server exit (%s)\n",
 794                         (reason ? reason : "normal exit")));
 795         }
 796
 797         exit(0);
 798 }
 799
 800 void exit_server(const char *const explanation)
 801 {
 802         exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
 803 }
 804
 805 void exit_server_cleanly(const char *const explanation)
 806 {
 807         exit_server_common(SERVER_EXIT_NORMAL, explanation);
 808 }
 809
 810 void exit_server_fault(void)
 811 {
 812         exit_server("critical server fault");
 813 }
 814
 815 /****************************************************************************
 816  Initialise connect, service and file structs.
 817 ****************************************************************************/
 818
 819 static bool init_structs(void )
 820 {
 821         /*
 822          * Set the machine NETBIOS name if not already
 823          * set from the config file.
 824          */
 825
 826         if (!init_names())
 827                 return False;
 828
 829         conn_init();
 830
 831         file_init();
 832
 833         /* for RPC pipes */
 834         init_rpc_pipe_hnd();
 835
 836         init_dptrs();
 837
 838         secrets_init();
 839
 840         return True;
 841 }
 842
 843 /*
 844  * Send keepalive packets to our client
 845  */
 846 static bool keepalive_fn(const struct timeval *now, void *private_data)
 847 {
 848         if (!send_keepalive(smbd_server_fd())) {
 849                 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
 850                 return False;
 851         }
 852         return True;
 853 }
 854
 855 /*
 856  * Do the recurring check if we're idle
 857  */
 858 static bool deadtime_fn(const struct timeval *now, void *private_data)
 859 {
 860         if ((conn_num_open() == 0)
 861             || (conn_idle_all(now->tv_sec))) {
 862                 DEBUG( 2, ( "Closing idle connection\n" ) );
 863                 messaging_send(smbd_messaging_context(), procid_self(),
 864                                MSG_SHUTDOWN, &data_blob_null);
 865                 return False;
 866         }
 867
 868         return True;
 869 }
 870
 871
 872 /****************************************************************************
 873  main program.
 874 ****************************************************************************/
 875
 876 /* Declare prototype for build_options() to avoid having to run it through
 877    mkproto.h.  Mixing $(builddir) and $(srcdir) source files in the current
 878    prototype generation system is too complicated. */
 879
 880 extern void build_options(bool screen);
 881
 882  int main(int argc,const char *argv[])
 883 {
 884         /* shall I run as a daemon */
 885         static int is_daemon = False;
 886         static int interactive = False;
 887         static int Fork = True;
 888         static int no_process_group = False;
 889         static int log_stdout = False;
 890         static char *ports = NULL;
 891         static char *profile_level = NULL;
 892         int opt;
 893         poptContext pc;
 894         bool print_build_options = False;
 895
 896         struct poptOption long_options[] = {
 897         POPT_AUTOHELP
 898         {"daemon", 'D', POPT_ARG_VAL, &is_daemon, True, "Become a daemon (default)" },
 899         {"interactive", 'i', POPT_ARG_VAL, &interactive, True, "Run interactive (not a daemon)"},
 900         {"foreground", 'F', POPT_ARG_VAL, &Fork, False, "Run daemon in foreground (for daemontools, etc.)" },
 901         {"no-process-group", '\0', POPT_ARG_VAL, &no_process_group, True, "Don't create a new process group" },
 902         {"log-stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" },
 903         {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
 904         {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
 905         {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
 906         POPT_COMMON_SAMBA
 907         POPT_COMMON_DYNCONFIG
 908         POPT_TABLEEND
 909         };
 910
 911         load_case_tables();
 912
 913         TimeInit();
 914
 915 #ifdef HAVE_SET_AUTH_PARAMETERS
 916         set_auth_parameters(argc,argv);
 917 #endif
 918
 919         pc = poptGetContext("smbd", argc, argv, long_options, 0);
 920         while((opt = poptGetNextOpt(pc)) != -1) {
 921                 switch (opt)  {
 922                 case 'b':
 923                         print_build_options = True;
 924                         break;
 925                 default:
 926                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
 927                                   poptBadOption(pc, 0), poptStrerror(opt));
 928                         poptPrintUsage(pc, stderr, 0);
 929                         exit(1);
 930                 }
 931         }
 932         poptFreeContext(pc);
 933
 934         if (print_build_options) {
 935                 build_options(True); /* Display output to screen as well as debug */
 936                 exit(0);
 937         }
 938
 939 #ifdef HAVE_SETLUID
 940         /* needed for SecureWare on SCO */
 941         setluid(0);
 942 #endif
 943
 944         sec_init();
 945
 946         set_remote_machine_name("smbd", False);
 947
 948         if (interactive) {
 949                 Fork = False;
 950                 log_stdout = True;
 951         }
 952
 953         if (interactive && (DEBUGLEVEL >= 9)) {
 954                 talloc_enable_leak_report();
 955         }
 956
 957         if (log_stdout && Fork) {
 958                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 959                 exit(1);
 960         }
 961
 962         setup_logging(argv[0],log_stdout);
 963
 964         /* we want to re-seed early to prevent time delays causing
 965            client problems at a later date. (tridge) */
 966         generate_random_buffer(NULL, 0);
 967
 968         /* make absolutely sure we run as root - to handle cases where people
 969            are crazy enough to have it setuid */
 970
 971         gain_root_privilege();
 972         gain_root_group_privilege();
 973
 974         fault_setup((void (*)(void *))exit_server_fault);
 975         dump_core_setup("smbd");
 976
 977         CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
 978         CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
 979
 980         /* we are never interested in SIGPIPE */
 981         BlockSignals(True,SIGPIPE);
 982
 983 #if defined(SIGFPE)
 984         /* we are never interested in SIGFPE */
 985         BlockSignals(True,SIGFPE);
 986 #endif
 987
 988 #if defined(SIGUSR2)
 989         /* We are no longer interested in USR2 */
 990         BlockSignals(True,SIGUSR2);
 991 #endif
 992
 993         /* POSIX demands that signals are inherited. If the invoking process has
 994          * these signals masked, we will have problems, as we won't recieve them. */
 995         BlockSignals(False, SIGHUP);
 996         BlockSignals(False, SIGUSR1);
 997         BlockSignals(False, SIGTERM);
 998
 999         /* we want total control over the permissions on created files,
1000            so set our umask to 0 */
1001         umask(0);
1002
1003         init_sec_ctx();
1004
1005         reopen_logs();
1006
1007         DEBUG(0,( "smbd version %s started.\n", SAMBA_VERSION_STRING));
1008         DEBUGADD( 0, ( "%s\n", COPYRIGHT_STARTUP_MESSAGE ) );
1009
1010         DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1011                  (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1012
1013         /* Output the build options to the debug log */
1014         build_options(False);
1015
1016         if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1017                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1018                 exit(1);
1019         }
1020
1021         /*
1022          * Do this before reload_services.
1023          */
1024
1025         if (!reload_services(False))
1026                 return(-1);
1027
1028         init_structs();
1029
1030 #ifdef WITH_PROFILE
1031         if (!profile_setup(smbd_messaging_context(), False)) {
1032                 DEBUG(0,("ERROR: failed to setup profiling\n"));
1033                 return -1;
1034         }
1035         if (profile_level != NULL) {
1036                 int pl = atoi(profile_level);
1037                 struct server_id src;
1038
1039                 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1040                 src.pid = getpid();
1041                 set_profile_level(pl, src);
1042         }
1043 #endif
1044
1045         DEBUG(3,( "loaded services\n"));
1046
1047         if (!is_daemon && !is_a_socket(0)) {
1048                 if (!interactive)
1049                         DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1050
1051                 /*
1052                  * Setting is_daemon here prevents us from eventually calling
1053                  * the open_sockets_inetd()
1054                  */
1055
1056                 is_daemon = True;
1057         }
1058
1059         if (is_daemon && !interactive) {
1060                 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1061                 become_daemon(Fork, no_process_group);
1062         }
1063
1064 #if HAVE_SETPGID
1065         /*
1066          * If we're interactive we want to set our own process group for
1067          * signal management.
1068          */
1069         if (interactive && !no_process_group)
1070                 setpgid( (pid_t)0, (pid_t)0);
1071 #endif
1072
1073         if (!directory_exist(lp_lockdir(), NULL))
1074                 mkdir(lp_lockdir(), 0755);
1075
1076         if (is_daemon)
1077                 pidfile_create("smbd");
1078
1079         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1080
1081         if (smbd_messaging_context() == NULL)
1082                 exit(1);
1083
1084         /* Initialise the password backed before the global_sam_sid
1085            to ensure that we fetch from ldap before we make a domain sid up */
1086
1087         if(!initialize_password_db(False, smbd_event_context()))
1088                 exit(1);
1089
1090         if (!secrets_init()) {
1091                 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1092                 exit(1);
1093         }
1094
1095         if(!get_global_sam_sid()) {
1096                 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1097                 exit(1);
1098         }
1099
1100         if (!session_init())
1101                 exit(1);
1102
1103         if (!connections_init(True))
1104                 exit(1);
1105
1106         if (!locking_init(0))
1107                 exit(1);
1108
1109         namecache_enable();
1110
1111         if (!init_registry())
1112                 exit(1);
1113
1114 #if 0
1115         if (!init_svcctl_db())
1116                 exit(1);
1117 #endif
1118
1119         if (!print_backend_init(smbd_messaging_context()))
1120                 exit(1);
1121
1122         if (!init_guest_info()) {
1123                 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1124                 return -1;
1125         }
1126
1127         /* only start the background queue daemon if we are
1128            running as a daemon -- bad things will happen if
1129            smbd is launched via inetd and we fork a copy of
1130            ourselves here */
1131
1132         if ( is_daemon && !interactive )
1133                 start_background_queue();
1134
1135         /* Always attempt to initialize DMAPI. We will only use it later if
1136          * lp_dmapi_support is set on the share, but we need a single global
1137          * session to work with.
1138          */
1139         dmapi_init_session();
1140
1141         if (!open_sockets_smbd(is_daemon, interactive, ports))
1142                 exit(1);
1143
1144         /*
1145          * everything after this point is run after the fork()
1146          */
1147
1148         static_init_rpc;
1149
1150         init_modules();
1151
1152         /* Possibly reload the services file. Only worth doing in
1153          * daemon mode. In inetd mode, we know we only just loaded this.
1154          */
1155         if (is_daemon) {
1156                 reload_services(True);
1157         }
1158
1159         if (!init_account_policy()) {
1160                 DEBUG(0,("Could not open account policy tdb.\n"));
1161                 exit(1);
1162         }
1163
1164         if (*lp_rootdir()) {
1165                 if (sys_chroot(lp_rootdir()) == 0)
1166                         DEBUG(2,("Changed root to %s\n", lp_rootdir()));
1167         }
1168
1169         /* Setup oplocks */
1170         if (!init_oplocks(smbd_messaging_context()))
1171                 exit(1);
1172
1173         /* Setup aio signal handler. */
1174         initialize_async_io_handler();
1175
1176         /*
1177          * For clustering, we need to re-init our ctdbd connection after the
1178          * fork
1179          */
1180         if (!NT_STATUS_IS_OK(messaging_reinit(smbd_messaging_context())))
1181                 exit(1);
1182
1183         /* register our message handlers */
1184         messaging_register(smbd_messaging_context(), NULL,
1185                            MSG_SMB_FORCE_TDIS, msg_force_tdis);
1186
1187         if ((lp_keepalive() != 0)
1188             && !(event_add_idle(smbd_event_context(), NULL,
1189                                 timeval_set(lp_keepalive(), 0),
1190                                 "keepalive", keepalive_fn,
1191                                 NULL))) {
1192                 DEBUG(0, ("Could not add keepalive event\n"));
1193                 exit(1);
1194         }
1195
1196         if (!(event_add_idle(smbd_event_context(), NULL,
1197                              timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1198                              "deadtime", deadtime_fn, NULL))) {
1199                 DEBUG(0, ("Could not add deadtime event\n"));
1200                 exit(1);
1201         }
1202
1203         smbd_process();
1204
1205         namecache_shutdown();
1206
1207         exit_server_cleanly(NULL);
1208         return(0);
1209 }