-/*
+/*
* Unix SMB/CIFS implementation.
* RPC Pipe client / server routines
* Copyright (C) Andrew Tridgell 1992-1998,
* Largely re-written : 2005
* Copyright (C) Jeremy Allison 1998 - 2005
- *
+ *
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#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 "../libcli/auth/schannel.h"
+#include "../libcli/auth/spnego.h"
+#include "../libcli/auth/ntlmssp.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
-static int pipes_open;
-
-static pipes_struct *InternalPipes;
-
-/* TODO
- * the following prototypes are declared here to avoid
- * code being moved about too much for a patch to be
- * disrupted / less obvious.
- *
- * these functions, and associated functions that they
- * call, should be moved behind a .so module-loading
- * system _anyway_. so that's the next step...
- */
-
-static int close_internal_rpc_pipe_hnd(struct pipes_struct *p);
-
-/****************************************************************************
- Internal Pipe iterator functions.
-****************************************************************************/
-
-pipes_struct *get_first_internal_pipe(void)
-{
- return InternalPipes;
-}
-
-pipes_struct *get_next_internal_pipe(pipes_struct *p)
-{
- return p->next;
-}
-
/****************************************************************************
Initialise an outgoing packet.
****************************************************************************/
o_data->data_sent_length = 0;
o_data->current_pdu_sent = 0;
- prs_mem_free(&o_data->frag);
+ data_blob_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, 128, p->mem_ctx, MARSHALL)) {
- DEBUG(0,("pipe_init_outgoing_data: malloc fail.\n"));
- return False;
- }
+ data_blob_free(&o_data->rdata);
return True;
}
-/****************************************************************************
- Make an internal namedpipes structure
-****************************************************************************/
-
-static struct pipes_struct *make_internal_rpc_pipe_p(TALLOC_CTX *mem_ctx,
- 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",
- get_pipe_name_from_iface(syntax)));
-
- p = TALLOC_ZERO_P(mem_ctx, struct pipes_struct);
-
- if (!p) {
- DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
- return 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, syntax)) {
- DEBUG(0,("open_rpc_pipe_p: init_pipe_handles failed.\n"));
- talloc_destroy(p->mem_ctx);
- TALLOC_FREE(p);
- return NULL;
- }
-
- /*
- * Initialize the incoming RPC data buffer with one PDU worth of memory.
- * We cheat here and say we're marshalling, as we intend to add incoming
- * data directly into the prs_struct and we want it to auto grow. We will
- * change the type to UNMARSALLING before processing the stream.
- */
-
- 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);
- TALLOC_FREE(p);
- return NULL;
- }
-
- p->server_info = copy_serverinfo(p, server_info);
- if (p->server_info == NULL) {
- DEBUG(0, ("open_rpc_pipe_p: copy_serverinfo failed\n"));
- talloc_destroy(p->mem_ctx);
- close_policy_by_pipe(p);
- TALLOC_FREE(p);
- return NULL;
- }
-
- DLIST_ADD(InternalPipes, p);
-
- memcpy(p->client_address, client_address, sizeof(p->client_address));
-
- p->endian = RPC_LITTLE_ENDIAN;
-
- /*
- * Initialize the outgoing RPC data buffer with no memory.
- */
- prs_init_empty(&p->out_data.rdata, p->mem_ctx, MARSHALL);
-
- p->syntax = *syntax;
-
- DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
- get_pipe_name_from_iface(syntax), pipes_open));
-
- talloc_set_destructor(p, close_internal_rpc_pipe_hnd);
-
- return p;
-}
-
/****************************************************************************
Sets the fault state on incoming packets.
****************************************************************************/
static void set_incoming_fault(pipes_struct *p)
{
- prs_mem_free(&p->in_data.data);
+ data_blob_free(&p->in_data.data);
p->in_data.pdu_needed_len = 0;
- p->in_data.pdu_received_len = 0;
+ p->in_data.pdu.length = 0;
p->fault_state = True;
DEBUG(10, ("set_incoming_fault: Setting fault state on pipe %s\n",
- get_pipe_name_from_iface(&p->syntax)));
+ get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
}
/****************************************************************************
static ssize_t fill_rpc_header(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_received_len);
+ 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_received_len ));
+ 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.current_in_pdu == NULL) {
- p->in_data.current_in_pdu = talloc_array(p, uint8_t,
- RPC_HEADER_LEN);
+ if (p->in_data.pdu.data == NULL) {
+ p->in_data.pdu.data = talloc_array(p, uint8_t, RPC_HEADER_LEN);
}
- if (p->in_data.current_in_pdu == NULL) {
+ if (p->in_data.pdu.data == 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;
+ 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;
}
-/****************************************************************************
- Unmarshalls a new PDU header. Assumes the raw header data is in current_in_pdu.
-****************************************************************************/
-
-static ssize_t unmarshall_rpc_header(pipes_struct *p)
+static bool get_pdu_size(pipes_struct *p)
{
- /*
- * Unmarshall the header to determine the needed length.
- */
-
- prs_struct rpc_in;
-
- if(p->in_data.pdu_received_len != RPC_HEADER_LEN) {
- DEBUG(0,("unmarshall_rpc_header: assert on rpc header length failed.\n"));
+ 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 -1;
+ return false;
}
- prs_init_empty( &rpc_in, p->mem_ctx, UNMARSHALL);
- prs_set_endian_data( &rpc_in, p->endian);
-
- prs_give_memory( &rpc_in, (char *)&p->in_data.current_in_pdu[0],
- p->in_data.pdu_received_len, False);
-
- /*
- * Unmarshall the header as this will tell us how much
- * data we need to read to get the complete pdu.
- * This also sets the endian flag in rpc_in.
- */
+ frag_len = dcerpc_get_frag_length(&p->in_data.pdu);
- if(!smb_io_rpc_hdr("", &p->hdr, &rpc_in, 0)) {
- DEBUG(0,("unmarshall_rpc_header: failed to unmarshall RPC_HDR.\n"));
+ /* 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);
- prs_mem_free(&rpc_in);
- return -1;
+ return false;
}
- /*
- * Validate the RPC header.
- */
+ p->in_data.pdu_needed_len = frag_len - RPC_HEADER_LEN;
- if(p->hdr.major != 5 && p->hdr.minor != 0) {
- DEBUG(0,("unmarshall_rpc_header: invalid major/minor numbers in RPC_HDR.\n"));
+ /* 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);
- prs_mem_free(&rpc_in);
- return -1;
+ return false;
}
- /*
- * If there's not data in the incoming buffer this should be the start of a new RPC.
- */
-
- if(prs_offset(&p->in_data.data) == 0) {
+ return true;
+}
- /*
- * AS/U doesn't set FIRST flag in a BIND packet it seems.
- */
+/****************************************************************************
+ Call this to free any talloc'ed memory. Do this after processing
+ a complete incoming and outgoing request (multiple incoming/outgoing
+ PDU's).
+****************************************************************************/
- if ((p->hdr.pkt_type == RPC_REQUEST) && !(p->hdr.flags & RPC_FLG_FIRST)) {
- /*
- * Ensure that the FIRST flag is set. If not then we have
- * a stream missmatch.
- */
+static void free_pipe_context(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);
+}
- DEBUG(0,("unmarshall_rpc_header: FIRST flag not set in first PDU !\n"));
- set_incoming_fault(p);
- prs_mem_free(&rpc_in);
- return -1;
- }
+/****************************************************************************
+ Processes a request pdu. This will do auth processing if needed, and
+ appends the data into the complete stream if the LAST flag is not set.
+****************************************************************************/
- /*
- * If this is the first PDU then set the endianness
- * flag in the pipe. We will need this when parsing all
- * data in this RPC.
- */
+static bool dcesrv_auth_request(pipes_struct *p, struct ncacn_packet *pkt)
+{
+ NTSTATUS status;
+ size_t hdr_size = DCERPC_REQUEST_LENGTH;
+ struct dcerpc_auth auth;
+ uint32_t auth_length;
+ DATA_BLOB data;
+ DATA_BLOB full_pkt;
- p->endian = rpc_in.bigendian_data;
+ DEBUG(10, ("Checking request auth.\n"));
- DEBUG(5,("unmarshall_rpc_header: using %sendian RPC\n",
- p->endian == RPC_LITTLE_ENDIAN ? "little-" : "big-" ));
+ if (pkt->pfc_flags & DCERPC_PFC_FLAG_OBJECT_UUID) {
+ hdr_size += 16;
+ }
- } else {
+ switch (p->auth.auth_level) {
+ case DCERPC_AUTH_LEVEL_PRIVACY:
+ DEBUG(10, ("Requested Privacy.\n"));
+ break;
- /*
- * If this is *NOT* the first PDU then check the endianness
- * flag in the pipe is the same as that in the PDU.
- */
+ case DCERPC_AUTH_LEVEL_INTEGRITY:
+ DEBUG(10, ("Requested Integrity.\n"));
+ break;
- if (p->endian != rpc_in.bigendian_data) {
- DEBUG(0,("unmarshall_rpc_header: FIRST endianness flag (%d) different in next PDU !\n", (int)p->endian));
- set_incoming_fault(p);
- prs_mem_free(&rpc_in);
- return -1;
+ case DCERPC_AUTH_LEVEL_CONNECT:
+ if (pkt->auth_length != 0) {
+ break;
}
- }
-
- /*
- * Ensure that the pdu length is sane.
- */
+ return true;
+ case DCERPC_AUTH_LEVEL_NONE:
+ if (pkt->auth_length != 0) {
+ return false;
+ }
+ return true;
- if((p->hdr.frag_len < RPC_HEADER_LEN) || (p->hdr.frag_len > RPC_MAX_PDU_FRAG_LEN)) {
- DEBUG(0,("unmarshall_rpc_header: assert on frag length failed.\n"));
- set_incoming_fault(p);
- prs_mem_free(&rpc_in);
- return -1;
+ default:
+ return false;
}
- DEBUG(10,("unmarshall_rpc_header: type = %u, flags = %u\n", (unsigned int)p->hdr.pkt_type,
- (unsigned int)p->hdr.flags ));
+ status = dcerpc_pull_auth_trailer(pkt, pkt,
+ &pkt->u.request.stub_and_verifier,
+ &auth, &auth_length, false);
+ if (!NT_STATUS_IS_OK(status)) {
+ return false;
+ }
- p->in_data.pdu_needed_len = (uint32)p->hdr.frag_len - RPC_HEADER_LEN;
+ pkt->u.request.stub_and_verifier.length -= auth_length;
- prs_mem_free(&rpc_in);
+ data.data = p->in_data.pdu.data + hdr_size;
+ data.length = pkt->u.request.stub_and_verifier.length;
+ full_pkt.data = p->in_data.pdu.data;
+ full_pkt.length = p->in_data.pdu.length - auth.credentials.length;
- 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;
- }
+ switch (p->auth.auth_type) {
+ case PIPE_AUTH_TYPE_NONE:
+ return true;
- return 0; /* No extra data processed. */
-}
+ case PIPE_AUTH_TYPE_SPNEGO_NTLMSSP:
+ case PIPE_AUTH_TYPE_NTLMSSP:
-/****************************************************************************
- Call this to free any talloc'ed memory. Do this before and after processing
- a complete PDU.
-****************************************************************************/
+ DEBUG(10, ("NTLMSSP auth\n"));
-static void free_pipe_context(pipes_struct *p)
-{
- if (p->mem_ctx) {
- 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);
- } else {
- 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;
+ if (!p->auth.a_u.auth_ntlmssp_state) {
+ DEBUG(0, ("Invalid auth level, "
+ "failed to process packet auth.\n"));
+ return false;
}
- }
-}
-
-/****************************************************************************
- Processes a request pdu. This will do auth processing if needed, and
- appends the data into the complete stream if the LAST flag is not set.
-****************************************************************************/
-static bool process_request_pdu(pipes_struct *p, prs_struct *rpc_in_p)
-{
- uint32 ss_padding_len = 0;
- size_t data_len = p->hdr.frag_len - RPC_HEADER_LEN - RPC_HDR_REQ_LEN -
- (p->hdr.auth_len ? RPC_HDR_AUTH_LEN : 0) - p->hdr.auth_len;
-
- if(!p->pipe_bound) {
- DEBUG(0,("process_request_pdu: rpc request with no bind.\n"));
- set_incoming_fault(p);
- return False;
- }
+ switch (p->auth.auth_level) {
+ case DCERPC_AUTH_LEVEL_PRIVACY:
+ status = auth_ntlmssp_unseal_packet(
+ p->auth.a_u.auth_ntlmssp_state,
+ data.data, data.length,
+ full_pkt.data, full_pkt.length,
+ &auth.credentials);
+ if (!NT_STATUS_IS_OK(status)) {
+ return false;
+ }
+ memcpy(pkt->u.request.stub_and_verifier.data,
+ data.data, data.length);
+ break;
- /*
- * Check if we need to do authentication processing.
- * This is only done on requests, not binds.
- */
+ case DCERPC_AUTH_LEVEL_INTEGRITY:
+ status = auth_ntlmssp_check_packet(
+ p->auth.a_u.auth_ntlmssp_state,
+ data.data, data.length,
+ full_pkt.data, full_pkt.length,
+ &auth.credentials);
+ if (!NT_STATUS_IS_OK(status)) {
+ return false;
+ }
+ break;
- /*
- * Read the RPC request header.
- */
+ default:
+ DEBUG(0, ("Invalid auth level, "
+ "failed to process packet auth.\n"));
+ return false;
+ }
+ break;
- if(!smb_io_rpc_hdr_req("req", &p->hdr_req, rpc_in_p, 0)) {
- DEBUG(0,("process_request_pdu: failed to unmarshall RPC_HDR_REQ.\n"));
- set_incoming_fault(p);
- return False;
- }
+ case PIPE_AUTH_TYPE_SCHANNEL:
- switch(p->auth.auth_type) {
- case PIPE_AUTH_TYPE_NONE:
- break;
+ DEBUG(10, ("SCHANNEL auth\n"));
- case PIPE_AUTH_TYPE_SPNEGO_NTLMSSP:
- case PIPE_AUTH_TYPE_NTLMSSP:
- {
- NTSTATUS status;
- if(!api_pipe_ntlmssp_auth_process(p, rpc_in_p, &ss_padding_len, &status)) {
- DEBUG(0,("process_request_pdu: failed to do auth processing.\n"));
- DEBUG(0,("process_request_pdu: error was %s.\n", nt_errstr(status) ));
- set_incoming_fault(p);
- return False;
+ switch (p->auth.auth_level) {
+ case DCERPC_AUTH_LEVEL_PRIVACY:
+ status = netsec_incoming_packet(
+ p->auth.a_u.schannel_auth,
+ pkt, true,
+ data.data, data.length,
+ &auth.credentials);
+ if (!NT_STATUS_IS_OK(status)) {
+ return false;
}
+ memcpy(pkt->u.request.stub_and_verifier.data,
+ data.data, data.length);
break;
- }
- case PIPE_AUTH_TYPE_SCHANNEL:
- if (!api_pipe_schannel_process(p, rpc_in_p, &ss_padding_len)) {
- DEBUG(3,("process_request_pdu: failed to do schannel processing.\n"));
- set_incoming_fault(p);
- return False;
+ case DCERPC_AUTH_LEVEL_INTEGRITY:
+ status = netsec_incoming_packet(
+ p->auth.a_u.schannel_auth,
+ pkt, false,
+ data.data, data.length,
+ &auth.credentials);
+ if (!NT_STATUS_IS_OK(status)) {
+ return false;
}
break;
default:
- DEBUG(0,("process_request_pdu: unknown auth type %u set.\n", (unsigned int)p->auth.auth_type ));
- set_incoming_fault(p);
- return False;
+ DEBUG(0, ("Invalid auth level, "
+ "failed to process packet auth.\n"));
+ return false;
+ }
+ break;
+
+ default:
+ DEBUG(0, ("process_request_pdu: "
+ "unknown auth type %u set.\n",
+ (unsigned int)p->auth.auth_type));
+ set_incoming_fault(p);
+ return false;
}
- /* Now we've done the sign/seal we can remove any padding data. */
- if (data_len > ss_padding_len) {
- data_len -= ss_padding_len;
+ /* remove the indicated amount of padding */
+ if (pkt->u.request.stub_and_verifier.length < auth.auth_pad_length) {
+ return false;
}
+ pkt->u.request.stub_and_verifier.length -= auth.auth_pad_length;
+
+ return true;
+}
+
+static bool process_request_pdu(pipes_struct *p, struct ncacn_packet *pkt)
+{
+ DATA_BLOB data;
+
+ if (!p->pipe_bound) {
+ DEBUG(0,("process_request_pdu: rpc request with no bind.\n"));
+ set_incoming_fault(p);
+ return False;
+ }
+
+ /* Store the opnum */
+ p->opnum = pkt->u.request.opnum;
+
+ if (!dcesrv_auth_request(p, pkt)) {
+ DEBUG(0,("Failed to check packet auth.\n"));
+ set_incoming_fault(p);
+ return false;
+ }
+
+ data = pkt->u.request.stub_and_verifier;
/*
* Check the data length doesn't go over the 15Mb limit.
* spoolsv.exe when the response to a GETPRINTERDRIVER2 RPC
* will not fit in the initial buffer of size 0x1068 --jerry 22/01/2002
*/
-
- 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 ));
+
+ if (p->in_data.data.length + data.length > MAX_RPC_DATA_SIZE) {
+ DEBUG(0, ("process_request_pdu: "
+ "rpc data buffer too large (%u) + (%u)\n",
+ (unsigned int)p->in_data.data.length,
+ (unsigned int)data.length));
set_incoming_fault(p);
return False;
}
* Append the data portion into the buffer and return.
*/
- if(!prs_append_some_prs_data(&p->in_data.data, rpc_in_p, prs_offset(rpc_in_p), data_len)) {
- DEBUG(0,("process_request_pdu: Unable to append data size %u to parse buffer of size %u.\n",
- (unsigned int)data_len, (unsigned int)prs_data_size(&p->in_data.data) ));
- set_incoming_fault(p);
- return False;
+ if (data.length) {
+ if (!data_blob_append(p->mem_ctx, &p->in_data.data,
+ data.data, data.length)) {
+ DEBUG(0, ("Unable to append data size %u "
+ "to parse buffer of size %u.\n",
+ (unsigned int)data.length,
+ (unsigned int)p->in_data.data.length));
+ set_incoming_fault(p);
+ return False;
+ }
}
- if(p->hdr.flags & RPC_FLG_LAST) {
+ if (pkt->pfc_flags & DCERPC_PFC_FLAG_LAST) {
bool ret = False;
/*
* Ok - we finally have a complete RPC stream.
* Call the rpc command to process it.
*/
- /*
- * Ensure the internal prs buffer size is *exactly* the same
- * size as the current offset.
- */
-
- if(!prs_set_buffer_size(&p->in_data.data, prs_offset(&p->in_data.data))) {
- DEBUG(0,("process_request_pdu: Call to prs_set_buffer_size failed!\n"));
- set_incoming_fault(p);
- return False;
- }
-
- /*
- * Set the parse offset to the start of the data and set the
- * prs_struct to UNMARSHALL.
- */
-
- prs_set_offset(&p->in_data.data, 0);
- prs_switch_type(&p->in_data.data, UNMARSHALL);
-
/*
* Process the complete data stream here.
*/
-
- free_pipe_context(p);
-
- if(pipe_init_outgoing_data(p)) {
- ret = api_pipe_request(p);
+ if (pipe_init_outgoing_data(p)) {
+ ret = api_pipe_request(p, pkt);
}
- free_pipe_context(p);
-
- /*
- * We have consumed the whole data stream. Set back to
- * marshalling and set the offset back to the start of
- * the buffer to re-use it (we could also do a prs_mem_free()
- * and then re_init on the next start of PDU. Not sure which
- * is best here.... JRA.
- */
-
- prs_switch_type(&p->in_data.data, MARSHALL);
- prs_set_offset(&p->in_data.data, 0);
return ret;
}
}
/****************************************************************************
- Processes a finished PDU stored in current_in_pdu. The RPC_HEADER has
- already been parsed and stored in p->hdr.
+ Processes a finished PDU stored in p->in_data.pdu.
****************************************************************************/
static void process_complete_pdu(pipes_struct *p)
{
- prs_struct rpc_in;
- size_t data_len = p->in_data.pdu_received_len - RPC_HEADER_LEN;
- char *data_p = (char *)&p->in_data.current_in_pdu[RPC_HEADER_LEN];
+ struct ncacn_packet *pkt = NULL;
+ NTSTATUS status;
bool reply = False;
if(p->fault_state) {
DEBUG(10,("process_complete_pdu: pipe %s in fault state.\n",
- get_pipe_name_from_iface(&p->syntax)));
- set_incoming_fault(p);
- setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
- return;
+ get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
+ goto done;
}
- prs_init_empty( &rpc_in, p->mem_ctx, UNMARSHALL);
+ pkt = talloc(p->mem_ctx, struct ncacn_packet);
+ if (!pkt) {
+ DEBUG(0, ("Out of memory!\n"));
+ goto done;
+ }
+
+ status = dcerpc_pull_ncacn_packet(pkt, &p->in_data.pdu, pkt);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("Failed to unmarshal rpc packet: %s!\n",
+ nt_errstr(status)));
+ goto done;
+ }
+
+ /* Store the call_id */
+ p->call_id = pkt->call_id;
/*
- * Ensure we're using the corrent endianness for both the
+ * Ensure we're using the corrent endianness for both the
* RPC header flags and the raw data we will be reading from.
*/
+ if (pkt->drep[0] == DCERPC_DREP_LE) {
+ p->endian = RPC_LITTLE_ENDIAN;
+ } else {
+ p->endian = RPC_BIG_ENDIAN;
+ }
+
+ DEBUG(10, ("Processing packet type %d\n", (int)pkt->ptype));
+
+ switch (pkt->ptype) {
+ case DCERPC_PKT_REQUEST:
+ reply = process_request_pdu(p, pkt);
+ break;
+
+ case DCERPC_PKT_PING: /* CL request - ignore... */
+ DEBUG(0, ("process_complete_pdu: Error. "
+ "Connectionless packet type %d received on "
+ "pipe %s.\n", (int)pkt->ptype,
+ get_pipe_name_from_syntax(talloc_tos(),
+ &p->syntax)));
+ break;
+
+ case DCERPC_PKT_RESPONSE: /* No responses here. */
+ DEBUG(0, ("process_complete_pdu: Error. "
+ "DCERPC_PKT_RESPONSE received from client "
+ "on pipe %s.\n",
+ get_pipe_name_from_syntax(talloc_tos(),
+ &p->syntax)));
+ break;
+
+ case DCERPC_PKT_FAULT:
+ case DCERPC_PKT_WORKING:
+ /* CL request - reply to a ping when a call in process. */
+ case DCERPC_PKT_NOCALL:
+ /* CL - server reply to a ping call. */
+ case DCERPC_PKT_REJECT:
+ case DCERPC_PKT_ACK:
+ case DCERPC_PKT_CL_CANCEL:
+ case DCERPC_PKT_FACK:
+ case DCERPC_PKT_CANCEL_ACK:
+ DEBUG(0, ("process_complete_pdu: Error. "
+ "Connectionless packet type %u received on "
+ "pipe %s.\n", (unsigned int)pkt->ptype,
+ get_pipe_name_from_syntax(talloc_tos(),
+ &p->syntax)));
+ break;
+
+ case DCERPC_PKT_BIND:
+ /*
+ * We assume that a pipe bind is only in one pdu.
+ */
+ if (pipe_init_outgoing_data(p)) {
+ reply = api_pipe_bind_req(p, pkt);
+ }
+ break;
- prs_set_endian_data( &rpc_in, p->endian);
- prs_set_endian_data( &p->in_data.data, p->endian);
-
- prs_give_memory( &rpc_in, data_p, (uint32)data_len, False);
-
- DEBUG(10,("process_complete_pdu: processing packet type %u\n",
- (unsigned int)p->hdr.pkt_type ));
-
- switch (p->hdr.pkt_type) {
- case RPC_REQUEST:
- reply = process_request_pdu(p, &rpc_in);
- break;
-
- 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,
- 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",
- get_pipe_name_from_iface(&p->syntax)));
- break;
-
- case RPC_FAULT:
- case RPC_WORKING: /* CL request - reply to a ping when a call in process. */
- case RPC_NOCALL: /* CL - server reply to a ping call. */
- case RPC_REJECT:
- case RPC_ACK:
- case RPC_CL_CANCEL:
- 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,
- get_pipe_name_from_iface(&p->syntax)));
- break;
-
- case RPC_BIND:
- /*
- * We assume that a pipe bind is only in one pdu.
- */
- if(pipe_init_outgoing_data(p)) {
- reply = api_pipe_bind_req(p, &rpc_in);
- }
- break;
-
- 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,
- get_pipe_name_from_iface(&p->syntax)));
- break;
-
+ case DCERPC_PKT_BIND_ACK:
+ case DCERPC_PKT_BIND_NAK:
+ DEBUG(0, ("process_complete_pdu: Error. "
+ "DCERPC_PKT_BINDACK/DCERPC_PKT_BINDNACK "
+ "packet type %u received on pipe %s.\n",
+ (unsigned int)pkt->ptype,
+ get_pipe_name_from_syntax(talloc_tos(),
+ &p->syntax)));
+ break;
- case RPC_ALTCONT:
- /*
- * We assume that a pipe bind is only in one pdu.
- */
- if(pipe_init_outgoing_data(p)) {
- reply = api_pipe_alter_context(p, &rpc_in);
- }
- break;
- case RPC_ALTCONTRESP:
- DEBUG(0,("process_complete_pdu: Error. RPC_ALTCONTRESP on pipe %s: Should only be server -> client.\n",
- get_pipe_name_from_iface(&p->syntax)));
- break;
+ case DCERPC_PKT_ALTER:
+ /*
+ * We assume that a pipe bind is only in one pdu.
+ */
+ if (pipe_init_outgoing_data(p)) {
+ reply = api_pipe_alter_context(p, pkt);
+ }
+ break;
- case RPC_AUTH3:
- /*
- * The third packet in an NTLMSSP auth exchange.
- */
- if(pipe_init_outgoing_data(p)) {
- reply = api_pipe_bind_auth3(p, &rpc_in);
- }
- break;
+ case DCERPC_PKT_ALTER_RESP:
+ DEBUG(0, ("process_complete_pdu: Error. "
+ "DCERPC_PKT_ALTER_RESP on pipe %s: "
+ "Should only be server -> client.\n",
+ get_pipe_name_from_syntax(talloc_tos(),
+ &p->syntax)));
+ break;
- case RPC_SHUTDOWN:
- DEBUG(0,("process_complete_pdu: Error. RPC_SHUTDOWN on pipe %s: Should only be server -> client.\n",
- get_pipe_name_from_iface(&p->syntax)));
- break;
+ case DCERPC_PKT_AUTH3:
+ /*
+ * The third packet in an NTLMSSP auth exchange.
+ */
+ if (pipe_init_outgoing_data(p)) {
+ reply = api_pipe_bind_auth3(p, pkt);
+ }
+ break;
+
+ case DCERPC_PKT_SHUTDOWN:
+ DEBUG(0, ("process_complete_pdu: Error. "
+ "DCERPC_PKT_SHUTDOWN on pipe %s: "
+ "Should only be server -> client.\n",
+ get_pipe_name_from_syntax(talloc_tos(),
+ &p->syntax)));
+ break;
+
+ case DCERPC_PKT_CO_CANCEL:
+ /* For now just free all client data and continue
+ * processing. */
+ DEBUG(3,("process_complete_pdu: DCERPC_PKT_CO_CANCEL."
+ " Abandoning rpc call.\n"));
+ /* As we never do asynchronous RPC serving, we can
+ * never cancel a call (as far as I know).
+ * If we ever did we'd have to send a cancel_ack reply.
+ * For now, just free all client data and continue
+ * processing. */
+ reply = True;
+ break;
- case RPC_CO_CANCEL:
- /* For now just free all client data and continue processing. */
- DEBUG(3,("process_complete_pdu: RPC_ORPHANED. Abandoning rpc call.\n"));
- /* As we never do asynchronous RPC serving, we can never cancel a
- call (as far as I know). If we ever did we'd have to send a cancel_ack
- reply. For now, just free all client data and continue processing. */
- reply = True;
- break;
#if 0
- /* Enable this if we're doing async rpc. */
- /* We must check the call-id matches the outstanding callid. */
- if(pipe_init_outgoing_data(p)) {
- /* Send a cancel_ack PDU reply. */
- /* We should probably check the auth-verifier here. */
- reply = setup_cancel_ack_reply(p, &rpc_in);
- }
- break;
+ /* Enable this if we're doing async rpc. */
+ /* We must check the outstanding callid matches. */
+ if (pipe_init_outgoing_data(p)) {
+ /* Send a cancel_ack PDU reply. */
+ /* We should probably check the auth-verifier here. */
+ reply = setup_cancel_ack_reply(p, pkt);
+ }
+ break;
#endif
- case RPC_ORPHANED:
- /* We should probably check the auth-verifier here.
- For now just free all client data and continue processing. */
- DEBUG(3,("process_complete_pdu: RPC_ORPHANED. Abandoning rpc call.\n"));
- reply = True;
- break;
+ case DCERPC_PKT_ORPHANED:
+ /* We should probably check the auth-verifier here.
+ * For now just free all client data and continue
+ * processing. */
+ DEBUG(3, ("process_complete_pdu: DCERPC_PKT_ORPHANED."
+ " Abandoning rpc call.\n"));
+ reply = True;
+ break;
- default:
- DEBUG(0,("process_complete_pdu: Unknown rpc type = %u received.\n", (unsigned int)p->hdr.pkt_type ));
- break;
+ default:
+ DEBUG(0, ("process_complete_pdu: "
+ "Unknown rpc type = %u received.\n",
+ (unsigned int)pkt->ptype));
+ break;
}
- /* Reset to little endian. Probably don't need this but it won't hurt. */
- prs_set_endian_data( &p->in_data.data, RPC_LITTLE_ENDIAN);
-
+done:
if (!reply) {
DEBUG(3,("process_complete_pdu: DCE/RPC fault sent on "
- "pipe %s\n", get_pipe_name_from_iface(&p->syntax)));
+ "pipe %s\n", get_pipe_name_from_syntax(talloc_tos(),
+ &p->syntax)));
set_incoming_fault(p);
setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
- prs_mem_free(&rpc_in);
+ TALLOC_FREE(pkt);
} else {
/*
* Reset the lengths. We're ready for a new pdu.
*/
- TALLOC_FREE(p->in_data.current_in_pdu);
+ TALLOC_FREE(p->in_data.pdu.data);
p->in_data.pdu_needed_len = 0;
- p->in_data.pdu_received_len = 0;
+ p->in_data.pdu.length = 0;
}
- prs_mem_free(&rpc_in);
+ TALLOC_FREE(pkt);
}
/****************************************************************************
static ssize_t process_incoming_data(pipes_struct *p, char *data, size_t n)
{
- size_t data_to_copy = MIN(n, RPC_MAX_PDU_FRAG_LEN - p->in_data.pdu_received_len);
+ size_t data_to_copy = MIN(n, RPC_MAX_PDU_FRAG_LEN
+ - p->in_data.pdu.length);
- DEBUG(10,("process_incoming_data: Start: pdu_received_len = %u, pdu_needed_len = %u, incoming data = %u\n",
- (unsigned int)p->in_data.pdu_received_len, (unsigned int)p->in_data.pdu_needed_len,
- (unsigned int)n ));
+ 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.
+ * 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_received_len, (unsigned int)n ));
+ 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 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_received_len < RPC_HEADER_LEN)) {
+ 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.
}
/*
- * At this point we know we have at least an RPC_HEADER_LEN amount of data
- * stored in current_in_pdu.
+ * 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.
- * Unmarshall the header so we know how much more
- * data we need, then loop again.
+ * 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) {
- if(p->in_data.pdu_needed_len == 0) {
- ssize_t rret = unmarshall_rpc_header(p);
- if (rret == -1 || p->in_data.pdu_needed_len > 0) {
- return rret;
+ bool ok = get_pdu_size(p);
+ if (!ok) {
+ return -1;
}
- /* If rret == 0 and pdu_needed_len == 0 here we have a PDU that consists
- of an RPC_HEADER only. This is a RPC_SHUTDOWN, RPC_CO_CANCEL or RPC_ORPHANED
- pdu type. Deal with this in process_complete_pdu(). */
+ 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 in p->hdr.
+ * 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 current_in_pdu buffer.
+ * 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.current_in_pdu[p->in_data.pdu_received_len], data, data_to_copy);
- p->in_data.pdu_received_len += data_to_copy;
+ 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;
/*
return data_to_copy;
}
- DEBUG(10,("process_incoming_data: not a complete PDU yet. pdu_received_len = %u, pdu_needed_len = %u\n",
- (unsigned int)p->in_data.pdu_received_len, (unsigned int)p->in_data.pdu_needed_len ));
+ 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;
}
while(data_left) {
ssize_t data_used;
- DEBUG(10,("write_to_pipe: data_left = %u\n", (unsigned int)data_left ));
+ 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 ));
+ 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;
}
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)
+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;
+ return -1;
}
- DEBUG(6,(" name: %s len: %u\n", get_pipe_name_from_iface(&p->syntax),
+ DEBUG(6,(" name: %s len: %u\n",
+ get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
(unsigned int)n));
/*
*/
/*
- * This condition should result in the connection being closed.
+ * 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_iface(&p->syntax),
+ (unsigned int)n,
+ get_pipe_name_from_syntax(talloc_tos(), &p->syntax),
RPC_MAX_PDU_FRAG_LEN ));
n = RPC_MAX_PDU_FRAG_LEN;
}
* PDU.
*/
- pdu_remaining = prs_offset(&p->out_data.frag)
+ pdu_remaining = p->out_data.frag.length
- p->out_data.current_pdu_sent;
if (pdu_remaining > 0) {
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),
+ 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,
- prs_data_p(&p->out_data.frag)
+ p->out_data.frag.data
+ p->out_data.current_pdu_sent,
data_returned);
*/
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,
+ "= %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)prs_offset(&p->out_data.rdata) ));
+ (unsigned int)p->out_data.rdata.length));
- if(p->out_data.data_sent_length >= prs_offset(&p->out_data.rdata)) {
+ if (p->out_data.data_sent_length >= p->out_data.rdata.length) {
/*
* We have sent all possible data, return 0.
*/
if(!create_next_pdu(p)) {
DEBUG(0,("read_from_pipe: %s: create_next_pdu failed.\n",
- get_pipe_name_from_iface(&p->syntax)));
+ get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
return -1;
}
- data_returned = MIN(n, prs_offset(&p->out_data.frag));
+ data_returned = MIN(n, p->out_data.frag.length);
- memcpy( data, prs_data_p(&p->out_data.frag), (size_t)data_returned);
+ memcpy(data, p->out_data.frag.data, (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.frag.length > n;
- return data_returned;
-}
-
-/****************************************************************************
- Close an rpc pipe.
-****************************************************************************/
+ 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);
-static int close_internal_rpc_pipe_hnd(struct pipes_struct *p)
-{
- if (!p) {
- DEBUG(0,("Invalid pipe in close_internal_rpc_pipe_hnd\n"));
- return False;
- }
-
- prs_mem_free(&p->out_data.frag);
- prs_mem_free(&p->out_data.rdata);
- prs_mem_free(&p->in_data.data);
-
- if (p->auth.auth_data_free_func) {
- (*p->auth.auth_data_free_func)(&p->auth);
+ 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);
+ }
}
- TALLOC_FREE(p->mem_ctx);
-
- free_pipe_rpc_context( p->contexts );
-
- /* Free the handles database. */
- close_policy_by_pipe(p);
-
- DLIST_REMOVE(InternalPipes, p);
-
- ZERO_STRUCTP(p);
-
- TALLOC_FREE(p);
-
- return True;
+ return data_returned;
}
bool fsp_is_np(struct files_struct *fsp)
}
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;
- int fd;
-
- uint8_t *msg;
- size_t sent;
};
-static int np_proxy_state_destructor(struct np_proxy_state *state)
-{
- if (state->fd != -1) {
- close(state->fd);
- }
- return 0;
-}
-
static struct np_proxy_state *make_external_rpc_pipe_p(TALLOC_CTX *mem_ctx,
- const char *pipe_name,
- struct auth_serversupplied_info *server_info)
+ 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;
- struct sockaddr_un addr;
- char *socket_path;
+ char *socket_np_dir;
const char *socket_dir;
-
- DATA_BLOB req_blob;
+ struct tevent_context *ev;
+ struct tevent_req *subreq;
struct netr_SamInfo3 *info3;
- struct named_pipe_auth_req req;
- DATA_BLOB rep_blob;
- uint8 rep_buf[20];
- struct named_pipe_auth_rep rep;
- enum ndr_err_code ndr_err;
NTSTATUS status;
- ssize_t written;
+ bool ok;
+ int ret;
+ int sys_errno;
result = talloc(mem_ctx, struct np_proxy_state);
if (result == NULL) {
return NULL;
}
- result->fd = socket(AF_UNIX, SOCK_STREAM, 0);
- if (result->fd == -1) {
- DEBUG(10, ("socket(2) failed: %s\n", strerror(errno)));
+ result->read_queue = tevent_queue_create(result, "np_read");
+ if (result->read_queue == NULL) {
+ DEBUG(0, ("tevent_queue_create failed\n"));
goto fail;
}
- talloc_set_destructor(result, np_proxy_state_destructor);
- ZERO_STRUCT(addr);
- addr.sun_family = AF_UNIX;
+ 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",
DEBUG(0, ("externan_rpc_pipe:socket_dir not set\n"));
goto fail;
}
-
- socket_path = talloc_asprintf(talloc_tos(), "%s/np/%s",
- socket_dir, pipe_name);
- if (socket_path == NULL) {
+ socket_np_dir = talloc_asprintf(talloc_tos(), "%s/np", socket_dir);
+ if (socket_np_dir == NULL) {
DEBUG(0, ("talloc_asprintf failed\n"));
goto fail;
}
- strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path));
- TALLOC_FREE(socket_path);
-
- become_root();
- if (sys_connect(result->fd, (struct sockaddr *)&addr) == -1) {
- unbecome_root();
- DEBUG(0, ("connect(%s) failed: %s\n", addr.sun_path,
- strerror(errno)));
- goto fail;
- }
- unbecome_root();
- info3 = talloc(talloc_tos(), struct netr_SamInfo3);
+ info3 = talloc_zero(talloc_tos(), struct netr_SamInfo3);
if (info3 == NULL) {
DEBUG(0, ("talloc failed\n"));
goto fail;
goto fail;
}
- req.level = 1;
- req.info.info1 = *info3;
-
- ndr_err = ndr_push_struct_blob(
- &req_blob, talloc_tos(), NULL, &req,
- (ndr_push_flags_fn_t)ndr_push_named_pipe_auth_req);
-
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- DEBUG(10, ("ndr_push_named_pipe_auth_req failed: %s\n",
- ndr_errstr(ndr_err)));
- goto fail;
- }
-
- DEBUG(10, ("named_pipe_auth_req(client)[%u]\n", (uint32_t)req_blob.length));
- dump_data(10, req_blob.data, req_blob.length);
-
- written = write_data(result->fd, (char *)req_blob.data,
- req_blob.length);
- if (written == -1) {
- DEBUG(3, ("Could not write auth req data to RPC server\n"));
- goto fail;
- }
-
- status = read_data(result->fd, (char *)rep_buf, sizeof(rep_buf));
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(3, ("Could not read auth result\n"));
- goto fail;
- }
-
- rep_blob = data_blob_const(rep_buf, sizeof(rep_buf));
-
- DEBUG(10,("name_pipe_auth_rep(client)[%u]\n", (uint32_t)rep_blob.length));
- dump_data(10, rep_blob.data, rep_blob.length);
-
- ndr_err = ndr_pull_struct_blob(
- &rep_blob, talloc_tos(), NULL, &rep,
- (ndr_pull_flags_fn_t)ndr_pull_named_pipe_auth_rep);
-
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- DEBUG(0, ("ndr_pull_named_pipe_auth_rep failed: %s\n",
- ndr_errstr(ndr_err)));
- goto fail;
- }
-
- if (rep.length != 16) {
- DEBUG(0, ("req invalid length: %u != 16\n",
- rep.length));
- goto fail;
- }
-
- if (strcmp(NAMED_PIPE_AUTH_MAGIC, rep.magic) != 0) {
- DEBUG(0, ("req invalid magic: %s != %s\n",
- rep.magic, NAMED_PIPE_AUTH_MAGIC));
- goto fail;
- }
-
- if (!NT_STATUS_IS_OK(rep.status)) {
- DEBUG(0, ("req failed: %s\n",
- nt_errstr(rep.status)));
+ 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;
}
-
- if (rep.level != 1) {
- DEBUG(0, ("req invalid level: %u != 1\n",
- rep.level));
+ 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;
- }
- 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) {
+ 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;
}
}
NTSTATUS np_open(TALLOC_CTX *mem_ctx, const char *name,
- const char *client_address,
+ const struct tsocket_address *local_address,
+ const struct tsocket_address *remote_address,
struct auth_serversupplied_info *server_info,
struct fake_file_handle **phandle)
{
if ((proxy_list != NULL) && str_list_check_ci(proxy_list, name)) {
struct np_proxy_state *p;
- p = make_external_rpc_pipe_p(handle, name, server_info);
+ p = make_external_rpc_pipe_p(handle, name,
+ local_address,
+ remote_address,
+ server_info);
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);
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 = "";
+ }
+
p = make_internal_rpc_pipe_p(handle, &syntax, client_address,
server_info);
return NT_STATUS_OK;
}
+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);
+ size_t read_count;
+
+ read_count = tevent_queue_length(p->read_queue);
+ if (read_count > 0) {
+ return true;
+ }
+
+ return false;
+ }
+
+ return false;
+}
+
struct np_write_state {
struct event_context *ev;
struct np_proxy_state *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);
+ subreq = tstream_writev_queue_send(state, ev,
+ p->npipe,
+ p->write_queue,
+ &state->iov, 1);
if (subreq == NULL) {
goto fail;
}
ssize_t received;
int err;
- received = writev_recv(subreq, &err);
+ received = tstream_writev_queue_recv(subreq, &err);
if (received < 0) {
tevent_req_nterror(req, map_nt_error_from_unix(err));
return;
return NT_STATUS_OK;
}
-static ssize_t rpc_frag_more_fn(uint8_t *buf, size_t buflen, void *priv)
+struct np_ipc_readv_next_vector_state {
+ uint8_t *buf;
+ size_t len;
+ off_t ofs;
+ size_t remaining;
+};
+
+static void np_ipc_readv_next_vector_init(struct np_ipc_readv_next_vector_state *s,
+ uint8_t *buf, size_t len)
+{
+ ZERO_STRUCTP(s);
+
+ s->buf = buf;
+ s->len = MIN(len, UINT16_MAX);
+}
+
+static int np_ipc_readv_next_vector(struct tstream_context *stream,
+ void *private_data,
+ TALLOC_CTX *mem_ctx,
+ struct iovec **_vector,
+ size_t *count)
{
- prs_struct hdr_prs;
- struct rpc_hdr_info hdr;
- bool ret;
+ struct np_ipc_readv_next_vector_state *state =
+ (struct np_ipc_readv_next_vector_state *)private_data;
+ struct iovec *vector;
+ ssize_t pending;
+ size_t wanted;
+
+ if (state->ofs == state->len) {
+ *_vector = NULL;
+ *count = 0;
+ return 0;
+ }
+
+ pending = tstream_pending_bytes(stream);
+ if (pending == -1) {
+ return -1;
+ }
- if (buflen > RPC_HEADER_LEN) {
+ if (pending == 0 && state->ofs != 0) {
+ /* return a short read */
+ *_vector = NULL;
+ *count = 0;
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) {
+ if (pending == 0) {
+ /* we want at least one byte and recheck again */
+ wanted = 1;
+ } else {
+ size_t missing = state->len - state->ofs;
+ if (pending > missing) {
+ /* there's more available */
+ state->remaining = pending - missing;
+ wanted = missing;
+ } else {
+ /* read what we can get and recheck in the next cycle */
+ wanted = pending;
+ }
+ }
+
+ vector = talloc_array(mem_ctx, struct iovec, 1);
+ if (!vector) {
return -1;
}
- return (hdr.frag_len - RPC_HEADER_LEN);
+ vector[0].iov_base = state->buf + state->ofs;
+ vector[0].iov_len = wanted;
+
+ state->ofs += wanted;
+
+ *_vector = vector;
+ *count = 1;
+ return 0;
}
struct np_read_state {
- struct event_context *ev;
struct np_proxy_state *p;
- uint8_t *data;
- size_t len;
+ struct np_ipc_readv_next_vector_state next_vector;
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,
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;
- if (p->msg != NULL) {
- size_t thistime;
-
- 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;
- }
+ np_ipc_readv_next_vector_init(&state->next_vector,
+ data, len);
- state->ev = ev;
- state->p = p;
- state->data = data;
- state->len = len;
+ subreq = tstream_readv_pdu_queue_send(state,
+ ev,
+ p->npipe,
+ p->read_queue,
+ np_ipc_readv_next_vector,
+ &state->next_vector);
+ if (subreq == NULL) {
- if (!tevent_queue_add(p->read_queue, ev, req, np_read_trigger,
- NULL)) {
- goto fail;
}
+ tevent_req_set_callback(subreq, np_read_done, req);
return req;
}
tevent_req_nterror(req, status);
}
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);
}
static void np_read_done(struct tevent_req *subreq)
subreq, struct tevent_req);
struct np_read_state *state = tevent_req_data(
req, struct np_read_state);
- ssize_t received;
- size_t thistime;
+ ssize_t ret;
int err;
- received = read_packet_recv(subreq, state->p, &state->p->msg, &err);
+ ret = tstream_readv_pdu_queue_recv(subreq, &err);
TALLOC_FREE(subreq);
- if (received == -1) {
+ if (ret == -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;
- }
+ state->nread = ret;
+ state->is_data_outstanding = (state->next_vector.remaining > 0);
tevent_req_done(req);
return;
}
/**
- * Create a new RPC client context which uses a local dispatch function.
+ * @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_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)
+NTSTATUS rpc_connect_spoolss_pipe(connection_struct *conn,
+ struct rpc_pipe_client **spoolss_pipe)
{
- 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;
- }
+ /* TODO: check and handle disconnections */
- 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);
+ 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;
}
}
- 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;
-
+ *spoolss_pipe = conn->spoolss_pipe;
return NT_STATUS_OK;
}
git.samba.org / kai / samba.git / blobdiff