Add "queue" to writev_send

[ira/wip.git] / source3 / rpc_server / srv_pipe_hnd.c

diff --git a/source3/rpc_server/srv_pipe_hnd.c b/source3/rpc_server/srv_pipe_hnd.c
index 653bab5e5abf36a9e34ede6e2e0aca5389aca3c9..fb7aca5c0fa2febbf9f3578d72962ce41f2dd3d3 100644 (file)
--- a/source3/rpc_server/srv_pipe_hnd.c
+++ b/source3/rpc_server/srv_pipe_hnd.c
@@ -426,7 +426,7 @@ static bool process_request_pdu(pipes_struct *p, prs_struct *rpc_in_p)
         * will not fit in the initial buffer of size 0x1068   --jerry 22/01/2002
         */
        
-       if(prs_offset(&p->in_data.data) + data_len > 15*1024*1024) {
+       if(prs_offset(&p->in_data.data) + data_len > MAX_RPC_DATA_SIZE) {
                DEBUG(0,("process_request_pdu: rpc data buffer too large (%u) + (%u)\n",
                                (unsigned int)prs_data_size(&p->in_data.data), (unsigned int)data_len ));
                set_incoming_fault(p);
@@ -944,6 +944,7 @@ bool fsp_is_np(struct files_struct *fsp)
 
 struct np_proxy_state {
        struct async_req_queue *read_queue;
+       struct async_req_queue *write_queue;
        int fd;
 
        uint8_t *msg;
@@ -1107,6 +1108,10 @@ static struct np_proxy_state *make_external_rpc_pipe_p(TALLOC_CTX *mem_ctx,
        if (result->read_queue == NULL) {
                goto fail;
        }
+       result->write_queue = async_req_queue_init(result);
+       if (result->write_queue == NULL) {
+               goto fail;
+       }
 
        return result;
 
@@ -1164,16 +1169,20 @@ NTSTATUS np_open(TALLOC_CTX *mem_ctx, const char *name,
 }
 
 struct np_write_state {
+       struct event_context *ev;
+       struct np_proxy_state *p;
+       struct iovec iov;
        ssize_t nwritten;
 };
 
-static void np_write_done(struct async_req *subreq);
+static void np_write_trigger(struct async_req *req);
+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 async_req *result, *subreq;
+       struct async_req *result;
        struct np_write_state *state;
        NTSTATUS status;
 
@@ -1206,14 +1215,15 @@ struct async_req *np_write_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
                struct np_proxy_state *p = talloc_get_type_abort(
                        handle->private_data, struct np_proxy_state);
 
-               state->nwritten = len;
+               state->ev = ev;
+               state->p = p;
+               state->iov.iov_base = CONST_DISCARD(void *, data);
+               state->iov.iov_len = len;
 
-               subreq = sendall_send(state, ev, p->fd, data, len, 0);
-               if (subreq == NULL) {
+               if (!async_req_enqueue(p->write_queue, ev, result,
+                                      np_write_trigger)) {
                        goto fail;
                }
-               subreq->async.fn = np_write_done;
-               subreq->async.priv = result;
                return result;
        }
 
@@ -1227,18 +1237,35 @@ struct async_req *np_write_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
        return NULL;
 }
 
-static void np_write_done(struct async_req *subreq)
+static void np_write_trigger(struct async_req *req)
 {
-       struct async_req *req = talloc_get_type_abort(
-               subreq->async.priv, struct async_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)
+{
+       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);
+       ssize_t received;
        int err;
-       ssize_t ret;
 
-       ret = sendall_recv(subreq, &err);
-       if (ret < 0) {
+       received = writev_recv(subreq, &err);
+       if (received < 0) {
                async_req_nterror(req, map_nt_error_from_unix(err));
                return;
        }
+       state->nwritten = received;
        async_req_done(req);
 }
 
@@ -1287,7 +1314,7 @@ struct np_read_state {
 };
 
 static void np_read_trigger(struct async_req *req);
-static void np_read_done(struct async_req *subreq);
+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,
@@ -1364,28 +1391,27 @@ static void np_read_trigger(struct async_req *req)
 {
        struct np_read_state *state = talloc_get_type_abort(
                req->private_data, struct np_read_state);
-       struct async_req *subreq;
+       struct tevent_req *subreq;
 
-       subreq = read_pkt_send(state, state->ev, state->p->fd, RPC_HEADER_LEN,
-                              rpc_frag_more_fn, NULL);
+       subreq = read_packet_send(state, state->ev, state->p->fd,
+                                 RPC_HEADER_LEN, rpc_frag_more_fn, NULL);
        if (async_req_nomem(subreq, req)) {
                return;
        }
-       subreq->async.fn = np_read_done;
-       subreq->async.priv = req;
+       tevent_req_set_callback(subreq, np_read_done, req);
 }
 
-static void np_read_done(struct async_req *subreq)
+static void np_read_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 np_read_state *state = talloc_get_type_abort(
                req->private_data, struct np_read_state);
        ssize_t received;
        size_t thistime;
        int err;
 
-       received = read_pkt_recv(subreq, state->p, &state->p->msg, &err);
+       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));