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)
{
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);
* 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);
}
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:
return NULL;
}
-NTSTATUS np_open(struct smb_request *smb_req, 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)
{
- struct connection_struct *conn = smb_req->conn;
- 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);
+ 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_done(struct tevent_req *subreq);
+
+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)
{
- if (!fsp_is_np(fsp)) {
- return NT_STATUS_INVALID_HANDLE;
- }
+ struct tevent_req *req;
+ 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: {
+ req = tevent_req_create(mem_ctx, &state, struct np_write_state);
+ if (req == NULL) {
+ 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);
+ struct tevent_req *subreq;
+
+ state->ev = ev;
+ state->p = p;
+ state->iov.iov_base = CONST_DISCARD(void *, data);
+ state->iov.iov_len = len;
+
+ subreq = writev_send(state, ev, p->write_queue, p->fd,
+ false, &state->iov, 1);
+ if (subreq == NULL) {
+ goto fail;
+ }
+ tevent_req_set_callback(subreq, np_write_done, req);
+ return req;
+ }
+
+ status = NT_STATUS_INVALID_HANDLE;
+ post_status:
+ if (NT_STATUS_IS_OK(status)) {
+ tevent_req_done(req);
+ } else {
+ tevent_req_nterror(req, status);
}
- default:
- return NT_STATUS_INVALID_HANDLE;
- break;
+ return tevent_req_post(req, ev);
+ fail:
+ TALLOC_FREE(req);
+ return NULL;
+}
+
+static void np_write_done(struct tevent_req *subreq)
+{
+ 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;
+
+ received = writev_recv(subreq, &err);
+ if (received < 0) {
+ tevent_req_nterror(req, map_nt_error_from_unix(err));
+ return;
}
+ state->nwritten = received;
+ tevent_req_done(req);
+}
- return ((*nwritten) >= 0)
- ? NT_STATUS_OK : NT_STATUS_UNEXPECTED_IO_ERROR;
+NTSTATUS np_write_recv(struct tevent_req *req, ssize_t *pnwritten)
+{
+ struct np_write_state *state = tevent_req_data(
+ req, struct np_write_state);
+ NTSTATUS status;
+
+ if (tevent_req_is_nterror(req, &status)) {
+ return status;
+ }
+ *pnwritten = state->nwritten;
+ return NT_STATUS_OK;
}
-NTSTATUS np_read(struct files_struct *fsp, uint8_t *data, size_t len,
- ssize_t *nread, bool *is_data_outstanding)
+static ssize_t rpc_frag_more_fn(uint8_t *buf, size_t buflen, void *priv)
{
- if (!fsp_is_np(fsp)) {
- return NT_STATUS_INVALID_HANDLE;
+ 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);
- switch (fsp->fake_file_handle->type) {
- case FAKE_FILE_TYPE_NAMED_PIPE: {
+ if (!ret) {
+ return -1;
+ }
+
+ return (hdr.frag_len - RPC_HEADER_LEN);
+}
+
+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 tevent_req *req, void *private_data);
+static void np_read_done(struct tevent_req *subreq);
+
+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 tevent_req *req;
+ struct np_read_state *state;
+ NTSTATUS status;
+
+ req = tevent_req_create(mem_ctx, &state, struct np_read_state);
+ if (req == NULL) {
+ return NULL;
+ }
+
+ 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;
+
+ 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;
+ }
+ return req;
+ }
- break;
+ status = NT_STATUS_INVALID_HANDLE;
+ post_status:
+ if (NT_STATUS_IS_OK(status)) {
+ tevent_req_done(req);
+ } else {
+ tevent_req_nterror(req, status);
}
- default:
- return NT_STATUS_INVALID_HANDLE;
- break;
+ return tevent_req_post(req, ev);
+ fail:
+ TALLOC_FREE(req);
+ return NULL;
+}
+
+static void np_read_trigger(struct tevent_req *req, void *private_data)
+{
+ 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;
}
+ tevent_req_set_callback(subreq, np_read_done, req);
+}
- return ((*nread) >= 0)
- ? NT_STATUS_OK : NT_STATUS_UNEXPECTED_IO_ERROR;
+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;
+ }
+
+ 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;
+ }
+
+ tevent_req_done(req);
+ return;
+}
+
+NTSTATUS np_read_recv(struct tevent_req *req, ssize_t *nread,
+ bool *is_data_outstanding)
+{
+ struct np_read_state *state = tevent_req_data(
+ req, struct np_read_state);
+ NTSTATUS status;
+
+ if (tevent_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;
+}
+
+/*******************************************************************
+ gets a domain user's groups from their already-calculated NT_USER_TOKEN
+ ********************************************************************/
+
+static NTSTATUS nt_token_to_group_list(TALLOC_CTX *mem_ctx,
+ const DOM_SID *domain_sid,
+ size_t num_sids,
+ const DOM_SID *sids,
+ int *numgroups,
+ struct samr_RidWithAttribute **pgids)
+{
+ int i;
+
+ *numgroups=0;
+ *pgids = NULL;
+
+ for (i=0; i<num_sids; i++) {
+ struct samr_RidWithAttribute gid;
+ if (!sid_peek_check_rid(domain_sid, &sids[i], &gid.rid)) {
+ continue;
+ }
+ gid.attributes = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT|
+ SE_GROUP_ENABLED);
+ ADD_TO_ARRAY(mem_ctx, struct samr_RidWithAttribute,
+ gid, pgids, numgroups);
+ if (*pgids == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ }
+ return NT_STATUS_OK;
+}
+
+/****************************************************************************
+ inits a netr_SamBaseInfo structure from an auth_serversupplied_info.
+*****************************************************************************/
+
+static NTSTATUS serverinfo_to_SamInfo_base(TALLOC_CTX *mem_ctx,
+ struct auth_serversupplied_info *server_info,
+ uint8_t *pipe_session_key,
+ size_t pipe_session_key_len,
+ struct netr_SamBaseInfo *base)
+{
+ struct samu *sampw;
+ struct samr_RidWithAttribute *gids = NULL;
+ const DOM_SID *user_sid = NULL;
+ const DOM_SID *group_sid = NULL;
+ DOM_SID domain_sid;
+ uint32 user_rid, group_rid;
+ NTSTATUS status;
+
+ int num_gids = 0;
+ const char *my_name;
+
+ struct netr_UserSessionKey user_session_key;
+ struct netr_LMSessionKey lm_session_key;
+
+ NTTIME last_logon, last_logoff, acct_expiry, last_password_change;
+ NTTIME allow_password_change, force_password_change;
+ struct samr_RidWithAttributeArray groups;
+ int i;
+ struct dom_sid2 *sid = NULL;
+
+ ZERO_STRUCT(user_session_key);
+ ZERO_STRUCT(lm_session_key);
+
+ sampw = server_info->sam_account;
+
+ user_sid = pdb_get_user_sid(sampw);
+ group_sid = pdb_get_group_sid(sampw);
+
+ if (pipe_session_key && pipe_session_key_len != 16) {
+ DEBUG(0,("serverinfo_to_SamInfo3: invalid "
+ "pipe_session_key_len[%zu] != 16\n",
+ pipe_session_key_len));
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+
+ if ((user_sid == NULL) || (group_sid == NULL)) {
+ DEBUG(1, ("_netr_LogonSamLogon: User without group or user SID\n"));
+ return NT_STATUS_UNSUCCESSFUL;
+ }
+
+ sid_copy(&domain_sid, user_sid);
+ sid_split_rid(&domain_sid, &user_rid);
+
+ sid = sid_dup_talloc(mem_ctx, &domain_sid);
+ if (!sid) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (!sid_peek_check_rid(&domain_sid, group_sid, &group_rid)) {
+ DEBUG(1, ("_netr_LogonSamLogon: user %s\\%s has user sid "
+ "%s\n but group sid %s.\n"
+ "The conflicting domain portions are not "
+ "supported for NETLOGON calls\n",
+ pdb_get_domain(sampw),
+ pdb_get_username(sampw),
+ sid_string_dbg(user_sid),
+ sid_string_dbg(group_sid)));
+ return NT_STATUS_UNSUCCESSFUL;
+ }
+
+ if(server_info->login_server) {
+ my_name = server_info->login_server;
+ } else {
+ my_name = global_myname();
+ }
+
+ status = nt_token_to_group_list(mem_ctx, &domain_sid,
+ server_info->num_sids,
+ server_info->sids,
+ &num_gids, &gids);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ if (server_info->user_session_key.length) {
+ memcpy(user_session_key.key,
+ server_info->user_session_key.data,
+ MIN(sizeof(user_session_key.key),
+ server_info->user_session_key.length));
+ if (pipe_session_key) {
+ arcfour_crypt(user_session_key.key, pipe_session_key, 16);
+ }
+ }
+ if (server_info->lm_session_key.length) {
+ memcpy(lm_session_key.key,
+ server_info->lm_session_key.data,
+ MIN(sizeof(lm_session_key.key),
+ server_info->lm_session_key.length));
+ if (pipe_session_key) {
+ arcfour_crypt(lm_session_key.key, pipe_session_key, 8);
+ }
+ }
+
+ groups.count = num_gids;
+ groups.rids = TALLOC_ARRAY(mem_ctx, struct samr_RidWithAttribute, groups.count);
+ if (!groups.rids) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ for (i=0; i < groups.count; i++) {
+ groups.rids[i].rid = gids[i].rid;
+ groups.rids[i].attributes = gids[i].attributes;
+ }
+
+ unix_to_nt_time(&last_logon, pdb_get_logon_time(sampw));
+ unix_to_nt_time(&last_logoff, get_time_t_max());
+ unix_to_nt_time(&acct_expiry, get_time_t_max());
+ unix_to_nt_time(&last_password_change, pdb_get_pass_last_set_time(sampw));
+ unix_to_nt_time(&allow_password_change, pdb_get_pass_can_change_time(sampw));
+ unix_to_nt_time(&force_password_change, pdb_get_pass_must_change_time(sampw));
+
+ base->last_logon = last_logon;
+ base->last_logoff = last_logoff;
+ base->acct_expiry = acct_expiry;
+ base->last_password_change = last_password_change;
+ base->allow_password_change = allow_password_change;
+ base->force_password_change = force_password_change;
+ base->account_name.string = talloc_strdup(mem_ctx, pdb_get_username(sampw));
+ base->full_name.string = talloc_strdup(mem_ctx, pdb_get_fullname(sampw));
+ base->logon_script.string = talloc_strdup(mem_ctx, pdb_get_logon_script(sampw));
+ base->profile_path.string = talloc_strdup(mem_ctx, pdb_get_profile_path(sampw));
+ base->home_directory.string = talloc_strdup(mem_ctx, pdb_get_homedir(sampw));
+ base->home_drive.string = talloc_strdup(mem_ctx, pdb_get_dir_drive(sampw));
+ base->logon_count = 0; /* ?? */
+ base->bad_password_count = 0; /* ?? */
+ base->rid = user_rid;
+ base->primary_gid = group_rid;
+ base->groups = groups;
+ base->user_flags = NETLOGON_EXTRA_SIDS;
+ base->key = user_session_key;
+ base->logon_server.string = my_name;
+ base->domain.string = talloc_strdup(mem_ctx, pdb_get_domain(sampw));
+ base->domain_sid = sid;
+ base->LMSessKey = lm_session_key;
+ base->acct_flags = pdb_get_acct_ctrl(sampw);
+
+ ZERO_STRUCT(user_session_key);
+ ZERO_STRUCT(lm_session_key);
+
+ return NT_STATUS_OK;
+}
+
+/****************************************************************************
+ inits a netr_SamInfo2 structure from an auth_serversupplied_info. sam2 must
+ already be initialized and is used as the talloc parent for its members.
+*****************************************************************************/
+
+NTSTATUS serverinfo_to_SamInfo2(struct auth_serversupplied_info *server_info,
+ uint8_t *pipe_session_key,
+ size_t pipe_session_key_len,
+ struct netr_SamInfo2 *sam2)
+{
+ NTSTATUS status;
+
+ status = serverinfo_to_SamInfo_base(sam2,
+ server_info,
+ pipe_session_key,
+ pipe_session_key_len,
+ &sam2->base);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ return NT_STATUS_OK;
+}
+
+/****************************************************************************
+ inits a netr_SamInfo3 structure from an auth_serversupplied_info. sam3 must
+ already be initialized and is used as the talloc parent for its members.
+*****************************************************************************/
+
+NTSTATUS serverinfo_to_SamInfo3(struct auth_serversupplied_info *server_info,
+ uint8_t *pipe_session_key,
+ size_t pipe_session_key_len,
+ struct netr_SamInfo3 *sam3)
+{
+ NTSTATUS status;
+
+ status = serverinfo_to_SamInfo_base(sam3,
+ server_info,
+ pipe_session_key,
+ pipe_session_key_len,
+ &sam3->base);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ sam3->sidcount = 0;
+ sam3->sids = NULL;
+
+ return NT_STATUS_OK;
}
git.samba.org / metze / samba / wip.git / blobdiff