Convert np_write to tevent_req

diff --git a/source3/include/proto.h b/source3/include/proto.h
index 7ac5af6e318dae4a15ac655f7ff31c379d672002..c0b4c1b93d27c510cf2c5973ee15545f5ff0840d 100644 (file)
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -5915,10 +5915,10 @@ NTSTATUS np_open(TALLOC_CTX *mem_ctx, const char *name,
                 const char *client_address,
                 struct auth_serversupplied_info *server_info,
                 struct fake_file_handle **phandle);
                 const char *client_address,
                 struct auth_serversupplied_info *server_info,
                 struct fake_file_handle **phandle);

-struct async_req *np_write_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
-                               struct fake_file_handle *handle,
-                               const uint8_t *data, size_t len);
-NTSTATUS np_write_recv(struct async_req *req, ssize_t *nwritten);
+struct tevent_req *np_write_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
+                                struct fake_file_handle *handle,
+                                const uint8_t *data, size_t len);
+NTSTATUS np_write_recv(struct tevent_req *req, ssize_t *pnwritten);

 struct async_req *np_read_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
                               struct fake_file_handle *handle,
                               uint8_t *data, size_t len);
 struct async_req *np_read_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
                               struct fake_file_handle *handle,
                               uint8_t *data, size_t len);

diff --git a/source3/rpc_server/srv_pipe_hnd.c b/source3/rpc_server/srv_pipe_hnd.c
index fb7aca5c0fa2febbf9f3578d72962ce41f2dd3d3..fc75f4b1d4ae0f03c5296d1246305fa5010d4add 100644 (file)
--- a/source3/rpc_server/srv_pipe_hnd.c
+++ b/source3/rpc_server/srv_pipe_hnd.c
@@ -944,7 +944,7 @@ bool fsp_is_np(struct files_struct *fsp)
 
 struct np_proxy_state {
        struct async_req_queue *read_queue;
 
 struct np_proxy_state {
        struct async_req_queue *read_queue;

-       struct async_req_queue *write_queue;
+       struct tevent_queue *write_queue;

        int fd;
 
        uint8_t *msg;
        int fd;
 
        uint8_t *msg;


@@ -1108,7 +1108,7 @@ static struct np_proxy_state *make_external_rpc_pipe_p(TALLOC_CTX *mem_ctx,
        if (result->read_queue == NULL) {
                goto fail;
        }
        if (result->read_queue == NULL) {
                goto fail;
        }

-       result->write_queue = async_req_queue_init(result);
+       result->write_queue = tevent_queue_create(result, "np_write");

        if (result->write_queue == NULL) {
                goto fail;
        }
        if (result->write_queue == NULL) {
                goto fail;
        }


@@ -1175,22 +1175,21 @@ struct np_write_state {
        ssize_t nwritten;
 };
 
        ssize_t nwritten;
 };
 

-static void np_write_trigger(struct async_req *req);

 static void np_write_done(struct tevent_req *subreq);
 
 static void np_write_done(struct tevent_req *subreq);
 

-struct async_req *np_write_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
-                               struct fake_file_handle *handle,
-                               const uint8_t *data, size_t len)
+struct tevent_req *np_write_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
+                                struct fake_file_handle *handle,
+                                const uint8_t *data, size_t len)

 {
 {

-       struct async_req *result;
+       struct tevent_req *req;

        struct np_write_state *state;
        NTSTATUS status;
 
        DEBUG(6, ("np_write_send: len: %d\n", (int)len));
        dump_data(50, data, len);
 
        struct np_write_state *state;
        NTSTATUS status;
 
        DEBUG(6, ("np_write_send: len: %d\n", (int)len));
        dump_data(50, data, len);
 

-       if (!async_req_setup(mem_ctx, &result, &state,
-                            struct np_write_state)) {
+       req = tevent_req_create(mem_ctx, &state, struct np_write_state);
+       if (req == NULL) {

                return NULL;
        }
 
                return NULL;
        }
 


@@ -1214,68 +1213,60 @@ struct async_req *np_write_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
        if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
                struct np_proxy_state *p = talloc_get_type_abort(
                        handle->private_data, struct np_proxy_state);
        if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
                struct np_proxy_state *p = talloc_get_type_abort(
                        handle->private_data, struct np_proxy_state);

+               struct tevent_req *subreq;

 
                state->ev = ev;
                state->p = p;
                state->iov.iov_base = CONST_DISCARD(void *, data);
                state->iov.iov_len = len;
 
 
                state->ev = ev;
                state->p = p;
                state->iov.iov_base = CONST_DISCARD(void *, data);
                state->iov.iov_len = len;
 

-               if (!async_req_enqueue(p->write_queue, ev, result,
-                                      np_write_trigger)) {
+               subreq = writev_send(state, ev, p->write_queue, p->fd,
+                                    &state->iov, 1);
+               if (subreq == NULL) {

                        goto fail;
                }
                        goto fail;
                }

-               return result;
+               tevent_req_set_callback(subreq, np_write_done, req);
+               return req;

        }
 
        status = NT_STATUS_INVALID_HANDLE;
  post_status:
        }
 
        status = NT_STATUS_INVALID_HANDLE;
  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:
  fail:

-       TALLOC_FREE(result);
+       TALLOC_FREE(req);

        return NULL;
 }
 
        return NULL;
 }
 

-static void np_write_trigger(struct async_req *req)
-{
-       struct np_write_state *state = talloc_get_type_abort(
-               req->private_data, struct np_write_state);
-       struct tevent_req *subreq;
-
-       subreq = writev_send(state, state->ev, NULL, state->p->fd,
-                            &state->iov, 1);
-       if (async_req_nomem(subreq, req)) {
-               return;
-       }
-       tevent_req_set_callback(subreq, np_write_done, req);
-}
-

 static void np_write_done(struct tevent_req *subreq)
 {
 static void np_write_done(struct tevent_req *subreq)
 {

-       struct async_req *req =
-               tevent_req_callback_data(subreq, struct async_req);
-       struct np_write_state *state = talloc_get_type_abort(
-               req->private_data, struct np_write_state);
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct np_write_state *state = tevent_req_data(
+               req, struct np_write_state);

        ssize_t received;
        int err;
 
        received = writev_recv(subreq, &err);
        if (received < 0) {
        ssize_t received;
        int err;
 
        received = writev_recv(subreq, &err);
        if (received < 0) {

-               async_req_nterror(req, map_nt_error_from_unix(err));
+               tevent_req_nterror(req, map_nt_error_from_unix(err));

                return;
        }
        state->nwritten = received;
                return;
        }
        state->nwritten = received;

-       async_req_done(req);
+       tevent_req_done(req);

 }
 
 }
 

-NTSTATUS np_write_recv(struct async_req *req, ssize_t *pnwritten)
+NTSTATUS np_write_recv(struct tevent_req *req, ssize_t *pnwritten)

 {
 {

-       struct np_write_state *state = talloc_get_type_abort(
-               req->private_data, struct np_write_state);
+       struct np_write_state *state = tevent_req_data(
+               req, struct np_write_state);

        NTSTATUS status;
 
        NTSTATUS status;
 

-       if (async_req_is_nterror(req, &status)) {
+       if (tevent_req_is_nterror(req, &status)) {

                return status;
        }
        *pnwritten = state->nwritten;
                return status;
        }
        *pnwritten = state->nwritten;

diff --git a/source3/smbd/ipc.c b/source3/smbd/ipc.c
index d18b5debe0da46acfeb7126e22e7bb38348f2f88..4383897c5759ad3ee87dd317c3ec5116928d8088 100644 (file)
--- a/source3/smbd/ipc.c
+++ b/source3/smbd/ipc.c
@@ -211,14 +211,14 @@ struct dcerpc_cmd_state {
        size_t max_read;
 };
 
        size_t max_read;
 };
 

-static void api_dcerpc_cmd_write_done(struct async_req *subreq);
+static void api_dcerpc_cmd_write_done(struct tevent_req *subreq);

 static void api_dcerpc_cmd_read_done(struct async_req *subreq);
 
 static void api_dcerpc_cmd(connection_struct *conn, struct smb_request *req,
                           files_struct *fsp, uint8_t *data, size_t length,
                           size_t max_read)
 {
 static void api_dcerpc_cmd_read_done(struct async_req *subreq);
 
 static void api_dcerpc_cmd(connection_struct *conn, struct smb_request *req,
                           files_struct *fsp, uint8_t *data, size_t length,
                           size_t max_read)
 {

-       struct async_req *subreq;
+       struct tevent_req *subreq;

        struct dcerpc_cmd_state *state;
 
        if (!fsp_is_np(fsp)) {
        struct dcerpc_cmd_state *state;
 
        if (!fsp_is_np(fsp)) {


@@ -254,16 +254,17 @@ static void api_dcerpc_cmd(connection_struct *conn, struct smb_request *req,
                reply_nterror(req, NT_STATUS_NO_MEMORY);
                return;
        }
                reply_nterror(req, NT_STATUS_NO_MEMORY);
                return;
        }

-       subreq->async.fn = api_dcerpc_cmd_write_done;
-       subreq->async.priv = talloc_move(conn, &req);
+       tevent_req_set_callback(subreq, api_dcerpc_cmd_write_done,
+                               talloc_move(conn, &req));

 }
 
 }
 

-static void api_dcerpc_cmd_write_done(struct async_req *subreq)
+static void api_dcerpc_cmd_write_done(struct tevent_req *subreq)

 {
 {

-       struct smb_request *req = talloc_get_type_abort(
-               subreq->async.priv, struct smb_request);
+       struct smb_request *req = tevent_req_callback_data(
+               subreq, struct smb_request);

        struct dcerpc_cmd_state *state = talloc_get_type_abort(
                req->async_priv, struct dcerpc_cmd_state);
        struct dcerpc_cmd_state *state = talloc_get_type_abort(
                req->async_priv, struct dcerpc_cmd_state);

+       struct async_req *subreq2;

        NTSTATUS status;
        ssize_t nwritten = -1;
 
        NTSTATUS status;
        ssize_t nwritten = -1;
 


@@ -284,15 +285,15 @@ static void api_dcerpc_cmd_write_done(struct async_req *subreq)
                goto send;
        }
 
                goto send;
        }
 

-       subreq = np_read_send(req->conn, smbd_event_context(),
-                             state->handle, state->data, state->max_read);
-       if (subreq == NULL) {
+       subreq2 = np_read_send(req->conn, smbd_event_context(),
+                              state->handle, state->data, state->max_read);
+       if (subreq2 == NULL) {

                reply_nterror(req, NT_STATUS_NO_MEMORY);
                goto send;
        }
 
                reply_nterror(req, NT_STATUS_NO_MEMORY);
                goto send;
        }
 

-       subreq->async.fn = api_dcerpc_cmd_read_done;
-       subreq->async.priv = req;
+       subreq2->async.fn = api_dcerpc_cmd_read_done;
+       subreq2->async.priv = req;

        return;
 
  send:
        return;
 
  send:

diff --git a/source3/smbd/pipes.c b/source3/smbd/pipes.c
index 6fd4031f3d60ba4b9fe3e2068f97f2354a5b6c0b..69522ea9922d77f30ffbcf4bbecb3582ab478501 100644 (file)
--- a/source3/smbd/pipes.c
+++ b/source3/smbd/pipes.c
@@ -148,14 +148,14 @@ struct pipe_write_state {
        size_t numtowrite;
 };
 
        size_t numtowrite;
 };
 

-static void pipe_write_done(struct async_req *subreq);
+static void pipe_write_done(struct tevent_req *subreq);

 
 void reply_pipe_write(struct smb_request *req)
 {
        files_struct *fsp = file_fsp(req, SVAL(req->vwv+0, 0));
        const uint8_t *data;
        struct pipe_write_state *state;
 
 void reply_pipe_write(struct smb_request *req)
 {
        files_struct *fsp = file_fsp(req, SVAL(req->vwv+0, 0));
        const uint8_t *data;
        struct pipe_write_state *state;

-       struct async_req *subreq;
+       struct tevent_req *subreq;

 
        if (!fsp_is_np(fsp)) {
                reply_doserror(req, ERRDOS, ERRbadfid);
 
        if (!fsp_is_np(fsp)) {
                reply_doserror(req, ERRDOS, ERRbadfid);


@@ -188,14 +188,14 @@ void reply_pipe_write(struct smb_request *req)
                reply_nterror(req, NT_STATUS_NO_MEMORY);
                return;
        }
                reply_nterror(req, NT_STATUS_NO_MEMORY);
                return;
        }

-       subreq->async.fn = pipe_write_done;
-       subreq->async.priv = talloc_move(req->conn, &req);
+       tevent_req_set_callback(subreq, pipe_write_done,
+                               talloc_move(req->conn, &req));

 }
 
 }
 

-static void pipe_write_done(struct async_req *subreq)
+static void pipe_write_done(struct tevent_req *subreq)

 {
 {

-       struct smb_request *req = talloc_get_type_abort(
-               subreq->async.priv, struct smb_request);
+       struct smb_request *req = tevent_req_callback_data(
+               subreq, struct smb_request);

        struct pipe_write_state *state = talloc_get_type_abort(
                req->async_priv, struct pipe_write_state);
        NTSTATUS status;
        struct pipe_write_state *state = talloc_get_type_abort(
                req->async_priv, struct pipe_write_state);
        NTSTATUS status;


@@ -235,7 +235,7 @@ struct pipe_write_andx_state {
        size_t numtowrite;
 };
 
        size_t numtowrite;
 };
 

-static void pipe_write_andx_done(struct async_req *subreq);
+static void pipe_write_andx_done(struct tevent_req *subreq);

 
 void reply_pipe_write_and_X(struct smb_request *req)
 {
 
 void reply_pipe_write_and_X(struct smb_request *req)
 {


@@ -243,7 +243,7 @@ void reply_pipe_write_and_X(struct smb_request *req)
        int smb_doff = SVAL(req->vwv+11, 0);
        uint8_t *data;
        struct pipe_write_andx_state *state;
        int smb_doff = SVAL(req->vwv+11, 0);
        uint8_t *data;
        struct pipe_write_andx_state *state;

-       struct async_req *subreq;
+       struct tevent_req *subreq;

 
        if (!fsp_is_np(fsp)) {
                reply_doserror(req, ERRDOS, ERRbadfid);
 
        if (!fsp_is_np(fsp)) {
                reply_doserror(req, ERRDOS, ERRbadfid);


@@ -297,14 +297,14 @@ void reply_pipe_write_and_X(struct smb_request *req)
                reply_nterror(req, NT_STATUS_NO_MEMORY);
                return;
        }
                reply_nterror(req, NT_STATUS_NO_MEMORY);
                return;
        }

-       subreq->async.fn = pipe_write_andx_done;
-       subreq->async.priv = talloc_move(req->conn, &req);
+       tevent_req_set_callback(subreq, pipe_write_andx_done,
+                               talloc_move(req->conn, &req));

 }
 
 }
 

-static void pipe_write_andx_done(struct async_req *subreq)
+static void pipe_write_andx_done(struct tevent_req *subreq)

 {
 {

-       struct smb_request *req = talloc_get_type_abort(
-               subreq->async.priv, struct smb_request);
+       struct smb_request *req = tevent_req_callback_data(
+               subreq, struct smb_request);

        struct pipe_write_andx_state *state = talloc_get_type_abort(
                req->async_priv, struct pipe_write_andx_state);
        NTSTATUS status;
        struct pipe_write_andx_state *state = talloc_get_type_abort(
                req->async_priv, struct pipe_write_andx_state);
        NTSTATUS status;