source3/smbd/server.c

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