summaryrefslogtreecommitdiff
path: root/source3
diff options
context:
space:
mode:
Diffstat (limited to 'source3')
-rw-r--r--source3/include/client.h13
-rw-r--r--source3/rpc_client/cli_pipe.c477
2 files changed, 174 insertions, 316 deletions
diff --git a/source3/include/client.h b/source3/include/client.h
index c47f058318..d62d1c05d2 100644
--- a/source3/include/client.h
+++ b/source3/include/client.h
@@ -114,18 +114,7 @@ struct rpc_cli_transport {
struct rpc_pipe_client {
struct rpc_pipe_client *prev, *next;
- enum dcerpc_transport_t transport_type;
-
- union {
- struct {
- struct cli_state *cli;
- const char *pipe_name;
- uint16 fnum;
- } np;
- struct {
- int fd;
- } sock;
- } trans ;
+ struct rpc_cli_transport *transport;
struct ndr_syntax_id abstract_syntax;
struct ndr_syntax_id transfer_syntax;
diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c
index cf2c833c28..5a53c0d940 100644
--- a/source3/rpc_client/cli_pipe.c
+++ b/source3/rpc_client/cli_pipe.c
@@ -136,28 +136,13 @@ static int map_pipe_auth_type_to_rpc_auth_type(enum pipe_auth_type auth_type)
/********************************************************************
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;
}
@@ -204,19 +189,18 @@ static bool rpc_grow_buffer(prs_struct *pdu, size_t size)
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)
+ struct rpc_cli_transport *transport,
+ uint8_t *data, size_t size)
{
struct async_req *result, *subreq;
struct rpc_read_state *state;
@@ -226,48 +210,28 @@ static struct async_req *rpc_read_send(TALLOC_CTX *mem_ctx,
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 = result;
+ return result;
- if (async_post_status(result, ev, NT_STATUS_INVALID_PARAMETER)) {
- return result;
- }
fail:
TALLOC_FREE(result);
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);
@@ -275,61 +239,31 @@ static void rpc_read_np_done(struct async_req *subreq)
req->private_data, 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);
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);
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);
-
+ subreq = state->transport->read_send(state, state->ev,
+ state->data + state->num_read,
+ state->size - state->num_read,
+ state->transport->priv);
if (async_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)
-{
- 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);
@@ -337,19 +271,18 @@ static NTSTATUS rpc_read_recv(struct async_req *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)
+ struct rpc_cli_transport *transport,
+ const uint8_t *data, size_t size)
{
struct async_req *result, *subreq;
struct rpc_write_state *state;
@@ -359,58 +292,35 @@ static struct async_req *rpc_write_send(TALLOC_CTX *mem_ctx,
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 = result;
+ return result;
fail:
TALLOC_FREE(result);
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);
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);
@@ -424,36 +334,17 @@ static void rpc_write_np_done(struct async_req *subreq)
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);
-
+ subreq = state->transport->write_send(state, state->ev,
+ state->data + state->num_written,
+ state->size - state->num_written,
+ state->transport->priv);
if (async_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)
-{
- 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);
@@ -525,9 +416,11 @@ static struct async_req *get_complete_frag_send(TALLOC_CTX *mem_ctx,
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;
@@ -550,8 +443,9 @@ static struct async_req *get_complete_frag_send(TALLOC_CTX *mem_ctx,
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;
@@ -602,9 +496,10 @@ static void get_complete_frag_got_header(struct async_req *subreq)
* 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);
+ 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 (async_req_nomem(subreq, req)) {
return;
}
@@ -1125,19 +1020,18 @@ static NTSTATUS cli_pipe_reset_current_pdu(struct rpc_pipe_client *cli, RPC_HDR
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 async_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,
+ struct rpc_cli_transport *transport,
uint8_t *data, size_t data_len,
uint32_t max_rdata_len)
{
@@ -1150,10 +1044,9 @@ static struct async_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx,
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
@@ -1163,37 +1056,30 @@ static struct async_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx,
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.fn = cli_api_pipe_trans_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, 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.
+ */
+
+ subreq = rpc_write_send(state, ev, transport, data, data_len);
+ if (subreq == NULL) {
+ goto fail;
}
+ subreq->async.fn = cli_api_pipe_write_done;
+ subreq->async.priv = result;
+ return result;
status = NT_STATUS_INVALID_PARAMETER;
@@ -1201,11 +1087,12 @@ static struct async_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx,
if (async_post_status(result, ev, status)) {
return result;
}
+ fail:
TALLOC_FREE(result);
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);
@@ -1213,8 +1100,8 @@ static void cli_api_pipe_np_trans_done(struct async_req *subreq)
req->private_data, 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);
@@ -1223,7 +1110,7 @@ static void cli_api_pipe_np_trans_done(struct async_req *subreq)
async_req_done(req);
}
-static void cli_api_pipe_sock_send_done(struct async_req *subreq)
+static void cli_api_pipe_write_done(struct async_req *subreq)
{
struct async_req *req = talloc_get_type_abort(
subreq->async.priv, struct async_req);
@@ -1231,7 +1118,7 @@ static void cli_api_pipe_sock_send_done(struct async_req *subreq)
req->private_data, struct cli_api_pipe_state);
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);
@@ -1242,29 +1129,38 @@ static void cli_api_pipe_sock_send_done(struct async_req *subreq)
if (async_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);
+ /*
+ * 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.
+ */
+ subreq = state->transport->read_send(state, state->ev, state->rdata,
+ RPC_HEADER_LEN,
+ state->transport->priv);
if (async_req_nomem(subreq, req)) {
return;
}
- subreq->async.fn = cli_api_pipe_sock_read_done;
+ subreq->async.fn = cli_api_pipe_read_done;
subreq->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 cli_api_pipe_state *state = talloc_get_type_abort(
+ req->private_data, 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);
return;
}
+ state->rdata_len = received;
async_req_done(req);
}
@@ -1376,7 +1272,8 @@ static struct async_req *rpc_api_pipe_send(TALLOC_CTX *mem_ctx,
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;
@@ -2194,9 +2091,10 @@ struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx,
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));
+ subreq = rpc_write_send(
+ state, ev, cli->transport,
+ (uint8_t *)prs_data_p(&state->outgoing_frag),
+ prs_offset(&state->outgoing_frag));
if (subreq == NULL) {
status = NT_STATUS_NO_MEMORY;
goto post_status;
@@ -2331,9 +2229,11 @@ static void rpc_api_pipe_req_write_done(struct async_req *subreq)
subreq->async.fn = rpc_api_pipe_req_done;
subreq->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;
}
@@ -2817,8 +2717,8 @@ static NTSTATUS rpc_finish_auth3_bind_send(struct async_req *req,
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;
@@ -3030,56 +2930,33 @@ 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);
-}
-
-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->transport_type == NCACN_NP) {
- E_md4hash(cli->trans.np.cli->pwd.password, nt_hash);
- return true;
- }
-
- return false;
-}
+ struct cli_state *cli = rpc_pipe_np_smb_conn(rpc_cli);
-struct cli_state *rpc_pipe_np_smb_conn(struct rpc_pipe_client *p)
-{
- if (p->transport_type == NCACN_NP) {
- return p->trans.np.cli;
+ if (cli == NULL) {
+ return 0;
}
- return NULL;
+ return cli_set_timeout(cli, timeout);
}
-static int rpc_pipe_destructor(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) {
- 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)));
+ struct cli_state *cli;
- 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->pwd.password, nt_hash);
+ return true;
}
NTSTATUS rpccli_anon_bind_data(TALLOC_CTX *mem_ctx,
@@ -3287,12 +3164,6 @@ NTSTATUS rpccli_kerberos_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.
*/
@@ -3304,14 +3175,13 @@ static NTSTATUS rpc_pipe_open_tcp_port(TALLOC_CTX *mem_ctx, const char *host,
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;
@@ -3332,12 +3202,17 @@ static NTSTATUS rpc_pipe_open_tcp_port(TALLOC_CTX *mem_ctx, const char *host,
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;
@@ -3512,14 +3387,13 @@ NTSTATUS rpc_pipe_open_ncalrpc(TALLOC_CTX *mem_ctx, const char *socket_path,
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;
@@ -3535,26 +3409,29 @@ NTSTATUS rpc_pipe_open_ncalrpc(TALLOC_CTX *mem_ctx, const char *socket_path,
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;
@@ -3563,6 +3440,16 @@ NTSTATUS rpc_pipe_open_ncalrpc(TALLOC_CTX *mem_ctx, const char *socket_path,
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.
@@ -3582,7 +3469,7 @@ static NTSTATUS rpc_pipe_open_np(struct cli_state *cli,
struct rpc_pipe_client **presult)
{
struct rpc_pipe_client *result;
- int fnum;
+ NTSTATUS status;
/* sanity check to protect against crashes */
@@ -3595,17 +3482,6 @@ static NTSTATUS rpc_pipe_open_np(struct cli_state *cli,
return NT_STATUS_NO_MEMORY;
}
- result->transport_type = NCACN_NP;
-
- result->trans.np.pipe_name = cli_get_pipe_name_from_iface(
- result, 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;
@@ -3621,21 +3497,15 @@ static NTSTATUS rpc_pipe_open_np(struct cli_state *cli,
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;
@@ -3725,7 +3595,8 @@ NTSTATUS cli_rpc_pipe_open_noauth(struct cli_state *cli,
}
DEBUG(10,("cli_rpc_pipe_open_noauth: opened pipe %s to machine "
- "%s and bound anonymously.\n", result->trans.np.pipe_name,
+ "%s and bound anonymously.\n",
+ cli_get_pipe_name_from_iface(debug_ctx(), interface),
cli->desthost ));
*presult = result;
@@ -3772,8 +3643,8 @@ static NTSTATUS cli_rpc_pipe_open_ntlmssp_internal(struct cli_state *cli,
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 ));
+ cli_get_pipe_name_from_iface(debug_ctx(), interface),
+ cli->desthost, domain, username ));
*presult = result;
return NT_STATUS_OK;
@@ -3963,9 +3834,9 @@ NTSTATUS cli_rpc_pipe_open_schannel_with_key(struct cli_state *cli,
}
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",
+ cli_get_pipe_name_from_iface(debug_ctx(), interface),
+ cli->desthost, domain ));
*presult = result;
return NT_STATUS_OK;
@@ -4190,8 +4061,6 @@ NTSTATUS rpc_pipe_open_internal(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id
return NT_STATUS_NO_MEMORY;
}
- result->transport_type = NCACN_INTERNAL;
-
result->abstract_syntax = *abstract_syntax;
result->transfer_syntax = ndr_transfer_syntax;
result->dispatch = dispatch;