/**
* Trigger an async read from the server. May return a short read.
*/
- struct async_req *(*read_send)(TALLOC_CTX *mem_ctx,
- struct event_context *ev,
- uint8_t *data, size_t size,
- void *priv);
+ struct tevent_req *(*read_send)(TALLOC_CTX *mem_ctx,
+ struct event_context *ev,
+ uint8_t *data, size_t size,
+ void *priv);
/**
* Get the result from the read_send operation.
*/
- NTSTATUS (*read_recv)(struct async_req *req, ssize_t *preceived);
+ NTSTATUS (*read_recv)(struct tevent_req *req, ssize_t *preceived);
/**
* Trigger an async write to the server. May return a short write.
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);
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:
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;
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)
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,
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);
* 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;
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;
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;
}
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;
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;
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;
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;
}
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;