* 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);
}
struct np_proxy_state {
+ struct tevent_queue *read_queue;
+ struct tevent_queue *write_queue;
int fd;
+
+ uint8_t *msg;
+ size_t sent;
};
static int np_proxy_state_destructor(struct np_proxy_state *state)
goto fail;
}
+ result->msg = NULL;
+
+ result->read_queue = tevent_queue_create(result, "np_read");
+ if (result->read_queue == NULL) {
+ goto fail;
+ }
+ result->write_queue = tevent_queue_create(result, "np_write");
+ if (result->write_queue == NULL) {
+ goto fail;
+ }
+
return result;
fail:
}
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_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, *subreq;
+ 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);
- 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;
}
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->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);
+ subreq = writev_send(state, ev, p->write_queue, p->fd,
+ &state->iov, 1);
if (subreq == NULL) {
goto fail;
}
- subreq->async.fn = np_write_done;
- subreq->async.priv = result;
- return result;
+ tevent_req_set_callback(subreq, np_write_done, req);
+ 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_write_done(struct async_req *subreq)
+static void np_write_done(struct tevent_req *subreq)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
+ 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;
- ssize_t ret;
- ret = sendall_recv(subreq, &err);
- if (ret < 0) {
- async_req_nterror(req, map_nt_error_from_unix(err));
+ received = writev_recv(subreq, &err);
+ if (received < 0) {
+ tevent_req_nterror(req, map_nt_error_from_unix(err));
return;
}
- async_req_done(req);
+ state->nwritten = received;
+ 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;
- if (async_req_is_nterror(req, &status)) {
+ if (tevent_req_is_nterror(req, &status)) {
return status;
}
*pnwritten = state->nwritten;
return NT_STATUS_OK;
}
+static ssize_t rpc_frag_more_fn(uint8_t *buf, size_t buflen, void *priv)
+{
+ prs_struct hdr_prs;
+ struct rpc_hdr_info hdr;
+ bool ret;
+
+ if (buflen > RPC_HEADER_LEN) {
+ return 0;
+ }
+ prs_init_empty(&hdr_prs, talloc_tos(), UNMARSHALL);
+ prs_give_memory(&hdr_prs, (char *)buf, RPC_HEADER_LEN, false);
+ ret = smb_io_rpc_hdr("", &hdr, &hdr_prs, 0);
+ prs_mem_free(&hdr_prs);
+
+ if (!ret) {
+ return -1;
+ }
+
+ return (hdr.frag_len - RPC_HEADER_LEN);
+}
+
struct np_read_state {
- ssize_t nread;
+ struct event_context *ev;
+ struct np_proxy_state *p;
+ uint8_t *data;
+ size_t len;
+
+ size_t nread;
bool is_data_outstanding;
- int fd;
};
-static void np_read_done(struct async_req *subreq);
+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, *subreq;
+ 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;
}
struct np_proxy_state *p = talloc_get_type_abort(
handle->private_data, struct np_proxy_state);
- state->fd = p->fd;
+ if (p->msg != NULL) {
+ size_t thistime;
- subreq = async_recv(state, ev, p->fd, data, len, 0);
- if (subreq == NULL) {
+ thistime = MIN(talloc_get_size(p->msg) - p->sent,
+ len);
+
+ memcpy(data, p->msg+p->sent, thistime);
+ state->nread = thistime;
+ p->sent += thistime;
+
+ if (p->sent < talloc_get_size(p->msg)) {
+ state->is_data_outstanding = true;
+ } else {
+ state->is_data_outstanding = false;
+ TALLOC_FREE(p->msg);
+ }
+ status = NT_STATUS_OK;
+ goto post_status;
+ }
+
+ state->ev = ev;
+ state->p = p;
+ state->data = data;
+ state->len = len;
+
+ if (!tevent_queue_add(p->read_queue, ev, req, np_read_trigger,
+ NULL)) {
goto fail;
}
- subreq->async.fn = np_read_done;
- subreq->async.priv = result;
- 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_done(struct async_req *subreq)
+static void np_read_trigger(struct tevent_req *req, void *private_data)
{
- struct async_req *req = talloc_get_type_abort(
- subreq->async.priv, struct async_req);
- struct np_read_state *state = talloc_get_type_abort(
- req->private_data, struct np_read_state);
- ssize_t result;
- int sys_errno;
- int available = 0;
-
- result = async_syscall_result_ssize_t(subreq, &sys_errno);
- if (result == -1) {
- async_req_nterror(req, map_nt_error_from_unix(sys_errno));
+ struct np_read_state *state = tevent_req_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 (tevent_req_nomem(subreq, req)) {
return;
}
- if (result == 0) {
- async_req_nterror(req, NT_STATUS_END_OF_FILE);
+ tevent_req_set_callback(subreq, np_read_done, req);
+}
+
+static void np_read_done(struct tevent_req *subreq)
+{
+ 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;
+
+ received = read_packet_recv(subreq, state->p, &state->p->msg, &err);
+ TALLOC_FREE(subreq);
+ if (received == -1) {
+ tevent_req_nterror(req, map_nt_error_from_unix(err));
return;
}
- state->nread = result;
+ thistime = MIN(received, state->len);
- /*
- * We don't look at the ioctl result. We don't really care if there is
- * data available, because this is racy anyway.
- */
- ioctl(state->fd, FIONREAD, &available);
- state->is_data_outstanding = (available > 0);
+ memcpy(state->data, state->p->msg, thistime);
+ state->p->sent = thistime;
+ state->nread = thistime;
+
+ if (state->p->sent < received) {
+ state->is_data_outstanding = true;
+ } else {
+ TALLOC_FREE(state->p->msg);
+ 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;
git.samba.org / samba.git / blobdiff