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