diff options
Diffstat (limited to 'source4/librpc/rpc/dcerpc.c')
-rw-r--r-- | source4/librpc/rpc/dcerpc.c | 382 |
1 files changed, 180 insertions, 202 deletions
diff --git a/source4/librpc/rpc/dcerpc.c b/source4/librpc/rpc/dcerpc.c index ee7250a4f9..a29e7f7b6b 100644 --- a/source4/librpc/rpc/dcerpc.c +++ b/source4/librpc/rpc/dcerpc.c @@ -3,7 +3,7 @@ raw dcerpc operations Copyright (C) Tim Potter 2003 - Copyright (C) Andrew Tridgell 2003 + Copyright (C) Andrew Tridgell 2003-2005 Copyright (C) Jelmer Vernooij 2004 This program is free software; you can redistribute it and/or modify @@ -25,8 +25,11 @@ #include "dlinklist.h" #include "librpc/gen_ndr/ndr_epmapper.h" -struct dcerpc_interface_list *dcerpc_pipes = NULL; +static struct dcerpc_interface_list *dcerpc_pipes = NULL; +/* + register a dcerpc client interface +*/ NTSTATUS librpc_register_interface(const struct dcerpc_interface_table *interface) { struct dcerpc_interface_list *l = talloc_p(talloc_autofree_context(), @@ -43,52 +46,92 @@ NTSTATUS librpc_register_interface(const struct dcerpc_interface_table *interfac return NT_STATUS_OK; } +/* + return the list of registered dcerpc_pipes +*/ +const struct dcerpc_interface_list *librpc_dcerpc_pipes(void) +{ + return dcerpc_pipes; +} + +/* destroy a dcerpc connection */ +static int dcerpc_connection_destructor(void *ptr) +{ + struct dcerpc_connection *c = ptr; + if (c->transport.shutdown_pipe) { + c->transport.shutdown_pipe(c); + } + return 0; +} + + +/* initialise a dcerpc connection. */ +struct dcerpc_connection *dcerpc_connection_init(TALLOC_CTX *mem_ctx) +{ + struct dcerpc_connection *c; + + c = talloc_zero(mem_ctx, struct dcerpc_connection); + if (!c) { + return NULL; + } + + c->call_id = 1; + c->security_state.auth_info = NULL; + c->security_state.session_key = dcerpc_generic_session_key; + c->security_state.generic_state = NULL; + c->binding_string = NULL; + c->flags = 0; + c->srv_max_xmit_frag = 0; + c->srv_max_recv_frag = 0; + c->pending = NULL; + + talloc_set_destructor(c, dcerpc_connection_destructor); + + return c; +} + /* initialise a dcerpc pipe. */ -struct dcerpc_pipe *dcerpc_pipe_init(void) +struct dcerpc_pipe *dcerpc_pipe_init(TALLOC_CTX *mem_ctx) { struct dcerpc_pipe *p; - p = talloc_p(NULL, struct dcerpc_pipe); + p = talloc_p(mem_ctx, struct dcerpc_pipe); if (!p) { return NULL; } - p->reference_count = 0; - p->call_id = 1; - p->security_state.auth_info = NULL; - p->security_state.session_key = dcerpc_generic_session_key; - p->security_state.generic_state = NULL; - p->binding_string = NULL; - p->flags = 0; - p->srv_max_xmit_frag = 0; - p->srv_max_recv_frag = 0; + p->conn = dcerpc_connection_init(p); + if (p->conn == NULL) { + talloc_free(p); + return NULL; + } + p->last_fault_code = 0; - p->pending = NULL; + p->context_id = 0; + + ZERO_STRUCT(p->syntax); + ZERO_STRUCT(p->transfer_syntax); return p; } + /* choose the next call id to use */ -static uint32_t next_call_id(struct dcerpc_pipe *p) +static uint32_t next_call_id(struct dcerpc_connection *c) { - p->call_id++; - if (p->call_id == 0) { - p->call_id++; + c->call_id++; + if (c->call_id == 0) { + c->call_id++; } - return p->call_id; + return c->call_id; } /* close down a dcerpc over SMB pipe */ void dcerpc_pipe_close(struct dcerpc_pipe *p) { - if (!p) return; - p->reference_count--; - if (p->reference_count <= 0) { - p->transport.shutdown_pipe(p); - talloc_free(p); - } + talloc_free(p); } /* we need to be able to get/set the fragment length without doing a full @@ -124,17 +167,18 @@ void dcerpc_set_auth_length(DATA_BLOB *blob, uint16_t v) /* setup for a ndr pull, also setting up any flags from the binding string */ -static struct ndr_pull *ndr_pull_init_flags(struct dcerpc_pipe *p, DATA_BLOB *blob, TALLOC_CTX *mem_ctx) +static struct ndr_pull *ndr_pull_init_flags(struct dcerpc_connection *c, + DATA_BLOB *blob, TALLOC_CTX *mem_ctx) { struct ndr_pull *ndr = ndr_pull_init_blob(blob, mem_ctx); if (ndr == NULL) return ndr; - if (p->flags & DCERPC_DEBUG_PAD_CHECK) { + if (c->flags & DCERPC_DEBUG_PAD_CHECK) { ndr->flags |= LIBNDR_FLAG_PAD_CHECK; } - if (p->flags & DCERPC_NDR_REF_ALLOC) { + if (c->flags & DCERPC_NDR_REF_ALLOC) { ndr->flags |= LIBNDR_FLAG_REF_ALLOC; } @@ -145,12 +189,12 @@ static struct ndr_pull *ndr_pull_init_flags(struct dcerpc_pipe *p, DATA_BLOB *bl parse a data blob into a dcerpc_packet structure. This handles both input and output packets */ -static NTSTATUS dcerpc_pull(struct dcerpc_pipe *p, DATA_BLOB *blob, TALLOC_CTX *mem_ctx, +static NTSTATUS dcerpc_pull(struct dcerpc_connection *c, DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct dcerpc_packet *pkt) { struct ndr_pull *ndr; - ndr = ndr_pull_init_flags(p, blob, mem_ctx); + ndr = ndr_pull_init_flags(c, blob, mem_ctx); if (!ndr) { return NT_STATUS_NO_MEMORY; } @@ -177,7 +221,7 @@ static NTSTATUS dcerpc_connect_verifier(TALLOC_CTX *mem_ctx, DATA_BLOB *blob) } /* - generate a CONNECT level verifier + check a CONNECT level verifier */ static NTSTATUS dcerpc_check_connect_verifier(DATA_BLOB *blob) { @@ -191,7 +235,7 @@ static NTSTATUS dcerpc_check_connect_verifier(DATA_BLOB *blob) /* parse a possibly signed blob into a dcerpc request packet structure */ -static NTSTATUS dcerpc_pull_request_sign(struct dcerpc_pipe *p, +static NTSTATUS dcerpc_pull_request_sign(struct dcerpc_connection *c, DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct dcerpc_packet *pkt) { @@ -201,12 +245,12 @@ static NTSTATUS dcerpc_pull_request_sign(struct dcerpc_pipe *p, DATA_BLOB auth_blob; /* non-signed packets are simpler */ - if (!p->security_state.auth_info || - !p->security_state.generic_state) { - return dcerpc_pull(p, blob, mem_ctx, pkt); + if (!c->security_state.auth_info || + !c->security_state.generic_state) { + return dcerpc_pull(c, blob, mem_ctx, pkt); } - ndr = ndr_pull_init_flags(p, blob, mem_ctx); + ndr = ndr_pull_init_flags(c, blob, mem_ctx); if (!ndr) { return NT_STATUS_NO_MEMORY; } @@ -226,7 +270,7 @@ static NTSTATUS dcerpc_pull_request_sign(struct dcerpc_pipe *p, } if (pkt->auth_length == 0 && - p->security_state.auth_info->auth_level == DCERPC_AUTH_LEVEL_CONNECT) { + c->security_state.auth_info->auth_level == DCERPC_AUTH_LEVEL_CONNECT) { return NT_STATUS_OK; } @@ -243,7 +287,7 @@ static NTSTATUS dcerpc_pull_request_sign(struct dcerpc_pipe *p, pkt->u.response.stub_and_verifier.length -= auth_blob.length; /* pull the auth structure */ - ndr = ndr_pull_init_flags(p, &auth_blob, mem_ctx); + ndr = ndr_pull_init_flags(c, &auth_blob, mem_ctx); if (!ndr) { return NT_STATUS_NO_MEMORY; } @@ -259,9 +303,9 @@ static NTSTATUS dcerpc_pull_request_sign(struct dcerpc_pipe *p, /* check signature or unseal the packet */ - switch (p->security_state.auth_info->auth_level) { + switch (c->security_state.auth_info->auth_level) { case DCERPC_AUTH_LEVEL_PRIVACY: - status = gensec_unseal_packet(p->security_state.generic_state, + status = gensec_unseal_packet(c->security_state.generic_state, mem_ctx, blob->data + DCERPC_REQUEST_LENGTH, pkt->u.response.stub_and_verifier.length, @@ -274,7 +318,7 @@ static NTSTATUS dcerpc_pull_request_sign(struct dcerpc_pipe *p, break; case DCERPC_AUTH_LEVEL_INTEGRITY: - status = gensec_check_packet(p->security_state.generic_state, + status = gensec_check_packet(c->security_state.generic_state, mem_ctx, pkt->u.response.stub_and_verifier.data, pkt->u.response.stub_and_verifier.length, @@ -308,7 +352,7 @@ static NTSTATUS dcerpc_pull_request_sign(struct dcerpc_pipe *p, /* push a dcerpc request packet into a blob, possibly signing it. */ -static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, +static NTSTATUS dcerpc_push_request_sign(struct dcerpc_connection *c, DATA_BLOB *blob, TALLOC_CTX *mem_ctx, struct dcerpc_packet *pkt) { @@ -317,9 +361,9 @@ static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, DATA_BLOB creds2; /* non-signed packets are simpler */ - if (!p->security_state.auth_info || - !p->security_state.generic_state) { - return dcerpc_push_auth(blob, mem_ctx, pkt, p->security_state.auth_info); + if (!c->security_state.auth_info || + !c->security_state.generic_state) { + return dcerpc_push_auth(blob, mem_ctx, pkt, c->security_state.auth_info); } ndr = ndr_push_init_ctx(mem_ctx); @@ -327,7 +371,7 @@ static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, return NT_STATUS_NO_MEMORY; } - if (p->flags & DCERPC_PUSH_BIGENDIAN) { + if (c->flags & DCERPC_PUSH_BIGENDIAN) { ndr->flags |= LIBNDR_FLAG_BIGENDIAN; } @@ -342,25 +386,25 @@ static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, /* pad to 16 byte multiple in the payload portion of the packet. This matches what w2k3 does */ - p->security_state.auth_info->auth_pad_length = + c->security_state.auth_info->auth_pad_length = (16 - (pkt->u.request.stub_and_verifier.length & 15)) & 15; - ndr_push_zero(ndr, p->security_state.auth_info->auth_pad_length); + ndr_push_zero(ndr, c->security_state.auth_info->auth_pad_length); /* sign or seal the packet */ - switch (p->security_state.auth_info->auth_level) { + switch (c->security_state.auth_info->auth_level) { case DCERPC_AUTH_LEVEL_PRIVACY: case DCERPC_AUTH_LEVEL_INTEGRITY: - p->security_state.auth_info->credentials - = data_blob_talloc(mem_ctx, NULL, gensec_sig_size(p->security_state.generic_state)); - data_blob_clear(&p->security_state.auth_info->credentials); + c->security_state.auth_info->credentials + = data_blob_talloc(mem_ctx, NULL, gensec_sig_size(c->security_state.generic_state)); + data_blob_clear(&c->security_state.auth_info->credentials); break; case DCERPC_AUTH_LEVEL_CONNECT: - status = dcerpc_connect_verifier(mem_ctx, &p->security_state.auth_info->credentials); + status = dcerpc_connect_verifier(mem_ctx, &c->security_state.auth_info->credentials); break; case DCERPC_AUTH_LEVEL_NONE: - p->security_state.auth_info->credentials = data_blob(NULL, 0); + c->security_state.auth_info->credentials = data_blob(NULL, 0); break; default: @@ -373,7 +417,7 @@ static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, } /* add the auth verifier */ - status = ndr_push_dcerpc_auth(ndr, NDR_SCALARS|NDR_BUFFERS, p->security_state.auth_info); + status = ndr_push_dcerpc_auth(ndr, NDR_SCALARS|NDR_BUFFERS, c->security_state.auth_info); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -385,18 +429,19 @@ static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, in these earlier as we don't know the signature length (it could be variable length) */ dcerpc_set_frag_length(blob, blob->length); - dcerpc_set_auth_length(blob, p->security_state.auth_info->credentials.length); + dcerpc_set_auth_length(blob, c->security_state.auth_info->credentials.length); /* sign or seal the packet */ - switch (p->security_state.auth_info->auth_level) { + switch (c->security_state.auth_info->auth_level) { case DCERPC_AUTH_LEVEL_PRIVACY: - status = gensec_seal_packet(p->security_state.generic_state, + status = gensec_seal_packet(c->security_state.generic_state, mem_ctx, blob->data + DCERPC_REQUEST_LENGTH, - pkt->u.request.stub_and_verifier.length+p->security_state.auth_info->auth_pad_length, + pkt->u.request.stub_and_verifier.length + + c->security_state.auth_info->auth_pad_length, blob->data, blob->length - - p->security_state.auth_info->credentials.length, + c->security_state.auth_info->credentials.length, &creds2); if (!NT_STATUS_IS_OK(status)) { return status; @@ -405,13 +450,14 @@ static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, break; case DCERPC_AUTH_LEVEL_INTEGRITY: - status = gensec_sign_packet(p->security_state.generic_state, + status = gensec_sign_packet(c->security_state.generic_state, mem_ctx, blob->data + DCERPC_REQUEST_LENGTH, - pkt->u.request.stub_and_verifier.length+p->security_state.auth_info->auth_pad_length, + pkt->u.request.stub_and_verifier.length + + c->security_state.auth_info->auth_pad_length, blob->data, blob->length - - p->security_state.auth_info->credentials.length, + c->security_state.auth_info->credentials.length, &creds2); if (!NT_STATUS_IS_OK(status)) { return status; @@ -423,7 +469,7 @@ static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, break; case DCERPC_AUTH_LEVEL_NONE: - p->security_state.auth_info->credentials = data_blob(NULL, 0); + c->security_state.auth_info->credentials = data_blob(NULL, 0); break; default: @@ -431,7 +477,7 @@ static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, break; } - data_blob_free(&p->security_state.auth_info->credentials); + data_blob_free(&c->security_state.auth_info->credentials); return NT_STATUS_OK; } @@ -440,11 +486,11 @@ static NTSTATUS dcerpc_push_request_sign(struct dcerpc_pipe *p, /* fill in the fixed values in a dcerpc header */ -static void init_dcerpc_hdr(struct dcerpc_pipe *p, struct dcerpc_packet *pkt) +static void init_dcerpc_hdr(struct dcerpc_connection *c, struct dcerpc_packet *pkt) { pkt->rpc_vers = 5; pkt->rpc_vers_minor = 0; - if (p->flags & DCERPC_PUSH_BIGENDIAN) { + if (c->flags & DCERPC_PUSH_BIGENDIAN) { pkt->drep[0] = 0; } else { pkt->drep[0] = DCERPC_DREP_LE; @@ -465,10 +511,10 @@ struct full_request_state { /* receive a reply to a full request */ -static void full_request_recv(struct dcerpc_pipe *p, DATA_BLOB *blob, +static void full_request_recv(struct dcerpc_connection *c, DATA_BLOB *blob, NTSTATUS status) { - struct full_request_state *state = p->full_request_private; + struct full_request_state *state = c->full_request_private; if (!NT_STATUS_IS_OK(status)) { state->status = status; @@ -482,7 +528,7 @@ static void full_request_recv(struct dcerpc_pipe *p, DATA_BLOB *blob, perform a single pdu synchronous request - used for the bind code this cannot be mixed with normal async requests */ -static NTSTATUS full_request(struct dcerpc_pipe *p, +static NTSTATUS full_request(struct dcerpc_connection *c, TALLOC_CTX *mem_ctx, DATA_BLOB *request_blob, DATA_BLOB *reply_blob) @@ -497,16 +543,16 @@ static NTSTATUS full_request(struct dcerpc_pipe *p, state->reply_blob = reply_blob; state->status = NT_STATUS_OK; - p->transport.recv_data = full_request_recv; - p->full_request_private = state; + c->transport.recv_data = full_request_recv; + c->full_request_private = state; - status = p->transport.send_request(p, request_blob, True); + status = c->transport.send_request(c, request_blob, True); if (!NT_STATUS_IS_OK(status)) { return status; } while (NT_STATUS_IS_OK(state->status) && state->reply_blob) { - struct event_context *ctx = p->transport.event_context(p); + struct event_context *ctx = c->transport.event_context(c); if (event_loop_once(ctx) != 0) { return NT_STATUS_CONNECTION_DISCONNECTED; } @@ -534,41 +580,41 @@ NTSTATUS dcerpc_bind(struct dcerpc_pipe *p, p->syntax = *syntax; p->transfer_syntax = *transfer_syntax; - init_dcerpc_hdr(p, &pkt); + init_dcerpc_hdr(p->conn, &pkt); pkt.ptype = DCERPC_PKT_BIND; pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST; - pkt.call_id = p->call_id; + pkt.call_id = p->conn->call_id; pkt.auth_length = 0; pkt.u.bind.max_xmit_frag = 5840; pkt.u.bind.max_recv_frag = 5840; pkt.u.bind.assoc_group_id = 0; pkt.u.bind.num_contexts = 1; - pkt.u.bind.ctx_list = talloc_p(mem_ctx, struct dcerpc_ctx_list); + pkt.u.bind.ctx_list = talloc_array(mem_ctx, struct dcerpc_ctx_list, 1); if (!pkt.u.bind.ctx_list) { return NT_STATUS_NO_MEMORY; } - pkt.u.bind.ctx_list[0].context_id = 0; + pkt.u.bind.ctx_list[0].context_id = p->context_id; pkt.u.bind.ctx_list[0].num_transfer_syntaxes = 1; pkt.u.bind.ctx_list[0].abstract_syntax = p->syntax; pkt.u.bind.ctx_list[0].transfer_syntaxes = &p->transfer_syntax; pkt.u.bind.auth_info = data_blob(NULL, 0); /* construct the NDR form of the packet */ - status = dcerpc_push_auth(&blob, mem_ctx, &pkt, p->security_state.auth_info); + status = dcerpc_push_auth(&blob, mem_ctx, &pkt, p->conn->security_state.auth_info); if (!NT_STATUS_IS_OK(status)) { return status; } /* send it on its way */ - status = full_request(p, mem_ctx, &blob, &blob); + status = full_request(p->conn, mem_ctx, &blob, &blob); if (!NT_STATUS_IS_OK(status)) { return status; } /* unmarshall the NDR */ - status = dcerpc_pull(p, &blob, mem_ctx, &pkt); + status = dcerpc_pull(p->conn, &blob, mem_ctx, &pkt); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -585,117 +631,49 @@ NTSTATUS dcerpc_bind(struct dcerpc_pipe *p, } if (pkt.ptype == DCERPC_PKT_BIND_ACK) { - p->srv_max_xmit_frag = pkt.u.bind_ack.max_xmit_frag; - p->srv_max_recv_frag = pkt.u.bind_ack.max_recv_frag; + p->conn->srv_max_xmit_frag = pkt.u.bind_ack.max_xmit_frag; + p->conn->srv_max_recv_frag = pkt.u.bind_ack.max_recv_frag; } /* the bind_ack might contain a reply set of credentials */ - if (p->security_state.auth_info && pkt.u.bind_ack.auth_info.length) { + if (p->conn->security_state.auth_info && pkt.u.bind_ack.auth_info.length) { status = ndr_pull_struct_blob(&pkt.u.bind_ack.auth_info, mem_ctx, - p->security_state.auth_info, + p->conn->security_state.auth_info, (ndr_pull_flags_fn_t)ndr_pull_dcerpc_auth); } return status; } -/* - perform a alter context using the given syntax - - the auth_info structure is updated with the reply authentication info - on success -*/ -NTSTATUS dcerpc_alter(struct dcerpc_pipe *p, - TALLOC_CTX *mem_ctx) -{ - struct dcerpc_packet pkt; - NTSTATUS status; - DATA_BLOB blob; - - init_dcerpc_hdr(p, &pkt); - - pkt.ptype = DCERPC_PKT_ALTER; - pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST; - pkt.call_id = p->call_id; - pkt.auth_length = 0; - - pkt.u.alter.max_xmit_frag = 0x2000; - pkt.u.alter.max_recv_frag = 0x2000; - pkt.u.alter.assoc_group_id = 0; - pkt.u.alter.num_contexts = 1; - pkt.u.alter.ctx_list = talloc_p(mem_ctx, struct dcerpc_ctx_list); - if (!pkt.u.alter.ctx_list) { - return NT_STATUS_NO_MEMORY; - } - pkt.u.alter.ctx_list[0].context_id = 0; - pkt.u.alter.ctx_list[0].num_transfer_syntaxes = 1; - pkt.u.alter.ctx_list[0].abstract_syntax = p->syntax; - pkt.u.alter.ctx_list[0].transfer_syntaxes = &p->transfer_syntax; - pkt.u.alter.auth_info = data_blob(NULL, 0); - - /* construct the NDR form of the packet */ - status = dcerpc_push_auth(&blob, mem_ctx, &pkt, p->security_state.auth_info); - if (!NT_STATUS_IS_OK(status)) { - return status; - } - - /* send it on its way */ - status = full_request(p, mem_ctx, &blob, &blob); - if (!NT_STATUS_IS_OK(status)) { - return status; - } - - /* unmarshall the NDR */ - status = dcerpc_pull(p, &blob, mem_ctx, &pkt); - if (!NT_STATUS_IS_OK(status)) { - return status; - } - - if ((pkt.ptype != DCERPC_PKT_ALTER_ACK) || - pkt.u.alter_ack.num_results == 0 || - pkt.u.alter_ack.ctx_list[0].result != 0) { - status = NT_STATUS_UNSUCCESSFUL; - } - - /* the bind_ack might contain a reply set of credentials */ - if (p->security_state.auth_info && pkt.u.alter_ack.auth_info.length) { - status = ndr_pull_struct_blob(&pkt.u.alter_ack.auth_info, - mem_ctx, - p->security_state.auth_info, - (ndr_pull_flags_fn_t)ndr_pull_dcerpc_auth); - } - - return status; -} /* perform a continued bind (and auth3) */ -NTSTATUS dcerpc_auth3(struct dcerpc_pipe *p, +NTSTATUS dcerpc_auth3(struct dcerpc_connection *c, TALLOC_CTX *mem_ctx) { struct dcerpc_packet pkt; NTSTATUS status; DATA_BLOB blob; - init_dcerpc_hdr(p, &pkt); + init_dcerpc_hdr(c, &pkt); pkt.ptype = DCERPC_PKT_AUTH3; pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST; - pkt.call_id = next_call_id(p); + pkt.call_id = next_call_id(c); pkt.auth_length = 0; pkt.u.auth3._pad = 0; pkt.u.auth3.auth_info = data_blob(NULL, 0); /* construct the NDR form of the packet */ - status = dcerpc_push_auth(&blob, mem_ctx, &pkt, p->security_state.auth_info); + status = dcerpc_push_auth(&blob, mem_ctx, &pkt, c->security_state.auth_info); if (!NT_STATUS_IS_OK(status)) { return status; } /* send it on its way */ - status = p->transport.send_request(p, &blob, False); + status = c->transport.send_request(c, &blob, False); if (!NT_STATUS_IS_OK(status)) { return status; } @@ -733,7 +711,7 @@ NTSTATUS dcerpc_bind_byuuid(struct dcerpc_pipe *p, process a fragment received from the transport layer during a request */ -static void dcerpc_request_recv_data(struct dcerpc_pipe *p, +static void dcerpc_request_recv_data(struct dcerpc_connection *c, DATA_BLOB *data, NTSTATUS status) { @@ -743,11 +721,11 @@ static void dcerpc_request_recv_data(struct dcerpc_pipe *p, if (!NT_STATUS_IS_OK(status)) { /* all pending requests get the error */ - while (p->pending) { - req = p->pending; + while (c->pending) { + req = c->pending; req->state = RPC_REQUEST_DONE; req->status = status; - DLIST_REMOVE(p->pending, req); + DLIST_REMOVE(c->pending, req); if (req->async.callback) { req->async.callback(req); } @@ -757,12 +735,12 @@ static void dcerpc_request_recv_data(struct dcerpc_pipe *p, pkt.call_id = 0; - status = dcerpc_pull_request_sign(p, data, (TALLOC_CTX *)data->data, &pkt); + status = dcerpc_pull_request_sign(c, data, (TALLOC_CTX *)data->data, &pkt); /* find the matching request. Notice we match before we check the status. this is ok as a pending call_id can never be zero */ - for (req=p->pending;req;req=req->next) { + for (req=c->pending;req;req=req->next) { if (pkt.call_id == req->call_id) break; } @@ -774,7 +752,7 @@ static void dcerpc_request_recv_data(struct dcerpc_pipe *p, if (!NT_STATUS_IS_OK(status)) { req->status = status; req->state = RPC_REQUEST_DONE; - DLIST_REMOVE(p->pending, req); + DLIST_REMOVE(c->pending, req); if (req->async.callback) { req->async.callback(req); } @@ -782,11 +760,11 @@ static void dcerpc_request_recv_data(struct dcerpc_pipe *p, } if (pkt.ptype == DCERPC_PKT_FAULT) { - DEBUG(5,("rpc fault: %s\n", dcerpc_errstr(p, pkt.u.fault.status))); + DEBUG(5,("rpc fault: %s\n", dcerpc_errstr(c, pkt.u.fault.status))); req->fault_code = pkt.u.fault.status; req->status = NT_STATUS_NET_WRITE_FAULT; req->state = RPC_REQUEST_DONE; - DLIST_REMOVE(p->pending, req); + DLIST_REMOVE(c->pending, req); if (req->async.callback) { req->async.callback(req); } @@ -799,7 +777,7 @@ static void dcerpc_request_recv_data(struct dcerpc_pipe *p, req->fault_code = DCERPC_FAULT_OTHER; req->status = NT_STATUS_NET_WRITE_FAULT; req->state = RPC_REQUEST_DONE; - DLIST_REMOVE(p->pending, req); + DLIST_REMOVE(c->pending, req); if (req->async.callback) { req->async.callback(req); } @@ -816,7 +794,7 @@ static void dcerpc_request_recv_data(struct dcerpc_pipe *p, if (!req->payload.data) { req->status = NT_STATUS_NO_MEMORY; req->state = RPC_REQUEST_DONE; - DLIST_REMOVE(p->pending, req); + DLIST_REMOVE(c->pending, req); if (req->async.callback) { req->async.callback(req); } @@ -828,13 +806,13 @@ static void dcerpc_request_recv_data(struct dcerpc_pipe *p, } if (!(pkt.pfc_flags & DCERPC_PFC_FLAG_LAST)) { - p->transport.send_read(p); + c->transport.send_read(c); return; } /* we've got the full payload */ req->state = RPC_REQUEST_DONE; - DLIST_REMOVE(p->pending, req); + DLIST_REMOVE(c->pending, req); if (!(pkt.drep[0] & DCERPC_DREP_LE)) { req->flags |= DCERPC_PULL_BIGENDIAN; @@ -854,12 +832,12 @@ static void dcerpc_request_recv_data(struct dcerpc_pipe *p, static int dcerpc_req_destructor(void *ptr) { struct rpc_request *req = ptr; - DLIST_REMOVE(req->p->pending, req); + DLIST_REMOVE(req->p->conn->pending, req); return 0; } /* - perform the send size of a async dcerpc request + perform the send side of a async dcerpc request */ struct rpc_request *dcerpc_request_send(struct dcerpc_pipe *p, const struct GUID *object, @@ -873,7 +851,7 @@ struct rpc_request *dcerpc_request_send(struct dcerpc_pipe *p, uint32_t remaining, chunk_size; BOOL first_packet = True; - p->transport.recv_data = dcerpc_request_recv_data; + p->conn->transport.recv_data = dcerpc_request_recv_data; req = talloc_p(mem_ctx, struct rpc_request); if (req == NULL) { @@ -881,7 +859,7 @@ struct rpc_request *dcerpc_request_send(struct dcerpc_pipe *p, } req->p = p; - req->call_id = next_call_id(p); + req->call_id = next_call_id(p->conn); req->status = NT_STATUS_OK; req->state = RPC_REQUEST_PENDING; req->payload = data_blob(NULL, 0); @@ -889,20 +867,20 @@ struct rpc_request *dcerpc_request_send(struct dcerpc_pipe *p, req->fault_code = 0; req->async.callback = NULL; - init_dcerpc_hdr(p, &pkt); + init_dcerpc_hdr(p->conn, &pkt); remaining = stub_data->length; /* we can write a full max_recv_frag size, minus the dcerpc request header size */ - chunk_size = p->srv_max_recv_frag - (DCERPC_MAX_SIGN_SIZE+DCERPC_REQUEST_LENGTH); + chunk_size = p->conn->srv_max_recv_frag - (DCERPC_MAX_SIGN_SIZE+DCERPC_REQUEST_LENGTH); pkt.ptype = DCERPC_PKT_REQUEST; pkt.call_id = req->call_id; pkt.auth_length = 0; pkt.pfc_flags = 0; pkt.u.request.alloc_hint = remaining; - pkt.u.request.context_id = 0; + pkt.u.request.context_id = p->context_id; pkt.u.request.opnum = opnum; if (object) { @@ -911,7 +889,7 @@ struct rpc_request *dcerpc_request_send(struct dcerpc_pipe *p, chunk_size -= ndr_size_GUID(object,0); } - DLIST_ADD(p->pending, req); + DLIST_ADD(p->conn->pending, req); /* we send a series of pdus without waiting for a reply */ while (remaining > 0 || first_packet) { @@ -933,17 +911,17 @@ struct rpc_request *dcerpc_request_send(struct dcerpc_pipe *p, (stub_data->length - remaining); pkt.u.request.stub_and_verifier.length = chunk; - req->status = dcerpc_push_request_sign(p, &blob, mem_ctx, &pkt); + req->status = dcerpc_push_request_sign(p->conn, &blob, mem_ctx, &pkt); if (!NT_STATUS_IS_OK(req->status)) { req->state = RPC_REQUEST_DONE; - DLIST_REMOVE(p->pending, req); + DLIST_REMOVE(p->conn->pending, req); return req; } - req->status = p->transport.send_request(p, &blob, last_frag); + req->status = p->conn->transport.send_request(p->conn, &blob, last_frag); if (!NT_STATUS_IS_OK(req->status)) { req->state = RPC_REQUEST_DONE; - DLIST_REMOVE(p->pending, req); + DLIST_REMOVE(p->conn->pending, req); return req; } @@ -961,7 +939,7 @@ struct rpc_request *dcerpc_request_send(struct dcerpc_pipe *p, */ struct event_context *dcerpc_event_context(struct dcerpc_pipe *p) { - return p->transport.event_context(p); + return p->conn->transport.event_context(p->conn); } @@ -1020,7 +998,7 @@ NTSTATUS dcerpc_request(struct dcerpc_pipe *p, for that to the NDR we initially generated. If they don't match then we know we must have a bug in either the pull or push side of our code */ -static NTSTATUS dcerpc_ndr_validate_in(struct dcerpc_pipe *p, +static NTSTATUS dcerpc_ndr_validate_in(struct dcerpc_connection *c, TALLOC_CTX *mem_ctx, DATA_BLOB blob, size_t struct_size, @@ -1038,7 +1016,7 @@ static NTSTATUS dcerpc_ndr_validate_in(struct dcerpc_pipe *p, return NT_STATUS_NO_MEMORY; } - pull = ndr_pull_init_flags(p, &blob, mem_ctx); + pull = ndr_pull_init_flags(c, &blob, mem_ctx); if (!pull) { return NT_STATUS_NO_MEMORY; } @@ -1084,7 +1062,7 @@ static NTSTATUS dcerpc_ndr_validate_in(struct dcerpc_pipe *p, initially generated. If they don't match then we know we must have a bug in either the pull or push side of our code */ -static NTSTATUS dcerpc_ndr_validate_out(struct dcerpc_pipe *p, +static NTSTATUS dcerpc_ndr_validate_out(struct dcerpc_connection *c, TALLOC_CTX *mem_ctx, void *struct_ptr, size_t struct_size, @@ -1117,7 +1095,7 @@ static NTSTATUS dcerpc_ndr_validate_out(struct dcerpc_pipe *p, blob = ndr_push_blob(push); - pull = ndr_pull_init_flags(p, &blob, mem_ctx); + pull = ndr_pull_init_flags(c, &blob, mem_ctx); if (!pull) { return NT_STATUS_NO_MEMORY; } @@ -1182,7 +1160,7 @@ struct rpc_request *dcerpc_ndr_request_send(struct dcerpc_pipe *p, return NULL; } - if (p->flags & DCERPC_PUSH_BIGENDIAN) { + if (p->conn->flags & DCERPC_PUSH_BIGENDIAN) { push->flags |= LIBNDR_FLAG_BIGENDIAN; } @@ -1198,8 +1176,8 @@ struct rpc_request *dcerpc_ndr_request_send(struct dcerpc_pipe *p, /* retrieve the blob */ request = ndr_push_blob(push); - if (p->flags & DCERPC_DEBUG_VALIDATE_IN) { - status = dcerpc_ndr_validate_in(p, mem_ctx, request, call->struct_size, + if (p->conn->flags & DCERPC_DEBUG_VALIDATE_IN) { + status = dcerpc_ndr_validate_in(p->conn, mem_ctx, request, call->struct_size, call->ndr_push, call->ndr_pull); if (!NT_STATUS_IS_OK(status)) { DEBUG(2,("Validation failed in dcerpc_ndr_request_send - %s\n", @@ -1256,7 +1234,7 @@ NTSTATUS dcerpc_ndr_request_recv(struct rpc_request *req) talloc_free(req); /* prepare for ndr_pull_* */ - pull = ndr_pull_init_flags(p, &response, mem_ctx); + pull = ndr_pull_init_flags(p->conn, &response, mem_ctx); if (!pull) { return NT_STATUS_NO_MEMORY; } @@ -1276,8 +1254,8 @@ NTSTATUS dcerpc_ndr_request_recv(struct rpc_request *req) return status; } - if (p->flags & DCERPC_DEBUG_VALIDATE_OUT) { - status = dcerpc_ndr_validate_out(p, mem_ctx, r, call->struct_size, + if (p->conn->flags & DCERPC_DEBUG_VALIDATE_OUT) { + status = dcerpc_ndr_validate_out(p->conn, mem_ctx, r, call->struct_size, call->ndr_push, call->ndr_pull); if (!NT_STATUS_IS_OK(status)) { dcerpc_log_packet(table, opnum, NDR_OUT, @@ -1329,25 +1307,25 @@ NTSTATUS dcerpc_ndr_request(struct dcerpc_pipe *p, */ const char *dcerpc_server_name(struct dcerpc_pipe *p) { - if (!p->transport.peer_name) { + if (!p->conn->transport.peer_name) { return ""; } - return p->transport.peer_name(p); + return p->conn->transport.peer_name(p->conn); } + /* - a useful function to get the auth_level + get the dcerpc auth_level for a open connection */ - -uint32 dcerpc_auth_level(struct dcerpc_pipe *p) +uint32 dcerpc_auth_level(struct dcerpc_connection *c) { uint8_t auth_level; - if (p->flags & DCERPC_SEAL) { + if (c->flags & DCERPC_SEAL) { auth_level = DCERPC_AUTH_LEVEL_PRIVACY; - } else if (p->flags & DCERPC_SIGN) { + } else if (c->flags & DCERPC_SIGN) { auth_level = DCERPC_AUTH_LEVEL_INTEGRITY; - } else if (p->flags & DCERPC_CONNECT) { + } else if (c->flags & DCERPC_CONNECT) { auth_level = DCERPC_AUTH_LEVEL_CONNECT; } else { auth_level = DCERPC_AUTH_LEVEL_NONE; |