/*
 *  Unix SMB/CIFS implementation.
 *
 *  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 "source3/include/includes.h"
#include <spawn.h>
#include "local_np.h"
#include "lib/async_req/async_sock.h"
#include "librpc/gen_ndr/ndr_named_pipe_auth.h"
#include "libcli/named_pipe_auth/npa_tstream.h"
#include "libcli/named_pipe_auth/tstream_u32_read.h"
#include "lib/util/tevent_unix.h"
#include "auth/auth_util.h"
#include "libcli/security/dom_sid.h"
#include "libcli/security/security_token.h"
#include "nsswitch/winbind_client.h"

/**
 * @file local_np.c
 *
 * Connect to a local named pipe by connecting to
 * samba-dcerpcd. Start samba-dcerpcd if it isn't
 * already running.
 */

extern bool override_logfile;

struct np_sock_connect_state {
	struct tevent_context *ev;
	struct samba_sockaddr addr;
	const struct named_pipe_auth_req *npa_req;
	struct named_pipe_auth_rep *npa_rep;

	DATA_BLOB npa_blob;
	struct iovec iov;

	int sock;
	struct tevent_req *subreq;
	struct tstream_context *transport;
	struct tstream_context *npa_stream;
};

static void np_sock_connect_cleanup(
	struct tevent_req *req, enum tevent_req_state req_state);
static void np_sock_connect_before(void *private_data);
static void np_sock_connect_after(void *private_data);
static void np_sock_connect_connected(struct tevent_req *subreq);
static void np_sock_connect_written(struct tevent_req *subreq);
static void np_sock_connect_read_done(struct tevent_req *subreq);

static struct tevent_req *np_sock_connect_send(
	TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	const char *sockpath,
	const struct named_pipe_auth_req *npa_req)
{
	struct tevent_req *req = NULL;
	struct np_sock_connect_state *state = NULL;
	size_t len;
	int ret;
	bool ok;

	req = tevent_req_create(mem_ctx, &state, struct np_sock_connect_state);
	if (req == NULL) {
		return NULL;
	}
	state->ev = ev;
	state->npa_req = npa_req;
	state->sock = -1;
	state->addr.u.un.sun_family = AF_UNIX;

	state->npa_rep = talloc_zero(state, struct named_pipe_auth_rep);
	if (tevent_req_nomem(state->npa_rep, req)) {
		return tevent_req_post(req, ev);
	}

	tevent_req_set_cleanup_fn(req, np_sock_connect_cleanup);

	state->addr.sa_socklen = sizeof(struct sockaddr_un);
	len = strlcpy(state->addr.u.un.sun_path,
		      sockpath,
		      sizeof(state->addr.u.un.sun_path));
	if (len >= sizeof(state->addr.u.un.sun_path)) {
		tevent_req_error(req, ENAMETOOLONG);
		return tevent_req_post(req, ev);
	}

	state->sock = socket(AF_UNIX, SOCK_STREAM, 0);
	if (state->sock == -1) {
		tevent_req_error(req, errno);
		return tevent_req_post(req, ev);
	}

	ret = set_blocking(state->sock, true);
	if (ret == -1) {
		tevent_req_error(req, errno);
		return tevent_req_post(req, ev);
	}
	ok = set_close_on_exec(state->sock);
	if (!ok) {
		tevent_req_error(req, errno);
		return tevent_req_post(req, ev);
	}

	state->subreq = async_connect_send(
		state,
		ev,
		state->sock,
		&state->addr.u.sa,
		state->addr.sa_socklen,
		np_sock_connect_before,
		np_sock_connect_after,
		NULL);
	if (tevent_req_nomem(state->subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(state->subreq, np_sock_connect_connected, req);

	return req;
}

static void np_sock_connect_cleanup(
	struct tevent_req *req, enum tevent_req_state req_state)
{
	struct np_sock_connect_state *state = tevent_req_data(
		req, struct np_sock_connect_state);

	TALLOC_FREE(state->subreq);
	TALLOC_FREE(state->transport);

	if (state->sock != -1) {
		close(state->sock);
		state->sock = -1;
	}
}

static void np_sock_connect_before(void *private_data)
{
	become_root();
}

static void np_sock_connect_after(void *private_data)
{
	unbecome_root();
}

static void np_sock_connect_connected(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct np_sock_connect_state *state = tevent_req_data(
		req, struct np_sock_connect_state);
	enum ndr_err_code ndr_err;
	int ret, err;

	SMB_ASSERT(subreq == state->subreq);

	ret = async_connect_recv(subreq, &err);
	TALLOC_FREE(subreq);
	state->subreq = NULL;
	if (ret == -1) {
		DBG_DEBUG("async_connect_recv returned %s\n", strerror(err));
		tevent_req_error(req, err);
		return;
	}

	/*
	 * As a quick workaround for bug 15310 we have done the
	 * connect in blocking mode (see np_sock_connect_send()). The
	 * rest of our code expects a nonblocking socket, activate
	 * this after the connect succeeded.
	 */
	ret = set_blocking(state->sock, false);
	if (ret == -1) {
		tevent_req_error(req, errno);
		return;
	}

	ret = tstream_bsd_existing_socket(
		state, state->sock, &state->transport);
	if (ret == -1) {
		err = errno;
		DBG_DEBUG("tstream_bsd_existing_socket failed: %s\n",
			  strerror(err));
		tevent_req_error(req, err);
		return;
	}
	state->sock = -1;

	ndr_err = ndr_push_struct_blob(
		&state->npa_blob,
		state,
		state->npa_req,
		(ndr_push_flags_fn_t)ndr_push_named_pipe_auth_req);
	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
		DBG_DEBUG("ndr_push_struct_blob failed: %s\n",
			  ndr_errstr(ndr_err));
		tevent_req_error(req, ndr_map_error2errno(ndr_err));
		return;
	}
	state->iov = (struct iovec) {
		.iov_base = state->npa_blob.data,
		.iov_len = state->npa_blob.length,
	};

	subreq = tstream_writev_send(
		state, state->ev, state->transport, &state->iov, 1);
	if (tevent_req_nomem(subreq, req)) {
		return;
	}
	tevent_req_set_callback(subreq, np_sock_connect_written, req);
}

static void np_sock_connect_written(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct np_sock_connect_state *state = tevent_req_data(
		req, struct np_sock_connect_state);
	int ret, err;

	ret = tstream_writev_recv(subreq, &err);
	TALLOC_FREE(subreq);
	if (ret == -1) {
		DBG_DEBUG("tstream_writev_recv returned %s\n", strerror(err));
		tevent_req_error(req, err);
		return;
	}

	subreq = tstream_u32_read_send(
		state, state->ev, 0x00FFFFFF, state->transport);
	if (tevent_req_nomem(subreq, req)) {
		return;
	}
	tevent_req_set_callback(subreq, np_sock_connect_read_done, req);
}

static void np_sock_connect_read_done(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct np_sock_connect_state *state = tevent_req_data(
		req, struct np_sock_connect_state);
	DATA_BLOB in;
	int ret;
	enum ndr_err_code ndr_err;

	ret = tstream_u32_read_recv(subreq, state, &in.data, &in.length);
	TALLOC_FREE(subreq);
	if (tevent_req_error(req, ret)) {
		return;
	}

	ndr_err = ndr_pull_struct_blob_all(
		&in,
		state->npa_rep,
		state->npa_rep,
		(ndr_pull_flags_fn_t)ndr_pull_named_pipe_auth_rep);
	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
		DBG_DEBUG("ndr_pull_named_pipe_auth_rep failed: %s\n",
			  ndr_errstr(ndr_err));
		tevent_req_error(req, ndr_map_error2errno(ndr_err));
		return;
	}
	if (state->npa_rep->level != 8) {
		DBG_DEBUG("npa level = %" PRIu32 ", expected 8\n",
			  state->npa_rep->level);
		tevent_req_error(req, EIO);
		return;
	}

	ret = tstream_npa_existing_stream(state,
					  &state->transport,
					  state->npa_rep->info.info8.file_type,
					  &state->npa_stream);
	if (ret == -1) {
		ret = errno;
		DBG_DEBUG("tstream_npa_existing_stream failed: %s\n",
			  strerror(ret));
		tevent_req_error(req, ret);
		return;
	}

	tevent_req_done(req);
}

static int np_sock_connect_recv(
	struct tevent_req *req,
	TALLOC_CTX *mem_ctx,
	struct tstream_context **stream)
{
	struct np_sock_connect_state *state = tevent_req_data(
		req, struct np_sock_connect_state);
	int err;

	if (tevent_req_is_unix_error(req, &err)) {
		tevent_req_received(req);
		return err;
	}
	*stream = talloc_move(mem_ctx, &state->npa_stream);
	tevent_req_received(req);
	return 0;
}

struct start_rpc_host_state {
	int ready_fd;
	struct tevent_req *read_ready_req;
};

static void start_rpc_host_cleanup(
	struct tevent_req *req, enum tevent_req_state req_state);
static void start_rpc_host_ready(struct tevent_req *subreq);

/*
 * Start samba-dcerpcd and wait for it to report ready.
 */
static struct tevent_req *start_rpc_host_send(
	TALLOC_CTX *mem_ctx, struct tevent_context *ev)
{
	struct tevent_req *req = NULL, *subreq = NULL;
	struct start_rpc_host_state *state = NULL;
	int ret;
	int ready_fds[2] = { -1, -1 };
	char **argv = NULL;
	pid_t pid;
	bool ok;

	req = tevent_req_create(
		mem_ctx, &state, struct start_rpc_host_state);
	if (req == NULL) {
		return NULL;
	}

	ret = pipe(ready_fds);
	if (ret == -1) {
		ret = errno;
		DBG_DEBUG("pipe() failed: %s\n", strerror(ret));
		goto fail;
	}

	ok = smb_set_close_on_exec(ready_fds[0]);
	if (!ok) {
		ret = errno;
		DBG_DEBUG("smb_set_close_on_exec failed: %s\n",
			  strerror(ret));
		goto fail;
	}

	argv = str_list_make_empty(mem_ctx);
	str_list_add_printf(
		&argv, "%s/samba-dcerpcd", get_dyn_SAMBA_LIBEXECDIR());
	if (!is_default_dyn_CONFIGFILE()) {
		str_list_add_printf(
			&argv, "--configfile=%s", get_dyn_CONFIGFILE());
	}
	str_list_add_printf(&argv, "--libexec-rpcds");
	str_list_add_printf(&argv, "--ready-signal-fd=%d", ready_fds[1]);
	str_list_add_printf(&argv, "--np-helper");
	str_list_add_printf(
		&argv, "--debuglevel=%d", debuglevel_get_class(DBGC_RPC_SRV));
	if (!is_default_dyn_LOGFILEBASE()) {
		str_list_add_printf(
			&argv, "--log-basename=%s", get_dyn_LOGFILEBASE());
	}
	if (argv == NULL) {
		errno = ENOMEM;
		goto fail;
	}

	become_root();
	ret = posix_spawn(&pid, argv[0], NULL, NULL, argv, environ);
	unbecome_root();
	if (ret != 0) {
		DBG_DEBUG("posix_spawn() failed: %s\n", strerror(ret));
		goto fail;
	}

	state->ready_fd = ready_fds[0];
	ready_fds[0] = -1;
	tevent_req_set_cleanup_fn(req, start_rpc_host_cleanup);

	close(ready_fds[1]);
	ready_fds[1] = -1;

	subreq = read_packet_send(state, ev, state->ready_fd, 1, NULL, NULL);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, start_rpc_host_ready, req);
	return req;

fail:
	if (ready_fds[0] != -1) {
		close(ready_fds[0]);
		ready_fds[0] = -1;
	}
	if (ready_fds[1] != -1) {
		close(ready_fds[1]);
		ready_fds[1] = -1;
	}
	tevent_req_error(req, ret);
	return tevent_req_post(req, ev);
}

static void start_rpc_host_cleanup(
	struct tevent_req *req, enum tevent_req_state req_state)
{
	struct start_rpc_host_state *state = tevent_req_data(
		req, struct start_rpc_host_state);

	if (state->ready_fd != -1) {
		close(state->ready_fd);
		state->ready_fd = -1;
	}
}

static void start_rpc_host_ready(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct start_rpc_host_state *state = tevent_req_data(
		req, struct start_rpc_host_state);
	uint8_t *buf;
	int err;
	ssize_t nread;

	nread = read_packet_recv(subreq, state, &buf, &err);
	TALLOC_FREE(subreq);
	if (nread == -1) {
		tevent_req_error(req, err);
		return;
	}

	close(state->ready_fd);
	state->ready_fd = -1;

	tevent_req_done(req);
}

static int start_rpc_host_recv(struct tevent_req *req)
{
	return tevent_req_simple_recv_unix(req);
}

struct local_np_connect_state {
	struct tevent_context *ev;
	const char *socketpath;
	struct named_pipe_auth_req *npa_req;
	struct tstream_context *npa_stream;
};

static void local_np_connect_connected(struct tevent_req *subreq);
static void local_np_connect_started(struct tevent_req *subreq);
static void local_np_connect_retried(struct tevent_req *subreq);

/**
 * @brief Async connect to a local named pipe RPC interface
 *
 * Start "samba-dcerpcd" on demand if it does not exist
 *
 * @param[in] mem_ctx  The memory context to use.
 * @param[in] ev       The tevent context to use.
 *
 * @param[in] pipename The raw pipename to connect to without path
 * @param[in] remote_client_name The client name to transmit
 * @param[in] remote_client_addr The client addr to transmit
 * @param[in] local_server_name The server name to transmit
 * @param[in] local_server_addr The server addr to transmit
 * @param[in] session_info The authorization info to use
 * @param[in] need_idle_server Does this need to be an exclusive server?
 * @return The tevent_req that was started
 */

struct tevent_req *local_np_connect_send(
	TALLOC_CTX *mem_ctx,
	struct tevent_context *ev,
	const char *pipename,
	enum dcerpc_transport_t transport,
	const char *remote_client_name,
	const struct tsocket_address *remote_client_addr,
	const char *local_server_name,
	const struct tsocket_address *local_server_addr,
	const struct auth_session_info *session_info,
	bool need_idle_server)
{
	struct tevent_req *req = NULL, *subreq = NULL;
	struct local_np_connect_state *state = NULL;
	struct named_pipe_auth_req_info8 *i8 = NULL;
	const char *socket_dir = NULL;
	char *lower_case_pipename = NULL;
	struct dom_sid npa_sid = global_sid_Samba_NPA_Flags;
	uint32_t npa_flags = 0;
	struct security_token *token = NULL;
	NTSTATUS status;
	size_t num_npa_sids;
	bool ok;

	req = tevent_req_create(
		mem_ctx, &state, struct local_np_connect_state);
	if (req == NULL) {
		return NULL;
	}
	state->ev = ev;

	num_npa_sids =
		security_token_count_flag_sids(session_info->security_token,
					       &npa_sid,
					       1,
					       NULL);
	if (num_npa_sids != 0) {
		DBG_ERR("ERROR: %zu NPA Flags SIDs have already been "
			"detected in the security token!\n",
			num_npa_sids);
		tevent_req_error(req, EACCES);
		return tevent_req_post(req, ev);
	}

	socket_dir = lp_parm_const_string(
		GLOBAL_SECTION_SNUM, "external_rpc_pipe", "socket_dir",
		lp_ncalrpc_dir());
	if (socket_dir == NULL) {
		DBG_DEBUG("external_rpc_pipe:socket_dir not set\n");
		tevent_req_error(req, EINVAL);
		return tevent_req_post(req, ev);
	}

	lower_case_pipename = strlower_talloc(state, pipename);
	if (tevent_req_nomem(lower_case_pipename, req)) {
		return tevent_req_post(req, ev);
	}

	/*
	 * Ensure we cannot process a path that exits
	 * the socket_dir.
	 */
	if (ISDOTDOT(lower_case_pipename) ||
	    (strchr(lower_case_pipename, '/')!=NULL))
	{
		DBG_DEBUG("attempt to connect to invalid pipe pathname %s\n",
			lower_case_pipename);
		tevent_req_error(req, ENOENT);
		return tevent_req_post(req, ev);
	}

	state->socketpath = talloc_asprintf(
		state, "%s/np/%s", socket_dir, lower_case_pipename);
	if (tevent_req_nomem(state->socketpath, req)) {
		return tevent_req_post(req, ev);
	}
	TALLOC_FREE(lower_case_pipename);

	state->npa_req = talloc_zero(state, struct named_pipe_auth_req);
	if (tevent_req_nomem(state->npa_req, req)) {
		return tevent_req_post(req, ev);
	}
	state->npa_req->level = 8;

	i8 = &state->npa_req->info.info8;

	i8->transport = transport;

	/* we don't have "int" in IDL, make sure we don't overflow */
	SMB_ASSERT(i8->transport == transport);

	if (remote_client_name == NULL) {
		remote_client_name = get_myname(state->npa_req);
		if (remote_client_name == NULL) {
			tevent_req_error(req, errno);
			return tevent_req_post(req, ev);
		}
	}
	i8->remote_client_name = remote_client_name;

	if (remote_client_addr == NULL) {
		struct tsocket_address *addr = NULL;
		int ret = tsocket_address_inet_from_strings(
			state->npa_req, "ip", NULL, 0, &addr);
		if (ret != 0) {
			tevent_req_error(req, errno);
			return tevent_req_post(req, ev);
		}
		remote_client_addr = addr;
	}
	i8->remote_client_addr =
		tsocket_address_inet_addr_string(remote_client_addr,
						 state->npa_req);
	if (i8->remote_client_addr == NULL) {
		tevent_req_error(req, errno);
		return tevent_req_post(req, ev);
	}
	i8->remote_client_port = tsocket_address_inet_port(remote_client_addr);

	if (local_server_name == NULL) {
		local_server_name = remote_client_name;
	}
	i8->local_server_name = local_server_name;

	if (local_server_addr == NULL) {
		struct tsocket_address *addr = NULL;
		int ret = tsocket_address_inet_from_strings(
			state->npa_req, "ip", NULL, 0, &addr);
		if (ret != 0) {
			tevent_req_error(req, errno);
			return tevent_req_post(req, ev);
		}
		local_server_addr = addr;
	}
	i8->local_server_addr =
		tsocket_address_inet_addr_string(local_server_addr,
						 state->npa_req);
	if (i8->local_server_addr == NULL) {
		tevent_req_error(req, errno);
		return tevent_req_post(req, ev);
	}
	i8->local_server_port = tsocket_address_inet_port(local_server_addr);

	i8->session_info = talloc_zero(state->npa_req,
				       struct auth_session_info_transport);
	if (tevent_req_nomem(i8->session_info, req)) {
		return tevent_req_post(req, ev);
	}

	i8->session_info->session_info =
		copy_session_info(i8->session_info, session_info);
	if (tevent_req_nomem(i8->session_info->session_info, req)) {
		return tevent_req_post(req, ev);
	}

	if (need_idle_server) {
		npa_flags |= SAMBA_NPA_FLAGS_NEED_IDLE;
	}

	ok = winbind_env_set();
	if (ok) {
		npa_flags |= SAMBA_NPA_FLAGS_WINBIND_OFF;
	}

	ok = sid_append_rid(&npa_sid, npa_flags);
	if (!ok) {
		tevent_req_error(req, EINVAL);
		return tevent_req_post(req, ev);
	}

	token = i8->session_info->session_info->security_token;

	status = add_sid_to_array_unique(token,
					 &npa_sid,
					 &token->sids,
					 &token->num_sids);
	if (!NT_STATUS_IS_OK(status)) {
		tevent_req_oom(req);
		return tevent_req_post(req, ev);
	}

	subreq = np_sock_connect_send(
		state, state->ev, state->socketpath, state->npa_req);
	if (tevent_req_nomem(subreq, req)) {
		return tevent_req_post(req, ev);
	}
	tevent_req_set_callback(subreq, local_np_connect_connected, req);

	return req;
}

static void local_np_connect_connected(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct local_np_connect_state *state = tevent_req_data(
		req, struct local_np_connect_state);
	int ret;

	ret = np_sock_connect_recv(subreq, state, &state->npa_stream);
	TALLOC_FREE(subreq);

	if (ret == 0) {
		tevent_req_done(req);
		return;
	}

	DBG_DEBUG("np_sock_connect failed: %s\n", strerror(ret));

	if (!lp_rpc_start_on_demand_helpers()) {
		/*
		 * samba-dcerpcd should already be started in
		 * daemon/standalone mode when "rpc start on demand
		 * helpers = false". We are prohibited from starting
		 * on demand as a named-pipe helper.
		 */
		DBG_ERR("Can't connect to a running samba-dcerpcd. smb.conf "
			"config prohibits starting as named pipe helper as "
			"the [global] section contains "
			"\"rpc start on demand helpers = false\".\n");
		tevent_req_error(req, ret);
		return;
	}

	/*
	 * samba-dcerpcd isn't running. We need to start it.
	 * Note if it doesn't start we treat this as a fatal
	 * error for connecting to the named pipe and don't
	 * keep trying to restart for this connection.
	 */
	subreq = start_rpc_host_send(state, state->ev);
	if (tevent_req_nomem(subreq, req)) {
		return;
	}
	tevent_req_set_callback(subreq, local_np_connect_started, req);
}

static void local_np_connect_started(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct local_np_connect_state *state = tevent_req_data(
		req, struct local_np_connect_state);
	int ret;

	ret = start_rpc_host_recv(subreq);
	TALLOC_FREE(subreq);
	if (tevent_req_error(req, ret)) {
		DBG_DEBUG("start_rpc_host_recv failed: %s\n",
			  strerror(ret));
		return;
	}

	subreq = np_sock_connect_send(
		state, state->ev, state->socketpath, state->npa_req);
	if (tevent_req_nomem(subreq, req)) {
		return;
	}
	tevent_req_set_callback(subreq, local_np_connect_retried, req);
}

static void local_np_connect_retried(struct tevent_req *subreq)
{
	struct tevent_req *req = tevent_req_callback_data(
		subreq, struct tevent_req);
	struct local_np_connect_state *state = tevent_req_data(
		req, struct local_np_connect_state);
	int ret;

	ret = np_sock_connect_recv(subreq, state, &state->npa_stream);
	TALLOC_FREE(subreq);
	if (tevent_req_error(req, ret)) {
		return;
	}
	tevent_req_done(req);
}

/**
 * @brief Receive handle to a local named pipe RPC interface
 *
 * @param[in] req The tevent_req that started the operation
 * @param[in] ev      The tevent context to use.
 * @param[in] mem_ctx The memory context to put pstream on
 * @param[out] pstream The established connection to the RPC server
 *
 * @return 0/errno
 */

int local_np_connect_recv(
	struct tevent_req *req,
	TALLOC_CTX *mem_ctx,
	struct tstream_context **pstream)
{
	struct local_np_connect_state *state = tevent_req_data(
		req, struct local_np_connect_state);
	int err;

	if (tevent_req_is_unix_error(req, &err)) {
		tevent_req_received(req);
		return err;
	}

	*pstream = talloc_move(mem_ctx, &state->npa_stream);
	return 0;
}

/**
 * @brief Sync connect to a local named pipe RPC interface
 *
 * Start "samba-dcerpcd" on demand if it does not exist
 *
 * @param[in] pipename The raw pipename to connect to without path
 * @param[in] remote_client_name The client name to transmit
 * @param[in] remote_client_addr The client addr to transmit
 * @param[in] local_server_name The server name to transmit
 * @param[in] local_server_addr The server addr to transmit
 * @param[in] session_info The authorization info to use
 * @param[in] need_idle_server Does this need to be an exclusive server?
 * @param[in] mem_ctx  The memory context to use.
 * @param[out] pstream The established connection to the RPC server
 * @return 0/errno
 */

int local_np_connect(
	const char *pipename,
	enum dcerpc_transport_t transport,
	const char *remote_client_name,
	const struct tsocket_address *remote_client_addr,
	const char *local_server_name,
	const struct tsocket_address *local_server_addr,
	const struct auth_session_info *session_info,
	bool need_idle_server,
	TALLOC_CTX *mem_ctx,
	struct tstream_context **pstream)
{
	struct tevent_context *ev = NULL;
	struct tevent_req *req = NULL;
	int ret = ENOMEM;

	ev = samba_tevent_context_init(mem_ctx);
	if (ev == NULL) {
		goto fail;
	}
	req = local_np_connect_send(
		ev,
		ev,
		pipename,
		transport,
		remote_client_name,
		remote_client_addr,
		local_server_name,
		local_server_addr,
		session_info,
		need_idle_server);
	if (req == NULL) {
		goto fail;
	}
	if (!tevent_req_poll_unix(req, ev, &ret)) {
		goto fail;
	}
	ret = local_np_connect_recv(req, mem_ctx, pstream);
 fail:
	TALLOC_FREE(req);
	TALLOC_FREE(ev);
	return ret;
}