source3/smbd/server.c

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