1998-03-12 00:11:04 +03:00
/*
2002-01-30 09:08:46 +03:00
* Unix SMB / CIFS implementation .
1998-03-12 00:11:04 +03:00
* RPC Pipe client / server routines
1998-10-20 22:27:49 +04:00
* Copyright ( C ) Andrew Tridgell 1992 - 1998 ,
2005-09-30 21:13:37 +04:00
* Largely re - written : 2005
* Copyright ( C ) Jeremy Allison 1998 - 2005
1998-03-12 00:11:04 +03:00
*
* 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
2007-07-09 23:25:36 +04:00
* the Free Software Foundation ; either version 3 of the License , or
1998-03-12 00:11:04 +03:00
* ( 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
2007-07-10 09:23:25 +04:00
* along with this program ; if not , see < http : //www.gnu.org/licenses/>.
1998-03-12 00:11:04 +03:00
*/
# include "includes.h"
2008-10-26 20:56:29 +03:00
# include "librpc/gen_ndr/ndr_named_pipe_auth.h"
1998-03-12 00:11:04 +03:00
2002-07-15 14:35:28 +04:00
# undef DBGC_CLASS
# define DBGC_CLASS DBGC_RPC_SRV
1998-08-17 07:06:20 +04:00
static int pipes_open ;
1998-03-12 00:11:04 +03:00
2002-01-20 05:40:05 +03:00
static pipes_struct * InternalPipes ;
1998-03-12 00:11:04 +03:00
2002-01-20 05:40:05 +03:00
/* 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 . . .
*/
2008-07-31 02:01:33 +04:00
static int close_internal_rpc_pipe_hnd ( struct pipes_struct * p ) ;
2002-01-20 05:40:05 +03:00
/****************************************************************************
Internal Pipe iterator functions .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
pipes_struct * get_first_internal_pipe ( void )
{
return InternalPipes ;
}
pipes_struct * get_next_internal_pipe ( pipes_struct * p )
2001-03-11 03:32:10 +03:00
{
return p - > next ;
}
1999-12-13 16:27:58 +03:00
/****************************************************************************
Initialise an outgoing packet .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-19 04:40:25 +04:00
static bool pipe_init_outgoing_data ( pipes_struct * p )
1999-12-13 16:27:58 +03:00
{
2000-07-27 04:47:19 +04:00
output_data * o_data = & p - > out_data ;
2000-03-10 22:50:03 +03:00
/* Reset the offset counters. */
o_data - > data_sent_length = 0 ;
o_data - > current_pdu_sent = 0 ;
1999-12-13 16:27:58 +03:00
2009-02-08 01:36:50 +03:00
prs_mem_free ( & o_data - > frag ) ;
1999-12-13 16:27:58 +03:00
/* Free any memory in the current return data buffer. */
2000-03-10 00:45:16 +03:00
prs_mem_free ( & o_data - > rdata ) ;
1999-12-13 16:27:58 +03:00
/*
* Initialize the outgoing RPC data buffer .
* we will use this as the raw data area for replying to rpc requests .
*/
2009-02-08 01:36:23 +03:00
if ( ! prs_init ( & o_data - > rdata , 128 , p - > mem_ctx , MARSHALL ) ) {
1999-12-13 16:27:58 +03:00
DEBUG ( 0 , ( " pipe_init_outgoing_data: malloc fail. \n " ) ) ;
return False ;
}
return True ;
}
1998-08-17 07:06:20 +04:00
2002-01-20 05:40:05 +03:00
/****************************************************************************
2002-07-15 14:35:28 +04:00
Make an internal namedpipes structure
2002-01-20 05:40:05 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2008-10-13 21:40:43 +04:00
static struct pipes_struct * make_internal_rpc_pipe_p ( TALLOC_CTX * mem_ctx ,
2009-02-01 14:03:31 +03:00
const struct ndr_syntax_id * syntax ,
2008-10-13 21:40:43 +04:00
const char * client_address ,
2009-01-03 17:23:13 +03:00
struct auth_serversupplied_info * server_info )
2002-01-20 05:40:05 +03:00
{
pipes_struct * p ;
2009-02-01 14:03:31 +03:00
DEBUG ( 4 , ( " Create pipe requested %s \n " ,
get_pipe_name_from_iface ( syntax ) ) ) ;
2002-01-20 05:40:05 +03:00
2008-10-13 01:01:38 +04:00
p = TALLOC_ZERO_P ( mem_ctx , struct pipes_struct ) ;
2002-01-20 05:40:05 +03:00
2004-12-07 21:25:53 +03:00
if ( ! p ) {
2002-01-20 05:40:05 +03:00
DEBUG ( 0 , ( " ERROR! no memory for pipes_struct! \n " ) ) ;
return NULL ;
}
2009-02-01 14:03:31 +03:00
if ( ( p - > mem_ctx = talloc_init ( " pipe %s %p " ,
get_pipe_name_from_iface ( syntax ) ,
p ) ) = = NULL ) {
2002-01-20 05:40:05 +03:00
DEBUG ( 0 , ( " open_rpc_pipe_p: talloc_init failed. \n " ) ) ;
2008-06-20 18:22:49 +04:00
TALLOC_FREE ( p ) ;
2005-09-30 21:13:37 +04:00
return NULL ;
}
2009-02-01 14:03:31 +03:00
if ( ! init_pipe_handle_list ( p , syntax ) ) {
2002-01-20 05:40:05 +03:00
DEBUG ( 0 , ( " open_rpc_pipe_p: init_pipe_handles failed. \n " ) ) ;
talloc_destroy ( p - > mem_ctx ) ;
2008-06-20 18:22:49 +04:00
TALLOC_FREE ( p ) ;
2002-01-20 05:40:05 +03:00
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 .
*/
2009-02-08 01:36:23 +03:00
if ( ! prs_init ( & p - > in_data . data , 128 , p - > mem_ctx , MARSHALL ) ) {
2002-01-20 05:40:05 +03:00
DEBUG ( 0 , ( " open_rpc_pipe_p: malloc fail for in_data struct. \n " ) ) ;
2005-09-30 21:13:37 +04:00
talloc_destroy ( p - > mem_ctx ) ;
2006-03-08 10:30:37 +03:00
close_policy_by_pipe ( p ) ;
2008-06-20 18:22:49 +04:00
TALLOC_FREE ( p ) ;
2002-01-20 05:40:05 +03:00
return NULL ;
}
2008-07-12 14:20:08 +04:00
p - > server_info = copy_serverinfo ( p , server_info ) ;
2008-06-24 16:18:55 +04:00
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 ;
}
2002-01-20 05:40:05 +03:00
DLIST_ADD ( InternalPipes , p ) ;
2008-07-12 14:20:08 +04:00
memcpy ( p - > client_address , client_address , sizeof ( p - > client_address ) ) ;
2002-07-15 14:35:28 +04:00
2001-03-10 02:48:58 +03:00
p - > endian = RPC_LITTLE_ENDIAN ;
2000-03-10 00:45:16 +03:00
/*
* Initialize the outgoing RPC data buffer with no memory .
*/
2008-03-15 01:26:28 +03:00
prs_init_empty ( & p - > out_data . rdata , p - > mem_ctx , MARSHALL ) ;
2009-02-01 14:03:31 +03:00
p - > syntax = * syntax ;
2002-01-20 05:40:05 +03:00
DEBUG ( 4 , ( " Created internal pipe %s (pipes_open=%d) \n " ,
2009-02-01 14:03:31 +03:00
get_pipe_name_from_iface ( syntax ) , pipes_open ) ) ;
1998-09-24 01:49:09 +04:00
2008-07-12 14:25:42 +04:00
talloc_set_destructor ( p , close_internal_rpc_pipe_hnd ) ;
2008-07-12 14:20:08 +04:00
return p ;
1998-03-12 00:11:04 +03:00
}
2000-03-10 00:45:16 +03:00
/****************************************************************************
Sets the fault state on incoming packets .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void set_incoming_fault ( pipes_struct * p )
{
prs_mem_free ( & p - > in_data . data ) ;
p - > in_data . pdu_needed_len = 0 ;
p - > in_data . pdu_received_len = 0 ;
p - > fault_state = True ;
2008-06-24 17:24:08 +04:00
DEBUG ( 10 , ( " set_incoming_fault: Setting fault state on pipe %s \n " ,
2009-02-01 14:03:31 +03:00
get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2000-03-10 00:45:16 +03:00
}
1998-08-17 07:06:20 +04:00
1998-10-07 19:22:49 +04:00
/****************************************************************************
2000-03-10 00:45:16 +03:00
Ensures we have at least RPC_HEADER_LEN amount of data in the incoming buffer .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-10-08 01:42:24 +04:00
2000-03-10 00:45:16 +03:00
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 ) ;
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 ) ) ;
2009-02-07 18:24:08 +03:00
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 ;
}
2000-03-10 00:45:16 +03:00
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 ;
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 )
{
/*
* 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 " ) ) ;
set_incoming_fault ( p ) ;
return - 1 ;
}
2008-03-15 01:26:28 +03:00
prs_init_empty ( & rpc_in , p - > mem_ctx , UNMARSHALL ) ;
2001-03-10 02:48:58 +03:00
prs_set_endian_data ( & rpc_in , p - > endian ) ;
2000-03-10 00:45:16 +03:00
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 .
2001-03-10 02:48:58 +03:00
* This also sets the endian flag in rpc_in .
2000-03-10 00:45:16 +03:00
*/
if ( ! smb_io_rpc_hdr ( " " , & p - > hdr , & rpc_in , 0 ) ) {
DEBUG ( 0 , ( " unmarshall_rpc_header: failed to unmarshall RPC_HDR. \n " ) ) ;
set_incoming_fault ( p ) ;
2000-07-27 04:47:19 +04:00
prs_mem_free ( & rpc_in ) ;
2000-03-10 00:45:16 +03:00
return - 1 ;
}
/*
* Validate the RPC header .
*/
if ( p - > hdr . major ! = 5 & & p - > hdr . minor ! = 0 ) {
DEBUG ( 0 , ( " unmarshall_rpc_header: invalid major/minor numbers in RPC_HDR. \n " ) ) ;
set_incoming_fault ( p ) ;
2000-07-27 04:47:19 +04:00
prs_mem_free ( & rpc_in ) ;
2000-03-10 00:45:16 +03:00
return - 1 ;
}
/*
2001-03-11 07:33:05 +03:00
* If there ' s not data in the incoming buffer this should be the start of a new RPC .
2000-03-10 00:45:16 +03:00
*/
2001-03-11 07:33:05 +03:00
if ( prs_offset ( & p - > in_data . data ) = = 0 ) {
2001-03-10 02:48:58 +03:00
2001-03-12 19:43:01 +03:00
/*
* 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 ) ) {
2001-03-10 02:48:58 +03:00
/*
* Ensure that the FIRST flag is set . If not then we have
* a stream missmatch .
*/
DEBUG ( 0 , ( " unmarshall_rpc_header: FIRST flag not set in first PDU ! \n " ) ) ;
set_incoming_fault ( p ) ;
prs_mem_free ( & rpc_in ) ;
return - 1 ;
}
/*
* 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 .
*/
p - > endian = rpc_in . bigendian_data ;
2001-03-11 07:33:05 +03:00
DEBUG ( 5 , ( " unmarshall_rpc_header: using %sendian RPC \n " ,
p - > endian = = RPC_LITTLE_ENDIAN ? " little- " : " big- " ) ) ;
2001-03-10 02:48:58 +03:00
} else {
/*
* If this is * NOT * the first PDU then check the endianness
* flag in the pipe is the same as that in the PDU .
*/
if ( p - > endian ! = rpc_in . bigendian_data ) {
2001-03-11 07:33:05 +03:00
DEBUG ( 0 , ( " unmarshall_rpc_header: FIRST endianness flag (%d) different in next PDU ! \n " , ( int ) p - > endian ) ) ;
2001-03-10 02:48:58 +03:00
set_incoming_fault ( p ) ;
prs_mem_free ( & rpc_in ) ;
return - 1 ;
}
2000-03-10 00:45:16 +03:00
}
/*
* Ensure that the pdu length is sane .
*/
2005-09-30 21:13:37 +04:00
if ( ( p - > hdr . frag_len < RPC_HEADER_LEN ) | | ( p - > hdr . frag_len > RPC_MAX_PDU_FRAG_LEN ) ) {
2000-03-10 00:45:16 +03:00
DEBUG ( 0 , ( " unmarshall_rpc_header: assert on frag length failed. \n " ) ) ;
set_incoming_fault ( p ) ;
2000-07-27 04:47:19 +04:00
prs_mem_free ( & rpc_in ) ;
2000-03-10 00:45:16 +03:00
return - 1 ;
}
DEBUG ( 10 , ( " unmarshall_rpc_header: type = %u, flags = %u \n " , ( unsigned int ) p - > hdr . pkt_type ,
( unsigned int ) p - > hdr . flags ) ) ;
p - > in_data . pdu_needed_len = ( uint32 ) p - > hdr . frag_len - RPC_HEADER_LEN ;
2000-07-27 04:47:19 +04:00
prs_mem_free ( & rpc_in ) ;
2009-02-07 18:24:08 +03:00
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 ;
}
2000-03-10 00:45:16 +03:00
return 0 ; /* No extra data processed. */
}
2001-03-11 03:32:10 +03:00
/****************************************************************************
Call this to free any talloc ' ed memory . Do this before and after processing
a complete PDU .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-05-03 11:33:49 +04:00
static void free_pipe_context ( pipes_struct * p )
2001-03-11 03:32:10 +03:00
{
if ( p - > mem_ctx ) {
2005-05-03 11:33:49 +04:00
DEBUG ( 3 , ( " free_pipe_context: destroying talloc pool of size "
2005-09-30 21:13:37 +04:00
" %lu \n " , ( unsigned long ) talloc_total_size ( p - > mem_ctx ) ) ) ;
2005-05-03 11:33:49 +04:00
talloc_free_children ( p - > mem_ctx ) ;
2001-03-11 03:32:10 +03:00
} else {
2009-02-01 14:03:31 +03:00
p - > mem_ctx = talloc_init (
" pipe %s %p " , get_pipe_name_from_iface ( & p - > syntax ) , p ) ;
2005-09-30 21:13:37 +04:00
if ( p - > mem_ctx = = NULL ) {
2001-03-11 03:32:10 +03:00
p - > fault_state = True ;
2005-09-30 21:13:37 +04:00
}
2001-03-11 03:32:10 +03:00
}
}
2000-03-10 00:45:16 +03:00
/****************************************************************************
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 .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-19 04:40:25 +04:00
static bool process_request_pdu ( pipes_struct * p , prs_struct * rpc_in_p )
2000-03-10 00:45:16 +03:00
{
2005-09-30 21:13:37 +04:00
uint32 ss_padding_len = 0 ;
2000-03-10 00:45:16 +03:00
size_t data_len = p - > hdr . frag_len - RPC_HEADER_LEN - RPC_HDR_REQ_LEN -
2005-09-30 21:13:37 +04:00
( p - > hdr . auth_len ? RPC_HDR_AUTH_LEN : 0 ) - p - > hdr . auth_len ;
2000-03-10 00:45:16 +03:00
if ( ! p - > pipe_bound ) {
DEBUG ( 0 , ( " process_request_pdu: rpc request with no bind. \n " ) ) ;
set_incoming_fault ( p ) ;
return False ;
}
/*
* Check if we need to do authentication processing .
* This is only done on requests , not binds .
*/
/*
* Read the RPC request header .
*/
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 ;
}
2005-09-30 21:13:37 +04:00
switch ( p - > auth . auth_type ) {
case PIPE_AUTH_TYPE_NONE :
break ;
2000-03-10 00:45:16 +03:00
2005-09-30 21:13:37 +04:00
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 ;
}
break ;
}
2000-03-10 00:45:16 +03:00
2005-09-30 21:13:37 +04:00
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 ;
}
break ;
2000-03-10 00:45:16 +03:00
2005-09-30 21:13:37 +04:00
default :
DEBUG ( 0 , ( " process_request_pdu: unknown auth type %u set. \n " , ( unsigned int ) p - > auth . auth_type ) ) ;
set_incoming_fault ( p ) ;
return False ;
2003-04-06 11:04:09 +04:00
}
2005-09-30 21:13:37 +04:00
/* Now we've done the sign/seal we can remove any padding data. */
if ( data_len > ss_padding_len ) {
data_len - = ss_padding_len ;
2003-04-06 11:04:09 +04:00
}
2000-03-10 00:45:16 +03:00
/*
2002-01-22 21:19:00 +03:00
* Check the data length doesn ' t go over the 15 Mb limit .
* increased after observing a bug in the Windows NT 4.0 SP6a
* spoolsv . exe when the response to a GETPRINTERDRIVER2 RPC
* will not fit in the initial buffer of size 0x1068 - - jerry 22 / 01 / 2002
2000-03-10 00:45:16 +03:00
*/
2002-02-09 00:51:40 +03:00
if ( prs_offset ( & p - > in_data . data ) + data_len > 15 * 1024 * 1024 ) {
2000-03-10 00:45:16 +03:00
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 ;
}
/*
* Append the data portion into the buffer and return .
*/
2003-02-15 01:55:46 +03:00
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 ;
2000-03-10 00:45:16 +03:00
}
if ( p - > hdr . flags & RPC_FLG_LAST ) {
2007-10-19 04:40:25 +04:00
bool ret = False ;
2000-03-10 00:45:16 +03:00
/*
* Ok - we finally have a complete RPC stream .
* Call the rpc command to process it .
*/
2000-05-17 23:17:16 +04:00
/*
* Ensure the internal prs buffer size is * exactly * the same
* size as the current offset .
*/
2005-09-30 21:13:37 +04:00
if ( ! prs_set_buffer_size ( & p - > in_data . data , prs_offset ( & p - > in_data . data ) ) ) {
2000-05-27 02:37:08 +04:00
DEBUG ( 0 , ( " process_request_pdu: Call to prs_set_buffer_size failed! \n " ) ) ;
set_incoming_fault ( p ) ;
return False ;
}
2000-05-17 23:17:16 +04:00
2000-03-10 00:45:16 +03:00
/*
* 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 .
*/
2001-03-11 03:32:10 +03:00
free_pipe_context ( p ) ;
2005-09-30 21:13:37 +04:00
if ( pipe_init_outgoing_data ( p ) ) {
2000-03-10 22:50:03 +03:00
ret = api_pipe_request ( p ) ;
2005-09-30 21:13:37 +04:00
}
2000-03-10 00:45:16 +03:00
2001-03-11 03:32:10 +03:00
free_pipe_context ( p ) ;
2000-03-10 00:45:16 +03:00
/*
* 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 ;
}
return True ;
}
/****************************************************************************
Processes a finished PDU stored in current_in_pdu . The RPC_HEADER has
already been parsed and stored in p - > hdr .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-09-30 21:13:37 +04:00
static void process_complete_pdu ( pipes_struct * p )
2000-03-10 00:45:16 +03:00
{
prs_struct rpc_in ;
2005-09-30 21:13:37 +04:00
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 ] ;
2007-10-19 04:40:25 +04:00
bool reply = False ;
2000-03-10 00:45:16 +03:00
if ( p - > fault_state ) {
DEBUG ( 10 , ( " process_complete_pdu: pipe %s in fault state. \n " ,
2009-02-01 14:03:31 +03:00
get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2000-03-10 00:45:16 +03:00
set_incoming_fault ( p ) ;
2006-03-21 03:04:05 +03:00
setup_fault_pdu ( p , NT_STATUS ( DCERPC_FAULT_OP_RNG_ERROR ) ) ;
2005-09-30 21:13:37 +04:00
return ;
2000-03-10 00:45:16 +03:00
}
2008-03-15 01:26:28 +03:00
prs_init_empty ( & rpc_in , p - > mem_ctx , UNMARSHALL ) ;
2001-03-12 23:19:31 +03:00
/*
* Ensure we ' re using the corrent endianness for both the
* RPC header flags and the raw data we will be reading from .
*/
2001-03-10 02:48:58 +03:00
prs_set_endian_data ( & rpc_in , p - > endian ) ;
2001-03-12 23:19:31 +03:00
prs_set_endian_data ( & p - > in_data . data , p - > endian ) ;
2001-03-10 02:48:58 +03:00
2000-03-10 00:45:16 +03:00
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 ) {
2005-11-29 05:10:52 +03:00
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 " ,
2009-02-01 14:03:31 +03:00
( unsigned int ) p - > hdr . pkt_type ,
get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2005-11-29 05:10:52 +03:00
break ;
case RPC_RESPONSE : /* No responses here. */
DEBUG ( 0 , ( " process_complete_pdu: Error. RPC_RESPONSE received from client on pipe %s. \n " ,
2009-02-01 14:03:31 +03:00
get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2005-11-29 05:10:52 +03:00
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 " ,
2009-02-01 14:03:31 +03:00
( unsigned int ) p - > hdr . pkt_type ,
get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2005-11-29 05:10:52 +03:00
break ;
2000-03-10 00:45:16 +03:00
case RPC_BIND :
/*
* We assume that a pipe bind is only in one pdu .
*/
2005-09-30 21:13:37 +04:00
if ( pipe_init_outgoing_data ( p ) ) {
2000-03-10 22:50:03 +03:00
reply = api_pipe_bind_req ( p , & rpc_in ) ;
2005-09-30 21:13:37 +04:00
}
break ;
2005-11-29 05:10:52 +03:00
case RPC_BINDACK :
case RPC_BINDNACK :
DEBUG ( 0 , ( " process_complete_pdu: Error. RPC_BINDACK/RPC_BINDNACK packet type %u received on pipe %s. \n " ,
2009-02-01 14:03:31 +03:00
( unsigned int ) p - > hdr . pkt_type ,
get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2005-11-29 05:10:52 +03:00
break ;
2005-09-30 21:13:37 +04:00
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 ) ;
}
2000-03-10 00:45:16 +03:00
break ;
2005-11-29 05:10:52 +03:00
case RPC_ALTCONTRESP :
DEBUG ( 0 , ( " process_complete_pdu: Error. RPC_ALTCONTRESP on pipe %s: Should only be server -> client. \n " ,
2009-02-01 14:03:31 +03:00
get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2005-11-29 05:10:52 +03:00
break ;
2005-09-30 21:13:37 +04:00
case RPC_AUTH3 :
2000-03-10 00:45:16 +03:00
/*
2005-09-30 21:13:37 +04:00
* The third packet in an NTLMSSP auth exchange .
2000-03-10 00:45:16 +03:00
*/
2005-09-30 21:13:37 +04:00
if ( pipe_init_outgoing_data ( p ) ) {
reply = api_pipe_bind_auth3 ( p , & rpc_in ) ;
}
2000-03-10 00:45:16 +03:00
break ;
2005-11-29 05:10:52 +03:00
case RPC_SHUTDOWN :
DEBUG ( 0 , ( " process_complete_pdu: Error. RPC_SHUTDOWN on pipe %s: Should only be server -> client. \n " ,
2009-02-01 14:03:31 +03:00
get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2005-11-29 05:10:52 +03:00
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 ;
2000-03-10 00:45:16 +03:00
break ;
2005-11-29 05:10:52 +03:00
#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 ;
# 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 ;
2000-03-10 00:45:16 +03:00
default :
DEBUG ( 0 , ( " process_complete_pdu: Unknown rpc type = %u received. \n " , ( unsigned int ) p - > hdr . pkt_type ) ) ;
break ;
}
2001-03-12 23:19:31 +03:00
/* 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 ) ;
2000-03-10 00:45:16 +03:00
if ( ! reply ) {
2009-02-01 14:03:31 +03:00
DEBUG ( 3 , ( " process_complete_pdu: DCE/RPC fault sent on "
" pipe %s \n " , get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2000-03-10 00:45:16 +03:00
set_incoming_fault ( p ) ;
2006-03-21 03:04:05 +03:00
setup_fault_pdu ( p , NT_STATUS ( DCERPC_FAULT_OP_RNG_ERROR ) ) ;
2000-07-27 04:47:19 +04:00
prs_mem_free ( & rpc_in ) ;
2000-03-10 00:45:16 +03:00
} else {
/*
* Reset the lengths . We ' re ready for a new pdu .
*/
2009-02-07 18:24:08 +03:00
TALLOC_FREE ( p - > in_data . current_in_pdu ) ;
2000-03-10 00:45:16 +03:00
p - > in_data . pdu_needed_len = 0 ;
p - > in_data . pdu_received_len = 0 ;
}
2000-07-27 04:47:19 +04:00
prs_mem_free ( & rpc_in ) ;
2000-03-10 00:45:16 +03:00
}
/****************************************************************************
Accepts incoming data on an rpc pipe . Processes the data in pdu sized units .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static ssize_t process_incoming_data ( pipes_struct * p , char * data , size_t n )
{
2005-09-30 21:13:37 +04:00
size_t data_to_copy = MIN ( n , RPC_MAX_PDU_FRAG_LEN - p - > in_data . pdu_received_len ) ;
2000-03-10 00:45:16 +03:00
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 ) ) ;
if ( data_to_copy = = 0 ) {
/*
* This is an error - data is being received and there is no
* space in the PDU . Free the received data and go into the fault state .
*/
DEBUG ( 0 , ( " process_incoming_data: No space in incoming pdu buffer. Current size = %u \
incoming data size = % u \ n " , (unsigned int)p->in_data.pdu_received_len, (unsigned int)n ));
set_incoming_fault ( p ) ;
return - 1 ;
}
/*
* If we have no data already , wait until we get at least a RPC_HEADER_LEN
* number of bytes before we can do anything .
*/
if ( ( p - > in_data . pdu_needed_len = = 0 ) & & ( p - > in_data . pdu_received_len < RPC_HEADER_LEN ) ) {
/*
* Always return here . If we have more data then the RPC_HEADER
* will be processed the next time around the loop .
*/
return fill_rpc_header ( p , data , data_to_copy ) ;
}
/*
* At this point we know we have at least an RPC_HEADER_LEN amount of data
* stored in current_in_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 .
*/
2005-09-30 21:13:37 +04:00
if ( p - > in_data . pdu_needed_len = = 0 ) {
2005-11-29 05:10:52 +03:00
ssize_t rret = unmarshall_rpc_header ( p ) ;
if ( rret = = - 1 | | p - > in_data . pdu_needed_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
pdu type . Deal with this in process_complete_pdu ( ) . */
2005-09-30 21:13:37 +04:00
}
2000-03-10 00:45:16 +03:00
/*
* Ok - at this point we have a valid RPC_HEADER in p - > hdr .
* 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 .
2005-09-30 21:13:37 +04:00
* pdu_needed_len becomes zero when we have a complete pdu .
2000-03-10 00:45:16 +03:00
*/
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 ;
2005-09-30 21:13:37 +04:00
p - > in_data . pdu_needed_len - = data_to_copy ;
2000-03-10 00:45:16 +03:00
/*
* Do we have a complete PDU ?
2005-09-30 21:13:37 +04:00
* ( return the number of bytes handled in the call )
2000-03-10 00:45:16 +03:00
*/
2005-09-30 21:13:37 +04:00
if ( p - > in_data . pdu_needed_len = = 0 ) {
process_complete_pdu ( p ) ;
return data_to_copy ;
}
2000-03-10 00:45:16 +03:00
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 ) ) ;
return ( ssize_t ) data_to_copy ;
}
2002-01-20 05:40:05 +03:00
/****************************************************************************
Accepts incoming data on an internal rpc pipe .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2008-10-13 21:40:43 +04:00
static ssize_t write_to_internal_pipe ( struct pipes_struct * p , char * data , size_t n )
2002-01-20 05:40:05 +03:00
{
size_t data_left = n ;
2000-03-10 00:45:16 +03:00
while ( data_left ) {
ssize_t data_used ;
DEBUG ( 10 , ( " write_to_pipe: data_left = %u \n " , ( unsigned int ) data_left ) ) ;
2000-07-27 04:47:19 +04:00
data_used = process_incoming_data ( p , data , data_left ) ;
2000-03-10 00:45:16 +03:00
DEBUG ( 10 , ( " write_to_pipe: data_used = %d \n " , ( int ) data_used ) ) ;
2005-09-30 21:13:37 +04:00
if ( data_used < 0 ) {
2000-03-10 00:45:16 +03:00
return - 1 ;
2005-09-30 21:13:37 +04:00
}
2000-03-10 00:45:16 +03:00
data_left - = data_used ;
data + = data_used ;
}
return n ;
1998-10-07 19:22:49 +04:00
}
1998-03-12 00:11:04 +03:00
/****************************************************************************
2000-03-10 22:50:03 +03:00
Replies to a request to read data from a pipe .
1998-03-12 00:11:04 +03:00
1999-12-13 16:27:58 +03:00
Headers are interspersed with the data at PDU intervals . By the time
1998-03-12 00:11:04 +03:00
this function is called , the start of the data could possibly have been
1998-04-21 06:36:37 +04:00
read by an SMBtrans ( file_offset ! = 0 ) .
1998-03-12 00:11:04 +03:00
1999-12-13 16:27:58 +03:00
Calling create_rpc_reply ( ) here is a hack . The data should already
1998-03-12 00:11:04 +03:00
have been prepared into arrays of headers + data stream sections .
2000-03-10 22:50:03 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-03-12 00:11:04 +03:00
2008-10-13 21:40:43 +04:00
static ssize_t read_from_internal_pipe ( struct pipes_struct * p , char * data , size_t n ,
bool * is_data_outstanding )
2002-01-20 05:40:05 +03:00
{
uint32 pdu_remaining = 0 ;
ssize_t data_returned = 0 ;
if ( ! p ) {
DEBUG ( 0 , ( " read_from_pipe: pipe not open \n " ) ) ;
return - 1 ;
}
2009-02-01 14:03:31 +03:00
DEBUG ( 6 , ( " name: %s len: %u \n " , get_pipe_name_from_iface ( & p - > syntax ) ,
( unsigned int ) n ) ) ;
1999-12-13 16:27:58 +03:00
/*
* We cannot return more than one PDU length per
* read request .
*/
2001-08-27 00:05:33 +04:00
/*
* 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 .
*/
2001-08-23 22:05:44 +04:00
2005-09-30 21:13:37 +04:00
if ( n > RPC_MAX_PDU_FRAG_LEN ) {
2009-02-01 14:03:31 +03:00
DEBUG ( 5 , ( " read_from_pipe: too large read (%u) requested on "
" pipe %s. We can only service %d sized reads. \n " ,
( unsigned int ) n , get_pipe_name_from_iface ( & p - > syntax ) ,
RPC_MAX_PDU_FRAG_LEN ) ) ;
2007-09-08 09:35:10 +04:00
n = RPC_MAX_PDU_FRAG_LEN ;
1998-08-17 07:06:20 +04:00
}
1998-04-10 22:21:16 +04:00
1999-12-13 16:27:58 +03:00
/*
* Determine if there is still data to send in the
* pipe PDU buffer . Always send this first . Never
* send more than is left in the current PDU . The
* client should send a new read request for a new
* PDU .
*/
1998-04-21 06:36:37 +04:00
2009-02-08 01:36:50 +03:00
pdu_remaining = prs_offset ( & p - > out_data . frag )
- p - > out_data . current_pdu_sent ;
if ( pdu_remaining > 0 ) {
2000-03-10 22:50:03 +03:00
data_returned = ( ssize_t ) MIN ( n , pdu_remaining ) ;
1998-03-12 00:11:04 +03:00
2009-02-01 14:03:31 +03:00
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 ) ,
2009-02-08 01:36:50 +03:00
( unsigned int ) prs_offset ( & p - > out_data . frag ) ,
2009-02-01 14:03:31 +03:00
( unsigned int ) p - > out_data . current_pdu_sent ,
( int ) data_returned ) ) ;
1999-02-03 03:48:27 +03:00
2009-02-08 01:36:50 +03:00
memcpy ( data ,
prs_data_p ( & p - > out_data . frag )
+ p - > out_data . current_pdu_sent ,
data_returned ) ;
2000-02-23 05:02:33 +03:00
p - > out_data . current_pdu_sent + = ( uint32 ) data_returned ;
2001-02-27 22:22:02 +03:00
goto out ;
1998-03-12 00:11:04 +03:00
}
1999-12-13 16:27:58 +03:00
/*
* At this point p - > current_pdu_len = = p - > current_pdu_sent ( which
* may of course be zero if this is the first return fragment .
*/
2009-02-01 14:03:31 +03:00
DEBUG ( 10 , ( " read_from_pipe: %s: fault_state = %d : data_sent_length "
" = %u, prs_offset(&p->out_data.rdata) = %u. \n " ,
get_pipe_name_from_iface ( & p - > syntax ) , ( int ) p - > fault_state ,
( unsigned int ) p - > out_data . data_sent_length ,
( unsigned int ) prs_offset ( & p - > out_data . rdata ) ) ) ;
1999-12-13 16:27:58 +03:00
2000-02-23 05:02:33 +03:00
if ( p - > out_data . data_sent_length > = prs_offset ( & p - > out_data . rdata ) ) {
1999-12-13 16:27:58 +03:00
/*
2001-02-27 22:22:02 +03:00
* We have sent all possible data , return 0.
1999-12-13 16:27:58 +03:00
*/
2001-02-27 22:22:02 +03:00
data_returned = 0 ;
goto out ;
1998-10-09 03:57:46 +04:00
}
1999-02-03 04:58:52 +03:00
2000-07-27 04:47:19 +04:00
/*
* We need to create a new PDU from the data left in p - > rdata .
* Create the header / data / footers . This also sets up the fields
* p - > current_pdu_len , p - > current_pdu_sent , p - > data_sent_length
* and stores the outgoing PDU in p - > current_pdu .
*/
2000-03-10 22:50:03 +03:00
2000-07-27 04:47:19 +04:00
if ( ! create_next_pdu ( p ) ) {
2009-02-01 14:03:31 +03:00
DEBUG ( 0 , ( " read_from_pipe: %s: create_next_pdu failed. \n " ,
get_pipe_name_from_iface ( & p - > syntax ) ) ) ;
2000-07-27 04:47:19 +04:00
return - 1 ;
1998-03-12 00:11:04 +03:00
}
1998-08-17 07:06:20 +04:00
2009-02-08 01:36:50 +03:00
data_returned = MIN ( n , prs_offset ( & p - > out_data . frag ) ) ;
1998-03-12 00:11:04 +03:00
2009-02-08 01:36:50 +03:00
memcpy ( data , prs_data_p ( & p - > out_data . frag ) , ( size_t ) data_returned ) ;
2000-02-23 05:02:33 +03:00
p - > out_data . current_pdu_sent + = ( uint32 ) data_returned ;
2001-02-27 22:22:02 +03:00
out :
2009-02-08 01:36:50 +03:00
( * is_data_outstanding ) = prs_offset ( & p - > out_data . frag ) > n ;
2001-02-27 22:22:02 +03:00
1999-12-13 16:27:58 +03:00
return data_returned ;
}
1998-08-17 07:06:20 +04:00
2002-01-20 05:40:05 +03:00
/****************************************************************************
Close an rpc pipe .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2008-07-12 14:25:42 +04:00
static int close_internal_rpc_pipe_hnd ( struct pipes_struct * p )
2002-01-20 05:40:05 +03:00
{
if ( ! p ) {
DEBUG ( 0 , ( " Invalid pipe in close_internal_rpc_pipe_hnd \n " ) ) ;
return False ;
}
2009-02-08 01:36:50 +03:00
prs_mem_free ( & p - > out_data . frag ) ;
2002-01-20 05:40:05 +03:00
prs_mem_free ( & p - > out_data . rdata ) ;
prs_mem_free ( & p - > in_data . data ) ;
2005-09-30 21:13:37 +04:00
if ( p - > auth . auth_data_free_func ) {
( * p - > auth . auth_data_free_func ) ( & p - > auth ) ;
}
2009-01-20 16:34:14 +03:00
TALLOC_FREE ( p - > mem_ctx ) ;
2005-09-30 21:13:37 +04:00
2003-08-15 01:14:28 +04:00
free_pipe_rpc_context ( p - > contexts ) ;
2002-01-20 05:40:05 +03:00
/* Free the handles database. */
close_policy_by_pipe ( p ) ;
DLIST_REMOVE ( InternalPipes , p ) ;
delineation between smb and msrpc more marked. smbd now constructs
pdus, and then feeds them over either a "local" function call or a "remote"
function call to an msrpc service. the "remote" msrpc daemon, on the
other side of a unix socket, then calls the same "local" function that
smbd would, if the msrpc service were being run from inside smbd.
this allows a transition from local msrpc services (inside the same smbd
process) to remote (over a unix socket).
removed reference to pipes_struct in msrpc services. all msrpc processing
functions take rpcsrv_struct which is a structure containing state info
for the msrpc functions to decode and create pdus.
created become_vuser() which does everything not related to connection_struct
that become_user() does.
removed, as best i could, connection_struct dependencies from the nt spoolss
printing code.
todo: remove dcinfo from rpcsrv_struct because this stores NETLOGON-specific
info on a per-connection basis, and if the connection dies then so does
the info, and that's a fairly serious problem.
had to put pretty much everything that is in user_struct into parse_creds.c
to feed unix user info over to the msrpc daemons. why? because it's
expensive to do unix password/group database lookups, and it's definitely
expensive to do nt user profile lookups, not to mention pretty difficult
and if you did either of these it would introduce a complication /
unnecessary interdependency. so, send uid/gid/num_groups/gid_t* +
SID+num_rids+domain_group_rids* + unix username + nt username + nt domain
+ user session key etc. this is the MINIMUM info identified so far that's
actually implemented. missing bits include the called and calling
netbios names etc. (basically, anything that can be loaded into
standard_sub() and standard_sub_basic()...)
(This used to be commit aa3c659a8dba0437c17c60055a6ed30fdfecdb6d)
1999-12-12 04:25:49 +03:00
ZERO_STRUCTP ( p ) ;
1999-12-13 16:27:58 +03:00
2008-06-20 18:22:49 +04:00
TALLOC_FREE ( p ) ;
1998-08-17 07:06:20 +04:00
return True ;
1998-03-12 00:11:04 +03:00
}
2008-10-13 01:01:38 +04:00
bool fsp_is_np ( struct files_struct * fsp )
{
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
enum FAKE_FILE_TYPE type ;
if ( ( fsp = = NULL ) | | ( fsp - > fake_file_handle = = NULL ) ) {
return false ;
}
type = fsp - > fake_file_handle - > type ;
return ( ( type = = FAKE_FILE_TYPE_NAMED_PIPE )
| | ( type = = FAKE_FILE_TYPE_NAMED_PIPE_PROXY ) ) ;
}
struct np_proxy_state {
int fd ;
} ;
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 )
{
struct np_proxy_state * result ;
struct sockaddr_un addr ;
char * socket_path ;
2008-10-26 20:56:29 +03:00
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 ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
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 ;
2008-10-26 20:56:29 +03:00
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 ) ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
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 ) ;
2008-10-26 20:56:29 +03:00
become_root ( ) ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
if ( sys_connect ( result - > fd , ( struct sockaddr * ) & addr ) = = - 1 ) {
2008-10-26 20:56:29 +03:00
unbecome_root ( ) ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
DEBUG ( 0 , ( " connect(%s) failed: %s \n " , addr . sun_path ,
strerror ( errno ) ) ) ;
goto fail ;
}
2008-10-26 20:56:29 +03:00
unbecome_root ( ) ;
info3 = talloc ( talloc_tos ( ) , struct netr_SamInfo3 ) ;
if ( info3 = = NULL ) {
DEBUG ( 0 , ( " talloc failed \n " ) ) ;
goto fail ;
}
status = serverinfo_to_SamInfo3 ( server_info , NULL , 0 , info3 ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
TALLOC_FREE ( info3 ) ;
DEBUG ( 0 , ( " serverinfo_to_SamInfo3 failed: %s \n " ,
nt_errstr ( status ) ) ) ;
goto fail ;
}
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 ) ) ) ;
goto fail ;
}
if ( rep . level ! = 1 ) {
DEBUG ( 0 , ( " req invalid level: %u != 1 \n " ,
rep . level ) ) ;
goto fail ;
}
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
return result ;
fail :
TALLOC_FREE ( result ) ;
return NULL ;
2008-10-13 01:01:38 +04:00
}
2009-01-20 17:21:04 +03:00
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 )
2008-10-13 01:01:38 +04:00
{
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
const char * * proxy_list ;
2009-01-20 17:21:04 +03:00
struct fake_file_handle * handle ;
2008-10-25 17:23:36 +04:00
2009-01-20 17:21:04 +03:00
proxy_list = lp_parm_string_list ( - 1 , " np " , " proxy " , NULL ) ;
2008-10-13 01:01:38 +04:00
2009-01-20 17:21:04 +03:00
handle = talloc ( mem_ctx , struct fake_file_handle ) ;
if ( handle = = NULL ) {
2008-10-13 01:01:38 +04:00
return NT_STATUS_NO_MEMORY ;
}
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
if ( ( proxy_list ! = NULL ) & & str_list_check_ci ( proxy_list , name ) ) {
struct np_proxy_state * p ;
2009-01-20 17:21:04 +03:00
p = make_external_rpc_pipe_p ( handle , name , server_info ) ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
2009-01-20 17:21:04 +03:00
handle - > type = FAKE_FILE_TYPE_NAMED_PIPE_PROXY ;
handle - > private_data = p ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
} else {
struct pipes_struct * p ;
2009-02-01 14:03:31 +03:00
struct ndr_syntax_id syntax ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
2009-02-01 14:03:31 +03:00
if ( ! is_known_pipename ( name , & syntax ) ) {
2009-01-20 17:21:04 +03:00
TALLOC_FREE ( handle ) ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
return NT_STATUS_OBJECT_NAME_NOT_FOUND ;
}
2009-02-01 14:03:31 +03:00
p = make_internal_rpc_pipe_p ( handle , & syntax , client_address ,
2009-01-20 17:21:04 +03:00
server_info ) ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
2009-01-20 17:21:04 +03:00
handle - > type = FAKE_FILE_TYPE_NAMED_PIPE ;
handle - > private_data = p ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
}
2009-01-20 17:21:04 +03:00
if ( handle - > private_data = = NULL ) {
TALLOC_FREE ( handle ) ;
2008-10-13 01:01:38 +04:00
return NT_STATUS_PIPE_NOT_AVAILABLE ;
}
2009-01-20 17:21:04 +03:00
* phandle = handle ;
2008-10-13 01:01:38 +04:00
return NT_STATUS_OK ;
}
2009-01-31 14:43:25 +03:00
struct np_write_state {
ssize_t nwritten ;
} ;
static void np_write_done ( struct async_req * subreq ) ;
struct async_req * np_write_send ( TALLOC_CTX * mem_ctx , struct event_context * ev ,
struct fake_file_handle * handle ,
const uint8_t * data , size_t len )
2008-10-13 01:01:38 +04:00
{
2009-01-31 14:43:25 +03:00
struct async_req * result , * subreq ;
struct np_write_state * state ;
NTSTATUS status ;
DEBUG ( 6 , ( " np_write_send: len: %d \n " , ( int ) len ) ) ;
2008-10-13 01:01:38 +04:00
dump_data ( 50 , data , len ) ;
2009-01-31 14:43:25 +03:00
if ( ! async_req_setup ( mem_ctx , & result , & state ,
struct np_write_state ) ) {
return NULL ;
}
2009-01-31 16:33:38 +03:00
if ( len = = 0 ) {
state - > nwritten = 0 ;
status = NT_STATUS_OK ;
goto post_status ;
}
2009-01-31 14:43:25 +03:00
if ( handle - > type = = FAKE_FILE_TYPE_NAMED_PIPE ) {
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
struct pipes_struct * p = talloc_get_type_abort (
2009-01-20 17:21:04 +03:00
handle - > private_data , struct pipes_struct ) ;
2009-01-31 14:43:25 +03:00
state - > nwritten = write_to_internal_pipe ( p , ( char * ) data , len ) ;
status = ( state - > nwritten > = 0 )
? NT_STATUS_OK : NT_STATUS_UNEXPECTED_IO_ERROR ;
goto post_status ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
}
2009-01-31 14:43:25 +03:00
if ( handle - > type = = FAKE_FILE_TYPE_NAMED_PIPE_PROXY ) {
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
struct np_proxy_state * p = talloc_get_type_abort (
2009-01-20 17:21:04 +03:00
handle - > private_data , struct np_proxy_state ) ;
2009-01-31 14:43:25 +03:00
state - > nwritten = len ;
subreq = sendall_send ( state , ev , p - > fd , data , len , 0 ) ;
if ( subreq = = NULL ) {
goto fail ;
}
subreq - > async . fn = np_write_done ;
subreq - > async . priv = result ;
return result ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
}
2009-01-31 14:43:25 +03:00
status = NT_STATUS_INVALID_HANDLE ;
post_status :
2009-02-01 18:32:02 +03:00
if ( async_post_ntstatus ( result , ev , status ) ) {
2009-01-31 14:43:25 +03:00
return result ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
}
2009-01-31 14:43:25 +03:00
fail :
TALLOC_FREE ( result ) ;
return NULL ;
}
2008-10-13 01:01:38 +04:00
2009-01-31 14:43:25 +03:00
static void np_write_done ( struct async_req * subreq )
{
struct async_req * req = talloc_get_type_abort (
subreq - > async . priv , struct async_req ) ;
NTSTATUS status ;
status = sendall_recv ( subreq ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2009-02-01 18:32:02 +03:00
async_req_nterror ( req , status ) ;
2009-01-31 14:43:25 +03:00
return ;
}
2009-02-01 02:07:16 +03:00
async_req_done ( req ) ;
2009-01-31 14:43:25 +03:00
}
NTSTATUS np_write_recv ( struct async_req * req , ssize_t * pnwritten )
{
struct np_write_state * state = talloc_get_type_abort (
req - > private_data , struct np_write_state ) ;
NTSTATUS status ;
2009-02-01 18:32:02 +03:00
if ( async_req_is_nterror ( req , & status ) ) {
2009-01-31 14:43:25 +03:00
return status ;
}
* pnwritten = state - > nwritten ;
return NT_STATUS_OK ;
}
2009-01-31 15:36:09 +03:00
struct np_read_state {
ssize_t nread ;
bool is_data_outstanding ;
2009-02-05 00:35:23 +03:00
int fd ;
2009-01-31 15:36:09 +03:00
} ;
static void np_read_done ( struct async_req * subreq ) ;
struct async_req * np_read_send ( TALLOC_CTX * mem_ctx , struct event_context * ev ,
struct fake_file_handle * handle ,
uint8_t * data , size_t len )
2008-10-13 01:01:38 +04:00
{
2009-01-31 15:36:09 +03:00
struct async_req * result , * subreq ;
struct np_read_state * state ;
NTSTATUS status ;
if ( ! async_req_setup ( mem_ctx , & result , & state ,
struct np_read_state ) ) {
return NULL ;
}
if ( handle - > type = = FAKE_FILE_TYPE_NAMED_PIPE ) {
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
struct pipes_struct * p = talloc_get_type_abort (
2009-01-20 17:21:04 +03:00
handle - > private_data , struct pipes_struct ) ;
2009-01-31 15:36:09 +03:00
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 ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
}
2009-01-31 15:36:09 +03:00
if ( handle - > type = = FAKE_FILE_TYPE_NAMED_PIPE_PROXY ) {
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
struct np_proxy_state * p = talloc_get_type_abort (
2009-01-20 17:21:04 +03:00
handle - > private_data , struct np_proxy_state ) ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
2009-02-05 00:35:23 +03:00
state - > fd = p - > fd ;
Add proxied named pipe support
This is a central piece of the "merged build" thing: Forward named pipes from
samba3 to samba4. This patch is not finished yet, as we will have to forward
the smb-level authentication information to samba4, but I'm pushing this patch
already to demonstrate the implementation without clutter.
It adds an intermediate parameter
np:proxy = srvsvc samr winreg wkssvc ... and so on
that states which of the pipes should be forwarded to the s4 unix domain socket
DEFAULT. The parameter is intermediate because once we have a proper endpoint
mapper implementation, this information will be retrieved out of a database.
If anybody wants to try this, do the merged build and configure s4 with
server services = samba3_smb, rpc, nbt, wrepl, ldap, cldap, kdc, drepl
samba3:smbd = /data/inst/sbin/smbd
and s3 with
auth methods = guest netlogond
np:proxy = srvsvc samr winreg wkssvc netlogon ntlsa ntsvcs lsass lsarpc netdfs \
rpcecho initshutdown epmapper svcctl eventlog drsuapi
Then run rpcclient against samba4. It will fork s3, which authenticates against
s4, and then forwards the rpc requests to s4.
Volker
2008-10-25 17:37:13 +04:00
2009-02-05 13:15:06 +03:00
subreq = async_recv ( state , ev , p - > fd , data , len , 0 ) ;
2009-01-31 15:36:09 +03:00
if ( subreq = = NULL ) {
goto fail ;
}
subreq - > async . fn = np_read_done ;
subreq - > async . priv = result ;
return result ;
}
status = NT_STATUS_INVALID_HANDLE ;
post_status :
2009-02-01 18:32:02 +03:00
if ( async_post_ntstatus ( result , ev , status ) ) {
2009-01-31 15:36:09 +03:00
return result ;
}
fail :
TALLOC_FREE ( result ) ;
return NULL ;
}
static void np_read_done ( struct async_req * subreq )
{
struct async_req * req = talloc_get_type_abort (
subreq - > async . priv , struct async_req ) ;
2009-02-05 00:35:23 +03:00
struct np_read_state * state = talloc_get_type_abort (
req - > private_data , struct np_read_state ) ;
2009-02-05 13:15:06 +03:00
ssize_t result ;
int sys_errno ;
2009-02-05 00:35:23 +03:00
int available = 0 ;
2009-01-31 15:36:09 +03:00
2009-02-05 13:15:06 +03:00
result = async_syscall_result_ssize_t ( subreq , & sys_errno ) ;
if ( result = = - 1 ) {
async_req_nterror ( req , map_nt_error_from_unix ( sys_errno ) ) ;
2009-01-31 15:36:09 +03:00
return ;
}
2009-02-05 13:15:06 +03:00
if ( result = = 0 ) {
async_req_nterror ( req , NT_STATUS_END_OF_FILE ) ;
return ;
}
state - > nread = result ;
2009-02-05 00:35:23 +03:00
/*
* We don ' t look at the ioctl result . We don ' t really care if there is
* data available , because this is racy anyway .
*/
ioctl ( state - > fd , FIONREAD , & available ) ;
state - > is_data_outstanding = ( available > 0 ) ;
2009-01-31 15:36:09 +03:00
async_req_done ( req ) ;
}
NTSTATUS np_read_recv ( struct async_req * req , ssize_t * nread ,
bool * is_data_outstanding )
{
struct np_read_state * state = talloc_get_type_abort (
req - > private_data , struct np_read_state ) ;
NTSTATUS status ;
2009-02-01 18:32:02 +03:00
if ( async_req_is_nterror ( req , & status ) ) {
2009-01-31 15:36:09 +03:00
return status ;
}
* nread = state - > nread ;
* is_data_outstanding = state - > is_data_outstanding ;
return NT_STATUS_OK ;
}
2009-02-01 15:01:54 +03:00
/**
* Create a new RPC client context which uses a local dispatch function .
*/
NTSTATUS rpc_pipe_open_internal ( TALLOC_CTX * mem_ctx ,
const struct ndr_syntax_id * abstract_syntax ,
NTSTATUS ( * dispatch ) ( struct rpc_pipe_client * cli ,
TALLOC_CTX * mem_ctx ,
const struct ndr_interface_table * table ,
uint32_t opnum , void * r ) ,
struct auth_serversupplied_info * serversupplied_info ,
struct rpc_pipe_client * * presult )
{
struct rpc_pipe_client * result ;
result = TALLOC_ZERO_P ( mem_ctx , struct rpc_pipe_client ) ;
if ( result = = NULL ) {
return NT_STATUS_NO_MEMORY ;
}
result - > abstract_syntax = * abstract_syntax ;
result - > transfer_syntax = ndr_transfer_syntax ;
result - > dispatch = dispatch ;
result - > pipes_struct = make_internal_rpc_pipe_p (
result , abstract_syntax , " " , serversupplied_info ) ;
if ( result - > pipes_struct = = NULL ) {
TALLOC_FREE ( result ) ;
return NT_STATUS_NO_MEMORY ;
}
result - > max_xmit_frag = - 1 ;
result - > max_recv_frag = - 1 ;
* presult = result ;
return NT_STATUS_OK ;
}