Convert np_read to tevent_req
authorVolker Lendecke <vl@samba.org>
Tue, 17 Mar 2009 08:34:17 +0000 (09:34 +0100)
committerVolker Lendecke <vl@samba.org>
Tue, 17 Mar 2009 16:31:22 +0000 (17:31 +0100)
source3/include/proto.h
source3/rpc_server/srv_pipe_hnd.c
source3/smbd/ipc.c
source3/smbd/pipes.c

index c0b4c1b93d27c510cf2c5973ee15545f5ff0840d..f837a31cfcdb679c02828a8bfd614af41f388bc6 100644 (file)
@@ -5919,10 +5919,10 @@ 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);
-NTSTATUS np_read_recv(struct async_req *req, ssize_t *nread,
+struct tevent_req *np_read_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
+                               struct fake_file_handle *handle,
+                               uint8_t *data, size_t len);
+NTSTATUS np_read_recv(struct tevent_req *req, ssize_t *nread,
                      bool *is_data_outstanding);
 
 /* The following definitions come from rpc_server/srv_samr_util.c  */
index fc75f4b1d4ae0f03c5296d1246305fa5010d4add..503e22b653e8baa0cd8eada2bfb0d9d9a5ffadac 100644 (file)
@@ -943,7 +943,7 @@ bool fsp_is_np(struct files_struct *fsp)
 }
 
 struct np_proxy_state {
-       struct async_req_queue *read_queue;
+       struct tevent_queue *read_queue;
        struct tevent_queue *write_queue;
        int fd;
 
@@ -1104,7 +1104,7 @@ static struct np_proxy_state *make_external_rpc_pipe_p(TALLOC_CTX *mem_ctx,
 
        result->msg = NULL;
 
-       result->read_queue = async_req_queue_init(result);
+       result->read_queue = tevent_queue_create(result, "np_read");
        if (result->read_queue == NULL) {
                goto fail;
        }
@@ -1304,19 +1304,19 @@ struct np_read_state {
        bool is_data_outstanding;
 };
 
-static void np_read_trigger(struct async_req *req);
+static void np_read_trigger(struct tevent_req *req, void *private_data);
 static void np_read_done(struct tevent_req *subreq);
 
-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 tevent_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 *result;
+       struct tevent_req *req;
        struct np_read_state *state;
        NTSTATUS status;
 
-       if (!async_req_setup(mem_ctx, &result, &state,
-                            struct np_read_state)) {
+       req = tevent_req_create(mem_ctx, &state, struct np_read_state);
+       if (req == NULL) {
                return NULL;
        }
 
@@ -1361,32 +1361,35 @@ struct async_req *np_read_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
                state->data = data;
                state->len = len;
 
-               if (!async_req_enqueue(p->read_queue, ev, result,
-                                      np_read_trigger)) {
+               if (!tevent_queue_add(p->read_queue, ev, req, np_read_trigger,
+                                     NULL)) {
                        goto fail;
                }
-               return result;
+               return req;
        }
 
        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:
-       TALLOC_FREE(result);
+       TALLOC_FREE(req);
        return NULL;
 }
 
-static void np_read_trigger(struct async_req *req)
+static void np_read_trigger(struct tevent_req *req, void *private_data)
 {
-       struct np_read_state *state = talloc_get_type_abort(
-               req->private_data, struct np_read_state);
+       struct np_read_state *state = tevent_req_callback_data(
+               req, struct np_read_state);
        struct tevent_req *subreq;
 
        subreq = read_packet_send(state, state->ev, state->p->fd,
                                  RPC_HEADER_LEN, rpc_frag_more_fn, NULL);
-       if (async_req_nomem(subreq, req)) {
+       if (tevent_req_nomem(subreq, req)) {
                return;
        }
        tevent_req_set_callback(subreq, np_read_done, req);
@@ -1394,10 +1397,10 @@ static void np_read_trigger(struct async_req *req)
 
 static void np_read_done(struct tevent_req *subreq)
 {
-       struct async_req *req =
-               tevent_req_callback_data(subreq, struct async_req);
-       struct np_read_state *state = talloc_get_type_abort(
-               req->private_data, struct np_read_state);
+       struct tevent_req *req = tevent_req_callback_data(
+               subreq, struct tevent_req);
+       struct np_read_state *state = tevent_req_data(
+               req, struct np_read_state);
        ssize_t received;
        size_t thistime;
        int err;
@@ -1405,7 +1408,7 @@ static void np_read_done(struct tevent_req *subreq)
        received = read_packet_recv(subreq, state->p, &state->p->msg, &err);
        TALLOC_FREE(subreq);
        if (received == -1) {
-               async_req_nterror(req, map_nt_error_from_unix(err));
+               tevent_req_nterror(req, map_nt_error_from_unix(err));
                return;
        }
 
@@ -1422,18 +1425,18 @@ static void np_read_done(struct tevent_req *subreq)
                state->is_data_outstanding = false;
        }
 
-       async_req_done(req);
+       tevent_req_done(req);
        return;
 }
 
-NTSTATUS np_read_recv(struct async_req *req, ssize_t *nread,
+NTSTATUS np_read_recv(struct tevent_req *req, ssize_t *nread,
                      bool *is_data_outstanding)
 {
-       struct np_read_state *state = talloc_get_type_abort(
-               req->private_data, struct np_read_state);
+       struct np_read_state *state = tevent_req_data(
+               req, struct np_read_state);
        NTSTATUS status;
 
-       if (async_req_is_nterror(req, &status)) {
+       if (tevent_req_is_nterror(req, &status)) {
                return status;
        }
        *nread = state->nread;
index 4383897c5759ad3ee87dd317c3ec5116928d8088..f20c8512975c573c6987896ce42fb36630aba271 100644 (file)
@@ -212,7 +212,7 @@ struct dcerpc_cmd_state {
 };
 
 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_read_done(struct tevent_req *subreq);
 
 static void api_dcerpc_cmd(connection_struct *conn, struct smb_request *req,
                           files_struct *fsp, uint8_t *data, size_t length,
@@ -264,7 +264,6 @@ static void api_dcerpc_cmd_write_done(struct tevent_req *subreq)
                subreq, struct smb_request);
        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;
 
@@ -285,15 +284,13 @@ static void api_dcerpc_cmd_write_done(struct tevent_req *subreq)
                goto send;
        }
 
-       subreq2 = np_read_send(req->conn, smbd_event_context(),
-                              state->handle, state->data, state->max_read);
-       if (subreq2 == NULL) {
+       subreq = np_read_send(req->conn, smbd_event_context(),
+                             state->handle, state->data, state->max_read);
+       if (subreq == NULL) {
                reply_nterror(req, NT_STATUS_NO_MEMORY);
                goto send;
        }
-
-       subreq2->async.fn = api_dcerpc_cmd_read_done;
-       subreq2->async.priv = req;
+       tevent_req_set_callback(subreq, api_dcerpc_cmd_read_done, req);
        return;
 
  send:
@@ -306,10 +303,10 @@ static void api_dcerpc_cmd_write_done(struct tevent_req *subreq)
        TALLOC_FREE(req);
 }
 
-static void api_dcerpc_cmd_read_done(struct async_req *subreq)
+static void api_dcerpc_cmd_read_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);
        NTSTATUS status;
index 69522ea9922d77f30ffbcf4bbecb3582ab478501..2686cf41d93a30137e44c260270a49f66bf323bd 100644 (file)
@@ -340,14 +340,14 @@ struct pipe_read_andx_state {
        int smb_maxcnt;
 };
 
-static void pipe_read_andx_done(struct async_req *subreq);
+static void pipe_read_andx_done(struct tevent_req *subreq);
 
 void reply_pipe_read_and_X(struct smb_request *req)
 {
        files_struct *fsp = file_fsp(req, SVAL(req->vwv+0, 0));
        uint8_t *data;
        struct pipe_read_andx_state *state;
-       struct async_req *subreq;
+       struct tevent_req *subreq;
 
        /* we don't use the offset given to use for pipe reads. This
            is deliberate, instead we always return the next lump of
@@ -392,14 +392,14 @@ void reply_pipe_read_and_X(struct smb_request *req)
                reply_nterror(req, NT_STATUS_NO_MEMORY);
                return;
        }
-       subreq->async.fn = pipe_read_andx_done;
-       subreq->async.priv = talloc_move(req->conn, &req);
+       tevent_req_set_callback(subreq, pipe_read_andx_done,
+                               talloc_move(req->conn, &req));
 }
 
-static void pipe_read_andx_done(struct async_req *subreq)
+static void pipe_read_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_read_andx_state *state = talloc_get_type_abort(
                req->async_priv, struct pipe_read_andx_state);
        NTSTATUS status;