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