{ PIPE_SRVSVC, &ndr_table_srvsvc.syntax_id },
{ PIPE_WKSSVC, &ndr_table_wkssvc.syntax_id },
{ PIPE_WINREG, &ndr_table_winreg.syntax_id },
- { PIPE_SPOOLSS, &syntax_spoolss },
+ { PIPE_SPOOLSS, &ndr_table_spoolss.syntax_id },
{ PIPE_NETDFS, &ndr_table_netdfs.syntax_id },
{ PIPE_ECHO, &ndr_table_rpcecho.syntax_id },
{ PIPE_SHUTDOWN, &ndr_table_initshutdown.syntax_id },
Return the pipe name from the interface.
****************************************************************************/
-const char *cli_get_pipe_name_from_iface(TALLOC_CTX *mem_ctx,
- struct cli_state *cli,
- const struct ndr_syntax_id *interface)
+const char *get_pipe_name_from_iface(const struct ndr_syntax_id *interface)
{
+ char *guid_str;
+ const char *result;
int i;
for (i = 0; pipe_names[i].client_pipe; i++) {
if (ndr_syntax_id_equal(pipe_names[i].abstr_syntax,
* interested in the known pipes mentioned in pipe_names[]
*/
- return NULL;
+ guid_str = GUID_string(talloc_tos(), &interface->uuid);
+ if (guid_str == NULL) {
+ return NULL;
+ }
+ result = talloc_asprintf(talloc_tos(), "Interface %s.%d", guid_str,
+ (int)interface->if_version);
+ TALLOC_FREE(guid_str);
+
+ if (result == NULL) {
+ return "PIPE";
+ }
+ return result;
}
/********************************************************************
/********************************************************************
Pipe description for a DEBUG
********************************************************************/
-static char *rpccli_pipe_txt(TALLOC_CTX *mem_ctx, struct rpc_pipe_client *cli)
+static const char *rpccli_pipe_txt(TALLOC_CTX *mem_ctx,
+ struct rpc_pipe_client *cli)
{
- char *result;
-
- switch (cli->transport_type) {
- case NCACN_NP:
- result = talloc_asprintf(mem_ctx, "host %s, pipe %s, "
- "fnum 0x%x",
- cli->desthost,
- cli->trans.np.pipe_name,
- (unsigned int)(cli->trans.np.fnum));
- break;
- case NCACN_IP_TCP:
- case NCACN_UNIX_STREAM:
- result = talloc_asprintf(mem_ctx, "host %s, fd %d",
- cli->desthost, cli->trans.sock.fd);
- break;
- default:
- result = talloc_asprintf(mem_ctx, "host %s", cli->desthost);
- break;
+ char *result = talloc_asprintf(mem_ctx, "host %s", cli->desthost);
+ if (result == NULL) {
+ return "pipe";
}
- SMB_ASSERT(result != NULL);
return result;
}
struct rpc_read_state {
struct event_context *ev;
- struct rpc_pipe_client *cli;
- char *data;
+ struct rpc_cli_transport *transport;
+ uint8_t *data;
size_t size;
size_t num_read;
};
-static void rpc_read_np_done(struct async_req *subreq);
-static void rpc_read_sock_done(struct async_req *subreq);
+static void rpc_read_done(struct async_req *subreq);
-static struct async_req *rpc_read_send(TALLOC_CTX *mem_ctx,
- struct event_context *ev,
- struct rpc_pipe_client *cli,
- char *data, size_t size)
+static struct tevent_req *rpc_read_send(TALLOC_CTX *mem_ctx,
+ struct event_context *ev,
+ struct rpc_cli_transport *transport,
+ uint8_t *data, size_t size)
{
- struct async_req *result, *subreq;
+ struct tevent_req *req;
+ struct async_req *subreq;
struct rpc_read_state *state;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct rpc_read_state)) {
+ req = tevent_req_create(mem_ctx, &state, struct rpc_read_state);
+ if (req == NULL) {
return NULL;
}
state->ev = ev;
- state->cli = cli;
+ state->transport = transport;
state->data = data;
state->size = size;
state->num_read = 0;
DEBUG(5, ("rpc_read_send: data_to_read: %u\n", (unsigned int)size));
- if (cli->transport_type == NCACN_NP) {
- subreq = cli_read_andx_send(
- state, ev, cli->trans.np.cli,
- cli->trans.np.fnum, 0, size);
- if (subreq == NULL) {
- DEBUG(10, ("cli_read_andx_send failed\n"));
- goto fail;
- }
- subreq->async.fn = rpc_read_np_done;
- subreq->async.priv = result;
- return result;
- }
-
- if ((cli->transport_type == NCACN_IP_TCP)
- || (cli->transport_type == NCACN_UNIX_STREAM)) {
- subreq = recvall_send(state, ev, cli->trans.sock.fd,
- data, size, 0);
- if (subreq == NULL) {
- DEBUG(10, ("recvall_send failed\n"));
- goto fail;
- }
- subreq->async.fn = rpc_read_sock_done;
- subreq->async.priv = result;
- return result;
+ subreq = transport->read_send(state, ev, (uint8_t *)data, size,
+ transport->priv);
+ if (subreq == NULL) {
+ goto fail;
}
+ subreq->async.fn = rpc_read_done;
+ subreq->async.priv = req;
+ return req;
- if (async_post_status(result, ev, NT_STATUS_INVALID_PARAMETER)) {
- return result;
- }
fail:
- TALLOC_FREE(result);
+ TALLOC_FREE(req);
return NULL;
}
-static void rpc_read_np_done(struct async_req *subreq)
+static void rpc_read_done(struct async_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct rpc_read_state *state = talloc_get_type_abort(
- req->private_data, struct rpc_read_state);
+ struct tevent_req *req = talloc_get_type_abort(
+ subreq->async.priv, struct tevent_req);
+ struct rpc_read_state *state = tevent_req_data(
+ req, struct rpc_read_state);
NTSTATUS status;
ssize_t received;
- uint8_t *rcvbuf;
- status = cli_read_andx_recv(subreq, &received, &rcvbuf);
- /*
- * We can't TALLOC_FREE(subreq) as usual here, as rcvbuf still is a
- * child of that.
- */
- if (NT_STATUS_EQUAL(status, NT_STATUS_BUFFER_TOO_SMALL)) {
- status = NT_STATUS_OK;
- }
+ status = state->transport->read_recv(subreq, &received);
+ TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- TALLOC_FREE(subreq);
- async_req_error(req, status);
+ tevent_req_nterror(req, status);
return;
}
- memcpy(state->data + state->num_read, rcvbuf, received);
- TALLOC_FREE(subreq);
-
state->num_read += received;
-
if (state->num_read == state->size) {
- async_req_done(req);
+ tevent_req_done(req);
return;
}
- subreq = cli_read_andx_send(
- state, state->ev, state->cli->trans.np.cli,
- state->cli->trans.np.fnum, 0,
- state->size - state->num_read);
-
- if (async_req_nomem(subreq, req)) {
+ subreq = state->transport->read_send(state, state->ev,
+ state->data + state->num_read,
+ state->size - state->num_read,
+ state->transport->priv);
+ if (tevent_req_nomem(subreq, req)) {
return;
}
-
- subreq->async.fn = rpc_read_np_done;
+ subreq->async.fn = rpc_read_done;
subreq->async.priv = req;
}
-static void rpc_read_sock_done(struct async_req *subreq)
+static NTSTATUS rpc_read_recv(struct tevent_req *req)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- NTSTATUS status;
-
- status = recvall_recv(subreq);
- TALLOC_FREE(subreq);
- if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
- return;
- }
-
- async_req_done(req);
-}
-
-static NTSTATUS rpc_read_recv(struct async_req *req)
-{
- return async_req_simple_recv(req);
+ return tevent_req_simple_recv_ntstatus(req);
}
struct rpc_write_state {
struct event_context *ev;
- struct rpc_pipe_client *cli;
- const char *data;
+ struct rpc_cli_transport *transport;
+ const uint8_t *data;
size_t size;
size_t num_written;
};
-static void rpc_write_np_done(struct async_req *subreq);
-static void rpc_write_sock_done(struct async_req *subreq);
+static void rpc_write_done(struct async_req *subreq);
-static struct async_req *rpc_write_send(TALLOC_CTX *mem_ctx,
- struct event_context *ev,
- struct rpc_pipe_client *cli,
- const char *data, size_t size)
+static struct tevent_req *rpc_write_send(TALLOC_CTX *mem_ctx,
+ struct event_context *ev,
+ struct rpc_cli_transport *transport,
+ const uint8_t *data, size_t size)
{
- struct async_req *result, *subreq;
+ struct tevent_req *req;
+ struct async_req *subreq;
struct rpc_write_state *state;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct rpc_write_state)) {
+ req = tevent_req_create(mem_ctx, &state, struct rpc_write_state);
+ if (req == NULL) {
return NULL;
}
state->ev = ev;
- state->cli = cli;
+ state->transport = transport;
state->data = data;
state->size = size;
state->num_written = 0;
DEBUG(5, ("rpc_write_send: data_to_write: %u\n", (unsigned int)size));
- if (cli->transport_type == NCACN_NP) {
- subreq = cli_write_andx_send(
- state, ev, cli->trans.np.cli,
- cli->trans.np.fnum, 8, /* 8 means message mode. */
- (uint8_t *)data, 0, size);
- if (subreq == NULL) {
- DEBUG(10, ("cli_write_andx_send failed\n"));
- goto fail;
- }
- subreq->async.fn = rpc_write_np_done;
- subreq->async.priv = result;
- return result;
- }
-
- if ((cli->transport_type == NCACN_IP_TCP)
- || (cli->transport_type == NCACN_UNIX_STREAM)) {
- subreq = sendall_send(state, ev, cli->trans.sock.fd,
- data, size, 0);
- if (subreq == NULL) {
- DEBUG(10, ("sendall_send failed\n"));
- goto fail;
- }
- subreq->async.fn = rpc_write_sock_done;
- subreq->async.priv = result;
- return result;
- }
-
- if (async_post_status(result, ev, NT_STATUS_INVALID_PARAMETER)) {
- return result;
+ subreq = transport->write_send(state, ev, data, size, transport->priv);
+ if (subreq == NULL) {
+ goto fail;
}
+ subreq->async.fn = rpc_write_done;
+ subreq->async.priv = req;
+ return req;
fail:
- TALLOC_FREE(result);
+ TALLOC_FREE(req);
return NULL;
}
-static void rpc_write_np_done(struct async_req *subreq)
+static void rpc_write_done(struct async_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct rpc_write_state *state = talloc_get_type_abort(
- req->private_data, struct rpc_write_state);
+ struct tevent_req *req = talloc_get_type_abort(
+ subreq->async.priv, struct tevent_req);
+ struct rpc_write_state *state = tevent_req_data(
+ req, struct rpc_write_state);
NTSTATUS status;
- size_t written;
+ ssize_t written;
- status = cli_write_andx_recv(subreq, &written);
+ status = state->transport->write_recv(subreq, &written);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ tevent_req_nterror(req, status);
return;
}
state->num_written += written;
if (state->num_written == state->size) {
- async_req_done(req);
+ tevent_req_done(req);
return;
}
- subreq = cli_write_andx_send(
- state, state->ev, state->cli->trans.np.cli,
- state->cli->trans.np.fnum, 8,
- (uint8_t *)(state->data + state->num_written),
- 0, state->size - state->num_written);
-
- if (async_req_nomem(subreq, req)) {
+ subreq = state->transport->write_send(state, state->ev,
+ state->data + state->num_written,
+ state->size - state->num_written,
+ state->transport->priv);
+ if (tevent_req_nomem(subreq, req)) {
return;
}
-
- subreq->async.fn = rpc_write_np_done;
+ subreq->async.fn = rpc_write_done;
subreq->async.priv = req;
}
-static void rpc_write_sock_done(struct async_req *subreq)
+static NTSTATUS rpc_write_recv(struct tevent_req *req)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- NTSTATUS status;
-
- status = sendall_recv(subreq);
- TALLOC_FREE(subreq);
- if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
- return;
- }
-
- async_req_done(req);
-}
-
-static NTSTATUS rpc_write_recv(struct async_req *req)
-{
- return async_req_simple_recv(req);
+ return tevent_req_simple_recv_ntstatus(req);
}
prs_struct *pdu;
};
-static void get_complete_frag_got_header(struct async_req *subreq);
-static void get_complete_frag_got_rest(struct async_req *subreq);
+static void get_complete_frag_got_header(struct tevent_req *subreq);
+static void get_complete_frag_got_rest(struct tevent_req *subreq);
-static struct async_req *get_complete_frag_send(TALLOC_CTX *mem_ctx,
- struct event_context *ev,
- struct rpc_pipe_client *cli,
- struct rpc_hdr_info *prhdr,
- prs_struct *pdu)
+static struct tevent_req *get_complete_frag_send(TALLOC_CTX *mem_ctx,
+ struct event_context *ev,
+ struct rpc_pipe_client *cli,
+ struct rpc_hdr_info *prhdr,
+ prs_struct *pdu)
{
- struct async_req *result, *subreq;
+ struct tevent_req *req, *subreq;
struct get_complete_frag_state *state;
uint32_t pdu_len;
NTSTATUS status;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct get_complete_frag_state)) {
+ req = tevent_req_create(mem_ctx, &state,
+ struct get_complete_frag_state);
+ if (req == NULL) {
return NULL;
}
state->ev = ev;
status = NT_STATUS_NO_MEMORY;
goto post_status;
}
- subreq = rpc_read_send(state, state->ev, state->cli,
- prs_data_p(state->pdu) + pdu_len,
- RPC_HEADER_LEN - pdu_len);
+ subreq = rpc_read_send(
+ state, state->ev,
+ state->cli->transport,
+ (uint8_t *)(prs_data_p(state->pdu) + pdu_len),
+ RPC_HEADER_LEN - pdu_len);
if (subreq == NULL) {
status = NT_STATUS_NO_MEMORY;
goto post_status;
}
- subreq->async.fn = get_complete_frag_got_header;
- subreq->async.priv = result;
- return result;
+ tevent_req_set_callback(subreq, get_complete_frag_got_header,
+ req);
+ return req;
}
status = parse_rpc_header(cli, prhdr, pdu);
status = NT_STATUS_NO_MEMORY;
goto post_status;
}
- subreq = rpc_read_send(state, state->ev, state->cli,
- prs_data_p(pdu) + pdu_len,
+ subreq = rpc_read_send(state, state->ev,
+ state->cli->transport,
+ (uint8_t *)(prs_data_p(pdu) + pdu_len),
prhdr->frag_len - pdu_len);
if (subreq == NULL) {
status = NT_STATUS_NO_MEMORY;
goto post_status;
}
- subreq->async.fn = get_complete_frag_got_rest;
- subreq->async.priv = result;
- return result;
+ tevent_req_set_callback(subreq, get_complete_frag_got_rest,
+ req);
+ return req;
}
status = NT_STATUS_OK;
post_status:
- if (async_post_status(result, ev, status)) {
- return result;
+ if (NT_STATUS_IS_OK(status)) {
+ tevent_req_done(req);
+ } else {
+ tevent_req_nterror(req, status);
}
- TALLOC_FREE(result);
- return NULL;
+ return tevent_req_post(req, ev);
}
-static void get_complete_frag_got_header(struct async_req *subreq)
+static void get_complete_frag_got_header(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct get_complete_frag_state *state = talloc_get_type_abort(
- req->private_data, struct get_complete_frag_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct get_complete_frag_state *state = tevent_req_data(
+ req, struct get_complete_frag_state);
NTSTATUS status;
status = rpc_read_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ tevent_req_nterror(req, status);
return;
}
status = parse_rpc_header(state->cli, state->prhdr, state->pdu);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ tevent_req_nterror(req, status);
return;
}
if (!rpc_grow_buffer(state->pdu, state->prhdr->frag_len)) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
* RPC_HEADER_LEN bytes into state->pdu.
*/
- subreq = rpc_read_send(state, state->ev, state->cli,
- prs_data_p(state->pdu) + RPC_HEADER_LEN,
- state->prhdr->frag_len - RPC_HEADER_LEN);
- if (async_req_nomem(subreq, req)) {
+ subreq = rpc_read_send(
+ state, state->ev, state->cli->transport,
+ (uint8_t *)(prs_data_p(state->pdu) + RPC_HEADER_LEN),
+ state->prhdr->frag_len - RPC_HEADER_LEN);
+ if (tevent_req_nomem(subreq, req)) {
return;
}
- subreq->async.fn = get_complete_frag_got_rest;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, get_complete_frag_got_rest, req);
}
-static void get_complete_frag_got_rest(struct async_req *subreq)
+static void get_complete_frag_got_rest(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
NTSTATUS status;
status = rpc_read_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ tevent_req_nterror(req, status);
return;
}
- async_req_done(req);
+ tevent_req_done(req);
}
-static NTSTATUS get_complete_frag_recv(struct async_req *req)
+static NTSTATUS get_complete_frag_recv(struct tevent_req *req)
{
- return async_req_simple_recv(req);
+ return tevent_req_simple_recv_ntstatus(req);
}
/****************************************************************************
struct cli_api_pipe_state {
struct event_context *ev;
- struct rpc_pipe_client *cli;
- uint32_t max_rdata_len;
+ struct rpc_cli_transport *transport;
uint8_t *rdata;
uint32_t rdata_len;
};
-static void cli_api_pipe_np_trans_done(struct async_req *subreq);
-static void cli_api_pipe_sock_send_done(struct async_req *subreq);
-static void cli_api_pipe_sock_read_done(struct async_req *subreq);
+static void cli_api_pipe_trans_done(struct async_req *subreq);
+static void cli_api_pipe_write_done(struct tevent_req *subreq);
+static void cli_api_pipe_read_done(struct async_req *subreq);
-static struct async_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx,
- struct event_context *ev,
- struct rpc_pipe_client *cli,
- uint8_t *data, size_t data_len,
- uint32_t max_rdata_len)
+static struct tevent_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx,
+ struct event_context *ev,
+ struct rpc_cli_transport *transport,
+ uint8_t *data, size_t data_len,
+ uint32_t max_rdata_len)
{
- struct async_req *result, *subreq;
+ struct tevent_req *req;
+ struct async_req *subreq;
+ struct tevent_req *subreq2;
struct cli_api_pipe_state *state;
NTSTATUS status;
- if (!async_req_setup(mem_ctx, &result, &state,
- struct cli_api_pipe_state)) {
+ req = tevent_req_create(mem_ctx, &state, struct cli_api_pipe_state);
+ if (req == NULL) {
return NULL;
}
state->ev = ev;
- state->cli = cli;
- state->max_rdata_len = max_rdata_len;
+ state->transport = transport;
- if (state->max_rdata_len < RPC_HEADER_LEN) {
+ if (max_rdata_len < RPC_HEADER_LEN) {
/*
* For a RPC reply we always need at least RPC_HEADER_LEN
* bytes. We check this here because we will receive
goto post_status;
}
- if (cli->transport_type == NCACN_NP) {
-
- uint16_t setup[2];
- SSVAL(setup+0, 0, TRANSACT_DCERPCCMD);
- SSVAL(setup+1, 0, cli->trans.np.fnum);
-
- subreq = cli_trans_send(
- state, ev, cli->trans.np.cli, SMBtrans,
- "\\PIPE\\", 0, 0, 0, setup, 2, 0,
- NULL, 0, 0, data, data_len, max_rdata_len);
+ if (transport->trans_send != NULL) {
+ subreq = transport->trans_send(state, ev, data, data_len,
+ max_rdata_len, transport->priv);
if (subreq == NULL) {
status = NT_STATUS_NO_MEMORY;
goto post_status;
}
- subreq->async.fn = cli_api_pipe_np_trans_done;
- subreq->async.priv = result;
- return result;
+ subreq->async.fn = cli_api_pipe_trans_done;
+ subreq->async.priv = req;
+ return req;
}
- if ((cli->transport_type == NCACN_IP_TCP)
- || (cli->transport_type == NCACN_UNIX_STREAM)) {
- subreq = sendall_send(state, ev, cli->trans.sock.fd,
- data, data_len, 0);
- if (subreq == NULL) {
- status = NT_STATUS_NO_MEMORY;
- goto post_status;
- }
- subreq->async.fn = cli_api_pipe_sock_send_done;
- subreq->async.priv = result;
- return result;
+ /*
+ * If the transport does not provide a "trans" routine, i.e. for
+ * example the ncacn_ip_tcp transport, do the write/read step here.
+ */
+
+ subreq2 = rpc_write_send(state, ev, transport, data, data_len);
+ if (subreq2 == NULL) {
+ goto fail;
}
+ tevent_req_set_callback(subreq2, cli_api_pipe_write_done, req);
+ return req;
status = NT_STATUS_INVALID_PARAMETER;
post_status:
- if (async_post_status(result, ev, status)) {
- return result;
+ if (NT_STATUS_IS_OK(status)) {
+ tevent_req_done(req);
+ } else {
+ tevent_req_nterror(req, status);
}
- TALLOC_FREE(result);
+ return tevent_req_post(req, ev);
+ fail:
+ TALLOC_FREE(req);
return NULL;
}
-static void cli_api_pipe_np_trans_done(struct async_req *subreq)
+static void cli_api_pipe_trans_done(struct async_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct cli_api_pipe_state *state = talloc_get_type_abort(
- req->private_data, struct cli_api_pipe_state);
+ struct tevent_req *req = talloc_get_type_abort(
+ subreq->async.priv, struct tevent_req);
+ struct cli_api_pipe_state *state = tevent_req_data(
+ req, struct cli_api_pipe_state);
NTSTATUS status;
- status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL,
- &state->rdata, &state->rdata_len);
+ status = state->transport->trans_recv(subreq, state, &state->rdata,
+ &state->rdata_len);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ tevent_req_nterror(req, status);
return;
}
- async_req_done(req);
+ tevent_req_done(req);
}
-static void cli_api_pipe_sock_send_done(struct async_req *subreq)
+static void cli_api_pipe_write_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct cli_api_pipe_state *state = talloc_get_type_abort(
- req->private_data, struct cli_api_pipe_state);
+ struct tevent_req *req = tevent_req_callback_data(
+ subreq, struct tevent_req);
+ struct cli_api_pipe_state *state = tevent_req_data(
+ req, struct cli_api_pipe_state);
+ struct async_req *subreq2;
NTSTATUS status;
- status = sendall_recv(subreq);
+ status = rpc_write_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ tevent_req_nterror(req, status);
return;
}
state->rdata = TALLOC_ARRAY(state, uint8_t, RPC_HEADER_LEN);
- if (async_req_nomem(state->rdata, req)) {
+ if (tevent_req_nomem(state->rdata, req)) {
return;
}
- state->rdata_len = RPC_HEADER_LEN;
- subreq = recvall_send(state, state->ev, state->cli->trans.sock.fd,
- state->rdata, RPC_HEADER_LEN, 0);
- if (async_req_nomem(subreq, req)) {
+ /*
+ * We don't need to use rpc_read_send here, the upper layer will cope
+ * with a short read, transport->trans_send could also return less
+ * than state->max_rdata_len.
+ */
+ subreq2 = state->transport->read_send(state, state->ev, state->rdata,
+ RPC_HEADER_LEN,
+ state->transport->priv);
+ if (tevent_req_nomem(subreq2, req)) {
return;
}
- subreq->async.fn = cli_api_pipe_sock_read_done;
- subreq->async.priv = req;
+ subreq2->async.fn = cli_api_pipe_read_done;
+ subreq2->async.priv = req;
}
-static void cli_api_pipe_sock_read_done(struct async_req *subreq)
+static void cli_api_pipe_read_done(struct async_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
+ struct tevent_req *req = talloc_get_type_abort(
+ subreq->async.priv, struct tevent_req);
+ struct cli_api_pipe_state *state = tevent_req_data(
+ req, struct cli_api_pipe_state);
NTSTATUS status;
+ ssize_t received;
- status = recvall_recv(subreq);
+ status = state->transport->read_recv(subreq, &received);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ tevent_req_nterror(req, status);
return;
}
- async_req_done(req);
+ state->rdata_len = received;
+ tevent_req_done(req);
}
-static NTSTATUS cli_api_pipe_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
+static NTSTATUS cli_api_pipe_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
uint8_t **prdata, uint32_t *prdata_len)
{
- struct cli_api_pipe_state *state = talloc_get_type_abort(
- req->private_data, struct cli_api_pipe_state);
+ struct cli_api_pipe_state *state = tevent_req_data(
+ req, struct cli_api_pipe_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (tevent_req_is_nterror(req, &status)) {
return status;
}
return 0;
}
-static void rpc_api_pipe_trans_done(struct async_req *subreq);
-static void rpc_api_pipe_got_pdu(struct async_req *subreq);
+static void rpc_api_pipe_trans_done(struct tevent_req *subreq);
+static void rpc_api_pipe_got_pdu(struct tevent_req *subreq);
static struct async_req *rpc_api_pipe_send(TALLOC_CTX *mem_ctx,
struct event_context *ev,
prs_struct *data, /* Outgoing PDU */
uint8_t expected_pkt_type)
{
- struct async_req *result, *subreq;
+ struct async_req *result;
+ struct tevent_req *subreq;
struct rpc_api_pipe_state *state;
uint16_t max_recv_frag;
NTSTATUS status;
prs_init_empty(&state->incoming_pdu, state, UNMARSHALL);
/* Make incoming_pdu dynamic with no memory. */
- prs_give_memory(&state->incoming_pdu, 0, 0, true);
+ prs_give_memory(&state->incoming_pdu, NULL, 0, true);
talloc_set_destructor(state, rpc_api_pipe_state_destructor);
max_recv_frag = RPC_HEADER_LEN + 10 + (sys_random() % 32);
#endif
- subreq = cli_api_pipe_send(state, ev, cli, (uint8_t *)prs_data_p(data),
+ subreq = cli_api_pipe_send(state, ev, cli->transport,
+ (uint8_t *)prs_data_p(data),
prs_offset(data), max_recv_frag);
if (subreq == NULL) {
status = NT_STATUS_NO_MEMORY;
goto post_status;
}
- subreq->async.fn = rpc_api_pipe_trans_done;
- subreq->async.priv = result;
+ tevent_req_set_callback(subreq, rpc_api_pipe_trans_done, result);
return result;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
TALLOC_FREE(result);
return NULL;
}
-static void rpc_api_pipe_trans_done(struct async_req *subreq)
+static void rpc_api_pipe_trans_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
+ struct async_req *req = tevent_req_callback_data(
+ subreq, struct async_req);
struct rpc_api_pipe_state *state = talloc_get_type_abort(
req->private_data, struct rpc_api_pipe_state);
NTSTATUS status;
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5, ("cli_api_pipe failed: %s\n", nt_errstr(status)));
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if (async_req_nomem(subreq, req)) {
return;
}
- subreq->async.fn = rpc_api_pipe_got_pdu;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, rpc_api_pipe_got_pdu, req);
}
-static void rpc_api_pipe_got_pdu(struct async_req *subreq)
+static void rpc_api_pipe_got_pdu(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
+ struct async_req *req = tevent_req_callback_data(
+ subreq, struct async_req);
struct rpc_api_pipe_state *state = talloc_get_type_abort(
req->private_data, struct rpc_api_pipe_state);
NTSTATUS status;
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5, ("get_complete_frag failed: %s\n",
nt_errstr(status)));
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
nt_errstr(status)));
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
"%s\n",
state->incoming_pdu.bigendian_data?"big":"little",
state->incoming_frag.bigendian_data?"big":"little"));
- async_req_error(req, NT_STATUS_INVALID_PARAMETER);
+ async_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
/* Now copy the data portion out of the pdu into rbuf. */
if (!prs_force_grow(&state->incoming_pdu, rdata_len)) {
- async_req_error(req, NT_STATUS_NO_MEMORY);
+ async_req_nterror(req, NT_STATUS_NO_MEMORY);
return;
}
status = cli_pipe_reset_current_pdu(state->cli, &state->rhdr,
&state->incoming_frag);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if (async_req_nomem(subreq, req)) {
return;
}
- subreq->async.fn = rpc_api_pipe_got_pdu;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, rpc_api_pipe_got_pdu, req);
}
static NTSTATUS rpc_api_pipe_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
req->private_data, struct rpc_api_pipe_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
return status;
}
return 0;
}
-static void rpc_api_pipe_req_write_done(struct async_req *subreq);
+static void rpc_api_pipe_req_write_done(struct tevent_req *subreq);
static void rpc_api_pipe_req_done(struct async_req *subreq);
static NTSTATUS prepare_next_frag(struct rpc_api_pipe_req_state *state,
bool *is_last_frag);
prs_struct *req_data)
{
struct async_req *result, *subreq;
+ struct tevent_req *subreq2;
struct rpc_api_pipe_req_state *state;
NTSTATUS status;
bool is_last_frag;
subreq->async.fn = rpc_api_pipe_req_done;
subreq->async.priv = result;
} else {
- subreq = rpc_write_send(state, ev, cli,
- prs_data_p(&state->outgoing_frag),
- prs_offset(&state->outgoing_frag));
- if (subreq == NULL) {
+ subreq2 = rpc_write_send(
+ state, ev, cli->transport,
+ (uint8_t *)prs_data_p(&state->outgoing_frag),
+ prs_offset(&state->outgoing_frag));
+ if (subreq2 == NULL) {
status = NT_STATUS_NO_MEMORY;
goto post_status;
}
- subreq->async.fn = rpc_api_pipe_req_write_done;
- subreq->async.priv = result;
+ tevent_req_set_callback(subreq2, rpc_api_pipe_req_write_done,
+ result);
}
return result;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
TALLOC_FREE(result);
return status;
}
-static void rpc_api_pipe_req_write_done(struct async_req *subreq)
+static void rpc_api_pipe_req_write_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
+ struct async_req *req = tevent_req_callback_data(
+ subreq, struct async_req);
struct rpc_api_pipe_req_state *state = talloc_get_type_abort(
req->private_data, struct rpc_api_pipe_req_state);
+ struct async_req *subreq2;
NTSTATUS status;
bool is_last_frag;
status = rpc_write_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
status = prepare_next_frag(state, &is_last_frag);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if (is_last_frag) {
- subreq = rpc_api_pipe_send(state, state->ev, state->cli,
+ subreq2 = rpc_api_pipe_send(state, state->ev, state->cli,
&state->outgoing_frag,
RPC_RESPONSE);
- if (async_req_nomem(subreq, req)) {
+ if (async_req_nomem(subreq2, req)) {
return;
}
- subreq->async.fn = rpc_api_pipe_req_done;
- subreq->async.priv = req;
+ subreq2->async.fn = rpc_api_pipe_req_done;
+ subreq2->async.priv = req;
} else {
- subreq = rpc_write_send(state, state->ev, state->cli,
- prs_data_p(&state->outgoing_frag),
- prs_offset(&state->outgoing_frag));
+ subreq = rpc_write_send(
+ state, state->ev,
+ state->cli->transport,
+ (uint8_t *)prs_data_p(&state->outgoing_frag),
+ prs_offset(&state->outgoing_frag));
if (async_req_nomem(subreq, req)) {
return;
}
- subreq->async.fn = rpc_api_pipe_req_write_done;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, rpc_api_pipe_req_write_done,
+ req);
}
}
status = rpc_api_pipe_recv(subreq, state, &state->reply_pdu);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
req->private_data, struct rpc_api_pipe_req_state);
NTSTATUS status;
- if (async_req_is_error(req, &status)) {
+ if (async_req_is_nterror(req, &status)) {
+ /*
+ * We always have to initialize to reply pdu, even if there is
+ * none. The rpccli_* caller routines expect this.
+ */
+ prs_init_empty(reply_pdu, mem_ctx, UNMARSHALL);
return status;
}
struct rpc_pipe_bind_state *state,
struct rpc_hdr_info *phdr,
prs_struct *reply_pdu);
-static void rpc_bind_auth3_write_done(struct async_req *subreq);
+static void rpc_bind_auth3_write_done(struct tevent_req *subreq);
static NTSTATUS rpc_finish_spnego_ntlmssp_bind_send(struct async_req *req,
struct rpc_pipe_bind_state *state,
struct rpc_hdr_info *phdr,
return result;
post_status:
- if (async_post_status(result, ev, status)) {
+ if (async_post_ntstatus(result, ev, status)) {
return result;
}
TALLOC_FREE(result);
DEBUG(3, ("rpc_pipe_bind: %s bind request returned %s\n",
rpccli_pipe_txt(debug_ctx(), state->cli),
nt_errstr(status)));
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
/* Unmarshall the RPC header */
if (!smb_io_rpc_hdr("hdr", &hdr, &reply_pdu, 0)) {
DEBUG(0, ("rpc_pipe_bind: failed to unmarshall RPC_HDR.\n"));
- async_req_error(req, NT_STATUS_BUFFER_TOO_SMALL);
+ prs_mem_free(&reply_pdu);
+ async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
return;
}
if (!smb_io_rpc_hdr_ba("", &hdr_ba, &reply_pdu, 0)) {
DEBUG(0, ("rpc_pipe_bind: Failed to unmarshall "
"RPC_HDR_BA.\n"));
- async_req_error(req, NT_STATUS_BUFFER_TOO_SMALL);
+ prs_mem_free(&reply_pdu);
+ async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
return;
}
if (!check_bind_response(&hdr_ba, &state->cli->transfer_syntax)) {
DEBUG(2, ("rpc_pipe_bind: check_bind_response failed.\n"));
- async_req_error(req, NT_STATUS_BUFFER_TOO_SMALL);
+ prs_mem_free(&reply_pdu);
+ async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
return;
}
case PIPE_AUTH_TYPE_NONE:
case PIPE_AUTH_TYPE_SCHANNEL:
/* Bind complete. */
+ prs_mem_free(&reply_pdu);
async_req_done(req);
break;
/* Need to send AUTH3 packet - no reply. */
status = rpc_finish_auth3_bind_send(req, state, &hdr,
&reply_pdu);
+ prs_mem_free(&reply_pdu);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
}
break;
/* Need to send alter context request and reply. */
status = rpc_finish_spnego_ntlmssp_bind_send(req, state, &hdr,
&reply_pdu);
+ prs_mem_free(&reply_pdu);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
}
break;
default:
DEBUG(0,("cli_finish_bind_auth: unknown auth type %u\n",
(unsigned int)state->cli->auth->auth_type));
- async_req_error(req, NT_STATUS_INTERNAL_ERROR);
+ prs_mem_free(&reply_pdu);
+ async_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
}
}
DATA_BLOB server_response = data_blob_null;
DATA_BLOB client_reply = data_blob_null;
struct rpc_hdr_auth_info hdr_auth;
- struct async_req *subreq;
+ struct tevent_req *subreq;
NTSTATUS status;
if ((phdr->auth_len == 0)
return status;
}
- subreq = rpc_write_send(state, state->ev, state->cli,
- prs_data_p(&state->rpc_out),
+ subreq = rpc_write_send(state, state->ev, state->cli->transport,
+ (uint8_t *)prs_data_p(&state->rpc_out),
prs_offset(&state->rpc_out));
if (subreq == NULL) {
return NT_STATUS_NO_MEMORY;
}
- subreq->async.fn = rpc_bind_auth3_write_done;
- subreq->async.priv = req;
+ tevent_req_set_callback(subreq, rpc_bind_auth3_write_done, req);
return NT_STATUS_OK;
}
-static void rpc_bind_auth3_write_done(struct async_req *subreq)
+static void rpc_bind_auth3_write_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
+ struct async_req *req = tevent_req_callback_data(
+ subreq, struct async_req);
NTSTATUS status;
status = rpc_write_recv(subreq);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
async_req_done(req);
status = rpc_api_pipe_recv(subreq, talloc_tos(), &reply_pdu);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- async_req_error(req, status);
+ async_req_nterror(req, status);
return;
}
if (!smb_io_rpc_hdr("rpc_hdr ", &hdr, &reply_pdu, 0)) {
DEBUG(0, ("rpc_finish_spnego_ntlmssp_bind: Failed to "
"unmarshall RPC_HDR.\n"));
- async_req_error(req, NT_STATUS_BUFFER_TOO_SMALL);
+ async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL);
return;
}
if (!prs_set_offset(
&reply_pdu,
hdr.frag_len - hdr.auth_len - RPC_HDR_AUTH_LEN)) {
- async_req_error(req, NT_STATUS_INVALID_PARAMETER);
+ async_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
if (!smb_io_rpc_hdr_auth("hdr_auth", &hdr_auth, &reply_pdu, 0)) {
- async_req_error(req, NT_STATUS_INVALID_PARAMETER);
+ async_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
OID_NTLMSSP, &tmp_blob)) {
data_blob_free(&server_spnego_response);
data_blob_free(&tmp_blob);
- async_req_error(req, NT_STATUS_INVALID_PARAMETER);
+ async_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
NTSTATUS rpc_pipe_bind_recv(struct async_req *req)
{
- return async_req_simple_recv(req);
+ return async_req_simple_recv_ntstatus(req);
}
NTSTATUS rpc_pipe_bind(struct rpc_pipe_client *cli,
return status;
}
-unsigned int rpccli_set_timeout(struct rpc_pipe_client *cli,
+unsigned int rpccli_set_timeout(struct rpc_pipe_client *rpc_cli,
unsigned int timeout)
{
- return cli_set_timeout(cli->trans.np.cli, timeout);
-}
+ struct cli_state *cli = rpc_pipe_np_smb_conn(rpc_cli);
-bool rpccli_get_pwd_hash(struct rpc_pipe_client *cli, uint8_t nt_hash[16])
-{
- if ((cli->auth->auth_type == PIPE_AUTH_TYPE_NTLMSSP)
- || (cli->auth->auth_type == PIPE_AUTH_TYPE_SPNEGO_NTLMSSP)) {
- memcpy(nt_hash, cli->auth->a_u.ntlmssp_state->nt_hash, 16);
- return true;
+ if (cli == NULL) {
+ return 0;
}
-
- if (cli->transport_type == NCACN_NP) {
- E_md4hash(cli->trans.np.cli->pwd.password, nt_hash);
- return true;
- }
-
- return false;
+ return cli_set_timeout(cli, timeout);
}
-struct cli_state *rpc_pipe_np_smb_conn(struct rpc_pipe_client *p)
+bool rpccli_get_pwd_hash(struct rpc_pipe_client *rpc_cli, uint8_t nt_hash[16])
{
- if (p->transport_type == NCACN_NP) {
- return p->trans.np.cli;
- }
- return NULL;
-}
+ struct cli_state *cli;
-static int rpc_pipe_destructor(struct rpc_pipe_client *p)
-{
- if (p->transport_type == NCACN_NP) {
- bool ret;
- ret = cli_close(p->trans.np.cli, p->trans.np.fnum);
- if (!ret) {
- DEBUG(1, ("rpc_pipe_destructor: cli_close failed on "
- "pipe %s. Error was %s\n",
- rpccli_pipe_txt(debug_ctx(), p),
- cli_errstr(p->trans.np.cli)));
- }
-
- DEBUG(10, ("rpc_pipe_destructor: closed %s\n",
- rpccli_pipe_txt(debug_ctx(), p)));
-
- DLIST_REMOVE(p->trans.np.cli->pipe_list, p);
- return ret ? -1 : 0;
+ if ((rpc_cli->auth->auth_type == PIPE_AUTH_TYPE_NTLMSSP)
+ || (rpc_cli->auth->auth_type == PIPE_AUTH_TYPE_SPNEGO_NTLMSSP)) {
+ memcpy(nt_hash, rpc_cli->auth->a_u.ntlmssp_state->nt_hash, 16);
+ return true;
}
- return -1;
+ cli = rpc_pipe_np_smb_conn(rpc_cli);
+ if (cli == NULL) {
+ return false;
+ }
+ E_md4hash(cli->password ? cli->password : "", nt_hash);
+ return true;
}
NTSTATUS rpccli_anon_bind_data(TALLOC_CTX *mem_ctx,
#endif
}
-static int rpc_pipe_sock_destructor(struct rpc_pipe_client *p)
-{
- close(p->trans.sock.fd);
- return 0;
-}
-
/**
* Create an rpc pipe client struct, connecting to a tcp port.
*/
struct rpc_pipe_client *result;
struct sockaddr_storage addr;
NTSTATUS status;
+ int fd;
result = TALLOC_ZERO_P(mem_ctx, struct rpc_pipe_client);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
- result->transport_type = NCACN_IP_TCP;
-
result->abstract_syntax = *abstract_syntax;
result->transfer_syntax = ndr_transfer_syntax;
result->dispatch = cli_do_rpc_ndr;
goto fail;
}
- status = open_socket_out(&addr, port, 60, &result->trans.sock.fd);
+ status = open_socket_out(&addr, port, 60, &fd);
if (!NT_STATUS_IS_OK(status)) {
goto fail;
}
+ set_socket_options(fd, lp_socket_options());
- talloc_set_destructor(result, rpc_pipe_sock_destructor);
+ status = rpc_transport_sock_init(result, fd, &result->transport);
+ if (!NT_STATUS_IS_OK(status)) {
+ close(fd);
+ goto fail;
+ }
*presult = result;
return NT_STATUS_OK;
struct rpc_pipe_client *result;
struct sockaddr_un addr;
NTSTATUS status;
+ int fd;
result = talloc_zero(mem_ctx, struct rpc_pipe_client);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
- result->transport_type = NCACN_UNIX_STREAM;
-
result->abstract_syntax = *abstract_syntax;
result->transfer_syntax = ndr_transfer_syntax;
result->dispatch = cli_do_rpc_ndr;
- result->desthost = talloc_get_myname(result);
+ result->desthost = get_myname(result);
result->srv_name_slash = talloc_asprintf_strupper_m(
result, "\\\\%s", result->desthost);
if ((result->desthost == NULL) || (result->srv_name_slash == NULL)) {
result->max_xmit_frag = RPC_MAX_PDU_FRAG_LEN;
result->max_recv_frag = RPC_MAX_PDU_FRAG_LEN;
- result->trans.sock.fd = socket(AF_UNIX, SOCK_STREAM, 0);
- if (result->trans.sock.fd == -1) {
+ fd = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (fd == -1) {
status = map_nt_error_from_unix(errno);
goto fail;
}
- talloc_set_destructor(result, rpc_pipe_sock_destructor);
-
ZERO_STRUCT(addr);
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path));
- if (sys_connect(result->trans.sock.fd,
- (struct sockaddr *)&addr) == -1) {
+ if (sys_connect(fd, (struct sockaddr *)&addr) == -1) {
DEBUG(0, ("connect(%s) failed: %s\n", socket_path,
strerror(errno)));
- close(result->trans.sock.fd);
+ close(fd);
return map_nt_error_from_unix(errno);
}
+ status = rpc_transport_sock_init(result, fd, &result->transport);
+ if (!NT_STATUS_IS_OK(status)) {
+ close(fd);
+ goto fail;
+ }
+
*presult = result;
return NT_STATUS_OK;
return status;
}
+static int rpc_pipe_client_np_destructor(struct rpc_pipe_client *p)
+{
+ struct cli_state *cli;
+
+ cli = rpc_pipe_np_smb_conn(p);
+ if (cli != NULL) {
+ DLIST_REMOVE(cli->pipe_list, p);
+ }
+ return 0;
+}
/****************************************************************************
Open a named pipe over SMB to a remote server.
struct rpc_pipe_client **presult)
{
struct rpc_pipe_client *result;
- int fnum;
+ NTSTATUS status;
/* sanity check to protect against crashes */
return NT_STATUS_NO_MEMORY;
}
- result->transport_type = NCACN_NP;
-
- result->trans.np.pipe_name = cli_get_pipe_name_from_iface(
- result, cli, abstract_syntax);
- if (result->trans.np.pipe_name == NULL) {
- DEBUG(1, ("Could not find pipe for interface\n"));
- TALLOC_FREE(result);
- return NT_STATUS_INVALID_PARAMETER;
- }
-
- result->trans.np.cli = cli;
result->abstract_syntax = *abstract_syntax;
result->transfer_syntax = ndr_transfer_syntax;
result->dispatch = cli_do_rpc_ndr;
return NT_STATUS_NO_MEMORY;
}
- fnum = cli_nt_create(cli, result->trans.np.pipe_name,
- DESIRED_ACCESS_PIPE);
- if (fnum == -1) {
- DEBUG(3,("rpc_pipe_open_np: cli_nt_create failed on pipe %s "
- "to machine %s. Error was %s\n",
- result->trans.np.pipe_name, cli->desthost,
- cli_errstr(cli)));
+ status = rpc_transport_np_init(result, cli, abstract_syntax,
+ &result->transport);
+ if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(result);
- return cli_get_nt_error(cli);
+ return status;
}
- result->trans.np.fnum = fnum;
-
DLIST_ADD(cli->pipe_list, result);
- talloc_set_destructor(result, rpc_pipe_destructor);
+ talloc_set_destructor(result, rpc_pipe_client_np_destructor);
+
+ *presult = result;
+ return NT_STATUS_OK;
+}
+
+NTSTATUS rpc_pipe_open_local(TALLOC_CTX *mem_ctx,
+ struct rpc_cli_smbd_conn *conn,
+ const struct ndr_syntax_id *syntax,
+ struct rpc_pipe_client **presult)
+{
+ struct rpc_pipe_client *result;
+ struct cli_pipe_auth_data *auth;
+ NTSTATUS status;
+
+ result = talloc(mem_ctx, struct rpc_pipe_client);
+ if (result == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ result->abstract_syntax = *syntax;
+ result->transfer_syntax = ndr_transfer_syntax;
+ result->dispatch = cli_do_rpc_ndr;
+ result->max_xmit_frag = RPC_MAX_PDU_FRAG_LEN;
+ result->max_recv_frag = RPC_MAX_PDU_FRAG_LEN;
+
+ result->desthost = talloc_strdup(result, global_myname());
+ result->srv_name_slash = talloc_asprintf_strupper_m(
+ result, "\\\\%s", global_myname());
+ if ((result->desthost == NULL) || (result->srv_name_slash == NULL)) {
+ TALLOC_FREE(result);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ status = rpc_transport_smbd_init(result, conn, syntax,
+ &result->transport);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("rpc_transport_smbd_init failed: %s\n",
+ nt_errstr(status)));
+ TALLOC_FREE(result);
+ return status;
+ }
+
+ status = rpccli_anon_bind_data(result, &auth);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("rpccli_anon_bind_data failed: %s\n",
+ nt_errstr(status)));
+ TALLOC_FREE(result);
+ return status;
+ }
+
+ status = rpc_pipe_bind(result, auth);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("rpc_pipe_bind failed: %s\n", nt_errstr(status)));
+ TALLOC_FREE(result);
+ return status;
+ }
*presult = result;
return NT_STATUS_OK;
}
DEBUG(lvl, ("cli_rpc_pipe_open_noauth: rpc_pipe_bind for pipe "
"%s failed with error %s\n",
- cli_get_pipe_name_from_iface(debug_ctx(), cli,
- interface),
+ get_pipe_name_from_iface(interface),
nt_errstr(status) ));
TALLOC_FREE(result);
return status;
}
DEBUG(10,("cli_rpc_pipe_open_noauth: opened pipe %s to machine "
- "%s and bound anonymously.\n", result->trans.np.pipe_name,
- cli->desthost ));
+ "%s and bound anonymously.\n",
+ get_pipe_name_from_iface(interface), cli->desthost));
*presult = result;
return NT_STATUS_OK;
status = rpccli_ntlmssp_bind_data(
result, auth_type, auth_level, domain, username,
- cli->pwd.null_pwd ? NULL : password, &auth);
+ password, &auth);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("rpccli_ntlmssp_bind_data returned %s\n",
nt_errstr(status)));
DEBUG(10,("cli_rpc_pipe_open_ntlmssp_internal: opened pipe %s to "
"machine %s and bound NTLMSSP as user %s\\%s.\n",
- result->trans.np.pipe_name, cli->desthost,
- domain, username ));
+ get_pipe_name_from_iface(interface), cli->desthost, domain,
+ username ));
*presult = result;
return NT_STATUS_OK;
}
DEBUG(10,("cli_rpc_pipe_open_schannel_with_key: opened pipe %s to machine %s "
- "for domain %s "
- "and bound using schannel.\n",
- result->trans.np.pipe_name, cli->desthost, domain ));
+ "for domain %s and bound using schannel.\n",
+ get_pipe_name_from_iface(interface),
+ cli->desthost, domain ));
*presult = result;
return NT_STATUS_OK;
git.samba.org / ira / wip.git / blobdiff