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