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