static int pipes_open;
static pipes_struct *InternalPipes;
-static struct bitmap *bmap;
/* TODO
* the following prototypes are declared here to avoid
return p->next;
}
-/****************************************************************************
- Initialise pipe handle states.
-****************************************************************************/
-
-void init_rpc_pipe_hnd(void)
-{
- bmap = bitmap_allocate(MAX_OPEN_PIPES);
- if (!bmap) {
- exit_server("out of memory in init_rpc_pipe_hnd");
- }
-}
-
/****************************************************************************
Initialise an outgoing packet.
****************************************************************************/
/* Reset the offset counters. */
o_data->data_sent_length = 0;
- o_data->current_pdu_len = 0;
o_data->current_pdu_sent = 0;
- memset(o_data->current_pdu, '\0', sizeof(o_data->current_pdu));
+ prs_mem_free(&o_data->frag);
/* Free any memory in the current return data buffer. */
prs_mem_free(&o_data->rdata);
* Initialize the outgoing RPC data buffer.
* we will use this as the raw data area for replying to rpc requests.
*/
- if(!prs_init(&o_data->rdata, RPC_MAX_PDU_FRAG_LEN, p->mem_ctx, MARSHALL)) {
+ if(!prs_init(&o_data->rdata, 128, p->mem_ctx, MARSHALL)) {
DEBUG(0,("pipe_init_outgoing_data: malloc fail.\n"));
return False;
}
****************************************************************************/
static struct pipes_struct *make_internal_rpc_pipe_p(TALLOC_CTX *mem_ctx,
- const char *pipe_name,
+ const struct ndr_syntax_id *syntax,
const char *client_address,
- struct auth_serversupplied_info *server_info,
- uint16_t vuid)
+ struct auth_serversupplied_info *server_info)
{
pipes_struct *p;
- DEBUG(4,("Create pipe requested %s\n", pipe_name));
+ DEBUG(4,("Create pipe requested %s\n",
+ get_pipe_name_from_iface(syntax)));
p = TALLOC_ZERO_P(mem_ctx, struct pipes_struct);
return NULL;
}
- if ((p->mem_ctx = talloc_init("pipe %s %p", pipe_name, p)) == NULL) {
+ if ((p->mem_ctx = talloc_init("pipe %s %p",
+ get_pipe_name_from_iface(syntax),
+ p)) == NULL) {
DEBUG(0,("open_rpc_pipe_p: talloc_init failed.\n"));
TALLOC_FREE(p);
return NULL;
}
- if (!init_pipe_handle_list(p, pipe_name)) {
+ if (!init_pipe_handle_list(p, syntax)) {
DEBUG(0,("open_rpc_pipe_p: init_pipe_handles failed.\n"));
talloc_destroy(p->mem_ctx);
TALLOC_FREE(p);
* change the type to UNMARSALLING before processing the stream.
*/
- if(!prs_init(&p->in_data.data, RPC_MAX_PDU_FRAG_LEN, p->mem_ctx, MARSHALL)) {
+ if(!prs_init(&p->in_data.data, 128, p->mem_ctx, MARSHALL)) {
DEBUG(0,("open_rpc_pipe_p: malloc fail for in_data struct.\n"));
talloc_destroy(p->mem_ctx);
close_policy_by_pipe(p);
p->endian = RPC_LITTLE_ENDIAN;
- ZERO_STRUCT(p->pipe_user);
-
- p->pipe_user.vuid = vuid;
- p->pipe_user.ut.uid = (uid_t)-1;
- p->pipe_user.ut.gid = (gid_t)-1;
- p->pipe_user.nt_user_token = dup_nt_token(NULL, server_info->ptok);
-
/*
* Initialize the outgoing RPC data buffer with no memory.
*/
prs_init_empty(&p->out_data.rdata, p->mem_ctx, MARSHALL);
-
- fstrcpy(p->name, pipe_name);
-
+
+ p->syntax = *syntax;
+
DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
- pipe_name, pipes_open));
+ get_pipe_name_from_iface(syntax), pipes_open));
talloc_set_destructor(p, close_internal_rpc_pipe_hnd);
p->in_data.pdu_received_len = 0;
p->fault_state = True;
DEBUG(10, ("set_incoming_fault: Setting fault state on pipe %s\n",
- p->name));
+ get_pipe_name_from_iface(&p->syntax)));
}
/****************************************************************************
(unsigned int)data_to_copy, (unsigned int)len_needed_to_complete_hdr,
(unsigned int)p->in_data.pdu_received_len ));
+ if (p->in_data.current_in_pdu == NULL) {
+ p->in_data.current_in_pdu = talloc_array(p, uint8_t,
+ RPC_HEADER_LEN);
+ }
+ if (p->in_data.current_in_pdu == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ return -1;
+ }
+
memcpy((char *)&p->in_data.current_in_pdu[p->in_data.pdu_received_len], data, len_needed_to_complete_hdr);
p->in_data.pdu_received_len += len_needed_to_complete_hdr;
prs_mem_free(&rpc_in);
+ p->in_data.current_in_pdu = TALLOC_REALLOC_ARRAY(
+ p, p->in_data.current_in_pdu, uint8_t, p->hdr.frag_len);
+ if (p->in_data.current_in_pdu == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ set_incoming_fault(p);
+ return -1;
+ }
+
return 0; /* No extra data processed. */
}
"%lu\n", (unsigned long)talloc_total_size(p->mem_ctx) ));
talloc_free_children(p->mem_ctx);
} else {
- p->mem_ctx = talloc_init("pipe %s %p", p->name, p);
+ p->mem_ctx = talloc_init(
+ "pipe %s %p", get_pipe_name_from_iface(&p->syntax), p);
if (p->mem_ctx == NULL) {
p->fault_state = True;
}
* 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);
if(p->fault_state) {
DEBUG(10,("process_complete_pdu: pipe %s in fault state.\n",
- p->name ));
+ get_pipe_name_from_iface(&p->syntax)));
set_incoming_fault(p);
setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
return;
case RPC_PING: /* CL request - ignore... */
DEBUG(0,("process_complete_pdu: Error. Connectionless packet type %u received on pipe %s.\n",
- (unsigned int)p->hdr.pkt_type, p->name));
+ (unsigned int)p->hdr.pkt_type,
+ get_pipe_name_from_iface(&p->syntax)));
break;
case RPC_RESPONSE: /* No responses here. */
DEBUG(0,("process_complete_pdu: Error. RPC_RESPONSE received from client on pipe %s.\n",
- p->name ));
+ get_pipe_name_from_iface(&p->syntax)));
break;
case RPC_FAULT:
case RPC_FACK:
case RPC_CANCEL_ACK:
DEBUG(0,("process_complete_pdu: Error. Connectionless packet type %u received on pipe %s.\n",
- (unsigned int)p->hdr.pkt_type, p->name));
+ (unsigned int)p->hdr.pkt_type,
+ get_pipe_name_from_iface(&p->syntax)));
break;
case RPC_BIND:
case RPC_BINDACK:
case RPC_BINDNACK:
DEBUG(0,("process_complete_pdu: Error. RPC_BINDACK/RPC_BINDNACK packet type %u received on pipe %s.\n",
- (unsigned int)p->hdr.pkt_type, p->name));
+ (unsigned int)p->hdr.pkt_type,
+ get_pipe_name_from_iface(&p->syntax)));
break;
case RPC_ALTCONTRESP:
DEBUG(0,("process_complete_pdu: Error. RPC_ALTCONTRESP on pipe %s: Should only be server -> client.\n",
- p->name));
+ get_pipe_name_from_iface(&p->syntax)));
break;
case RPC_AUTH3:
case RPC_SHUTDOWN:
DEBUG(0,("process_complete_pdu: Error. RPC_SHUTDOWN on pipe %s: Should only be server -> client.\n",
- p->name));
+ get_pipe_name_from_iface(&p->syntax)));
break;
case RPC_CO_CANCEL:
prs_set_endian_data( &p->in_data.data, RPC_LITTLE_ENDIAN);
if (!reply) {
- DEBUG(3,("process_complete_pdu: DCE/RPC fault sent on pipe %s\n", p->pipe_srv_name));
+ DEBUG(3,("process_complete_pdu: DCE/RPC fault sent on "
+ "pipe %s\n", get_pipe_name_from_iface(&p->syntax)));
set_incoming_fault(p);
setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
prs_mem_free(&rpc_in);
/*
* Reset the lengths. We're ready for a new pdu.
*/
+ TALLOC_FREE(p->in_data.current_in_pdu);
p->in_data.pdu_needed_len = 0;
p->in_data.pdu_received_len = 0;
}
return -1;
}
- DEBUG(6,(" name: %s len: %u\n", p->name, (unsigned int)n));
+ DEBUG(6,(" name: %s len: %u\n", get_pipe_name_from_iface(&p->syntax),
+ (unsigned int)n));
/*
* We cannot return more than one PDU length per
*/
if(n > RPC_MAX_PDU_FRAG_LEN) {
- DEBUG(5,("read_from_pipe: too large read (%u) requested on \
-pipe %s. We can only service %d sized reads.\n", (unsigned int)n, p->name, RPC_MAX_PDU_FRAG_LEN ));
+ DEBUG(5,("read_from_pipe: too large read (%u) requested on "
+ "pipe %s. We can only service %d sized reads.\n",
+ (unsigned int)n, get_pipe_name_from_iface(&p->syntax),
+ RPC_MAX_PDU_FRAG_LEN ));
n = RPC_MAX_PDU_FRAG_LEN;
}
* PDU.
*/
- if((pdu_remaining = p->out_data.current_pdu_len - p->out_data.current_pdu_sent) > 0) {
+ pdu_remaining = prs_offset(&p->out_data.frag)
+ - p->out_data.current_pdu_sent;
+
+ if (pdu_remaining > 0) {
data_returned = (ssize_t)MIN(n, pdu_remaining);
- DEBUG(10,("read_from_pipe: %s: current_pdu_len = %u, current_pdu_sent = %u \
-returning %d bytes.\n", p->name, (unsigned int)p->out_data.current_pdu_len,
- (unsigned int)p->out_data.current_pdu_sent, (int)data_returned));
+ DEBUG(10,("read_from_pipe: %s: current_pdu_len = %u, "
+ "current_pdu_sent = %u returning %d bytes.\n",
+ get_pipe_name_from_iface(&p->syntax),
+ (unsigned int)prs_offset(&p->out_data.frag),
+ (unsigned int)p->out_data.current_pdu_sent,
+ (int)data_returned));
+
+ memcpy(data,
+ prs_data_p(&p->out_data.frag)
+ + p->out_data.current_pdu_sent,
+ data_returned);
- memcpy( data, &p->out_data.current_pdu[p->out_data.current_pdu_sent], (size_t)data_returned);
p->out_data.current_pdu_sent += (uint32)data_returned;
goto out;
}
* may of course be zero if this is the first return fragment.
*/
- DEBUG(10,("read_from_pipe: %s: fault_state = %d : data_sent_length \
-= %u, prs_offset(&p->out_data.rdata) = %u.\n",
- p->name, (int)p->fault_state, (unsigned int)p->out_data.data_sent_length, (unsigned int)prs_offset(&p->out_data.rdata) ));
+ DEBUG(10,("read_from_pipe: %s: fault_state = %d : data_sent_length "
+ "= %u, prs_offset(&p->out_data.rdata) = %u.\n",
+ get_pipe_name_from_iface(&p->syntax), (int)p->fault_state,
+ (unsigned int)p->out_data.data_sent_length,
+ (unsigned int)prs_offset(&p->out_data.rdata) ));
if(p->out_data.data_sent_length >= prs_offset(&p->out_data.rdata)) {
/*
*/
if(!create_next_pdu(p)) {
- DEBUG(0,("read_from_pipe: %s: create_next_pdu failed.\n", p->name));
+ DEBUG(0,("read_from_pipe: %s: create_next_pdu failed.\n",
+ get_pipe_name_from_iface(&p->syntax)));
return -1;
}
- data_returned = MIN(n, p->out_data.current_pdu_len);
+ data_returned = MIN(n, prs_offset(&p->out_data.frag));
- memcpy( data, p->out_data.current_pdu, (size_t)data_returned);
+ memcpy( data, prs_data_p(&p->out_data.frag), (size_t)data_returned);
p->out_data.current_pdu_sent += (uint32)data_returned;
out:
+ (*is_data_outstanding) = prs_offset(&p->out_data.frag) > n;
- (*is_data_outstanding) = p->out_data.current_pdu_len > n;
return data_returned;
}
return False;
}
+ prs_mem_free(&p->out_data.frag);
prs_mem_free(&p->out_data.rdata);
prs_mem_free(&p->in_data.data);
(*p->auth.auth_data_free_func)(&p->auth);
}
- if (p->mem_ctx) {
- talloc_destroy(p->mem_ctx);
- }
+ TALLOC_FREE(p->mem_ctx);
free_pipe_rpc_context( p->contexts );
/* Free the handles database. */
close_policy_by_pipe(p);
- TALLOC_FREE(p->pipe_user.nt_user_token);
- SAFE_FREE(p->pipe_user.ut.groups);
-
DLIST_REMOVE(InternalPipes, p);
ZERO_STRUCTP(p);
}
struct np_proxy_state {
+ struct async_req_queue *read_queue;
+ struct async_req_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 = async_req_queue_init(result);
+ if (result->read_queue == NULL) {
+ goto fail;
+ }
+ result->write_queue = async_req_queue_init(result);
+ if (result->write_queue == NULL) {
+ goto fail;
+ }
+
return result;
fail:
return NULL;
}
-NTSTATUS np_open(struct smb_request *smb_req, struct connection_struct *conn,
- const char *name, struct files_struct **pfsp)
+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)
{
- NTSTATUS status;
- struct files_struct *fsp;
const char **proxy_list;
+ struct fake_file_handle *handle;
- proxy_list = lp_parm_string_list(SNUM(conn), "np", "proxy", NULL);
+ proxy_list = lp_parm_string_list(-1, "np", "proxy", NULL);
- status = file_new(smb_req, conn, &fsp);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0, ("file_new failed: %s\n", nt_errstr(status)));
- return status;
- }
-
- fsp->conn = conn;
- fsp->fh->fd = -1;
- fsp->vuid = smb_req->vuid;
- fsp->can_lock = false;
- fsp->access_mask = FILE_READ_DATA | FILE_WRITE_DATA;
- string_set(&fsp->fsp_name, name);
-
- fsp->fake_file_handle = talloc(NULL, struct fake_file_handle);
- if (fsp->fake_file_handle == NULL) {
- file_free(smb_req, fsp);
+ handle = talloc(mem_ctx, struct fake_file_handle);
+ if (handle == NULL) {
return NT_STATUS_NO_MEMORY;
}
if ((proxy_list != NULL) && str_list_check_ci(proxy_list, name)) {
struct np_proxy_state *p;
- p = make_external_rpc_pipe_p(fsp->fake_file_handle, name,
- conn->server_info);
+ p = make_external_rpc_pipe_p(handle, name, server_info);
- fsp->fake_file_handle->type = FAKE_FILE_TYPE_NAMED_PIPE_PROXY;
- fsp->fake_file_handle->private_data = p;
+ handle->type = FAKE_FILE_TYPE_NAMED_PIPE_PROXY;
+ handle->private_data = p;
} else {
struct pipes_struct *p;
+ struct ndr_syntax_id syntax;
- if (!is_known_pipename(name)) {
- file_free(smb_req, fsp);
+ if (!is_known_pipename(name, &syntax)) {
+ TALLOC_FREE(handle);
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
- p = make_internal_rpc_pipe_p(fsp->fake_file_handle, name,
- conn->client_address,
- conn->server_info,
- smb_req->vuid);
+ p = make_internal_rpc_pipe_p(handle, &syntax, client_address,
+ server_info);
- fsp->fake_file_handle->type = FAKE_FILE_TYPE_NAMED_PIPE;
- fsp->fake_file_handle->private_data = p;
+ handle->type = FAKE_FILE_TYPE_NAMED_PIPE;
+ handle->private_data = p;
}
- if (fsp->fake_file_handle->private_data == NULL) {
- file_free(smb_req, fsp);
+ if (handle->private_data == NULL) {
+ TALLOC_FREE(handle);
return NT_STATUS_PIPE_NOT_AVAILABLE;
}
- *pfsp = fsp;
+ *phandle = handle;
return NT_STATUS_OK;
}
-NTSTATUS np_write(struct files_struct *fsp, const uint8_t *data, size_t len,
- ssize_t *nwritten)
+struct np_write_state {
+ struct event_context *ev;
+ struct np_proxy_state *p;
+ struct iovec iov;
+ ssize_t nwritten;
+};
+
+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)
{
- if (!fsp_is_np(fsp)) {
- return NT_STATUS_INVALID_HANDLE;
- }
+ struct async_req *result;
+ struct np_write_state *state;
+ NTSTATUS status;
- DEBUG(6, ("np_write: %x name: %s len: %d\n", (int)fsp->fnum,
- fsp->fsp_name, (int)len));
+ DEBUG(6, ("np_write_send: len: %d\n", (int)len));
dump_data(50, data, len);
- switch (fsp->fake_file_handle->type) {
- case FAKE_FILE_TYPE_NAMED_PIPE: {
+ if (!async_req_setup(mem_ctx, &result, &state,
+ struct np_write_state)) {
+ return NULL;
+ }
+
+ if (len == 0) {
+ state->nwritten = 0;
+ status = NT_STATUS_OK;
+ goto post_status;
+ }
+
+ if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE) {
struct pipes_struct *p = talloc_get_type_abort(
- fsp->fake_file_handle->private_data,
- struct pipes_struct);
- *nwritten = write_to_internal_pipe(p, (char *)data, len);
- break;
+ handle->private_data, struct pipes_struct);
+
+ state->nwritten = write_to_internal_pipe(p, (char *)data, len);
+
+ status = (state->nwritten >= 0)
+ ? NT_STATUS_OK : NT_STATUS_UNEXPECTED_IO_ERROR;
+ goto post_status;
}
- case FAKE_FILE_TYPE_NAMED_PIPE_PROXY: {
+
+ if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
struct np_proxy_state *p = talloc_get_type_abort(
- fsp->fake_file_handle->private_data,
- struct np_proxy_state);
- *nwritten = write_data(p->fd, (char *)data, len);
- break;
+ handle->private_data, struct np_proxy_state);
+
+ 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)) {
+ goto fail;
+ }
+ return result;
+ }
+
+ status = NT_STATUS_INVALID_HANDLE;
+ post_status:
+ if (async_post_ntstatus(result, ev, status)) {
+ return result;
+ }
+ fail:
+ TALLOC_FREE(result);
+ 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)
+{
+ 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;
+
+ 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);
+}
+
+NTSTATUS np_write_recv(struct async_req *req, ssize_t *pnwritten)
+{
+ struct np_write_state *state = talloc_get_type_abort(
+ req->private_data, struct np_write_state);
+ NTSTATUS status;
+
+ if (async_req_is_nterror(req, &status)) {
+ return status;
}
- default:
- return NT_STATUS_INVALID_HANDLE;
- break;
+ *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);
- return ((*nwritten) >= 0)
- ? NT_STATUS_OK : NT_STATUS_UNEXPECTED_IO_ERROR;
+ if (!ret) {
+ return -1;
+ }
+
+ return (hdr.frag_len - RPC_HEADER_LEN);
}
-NTSTATUS np_read(struct files_struct *fsp, uint8_t *data, size_t len,
- ssize_t *nread, bool *is_data_outstanding)
+struct np_read_state {
+ struct event_context *ev;
+ struct np_proxy_state *p;
+ uint8_t *data;
+ size_t len;
+
+ size_t nread;
+ bool is_data_outstanding;
+};
+
+static void np_read_trigger(struct async_req *req);
+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)
{
- if (!fsp_is_np(fsp)) {
- return NT_STATUS_INVALID_HANDLE;
+ struct async_req *result;
+ struct np_read_state *state;
+ NTSTATUS status;
+
+ if (!async_req_setup(mem_ctx, &result, &state,
+ struct np_read_state)) {
+ return NULL;
}
- switch (fsp->fake_file_handle->type) {
- case FAKE_FILE_TYPE_NAMED_PIPE: {
+ if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE) {
struct pipes_struct *p = talloc_get_type_abort(
- fsp->fake_file_handle->private_data,
- struct pipes_struct);
- *nread = read_from_internal_pipe(p, (char *)data, len,
- is_data_outstanding);
- break;
+ handle->private_data, struct pipes_struct);
+
+ state->nread = read_from_internal_pipe(
+ p, (char *)data, len, &state->is_data_outstanding);
+
+ status = (state->nread >= 0)
+ ? NT_STATUS_OK : NT_STATUS_UNEXPECTED_IO_ERROR;
+ goto post_status;
}
- case FAKE_FILE_TYPE_NAMED_PIPE_PROXY: {
+
+ if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
struct np_proxy_state *p = talloc_get_type_abort(
- fsp->fake_file_handle->private_data,
- struct np_proxy_state);
- int available = 0;
+ handle->private_data, struct np_proxy_state);
- *nread = sys_read(p->fd, (char *)data, len);
+ if (p->msg != NULL) {
+ size_t thistime;
- /*
- * We don't look at the ioctl result. We don't really care
- * if there is data available, because this is racy anyway.
- */
- ioctl(p->fd, FIONREAD, &available);
- *is_data_outstanding = (available > 0);
+ thistime = MIN(talloc_get_size(p->msg) - p->sent,
+ len);
+
+ memcpy(data, p->msg+p->sent, thistime);
+ state->nread = thistime;
+ p->sent += thistime;
- break;
+ 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 (!async_req_enqueue(p->read_queue, ev, result,
+ np_read_trigger)) {
+ goto fail;
+ }
+ return result;
}
- default:
- return NT_STATUS_INVALID_HANDLE;
- break;
+
+ status = NT_STATUS_INVALID_HANDLE;
+ post_status:
+ if (async_post_ntstatus(result, ev, status)) {
+ return result;
}
+ fail:
+ TALLOC_FREE(result);
+ return NULL;
+}
- return ((*nread) >= 0)
- ? NT_STATUS_OK : NT_STATUS_UNEXPECTED_IO_ERROR;
+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 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)) {
+ return;
+ }
+ tevent_req_set_callback(subreq, np_read_done, 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);
+ 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) {
+ async_req_nterror(req, map_nt_error_from_unix(err));
+ return;
+ }
+
+ thistime = MIN(received, state->len);
+
+ 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);
+ return;
+}
+
+NTSTATUS np_read_recv(struct async_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);
+ NTSTATUS status;
+
+ if (async_req_is_nterror(req, &status)) {
+ return status;
+ }
+ *nread = state->nread;
+ *is_data_outstanding = state->is_data_outstanding;
+ return NT_STATUS_OK;
+}
+
+/**
+ * Create a new RPC client context which uses a local dispatch function.
+ */
+NTSTATUS rpc_pipe_open_internal(TALLOC_CTX *mem_ctx,
+ const struct ndr_syntax_id *abstract_syntax,
+ NTSTATUS (*dispatch) (struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ const struct ndr_interface_table *table,
+ uint32_t opnum, void *r),
+ struct auth_serversupplied_info *serversupplied_info,
+ struct rpc_pipe_client **presult)
+{
+ struct rpc_pipe_client *result;
+
+ result = TALLOC_ZERO_P(mem_ctx, struct rpc_pipe_client);
+ if (result == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ result->abstract_syntax = *abstract_syntax;
+ result->transfer_syntax = ndr_transfer_syntax;
+ result->dispatch = dispatch;
+
+ result->pipes_struct = make_internal_rpc_pipe_p(
+ result, abstract_syntax, "", serversupplied_info);
+ if (result->pipes_struct == NULL) {
+ TALLOC_FREE(result);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ result->max_xmit_frag = -1;
+ result->max_recv_frag = -1;
+
+ *presult = result;
+ return NT_STATUS_OK;
}