*/
#include "includes.h"
-#include "../librpc/gen_ndr/srv_spoolss.h"
-#include "librpc/gen_ndr/ndr_named_pipe_auth.h"
-#include "../libcli/named_pipe_auth/npa_tstream.h"
-#include "rpc_server.h"
+#include "fake_file.h"
+#include "rpc_dce.h"
+#include "ntdomain.h"
+#include "rpc_server/rpc_ncacn_np.h"
+#include "rpc_server/srv_pipe_hnd.h"
+#include "rpc_server/srv_pipe.h"
+#include "rpc_server/rpc_server.h"
+#include "rpc_server/rpc_config.h"
+#include "../lib/tsocket/tsocket.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "librpc/ndr/ndr_table.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
-/****************************************************************************
- Ensures we have at least RPC_HEADER_LEN amount of data in the incoming buffer.
-****************************************************************************/
-
-static ssize_t fill_rpc_header(struct pipes_struct *p, char *data, size_t data_to_copy)
-{
- size_t len_needed_to_complete_hdr =
- MIN(data_to_copy, RPC_HEADER_LEN - p->in_data.pdu.length);
-
- DEBUG(10, ("fill_rpc_header: data_to_copy = %u, "
- "len_needed_to_complete_hdr = %u, "
- "receive_len = %u\n",
- (unsigned int)data_to_copy,
- (unsigned int)len_needed_to_complete_hdr,
- (unsigned int)p->in_data.pdu.length ));
-
- if (p->in_data.pdu.data == NULL) {
- p->in_data.pdu.data = talloc_array(p, uint8_t, RPC_HEADER_LEN);
- }
- if (p->in_data.pdu.data == NULL) {
- DEBUG(0, ("talloc failed\n"));
- return -1;
- }
-
- memcpy((char *)&p->in_data.pdu.data[p->in_data.pdu.length],
- data, len_needed_to_complete_hdr);
- p->in_data.pdu.length += len_needed_to_complete_hdr;
-
- return (ssize_t)len_needed_to_complete_hdr;
-}
-
-static bool get_pdu_size(struct pipes_struct *p)
-{
- uint16_t frag_len;
- /* the fill_rpc_header() call insures we copy only
- * RPC_HEADER_LEN bytes. If this doesn't match then
- * somethign is very wrong and we can only abort */
- if (p->in_data.pdu.length != RPC_HEADER_LEN) {
- DEBUG(0, ("Unexpected RPC Header size! "
- "got %d, expected %d)\n",
- (int)p->in_data.pdu.length,
- RPC_HEADER_LEN));
- set_incoming_fault(p);
- return false;
- }
-
- frag_len = dcerpc_get_frag_length(&p->in_data.pdu);
-
- /* verify it is a reasonable value */
- if ((frag_len < RPC_HEADER_LEN) ||
- (frag_len > RPC_MAX_PDU_FRAG_LEN)) {
- DEBUG(0, ("Unexpected RPC Fragment size! (%d)\n",
- frag_len));
- set_incoming_fault(p);
- return false;
- }
-
- p->in_data.pdu_needed_len = frag_len - RPC_HEADER_LEN;
-
- /* allocate the space needed to fill the pdu */
- p->in_data.pdu.data = talloc_realloc(p, p->in_data.pdu.data,
- uint8_t, frag_len);
- if (p->in_data.pdu.data == NULL) {
- DEBUG(0, ("talloc_realloc failed\n"));
- set_incoming_fault(p);
- return false;
- }
-
- return true;
-}
-
-/****************************************************************************
- Call this to free any talloc'ed memory. Do this after processing
- a complete incoming and outgoing request (multiple incoming/outgoing
- PDU's).
-****************************************************************************/
-
-static void free_pipe_context(struct pipes_struct *p)
-{
- data_blob_free(&p->out_data.frag);
- data_blob_free(&p->out_data.rdata);
- data_blob_free(&p->in_data.data);
-
- DEBUG(3, ("free_pipe_context: "
- "destroying talloc pool of size %lu\n",
- (unsigned long)talloc_total_size(p->mem_ctx)));
- talloc_free_children(p->mem_ctx);
-}
-
-/****************************************************************************
- Accepts incoming data on an rpc pipe. Processes the data in pdu sized units.
-****************************************************************************/
-
-static ssize_t process_incoming_data(struct pipes_struct *p, char *data, size_t n)
-{
- size_t data_to_copy = MIN(n, RPC_MAX_PDU_FRAG_LEN
- - p->in_data.pdu.length);
-
- DEBUG(10, ("process_incoming_data: Start: pdu.length = %u, "
- "pdu_needed_len = %u, incoming data = %u\n",
- (unsigned int)p->in_data.pdu.length,
- (unsigned int)p->in_data.pdu_needed_len,
- (unsigned int)n ));
-
- if(data_to_copy == 0) {
- /*
- * This is an error - data is being received and there is no
- * space in the PDU. Free the received data and go into the
- * fault state.
- */
- DEBUG(0, ("process_incoming_data: "
- "No space in incoming pdu buffer. "
- "Current size = %u incoming data size = %u\n",
- (unsigned int)p->in_data.pdu.length,
- (unsigned int)n));
- set_incoming_fault(p);
- return -1;
- }
-
- /*
- * If we have no data already, wait until we get at least
- * a RPC_HEADER_LEN * number of bytes before we can do anything.
- */
-
- if ((p->in_data.pdu_needed_len == 0) &&
- (p->in_data.pdu.length < RPC_HEADER_LEN)) {
- /*
- * Always return here. If we have more data then the RPC_HEADER
- * will be processed the next time around the loop.
- */
- return fill_rpc_header(p, data, data_to_copy);
- }
-
- /*
- * At this point we know we have at least an RPC_HEADER_LEN amount of
- * data stored in p->in_data.pdu.
- */
-
- /*
- * If pdu_needed_len is zero this is a new pdu.
- * Check how much more data we need, then loop again.
- */
- if (p->in_data.pdu_needed_len == 0) {
-
- bool ok = get_pdu_size(p);
- if (!ok) {
- return -1;
- }
- if (p->in_data.pdu_needed_len > 0) {
- return 0;
- }
-
- /* If rret == 0 and pdu_needed_len == 0 here we have a PDU
- * that consists of an RPC_HEADER only. This is a
- * DCERPC_PKT_SHUTDOWN, DCERPC_PKT_CO_CANCEL or
- * DCERPC_PKT_ORPHANED pdu type.
- * Deal with this in process_complete_pdu(). */
- }
-
- /*
- * Ok - at this point we have a valid RPC_HEADER.
- * Keep reading until we have a full pdu.
- */
-
- data_to_copy = MIN(data_to_copy, p->in_data.pdu_needed_len);
-
- /*
- * Copy as much of the data as we need into the p->in_data.pdu buffer.
- * pdu_needed_len becomes zero when we have a complete pdu.
- */
-
- memcpy((char *)&p->in_data.pdu.data[p->in_data.pdu.length],
- data, data_to_copy);
- p->in_data.pdu.length += data_to_copy;
- p->in_data.pdu_needed_len -= data_to_copy;
-
- /*
- * Do we have a complete PDU ?
- * (return the number of bytes handled in the call)
- */
-
- if(p->in_data.pdu_needed_len == 0) {
- process_complete_pdu(p);
- return data_to_copy;
- }
-
- DEBUG(10, ("process_incoming_data: not a complete PDU yet. "
- "pdu.length = %u, pdu_needed_len = %u\n",
- (unsigned int)p->in_data.pdu.length,
- (unsigned int)p->in_data.pdu_needed_len));
-
- return (ssize_t)data_to_copy;
-}
-
-/****************************************************************************
- Accepts incoming data on an internal rpc pipe.
-****************************************************************************/
-
-static ssize_t write_to_internal_pipe(struct pipes_struct *p, char *data, size_t n)
-{
- size_t data_left = n;
-
- while(data_left) {
- ssize_t data_used;
-
- DEBUG(10, ("write_to_pipe: data_left = %u\n",
- (unsigned int)data_left));
-
- data_used = process_incoming_data(p, data, data_left);
-
- DEBUG(10, ("write_to_pipe: data_used = %d\n",
- (int)data_used));
-
- if(data_used < 0) {
- return -1;
- }
-
- data_left -= data_used;
- data += data_used;
- }
-
- return n;
-}
-
-/****************************************************************************
- Replies to a request to read data from a pipe.
-
- Headers are interspersed with the data at PDU intervals. By the time
- this function is called, the start of the data could possibly have been
- read by an SMBtrans (file_offset != 0).
-
- Calling create_rpc_reply() here is a hack. The data should already
- have been prepared into arrays of headers + data stream sections.
-****************************************************************************/
-
-static ssize_t read_from_internal_pipe(struct pipes_struct *p, char *data,
- size_t n, bool *is_data_outstanding)
-{
- uint32 pdu_remaining = 0;
- ssize_t data_returned = 0;
-
- if (!p) {
- DEBUG(0,("read_from_pipe: pipe not open\n"));
- return -1;
- }
-
- DEBUG(6,(" name: %s len: %u\n",
- get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
- (unsigned int)n));
-
- /*
- * We cannot return more than one PDU length per
- * read request.
- */
-
- /*
- * This condition should result in the connection being closed.
- * Netapp filers seem to set it to 0xffff which results in domain
- * authentications failing. Just ignore it so things work.
- */
-
- 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,
- get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
- RPC_MAX_PDU_FRAG_LEN ));
- n = RPC_MAX_PDU_FRAG_LEN;
- }
-
- /*
- * Determine if there is still data to send in the
- * pipe PDU buffer. Always send this first. Never
- * send more than is left in the current PDU. The
- * client should send a new read request for a new
- * PDU.
- */
-
- pdu_remaining = p->out_data.frag.length
- - 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",
- get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
- (unsigned int)p->out_data.frag.length,
- (unsigned int)p->out_data.current_pdu_sent,
- (int)data_returned));
-
- memcpy(data,
- p->out_data.frag.data
- + p->out_data.current_pdu_sent,
- data_returned);
-
- p->out_data.current_pdu_sent += (uint32)data_returned;
- goto out;
- }
-
- /*
- * At this point p->current_pdu_len == p->current_pdu_sent (which
- * 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, p->out_data.rdata.length = %u.\n",
- get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
- (int)p->fault_state,
- (unsigned int)p->out_data.data_sent_length,
- (unsigned int)p->out_data.rdata.length));
-
- if (p->out_data.data_sent_length >= p->out_data.rdata.length) {
- /*
- * We have sent all possible data, return 0.
- */
- data_returned = 0;
- goto out;
- }
-
- /*
- * We need to create a new PDU from the data left in p->rdata.
- * Create the header/data/footers. This also sets up the fields
- * p->current_pdu_len, p->current_pdu_sent, p->data_sent_length
- * and stores the outgoing PDU in p->current_pdu.
- */
-
- if(!create_next_pdu(p)) {
- DEBUG(0,("read_from_pipe: %s: create_next_pdu failed.\n",
- get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
- return -1;
- }
-
- data_returned = MIN(n, p->out_data.frag.length);
-
- memcpy(data, p->out_data.frag.data, (size_t)data_returned);
- p->out_data.current_pdu_sent += (uint32)data_returned;
-
- out:
- (*is_data_outstanding) = p->out_data.frag.length > n;
-
- if (p->out_data.current_pdu_sent == p->out_data.frag.length) {
- /* We've returned everything in the out_data.frag
- * so we're done with this pdu. Free it and reset
- * current_pdu_sent. */
- p->out_data.current_pdu_sent = 0;
- data_blob_free(&p->out_data.frag);
-
- if (p->out_data.data_sent_length >= p->out_data.rdata.length) {
- /*
- * We're completely finished with both outgoing and
- * incoming data streams. It's safe to free all
- * temporary data from this request.
- */
- free_pipe_context(p);
- }
- }
-
- return data_returned;
-}
-
bool fsp_is_np(struct files_struct *fsp)
{
enum FAKE_FILE_TYPE type;
type = fsp->fake_file_handle->type;
- return ((type == FAKE_FILE_TYPE_NAMED_PIPE)
- || (type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY));
-}
-
-struct np_proxy_state {
- uint16_t file_type;
- uint16_t device_state;
- uint64_t allocation_size;
- struct tstream_context *npipe;
- struct tevent_queue *read_queue;
- struct tevent_queue *write_queue;
-};
-
-static struct np_proxy_state *make_external_rpc_pipe_p(TALLOC_CTX *mem_ctx,
- const char *pipe_name,
- const struct tsocket_address *local_address,
- const struct tsocket_address *remote_address,
- struct auth_serversupplied_info *server_info)
-{
- struct np_proxy_state *result;
- char *socket_np_dir;
- const char *socket_dir;
- struct tevent_context *ev;
- struct tevent_req *subreq;
- struct netr_SamInfo3 *info3;
- NTSTATUS status;
- bool ok;
- int ret;
- int sys_errno;
-
- result = talloc(mem_ctx, struct np_proxy_state);
- if (result == NULL) {
- DEBUG(0, ("talloc failed\n"));
- return NULL;
- }
-
- result->read_queue = tevent_queue_create(result, "np_read");
- if (result->read_queue == NULL) {
- DEBUG(0, ("tevent_queue_create failed\n"));
- goto fail;
- }
-
- result->write_queue = tevent_queue_create(result, "np_write");
- if (result->write_queue == NULL) {
- DEBUG(0, ("tevent_queue_create failed\n"));
- goto fail;
- }
-
- ev = s3_tevent_context_init(talloc_tos());
- if (ev == NULL) {
- DEBUG(0, ("s3_tevent_context_init failed\n"));
- goto fail;
- }
-
- socket_dir = lp_parm_const_string(
- GLOBAL_SECTION_SNUM, "external_rpc_pipe", "socket_dir",
- get_dyn_NCALRPCDIR());
- if (socket_dir == NULL) {
- DEBUG(0, ("externan_rpc_pipe:socket_dir not set\n"));
- goto fail;
- }
- socket_np_dir = talloc_asprintf(talloc_tos(), "%s/np", socket_dir);
- if (socket_np_dir == NULL) {
- DEBUG(0, ("talloc_asprintf failed\n"));
- goto fail;
- }
-
- info3 = talloc_zero(talloc_tos(), struct netr_SamInfo3);
- if (info3 == NULL) {
- DEBUG(0, ("talloc failed\n"));
- goto fail;
- }
-
- status = serverinfo_to_SamInfo3(server_info, NULL, 0, info3);
- if (!NT_STATUS_IS_OK(status)) {
- TALLOC_FREE(info3);
- DEBUG(0, ("serverinfo_to_SamInfo3 failed: %s\n",
- nt_errstr(status)));
- goto fail;
- }
-
- become_root();
- subreq = tstream_npa_connect_send(talloc_tos(), ev,
- socket_np_dir,
- pipe_name,
- remote_address, /* client_addr */
- NULL, /* client_name */
- local_address, /* server_addr */
- NULL, /* server_name */
- info3,
- server_info->user_session_key,
- data_blob_null /* delegated_creds */);
- if (subreq == NULL) {
- unbecome_root();
- DEBUG(0, ("tstream_npa_connect_send to %s for pipe %s and "
- "user %s\\%s failed\n",
- socket_np_dir, pipe_name, info3->base.domain.string,
- info3->base.account_name.string));
- goto fail;
- }
- ok = tevent_req_poll(subreq, ev);
- unbecome_root();
- if (!ok) {
- DEBUG(0, ("tevent_req_poll to %s for pipe %s and user %s\\%s "
- "failed for tstream_npa_connect: %s\n",
- socket_np_dir, pipe_name, info3->base.domain.string,
- info3->base.account_name.string,
- strerror(errno)));
- goto fail;
-
- }
- ret = tstream_npa_connect_recv(subreq, &sys_errno,
- result,
- &result->npipe,
- &result->file_type,
- &result->device_state,
- &result->allocation_size);
- TALLOC_FREE(subreq);
- if (ret != 0) {
- DEBUG(0, ("tstream_npa_connect_recv to %s for pipe %s and "
- "user %s\\%s failed: %s\n",
- socket_np_dir, pipe_name, info3->base.domain.string,
- info3->base.account_name.string,
- strerror(sys_errno)));
- goto fail;
- }
-
- return result;
-
- fail:
- TALLOC_FREE(result);
- return NULL;
+ return (type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY);
}
NTSTATUS np_open(TALLOC_CTX *mem_ctx, const char *name,
- const struct tsocket_address *local_address,
- const struct tsocket_address *remote_address,
- struct auth_serversupplied_info *server_info,
+ const struct tsocket_address *remote_client_address,
+ const struct tsocket_address *local_server_address,
+ struct auth_session_info *session_info,
+ struct tevent_context *ev_ctx,
struct messaging_context *msg_ctx,
struct fake_file_handle **phandle)
{
+ enum rpc_service_mode_e pipe_mode;
const char **proxy_list;
struct fake_file_handle *handle;
+ struct ndr_syntax_id syntax;
+ struct npa_state *npa = NULL;
+ NTSTATUS status;
+ bool ok;
proxy_list = lp_parm_string_list(-1, "np", "proxy", NULL);
return NT_STATUS_NO_MEMORY;
}
+ /* Check what is the server type for this pipe.
+ Defaults to "embedded" */
+ pipe_mode = rpc_service_mode(name);
+
+ /* Still support the old method for defining external servers */
if ((proxy_list != NULL) && str_list_check_ci(proxy_list, name)) {
- struct np_proxy_state *p;
+ pipe_mode = RPC_SERVICE_MODE_EXTERNAL;
+ }
- p = make_external_rpc_pipe_p(handle, name,
- local_address,
- remote_address,
- server_info);
+ switch (pipe_mode) {
+ case RPC_SERVICE_MODE_EXTERNAL:
+ status = make_external_rpc_pipe(handle,
+ name,
+ remote_client_address,
+ local_server_address,
+ session_info,
+ &npa);
+ if (!NT_STATUS_IS_OK(status)) {
+ talloc_free(handle);
+ return status;
+ }
+ handle->private_data = (void *)npa;
handle->type = FAKE_FILE_TYPE_NAMED_PIPE_PROXY;
- handle->private_data = p;
- } else {
- struct pipes_struct *p;
- struct ndr_syntax_id syntax;
- const char *client_address;
- if (!is_known_pipename(name, &syntax)) {
- TALLOC_FREE(handle);
+ break;
+ case RPC_SERVICE_MODE_EMBEDDED:
+ /* Check if we handle this pipe internally */
+ ok = is_known_pipename(name, &syntax);
+ if (!ok) {
+ DEBUG(2, ("'%s' is not a registered pipe!\n", name));
+ talloc_free(handle);
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
- if (tsocket_address_is_inet(remote_address, "ip")) {
- client_address = tsocket_address_inet_addr_string(
- remote_address,
- talloc_tos());
- if (client_address == NULL) {
- TALLOC_FREE(handle);
- return NT_STATUS_NO_MEMORY;
- }
- } else {
- client_address = "";
+ status = make_internal_rpc_pipe_socketpair(
+ handle,
+ ev_ctx,
+ msg_ctx,
+ name,
+ &syntax,
+ remote_client_address,
+ local_server_address,
+ session_info,
+ &npa);
+ if (!NT_STATUS_IS_OK(status)) {
+ talloc_free(handle);
+ return status;
}
- p = make_internal_rpc_pipe_p(handle, &syntax, client_address,
- server_info, msg_ctx);
-
- handle->type = FAKE_FILE_TYPE_NAMED_PIPE;
- handle->private_data = p;
- }
+ handle->private_data = (void *)npa;
+ handle->type = FAKE_FILE_TYPE_NAMED_PIPE_PROXY;
- if (handle->private_data == NULL) {
- TALLOC_FREE(handle);
- return NT_STATUS_PIPE_NOT_AVAILABLE;
+ break;
+ case RPC_SERVICE_MODE_DISABLED:
+ talloc_free(handle);
+ return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
*phandle = handle;
bool np_read_in_progress(struct fake_file_handle *handle)
{
- if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE) {
- return false;
- }
-
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 npa_state *p =
+ talloc_get_type_abort(handle->private_data,
+ struct npa_state);
size_t read_count;
read_count = tevent_queue_length(p->read_queue);
}
struct np_write_state {
- struct event_context *ev;
- struct np_proxy_state *p;
+ struct tevent_context *ev;
+ struct npa_state *p;
struct iovec iov;
ssize_t nwritten;
};
static void np_write_done(struct tevent_req *subreq);
-struct tevent_req *np_write_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
+struct tevent_req *np_write_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
struct fake_file_handle *handle,
const uint8_t *data, size_t len)
{
goto post_status;
}
- if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE) {
- struct pipes_struct *p = talloc_get_type_abort(
- 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;
- }
-
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 npa_state *p = talloc_get_type_abort(
+ handle->private_data, struct npa_state);
struct tevent_req *subreq;
state->ev = ev;
state->p = p;
- state->iov.iov_base = CONST_DISCARD(void *, data);
+ state->iov.iov_base = discard_const_p(void, data);
state->iov.iov_len = len;
subreq = tstream_writev_queue_send(state, ev,
- p->npipe,
+ p->stream,
p->write_queue,
&state->iov, 1);
if (subreq == NULL) {
}
struct np_read_state {
- struct np_proxy_state *p;
+ struct npa_state *p;
struct np_ipc_readv_next_vector_state next_vector;
- size_t nread;
+ ssize_t nread;
bool is_data_outstanding;
};
static void np_read_done(struct tevent_req *subreq);
-struct tevent_req *np_read_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
+struct tevent_req *np_read_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
struct fake_file_handle *handle,
uint8_t *data, size_t len)
{
return NULL;
}
- if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE) {
- struct pipes_struct *p = talloc_get_type_abort(
- 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;
- }
-
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 npa_state *p = talloc_get_type_abort(
+ handle->private_data, struct npa_state);
struct tevent_req *subreq;
np_ipc_readv_next_vector_init(&state->next_vector,
subreq = tstream_readv_pdu_queue_send(state,
ev,
- p->npipe,
+ p->stream,
p->read_queue,
np_ipc_readv_next_vector,
&state->next_vector);
if (subreq == NULL) {
-
+ status = NT_STATUS_NO_MEMORY;
+ goto post_status;
}
tevent_req_set_callback(subreq, np_read_done, req);
return req;
if (tevent_req_is_nterror(req, &status)) {
return status;
}
- *nread = state->nread;
- *is_data_outstanding = state->is_data_outstanding;
- return NT_STATUS_OK;
-}
-/**
- * @brief Create a new RPC client context which uses a local dispatch function.
- *
- * @param[in] conn The connection struct that will hold the pipe
- *
- * @param[out] spoolss_pipe A pointer to the connected rpc client pipe.
- *
- * @return NT_STATUS_OK on success, a corresponding NT status if an
- * error occured.
- */
-NTSTATUS rpc_connect_spoolss_pipe(connection_struct *conn,
- struct rpc_pipe_client **spoolss_pipe)
-{
- NTSTATUS status;
-
- /* TODO: check and handle disconnections */
-
- if (!conn->spoolss_pipe) {
- status = rpc_pipe_open_internal(conn,
- &ndr_table_spoolss.syntax_id,
- conn->server_info,
- &conn->spoolss_pipe);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
- }
+ DEBUG(10, ("Received %d bytes. There is %smore data outstanding\n",
+ (int)state->nread, state->is_data_outstanding?"":"no "));
- *spoolss_pipe = conn->spoolss_pipe;
+ *nread = state->nread;
+ *is_data_outstanding = state->is_data_outstanding;
return NT_STATUS_OK;
}
git.samba.org / vlendec / samba-autobuild / .git / blobdiff