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