*/
#include "includes.h"
+#include "librpc/gen_ndr/ndr_named_pipe_auth.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
-#define PIPE "\\PIPE\\"
-#define PIPELEN strlen(PIPE)
-
-static smb_np_struct *chain_p;
static int pipes_open;
-/*
- * Sometimes I can't decide if I hate Windows printer driver
- * writers more than I hate the Windows spooler service driver
- * writers. This gets around a combination of bugs in the spooler
- * and the HP 8500 PCL driver that causes a spooler spin. JRA.
- *
- * bumped up from 20 -> 64 after viewing traffic from WordPerfect
- * 2002 running on NT 4.- SP6
- * bumped up from 64 -> 256 after viewing traffic from con2prt
- * for lots of printers on a WinNT 4.x SP6 box.
- */
-
-#ifndef MAX_OPEN_SPOOLSS_PIPES
-#define MAX_OPEN_SPOOLSS_PIPES 256
-#endif
-static int current_spoolss_pipes_open;
-
-static smb_np_struct *Pipes;
static pipes_struct *InternalPipes;
-static struct bitmap *bmap;
/* TODO
* the following prototypes are declared here to avoid
* system _anyway_. so that's the next step...
*/
-static ssize_t read_from_internal_pipe(void *np_conn, char *data, size_t n,
- bool *is_data_outstanding);
-static ssize_t write_to_internal_pipe(void *np_conn, char *data, size_t n);
-static bool close_internal_rpc_pipe_hnd(void *np_conn);
-static void *make_internal_rpc_pipe_p(const char *pipe_name,
- connection_struct *conn, uint16 vuid);
+static int close_internal_rpc_pipe_hnd(struct pipes_struct *p);
/****************************************************************************
Internal Pipe iterator functions.
return p->next;
}
-/* this must be larger than the sum of the open files and directories */
-static int pipe_handle_offset;
-
-/****************************************************************************
- Set the pipe_handle_offset. Called from smbd/files.c
-****************************************************************************/
-
-void set_pipe_handle_offset(int max_open_files)
-{
- if(max_open_files < 0x7000) {
- pipe_handle_offset = 0x7000;
- } else {
- pipe_handle_offset = max_open_files + 10; /* For safety. :-) */
- }
-}
-
-/****************************************************************************
- Reset pipe chain handle number.
-****************************************************************************/
-
-void reset_chain_p(void)
-{
- chain_p = NULL;
-}
-
-/****************************************************************************
- 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;
}
return True;
}
-/****************************************************************************
- Find first available pipe slot.
-****************************************************************************/
-
-smb_np_struct *open_rpc_pipe_p(const char *pipe_name,
- connection_struct *conn, uint16 vuid)
-{
- int i;
- smb_np_struct *p, *p_it;
- static int next_pipe;
- bool is_spoolss_pipe = False;
-
- DEBUG(4,("Open pipe requested %s (pipes_open=%d)\n",
- pipe_name, pipes_open));
-
- if (strstr(pipe_name, "spoolss")) {
- is_spoolss_pipe = True;
- }
-
- if (is_spoolss_pipe && current_spoolss_pipes_open >= MAX_OPEN_SPOOLSS_PIPES) {
- DEBUG(10,("open_rpc_pipe_p: spooler bug workaround. Denying open on pipe %s\n",
- pipe_name ));
- return NULL;
- }
-
- /* not repeating pipe numbers makes it easier to track things in
- log files and prevents client bugs where pipe numbers are reused
- over connection restarts */
-
- if (next_pipe == 0) {
- next_pipe = (sys_getpid() ^ time(NULL)) % MAX_OPEN_PIPES;
- }
-
- i = bitmap_find(bmap, next_pipe);
-
- if (i == -1) {
- DEBUG(0,("ERROR! Out of pipe structures\n"));
- return NULL;
- }
-
- next_pipe = (i+1) % MAX_OPEN_PIPES;
-
- for (p = Pipes; p; p = p->next) {
- DEBUG(5,("open_rpc_pipe_p: name %s pnum=%x\n", p->name, p->pnum));
- }
-
- p = talloc(NULL, smb_np_struct);
- if (!p) {
- DEBUG(0,("ERROR! no memory for smb_np_struct!\n"));
- return NULL;
- }
-
- ZERO_STRUCTP(p);
-
- p->name = talloc_strdup(p, pipe_name);
- if (p->name == NULL) {
- TALLOC_FREE(p);
- DEBUG(0,("ERROR! no memory for pipe name!\n"));
- return NULL;
- }
-
- /* add a dso mechanism instead of this, here */
-
- p->namedpipe_create = make_internal_rpc_pipe_p;
- p->namedpipe_read = read_from_internal_pipe;
- p->namedpipe_write = write_to_internal_pipe;
- p->namedpipe_close = close_internal_rpc_pipe_hnd;
-
- p->np_state = p->namedpipe_create(pipe_name, conn, vuid);
-
- if (p->np_state == NULL) {
- DEBUG(0,("open_rpc_pipe_p: make_internal_rpc_pipe_p failed.\n"));
- TALLOC_FREE(p);
- return NULL;
- }
-
- DLIST_ADD(Pipes, p);
-
- /*
- * 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.
- */
-
- bitmap_set(bmap, i);
- i += pipe_handle_offset;
-
- pipes_open++;
-
- p->pnum = i;
-
- p->open = True;
- p->device_state = 0;
- p->priority = 0;
- p->conn = conn;
- p->vuid = vuid;
-
- p->max_trans_reply = 0;
-
- DEBUG(4,("Opened pipe %s with handle %x (pipes_open=%d)\n",
- pipe_name, i, pipes_open));
-
- chain_p = p;
-
- /* Iterate over p_it as a temp variable, to display all open pipes */
- for (p_it = Pipes; p_it; p_it = p_it->next) {
- DEBUG(5,("open pipes: name %s pnum=%x\n", p_it->name, p_it->pnum));
- }
-
- return chain_p;
-}
-
/****************************************************************************
Make an internal namedpipes structure
****************************************************************************/
-static void *make_internal_rpc_pipe_p(const char *pipe_name,
- connection_struct *conn, uint16 vuid)
+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;
- user_struct *vuser = get_valid_user_struct(vuid);
-
- DEBUG(4,("Create pipe requested %s\n", pipe_name));
- if (!vuser && vuid != UID_FIELD_INVALID) {
- DEBUG(0,("ERROR! vuid %d did not map to a valid vuser struct!\n", vuid));
- return NULL;
- }
+ DEBUG(4,("Create pipe requested %s\n",
+ get_pipe_name_from_syntax(talloc_tos(), syntax)));
- p = SMB_MALLOC_P(pipes_struct);
+ p = TALLOC_ZERO_P(mem_ctx, struct pipes_struct);
if (!p) {
DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
return NULL;
}
- ZERO_STRUCTP(p);
-
- if ((p->mem_ctx = talloc_init("pipe %s %p", pipe_name, p)) == NULL) {
- DEBUG(0,("open_rpc_pipe_p: talloc_init failed.\n"));
- SAFE_FREE(p);
- return NULL;
- }
-
- if ((p->pipe_state_mem_ctx = talloc_init("pipe_state %s %p", pipe_name, p)) == NULL) {
+ p->mem_ctx = talloc_named(p, 0, "pipe %s %p",
+ get_pipe_name_from_syntax(talloc_tos(),
+ syntax), p);
+ if (p->mem_ctx == NULL) {
DEBUG(0,("open_rpc_pipe_p: talloc_init failed.\n"));
- talloc_destroy(p->mem_ctx);
- SAFE_FREE(p);
+ 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_destroy(p->pipe_state_mem_ctx);
- SAFE_FREE(p);
+ TALLOC_FREE(p);
return NULL;
}
* 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);
- talloc_destroy(p->pipe_state_mem_ctx);
close_policy_by_pipe(p);
- SAFE_FREE(p);
+ TALLOC_FREE(p);
return NULL;
}
- DLIST_ADD(InternalPipes, p);
+ p->server_info = copy_serverinfo(p, server_info);
+ if (p->server_info == NULL) {
+ DEBUG(0, ("open_rpc_pipe_p: copy_serverinfo failed\n"));
+ close_policy_by_pipe(p);
+ TALLOC_FREE(p);
+ return NULL;
+ }
- p->conn = conn;
+ DLIST_ADD(InternalPipes, p);
- p->vuid = vuid;
+ memcpy(p->client_address, client_address, sizeof(p->client_address));
p->endian = RPC_LITTLE_ENDIAN;
- ZERO_STRUCT(p->pipe_user);
-
- p->pipe_user.ut.uid = (uid_t)-1;
- p->pipe_user.ut.gid = (gid_t)-1;
-
- /* Store the session key and NT_TOKEN */
- if (vuser) {
- p->session_key = data_blob(
- vuser->server_info->user_session_key.data,
- vuser->server_info->user_session_key.length);
- p->pipe_user.nt_user_token = dup_nt_token(
- NULL, vuser->server_info->ptok);
- }
-
/*
* Initialize the outgoing RPC data buffer with no memory.
*/
prs_init_empty(&p->out_data.rdata, p->mem_ctx, MARSHALL);
-
- fstrcpy(p->name, pipe_name);
-
+
+ p->syntax = *syntax;
+
DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
- pipe_name, pipes_open));
+ get_pipe_name_from_syntax(talloc_tos(), syntax), pipes_open));
+
+ talloc_set_destructor(p, close_internal_rpc_pipe_hnd);
- return (void*)p;
+ return p;
}
/****************************************************************************
p->in_data.pdu_needed_len = 0;
p->in_data.pdu_received_len = 0;
p->fault_state = True;
- DEBUG(10,("set_incoming_fault: Setting fault state on pipe %s : vuid = 0x%x\n",
- p->name, p->vuid ));
+ DEBUG(10, ("set_incoming_fault: Setting fault state on pipe %s\n",
+ get_pipe_name_from_syntax(talloc_tos(), &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;
* AS/U doesn't set FIRST flag in a BIND packet it seems.
*/
- if ((p->hdr.pkt_type == RPC_REQUEST) && !(p->hdr.flags & RPC_FLG_FIRST)) {
+ if ((p->hdr.pkt_type == DCERPC_PKT_REQUEST) && !(p->hdr.flags & DCERPC_PFC_FLAG_FIRST)) {
/*
* Ensure that the FIRST flag is set. If not then we have
* a stream missmatch.
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_named(p, 0, "pipe %s %p",
+ get_pipe_name_from_syntax(talloc_tos(),
+ &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);
return False;
}
- if(p->hdr.flags & RPC_FLG_LAST) {
+ if(p->hdr.flags & DCERPC_PFC_FLAG_LAST) {
bool ret = False;
/*
* Ok - we finally have a complete RPC stream.
if(p->fault_state) {
DEBUG(10,("process_complete_pdu: pipe %s in fault state.\n",
- p->name ));
+ get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));
set_incoming_fault(p);
setup_fault_pdu(p, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR));
return;
(unsigned int)p->hdr.pkt_type ));
switch (p->hdr.pkt_type) {
- case RPC_REQUEST:
+ case DCERPC_PKT_REQUEST:
reply = process_request_pdu(p, &rpc_in);
break;
- case RPC_PING: /* CL request - ignore... */
+ case DCERPC_PKT_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_syntax(talloc_tos(),
+ &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 ));
+ 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 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:
+ 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)p->hdr.pkt_type, p->name));
+ (unsigned int)p->hdr.pkt_type,
+ get_pipe_name_from_syntax(talloc_tos(),
+ &p->syntax)));
break;
- case RPC_BIND:
+ case DCERPC_PKT_BIND:
/*
* We assume that a pipe bind is only in one pdu.
*/
}
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, p->name));
+ 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)p->hdr.pkt_type,
+ get_pipe_name_from_syntax(talloc_tos(),
+ &p->syntax)));
break;
- case RPC_ALTCONT:
+ case DCERPC_PKT_ALTER:
/*
* We assume that a pipe bind is only in one pdu.
*/
}
break;
- case RPC_ALTCONTRESP:
- DEBUG(0,("process_complete_pdu: Error. RPC_ALTCONTRESP on pipe %s: Should only be server -> client.\n",
- p->name));
+ 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_AUTH3:
+ case DCERPC_PKT_AUTH3:
/*
* The third packet in an NTLMSSP auth exchange.
*/
}
break;
- case RPC_SHUTDOWN:
- DEBUG(0,("process_complete_pdu: Error. RPC_SHUTDOWN on pipe %s: Should only be server -> client.\n",
- p->name));
+ 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 RPC_CO_CANCEL:
+ case DCERPC_PKT_CO_CANCEL:
/* For now just free all client data and continue processing. */
- DEBUG(3,("process_complete_pdu: RPC_ORPHANED. Abandoning rpc call.\n"));
+ 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. */
break;
#endif
- case RPC_ORPHANED:
+ 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: RPC_ORPHANED. Abandoning rpc call.\n"));
+ DEBUG(3,("process_complete_pdu: DCERPC_PKT_ORPHANED. Abandoning rpc call.\n"));
reply = True;
break;
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_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);
/*
* 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 rret;
}
/* 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
+ 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(). */
}
return (ssize_t)data_to_copy;
}
-/****************************************************************************
- Accepts incoming data on an rpc pipe.
-****************************************************************************/
-
-ssize_t write_to_pipe(smb_np_struct *p, char *data, size_t n)
-{
- DEBUG(6,("write_to_pipe: %x", p->pnum));
-
- DEBUG(6,(" name: %s open: %s len: %d\n",
- p->name, BOOLSTR(p->open), (int)n));
-
- dump_data(50, (uint8 *)data, n);
-
- return p->namedpipe_write(p->np_state, data, n);
-}
-
/****************************************************************************
Accepts incoming data on an internal rpc pipe.
****************************************************************************/
-static ssize_t write_to_internal_pipe(void *np_conn, char *data, size_t n)
+static ssize_t write_to_internal_pipe(struct pipes_struct *p, char *data, size_t n)
{
- pipes_struct *p = (pipes_struct*)np_conn;
size_t data_left = n;
while(data_left) {
have been prepared into arrays of headers + data stream sections.
****************************************************************************/
-ssize_t read_from_pipe(smb_np_struct *p, char *data, size_t n,
- bool *is_data_outstanding)
-{
- if (!p || !p->open) {
- DEBUG(0,("read_from_pipe: pipe not open\n"));
- return -1;
- }
-
- DEBUG(6,("read_from_pipe: %x", p->pnum));
-
- return p->namedpipe_read(p->np_state, data, n, is_data_outstanding);
-}
-
-/****************************************************************************
- 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(void *np_conn, 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)
{
- pipes_struct *p = (pipes_struct*)np_conn;
uint32 pdu_remaining = 0;
ssize_t data_returned = 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_syntax(talloc_tos(), &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_syntax(talloc_tos(), &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_syntax(talloc_tos(), &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_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) ));
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_syntax(talloc_tos(), &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) = p->out_data.current_pdu_len > n;
+ (*is_data_outstanding) = prs_offset(&p->out_data.frag) > n;
+
+ if (p->out_data.current_pdu_sent == prs_offset(&p->out_data.frag)) {
+ /* 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;
+ prs_mem_free(&p->out_data.frag);
+ }
return data_returned;
}
/****************************************************************************
- Wait device state on a pipe. Exactly what this is for is unknown...
+ Close an rpc pipe.
****************************************************************************/
-bool wait_rpc_pipe_hnd_state(smb_np_struct *p, uint16 priority)
+static int close_internal_rpc_pipe_hnd(struct pipes_struct *p)
{
- if (p == NULL) {
+ if (!p) {
+ DEBUG(0,("Invalid pipe in close_internal_rpc_pipe_hnd\n"));
return False;
}
- if (p->open) {
- DEBUG(3,("wait_rpc_pipe_hnd_state: Setting pipe wait state priority=%x on pipe (name=%s)\n",
- priority, p->name));
+ prs_mem_free(&p->out_data.frag);
+ prs_mem_free(&p->out_data.rdata);
+ prs_mem_free(&p->in_data.data);
- p->priority = priority;
-
- return True;
- }
+ if (p->auth.auth_data_free_func) {
+ (*p->auth.auth_data_free_func)(&p->auth);
+ }
- DEBUG(3,("wait_rpc_pipe_hnd_state: Error setting pipe wait state priority=%x (name=%s)\n",
- priority, p->name));
- return False;
+ free_pipe_rpc_context( p->contexts );
+
+ /* Free the handles database. */
+ close_policy_by_pipe(p);
+
+ DLIST_REMOVE(InternalPipes, p);
+
+ ZERO_STRUCTP(p);
+
+ return 0;
}
+bool fsp_is_np(struct files_struct *fsp)
+{
+ enum FAKE_FILE_TYPE type;
-/****************************************************************************
- Set device state on a pipe. Exactly what this is for is unknown...
-****************************************************************************/
+ if ((fsp == NULL) || (fsp->fake_file_handle == NULL)) {
+ return false;
+ }
-bool set_rpc_pipe_hnd_state(smb_np_struct *p, uint16 device_state)
+ type = fsp->fake_file_handle->type;
+
+ return ((type == FAKE_FILE_TYPE_NAMED_PIPE)
+ || (type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY));
+}
+
+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)
{
- if (p == NULL) {
- return False;
+ 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)
+{
+ struct np_proxy_state *result;
+ struct sockaddr_un addr;
+ char *socket_path;
+ const char *socket_dir;
+
+ DATA_BLOB req_blob;
+ 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;
+
+ result = talloc(mem_ctx, struct np_proxy_state);
+ if (result == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ return NULL;
+ }
+
+ result->fd = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (result->fd == -1) {
+ DEBUG(10, ("socket(2) failed: %s\n", strerror(errno)));
+ goto fail;
+ }
+ talloc_set_destructor(result, np_proxy_state_destructor);
+
+ ZERO_STRUCT(addr);
+ addr.sun_family = AF_UNIX;
+
+ 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_path = talloc_asprintf(talloc_tos(), "%s/np/%s",
+ socket_dir, pipe_name);
+ if (socket_path == 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);
+ if (info3 == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ goto fail;
}
- if (p->open) {
- DEBUG(3,("set_rpc_pipe_hnd_state: Setting pipe device state=%x on pipe (name=%s)\n",
- device_state, p->name));
+ 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;
+ }
+
+ req.level = 1;
+ req.info.info1 = *info3;
- p->device_state = device_state;
-
- return True;
- }
+ ndr_err = ndr_push_struct_blob(
+ &req_blob, talloc_tos(), NULL, &req,
+ (ndr_push_flags_fn_t)ndr_push_named_pipe_auth_req);
- DEBUG(3,("set_rpc_pipe_hnd_state: Error setting pipe device state=%x (name=%s)\n",
- device_state, p->name));
- return False;
+ 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)));
+ goto fail;
+ }
+
+ if (rep.level != 1) {
+ DEBUG(0, ("req invalid level: %u != 1\n",
+ rep.level));
+ 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:
+ TALLOC_FREE(result);
+ return NULL;
}
+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)
+{
+ const char **proxy_list;
+ struct fake_file_handle *handle;
-/****************************************************************************
- Close an rpc pipe.
-****************************************************************************/
+ proxy_list = lp_parm_string_list(-1, "np", "proxy", NULL);
+
+ 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(handle, name, server_info);
+
+ 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, &syntax)) {
+ TALLOC_FREE(handle);
+ return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+ }
-bool close_rpc_pipe_hnd(smb_np_struct *p)
+ p = make_internal_rpc_pipe_p(handle, &syntax, client_address,
+ server_info);
+
+ handle->type = FAKE_FILE_TYPE_NAMED_PIPE;
+ handle->private_data = p;
+ }
+
+ if (handle->private_data == NULL) {
+ TALLOC_FREE(handle);
+ return NT_STATUS_PIPE_NOT_AVAILABLE;
+ }
+
+ *phandle = handle;
+
+ return NT_STATUS_OK;
+}
+
+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 (!p) {
- DEBUG(0,("Invalid pipe in close_rpc_pipe_hnd\n"));
- return False;
+ struct tevent_req *req;
+ struct np_write_state *state;
+ NTSTATUS status;
+
+ DEBUG(6, ("np_write_send: len: %d\n", (int)len));
+ dump_data(50, data, len);
+
+ req = tevent_req_create(mem_ctx, &state, struct np_write_state);
+ if (req == NULL) {
+ return NULL;
}
- p->namedpipe_close(p->np_state);
+ if (len == 0) {
+ state->nwritten = 0;
+ status = NT_STATUS_OK;
+ goto post_status;
+ }
- bitmap_clear(bmap, p->pnum - pipe_handle_offset);
+ if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE) {
+ struct pipes_struct *p = talloc_get_type_abort(
+ handle->private_data, struct pipes_struct);
- pipes_open--;
+ state->nwritten = write_to_internal_pipe(p, (char *)data, len);
- DEBUG(4,("closed pipe name %s pnum=%x (pipes_open=%d)\n",
- p->name, p->pnum, pipes_open));
+ status = (state->nwritten >= 0)
+ ? NT_STATUS_OK : NT_STATUS_UNEXPECTED_IO_ERROR;
+ goto post_status;
+ }
- DLIST_REMOVE(Pipes, p);
-
- /* TODO: Remove from pipe open db */
-
- if ( !delete_pipe_opendb( p ) ) {
- DEBUG(3,("close_rpc_pipe_hnd: failed to delete %s "
- "pipe from open db.\n", p->name));
+ if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
+ struct np_proxy_state *p = talloc_get_type_abort(
+ handle->private_data, struct np_proxy_state);
+ struct tevent_req *subreq;
+
+ state->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;
}
- TALLOC_FREE(p);
+ status = NT_STATUS_INVALID_HANDLE;
+ post_status:
+ if (NT_STATUS_IS_OK(status)) {
+ tevent_req_done(req);
+ } else {
+ tevent_req_nterror(req, status);
+ }
+ return tevent_req_post(req, ev);
+ fail:
+ TALLOC_FREE(req);
+ return NULL;
+}
- return True;
+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);
}
-/****************************************************************************
- Close all pipes on a connection.
-****************************************************************************/
+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;
+}
-void pipe_close_conn(connection_struct *conn)
+static ssize_t rpc_frag_more_fn(uint8_t *buf, size_t buflen, void *priv)
{
- smb_np_struct *p, *next;
+ prs_struct hdr_prs;
+ struct rpc_hdr_info hdr;
+ bool ret;
- for (p=Pipes;p;p=next) {
- next = p->next;
- if (p->conn == conn) {
- close_rpc_pipe_hnd(p);
+ if (buflen > RPC_HEADER_LEN) {
+ return 0;
+ }
+ prs_init_empty(&hdr_prs, talloc_tos(), UNMARSHALL);
+ prs_give_memory(&hdr_prs, (char *)buf, RPC_HEADER_LEN, false);
+ ret = smb_io_rpc_hdr("", &hdr, &hdr_prs, 0);
+ prs_mem_free(&hdr_prs);
+
+ if (!ret) {
+ return -1;
+ }
+
+ return (hdr.frag_len - RPC_HEADER_LEN);
+}
+
+struct np_read_state {
+ 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(
+ 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);
+
+ 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;
}
+
+ 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;
}
+
+ status = NT_STATUS_INVALID_HANDLE;
+ post_status:
+ if (NT_STATUS_IS_OK(status)) {
+ tevent_req_done(req);
+ } else {
+ tevent_req_nterror(req, status);
+ }
+ return tevent_req_post(req, ev);
+ fail:
+ TALLOC_FREE(req);
+ return NULL;
}
-/****************************************************************************
- Close an rpc pipe.
-****************************************************************************/
+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;
-static bool close_internal_rpc_pipe_hnd(void *np_conn)
+ 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)
{
- pipes_struct *p = (pipes_struct *)np_conn;
- if (!p) {
- DEBUG(0,("Invalid pipe in close_internal_rpc_pipe_hnd\n"));
- return False;
+ 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;
}
- prs_mem_free(&p->out_data.rdata);
- prs_mem_free(&p->in_data.data);
+ thistime = MIN(received, state->len);
- if (p->auth.auth_data_free_func) {
- (*p->auth.auth_data_free_func)(&p->auth);
+ 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;
}
- if (p->mem_ctx) {
- talloc_destroy(p->mem_ctx);
+ 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;
- if (p->pipe_state_mem_ctx) {
- talloc_destroy(p->pipe_state_mem_ctx);
+ result = TALLOC_ZERO_P(mem_ctx, struct rpc_pipe_client);
+ if (result == NULL) {
+ return NT_STATUS_NO_MEMORY;
}
- free_pipe_rpc_context( p->contexts );
+ result->abstract_syntax = *abstract_syntax;
+ result->transfer_syntax = ndr_transfer_syntax;
+ result->dispatch = dispatch;
- /* Free the handles database. */
- close_policy_by_pipe(p);
+ 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;
+ }
- TALLOC_FREE(p->pipe_user.nt_user_token);
- data_blob_free(&p->session_key);
- SAFE_FREE(p->pipe_user.ut.groups);
+ result->max_xmit_frag = -1;
+ result->max_recv_frag = -1;
- DLIST_REMOVE(InternalPipes, p);
+ *presult = result;
+ return NT_STATUS_OK;
+}
- ZERO_STRUCTP(p);
+/*******************************************************************
+ gets a domain user's groups from their already-calculated NT_USER_TOKEN
+ ********************************************************************/
- SAFE_FREE(p);
-
- return True;
+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;
}
/****************************************************************************
- Find an rpc pipe given a pipe handle in a buffer and an offset.
-****************************************************************************/
+ 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;
+ }
-smb_np_struct *get_rpc_pipe_p(uint16 pnum)
+ 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 = talloc_strdup(mem_ctx, 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)
{
- if (chain_p) {
- return chain_p;
+ 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 get_rpc_pipe(pnum);
+ return NT_STATUS_OK;
}
/****************************************************************************
- Find an rpc pipe given a pipe handle.
-****************************************************************************/
+ 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;
+ }
-smb_np_struct *get_rpc_pipe(int pnum)
+ sam3->sidcount = 0;
+ sam3->sids = NULL;
+
+ return NT_STATUS_OK;
+}
+
+/****************************************************************************
+ inits a netr_SamInfo6 structure from an auth_serversupplied_info. sam6 must
+ already be initialized and is used as the talloc parent for its members.
+*****************************************************************************/
+
+NTSTATUS serverinfo_to_SamInfo6(struct auth_serversupplied_info *server_info,
+ uint8_t *pipe_session_key,
+ size_t pipe_session_key_len,
+ struct netr_SamInfo6 *sam6)
{
- smb_np_struct *p;
+ NTSTATUS status;
+ struct pdb_domain_info *dominfo;
- DEBUG(4,("search for pipe pnum=%x\n", pnum));
+ if ((pdb_capabilities() & PDB_CAP_ADS) == 0) {
+ DEBUG(10,("Not adding validation info level 6 "
+ "without ADS passdb backend\n"));
+ return NT_STATUS_INVALID_INFO_CLASS;
+ }
- for (p=Pipes;p;p=p->next) {
- DEBUG(5,("pipe name %s pnum=%x (pipes_open=%d)\n",
- p->name, p->pnum, pipes_open));
+ dominfo = pdb_get_domain_info(sam6);
+ if (dominfo == NULL) {
+ return NT_STATUS_NO_MEMORY;
}
- for (p=Pipes;p;p=p->next) {
- if (p->pnum == pnum) {
- chain_p = p;
- return p;
- }
+ status = serverinfo_to_SamInfo_base(sam6,
+ server_info,
+ pipe_session_key,
+ pipe_session_key_len,
+ &sam6->base);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
}
- return NULL;
+ sam6->sidcount = 0;
+ sam6->sids = NULL;
+
+ sam6->forest.string = talloc_strdup(sam6, dominfo->dns_forest);
+ if (sam6->forest.string == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ sam6->principle.string = talloc_asprintf(sam6, "%s@%s",
+ pdb_get_username(server_info->sam_account),
+ dominfo->dns_domain);
+ if (sam6->principle.string == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ return NT_STATUS_OK;
}