s3-mdssvc: add mdssd RPC service daemon for mdssvc
authorRalph Boehme <rb@sernet.de>
Mon, 11 Aug 2014 20:29:09 +0000 (22:29 +0200)
committerRalph Böhme <slow@samba.org>
Tue, 7 Jul 2015 15:34:28 +0000 (17:34 +0200)
Signed-off-by: Ralph Boehme <slow@samba.org>
Reviewed-by: Stefan Metzmacher <metze@samba.org>
source3/rpc_server/mdssd.c [new file with mode: 0644]
source3/rpc_server/rpc_config.h
source3/rpc_server/rpc_service_setup.c
source3/rpc_server/wscript_build
source3/smbd/server.c
source3/wscript_build

diff --git a/source3/rpc_server/mdssd.c b/source3/rpc_server/mdssd.c
new file mode 100644 (file)
index 0000000..fac386b
--- /dev/null
@@ -0,0 +1,753 @@
+/*
+ *  Unix SMB/CIFS implementation.
+ *
+ *  mds service daemon
+ *
+ *  Copyright (c) 2014      Ralph Boehme <rb@sernet.de>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "includes.h"
+#include "serverid.h"
+#include "messages.h"
+#include "ntdomain.h"
+
+#include "lib/util/util_process.h"
+
+#include "lib/id_cache.h"
+
+#include "../lib/tsocket/tsocket.h"
+#include "lib/server_prefork.h"
+#include "lib/server_prefork_util.h"
+#include "librpc/rpc/dcerpc_ep.h"
+
+#include "rpc_server/rpc_server.h"
+#include "rpc_server/rpc_ep_register.h"
+#include "rpc_server/rpc_sock_helper.h"
+
+#include "librpc/gen_ndr/srv_mdssvc.h"
+#include "rpc_server/mdssvc/srv_mdssvc_nt.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_RPC_SRV
+
+#define DAEMON_NAME "mdssd"
+#define MDSSD_MAX_SOCKETS 64
+
+static struct server_id parent_id;
+static struct prefork_pool *mdssd_pool = NULL;
+static int mdssd_child_id = 0;
+
+static struct pf_daemon_config default_pf_mdssd_cfg = {
+       .prefork_status = PFH_INIT,
+       .min_children = 5,
+       .max_children = 25,
+       .spawn_rate = 5,
+       .max_allowed_clients = 1000,
+       .child_min_life = 60 /* 1 minute minimum life time */
+};
+static struct pf_daemon_config pf_mdssd_cfg = { 0 };
+
+void start_mdssd(struct tevent_context *ev_ctx,
+                struct messaging_context *msg_ctx);
+
+static void mdssd_smb_conf_updated(struct messaging_context *msg,
+                                  void *private_data,
+                                  uint32_t msg_type,
+                                  struct server_id server_id,
+                                  DATA_BLOB *data)
+{
+       struct tevent_context *ev_ctx;
+
+       DEBUG(10, ("Got message saying smb.conf was updated. Reloading.\n"));
+       ev_ctx = talloc_get_type_abort(private_data, struct tevent_context);
+
+       change_to_root_user();
+       lp_load_global(get_dyn_CONFIGFILE());
+
+       reopen_logs();
+       if (mdssd_child_id == 0) {
+               pfh_daemon_config(DAEMON_NAME,
+                                 &pf_mdssd_cfg,
+                                 &default_pf_mdssd_cfg);
+               pfh_manage_pool(ev_ctx, msg, &pf_mdssd_cfg, mdssd_pool);
+       }
+}
+
+static void mdssd_sig_term_handler(struct tevent_context *ev,
+                                  struct tevent_signal *se,
+                                  int signum,
+                                  int count,
+                                  void *siginfo,
+                                  void *private_data)
+{
+       rpc_mdssvc_shutdown();
+
+       DEBUG(0, ("termination signal\n"));
+       exit(0);
+}
+
+static void mdssd_setup_sig_term_handler(struct tevent_context *ev_ctx)
+{
+       struct tevent_signal *se;
+
+       se = tevent_add_signal(ev_ctx,
+                              ev_ctx,
+                              SIGTERM, 0,
+                              mdssd_sig_term_handler,
+                              NULL);
+       if (!se) {
+               DEBUG(0, ("failed to setup SIGTERM handler\n"));
+               exit(1);
+       }
+}
+
+static void mdssd_sig_hup_handler(struct tevent_context *ev,
+                                 struct tevent_signal *se,
+                                 int signum,
+                                 int count,
+                                 void *siginfo,
+                                 void *pvt)
+{
+
+       change_to_root_user();
+       lp_load_global(get_dyn_CONFIGFILE());
+
+       reopen_logs();
+       pfh_daemon_config(DAEMON_NAME,
+                         &pf_mdssd_cfg,
+                         &default_pf_mdssd_cfg);
+
+       /* relay to all children */
+       prefork_send_signal_to_all(mdssd_pool, SIGHUP);
+}
+
+static void mdssd_setup_sig_hup_handler(struct tevent_context *ev_ctx)
+{
+       struct tevent_signal *se;
+
+       se = tevent_add_signal(ev_ctx,
+                              ev_ctx,
+                              SIGHUP, 0,
+                              mdssd_sig_hup_handler,
+                              NULL);
+       if (!se) {
+               DEBUG(0, ("failed to setup SIGHUP handler\n"));
+               exit(1);
+       }
+}
+
+/**********************************************************
+ * Children
+ **********************************************************/
+
+static void mdssd_chld_sig_hup_handler(struct tevent_context *ev,
+                                      struct tevent_signal *se,
+                                      int signum,
+                                      int count,
+                                      void *siginfo,
+                                      void *pvt)
+{
+       change_to_root_user();
+       reopen_logs();
+}
+
+static bool mdssd_setup_chld_hup_handler(struct tevent_context *ev_ctx)
+{
+       struct tevent_signal *se;
+
+       se = tevent_add_signal(ev_ctx,
+                              ev_ctx,
+                              SIGHUP, 0,
+                              mdssd_chld_sig_hup_handler,
+                              NULL);
+       if (!se) {
+               DEBUG(1, ("failed to setup SIGHUP handler"));
+               return false;
+       }
+
+       return true;
+}
+
+static void parent_ping(struct messaging_context *msg_ctx,
+                       void *private_data,
+                       uint32_t msg_type,
+                       struct server_id server_id,
+                       DATA_BLOB *data)
+{
+       /*
+        * The fact we received this message is enough to let make the
+        * event loop if it was idle. mdssd_children_main will cycle
+        * through mdssd_next_client at least once. That function will
+        * take whatever action is necessary
+        */
+       DEBUG(10, ("Got message that the parent changed status.\n"));
+       return;
+}
+
+static bool mdssd_child_init(struct tevent_context *ev_ctx,
+                            int child_id,
+                            struct pf_worker_data *pf)
+{
+       NTSTATUS status;
+       struct messaging_context *msg_ctx = server_messaging_context();
+       bool ok;
+
+       status = reinit_after_fork(msg_ctx, ev_ctx,
+                                  true);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(0,("reinit_after_fork() failed\n"));
+               smb_panic("reinit_after_fork() failed");
+       }
+
+       prctl_set_comment("mdssd-child");
+
+       mdssd_child_id = child_id;
+       reopen_logs();
+
+       ok = mdssd_setup_chld_hup_handler(ev_ctx);
+       if (!ok) {
+               return false;
+       }
+
+       if (!serverid_register(messaging_server_id(msg_ctx),
+                              FLAG_MSG_GENERAL)) {
+               return false;
+       }
+
+       messaging_register(msg_ctx, ev_ctx,
+                          MSG_SMB_CONF_UPDATED, mdssd_smb_conf_updated);
+       messaging_register(msg_ctx, ev_ctx,
+                          MSG_PREFORK_PARENT_EVENT, parent_ping);
+
+       status = rpc_mdssvc_init(NULL);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(0, ("Failed to intialize RPC: %s\n",
+                         nt_errstr(status)));
+               return false;
+       }
+
+       return true;
+}
+
+struct mdssd_children_data {
+       struct tevent_context *ev_ctx;
+       struct messaging_context *msg_ctx;
+       struct pf_worker_data *pf;
+       int listen_fd_size;
+       int *listen_fds;
+};
+
+static void mdssd_next_client(void *pvt);
+
+static int mdssd_children_main(struct tevent_context *ev_ctx,
+                              struct messaging_context *msg_ctx,
+                              struct pf_worker_data *pf,
+                              int child_id,
+                              int listen_fd_size,
+                              int *listen_fds,
+                              void *private_data)
+{
+       struct mdssd_children_data *data;
+       bool ok;
+       int ret = 0;
+
+       ok = mdssd_child_init(ev_ctx, child_id, pf);
+       if (!ok) {
+               return 1;
+       }
+
+       data = talloc(ev_ctx, struct mdssd_children_data);
+       if (!data) {
+               return 1;
+       }
+       data->pf = pf;
+       data->ev_ctx = ev_ctx;
+       data->msg_ctx = msg_ctx;
+       data->listen_fd_size = listen_fd_size;
+       data->listen_fds = listen_fds;
+
+       /* loop until it is time to exit */
+       while (pf->status != PF_WORKER_EXITING) {
+               /* try to see if it is time to schedule the next client */
+               mdssd_next_client(data);
+
+               ret = tevent_loop_once(ev_ctx);
+               if (ret != 0) {
+                       DEBUG(0, ("tevent_loop_once() exited with %d: %s\n",
+                                 ret, strerror(errno)));
+                       pf->status = PF_WORKER_EXITING;
+               }
+       }
+
+       return ret;
+}
+
+static void mdssd_client_terminated(void *pvt)
+{
+       struct mdssd_children_data *data;
+
+       data = talloc_get_type_abort(pvt, struct mdssd_children_data);
+
+       pfh_client_terminated(data->pf);
+
+       mdssd_next_client(pvt);
+}
+
+struct mdssd_new_client {
+       struct mdssd_children_data *data;
+};
+
+static void mdssd_handle_client(struct tevent_req *req);
+
+static void mdssd_next_client(void *pvt)
+{
+       struct tevent_req *req;
+       struct mdssd_children_data *data;
+       struct mdssd_new_client *next;
+
+       data = talloc_get_type_abort(pvt, struct mdssd_children_data);
+
+       if (!pfh_child_allowed_to_accept(data->pf)) {
+               /* nothing to do for now we are already listening
+                * or we are not allowed to listen further */
+               return;
+       }
+
+       next = talloc_zero(data, struct mdssd_new_client);
+       if (!next) {
+               DEBUG(1, ("Out of memory!?\n"));
+               return;
+       }
+       next->data = data;
+
+       req = prefork_listen_send(next,
+                                 data->ev_ctx,
+                                 data->pf,
+                                 data->listen_fd_size,
+                                 data->listen_fds);
+       if (!req) {
+               DEBUG(1, ("Failed to make listening request!?\n"));
+               talloc_free(next);
+               return;
+       }
+       tevent_req_set_callback(req, mdssd_handle_client, next);
+}
+
+static void mdssd_handle_client(struct tevent_req *req)
+{
+       struct mdssd_children_data *data;
+       struct mdssd_new_client *client;
+       const DATA_BLOB ping = data_blob_null;
+       int rc;
+       int sd;
+       TALLOC_CTX *tmp_ctx;
+       struct tsocket_address *srv_addr;
+       struct tsocket_address *cli_addr;
+
+       client = tevent_req_callback_data(req, struct mdssd_new_client);
+       data = client->data;
+
+       tmp_ctx = talloc_stackframe();
+       if (tmp_ctx == NULL) {
+               DEBUG(1, ("Failed to allocate stackframe!\n"));
+               return;
+       }
+
+       rc = prefork_listen_recv(req,
+                                tmp_ctx,
+                                &sd,
+                                &srv_addr,
+                                &cli_addr);
+
+       /* this will free the request too */
+       talloc_free(client);
+
+       if (rc != 0) {
+               DEBUG(6, ("No client connection was available after all!\n"));
+               goto done;
+       }
+
+       /* Warn parent that our status changed */
+       messaging_send(data->msg_ctx, parent_id,
+                       MSG_PREFORK_CHILD_EVENT, &ping);
+
+       DEBUG(2, ("mdssd preforked child %d got client connection!\n",
+                 (int)(data->pf->pid)));
+
+       if (tsocket_address_is_inet(srv_addr, "ip")) {
+               DEBUG(3, ("Got a tcpip client connection from %s on inteface %s\n",
+                          tsocket_address_string(cli_addr, tmp_ctx),
+                          tsocket_address_string(srv_addr, tmp_ctx)));
+
+               dcerpc_ncacn_accept(data->ev_ctx,
+                                   data->msg_ctx,
+                                   NCACN_IP_TCP,
+                                   "IP",
+                                   cli_addr,
+                                   srv_addr,
+                                   sd,
+                                   NULL);
+       } else if (tsocket_address_is_unix(srv_addr)) {
+               const char *p;
+               const char *b;
+
+               p = tsocket_address_unix_path(srv_addr, tmp_ctx);
+               if (p == NULL) {
+                       talloc_free(tmp_ctx);
+                       return;
+               }
+
+               b = strrchr(p, '/');
+               if (b != NULL) {
+                       b++;
+               } else {
+                       b = p;
+               }
+
+               if (strstr(p, "/np/")) {
+                       named_pipe_accept_function(data->ev_ctx,
+                                                  data->msg_ctx,
+                                                  b,
+                                                  sd,
+                                                  mdssd_client_terminated,
+                                                  data);
+               } else {
+                       dcerpc_ncacn_accept(data->ev_ctx,
+                                           data->msg_ctx,
+                                           NCALRPC,
+                                           b,
+                                           cli_addr,
+                                           srv_addr,
+                                           sd,
+                                           NULL);
+               }
+       } else {
+               DEBUG(0, ("ERROR: Unsupported socket!\n"));
+       }
+
+done:
+       talloc_free(tmp_ctx);
+}
+
+/*
+ * MAIN
+ */
+
+static void child_ping(struct messaging_context *msg_ctx,
+                       void *private_data,
+                       uint32_t msg_type,
+                       struct server_id server_id,
+                       DATA_BLOB *data)
+{
+       struct tevent_context *ev_ctx;
+
+       ev_ctx = talloc_get_type_abort(private_data, struct tevent_context);
+
+       DEBUG(10, ("Got message that a child changed status.\n"));
+       pfh_manage_pool(ev_ctx, msg_ctx, &pf_mdssd_cfg, mdssd_pool);
+}
+
+static bool mdssd_schedule_check(struct tevent_context *ev_ctx,
+                                struct messaging_context *msg_ctx,
+                                struct timeval current_time);
+
+static void mdssd_check_children(struct tevent_context *ev_ctx,
+                                   struct tevent_timer *te,
+                                   struct timeval current_time,
+                                   void *pvt);
+
+static void mdssd_sigchld_handler(struct tevent_context *ev_ctx,
+                                 struct prefork_pool *pfp,
+                                 void *pvt)
+{
+       struct messaging_context *msg_ctx;
+
+       msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
+
+       /* run pool management so we can fork/retire or increase
+        * the allowed connections per child based on load */
+       pfh_manage_pool(ev_ctx, msg_ctx, &pf_mdssd_cfg, mdssd_pool);
+}
+
+static bool mdssd_setup_children_monitor(struct tevent_context *ev_ctx,
+                                        struct messaging_context *msg_ctx)
+{
+       bool ok;
+
+       /* add our oun sigchld callback */
+       prefork_set_sigchld_callback(mdssd_pool, mdssd_sigchld_handler, msg_ctx);
+
+       ok = mdssd_schedule_check(ev_ctx, msg_ctx, tevent_timeval_current());
+
+       return ok;
+}
+
+static bool mdssd_schedule_check(struct tevent_context *ev_ctx,
+                                struct messaging_context *msg_ctx,
+                                struct timeval current_time)
+{
+       struct tevent_timer *te;
+       struct timeval next_event;
+
+       /* check situation again in 10 seconds */
+       next_event = tevent_timeval_current_ofs(10, 0);
+
+       /* TODO: check when the socket becomes readable, so that children
+        * are checked only when there is some activity ? */
+       te = tevent_add_timer(ev_ctx, mdssd_pool, next_event,
+                             mdssd_check_children, msg_ctx);
+       if (!te) {
+               DEBUG(2, ("Failed to set up children monitoring!\n"));
+               return false;
+       }
+
+       return true;
+}
+
+static void mdssd_check_children(struct tevent_context *ev_ctx,
+                                struct tevent_timer *te,
+                                struct timeval current_time,
+                                void *pvt)
+{
+       struct messaging_context *msg_ctx;
+
+       msg_ctx = talloc_get_type_abort(pvt, struct messaging_context);
+
+       pfh_manage_pool(ev_ctx, msg_ctx, &pf_mdssd_cfg, mdssd_pool);
+
+       mdssd_schedule_check(ev_ctx, msg_ctx, current_time);
+}
+
+/*
+ * start it up
+ */
+
+static bool mdssd_create_sockets(struct tevent_context *ev_ctx,
+                                struct messaging_context *msg_ctx,
+                                int *listen_fd,
+                                int *listen_fd_size)
+{
+       struct dcerpc_binding_vector *v, *v_orig;
+       TALLOC_CTX *tmp_ctx;
+       NTSTATUS status;
+       int fd = -1;
+       int rc;
+       bool ok = false;
+
+       tmp_ctx = talloc_stackframe();
+       if (tmp_ctx == NULL) {
+               return false;
+       }
+
+       status = dcerpc_binding_vector_new(tmp_ctx, &v_orig);
+       if (!NT_STATUS_IS_OK(status)) {
+               goto done;
+       }
+
+       /* mdssvc */
+       fd = create_named_pipe_socket("mdssvc");
+       if (fd < 0) {
+               goto done;
+       }
+
+       rc = listen(fd, pf_mdssd_cfg.max_allowed_clients);
+       if (rc == -1) {
+               goto done;
+       }
+       listen_fd[*listen_fd_size] = fd;
+       (*listen_fd_size)++;
+
+       fd = create_dcerpc_ncalrpc_socket("mdssvc");
+       if (fd < 0) {
+               goto done;
+       }
+
+       rc = listen(fd, pf_mdssd_cfg.max_allowed_clients);
+       if (rc == -1) {
+               goto done;
+       }
+       listen_fd[*listen_fd_size] = fd;
+       (*listen_fd_size)++;
+       fd = -1;
+
+       v = dcerpc_binding_vector_dup(tmp_ctx, v_orig);
+       if (v == NULL) {
+               goto done;
+       }
+
+       status = dcerpc_binding_vector_replace_iface(&ndr_table_mdssvc, v);
+       if (!NT_STATUS_IS_OK(status)) {
+               goto done;
+       }
+
+       status = dcerpc_binding_vector_add_np_default(&ndr_table_mdssvc, v);
+       if (!NT_STATUS_IS_OK(status)) {
+               goto done;
+       }
+
+       status = dcerpc_binding_vector_add_unix(&ndr_table_mdssvc, v, "mdssvc");
+       if (!NT_STATUS_IS_OK(status)) {
+               goto done;
+       }
+
+       ok = true;
+done:
+       if (fd != -1) {
+               close(fd);
+       }
+       talloc_free(tmp_ctx);
+       return ok;
+}
+
+static bool mdssvc_init_cb(void *ptr)
+{
+       struct messaging_context *msg_ctx =
+               talloc_get_type_abort(ptr, struct messaging_context);
+       bool ok;
+
+       ok = init_service_mdssvc(msg_ctx);
+       if (!ok) {
+               return false;
+       }
+
+       return true;
+}
+
+static bool mdssvc_shutdown_cb(void *ptr)
+{
+       shutdown_service_mdssvc();
+
+       return true;
+}
+
+void start_mdssd(struct tevent_context *ev_ctx,
+                struct messaging_context *msg_ctx)
+{
+       NTSTATUS status;
+       int listen_fd[MDSSD_MAX_SOCKETS];
+       int listen_fd_size = 0;
+       pid_t pid;
+       int rc;
+       bool ok;
+       struct rpc_srv_callbacks mdssvc_cb;
+
+       DEBUG(1, ("Forking Metadata Service Daemon\n"));
+
+       /*
+        * Block signals before forking child as it will have to
+        * set its own handlers. Child will re-enable SIGHUP as
+        * soon as the handlers are set up.
+        */
+       BlockSignals(true, SIGTERM);
+       BlockSignals(true, SIGHUP);
+
+       pid = fork();
+       if (pid == -1) {
+               DEBUG(0, ("Failed to fork mdssd [%s], aborting ...\n",
+                          strerror(errno)));
+               exit(1);
+       }
+
+       /* parent or error */
+       if (pid != 0) {
+
+               /* Re-enable SIGHUP before returnig */
+               BlockSignals(false, SIGTERM);
+               BlockSignals(false, SIGHUP);
+
+               return;
+       }
+
+       status = reinit_after_fork(msg_ctx,
+                                  ev_ctx,
+                                  true);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(0,("reinit_after_fork() failed\n"));
+               smb_panic("reinit_after_fork() failed");
+       }
+
+       prctl_set_comment("mdssd-master");
+       reopen_logs();
+
+       /* save the parent process id so the children can use it later */
+       parent_id = messaging_server_id(msg_ctx);
+
+       pfh_daemon_config(DAEMON_NAME,
+                         &pf_mdssd_cfg,
+                         &default_pf_mdssd_cfg);
+
+       mdssd_setup_sig_term_handler(ev_ctx);
+       mdssd_setup_sig_hup_handler(ev_ctx);
+
+       BlockSignals(false, SIGTERM);
+       BlockSignals(false, SIGHUP);
+
+       ok = mdssd_create_sockets(ev_ctx, msg_ctx, listen_fd, &listen_fd_size);
+       if (!ok) {
+               exit(1);
+       }
+
+       /* start children before any more initialization is done */
+       ok = prefork_create_pool(ev_ctx, /* mem_ctx */
+                                ev_ctx,
+                                msg_ctx,
+                                listen_fd_size,
+                                listen_fd,
+                                pf_mdssd_cfg.min_children,
+                                pf_mdssd_cfg.max_children,
+                                &mdssd_children_main,
+                                NULL,
+                                &mdssd_pool);
+       if (!ok) {
+               exit(1);
+       }
+
+       if (!serverid_register(messaging_server_id(msg_ctx),
+                              FLAG_MSG_GENERAL)) {
+               exit(1);
+       }
+
+       messaging_register(msg_ctx,
+                          ev_ctx,
+                          MSG_SMB_CONF_UPDATED,
+                          mdssd_smb_conf_updated);
+       messaging_register(msg_ctx, ev_ctx,
+                          MSG_PREFORK_CHILD_EVENT, child_ping);
+
+       mdssvc_cb.init         = mdssvc_init_cb;
+       mdssvc_cb.shutdown     = mdssvc_shutdown_cb;
+       mdssvc_cb.private_data = msg_ctx;
+
+       status = rpc_mdssvc_init(&mdssvc_cb);
+       if (!NT_STATUS_IS_OK(status)) {
+               exit(1);
+       }
+
+       ok = mdssd_setup_children_monitor(ev_ctx, msg_ctx);
+       if (!ok) {
+               exit(1);
+       }
+
+       DEBUG(1, ("mdssd Daemon Started (%u)\n", (unsigned int)getpid()));
+
+       /* loop forever */
+       rc = tevent_loop_wait(ev_ctx);
+
+       /* should not be reached */
+       DEBUG(0,("mdssd: tevent_loop_wait() exited with %d - %s\n",
+                rc, (rc == 0) ? "out of events" : strerror(errno)));
+       exit(1);
+}
index ab5e3a4b0d133e7c9da4950d9ad38cad7c313fcc..50917042fe66125d3ec90c1c3c5779bf29114da0 100644 (file)
@@ -44,6 +44,7 @@ enum rpc_service_mode_e rpc_service_mode(const char *name);
 #define rpc_samr_mode() rpc_service_mode("samr")
 #define rpc_netlogon_mode() rpc_service_mode("netlogon")
 #define rpc_fssagentrpc_mode() rpc_service_mode("fssagentrpc")
+#define rpc_mdssvc_mode() rpc_service_mode("mdssvc")
 
 
 
@@ -66,5 +67,6 @@ enum rpc_daemon_type_e rpc_daemon_type(const char *name);
 #define rpc_spoolss_daemon() rpc_daemon_type("spoolssd")
 #define rpc_lsasd_daemon() rpc_daemon_type("lsasd")
 #define rpc_fss_daemon() rpc_daemon_type("fssd")
+#define rpc_mdssd_daemon() rpc_daemon_type("mdssd")
 
 #endif /* _RPC_CONFIG_H */
index f0624978926d67545e7e5363dfeaffc4a42a491e..ee995a805d161e9e1c73283f00ca49746b15564a 100644 (file)
@@ -475,7 +475,10 @@ static bool rpc_setup_mdssvc(struct tevent_context *ev_ctx,
        struct rpc_srv_callbacks mdssvc_cb;
        NTSTATUS status;
        enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
-       if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
+       enum rpc_daemon_type_e mdssvc_type = rpc_mdssd_daemon();
+
+       if (service_mode != RPC_SERVICE_MODE_EMBEDDED
+           || mdssvc_type != RPC_DAEMON_EMBEDDED) {
                return true;
        }
 
index 99e2b0626954db41f2f4abc622801fb0d3dd4feb..278e0bd924a3ac290131e6cae71f1b1589d7fdf6 100755 (executable)
@@ -186,3 +186,8 @@ bld.SAMBA3_SUBSYSTEM('LSASD',
 bld.SAMBA3_SUBSYSTEM('FSSD',
                     source='fssd.c',
                     deps='samba-util')
+
+bld.SAMBA3_SUBSYSTEM('MDSSD',
+                    source='mdssd.c',
+                    deps='RPC_SOCK_HELPER samba-util',
+                    enabled=bld.env.with_spotlight)
index 20aed163ba278f39e1283b0cd5bda5e43005fe7d..0ebaf85c050f7322648437ce2c54e0967e4616ea 100644 (file)
@@ -90,6 +90,9 @@ extern void start_lsasd(struct tevent_context *ev_ctx,
 extern void start_fssd(struct tevent_context *ev_ctx,
                       struct messaging_context *msg_ctx);
 
+extern void start_mdssd(struct tevent_context *ev_ctx,
+                       struct messaging_context *msg_ctx);
+
 #ifdef WITH_DFS
 extern int dcelogin_atmost_once;
 #endif /* WITH_DFS */
@@ -1586,6 +1589,13 @@ extern void build_options(bool screen);
                                exit_daemon("Samba failed to init printing subsystem", EACCES);
                        }
                }
+
+#ifdef WITH_SPOTLIGHT
+               if ((rpc_mdssvc_mode() == RPC_SERVICE_MODE_EXTERNAL) &&
+                   (rpc_mdssd_daemon() == RPC_DAEMON_FORK)) {
+                       start_mdssd(ev_ctx, msg_ctx);
+               }
+#endif
        } else if (!lp__disable_spoolss() &&
                   (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
                if (!printing_subsystem_init(ev_ctx, msg_ctx, false, false)) {
index 79a0158218e34483038af234de717c99b8440849..67b6c8d96db6d6d3a59e30ea615bcab6171b27d6 100755 (executable)
@@ -857,7 +857,7 @@ bld.SAMBA3_SUBSYSTEM('LIBLSA',
 
 bld.SAMBA3_BINARY('smbd/smbd',
                  source='smbd/server.c',
-                 deps='smbd_base EPMD LSASD FSSD',
+                 deps='smbd_base EPMD LSASD FSSD MDSSD',
                  install_path='${SBINDIR}')
 
 bld.SAMBA3_BINARY('nmbd/nmbd',