2010-06-10 22:36:19 +04: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
2010-06-10 22:36:19 +04:00
*
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 .
2010-06-10 22:36:19 +04:00
*
1998-03-12 00:11:04 +03:00
* 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 .
2010-06-10 22:36:19 +04:00
*
1998-03-12 00:11:04 +03:00
* 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"
2010-04-28 17:51:12 +04:00
# include "../librpc/gen_ndr/srv_spoolss.h"
2008-10-26 20:56:29 +03:00
# include "librpc/gen_ndr/ndr_named_pipe_auth.h"
2010-04-27 17:15:09 +04:00
# include "../libcli/named_pipe_auth/npa_tstream.h"
2010-07-17 23:22:26 +04:00
# include "rpc_server.h"
2010-08-08 11:22:05 +04:00
# include "smbd/globals.h"
2010-08-18 18:44:47 +04:00
# include "fake_file.h"
2010-08-18 20:26:17 +04:00
# include "rpc_dce.h"
2010-07-07 23:24:00 +04:00
# include "rpc_server/rpc_ncacn_np.h"
2011-03-25 00:33:07 +03:00
# include "ntdomain.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-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
2010-07-28 12:16:34 +04:00
static ssize_t fill_rpc_header ( struct pipes_struct * p , char * data , size_t data_to_copy )
2000-03-10 00:45:16 +03:00
{
2010-06-10 22:56:03 +04:00
size_t len_needed_to_complete_hdr =
2010-07-10 00:28:52 +04:00
MIN ( data_to_copy , RPC_HEADER_LEN - p - > in_data . pdu . length ) ;
2000-03-10 00:45:16 +03:00
2010-06-10 22:56:03 +04:00
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 ,
2010-07-10 00:28:52 +04:00
( unsigned int ) p - > in_data . pdu . length ) ) ;
2000-03-10 00:45:16 +03:00
2010-07-10 00:28:52 +04:00
if ( p - > in_data . pdu . data = = NULL ) {
p - > in_data . pdu . data = talloc_array ( p , uint8_t , RPC_HEADER_LEN ) ;
2009-02-07 18:24:08 +03:00
}
2010-07-10 00:28:52 +04:00
if ( p - > in_data . pdu . data = = NULL ) {
2009-02-07 18:24:08 +03:00
DEBUG ( 0 , ( " talloc failed \n " ) ) ;
return - 1 ;
}
2010-07-10 00:28:52 +04:00
memcpy ( ( char * ) & p - > in_data . pdu . data [ p - > in_data . pdu . length ] ,
2010-06-10 22:56:03 +04:00
data , len_needed_to_complete_hdr ) ;
2010-07-10 00:28:52 +04:00
p - > in_data . pdu . length + = len_needed_to_complete_hdr ;
2000-03-10 00:45:16 +03:00
return ( ssize_t ) len_needed_to_complete_hdr ;
}
2010-07-28 12:16:34 +04:00
static bool get_pdu_size ( struct pipes_struct * p )
2010-07-09 22:23:59 +04:00
{
uint16_t frag_len ;
/* the fill_rpc_header() call insures we copy only
* RPC_HEADER_LEN bytes . If this doesn ' t match then
* somethign is very wrong and we can only abort */
2010-07-10 00:28:52 +04:00
if ( p - > in_data . pdu . length ! = RPC_HEADER_LEN ) {
2010-07-09 22:23:59 +04:00
DEBUG ( 0 , ( " Unexpected RPC Header size! "
" got %d, expected %d) \n " ,
2010-07-10 00:28:52 +04:00
( int ) p - > in_data . pdu . length ,
2010-07-09 22:23:59 +04:00
RPC_HEADER_LEN ) ) ;
set_incoming_fault ( p ) ;
return false ;
}
2010-07-10 00:28:52 +04:00
frag_len = dcerpc_get_frag_length ( & p - > in_data . pdu ) ;
2010-07-09 22:23:59 +04:00
/* verify it is a reasonable value */
if ( ( frag_len < RPC_HEADER_LEN ) | |
( frag_len > RPC_MAX_PDU_FRAG_LEN ) ) {
DEBUG ( 0 , ( " Unexpected RPC Fragment size! (%d) \n " ,
frag_len ) ) ;
set_incoming_fault ( p ) ;
return false ;
}
p - > in_data . pdu_needed_len = frag_len - RPC_HEADER_LEN ;
/* allocate the space needed to fill the pdu */
2010-07-10 00:28:52 +04:00
p - > in_data . pdu . data = talloc_realloc ( p , p - > in_data . pdu . data ,
uint8_t , frag_len ) ;
if ( p - > in_data . pdu . data = = NULL ) {
2010-07-09 22:23:59 +04:00
DEBUG ( 0 , ( " talloc_realloc failed \n " ) ) ;
set_incoming_fault ( p ) ;
return false ;
}
return true ;
}
2001-03-11 03:32:10 +03:00
/****************************************************************************
2010-06-18 02:35:07 +04:00
Call this to free any talloc ' ed memory . Do this after processing
a complete incoming and outgoing request ( multiple incoming / outgoing
PDU ' s ) .
2001-03-11 03:32:10 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-07-28 12:16:34 +04:00
static void free_pipe_context ( struct pipes_struct * p )
2001-03-11 03:32:10 +03:00
{
2010-07-14 02:01:16 +04:00
data_blob_free ( & p - > out_data . frag ) ;
2010-07-13 23:43:44 +04:00
data_blob_free ( & p - > out_data . rdata ) ;
2010-07-15 18:28:59 +04:00
data_blob_free ( & p - > in_data . data ) ;
2010-06-18 02:35:07 +04:00
DEBUG ( 3 , ( " free_pipe_context: "
" destroying talloc pool of size %lu \n " ,
( unsigned long ) talloc_total_size ( p - > mem_ctx ) ) ) ;
talloc_free_children ( p - > mem_ctx ) ;
2001-03-11 03:32:10 +03:00
}
2000-03-10 00:45:16 +03:00
/****************************************************************************
Accepts incoming data on an rpc pipe . Processes the data in pdu sized units .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-06-15 05:11:10 +04:00
ssize_t process_incoming_data ( struct pipes_struct * p , char * data , size_t n )
2000-03-10 00:45:16 +03:00
{
2010-06-10 22:56:03 +04:00
size_t data_to_copy = MIN ( n , RPC_MAX_PDU_FRAG_LEN
2010-07-10 00:28:52 +04:00
- p - > in_data . pdu . length ) ;
2000-03-10 00:45:16 +03:00
2010-07-10 00:28:52 +04:00
DEBUG ( 10 , ( " process_incoming_data: Start: pdu.length = %u, "
2010-06-10 22:56:03 +04:00
" pdu_needed_len = %u, incoming data = %u \n " ,
2010-07-10 00:28:52 +04:00
( unsigned int ) p - > in_data . pdu . length ,
2010-06-10 22:56:03 +04:00
( unsigned int ) p - > in_data . pdu_needed_len ,
( unsigned int ) n ) ) ;
2000-03-10 00:45:16 +03:00
if ( data_to_copy = = 0 ) {
/*
* This is an error - data is being received and there is no
2010-06-10 22:56:03 +04:00
* space in the PDU . Free the received data and go into the
* fault state .
2000-03-10 00:45:16 +03:00
*/
2010-06-10 22:56:03 +04:00
DEBUG ( 0 , ( " process_incoming_data: "
" No space in incoming pdu buffer. "
" Current size = %u incoming data size = %u \n " ,
2010-07-10 00:28:52 +04:00
( unsigned int ) p - > in_data . pdu . length ,
2010-06-10 22:56:03 +04:00
( unsigned int ) n ) ) ;
2000-03-10 00:45:16 +03:00
set_incoming_fault ( p ) ;
return - 1 ;
}
/*
2010-06-10 22:56:03 +04:00
* If we have no data already , wait until we get at least
* a RPC_HEADER_LEN * number of bytes before we can do anything .
2000-03-10 00:45:16 +03:00
*/
2010-06-10 22:56:03 +04:00
if ( ( p - > in_data . pdu_needed_len = = 0 ) & &
2010-07-10 00:28:52 +04:00
( p - > in_data . pdu . length < RPC_HEADER_LEN ) ) {
2000-03-10 00:45:16 +03:00
/*
* 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 ) ;
}
/*
2010-06-10 22:56:03 +04:00
* At this point we know we have at least an RPC_HEADER_LEN amount of
2010-07-10 00:28:52 +04:00
* data stored in p - > in_data . pdu .
2000-03-10 00:45:16 +03:00
*/
/*
2010-06-10 22:36:19 +04:00
* If pdu_needed_len is zero this is a new pdu .
2010-07-09 22:23:59 +04:00
* Check how much more data we need , then loop again .
2000-03-10 00:45:16 +03:00
*/
2010-07-09 22:23:59 +04:00
if ( p - > in_data . pdu_needed_len = = 0 ) {
2000-03-10 00:45:16 +03:00
2010-07-09 22:23:59 +04:00
bool ok = get_pdu_size ( p ) ;
if ( ! ok ) {
return - 1 ;
}
if ( p - > in_data . pdu_needed_len > 0 ) {
return 0 ;
2005-11-29 05:10:52 +03:00
}
2010-07-09 22:23:59 +04:00
2010-06-10 22:56:03 +04:00
/* If rret == 0 and pdu_needed_len == 0 here we have a PDU
* that consists of an RPC_HEADER only . This is a
* DCERPC_PKT_SHUTDOWN , DCERPC_PKT_CO_CANCEL or
* DCERPC_PKT_ORPHANED pdu type .
* Deal with this in process_complete_pdu ( ) . */
2005-09-30 21:13:37 +04:00
}
2000-03-10 00:45:16 +03:00
/*
2010-07-09 22:23:59 +04:00
* Ok - at this point we have a valid RPC_HEADER .
2000-03-10 00:45:16 +03:00
* Keep reading until we have a full pdu .
*/
data_to_copy = MIN ( data_to_copy , p - > in_data . pdu_needed_len ) ;
/*
2010-07-10 00:28:52 +04:00
* Copy as much of the data as we need into the p - > in_data . 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
*/
2010-07-10 00:28:52 +04:00
memcpy ( ( char * ) & p - > in_data . pdu . data [ p - > in_data . pdu . length ] ,
2010-06-10 22:56:03 +04:00
data , data_to_copy ) ;
2010-07-10 00:28:52 +04:00
p - > in_data . pdu . length + = 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
2010-06-10 22:56:03 +04:00
DEBUG ( 10 , ( " process_incoming_data: not a complete PDU yet. "
2010-07-10 00:28:52 +04:00
" pdu.length = %u, pdu_needed_len = %u \n " ,
( unsigned int ) p - > in_data . pdu . length ,
2010-06-10 22:56:03 +04:00
( unsigned int ) p - > in_data . pdu_needed_len ) ) ;
2000-03-10 00:45:16 +03:00
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 ;
2010-06-10 22:56:03 +04:00
DEBUG ( 10 , ( " write_to_pipe: data_left = %u \n " ,
( unsigned int ) data_left ) ) ;
2000-03-10 00:45:16 +03:00
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
2010-06-10 22:56:03 +04:00
DEBUG ( 10 , ( " write_to_pipe: data_used = %d \n " ,
( int ) data_used ) ) ;
2000-03-10 00:45:16 +03:00
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 ;
2010-06-10 22:36:19 +04:00
}
2000-03-10 00:45:16 +03:00
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
2010-06-10 22:56:03 +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 " ) ) ;
2010-06-10 22:36:19 +04:00
return - 1 ;
2002-01-20 05:40:05 +03:00
}
2009-11-08 21:37:53 +03:00
DEBUG ( 6 , ( " name: %s len: %u \n " ,
get_pipe_name_from_syntax ( talloc_tos ( ) , & p - > syntax ) ,
2009-02-01 14:03:31 +03:00
( 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
/*
2010-06-10 22:36:19 +04:00
* This condition should result in the connection being closed .
2001-08-27 00:05:33 +04:00
* 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 " ,
2009-11-08 21:37:53 +03:00
( unsigned int ) n ,
get_pipe_name_from_syntax ( talloc_tos ( ) , & p - > syntax ) ,
2009-02-01 14:03:31 +03:00
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
2010-07-14 02:01:16 +04:00
pdu_remaining = p - > out_data . frag . length
2009-02-08 01:36:50 +03:00
- 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 " ,
2009-11-08 21:37:53 +03:00
get_pipe_name_from_syntax ( talloc_tos ( ) , & p - > syntax ) ,
2010-07-14 02:01:16 +04:00
( unsigned int ) p - > out_data . frag . length ,
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 ,
2010-07-14 02:01:16 +04:00
p - > out_data . frag . data
2009-02-08 01:36:50 +03:00
+ 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 "
2010-07-13 23:43:44 +04:00
" = %u, p->out_data.rdata.length = %u. \n " ,
2009-11-08 21:37:53 +03:00
get_pipe_name_from_syntax ( talloc_tos ( ) , & p - > syntax ) ,
( int ) p - > fault_state ,
2009-02-01 14:03:31 +03:00
( unsigned int ) p - > out_data . data_sent_length ,
2010-07-13 23:43:44 +04:00
( unsigned int ) p - > out_data . rdata . length ) ) ;
1999-12-13 16:27:58 +03:00
2010-07-13 23:43:44 +04:00
if ( p - > out_data . data_sent_length > = p - > out_data . rdata . length ) {
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 " ,
2009-11-08 21:37:53 +03:00
get_pipe_name_from_syntax ( talloc_tos ( ) , & 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
2010-07-14 02:01:16 +04:00
data_returned = MIN ( n , p - > out_data . frag . length ) ;
1998-03-12 00:11:04 +03:00
2010-07-14 02:01:16 +04:00
memcpy ( data , p - > out_data . frag . data , ( 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 :
2010-07-14 02:01:16 +04:00
( * is_data_outstanding ) = p - > out_data . frag . length > n ;
2001-02-27 22:22:02 +03:00
2010-07-14 02:01:16 +04:00
if ( p - > out_data . current_pdu_sent = = p - > out_data . frag . length ) {
2010-01-07 00:11:00 +03:00
/* 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 ;
2010-07-14 02:01:16 +04:00
data_blob_free ( & p - > out_data . frag ) ;
2010-06-18 02:35:07 +04:00
2010-07-13 23:43:44 +04:00
if ( p - > out_data . data_sent_length > = p - > out_data . rdata . length ) {
2010-07-06 17:07:05 +04:00
/*
* We ' re completely finished with both outgoing and
* incoming data streams . It ' s safe to free all
* temporary data from this request .
*/
free_pipe_context ( p ) ;
}
2010-06-18 02:35:07 +04:00
}
1999-12-13 16:27:58 +03:00
return data_returned ;
}
1998-08-17 07:06:20 +04: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 ) ) ;
}
2009-01-20 17:21:04 +03:00
NTSTATUS np_open ( TALLOC_CTX * mem_ctx , const char * name ,
2010-04-27 17:12:32 +04:00
const struct tsocket_address * local_address ,
const struct tsocket_address * remote_address ,
2010-08-16 13:01:26 +04:00
struct client_address * client_id ,
2011-02-21 12:25:52 +03:00
struct auth_serversupplied_info * session_info ,
2010-08-08 11:11:45 +04:00
struct messaging_context * msg_ctx ,
2009-01-20 17:21:04 +03:00
struct fake_file_handle * * phandle )
2008-10-13 01:01:38 +04:00
{
2010-09-14 15:37:46 +04:00
const char * rpcsrv_type ;
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 ;
2010-09-14 15:37:46 +04:00
bool external = false ;
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 ;
}
2010-09-14 15:37:46 +04:00
/* Check what is the server type for this pipe.
Defaults to " embedded " */
rpcsrv_type = lp_parm_const_string ( GLOBAL_SECTION_SNUM ,
" rpc_server " , name ,
" embedded " ) ;
if ( StrCaseCmp ( rpcsrv_type , " embedded " ) ! = 0 ) {
external = true ;
}
/* Still support the old method for defining external servers */
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 ) ) {
2010-09-14 15:37:46 +04:00
external = true ;
}
if ( external ) {
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 ;
2010-04-27 17:15:09 +04:00
p = make_external_rpc_pipe_p ( handle , name ,
local_address ,
remote_address ,
2011-02-21 12:25:52 +03:00
session_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 ;
}
2010-08-16 13:01:26 +04:00
p = make_internal_rpc_pipe_p ( handle , & syntax , client_id ,
2011-02-21 12:25:52 +03:00
session_info , msg_ctx ) ;
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 ;
}
2010-04-28 17:05:30 +04:00
bool np_read_in_progress ( struct fake_file_handle * handle )
{
if ( handle - > type = = FAKE_FILE_TYPE_NAMED_PIPE ) {
return false ;
}
if ( handle - > type = = FAKE_FILE_TYPE_NAMED_PIPE_PROXY ) {
struct np_proxy_state * p = talloc_get_type_abort (
handle - > private_data , struct np_proxy_state ) ;
size_t read_count ;
read_count = tevent_queue_length ( p - > read_queue ) ;
if ( read_count > 0 ) {
return true ;
}
return false ;
}
return false ;
}
2009-01-31 14:43:25 +03:00
struct np_write_state {
2009-02-10 17:28:56 +03:00
struct event_context * ev ;
struct np_proxy_state * p ;
2009-02-23 00:01:35 +03:00
struct iovec iov ;
2009-01-31 14:43:25 +03:00
ssize_t nwritten ;
} ;
2009-02-23 00:01:35 +03:00
static void np_write_done ( struct tevent_req * subreq ) ;
2009-01-31 14:43:25 +03:00
2009-03-17 11:17:16 +03:00
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 )
2008-10-13 01:01:38 +04:00
{
2009-03-17 11:17:16 +03:00
struct tevent_req * req ;
2009-01-31 14:43:25 +03:00
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-03-17 11:17:16 +03:00
req = tevent_req_create ( mem_ctx , & state , struct np_write_state ) ;
if ( req = = NULL ) {
2009-01-31 14:43:25 +03:00
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-03-17 11:17:16 +03:00
struct tevent_req * subreq ;
2009-01-31 14:43:25 +03:00
2009-02-10 17:28:56 +03:00
state - > ev = ev ;
state - > p = p ;
2009-02-23 00:01:35 +03:00
state - > iov . iov_base = CONST_DISCARD ( void * , data ) ;
state - > iov . iov_len = len ;
2009-01-31 14:43:25 +03:00
2010-04-27 17:15:09 +04:00
subreq = tstream_writev_queue_send ( state , ev ,
p - > npipe ,
p - > write_queue ,
& state - > iov , 1 ) ;
2009-03-17 11:17:16 +03:00
if ( subreq = = NULL ) {
2009-01-31 14:43:25 +03:00
goto fail ;
}
2009-03-17 11:17:16 +03:00
tevent_req_set_callback ( subreq , np_write_done , req ) ;
return req ;
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-03-17 11:17:16 +03:00
if ( NT_STATUS_IS_OK ( status ) ) {
tevent_req_done ( req ) ;
} else {
tevent_req_nterror ( req , 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-03-17 11:17:16 +03:00
return tevent_req_post ( req , ev ) ;
2009-01-31 14:43:25 +03:00
fail :
2009-03-17 11:17:16 +03:00
TALLOC_FREE ( req ) ;
2009-01-31 14:43:25 +03:00
return NULL ;
}
2008-10-13 01:01:38 +04:00
2009-02-23 00:01:35 +03:00
static void np_write_done ( struct tevent_req * subreq )
2009-01-31 14:43:25 +03:00
{
2009-03-17 11:17:16 +03:00
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 ) ;
2009-02-10 17:28:56 +03:00
ssize_t received ;
2009-02-04 11:07:36 +03:00
int err ;
2009-01-31 14:43:25 +03:00
2010-04-27 17:15:09 +04:00
received = tstream_writev_queue_recv ( subreq , & err ) ;
2009-02-10 17:28:56 +03:00
if ( received < 0 ) {
2009-03-17 11:17:16 +03:00
tevent_req_nterror ( req , map_nt_error_from_unix ( err ) ) ;
2009-01-31 14:43:25 +03:00
return ;
}
2009-02-10 17:28:56 +03:00
state - > nwritten = received ;
2009-03-17 11:17:16 +03:00
tevent_req_done ( req ) ;
2009-01-31 14:43:25 +03:00
}
2009-03-17 11:17:16 +03:00
NTSTATUS np_write_recv ( struct tevent_req * req , ssize_t * pnwritten )
2009-01-31 14:43:25 +03:00
{
2009-03-17 11:17:16 +03:00
struct np_write_state * state = tevent_req_data (
req , struct np_write_state ) ;
2009-01-31 14:43:25 +03:00
NTSTATUS status ;
2009-03-17 11:17:16 +03:00
if ( tevent_req_is_nterror ( req , & status ) ) {
2009-01-31 14:43:25 +03:00
return status ;
}
* pnwritten = state - > nwritten ;
return NT_STATUS_OK ;
}
2010-04-27 17:15:09 +04:00
struct np_ipc_readv_next_vector_state {
uint8_t * buf ;
size_t len ;
off_t ofs ;
size_t remaining ;
} ;
static void np_ipc_readv_next_vector_init ( struct np_ipc_readv_next_vector_state * s ,
uint8_t * buf , size_t len )
{
ZERO_STRUCTP ( s ) ;
s - > buf = buf ;
s - > len = MIN ( len , UINT16_MAX ) ;
}
static int np_ipc_readv_next_vector ( struct tstream_context * stream ,
void * private_data ,
TALLOC_CTX * mem_ctx ,
struct iovec * * _vector ,
size_t * count )
2009-02-09 10:10:09 +03:00
{
2010-04-27 17:15:09 +04:00
struct np_ipc_readv_next_vector_state * state =
( struct np_ipc_readv_next_vector_state * ) private_data ;
struct iovec * vector ;
ssize_t pending ;
size_t wanted ;
if ( state - > ofs = = state - > len ) {
* _vector = NULL ;
* count = 0 ;
return 0 ;
}
2009-02-09 10:10:09 +03:00
2010-04-27 17:15:09 +04:00
pending = tstream_pending_bytes ( stream ) ;
if ( pending = = - 1 ) {
return - 1 ;
}
if ( pending = = 0 & & state - > ofs ! = 0 ) {
/* return a short read */
* _vector = NULL ;
* count = 0 ;
2009-02-09 10:10:09 +03:00
return 0 ;
}
2010-04-27 17:15:09 +04:00
if ( pending = = 0 ) {
/* we want at least one byte and recheck again */
wanted = 1 ;
} else {
size_t missing = state - > len - state - > ofs ;
if ( pending > missing ) {
/* there's more available */
state - > remaining = pending - missing ;
wanted = missing ;
} else {
/* read what we can get and recheck in the next cycle */
wanted = pending ;
}
}
vector = talloc_array ( mem_ctx , struct iovec , 1 ) ;
if ( ! vector ) {
2009-02-09 10:10:09 +03:00
return - 1 ;
}
2010-04-27 17:15:09 +04:00
vector [ 0 ] . iov_base = state - > buf + state - > ofs ;
vector [ 0 ] . iov_len = wanted ;
state - > ofs + = wanted ;
* _vector = vector ;
* count = 1 ;
return 0 ;
2009-02-09 10:10:09 +03:00
}
2009-01-31 15:36:09 +03:00
struct np_read_state {
2009-02-09 10:10:09 +03:00
struct np_proxy_state * p ;
2010-04-27 17:15:09 +04:00
struct np_ipc_readv_next_vector_state next_vector ;
2009-02-09 10:10:09 +03:00
size_t nread ;
2009-01-31 15:36:09 +03:00
bool is_data_outstanding ;
} ;
2009-02-23 01:17:15 +03:00
static void np_read_done ( struct tevent_req * subreq ) ;
2009-01-31 15:36:09 +03:00
2009-03-17 11:34:17 +03:00
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 )
2008-10-13 01:01:38 +04:00
{
2009-03-17 11:34:17 +03:00
struct tevent_req * req ;
2009-01-31 15:36:09 +03:00
struct np_read_state * state ;
NTSTATUS status ;
2009-03-17 11:34:17 +03:00
req = tevent_req_create ( mem_ctx , & state , struct np_read_state ) ;
if ( req = = NULL ) {
2009-01-31 15:36:09 +03:00
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 ) ;
2010-04-27 17:15:09 +04:00
struct tevent_req * subreq ;
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
2010-04-27 17:15:09 +04:00
np_ipc_readv_next_vector_init ( & state - > next_vector ,
data , len ) ;
2009-02-09 10:10:09 +03:00
2010-04-27 17:15:09 +04:00
subreq = tstream_readv_pdu_queue_send ( state ,
ev ,
p - > npipe ,
p - > read_queue ,
np_ipc_readv_next_vector ,
& state - > next_vector ) ;
if ( subreq = = NULL ) {
2010-06-23 02:03:17 +04:00
status = NT_STATUS_NO_MEMORY ;
goto post_status ;
2009-01-31 15:36:09 +03:00
}
2010-04-27 17:15:09 +04:00
tevent_req_set_callback ( subreq , np_read_done , req ) ;
2009-03-17 11:34:17 +03:00
return req ;
2009-01-31 15:36:09 +03:00
}
status = NT_STATUS_INVALID_HANDLE ;
post_status :
2009-03-17 11:34:17 +03:00
if ( NT_STATUS_IS_OK ( status ) ) {
tevent_req_done ( req ) ;
} else {
tevent_req_nterror ( req , status ) ;
2009-01-31 15:36:09 +03:00
}
2009-03-17 11:34:17 +03:00
return tevent_req_post ( req , ev ) ;
2009-02-09 10:10:09 +03:00
}
2009-02-23 01:17:15 +03:00
static void np_read_done ( struct tevent_req * subreq )
2009-01-31 15:36:09 +03:00
{
2009-03-17 11:34:17 +03:00
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 ) ;
2010-04-27 17:15:09 +04:00
ssize_t ret ;
2009-02-09 10:10:09 +03:00
int err ;
2009-01-31 15:36:09 +03:00
2010-04-27 17:15:09 +04:00
ret = tstream_readv_pdu_queue_recv ( subreq , & err ) ;
2009-02-09 10:10:09 +03:00
TALLOC_FREE ( subreq ) ;
2010-04-27 17:15:09 +04:00
if ( ret = = - 1 ) {
2009-03-17 11:34:17 +03:00
tevent_req_nterror ( req , map_nt_error_from_unix ( err ) ) ;
2009-02-05 13:15:06 +03:00
return ;
}
2010-04-27 17:15:09 +04:00
state - > nread = ret ;
state - > is_data_outstanding = ( state - > next_vector . remaining > 0 ) ;
2009-02-05 00:35:23 +03:00
2009-03-17 11:34:17 +03:00
tevent_req_done ( req ) ;
2009-02-09 10:10:09 +03:00
return ;
2009-01-31 15:36:09 +03:00
}
2009-03-17 11:34:17 +03:00
NTSTATUS np_read_recv ( struct tevent_req * req , ssize_t * nread ,
2009-01-31 15:36:09 +03:00
bool * is_data_outstanding )
{
2009-03-17 11:34:17 +03:00
struct np_read_state * state = tevent_req_data (
req , struct np_read_state ) ;
2009-01-31 15:36:09 +03:00
NTSTATUS status ;
2009-03-17 11:34:17 +03:00
if ( tevent_req_is_nterror ( req , & status ) ) {
2009-01-31 15:36:09 +03:00
return status ;
}
2010-06-16 17:03:37 +04:00
DEBUG ( 10 , ( " Received %d bytes. There is %smore data outstanding \n " ,
( int ) state - > nread , state - > is_data_outstanding ? " " : " no " ) ) ;
2009-01-31 15:36:09 +03:00
* nread = state - > nread ;
* is_data_outstanding = state - > is_data_outstanding ;
return NT_STATUS_OK ;
}