From 1dd08834586484f0a463ba9378e03f742871d517 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 21:37:27 +0100 Subject: Convert rpc_read to tevent_req --- source3/rpc_client/cli_pipe.c | 69 ++++++++++++++++++++++--------------------- 1 file changed, 35 insertions(+), 34 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index 57f49fb83a..f27278de45 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -209,16 +209,17 @@ struct rpc_read_state { 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_cli_transport *transport, - uint8_t *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; @@ -235,33 +236,33 @@ static struct async_req *rpc_read_send(TALLOC_CTX *mem_ctx, goto fail; } subreq->async.fn = rpc_read_done; - subreq->async.priv = result; - return result; + subreq->async.priv = req; + return req; fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } 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; status = state->transport->read_recv(subreq, &received); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } state->num_read += received; if (state->num_read == state->size) { - async_req_done(req); + tevent_req_done(req); return; } @@ -269,16 +270,16 @@ static void rpc_read_done(struct async_req *subreq) state->data + state->num_read, state->size - state->num_read, state->transport->priv); - if (async_req_nomem(subreq, req)) { + if (tevent_req_nomem(subreq, req)) { return; } subreq->async.fn = rpc_read_done; subreq->async.priv = req; } -static NTSTATUS rpc_read_recv(struct async_req *req) +static NTSTATUS rpc_read_recv(struct tevent_req *req) { - return async_req_simple_recv_ntstatus(req); + return tevent_req_simple_recv_ntstatus(req); } struct rpc_write_state { @@ -399,8 +400,8 @@ struct get_complete_frag_state { 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, @@ -408,7 +409,8 @@ static struct async_req *get_complete_frag_send(TALLOC_CTX *mem_ctx, struct rpc_hdr_info *prhdr, prs_struct *pdu) { - struct async_req *result, *subreq; + struct async_req *result; + struct tevent_req *subreq; struct get_complete_frag_state *state; uint32_t pdu_len; NTSTATUS status; @@ -437,8 +439,8 @@ static struct async_req *get_complete_frag_send(TALLOC_CTX *mem_ctx, status = NT_STATUS_NO_MEMORY; goto post_status; } - subreq->async.fn = get_complete_frag_got_header; - subreq->async.priv = result; + tevent_req_set_callback(subreq, get_complete_frag_got_header, + result); return result; } @@ -463,8 +465,8 @@ static struct async_req *get_complete_frag_send(TALLOC_CTX *mem_ctx, status = NT_STATUS_NO_MEMORY; goto post_status; } - subreq->async.fn = get_complete_frag_got_rest; - subreq->async.priv = result; + tevent_req_set_callback(subreq, get_complete_frag_got_rest, + result); return result; } @@ -477,10 +479,10 @@ static struct async_req *get_complete_frag_send(TALLOC_CTX *mem_ctx, return NULL; } -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 async_req *req = tevent_req_callback_data( + subreq, struct async_req); struct get_complete_frag_state *state = talloc_get_type_abort( req->private_data, struct get_complete_frag_state); NTSTATUS status; @@ -515,14 +517,13 @@ static void get_complete_frag_got_header(struct async_req *subreq) if (async_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 async_req *req = tevent_req_callback_data( + subreq, struct async_req); NTSTATUS status; status = rpc_read_recv(subreq); -- cgit From 7573bb758e843912335af7ee3a60b21a31b5118e Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 21:49:19 +0100 Subject: Convert rpc_write to tevent_req --- source3/rpc_client/cli_pipe.c | 111 ++++++++++++++++++++++-------------------- 1 file changed, 57 insertions(+), 54 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index f27278de45..7dcd103456 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -292,16 +292,17 @@ struct rpc_write_state { 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_cli_transport *transport, - const uint8_t *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; @@ -317,33 +318,33 @@ static struct async_req *rpc_write_send(TALLOC_CTX *mem_ctx, goto fail; } subreq->async.fn = rpc_write_done; - subreq->async.priv = result; - return result; + subreq->async.priv = req; + return req; fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } 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; ssize_t written; status = state->transport->write_recv(subreq, &written); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(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; } @@ -351,16 +352,16 @@ static void rpc_write_done(struct async_req *subreq) state->data + state->num_written, state->size - state->num_written, state->transport->priv); - if (async_req_nomem(subreq, req)) { + if (tevent_req_nomem(subreq, req)) { return; } subreq->async.fn = rpc_write_done; subreq->async.priv = req; } -static NTSTATUS rpc_write_recv(struct async_req *req) +static NTSTATUS rpc_write_recv(struct tevent_req *req) { - return async_req_simple_recv_ntstatus(req); + return tevent_req_simple_recv_ntstatus(req); } @@ -1039,7 +1040,7 @@ struct cli_api_pipe_state { }; 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_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, @@ -1049,6 +1050,7 @@ static struct async_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx, uint32_t max_rdata_len) { struct async_req *result, *subreq; + struct tevent_req *subreq2; struct cli_api_pipe_state *state; NTSTATUS status; @@ -1086,12 +1088,11 @@ static struct async_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx, * 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) { + subreq2 = rpc_write_send(state, ev, transport, data, data_len); + if (subreq2 == NULL) { goto fail; } - subreq->async.fn = cli_api_pipe_write_done; - subreq->async.priv = result; + tevent_req_set_callback(subreq2, cli_api_pipe_write_done, result); return result; status = NT_STATUS_INVALID_PARAMETER; @@ -1123,12 +1124,13 @@ static void cli_api_pipe_trans_done(struct async_req *subreq) async_req_done(req); } -static void cli_api_pipe_write_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 async_req *req = tevent_req_callback_data( + subreq, struct async_req); struct cli_api_pipe_state *state = talloc_get_type_abort( req->private_data, struct cli_api_pipe_state); + struct async_req *subreq2; NTSTATUS status; status = rpc_write_recv(subreq); @@ -1148,14 +1150,14 @@ static void cli_api_pipe_write_done(struct async_req *subreq) * 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)) { + subreq2 = state->transport->read_send(state, state->ev, state->rdata, + RPC_HEADER_LEN, + state->transport->priv); + if (async_req_nomem(subreq2, req)) { return; } - subreq->async.fn = cli_api_pipe_read_done; - subreq->async.priv = req; + subreq2->async.fn = cli_api_pipe_read_done; + subreq2->async.priv = req; } static void cli_api_pipe_read_done(struct async_req *subreq) @@ -2044,7 +2046,7 @@ static int rpc_api_pipe_req_state_destructor(struct rpc_api_pipe_req_state *s) 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); @@ -2056,6 +2058,7 @@ struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx, 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; @@ -2104,16 +2107,16 @@ 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( + subreq2 = rpc_write_send( state, ev, cli->transport, (uint8_t *)prs_data_p(&state->outgoing_frag), prs_offset(&state->outgoing_frag)); - if (subreq == NULL) { + 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; @@ -2210,12 +2213,13 @@ static NTSTATUS prepare_next_frag(struct rpc_api_pipe_req_state *state, 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; @@ -2233,14 +2237,14 @@ static void rpc_api_pipe_req_write_done(struct async_req *subreq) } 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, @@ -2250,8 +2254,8 @@ static void rpc_api_pipe_req_write_done(struct async_req *subreq) 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); } } @@ -2528,7 +2532,7 @@ static NTSTATUS rpc_finish_auth3_bind_send(struct async_req *req, 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, @@ -2692,7 +2696,7 @@ static NTSTATUS rpc_finish_auth3_bind_send(struct async_req *req, 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) @@ -2743,15 +2747,14 @@ static NTSTATUS rpc_finish_auth3_bind_send(struct async_req *req, 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); -- cgit From 7a429fb369f608c0aaad20a89baf86aebf615440 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 21:57:19 +0100 Subject: Convert get_complete_frag to tevent_req --- source3/rpc_client/cli_pipe.c | 84 +++++++++++++++++++++---------------------- 1 file changed, 42 insertions(+), 42 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index 7dcd103456..8f39e971c3 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -404,20 +404,20 @@ struct get_complete_frag_state { 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; - struct tevent_req *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; @@ -441,8 +441,8 @@ static struct async_req *get_complete_frag_send(TALLOC_CTX *mem_ctx, goto post_status; } tevent_req_set_callback(subreq, get_complete_frag_got_header, - result); - return result; + req); + return req; } status = parse_rpc_header(cli, prhdr, pdu); @@ -467,42 +467,43 @@ static struct async_req *get_complete_frag_send(TALLOC_CTX *mem_ctx, goto post_status; } tevent_req_set_callback(subreq, get_complete_frag_got_rest, - result); - return result; + req); + return req; } status = NT_STATUS_OK; post_status: - if (async_post_ntstatus(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 tevent_req *subreq) { - struct async_req *req = tevent_req_callback_data( - subreq, 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_nterror(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_nterror(req, status); + tevent_req_nterror(req, status); return; } if (!rpc_grow_buffer(state->pdu, state->prhdr->frag_len)) { - async_req_nterror(req, NT_STATUS_NO_MEMORY); + tevent_req_nterror(req, NT_STATUS_NO_MEMORY); return; } @@ -515,7 +516,7 @@ static void get_complete_frag_got_header(struct tevent_req *subreq) 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)) { + if (tevent_req_nomem(subreq, req)) { return; } tevent_req_set_callback(subreq, get_complete_frag_got_rest, req); @@ -523,22 +524,22 @@ static void get_complete_frag_got_header(struct tevent_req *subreq) static void get_complete_frag_got_rest(struct tevent_req *subreq) { - struct async_req *req = tevent_req_callback_data( - subreq, 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_nterror(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_ntstatus(req); + return tevent_req_simple_recv_ntstatus(req); } /**************************************************************************** @@ -1241,7 +1242,7 @@ static int rpc_api_pipe_state_destructor(struct rpc_api_pipe_state *state) } 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_got_pdu(struct tevent_req *subreq); static struct async_req *rpc_api_pipe_send(TALLOC_CTX *mem_ctx, struct event_context *ev, @@ -1312,6 +1313,7 @@ static void rpc_api_pipe_trans_done(struct async_req *subreq) subreq->async.priv, struct async_req); struct rpc_api_pipe_state *state = talloc_get_type_abort( req->private_data, struct rpc_api_pipe_state); + struct tevent_req *subreq2; NTSTATUS status; uint8_t *rdata = NULL; uint32_t rdata_len = 0; @@ -1345,19 +1347,18 @@ static void rpc_api_pipe_trans_done(struct async_req *subreq) prs_give_memory(&state->incoming_frag, rdata_copy, rdata_len, true); /* Ensure we have enough data for a pdu. */ - subreq = get_complete_frag_send(state, state->ev, state->cli, - &state->rhdr, &state->incoming_frag); - if (async_req_nomem(subreq, req)) { + subreq2 = get_complete_frag_send(state, state->ev, state->cli, + &state->rhdr, &state->incoming_frag); + if (async_req_nomem(subreq2, req)) { return; } - subreq->async.fn = rpc_api_pipe_got_pdu; - subreq->async.priv = req; + tevent_req_set_callback(subreq2, 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; @@ -1442,8 +1443,7 @@ static void rpc_api_pipe_got_pdu(struct async_req *subreq) 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, -- cgit From 545ed5b52e41f495a48370ba4218834337b85dd2 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 22:13:44 +0100 Subject: Convert cli_api_pipe to tevent_req --- source3/rpc_client/cli_pipe.c | 103 ++++++++++++++++++++++-------------------- 1 file changed, 53 insertions(+), 50 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index 8f39e971c3..d39fb8516f 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -1044,19 +1044,20 @@ 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_cli_transport *transport, - 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; @@ -1080,8 +1081,8 @@ static struct async_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx, goto post_status; } subreq->async.fn = cli_api_pipe_trans_done; - subreq->async.priv = result; - return result; + subreq->async.priv = req; + return req; } /* @@ -1093,56 +1094,59 @@ static struct async_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx, if (subreq2 == NULL) { goto fail; } - tevent_req_set_callback(subreq2, cli_api_pipe_write_done, result); - return result; + tevent_req_set_callback(subreq2, cli_api_pipe_write_done, req); + return req; status = NT_STATUS_INVALID_PARAMETER; post_status: - if (async_post_ntstatus(result, ev, status)) { - return result; + if (NT_STATUS_IS_OK(status)) { + tevent_req_done(req); + } else { + tevent_req_nterror(req, status); } + return tevent_req_post(req, ev); fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } 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 = state->transport->trans_recv(subreq, state, &state->rdata, &state->rdata_len); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } - async_req_done(req); + tevent_req_done(req); } static void cli_api_pipe_write_done(struct tevent_req *subreq) { - struct async_req *req = tevent_req_callback_data( - subreq, 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 = rpc_write_recv(subreq); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(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; } @@ -1154,7 +1158,7 @@ static void cli_api_pipe_write_done(struct tevent_req *subreq) subreq2 = state->transport->read_send(state, state->ev, state->rdata, RPC_HEADER_LEN, state->transport->priv); - if (async_req_nomem(subreq2, req)) { + if (tevent_req_nomem(subreq2, req)) { return; } subreq2->async.fn = cli_api_pipe_read_done; @@ -1163,31 +1167,31 @@ static void cli_api_pipe_write_done(struct tevent_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); + 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 = state->transport->read_recv(subreq, &received); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } state->rdata_len = received; - async_req_done(req); + 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_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { return status; } @@ -1241,7 +1245,7 @@ static int rpc_api_pipe_state_destructor(struct rpc_api_pipe_state *state) return 0; } -static void rpc_api_pipe_trans_done(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, @@ -1250,7 +1254,8 @@ static struct async_req *rpc_api_pipe_send(TALLOC_CTX *mem_ctx, 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; @@ -1295,8 +1300,7 @@ static struct async_req *rpc_api_pipe_send(TALLOC_CTX *mem_ctx, 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: @@ -1307,13 +1311,12 @@ static struct async_req *rpc_api_pipe_send(TALLOC_CTX *mem_ctx, 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); - struct tevent_req *subreq2; NTSTATUS status; uint8_t *rdata = NULL; uint32_t rdata_len = 0; @@ -1347,12 +1350,12 @@ static void rpc_api_pipe_trans_done(struct async_req *subreq) prs_give_memory(&state->incoming_frag, rdata_copy, rdata_len, true); /* Ensure we have enough data for a pdu. */ - subreq2 = get_complete_frag_send(state, state->ev, state->cli, - &state->rhdr, &state->incoming_frag); - if (async_req_nomem(subreq2, req)) { + subreq = get_complete_frag_send(state, state->ev, state->cli, + &state->rhdr, &state->incoming_frag); + if (async_req_nomem(subreq, req)) { return; } - tevent_req_set_callback(subreq2, rpc_api_pipe_got_pdu, req); + tevent_req_set_callback(subreq, rpc_api_pipe_got_pdu, req); } static void rpc_api_pipe_got_pdu(struct tevent_req *subreq) -- cgit From f88990ec7ec92f0b8371419bfdf777d1d624abf9 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 22:33:00 +0100 Subject: Convert rpc_api_pipe to tevent_req --- source3/rpc_client/cli_pipe.c | 149 ++++++++++++++++++++---------------------- 1 file changed, 71 insertions(+), 78 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index d39fb8516f..b87c8a6815 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -1248,20 +1248,19 @@ static int rpc_api_pipe_state_destructor(struct rpc_api_pipe_state *state) 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, - struct rpc_pipe_client *cli, - prs_struct *data, /* Outgoing PDU */ - uint8_t expected_pkt_type) +static struct tevent_req *rpc_api_pipe_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + struct rpc_pipe_client *cli, + prs_struct *data, /* Outgoing PDU */ + uint8_t expected_pkt_type) { - struct async_req *result; - struct tevent_req *subreq; + struct tevent_req *req, *subreq; struct rpc_api_pipe_state *state; uint16_t max_recv_frag; NTSTATUS status; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_api_pipe_state)) { + req = tevent_req_create(mem_ctx, &state, struct rpc_api_pipe_state); + if (req == NULL) { return NULL; } state->ev = ev; @@ -1297,26 +1296,25 @@ static struct async_req *rpc_api_pipe_send(TALLOC_CTX *mem_ctx, (uint8_t *)prs_data_p(data), prs_offset(data), max_recv_frag); if (subreq == NULL) { - status = NT_STATUS_NO_MEMORY; - goto post_status; + goto fail; } - tevent_req_set_callback(subreq, rpc_api_pipe_trans_done, result); - return result; + tevent_req_set_callback(subreq, rpc_api_pipe_trans_done, req); + return req; post_status: - if (async_post_ntstatus(result, ev, status)) { - return result; - } - TALLOC_FREE(result); + tevent_req_nterror(req, status); + return tevent_req_post(req, ev); + fail: + TALLOC_FREE(req); return NULL; } static void rpc_api_pipe_trans_done(struct tevent_req *subreq) { - 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); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_api_pipe_state *state = tevent_req_data( + req, struct rpc_api_pipe_state); NTSTATUS status; uint8_t *rdata = NULL; uint32_t rdata_len = 0; @@ -1326,14 +1324,14 @@ static void rpc_api_pipe_trans_done(struct tevent_req *subreq) TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { DEBUG(5, ("cli_api_pipe failed: %s\n", nt_errstr(status))); - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } if (rdata == NULL) { DEBUG(3,("rpc_api_pipe: %s failed to return data.\n", rpccli_pipe_txt(debug_ctx(), state->cli))); - async_req_done(req); + tevent_req_done(req); return; } @@ -1344,7 +1342,7 @@ static void rpc_api_pipe_trans_done(struct tevent_req *subreq) */ rdata_copy = (char *)memdup(rdata, rdata_len); TALLOC_FREE(rdata); - if (async_req_nomem(rdata_copy, req)) { + if (tevent_req_nomem(rdata_copy, req)) { return; } prs_give_memory(&state->incoming_frag, rdata_copy, rdata_len, true); @@ -1352,7 +1350,7 @@ static void rpc_api_pipe_trans_done(struct tevent_req *subreq) /* Ensure we have enough data for a pdu. */ subreq = get_complete_frag_send(state, state->ev, state->cli, &state->rhdr, &state->incoming_frag); - if (async_req_nomem(subreq, req)) { + if (tevent_req_nomem(subreq, req)) { return; } tevent_req_set_callback(subreq, rpc_api_pipe_got_pdu, req); @@ -1360,10 +1358,10 @@ static void rpc_api_pipe_trans_done(struct tevent_req *subreq) static void rpc_api_pipe_got_pdu(struct tevent_req *subreq) { - 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); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_api_pipe_state *state = tevent_req_data( + req, struct rpc_api_pipe_state); NTSTATUS status; char *rdata = NULL; uint32_t rdata_len = 0; @@ -1373,7 +1371,7 @@ static void rpc_api_pipe_got_pdu(struct tevent_req *subreq) if (!NT_STATUS_IS_OK(status)) { DEBUG(5, ("get_complete_frag failed: %s\n", nt_errstr(status))); - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } @@ -1388,7 +1386,7 @@ static void rpc_api_pipe_got_pdu(struct tevent_req *subreq) nt_errstr(status))); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } @@ -1412,13 +1410,13 @@ static void rpc_api_pipe_got_pdu(struct tevent_req *subreq) "%s\n", state->incoming_pdu.bigendian_data?"big":"little", state->incoming_frag.bigendian_data?"big":"little")); - async_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + tevent_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_nterror(req, NT_STATUS_NO_MEMORY); + tevent_req_nterror(req, NT_STATUS_NO_MEMORY); return; } @@ -1429,7 +1427,7 @@ static void rpc_api_pipe_got_pdu(struct tevent_req *subreq) status = cli_pipe_reset_current_pdu(state->cli, &state->rhdr, &state->incoming_frag); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } @@ -1437,26 +1435,26 @@ static void rpc_api_pipe_got_pdu(struct tevent_req *subreq) DEBUG(10,("rpc_api_pipe: %s returned %u bytes.\n", rpccli_pipe_txt(debug_ctx(), state->cli), (unsigned)prs_data_size(&state->incoming_pdu))); - async_req_done(req); + tevent_req_done(req); return; } subreq = get_complete_frag_send(state, state->ev, state->cli, &state->rhdr, &state->incoming_frag); - if (async_req_nomem(subreq, req)) { + if (tevent_req_nomem(subreq, req)) { return; } 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, +static NTSTATUS rpc_api_pipe_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx, prs_struct *reply_pdu) { - struct rpc_api_pipe_state *state = talloc_get_type_abort( - req->private_data, struct rpc_api_pipe_state); + struct rpc_api_pipe_state *state = tevent_req_data( + req, struct rpc_api_pipe_state); NTSTATUS status; - if (async_req_is_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { return status; } @@ -2050,7 +2048,7 @@ static int rpc_api_pipe_req_state_destructor(struct rpc_api_pipe_req_state *s) } static void rpc_api_pipe_req_write_done(struct tevent_req *subreq); -static void rpc_api_pipe_req_done(struct async_req *subreq); +static void rpc_api_pipe_req_done(struct tevent_req *subreq); static NTSTATUS prepare_next_frag(struct rpc_api_pipe_req_state *state, bool *is_last_frag); @@ -2060,8 +2058,8 @@ struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx, uint8_t op_num, prs_struct *req_data) { - struct async_req *result, *subreq; - struct tevent_req *subreq2; + struct async_req *result; + struct tevent_req *subreq; struct rpc_api_pipe_req_state *state; NTSTATUS status; bool is_last_frag; @@ -2088,8 +2086,7 @@ struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx, if (!prs_init(&state->outgoing_frag, cli->max_xmit_frag, state, MARSHALL)) { - status = NT_STATUS_NO_MEMORY; - goto post_status; + goto fail; } talloc_set_destructor(state, rpc_api_pipe_req_state_destructor); @@ -2104,21 +2101,19 @@ struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx, &state->outgoing_frag, RPC_RESPONSE); if (subreq == NULL) { - status = NT_STATUS_NO_MEMORY; - goto post_status; + goto fail; } - subreq->async.fn = rpc_api_pipe_req_done; - subreq->async.priv = result; + tevent_req_set_callback(subreq, rpc_api_pipe_req_done, + result); } else { - subreq2 = rpc_write_send( + subreq = 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; + if (subreq == NULL) { + goto fail; } - tevent_req_set_callback(subreq2, rpc_api_pipe_req_write_done, + tevent_req_set_callback(subreq, rpc_api_pipe_req_write_done, result); } return result; @@ -2127,6 +2122,7 @@ struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx, if (async_post_ntstatus(result, ev, status)) { return result; } + fail: TALLOC_FREE(result); return NULL; } @@ -2222,7 +2218,6 @@ static void rpc_api_pipe_req_write_done(struct tevent_req *subreq) 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; @@ -2240,14 +2235,13 @@ static void rpc_api_pipe_req_write_done(struct tevent_req *subreq) } if (is_last_frag) { - subreq2 = rpc_api_pipe_send(state, state->ev, state->cli, + subreq = rpc_api_pipe_send(state, state->ev, state->cli, &state->outgoing_frag, RPC_RESPONSE); - if (async_req_nomem(subreq2, req)) { + if (async_req_nomem(subreq, req)) { return; } - subreq2->async.fn = rpc_api_pipe_req_done; - subreq2->async.priv = req; + tevent_req_set_callback(subreq, rpc_api_pipe_req_done, req); } else { subreq = rpc_write_send( state, state->ev, @@ -2262,10 +2256,10 @@ static void rpc_api_pipe_req_write_done(struct tevent_req *subreq) } } -static void rpc_api_pipe_req_done(struct async_req *subreq) +static void rpc_api_pipe_req_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); NTSTATUS status; @@ -2530,7 +2524,7 @@ static int rpc_pipe_bind_state_destructor(struct rpc_pipe_bind_state *state) return 0; } -static void rpc_pipe_bind_step_one_done(struct async_req *subreq); +static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq); static NTSTATUS rpc_finish_auth3_bind_send(struct async_req *req, struct rpc_pipe_bind_state *state, struct rpc_hdr_info *phdr, @@ -2540,14 +2534,15 @@ static NTSTATUS rpc_finish_spnego_ntlmssp_bind_send(struct async_req *req, struct rpc_pipe_bind_state *state, struct rpc_hdr_info *phdr, prs_struct *reply_pdu); -static void rpc_bind_ntlmssp_api_done(struct async_req *subreq); +static void rpc_bind_ntlmssp_api_done(struct tevent_req *subreq); struct async_req *rpc_pipe_bind_send(TALLOC_CTX *mem_ctx, struct event_context *ev, struct rpc_pipe_client *cli, struct cli_pipe_auth_data *auth) { - struct async_req *result, *subreq; + struct async_req *result; + struct tevent_req *subreq; struct rpc_pipe_bind_state *state; NTSTATUS status; @@ -2585,25 +2580,24 @@ struct async_req *rpc_pipe_bind_send(TALLOC_CTX *mem_ctx, subreq = rpc_api_pipe_send(state, ev, cli, &state->rpc_out, RPC_BINDACK); if (subreq == NULL) { - status = NT_STATUS_NO_MEMORY; - goto post_status; + goto fail; } - subreq->async.fn = rpc_pipe_bind_step_one_done; - subreq->async.priv = result; + tevent_req_set_callback(subreq, rpc_pipe_bind_step_one_done, result); return result; post_status: if (async_post_ntstatus(result, ev, status)) { return result; } + fail: TALLOC_FREE(result); return NULL; } -static void rpc_pipe_bind_step_one_done(struct async_req *subreq) +static void rpc_pipe_bind_step_one_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_pipe_bind_state *state = talloc_get_type_abort( req->private_data, struct rpc_pipe_bind_state); prs_struct reply_pdu; @@ -2779,7 +2773,7 @@ static NTSTATUS rpc_finish_spnego_ntlmssp_bind_send(struct async_req *req, DATA_BLOB client_reply = data_blob_null; DATA_BLOB tmp_blob = data_blob_null; RPC_HDR_AUTH hdr_auth; - struct async_req *subreq; + struct tevent_req *subreq; NTSTATUS status; if ((phdr->auth_len == 0) @@ -2857,15 +2851,14 @@ static NTSTATUS rpc_finish_spnego_ntlmssp_bind_send(struct async_req *req, if (subreq == NULL) { return NT_STATUS_NO_MEMORY; } - subreq->async.fn = rpc_bind_ntlmssp_api_done; - subreq->async.priv = req; + tevent_req_set_callback(subreq, rpc_bind_ntlmssp_api_done, req); return NT_STATUS_OK; } -static void rpc_bind_ntlmssp_api_done(struct async_req *subreq) +static void rpc_bind_ntlmssp_api_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_pipe_bind_state *state = talloc_get_type_abort( req->private_data, struct rpc_pipe_bind_state); DATA_BLOB server_spnego_response = data_blob_null; -- cgit From 1724f2ff316d20dd7e67fed59f467d4a3e187114 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 22:49:29 +0100 Subject: Convert rpc_api_pipe_req to tevent_req --- source3/rpc_client/cli_pipe.c | 74 ++++++++++++++++++++----------------------- 1 file changed, 35 insertions(+), 39 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index b87c8a6815..8fc05e233e 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -2052,20 +2052,20 @@ static void rpc_api_pipe_req_done(struct tevent_req *subreq); static NTSTATUS prepare_next_frag(struct rpc_api_pipe_req_state *state, bool *is_last_frag); -struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx, - struct event_context *ev, - struct rpc_pipe_client *cli, - uint8_t op_num, - prs_struct *req_data) +struct tevent_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + struct rpc_pipe_client *cli, + uint8_t op_num, + prs_struct *req_data) { - struct async_req *result; - struct tevent_req *subreq; + struct tevent_req *req, *subreq; struct rpc_api_pipe_req_state *state; NTSTATUS status; bool is_last_frag; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_api_pipe_req_state)) { + req = tevent_req_create(mem_ctx, &state, + struct rpc_api_pipe_req_state); + if (req == NULL) { return NULL; } state->ev = ev; @@ -2103,8 +2103,7 @@ struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx, if (subreq == NULL) { goto fail; } - tevent_req_set_callback(subreq, rpc_api_pipe_req_done, - result); + tevent_req_set_callback(subreq, rpc_api_pipe_req_done, req); } else { subreq = rpc_write_send( state, ev, cli->transport, @@ -2114,16 +2113,15 @@ struct async_req *rpc_api_pipe_req_send(TALLOC_CTX *mem_ctx, goto fail; } tevent_req_set_callback(subreq, rpc_api_pipe_req_write_done, - result); + req); } - return result; + return req; post_status: - if (async_post_ntstatus(result, ev, status)) { - return result; - } + tevent_req_nterror(req, status); + return tevent_req_post(req, ev); fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } @@ -2214,23 +2212,23 @@ static NTSTATUS prepare_next_frag(struct rpc_api_pipe_req_state *state, static void rpc_api_pipe_req_write_done(struct tevent_req *subreq) { - 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 tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_api_pipe_req_state *state = tevent_req_data( + req, struct rpc_api_pipe_req_state); NTSTATUS status; bool is_last_frag; status = rpc_write_recv(subreq); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } status = prepare_next_frag(state, &is_last_frag); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } @@ -2238,7 +2236,7 @@ static void rpc_api_pipe_req_write_done(struct tevent_req *subreq) subreq = rpc_api_pipe_send(state, state->ev, state->cli, &state->outgoing_frag, RPC_RESPONSE); - if (async_req_nomem(subreq, req)) { + if (tevent_req_nomem(subreq, req)) { return; } tevent_req_set_callback(subreq, rpc_api_pipe_req_done, req); @@ -2248,7 +2246,7 @@ static void rpc_api_pipe_req_write_done(struct tevent_req *subreq) state->cli->transport, (uint8_t *)prs_data_p(&state->outgoing_frag), prs_offset(&state->outgoing_frag)); - if (async_req_nomem(subreq, req)) { + if (tevent_req_nomem(subreq, req)) { return; } tevent_req_set_callback(subreq, rpc_api_pipe_req_write_done, @@ -2258,29 +2256,29 @@ static void rpc_api_pipe_req_write_done(struct tevent_req *subreq) static void rpc_api_pipe_req_done(struct tevent_req *subreq) { - 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 tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_api_pipe_req_state *state = tevent_req_data( + req, struct rpc_api_pipe_req_state); NTSTATUS status; status = rpc_api_pipe_recv(subreq, state, &state->reply_pdu); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } - async_req_done(req); + tevent_req_done(req); } -NTSTATUS rpc_api_pipe_req_recv(struct async_req *req, TALLOC_CTX *mem_ctx, +NTSTATUS rpc_api_pipe_req_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx, prs_struct *reply_pdu) { - struct rpc_api_pipe_req_state *state = talloc_get_type_abort( - req->private_data, struct rpc_api_pipe_req_state); + struct rpc_api_pipe_req_state *state = tevent_req_data( + req, struct rpc_api_pipe_req_state); NTSTATUS status; - if (async_req_is_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { /* * We always have to initialize to reply pdu, even if there is * none. The rpccli_* caller routines expect this. @@ -2308,7 +2306,7 @@ NTSTATUS rpc_api_pipe_req(TALLOC_CTX *mem_ctx, struct rpc_pipe_client *cli, { TALLOC_CTX *frame = talloc_stackframe(); struct event_context *ev; - struct async_req *req; + struct tevent_req *req; NTSTATUS status = NT_STATUS_NO_MEMORY; ev = event_context_init(frame); @@ -2321,9 +2319,7 @@ NTSTATUS rpc_api_pipe_req(TALLOC_CTX *mem_ctx, struct rpc_pipe_client *cli, goto fail; } - while (req->state < ASYNC_REQ_DONE) { - event_loop_once(ev); - } + tevent_req_poll(req, ev); status = rpc_api_pipe_req_recv(req, mem_ctx, out_data); fail: -- cgit From 22badee4bf7d75a4337a3826847070ebd7464ce8 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 23:03:37 +0100 Subject: Convert rpc_cli_transport->read to tevent_req --- source3/rpc_client/cli_pipe.c | 37 +++++++++++--------------- source3/rpc_client/rpc_transport_np.c | 43 +++++++++++++++--------------- source3/rpc_client/rpc_transport_smbd.c | 47 +++++++++++++++------------------ source3/rpc_client/rpc_transport_sock.c | 41 ++++++++++++++-------------- 4 files changed, 80 insertions(+), 88 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index 8fc05e233e..d4abe3c4fd 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -207,15 +207,14 @@ struct rpc_read_state { size_t num_read; }; -static void rpc_read_done(struct async_req *subreq); +static void rpc_read_done(struct tevent_req *subreq); 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 tevent_req *req; - struct async_req *subreq; + struct tevent_req *req, *subreq; struct rpc_read_state *state; req = tevent_req_create(mem_ctx, &state, struct rpc_read_state); @@ -235,8 +234,7 @@ static struct tevent_req *rpc_read_send(TALLOC_CTX *mem_ctx, if (subreq == NULL) { goto fail; } - subreq->async.fn = rpc_read_done; - subreq->async.priv = req; + tevent_req_set_callback(subreq, rpc_read_done, req); return req; fail: @@ -244,10 +242,10 @@ static struct tevent_req *rpc_read_send(TALLOC_CTX *mem_ctx, return NULL; } -static void rpc_read_done(struct async_req *subreq) +static void rpc_read_done(struct tevent_req *subreq) { - struct tevent_req *req = talloc_get_type_abort( - subreq->async.priv, struct tevent_req); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); struct rpc_read_state *state = tevent_req_data( req, struct rpc_read_state); NTSTATUS status; @@ -273,8 +271,7 @@ static void rpc_read_done(struct async_req *subreq) if (tevent_req_nomem(subreq, req)) { return; } - subreq->async.fn = rpc_read_done; - subreq->async.priv = req; + tevent_req_set_callback(subreq, rpc_read_done, req); } static NTSTATUS rpc_read_recv(struct tevent_req *req) @@ -1042,7 +1039,7 @@ struct cli_api_pipe_state { 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 void cli_api_pipe_read_done(struct tevent_req *subreq); static struct tevent_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx, struct event_context *ev, @@ -1135,7 +1132,6 @@ static void cli_api_pipe_write_done(struct tevent_req *subreq) 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 = rpc_write_recv(subreq); @@ -1155,20 +1151,19 @@ static void cli_api_pipe_write_done(struct tevent_req *subreq) * 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)) { + subreq = state->transport->read_send(state, state->ev, state->rdata, + RPC_HEADER_LEN, + state->transport->priv); + if (tevent_req_nomem(subreq, req)) { return; } - subreq2->async.fn = cli_api_pipe_read_done; - subreq2->async.priv = req; + tevent_req_set_callback(subreq, cli_api_pipe_read_done, req); } -static void cli_api_pipe_read_done(struct async_req *subreq) +static void cli_api_pipe_read_done(struct tevent_req *subreq) { - struct tevent_req *req = talloc_get_type_abort( - subreq->async.priv, struct tevent_req); + 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); NTSTATUS status; diff --git a/source3/rpc_client/rpc_transport_np.c b/source3/rpc_client/rpc_transport_np.c index 80ff384046..7da4421329 100644 --- a/source3/rpc_client/rpc_transport_np.c +++ b/source3/rpc_client/rpc_transport_np.c @@ -120,18 +120,19 @@ struct rpc_np_read_state { static void rpc_np_read_done(struct async_req *subreq); -static struct async_req *rpc_np_read_send(TALLOC_CTX *mem_ctx, - struct event_context *ev, - uint8_t *data, size_t size, - void *priv) +static struct tevent_req *rpc_np_read_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + uint8_t *data, size_t size, + void *priv) { struct rpc_transport_np_state *np_transport = talloc_get_type_abort( priv, struct rpc_transport_np_state); - struct async_req *result, *subreq; + struct tevent_req *req; + struct async_req *subreq; struct rpc_np_read_state *state; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_np_read_state)) { + req = tevent_req_create(mem_ctx, &state, struct rpc_np_read_state); + if (req == NULL) { return NULL; } state->data = data; @@ -143,19 +144,19 @@ static struct async_req *rpc_np_read_send(TALLOC_CTX *mem_ctx, goto fail; } subreq->async.fn = rpc_np_read_done; - subreq->async.priv = result; - return result; + subreq->async.priv = req; + return req; fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } static void rpc_np_read_done(struct async_req *subreq) { - struct async_req *req = talloc_get_type_abort( - subreq->async.priv, struct async_req); - struct rpc_np_read_state *state = talloc_get_type_abort( - req->private_data, struct rpc_np_read_state); + struct tevent_req *req = talloc_get_type_abort( + subreq->async.priv, struct tevent_req); + struct rpc_np_read_state *state = tevent_req_data( + req, struct rpc_np_read_state); NTSTATUS status; uint8_t *rcvbuf; @@ -169,27 +170,27 @@ static void rpc_np_read_done(struct async_req *subreq) } if (!NT_STATUS_IS_OK(status)) { TALLOC_FREE(subreq); - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } if (state->received > state->size) { TALLOC_FREE(subreq); - async_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE); + tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE); return; } memcpy(state->data, rcvbuf, state->received); - async_req_done(req); + tevent_req_done(req); } -static NTSTATUS rpc_np_read_recv(struct async_req *req, ssize_t *preceived) +static NTSTATUS rpc_np_read_recv(struct tevent_req *req, ssize_t *preceived) { - struct rpc_np_read_state *state = talloc_get_type_abort( - req->private_data, struct rpc_np_read_state); + struct rpc_np_read_state *state = tevent_req_data( + req, struct rpc_np_read_state); NTSTATUS status; - if (async_req_is_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { return status; } *preceived = state->received; diff --git a/source3/rpc_client/rpc_transport_smbd.c b/source3/rpc_client/rpc_transport_smbd.c index bf4aa65dae..85fe3d86ce 100644 --- a/source3/rpc_client/rpc_transport_smbd.c +++ b/source3/rpc_client/rpc_transport_smbd.c @@ -505,20 +505,20 @@ struct rpc_smbd_read_state { ssize_t received; }; -static void rpc_smbd_read_done(struct async_req *subreq); +static void rpc_smbd_read_done(struct tevent_req *subreq); -static struct async_req *rpc_smbd_read_send(TALLOC_CTX *mem_ctx, - struct event_context *ev, - uint8_t *data, size_t size, - void *priv) +static struct tevent_req *rpc_smbd_read_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + uint8_t *data, size_t size, + void *priv) { struct rpc_transport_smbd_state *transp = talloc_get_type_abort( priv, struct rpc_transport_smbd_state); - struct async_req *result, *subreq; + struct tevent_req *req, *subreq; struct rpc_smbd_read_state *state; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_smbd_read_state)) { + req = tevent_req_create(mem_ctx, &state, struct rpc_smbd_read_state); + if (req == NULL) { return NULL; } state->sub_transp = transp->sub_transp; @@ -533,40 +533,37 @@ static struct async_req *rpc_smbd_read_send(TALLOC_CTX *mem_ctx, rpc_cli_smbd_stdout_reader, transp->conn) == NULL) { goto fail; } - - subreq->async.fn = rpc_smbd_read_done; - subreq->async.priv = result; - return result; - + tevent_req_set_callback(subreq, rpc_smbd_read_done, req); + return req; fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } -static void rpc_smbd_read_done(struct async_req *subreq) +static void rpc_smbd_read_done(struct tevent_req *subreq) { - struct async_req *req = talloc_get_type_abort( - subreq->async.priv, struct async_req); - struct rpc_smbd_read_state *state = talloc_get_type_abort( - req->private_data, struct rpc_smbd_read_state); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_smbd_read_state *state = tevent_req_data( + req, struct rpc_smbd_read_state); NTSTATUS status; status = state->sub_transp->read_recv(subreq, &state->received); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } - async_req_done(req); + tevent_req_done(req); } -static NTSTATUS rpc_smbd_read_recv(struct async_req *req, ssize_t *preceived) +static NTSTATUS rpc_smbd_read_recv(struct tevent_req *req, ssize_t *preceived) { - struct rpc_smbd_read_state *state = talloc_get_type_abort( - req->private_data, struct rpc_smbd_read_state); + struct rpc_smbd_read_state *state = tevent_req_data( + req, struct rpc_smbd_read_state); NTSTATUS status; - if (async_req_is_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { return status; } *preceived = state->received; diff --git a/source3/rpc_client/rpc_transport_sock.c b/source3/rpc_client/rpc_transport_sock.c index b1d9d8fbe1..c9fcbcc07e 100644 --- a/source3/rpc_client/rpc_transport_sock.c +++ b/source3/rpc_client/rpc_transport_sock.c @@ -41,19 +41,18 @@ struct rpc_sock_read_state { static void rpc_sock_read_done(struct tevent_req *subreq); -static struct async_req *rpc_sock_read_send(TALLOC_CTX *mem_ctx, - struct event_context *ev, - uint8_t *data, size_t size, - void *priv) +static struct tevent_req *rpc_sock_read_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + uint8_t *data, size_t size, + void *priv) { struct rpc_transport_sock_state *sock_transp = talloc_get_type_abort( priv, struct rpc_transport_sock_state); - struct async_req *result; - struct tevent_req *subreq; + struct tevent_req *req, *subreq; struct rpc_sock_read_state *state; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_sock_read_state)) { + req = tevent_req_create(mem_ctx, &state, struct rpc_sock_read_state); + if (req == NULL) { return NULL; } @@ -61,36 +60,36 @@ static struct async_req *rpc_sock_read_send(TALLOC_CTX *mem_ctx, if (subreq == NULL) { goto fail; } - tevent_req_set_callback(subreq, rpc_sock_read_done, result); - return result; + tevent_req_set_callback(subreq, rpc_sock_read_done, req); + return req; fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } static void rpc_sock_read_done(struct tevent_req *subreq) { - struct async_req *req = - tevent_req_callback_data(subreq, struct async_req); - struct rpc_sock_read_state *state = talloc_get_type_abort( - req->private_data, struct rpc_sock_read_state); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_sock_read_state *state = tevent_req_data( + req, struct rpc_sock_read_state); int err; state->received = async_recv_recv(subreq, &err); if (state->received == -1) { - async_req_nterror(req, map_nt_error_from_unix(err)); + tevent_req_nterror(req, map_nt_error_from_unix(err)); return; } - async_req_done(req); + tevent_req_done(req); } -static NTSTATUS rpc_sock_read_recv(struct async_req *req, ssize_t *preceived) +static NTSTATUS rpc_sock_read_recv(struct tevent_req *req, ssize_t *preceived) { - struct rpc_sock_read_state *state = talloc_get_type_abort( - req->private_data, struct rpc_sock_read_state); + struct rpc_sock_read_state *state = tevent_req_data( + req, struct rpc_sock_read_state); NTSTATUS status; - if (async_req_is_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { return status; } *preceived = state->received; -- cgit From 8e0d9d002a4b0266c9d910bf7ce9c0510c89b09f Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 23:20:03 +0100 Subject: Convert rpc_cli_transport->write to tevent_req --- source3/rpc_client/cli_pipe.c | 17 +++++------- source3/rpc_client/rpc_transport_np.c | 41 +++++++++++++++-------------- source3/rpc_client/rpc_transport_smbd.c | 46 ++++++++++++++++----------------- source3/rpc_client/rpc_transport_sock.c | 41 ++++++++++++++--------------- 4 files changed, 70 insertions(+), 75 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index d4abe3c4fd..dbd6930718 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -287,15 +287,14 @@ struct rpc_write_state { size_t num_written; }; -static void rpc_write_done(struct async_req *subreq); +static void rpc_write_done(struct tevent_req *subreq); 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 tevent_req *req; - struct async_req *subreq; + struct tevent_req *req, *subreq; struct rpc_write_state *state; req = tevent_req_create(mem_ctx, &state, struct rpc_write_state); @@ -314,18 +313,17 @@ static struct tevent_req *rpc_write_send(TALLOC_CTX *mem_ctx, if (subreq == NULL) { goto fail; } - subreq->async.fn = rpc_write_done; - subreq->async.priv = req; + tevent_req_set_callback(subreq, rpc_write_done, req); return req; fail: TALLOC_FREE(req); return NULL; } -static void rpc_write_done(struct async_req *subreq) +static void rpc_write_done(struct tevent_req *subreq) { - struct tevent_req *req = talloc_get_type_abort( - subreq->async.priv, struct tevent_req); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); struct rpc_write_state *state = tevent_req_data( req, struct rpc_write_state); NTSTATUS status; @@ -352,8 +350,7 @@ static void rpc_write_done(struct async_req *subreq) if (tevent_req_nomem(subreq, req)) { return; } - subreq->async.fn = rpc_write_done; - subreq->async.priv = req; + tevent_req_set_callback(subreq, rpc_write_done, req); } static NTSTATUS rpc_write_recv(struct tevent_req *req) diff --git a/source3/rpc_client/rpc_transport_np.c b/source3/rpc_client/rpc_transport_np.c index 7da4421329..620910060a 100644 --- a/source3/rpc_client/rpc_transport_np.c +++ b/source3/rpc_client/rpc_transport_np.c @@ -51,18 +51,19 @@ struct rpc_np_write_state { static void rpc_np_write_done(struct async_req *subreq); -static struct async_req *rpc_np_write_send(TALLOC_CTX *mem_ctx, - struct event_context *ev, - const uint8_t *data, size_t size, - void *priv) +static struct tevent_req *rpc_np_write_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + const uint8_t *data, size_t size, + void *priv) { struct rpc_transport_np_state *np_transport = talloc_get_type_abort( priv, struct rpc_transport_np_state); - struct async_req *result, *subreq; + struct tevent_req *req; + struct async_req *subreq; struct rpc_np_write_state *state; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_np_write_state)) { + req = tevent_req_create(mem_ctx, &state, struct rpc_np_write_state); + if (req == NULL) { return NULL; } state->size = size; @@ -75,37 +76,37 @@ static struct async_req *rpc_np_write_send(TALLOC_CTX *mem_ctx, goto fail; } subreq->async.fn = rpc_np_write_done; - subreq->async.priv = result; - return result; + subreq->async.priv = req; + return req; fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } static void rpc_np_write_done(struct async_req *subreq) { - struct async_req *req = talloc_get_type_abort( - subreq->async.priv, struct async_req); - struct rpc_np_write_state *state = talloc_get_type_abort( - req->private_data, struct rpc_np_write_state); + struct tevent_req *req = talloc_get_type_abort( + subreq->async.priv, struct tevent_req); + struct rpc_np_write_state *state = tevent_req_data( + req, struct rpc_np_write_state); NTSTATUS status; status = cli_write_andx_recv(subreq, &state->written); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } - async_req_done(req); + tevent_req_done(req); } -static NTSTATUS rpc_np_write_recv(struct async_req *req, ssize_t *pwritten) +static NTSTATUS rpc_np_write_recv(struct tevent_req *req, ssize_t *pwritten) { - struct rpc_np_write_state *state = talloc_get_type_abort( - req->private_data, struct rpc_np_write_state); + struct rpc_np_write_state *state = tevent_req_data( + req, struct rpc_np_write_state); NTSTATUS status; - if (async_req_is_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { return status; } *pwritten = state->written; diff --git a/source3/rpc_client/rpc_transport_smbd.c b/source3/rpc_client/rpc_transport_smbd.c index 85fe3d86ce..bde8d04208 100644 --- a/source3/rpc_client/rpc_transport_smbd.c +++ b/source3/rpc_client/rpc_transport_smbd.c @@ -432,20 +432,20 @@ struct rpc_smbd_write_state { ssize_t written; }; -static void rpc_smbd_write_done(struct async_req *subreq); +static void rpc_smbd_write_done(struct tevent_req *subreq); -static struct async_req *rpc_smbd_write_send(TALLOC_CTX *mem_ctx, - struct event_context *ev, - const uint8_t *data, size_t size, - void *priv) +static struct tevent_req *rpc_smbd_write_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + const uint8_t *data, size_t size, + void *priv) { struct rpc_transport_smbd_state *transp = talloc_get_type_abort( priv, struct rpc_transport_smbd_state); - struct async_req *result, *subreq; + struct tevent_req *req, *subreq; struct rpc_smbd_write_state *state; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_smbd_write_state)) { + req = tevent_req_create(mem_ctx, &state, struct rpc_smbd_write_state); + if (req == NULL) { return NULL; } state->sub_transp = transp->sub_transp; @@ -460,40 +460,38 @@ static struct async_req *rpc_smbd_write_send(TALLOC_CTX *mem_ctx, rpc_cli_smbd_stdout_reader, transp->conn) == NULL) { goto fail; } - - subreq->async.fn = rpc_smbd_write_done; - subreq->async.priv = result; - return result; + tevent_req_set_callback(subreq, rpc_smbd_write_done, req); + return req; fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } -static void rpc_smbd_write_done(struct async_req *subreq) +static void rpc_smbd_write_done(struct tevent_req *subreq) { - struct async_req *req = talloc_get_type_abort( - subreq->async.priv, struct async_req); - struct rpc_smbd_write_state *state = talloc_get_type_abort( - req->private_data, struct rpc_smbd_write_state); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_smbd_write_state *state = tevent_req_data( + req, struct rpc_smbd_write_state); NTSTATUS status; status = state->sub_transp->write_recv(subreq, &state->written); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } - async_req_done(req); + tevent_req_done(req); } -static NTSTATUS rpc_smbd_write_recv(struct async_req *req, ssize_t *pwritten) +static NTSTATUS rpc_smbd_write_recv(struct tevent_req *req, ssize_t *pwritten) { - struct rpc_smbd_write_state *state = talloc_get_type_abort( - req->private_data, struct rpc_smbd_write_state); + struct rpc_smbd_write_state *state = tevent_req_data( + req, struct rpc_smbd_write_state); NTSTATUS status; - if (async_req_is_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { return status; } *pwritten = state->written; diff --git a/source3/rpc_client/rpc_transport_sock.c b/source3/rpc_client/rpc_transport_sock.c index c9fcbcc07e..570d792c9c 100644 --- a/source3/rpc_client/rpc_transport_sock.c +++ b/source3/rpc_client/rpc_transport_sock.c @@ -102,55 +102,54 @@ struct rpc_sock_write_state { static void rpc_sock_write_done(struct tevent_req *subreq); -static struct async_req *rpc_sock_write_send(TALLOC_CTX *mem_ctx, - struct event_context *ev, - const uint8_t *data, size_t size, - void *priv) +static struct tevent_req *rpc_sock_write_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + const uint8_t *data, size_t size, + void *priv) { struct rpc_transport_sock_state *sock_transp = talloc_get_type_abort( priv, struct rpc_transport_sock_state); - struct async_req *result; - struct tevent_req *subreq; + struct tevent_req *req, *subreq; struct rpc_sock_write_state *state; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_sock_write_state)) { + req = tevent_req_create(mem_ctx, &state, struct rpc_sock_write_state); + if (req == NULL) { return NULL; } subreq = async_send_send(state, ev, sock_transp->fd, data, size, 0); if (subreq == NULL) { goto fail; } - tevent_req_set_callback(subreq, rpc_sock_write_done, result); - return result; + tevent_req_set_callback(subreq, rpc_sock_write_done, req); + return req; fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } static void rpc_sock_write_done(struct tevent_req *subreq) { - struct async_req *req = - tevent_req_callback_data(subreq, struct async_req); - struct rpc_sock_write_state *state = talloc_get_type_abort( - req->private_data, struct rpc_sock_write_state); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_sock_write_state *state = tevent_req_data( + req, struct rpc_sock_write_state); int err; state->sent = async_send_recv(subreq, &err); if (state->sent == -1) { - async_req_nterror(req, map_nt_error_from_unix(err)); + tevent_req_nterror(req, map_nt_error_from_unix(err)); return; } - async_req_done(req); + tevent_req_done(req); } -static NTSTATUS rpc_sock_write_recv(struct async_req *req, ssize_t *psent) +static NTSTATUS rpc_sock_write_recv(struct tevent_req *req, ssize_t *psent) { - struct rpc_sock_write_state *state = talloc_get_type_abort( - req->private_data, struct rpc_sock_write_state); + struct rpc_sock_write_state *state = tevent_req_data( + req, struct rpc_sock_write_state); NTSTATUS status; - if (async_req_is_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { return status; } *psent = state->sent; -- cgit From fa6283683981c61406967ede7ad48910b602f5a4 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 23:30:18 +0100 Subject: Convert rpc_cli_transport->trans to tevent_req --- source3/rpc_client/cli_pipe.c | 30 +++++++++--------------- source3/rpc_client/rpc_transport_np.c | 43 ++++++++++++++++++----------------- 2 files changed, 33 insertions(+), 40 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index dbd6930718..98278e02d9 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -1034,7 +1034,7 @@ struct cli_api_pipe_state { uint32_t rdata_len; }; -static void cli_api_pipe_trans_done(struct async_req *subreq); +static void cli_api_pipe_trans_done(struct tevent_req *subreq); static void cli_api_pipe_write_done(struct tevent_req *subreq); static void cli_api_pipe_read_done(struct tevent_req *subreq); @@ -1044,9 +1044,7 @@ static struct tevent_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx, uint8_t *data, size_t data_len, uint32_t max_rdata_len) { - struct tevent_req *req; - struct async_req *subreq; - struct tevent_req *subreq2; + struct tevent_req *req, *subreq; struct cli_api_pipe_state *state; NTSTATUS status; @@ -1071,11 +1069,9 @@ static struct tevent_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx, 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; + goto fail; } - subreq->async.fn = cli_api_pipe_trans_done; - subreq->async.priv = req; + tevent_req_set_callback(subreq, cli_api_pipe_trans_done, req); return req; } @@ -1084,31 +1080,27 @@ static struct tevent_req *cli_api_pipe_send(TALLOC_CTX *mem_ctx, * 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) { + subreq = rpc_write_send(state, ev, transport, data, data_len); + if (subreq == NULL) { goto fail; } - tevent_req_set_callback(subreq2, cli_api_pipe_write_done, req); + tevent_req_set_callback(subreq, cli_api_pipe_write_done, req); return req; status = NT_STATUS_INVALID_PARAMETER; post_status: - if (NT_STATUS_IS_OK(status)) { - tevent_req_done(req); - } else { - tevent_req_nterror(req, status); - } + tevent_req_nterror(req, status); return tevent_req_post(req, ev); fail: TALLOC_FREE(req); return NULL; } -static void cli_api_pipe_trans_done(struct async_req *subreq) +static void cli_api_pipe_trans_done(struct tevent_req *subreq) { - struct tevent_req *req = talloc_get_type_abort( - subreq->async.priv, struct tevent_req); + 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); NTSTATUS status; diff --git a/source3/rpc_client/rpc_transport_np.c b/source3/rpc_client/rpc_transport_np.c index 620910060a..8b45cb4e9c 100644 --- a/source3/rpc_client/rpc_transport_np.c +++ b/source3/rpc_client/rpc_transport_np.c @@ -206,19 +206,20 @@ struct rpc_np_trans_state { static void rpc_np_trans_done(struct async_req *subreq); -static struct async_req *rpc_np_trans_send(TALLOC_CTX *mem_ctx, - struct event_context *ev, - uint8_t *data, size_t data_len, - uint32_t max_rdata_len, - void *priv) +static struct tevent_req *rpc_np_trans_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + uint8_t *data, size_t data_len, + uint32_t max_rdata_len, + void *priv) { struct rpc_transport_np_state *np_transport = talloc_get_type_abort( priv, struct rpc_transport_np_state); - struct async_req *result, *subreq; + struct tevent_req *req; + struct async_req *subreq; struct rpc_np_trans_state *state; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_np_trans_state)) { + req = tevent_req_create(mem_ctx, &state, struct rpc_np_trans_state); + if (req == NULL) { return NULL; } @@ -233,40 +234,40 @@ static struct async_req *rpc_np_trans_send(TALLOC_CTX *mem_ctx, goto fail; } subreq->async.fn = rpc_np_trans_done; - subreq->async.priv = result; - return result; + subreq->async.priv = req; + return req; fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } static void rpc_np_trans_done(struct async_req *subreq) { - struct async_req *req = talloc_get_type_abort( - subreq->async.priv, struct async_req); - struct rpc_np_trans_state *state = talloc_get_type_abort( - req->private_data, struct rpc_np_trans_state); + struct tevent_req *req = talloc_get_type_abort( + subreq->async.priv, struct tevent_req); + struct rpc_np_trans_state *state = tevent_req_data( + req, struct rpc_np_trans_state); NTSTATUS status; status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL, &state->rdata, &state->rdata_len); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } - async_req_done(req); + tevent_req_done(req); } -static NTSTATUS rpc_np_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx, +static NTSTATUS rpc_np_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx, uint8_t **prdata, uint32_t *prdata_len) { - struct rpc_np_trans_state *state = talloc_get_type_abort( - req->private_data, struct rpc_np_trans_state); + struct rpc_np_trans_state *state = tevent_req_data( + req, struct rpc_np_trans_state); NTSTATUS status; - if (async_req_is_nterror(req, &status)) { + if (tevent_req_is_nterror(req, &status)) { return status; } *prdata = talloc_move(mem_ctx, &state->rdata); -- cgit From 5f753e22f1f536e0e227db0f453809ad6cfacaf6 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Mon, 23 Mar 2009 23:38:04 +0100 Subject: Convert rpc_pipe_bind to tevent_req --- source3/rpc_client/cli_pipe.c | 96 +++++++++++++++++++++---------------------- 1 file changed, 46 insertions(+), 50 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c index 98278e02d9..6b83c170f5 100644 --- a/source3/rpc_client/cli_pipe.c +++ b/source3/rpc_client/cli_pipe.c @@ -2505,29 +2505,28 @@ static int rpc_pipe_bind_state_destructor(struct rpc_pipe_bind_state *state) } static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq); -static NTSTATUS rpc_finish_auth3_bind_send(struct async_req *req, +static NTSTATUS rpc_finish_auth3_bind_send(struct tevent_req *req, struct rpc_pipe_bind_state *state, struct rpc_hdr_info *phdr, prs_struct *reply_pdu); static void rpc_bind_auth3_write_done(struct tevent_req *subreq); -static NTSTATUS rpc_finish_spnego_ntlmssp_bind_send(struct async_req *req, +static NTSTATUS rpc_finish_spnego_ntlmssp_bind_send(struct tevent_req *req, struct rpc_pipe_bind_state *state, struct rpc_hdr_info *phdr, prs_struct *reply_pdu); static void rpc_bind_ntlmssp_api_done(struct tevent_req *subreq); -struct async_req *rpc_pipe_bind_send(TALLOC_CTX *mem_ctx, - struct event_context *ev, - struct rpc_pipe_client *cli, - struct cli_pipe_auth_data *auth) +struct tevent_req *rpc_pipe_bind_send(TALLOC_CTX *mem_ctx, + struct event_context *ev, + struct rpc_pipe_client *cli, + struct cli_pipe_auth_data *auth) { - struct async_req *result; - struct tevent_req *subreq; + struct tevent_req *req, *subreq; struct rpc_pipe_bind_state *state; NTSTATUS status; - if (!async_req_setup(mem_ctx, &result, &state, - struct rpc_pipe_bind_state)) { + req = tevent_req_create(mem_ctx, &state, struct rpc_pipe_bind_state); + if (req == NULL) { return NULL; } @@ -2562,24 +2561,23 @@ struct async_req *rpc_pipe_bind_send(TALLOC_CTX *mem_ctx, if (subreq == NULL) { goto fail; } - tevent_req_set_callback(subreq, rpc_pipe_bind_step_one_done, result); - return result; + tevent_req_set_callback(subreq, rpc_pipe_bind_step_one_done, req); + return req; post_status: - if (async_post_ntstatus(result, ev, status)) { - return result; - } + tevent_req_nterror(req, status); + return tevent_req_post(req, ev); fail: - TALLOC_FREE(result); + TALLOC_FREE(req); return NULL; } static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq) { - struct async_req *req = tevent_req_callback_data( - subreq, struct async_req); - struct rpc_pipe_bind_state *state = talloc_get_type_abort( - req->private_data, struct rpc_pipe_bind_state); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_pipe_bind_state *state = tevent_req_data( + req, struct rpc_pipe_bind_state); prs_struct reply_pdu; struct rpc_hdr_info hdr; struct rpc_hdr_ba_info hdr_ba; @@ -2591,7 +2589,7 @@ static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq) DEBUG(3, ("rpc_pipe_bind: %s bind request returned %s\n", rpccli_pipe_txt(debug_ctx(), state->cli), nt_errstr(status))); - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } @@ -2599,7 +2597,7 @@ static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq) if (!smb_io_rpc_hdr("hdr", &hdr, &reply_pdu, 0)) { DEBUG(0, ("rpc_pipe_bind: failed to unmarshall RPC_HDR.\n")); prs_mem_free(&reply_pdu); - async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL); + tevent_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL); return; } @@ -2607,14 +2605,14 @@ static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq) DEBUG(0, ("rpc_pipe_bind: Failed to unmarshall " "RPC_HDR_BA.\n")); prs_mem_free(&reply_pdu); - async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL); + tevent_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")); prs_mem_free(&reply_pdu); - async_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL); + tevent_req_nterror(req, NT_STATUS_BUFFER_TOO_SMALL); return; } @@ -2631,7 +2629,7 @@ static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq) case PIPE_AUTH_TYPE_SCHANNEL: /* Bind complete. */ prs_mem_free(&reply_pdu); - async_req_done(req); + tevent_req_done(req); break; case PIPE_AUTH_TYPE_NTLMSSP: @@ -2640,7 +2638,7 @@ static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq) &reply_pdu); prs_mem_free(&reply_pdu); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); } break; @@ -2650,7 +2648,7 @@ static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq) &reply_pdu); prs_mem_free(&reply_pdu); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); } break; @@ -2661,11 +2659,11 @@ static void rpc_pipe_bind_step_one_done(struct tevent_req *subreq) DEBUG(0,("cli_finish_bind_auth: unknown auth type %u\n", (unsigned int)state->cli->auth->auth_type)); prs_mem_free(&reply_pdu); - async_req_nterror(req, NT_STATUS_INTERNAL_ERROR); + tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR); } } -static NTSTATUS rpc_finish_auth3_bind_send(struct async_req *req, +static NTSTATUS rpc_finish_auth3_bind_send(struct tevent_req *req, struct rpc_pipe_bind_state *state, struct rpc_hdr_info *phdr, prs_struct *reply_pdu) @@ -2730,20 +2728,20 @@ static NTSTATUS rpc_finish_auth3_bind_send(struct async_req *req, static void rpc_bind_auth3_write_done(struct tevent_req *subreq) { - struct async_req *req = tevent_req_callback_data( - subreq, struct async_req); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); NTSTATUS status; status = rpc_write_recv(subreq); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } - async_req_done(req); + tevent_req_done(req); } -static NTSTATUS rpc_finish_spnego_ntlmssp_bind_send(struct async_req *req, +static NTSTATUS rpc_finish_spnego_ntlmssp_bind_send(struct tevent_req *req, struct rpc_pipe_bind_state *state, struct rpc_hdr_info *phdr, prs_struct *reply_pdu) @@ -2837,10 +2835,10 @@ static NTSTATUS rpc_finish_spnego_ntlmssp_bind_send(struct async_req *req, static void rpc_bind_ntlmssp_api_done(struct tevent_req *subreq) { - struct async_req *req = tevent_req_callback_data( - subreq, struct async_req); - struct rpc_pipe_bind_state *state = talloc_get_type_abort( - req->private_data, struct rpc_pipe_bind_state); + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpc_pipe_bind_state *state = tevent_req_data( + req, struct rpc_pipe_bind_state); DATA_BLOB server_spnego_response = data_blob_null; DATA_BLOB tmp_blob = data_blob_null; prs_struct reply_pdu; @@ -2851,7 +2849,7 @@ static void rpc_bind_ntlmssp_api_done(struct tevent_req *subreq) status = rpc_api_pipe_recv(subreq, talloc_tos(), &reply_pdu); TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - async_req_nterror(req, status); + tevent_req_nterror(req, status); return; } @@ -2859,19 +2857,19 @@ static void rpc_bind_ntlmssp_api_done(struct tevent_req *subreq) 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_nterror(req, NT_STATUS_BUFFER_TOO_SMALL); + tevent_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_nterror(req, NT_STATUS_INVALID_PARAMETER); + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); return; } if (!smb_io_rpc_hdr_auth("hdr_auth", &hdr_auth, &reply_pdu, 0)) { - async_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); return; } @@ -2884,7 +2882,7 @@ static void rpc_bind_ntlmssp_api_done(struct tevent_req *subreq) OID_NTLMSSP, &tmp_blob)) { data_blob_free(&server_spnego_response); data_blob_free(&tmp_blob); - async_req_nterror(req, NT_STATUS_INVALID_PARAMETER); + tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER); return; } @@ -2893,12 +2891,12 @@ static void rpc_bind_ntlmssp_api_done(struct tevent_req *subreq) DEBUG(5,("rpc_finish_spnego_ntlmssp_bind: alter context request to " "%s.\n", rpccli_pipe_txt(debug_ctx(), state->cli))); - async_req_done(req); + tevent_req_done(req); } -NTSTATUS rpc_pipe_bind_recv(struct async_req *req) +NTSTATUS rpc_pipe_bind_recv(struct tevent_req *req) { - return async_req_simple_recv_ntstatus(req); + return tevent_req_simple_recv_ntstatus(req); } NTSTATUS rpc_pipe_bind(struct rpc_pipe_client *cli, @@ -2906,7 +2904,7 @@ NTSTATUS rpc_pipe_bind(struct rpc_pipe_client *cli, { TALLOC_CTX *frame = talloc_stackframe(); struct event_context *ev; - struct async_req *req; + struct tevent_req *req; NTSTATUS status = NT_STATUS_NO_MEMORY; ev = event_context_init(frame); @@ -2919,9 +2917,7 @@ NTSTATUS rpc_pipe_bind(struct rpc_pipe_client *cli, goto fail; } - while (req->state < ASYNC_REQ_DONE) { - event_loop_once(ev); - } + tevent_req_poll(req, ev); status = rpc_pipe_bind_recv(req); fail: -- cgit