2003-11-15 08:42:49 +03:00
/*
Unix SMB / CIFS implementation .
test suite for spoolss rpc operations
Copyright ( C ) Tim Potter 2003
2005-04-02 10:51:54 +04:00
Copyright ( C ) Stefan Metzmacher 2005
2007-09-03 17:13:25 +04:00
Copyright ( C ) Jelmer Vernooij 2007
2003-11-15 08:42:49 +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-10 06:07:03 +04:00
the Free Software Foundation ; either version 3 of the License , or
2003-11-15 08:42:49 +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 06:07:03 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
2003-11-15 08:42:49 +03:00
*/
# include "includes.h"
2006-01-03 16:41:17 +03:00
# include "torture/torture.h"
2006-03-14 18:02:05 +03:00
# include "torture/rpc/rpc.h"
2006-03-15 02:35:30 +03:00
# include "librpc/gen_ndr/ndr_spoolss_c.h"
2003-11-15 08:42:49 +03:00
2005-04-02 10:51:54 +04:00
struct test_spoolss_context {
2005-04-04 19:19:27 +04:00
/* print server handle */
struct policy_handle server_handle ;
2005-04-02 10:51:54 +04:00
/* for EnumPorts */
uint32_t port_count [ 3 ] ;
2005-05-31 02:44:17 +04:00
union spoolss_PortInfo * ports [ 3 ] ;
2005-04-02 10:51:54 +04:00
/* for EnumPrinterDrivers */
uint32_t driver_count [ 7 ] ;
2005-05-31 02:44:17 +04:00
union spoolss_DriverInfo * drivers [ 7 ] ;
2005-04-02 10:51:54 +04:00
/* for EnumMonitors */
uint32_t monitor_count [ 3 ] ;
2005-05-31 02:44:17 +04:00
union spoolss_MonitorInfo * monitors [ 3 ] ;
2005-04-02 10:51:54 +04:00
/* for EnumPrintProcessors */
uint32_t print_processor_count [ 2 ] ;
2005-05-31 02:44:17 +04:00
union spoolss_PrintProcessorInfo * print_processors [ 2 ] ;
2005-04-02 10:51:54 +04:00
/* for EnumPrinters */
uint32_t printer_count [ 6 ] ;
2005-05-31 02:44:17 +04:00
union spoolss_PrinterInfo * printers [ 6 ] ;
2005-04-02 10:51:54 +04:00
} ;
2007-09-03 17:13:25 +04:00
# define COMPARE_STRING(tctx, c,r,e) \
torture_assert_str_equal ( tctx , c . e , r . e , " invalid value " )
2005-04-02 10:51:54 +04:00
2007-07-03 20:27:35 +04:00
/* not every compiler supports __typeof__() */
# if (__GNUC__ >= 3)
2006-08-24 14:38:06 +04:00
# define _CHECK_FIELD_SIZE(c,r,e,type) do {\
if ( sizeof ( __typeof__ ( c . e ) ) ! = sizeof ( type ) ) { \
2007-09-03 17:13:25 +04:00
torture_fail ( tctx , # c " . " # e " field is not " # type " \n " ) ; \
2006-08-24 14:38:06 +04:00
} \
if ( sizeof ( __typeof__ ( r . e ) ) ! = sizeof ( type ) ) { \
2007-09-03 17:13:25 +04:00
torture_fail ( tctx , # r " . " # e " field is not " # type " \n " ) ; \
2006-08-24 14:38:06 +04:00
} \
} while ( 0 )
2007-07-03 20:27:35 +04:00
# else
# define _CHECK_FIELD_SIZE(c,r,e,type) do {} while(0)
# endif
2006-08-24 14:38:06 +04:00
2007-09-03 17:13:25 +04:00
# define COMPARE_UINT32(tctx, c, r, e) do {\
_CHECK_FIELD_SIZE ( c , r , e , uint32_t ) ; \
torture_assert_int_equal ( tctx , c . e , r . e , " invalid value " ) ; \
2005-04-02 10:51:54 +04:00
} while ( 0 )
2007-09-03 17:13:25 +04:00
# define COMPARE_STRING_ARRAY(tctx, c,r,e)
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
static bool test_OpenPrinter_server ( struct torture_context * tctx , struct dcerpc_pipe * p , struct test_spoolss_context * ctx )
2005-04-04 19:19:27 +04:00
{
NTSTATUS status ;
struct spoolss_OpenPrinter op ;
2007-09-03 17:13:25 +04:00
op . in . printername = talloc_asprintf ( ctx , " \\ \\ %s " , dcerpc_server_name ( p ) ) ;
2005-04-04 19:19:27 +04:00
op . in . datatype = NULL ;
op . in . devmode_ctr . devmode = NULL ;
op . in . access_mask = 0 ;
op . out . handle = & ctx - > server_handle ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing OpenPrinter(%s) \n " , op . in . printername ) ;
2005-04-04 19:19:27 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_OpenPrinter ( p , ctx , & op ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_OpenPrinter failed " ) ;
torture_assert_werr_ok ( tctx , op . out . result , " dcerpc_spoolss_OpenPrinter failed " ) ;
2005-04-04 19:19:27 +04:00
2007-09-03 17:13:25 +04:00
return true ;
2005-04-04 19:19:27 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumPorts ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct test_spoolss_context * ctx )
2005-04-02 10:51:54 +04:00
{
NTSTATUS status ;
struct spoolss_EnumPorts r ;
uint16_t levels [ ] = { 1 , 2 } ;
int i , j ;
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
DATA_BLOB blob ;
r . in . servername = " " ;
r . in . level = level ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumPorts level %u \n " , r . in . level ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPorts ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EnumPorts failed " ) ;
2005-06-07 18:31:45 +04:00
if ( W_ERROR_IS_OK ( r . out . result ) ) {
/* TODO: do some more checks here */
continue ;
}
2007-09-03 17:13:25 +04:00
torture_assert_werr_equal ( tctx , r . out . result , WERR_INSUFFICIENT_BUFFER ,
" EnumPorts unexpected return code " ) ;
2005-04-02 10:51:54 +04:00
2005-06-14 19:52:31 +04:00
blob = data_blob_talloc ( ctx , NULL , r . out . needed ) ;
2005-04-02 10:51:54 +04:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPorts ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EnumPorts failed " ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " EnumPorts failed " ) ;
2005-04-02 10:51:54 +04:00
ctx - > port_count [ level ] = r . out . count ;
ctx - > ports [ level ] = r . out . info ;
}
for ( i = 1 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
int old_level = levels [ i - 1 ] ;
2007-09-03 17:13:25 +04:00
torture_assert_int_equal ( tctx , ctx - > port_count [ level ] , ctx - > port_count [ old_level ] ,
" EnumPorts invalid value " ) ;
2005-04-02 10:51:54 +04:00
}
/* if the array sizes are not the same we would maybe segfault in the following code */
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
for ( j = 0 ; j < ctx - > port_count [ level ] ; j + + ) {
2005-05-31 02:44:17 +04:00
union spoolss_PortInfo * cur = & ctx - > ports [ level ] [ j ] ;
union spoolss_PortInfo * ref = & ctx - > ports [ 2 ] [ j ] ;
2005-04-02 10:51:54 +04:00
switch ( level ) {
case 1 :
2007-09-03 17:13:25 +04:00
COMPARE_STRING ( tctx , cur - > info1 , ref - > info2 , port_name ) ;
2005-04-02 10:51:54 +04:00
break ;
case 2 :
/* level 2 is our reference, and it makes no sense to compare it to itself */
break ;
}
}
}
2007-09-03 17:13:25 +04:00
return true ;
2005-04-02 10:51:54 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_GetPrinterDriverDirectory ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct test_spoolss_context * ctx )
2005-06-14 22:44:22 +04:00
{
NTSTATUS status ;
struct spoolss_GetPrinterDriverDirectory r ;
struct {
uint16_t level ;
const char * server ;
} levels [ ] = { {
2005-06-16 20:46:42 +04:00
. level = 1 ,
. server = NULL
} , {
2005-06-14 22:44:22 +04:00
. level = 1 ,
. server = " "
} , {
. level = 78 ,
. server = " "
} , {
. level = 1 ,
2007-09-03 17:13:25 +04:00
. server = talloc_asprintf ( ctx , " \\ \\ %s " , dcerpc_server_name ( p ) )
2005-06-14 22:44:22 +04:00
} , {
. level = 1024 ,
2007-09-03 17:13:25 +04:00
. server = talloc_asprintf ( ctx , " \\ \\ %s " , dcerpc_server_name ( p ) )
2005-06-14 22:44:22 +04:00
}
} ;
int i ;
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] . level ;
DATA_BLOB blob ;
r . in . server = levels [ i ] . server ;
r . in . environment = SPOOLSS_ARCHITECTURE_NT_X86 ;
r . in . level = level ;
r . in . buffer = NULL ;
r . in . offered = 0 ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing GetPrinterDriverDirectory level %u \n " , r . in . level ) ;
2005-06-14 22:44:22 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinterDriverDirectory ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status ,
" dcerpc_spoolss_GetPrinterDriverDirectory failed " ) ;
torture_assert_werr_equal ( tctx , r . out . result , WERR_INSUFFICIENT_BUFFER ,
" GetPrinterDriverDirectory unexpected return code " ) ;
2005-06-14 22:44:22 +04:00
blob = data_blob_talloc ( ctx , NULL , r . out . needed ) ;
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
r . in . offered = r . out . needed ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinterDriverDirectory ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_GetPrinterDriverDirectory failed " ) ;
2005-06-14 22:44:22 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " GetPrinterDriverDirectory failed " ) ;
2005-06-14 22:44:22 +04:00
}
2007-09-03 17:13:25 +04:00
return true ;
2005-06-14 22:44:22 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumPrinterDrivers ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct test_spoolss_context * ctx )
2005-04-02 10:51:54 +04:00
{
NTSTATUS status ;
struct spoolss_EnumPrinterDrivers r ;
uint16_t levels [ ] = { 1 , 2 , 3 , 4 , 5 , 6 } ;
int i , j ;
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
DATA_BLOB blob ;
2005-06-14 22:44:22 +04:00
r . in . server = " " ;
r . in . environment = SPOOLSS_ARCHITECTURE_NT_X86 ;
r . in . level = level ;
r . in . buffer = NULL ;
r . in . offered = 0 ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumPrinterDrivers level %u \n " , r . in . level ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinterDrivers ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status ,
" dcerpc_spoolss_EnumPrinterDrivers failed " ) ;
2005-06-07 18:31:45 +04:00
if ( W_ERROR_IS_OK ( r . out . result ) ) {
/* TODO: do some more checks here */
continue ;
}
2007-09-03 17:13:25 +04:00
torture_assert_werr_equal ( tctx , r . out . result , WERR_INSUFFICIENT_BUFFER ,
" EnumPrinterDrivers failed " ) ;
2005-04-02 10:51:54 +04:00
2005-06-14 19:52:31 +04:00
blob = data_blob_talloc ( ctx , NULL , r . out . needed ) ;
2005-04-02 10:51:54 +04:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinterDrivers ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EnumPrinterDrivers failed " ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " EnumPrinterDrivers failed " ) ;
2005-04-02 10:51:54 +04:00
ctx - > driver_count [ level ] = r . out . count ;
ctx - > drivers [ level ] = r . out . info ;
}
for ( i = 1 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
int old_level = levels [ i - 1 ] ;
2007-09-03 17:13:25 +04:00
torture_assert_int_equal ( tctx , ctx - > driver_count [ level ] , ctx - > driver_count [ old_level ] ,
" EnumPrinterDrivers invalid value " ) ;
2005-04-02 10:51:54 +04:00
}
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
for ( j = 0 ; j < ctx - > driver_count [ level ] ; j + + ) {
2005-05-31 02:44:17 +04:00
union spoolss_DriverInfo * cur = & ctx - > drivers [ level ] [ j ] ;
union spoolss_DriverInfo * ref = & ctx - > drivers [ 6 ] [ j ] ;
2005-04-02 10:51:54 +04:00
switch ( level ) {
case 1 :
2007-09-03 17:13:25 +04:00
COMPARE_STRING ( tctx , cur - > info1 , ref - > info6 , driver_name ) ;
2005-04-02 10:51:54 +04:00
break ;
case 2 :
2007-09-03 17:13:25 +04:00
COMPARE_UINT32 ( tctx , cur - > info2 , ref - > info6 , version ) ;
COMPARE_STRING ( tctx , cur - > info2 , ref - > info6 , driver_name ) ;
COMPARE_STRING ( tctx , cur - > info2 , ref - > info6 , architecture ) ;
COMPARE_STRING ( tctx , cur - > info2 , ref - > info6 , driver_path ) ;
COMPARE_STRING ( tctx , cur - > info2 , ref - > info6 , data_file ) ;
COMPARE_STRING ( tctx , cur - > info2 , ref - > info6 , config_file ) ;
2005-04-02 10:51:54 +04:00
break ;
case 3 :
2007-09-03 17:13:25 +04:00
COMPARE_UINT32 ( tctx , cur - > info3 , ref - > info6 , version ) ;
COMPARE_STRING ( tctx , cur - > info3 , ref - > info6 , driver_name ) ;
COMPARE_STRING ( tctx , cur - > info3 , ref - > info6 , architecture ) ;
COMPARE_STRING ( tctx , cur - > info3 , ref - > info6 , driver_path ) ;
COMPARE_STRING ( tctx , cur - > info3 , ref - > info6 , data_file ) ;
COMPARE_STRING ( tctx , cur - > info3 , ref - > info6 , config_file ) ;
COMPARE_STRING ( tctx , cur - > info3 , ref - > info6 , help_file ) ;
COMPARE_STRING_ARRAY ( tctx , cur - > info3 , ref - > info6 , dependent_files ) ;
COMPARE_STRING ( tctx , cur - > info3 , ref - > info6 , monitor_name ) ;
COMPARE_STRING ( tctx , cur - > info3 , ref - > info6 , default_datatype ) ;
2005-04-02 10:51:54 +04:00
break ;
case 4 :
2007-09-03 17:13:25 +04:00
COMPARE_UINT32 ( tctx , cur - > info4 , ref - > info6 , version ) ;
COMPARE_STRING ( tctx , cur - > info4 , ref - > info6 , driver_name ) ;
COMPARE_STRING ( tctx , cur - > info4 , ref - > info6 , architecture ) ;
COMPARE_STRING ( tctx , cur - > info4 , ref - > info6 , driver_path ) ;
COMPARE_STRING ( tctx , cur - > info4 , ref - > info6 , data_file ) ;
COMPARE_STRING ( tctx , cur - > info4 , ref - > info6 , config_file ) ;
COMPARE_STRING ( tctx , cur - > info4 , ref - > info6 , help_file ) ;
COMPARE_STRING_ARRAY ( tctx , cur - > info4 , ref - > info6 , dependent_files ) ;
COMPARE_STRING ( tctx , cur - > info4 , ref - > info6 , monitor_name ) ;
COMPARE_STRING ( tctx , cur - > info4 , ref - > info6 , default_datatype ) ;
COMPARE_STRING_ARRAY ( tctx , cur - > info4 , ref - > info6 , previous_names ) ;
2005-04-02 10:51:54 +04:00
break ;
case 5 :
2007-09-03 17:13:25 +04:00
COMPARE_UINT32 ( tctx , cur - > info5 , ref - > info6 , version ) ;
COMPARE_STRING ( tctx , cur - > info5 , ref - > info6 , driver_name ) ;
COMPARE_STRING ( tctx , cur - > info5 , ref - > info6 , architecture ) ;
COMPARE_STRING ( tctx , cur - > info5 , ref - > info6 , driver_path ) ;
COMPARE_STRING ( tctx , cur - > info5 , ref - > info6 , data_file ) ;
COMPARE_STRING ( tctx , cur - > info5 , ref - > info6 , config_file ) ;
/*COMPARE_UINT32(tctx, cur->info5, ref->info6, driver_attributes);*/
/*COMPARE_UINT32(tctx, cur->info5, ref->info6, config_version);*/
/*TODO: ! COMPARE_UINT32(tctx, cur->info5, ref->info6, driver_version); */
2005-04-02 10:51:54 +04:00
break ;
case 6 :
/* level 6 is our reference, and it makes no sense to compare it to itself */
break ;
}
}
}
2007-09-03 17:13:25 +04:00
return true ;
2005-04-02 10:51:54 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumMonitors ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct test_spoolss_context * ctx )
2005-04-02 10:51:54 +04:00
{
NTSTATUS status ;
struct spoolss_EnumMonitors r ;
uint16_t levels [ ] = { 1 , 2 } ;
int i , j ;
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
DATA_BLOB blob ;
r . in . servername = " " ;
r . in . level = level ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumMonitors level %u \n " , r . in . level ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumMonitors ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EnumMonitors failed " ) ;
2005-06-07 18:31:45 +04:00
if ( W_ERROR_IS_OK ( r . out . result ) ) {
/* TODO: do some more checks here */
continue ;
}
2007-09-03 17:13:25 +04:00
torture_assert_werr_equal ( tctx , r . out . result , WERR_INSUFFICIENT_BUFFER ,
" EnumMonitors failed " ) ;
2005-04-02 10:51:54 +04:00
2005-06-14 19:52:31 +04:00
blob = data_blob_talloc ( ctx , NULL , r . out . needed ) ;
2005-04-02 10:51:54 +04:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumMonitors ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EnumMonitors failed " ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " EnumMonitors failed " ) ;
2005-04-02 10:51:54 +04:00
ctx - > monitor_count [ level ] = r . out . count ;
ctx - > monitors [ level ] = r . out . info ;
}
for ( i = 1 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
int old_level = levels [ i - 1 ] ;
2007-09-03 17:13:25 +04:00
torture_assert_int_equal ( tctx , ctx - > monitor_count [ level ] , ctx - > monitor_count [ old_level ] ,
" EnumMonitors invalid value " ) ;
2005-04-02 10:51:54 +04:00
}
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
for ( j = 0 ; j < ctx - > monitor_count [ level ] ; j + + ) {
2005-05-31 02:44:17 +04:00
union spoolss_MonitorInfo * cur = & ctx - > monitors [ level ] [ j ] ;
union spoolss_MonitorInfo * ref = & ctx - > monitors [ 2 ] [ j ] ;
2005-04-02 10:51:54 +04:00
switch ( level ) {
case 1 :
2007-09-03 17:13:25 +04:00
COMPARE_STRING ( tctx , cur - > info1 , ref - > info2 , monitor_name ) ;
2005-04-02 10:51:54 +04:00
break ;
case 2 :
/* level 2 is our reference, and it makes no sense to compare it to itself */
break ;
}
}
}
2007-09-03 17:13:25 +04:00
return true ;
2005-04-02 10:51:54 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumPrintProcessors ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct test_spoolss_context * ctx )
2005-04-02 10:51:54 +04:00
{
NTSTATUS status ;
struct spoolss_EnumPrintProcessors r ;
uint16_t levels [ ] = { 1 } ;
int i , j ;
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
DATA_BLOB blob ;
r . in . servername = " " ;
r . in . environment = " Windows NT x86 " ;
r . in . level = level ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumPrintProcessors level %u \n " , r . in . level ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrintProcessors ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EnumPrintProcessors failed " ) ;
2005-06-07 18:31:45 +04:00
if ( W_ERROR_IS_OK ( r . out . result ) ) {
/* TODO: do some more checks here */
continue ;
}
2007-09-03 17:13:25 +04:00
torture_assert_werr_equal ( tctx , r . out . result , WERR_INSUFFICIENT_BUFFER ,
" EnumPrintProcessors unexpected return code " ) ;
2005-04-02 10:51:54 +04:00
2005-06-14 19:52:31 +04:00
blob = data_blob_talloc ( ctx , NULL , r . out . needed ) ;
2005-04-02 10:51:54 +04:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrintProcessors ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EnumPrintProcessors failed " ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " EnumPrintProcessors failed " ) ;
2005-04-02 10:51:54 +04:00
ctx - > print_processor_count [ level ] = r . out . count ;
ctx - > print_processors [ level ] = r . out . info ;
}
for ( i = 1 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
int old_level = levels [ i - 1 ] ;
2007-09-03 17:13:25 +04:00
torture_assert_int_equal ( tctx , ctx - > print_processor_count [ level ] , ctx - > print_processor_count [ old_level ] ,
" EnumPrintProcessors failed " ) ;
2005-04-02 10:51:54 +04:00
}
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
for ( j = 0 ; j < ctx - > print_processor_count [ level ] ; j + + ) {
#if 0
2005-05-31 02:44:17 +04:00
union spoolss_PrintProcessorInfo * cur = & ctx - > print_processors [ level ] [ j ] ;
union spoolss_PrintProcessorInfo * ref = & ctx - > print_processors [ 1 ] [ j ] ;
2005-04-02 10:51:54 +04:00
# endif
switch ( level ) {
case 1 :
/* level 1 is our reference, and it makes no sense to compare it to itself */
break ;
}
}
}
2007-09-03 17:13:25 +04:00
return true ;
2005-04-02 10:51:54 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumPrinters ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct test_spoolss_context * ctx )
2005-04-02 10:51:54 +04:00
{
struct spoolss_EnumPrinters r ;
NTSTATUS status ;
uint16_t levels [ ] = { 0 , 1 , 2 , 4 , 5 } ;
int i , j ;
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
DATA_BLOB blob ;
r . in . flags = PRINTER_ENUM_LOCAL ;
r . in . server = " " ;
r . in . level = level ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumPrinters level %u \n " , r . in . level ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinters ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EnumPrinters failed " ) ;
2005-06-07 18:31:45 +04:00
if ( W_ERROR_IS_OK ( r . out . result ) ) {
/* TODO: do some more checks here */
continue ;
}
2007-09-03 17:13:25 +04:00
torture_assert_werr_equal ( tctx , r . out . result , WERR_INSUFFICIENT_BUFFER ,
" EnumPrinters unexpected return code " ) ;
2005-04-02 10:51:54 +04:00
2005-06-14 19:52:31 +04:00
blob = data_blob_talloc ( ctx , NULL , r . out . needed ) ;
2005-04-02 10:51:54 +04:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinters ( p , ctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EnumPrinters failed " ) ;
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " EnumPrinters failed " ) ;
2005-04-02 10:51:54 +04:00
ctx - > printer_count [ level ] = r . out . count ;
ctx - > printers [ level ] = r . out . info ;
}
for ( i = 1 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
int old_level = levels [ i - 1 ] ;
2007-09-03 17:13:25 +04:00
torture_assert_int_equal ( tctx , ctx - > printer_count [ level ] , ctx - > printer_count [ old_level ] ,
" EnumPrinters invalid value " ) ;
2005-04-02 10:51:54 +04:00
}
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
int level = levels [ i ] ;
for ( j = 0 ; j < ctx - > printer_count [ level ] ; j + + ) {
2005-05-31 02:44:17 +04:00
union spoolss_PrinterInfo * cur = & ctx - > printers [ level ] [ j ] ;
union spoolss_PrinterInfo * ref = & ctx - > printers [ 2 ] [ j ] ;
2005-04-02 10:51:54 +04:00
switch ( level ) {
case 0 :
2007-09-03 17:13:25 +04:00
COMPARE_STRING ( tctx , cur - > info0 , ref - > info2 , printername ) ;
COMPARE_STRING ( tctx , cur - > info0 , ref - > info2 , servername ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , cjobs ) ;
/*COMPARE_UINT32(tctx, cur->info0, ref->info2, total_jobs);
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , total_bytes ) ;
2005-04-02 10:51:54 +04:00
COMPARE_SPOOLSS_TIME ( cur - > info0 , ref - > info2 , spoolss_Time time ) ;
2007-09-03 17:13:25 +04:00
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , global_counter ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , total_pages ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , version ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown10 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown11 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown12 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , session_counter ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown14 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , printer_errors ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown16 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown17 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown18 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown19 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , change_id ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown21 ) ; */
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , status ) ;
/*COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown23);
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , c_setprinter ) ;
2005-04-02 10:51:54 +04:00
COMPARE_UINT16 ( cur - > info0 , ref - > info2 , unknown25 ) ;
COMPARE_UINT16 ( cur - > info0 , ref - > info2 , unknown26 ) ;
2007-09-03 17:13:25 +04:00
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown27 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown28 ) ;
COMPARE_UINT32 ( tctx , cur - > info0 , ref - > info2 , unknown29 ) ; */
2005-04-02 10:51:54 +04:00
break ;
case 1 :
2007-09-03 17:13:25 +04:00
/*COMPARE_UINT32(tctx, cur->info1, ref->info2, flags);*/
/*COMPARE_STRING(tctx, cur->info1, ref->info2, name);*/
/*COMPARE_STRING(tctx, cur->info1, ref->info2, description);*/
COMPARE_STRING ( tctx , cur - > info1 , ref - > info2 , comment ) ;
2005-04-02 10:51:54 +04:00
break ;
case 2 :
/* level 2 is our reference, and it makes no sense to compare it to itself */
break ;
case 4 :
2007-09-03 17:13:25 +04:00
COMPARE_STRING ( tctx , cur - > info4 , ref - > info2 , printername ) ;
COMPARE_STRING ( tctx , cur - > info4 , ref - > info2 , servername ) ;
COMPARE_UINT32 ( tctx , cur - > info4 , ref - > info2 , attributes ) ;
2005-04-02 10:51:54 +04:00
break ;
case 5 :
2007-09-03 17:13:25 +04:00
COMPARE_STRING ( tctx , cur - > info5 , ref - > info2 , printername ) ;
COMPARE_STRING ( tctx , cur - > info5 , ref - > info2 , portname ) ;
COMPARE_UINT32 ( tctx , cur - > info5 , ref - > info2 , attributes ) ;
/*COMPARE_UINT32(tctx, cur->info5, ref->info2, device_not_selected_timeout);
COMPARE_UINT32 ( tctx , cur - > info5 , ref - > info2 , transmission_retry_timeout ) ; */
2005-04-02 10:51:54 +04:00
break ;
}
}
}
/* TODO:
* - verify that the port of a printer was in the list returned by EnumPorts
*/
2007-09-03 17:13:25 +04:00
return true ;
2005-04-02 10:51:54 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_GetPrinter ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2003-11-17 07:56:59 +03:00
struct policy_handle * handle )
{
NTSTATUS status ;
struct spoolss_GetPrinter r ;
2005-02-24 17:05:52 +03:00
uint16_t levels [ ] = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } ;
2003-11-17 07:56:59 +03:00
int i ;
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
r . in . handle = handle ;
r . in . level = levels [ i ] ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-17 07:56:59 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing GetPrinter level %u \n " , r . in . level ) ;
2003-11-17 07:56:59 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinter ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " GetPrinter failed " ) ;
2003-11-17 07:56:59 +03:00
if ( W_ERROR_EQUAL ( r . out . result , WERR_INSUFFICIENT_BUFFER ) ) {
2007-09-03 17:13:25 +04:00
DATA_BLOB blob = data_blob_talloc ( tctx , NULL , r . out . needed ) ;
2003-11-17 07:56:59 +03:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinter ( p , tctx , & r ) ;
2003-11-17 07:56:59 +03:00
}
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " GetPrinter failed " ) ;
2005-06-14 19:52:31 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " GetPrinter failed " ) ;
2003-11-17 07:56:59 +03:00
}
2007-09-03 17:13:25 +04:00
return true ;
2003-11-17 07:56:59 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_ClosePrinter ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle )
2003-11-17 07:56:59 +03:00
{
NTSTATUS status ;
struct spoolss_ClosePrinter r ;
r . in . handle = handle ;
r . out . handle = handle ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing ClosePrinter \n " ) ;
2003-11-17 07:56:59 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_ClosePrinter ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " ClosePrinter failed " ) ;
2003-11-17 07:56:59 +03:00
2007-09-03 17:13:25 +04:00
return true ;
2003-11-17 07:56:59 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_GetForm ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2004-10-28 17:40:50 +04:00
struct policy_handle * handle ,
2005-04-04 19:19:27 +04:00
const char * form_name )
2003-11-26 09:26:18 +03:00
{
NTSTATUS status ;
struct spoolss_GetForm r ;
r . in . handle = handle ;
2005-04-04 19:19:27 +04:00
r . in . form_name = form_name ;
2003-11-26 09:26:18 +03:00
r . in . level = 1 ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-26 09:26:18 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing GetForm \n " ) ;
2003-11-26 09:26:18 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetForm ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " GetForm failed " ) ;
2003-11-26 09:26:18 +03:00
if ( W_ERROR_EQUAL ( r . out . result , WERR_INSUFFICIENT_BUFFER ) ) {
2007-09-03 17:13:25 +04:00
DATA_BLOB blob = data_blob_talloc ( tctx , NULL , r . out . needed ) ;
2003-11-26 09:26:18 +03:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetForm ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " GetForm failed " ) ;
2005-07-01 13:05:10 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " GetForm failed " ) ;
2003-11-26 09:26:18 +03:00
2007-09-03 17:13:25 +04:00
torture_assert ( tctx , r . out . info , " No form info returned " ) ;
2003-11-26 09:26:18 +03:00
}
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " GetForm failed " ) ;
2005-07-01 13:05:10 +04:00
2007-09-03 17:13:25 +04:00
return true ;
2003-11-26 09:26:18 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumForms ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle , bool print_server )
2003-11-26 09:26:18 +03:00
{
NTSTATUS status ;
struct spoolss_EnumForms r ;
2007-09-03 17:13:25 +04:00
bool ret = true ;
2003-11-26 09:26:18 +03:00
r . in . handle = handle ;
r . in . level = 1 ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-26 09:26:18 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumForms \n " ) ;
2003-11-26 09:26:18 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumForms ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " EnumForms failed " ) ;
2003-11-26 09:26:18 +03:00
2007-09-03 17:13:25 +04:00
if ( print_server & & W_ERROR_EQUAL ( r . out . result , WERR_BADFID ) )
torture_fail ( tctx , " EnumForms on the PrintServer isn't supported by test server (NT4) " ) ;
2005-06-16 20:46:42 +04:00
2003-11-26 09:26:18 +03:00
if ( W_ERROR_EQUAL ( r . out . result , WERR_INSUFFICIENT_BUFFER ) ) {
union spoolss_FormInfo * info ;
int j ;
2007-09-03 17:13:25 +04:00
DATA_BLOB blob = data_blob_talloc ( tctx , NULL , r . out . needed ) ;
2003-11-26 09:26:18 +03:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2003-11-26 09:26:18 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumForms ( p , tctx , & r ) ;
2003-11-26 09:26:18 +03:00
2007-09-03 17:13:25 +04:00
torture_assert ( tctx , r . out . info , " No forms returned " ) ;
2003-11-26 09:26:18 +03:00
2005-05-31 02:44:17 +04:00
info = r . out . info ;
2003-11-26 09:26:18 +03:00
2005-02-21 16:54:06 +03:00
for ( j = 0 ; j < r . out . count ; j + + ) {
2007-09-03 17:13:25 +04:00
if ( ! print_server )
ret & = test_GetForm ( tctx , p , handle , info [ j ] . info1 . form_name ) ;
2005-02-21 16:54:06 +03:00
}
2003-11-26 09:26:18 +03:00
}
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " EnumForms failed " ) ;
2005-02-25 08:39:01 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " EnumForms failed " ) ;
2003-11-26 09:26:18 +03:00
2007-09-03 17:13:25 +04:00
return true ;
2003-11-26 09:26:18 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_DeleteForm ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2004-10-28 17:40:50 +04:00
struct policy_handle * handle ,
2005-04-04 19:19:27 +04:00
const char * form_name )
2003-11-27 12:50:25 +03:00
{
NTSTATUS status ;
struct spoolss_DeleteForm r ;
r . in . handle = handle ;
2005-04-04 19:19:27 +04:00
r . in . form_name = form_name ;
2003-11-27 12:50:25 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_DeleteForm ( p , tctx , & r ) ;
2003-11-27 12:50:25 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " DeleteForm failed " ) ;
2005-02-25 08:39:01 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " DeleteForm failed " ) ;
2003-11-27 12:50:25 +03:00
2007-09-03 17:13:25 +04:00
return true ;
2003-11-27 12:50:25 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_AddForm ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle , bool print_server )
2003-11-27 12:50:25 +03:00
{
struct spoolss_AddForm r ;
2005-04-04 19:19:27 +04:00
struct spoolss_AddFormInfo1 addform ;
const char * form_name = " testform3 " ;
2003-11-27 12:50:25 +03:00
NTSTATUS status ;
2007-09-03 17:13:25 +04:00
bool ret = true ;
2003-11-27 12:50:25 +03:00
2005-04-04 19:19:27 +04:00
r . in . handle = handle ;
r . in . level = 1 ;
r . in . info . info1 = & addform ;
addform . flags = SPOOLSS_FORM_USER ;
addform . form_name = form_name ;
addform . size . width = 50 ;
addform . size . height = 25 ;
addform . area . left = 5 ;
addform . area . top = 10 ;
addform . area . right = 45 ;
addform . area . bottom = 15 ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_AddForm ( p , tctx , & r ) ;
2003-11-27 12:50:25 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " AddForm failed " ) ;
2003-11-27 12:50:25 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " AddForm failed " ) ;
2003-11-27 23:55:13 +03:00
2007-09-03 17:13:25 +04:00
if ( ! print_server ) ret & = test_GetForm ( tctx , p , handle , form_name ) ;
2005-07-01 13:05:10 +04:00
2003-11-27 23:55:13 +03:00
{
struct spoolss_SetForm sf ;
2005-06-17 01:07:45 +04:00
struct spoolss_AddFormInfo1 setform ;
2005-04-04 19:19:27 +04:00
sf . in . handle = handle ;
sf . in . form_name = form_name ;
sf . in . level = 1 ;
sf . in . info . info1 = & setform ;
setform . flags = addform . flags ;
setform . form_name = addform . form_name ;
setform . size = addform . size ;
setform . area = addform . area ;
2003-11-27 23:55:13 +03:00
2005-04-04 19:19:27 +04:00
setform . size . width = 1234 ;
2003-11-27 23:55:13 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_SetForm ( p , tctx , & sf ) ;
2003-11-27 23:55:13 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " SetForm failed " ) ;
2005-02-25 08:39:01 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " SetForm failed " ) ;
2003-11-27 12:50:25 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! print_server ) ret & = test_GetForm ( tctx , p , handle , form_name ) ;
2005-07-01 13:05:10 +04:00
2007-09-03 17:13:25 +04:00
if ( ! test_DeleteForm ( tctx , p , handle , form_name ) ) {
ret = false ;
2003-11-27 12:50:25 +03:00
}
2003-11-27 23:55:13 +03:00
return ret ;
2003-11-27 12:50:25 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumPorts_old ( struct torture_context * tctx ,
struct dcerpc_pipe * p )
2004-09-03 17:36:58 +04:00
{
NTSTATUS status ;
struct spoolss_EnumPorts r ;
2007-09-03 17:13:25 +04:00
r . in . servername = talloc_asprintf ( tctx , " \\ \\ %s " ,
2004-09-03 17:36:58 +04:00
dcerpc_server_name ( p ) ) ;
r . in . level = 2 ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2004-09-03 17:36:58 +04:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumPorts \n " ) ;
2004-09-03 17:36:58 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPorts ( p , tctx , & r ) ;
2004-09-03 17:36:58 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " EnumPorts failed " ) ;
2004-09-03 17:36:58 +04:00
if ( W_ERROR_EQUAL ( r . out . result , WERR_INSUFFICIENT_BUFFER ) ) {
2007-09-03 17:13:25 +04:00
DATA_BLOB blob = data_blob_talloc ( tctx , NULL , r . out . needed ) ;
2004-09-03 17:36:58 +04:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2004-09-03 17:36:58 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPorts ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " EnumPorts failed " ) ;
2004-09-03 17:36:58 +04:00
2007-09-03 17:13:25 +04:00
torture_assert ( tctx , r . out . info , " No ports returned " ) ;
2004-09-03 17:36:58 +04:00
}
2007-09-03 17:13:25 +04:00
return true ;
2004-09-03 17:36:58 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_AddPort ( struct torture_context * tctx ,
struct dcerpc_pipe * p )
2005-02-25 09:16:13 +03:00
{
NTSTATUS status ;
struct spoolss_AddPort r ;
2007-09-03 17:13:25 +04:00
r . in . server_name = talloc_asprintf ( tctx , " \\ \\ %s " ,
2005-02-25 09:16:13 +03:00
dcerpc_server_name ( p ) ) ;
r . in . unknown = 0 ;
r . in . monitor_name = " foo " ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing AddPort \n " ) ;
2005-02-25 09:16:13 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_AddPort ( p , tctx , & r ) ;
2005-02-25 09:16:13 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " AddPort failed " ) ;
2005-02-25 09:16:13 +03:00
/* win2k3 returns WERR_NOT_SUPPORTED */
#if 0
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " AddPort failed - %s \n " , win_errstr ( r . out . result ) ) ;
return False ;
}
# endif
return True ;
}
2007-09-03 17:13:25 +04:00
static bool test_GetJob ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle , uint32_t job_id )
2003-11-28 08:02:32 +03:00
{
NTSTATUS status ;
struct spoolss_GetJob r ;
r . in . handle = handle ;
r . in . job_id = job_id ;
r . in . level = 1 ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing GetJob \n " ) ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetJob ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " GetJob failed " ) ;
2003-11-28 08:02:32 +03:00
if ( W_ERROR_EQUAL ( r . out . result , WERR_INSUFFICIENT_BUFFER ) ) {
2007-09-03 17:13:25 +04:00
DATA_BLOB blob = data_blob_talloc ( tctx , NULL , r . out . needed ) ;
2003-11-28 08:02:32 +03:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetJob ( p , tctx , & r ) ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
torture_assert ( tctx , r . out . info , " No job info returned " ) ;
2003-11-28 08:02:32 +03:00
}
2007-09-03 17:13:25 +04:00
return true ;
2003-11-28 08:02:32 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_SetJob ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle , uint32_t job_id ,
enum spoolss_JobControl command )
2003-11-28 08:02:32 +03:00
{
NTSTATUS status ;
struct spoolss_SetJob r ;
2005-06-06 18:56:51 +04:00
r . in . handle = handle ;
r . in . job_id = job_id ;
r . in . ctr = NULL ;
r . in . command = command ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing SetJob \n " ) ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_SetJob ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " SetJob failed " ) ;
torture_assert_werr_ok ( tctx , r . out . result , " SetJob failed " ) ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
return true ;
2003-11-28 08:02:32 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumJobs ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle )
2003-11-28 08:02:32 +03:00
{
NTSTATUS status ;
struct spoolss_EnumJobs r ;
r . in . handle = handle ;
r . in . firstjob = 0 ;
r . in . numjobs = 0xffffffff ;
r . in . level = 1 ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumJobs \n " ) ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumJobs ( p , tctx , & r ) ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " EnumJobs failed " ) ;
2003-11-28 08:02:32 +03:00
if ( W_ERROR_EQUAL ( r . out . result , WERR_INSUFFICIENT_BUFFER ) ) {
union spoolss_JobInfo * info ;
int j ;
2007-09-03 17:13:25 +04:00
DATA_BLOB blob = data_blob_talloc ( tctx , NULL , r . out . needed ) ;
2003-11-28 08:02:32 +03:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumJobs ( p , tctx , & r ) ;
2003-11-28 08:02:32 +03:00
2007-09-03 17:13:25 +04:00
torture_assert ( tctx , r . out . info , " No jobs returned " ) ;
2003-11-28 08:02:32 +03:00
2005-05-31 02:44:17 +04:00
info = r . out . info ;
2003-11-28 08:02:32 +03:00
for ( j = 0 ; j < r . out . count ; j + + ) {
2007-09-03 17:13:25 +04:00
test_GetJob ( tctx , p , handle , info [ j ] . info1 . job_id ) ;
test_SetJob ( tctx , p , handle , info [ j ] . info1 . job_id , SPOOLSS_JOB_CONTROL_PAUSE ) ;
test_SetJob ( tctx , p , handle , info [ j ] . info1 . job_id , SPOOLSS_JOB_CONTROL_RESUME ) ;
2003-11-28 08:02:32 +03:00
}
2007-09-03 17:13:25 +04:00
} else {
torture_assert_werr_ok ( tctx , r . out . result , " EnumJobs failed " ) ;
2003-11-28 08:02:32 +03:00
}
2007-09-03 17:13:25 +04:00
return true ;
2003-11-28 08:02:32 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_DoPrintTest ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle )
2005-06-06 19:03:16 +04:00
{
2007-09-03 17:13:25 +04:00
bool ret = True ;
2005-06-06 19:03:16 +04:00
NTSTATUS status ;
struct spoolss_StartDocPrinter s ;
struct spoolss_DocumentInfo1 info1 ;
2005-06-06 20:08:29 +04:00
struct spoolss_StartPagePrinter sp ;
struct spoolss_WritePrinter w ;
struct spoolss_EndPagePrinter ep ;
2005-06-06 19:03:16 +04:00
struct spoolss_EndDocPrinter e ;
2005-06-06 20:08:29 +04:00
int i ;
2005-06-06 19:03:16 +04:00
uint32_t job_id ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing StartDocPrinter \n " ) ;
2005-06-06 19:03:16 +04:00
s . in . handle = handle ;
s . in . level = 1 ;
s . in . info . info1 = & info1 ;
info1 . document_name = " TorturePrintJob " ;
info1 . output_file = NULL ;
info1 . datatype = " RAW " ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_StartDocPrinter ( p , tctx , & s ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_StartDocPrinter failed " ) ;
torture_assert_werr_ok ( tctx , s . out . result , " StartDocPrinter failed " ) ;
2005-06-06 19:03:16 +04:00
job_id = s . out . job_id ;
2005-06-06 20:08:29 +04:00
for ( i = 1 ; i < 4 ; i + + ) {
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing StartPagePrinter: Page[%d] \n " , i ) ;
2005-06-06 20:08:29 +04:00
sp . in . handle = handle ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_StartPagePrinter ( p , tctx , & sp ) ;
torture_assert_ntstatus_ok ( tctx , status ,
" dcerpc_spoolss_StartPagePrinter failed " ) ;
torture_assert_werr_ok ( tctx , sp . out . result , " StartPagePrinter failed " ) ;
2005-06-06 20:08:29 +04:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing WritePrinter: Page[%d] \n " , i ) ;
2005-06-06 20:08:29 +04:00
w . in . handle = handle ;
2007-09-03 17:13:25 +04:00
w . in . data = data_blob_string_const ( talloc_asprintf ( tctx , " TortureTestPage: %d \n Data \n " , i ) ) ;
2005-06-06 20:08:29 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_WritePrinter ( p , tctx , & w ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_WritePrinter failed " ) ;
torture_assert_werr_ok ( tctx , w . out . result , " WritePrinter failed " ) ;
2005-06-06 20:08:29 +04:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EndPagePrinter: Page[%d] \n " , i ) ;
2005-06-06 20:08:29 +04:00
ep . in . handle = handle ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EndPagePrinter ( p , tctx , & ep ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EndPagePrinter failed " ) ;
torture_assert_werr_ok ( tctx , ep . out . result , " EndPagePrinter failed " ) ;
2005-06-06 20:08:29 +04:00
}
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EndDocPrinter \n " ) ;
2005-06-06 19:03:16 +04:00
e . in . handle = handle ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EndDocPrinter ( p , tctx , & e ) ;
torture_assert_ntstatus_ok ( tctx , status , " dcerpc_spoolss_EndDocPrinter failed " ) ;
torture_assert_werr_ok ( tctx , e . out . result , " EndDocPrinter failed " ) ;
2005-06-06 19:03:16 +04:00
2007-09-03 17:13:25 +04:00
ret & = test_EnumJobs ( tctx , p , handle ) ;
2005-06-06 19:03:16 +04:00
2007-09-03 17:13:25 +04:00
ret & = test_SetJob ( tctx , p , handle , job_id , SPOOLSS_JOB_CONTROL_DELETE ) ;
2005-06-06 19:03:16 +04:00
return ret ;
}
2007-09-03 17:13:25 +04:00
static bool test_PausePrinter ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle )
2005-06-06 17:21:49 +04:00
{
NTSTATUS status ;
struct spoolss_SetPrinter r ;
r . in . handle = handle ;
r . in . level = 0 ;
r . in . info . info1 = NULL ;
r . in . devmode_ctr . devmode = NULL ;
r . in . secdesc_ctr . sd = NULL ;
r . in . command = SPOOLSS_PRINTER_CONTROL_PAUSE ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE \n " ) ;
2005-06-06 17:21:49 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_SetPrinter ( p , tctx , & r ) ;
2005-06-06 17:21:49 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " SetPrinter failed " ) ;
2005-06-06 17:21:49 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " SetPrinter failed " ) ;
2005-06-06 17:21:49 +04:00
2007-09-03 17:13:25 +04:00
return true ;
2005-06-06 17:21:49 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_ResumePrinter ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle )
2005-06-06 17:21:49 +04:00
{
NTSTATUS status ;
struct spoolss_SetPrinter r ;
r . in . handle = handle ;
r . in . level = 0 ;
r . in . info . info1 = NULL ;
r . in . devmode_ctr . devmode = NULL ;
r . in . secdesc_ctr . sd = NULL ;
r . in . command = SPOOLSS_PRINTER_CONTROL_RESUME ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME \n " ) ;
2005-06-06 17:21:49 +04:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_SetPrinter ( p , tctx , & r ) ;
2005-06-06 17:21:49 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " SetPrinter failed " ) ;
2005-06-06 17:21:49 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " SetPrinter failed " ) ;
2005-06-06 17:21:49 +04:00
2007-09-03 17:13:25 +04:00
return true ;
2005-06-06 17:21:49 +04:00
}
2007-09-03 17:13:25 +04:00
static bool test_GetPrinterData ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2004-10-28 17:40:50 +04:00
struct policy_handle * handle ,
const char * value_name )
2003-11-28 09:39:06 +03:00
{
NTSTATUS status ;
struct spoolss_GetPrinterData r ;
r . in . handle = handle ;
r . in . value_name = value_name ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-28 09:39:06 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing GetPrinterData \n " ) ;
2003-11-28 09:39:06 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinterData ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " GetPrinterData failed " ) ;
2003-11-28 09:39:06 +03:00
if ( W_ERROR_EQUAL ( r . out . result , WERR_MORE_DATA ) ) {
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2003-11-28 09:39:06 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinterData ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " GetPrinterData failed " ) ;
2005-02-25 08:39:01 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " GetPrinterData failed " ) ;
2003-11-28 09:39:06 +03:00
}
2007-09-03 17:13:25 +04:00
return true ;
2003-11-28 09:39:06 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_GetPrinterDataEx ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2004-10-28 17:40:50 +04:00
struct policy_handle * handle ,
const char * key_name ,
const char * value_name )
2003-11-28 14:50:33 +03:00
{
NTSTATUS status ;
struct spoolss_GetPrinterDataEx r ;
r . in . handle = handle ;
r . in . key_name = key_name ;
r . in . value_name = value_name ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-28 14:50:33 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing GetPrinterDataEx \n " ) ;
2003-11-28 14:50:33 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinterDataEx ( p , tctx , & r ) ;
2003-11-28 14:50:33 +03:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
2005-02-23 18:08:41 +03:00
if ( NT_STATUS_EQUAL ( status , NT_STATUS_NET_WRITE_FAULT ) & &
p - > last_fault_code = = DCERPC_FAULT_OP_RNG_ERROR ) {
2007-09-03 17:13:25 +04:00
torture_skip ( tctx , " GetPrinterDataEx not supported by server \n " ) ;
2005-02-23 18:08:41 +03:00
}
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " GetPrinterDataEx failed " ) ;
2003-11-28 14:50:33 +03:00
}
if ( W_ERROR_EQUAL ( r . out . result , WERR_MORE_DATA ) ) {
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2003-11-28 14:50:33 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinterDataEx ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " GetPrinterDataEx failed " ) ;
2005-02-25 08:39:01 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " GetPrinterDataEx failed " ) ;
2003-11-28 14:50:33 +03:00
}
2007-09-03 17:13:25 +04:00
return true ;
2003-11-28 14:50:33 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumPrinterData ( struct torture_context * tctx , struct dcerpc_pipe * p ,
2005-03-02 03:15:06 +03:00
struct policy_handle * handle )
2003-11-18 08:54:14 +03:00
{
NTSTATUS status ;
struct spoolss_EnumPrinterData r ;
r . in . handle = handle ;
r . in . enum_index = 0 ;
do {
2004-05-25 20:24:13 +04:00
uint32_t data_size ;
2003-11-18 08:54:14 +03:00
r . in . value_offered = 0 ;
data_size = 0 ;
r . in . data_size = & data_size ;
r . out . data_size = & data_size ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumPrinterData \n " ) ;
2003-11-18 08:54:14 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinterData ( p , tctx , & r ) ;
2003-11-18 08:54:14 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " EnumPrinterData failed " ) ;
2003-11-18 08:54:14 +03:00
r . in . value_offered = r . out . value_needed ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinterData ( p , tctx , & r ) ;
2003-11-18 08:54:14 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " EnumPrinterData failed " ) ;
2003-11-18 08:54:14 +03:00
2007-09-03 17:13:25 +04:00
test_GetPrinterData ( tctx , p , handle , r . out . value_name ) ;
2003-11-28 09:39:06 +03:00
2007-09-03 17:13:25 +04:00
test_GetPrinterDataEx ( tctx ,
p , handle , " PrinterDriverData " ,
2003-11-28 14:50:33 +03:00
r . out . value_name ) ;
2003-11-18 08:54:14 +03:00
r . in . enum_index + + ;
2003-11-28 09:39:06 +03:00
} while ( W_ERROR_IS_OK ( r . out . result ) ) ;
2003-11-18 08:54:14 +03:00
return True ;
}
2007-09-03 17:13:25 +04:00
static bool test_EnumPrinterDataEx ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2005-03-02 03:15:06 +03:00
struct policy_handle * handle )
{
NTSTATUS status ;
struct spoolss_EnumPrinterDataEx r ;
r . in . handle = handle ;
r . in . key_name = " PrinterDriverData " ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2005-03-02 03:15:06 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumPrinterDataEx \n " ) ;
2005-03-02 03:15:06 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinterDataEx ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " EnumPrinterDataEx failed " ) ;
2005-03-02 03:15:06 +03:00
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2005-03-02 03:15:06 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinterDataEx ( p , tctx , & r ) ;
2005-03-02 03:15:06 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " EnumPrinterDataEx failed " ) ;
2005-03-02 03:15:06 +03:00
2007-09-03 17:13:25 +04:00
return true ;
2005-03-02 03:15:06 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_DeletePrinterData ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2004-10-28 17:40:50 +04:00
struct policy_handle * handle ,
const char * value_name )
2003-11-28 13:34:58 +03:00
{
NTSTATUS status ;
struct spoolss_DeletePrinterData r ;
r . in . handle = handle ;
r . in . value_name = value_name ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing DeletePrinterData \n " ) ;
2003-11-28 13:34:58 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_DeletePrinterData ( p , tctx , & r ) ;
2003-11-28 13:34:58 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " DeletePrinterData failed " ) ;
2003-11-28 13:34:58 +03:00
2007-09-03 17:13:25 +04:00
return true ;
2003-11-28 13:34:58 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_SetPrinterData ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
struct policy_handle * handle )
2003-11-28 13:34:58 +03:00
{
NTSTATUS status ;
struct spoolss_SetPrinterData r ;
2004-10-28 17:40:50 +04:00
const char * value_name = " spottyfoot " ;
2003-11-28 13:34:58 +03:00
r . in . handle = handle ;
r . in . value_name = value_name ;
2005-06-06 13:59:43 +04:00
r . in . type = SPOOLSS_PRINTER_DATA_TYPE_STRING ;
r . in . data . string = " dog " ;
2003-11-28 13:34:58 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing SetPrinterData \n " ) ;
2003-11-28 13:34:58 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_SetPrinterData ( p , tctx , & r ) ;
2003-11-28 13:34:58 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " SetPrinterData failed " ) ;
2003-11-28 13:34:58 +03:00
2007-09-03 17:13:25 +04:00
if ( ! test_GetPrinterData ( tctx , p , handle , value_name ) ) {
return false ;
2005-06-06 13:59:43 +04:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_DeletePrinterData ( tctx , p , handle , value_name ) ) {
return false ;
2003-11-28 13:34:58 +03:00
}
2007-09-03 17:13:25 +04:00
return true ;
2003-11-28 13:34:58 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_SecondaryClosePrinter ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2004-01-20 09:07:09 +03:00
struct policy_handle * handle )
{
NTSTATUS status ;
r5902: A rather large change...
I wanted to add a simple 'workstation' argument to the DCERPC
authenticated binding calls, but this patch kind of grew from there.
With SCHANNEL, the 'workstation' name (the netbios name of the client)
matters, as this is what ties the session between the NETLOGON ops and
the SCHANNEL bind. This changes a lot of files, and these will again
be changed when jelmer does the credentials work.
I also correct some schannel IDL to distinguish between workstation
names and account names. The distinction matters for domain trust
accounts.
Issues in handling this (issues with lifetime of talloc pointers)
caused me to change the 'creds_CredentialsState' and 'struct
dcerpc_binding' pointers to always be talloc()ed pointers.
In the schannel DB, we now store both the domain and computername, and
query on both. This should ensure we fault correctly when the domain
is specified incorrectly in the SCHANNEL bind.
In the RPC-SCHANNEL test, I finally fixed a bug that vl pointed out,
where the comment claimed we re-used a connection, but in fact we made
a new connection.
This was achived by breaking apart some of the
dcerpc_secondary_connection() logic.
The addition of workstation handling was also propogated to NTLMSSP
and GENSEC, for completeness.
The RPC-SAMSYNC test has been cleaned up a little, using a loop over
usernames/passwords rather than manually expanded tests. This will be
expanded further (the code in #if 0 in this patch) to use a newly
created user account for testing.
In making this test pass test_rpc.sh, I found a bug in the RPC-ECHO
server, caused by the removal of [ref] and the assoicated pointer from
the IDL. This has been re-added, until the underlying pidl issues are
solved.
(This used to be commit 824289dcc20908ddec957a4a892a103eec2da9b9)
2005-03-19 11:34:43 +03:00
struct dcerpc_binding * b ;
2004-01-20 09:07:09 +03:00
struct dcerpc_pipe * p2 ;
2007-09-03 17:13:25 +04:00
bool ret = true ;
2004-01-20 09:07:09 +03:00
/* only makes sense on SMB */
2005-01-09 11:34:05 +03:00
if ( p - > conn - > transport . transport ! = NCACN_NP ) {
2004-01-20 09:07:09 +03:00
return True ;
}
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " testing close on secondary pipe \n " ) ;
2004-01-20 09:07:09 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_parse_binding ( tctx , p - > conn - > binding_string , & b ) ;
torture_assert_ntstatus_ok ( tctx , status , " Failed to parse dcerpc binding " ) ;
r5902: A rather large change...
I wanted to add a simple 'workstation' argument to the DCERPC
authenticated binding calls, but this patch kind of grew from there.
With SCHANNEL, the 'workstation' name (the netbios name of the client)
matters, as this is what ties the session between the NETLOGON ops and
the SCHANNEL bind. This changes a lot of files, and these will again
be changed when jelmer does the credentials work.
I also correct some schannel IDL to distinguish between workstation
names and account names. The distinction matters for domain trust
accounts.
Issues in handling this (issues with lifetime of talloc pointers)
caused me to change the 'creds_CredentialsState' and 'struct
dcerpc_binding' pointers to always be talloc()ed pointers.
In the schannel DB, we now store both the domain and computername, and
query on both. This should ensure we fault correctly when the domain
is specified incorrectly in the SCHANNEL bind.
In the RPC-SCHANNEL test, I finally fixed a bug that vl pointed out,
where the comment claimed we re-used a connection, but in fact we made
a new connection.
This was achived by breaking apart some of the
dcerpc_secondary_connection() logic.
The addition of workstation handling was also propogated to NTLMSSP
and GENSEC, for completeness.
The RPC-SAMSYNC test has been cleaned up a little, using a loop over
usernames/passwords rather than manually expanded tests. This will be
expanded further (the code in #if 0 in this patch) to use a newly
created user account for testing.
In making this test pass test_rpc.sh, I found a bug in the RPC-ECHO
server, caused by the removal of [ref] and the assoicated pointer from
the IDL. This has been re-added, until the underlying pidl issues are
solved.
(This used to be commit 824289dcc20908ddec957a4a892a103eec2da9b9)
2005-03-19 11:34:43 +03:00
status = dcerpc_secondary_connection ( p , & p2 , b ) ;
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " Failed to create secondary connection " ) ;
2004-01-20 09:07:09 +03:00
2007-08-20 01:23:03 +04:00
status = dcerpc_bind_auth_none ( p2 , & ndr_table_spoolss ) ;
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " Failed to create bind on secondary connection " ) ;
r5902: A rather large change...
I wanted to add a simple 'workstation' argument to the DCERPC
authenticated binding calls, but this patch kind of grew from there.
With SCHANNEL, the 'workstation' name (the netbios name of the client)
matters, as this is what ties the session between the NETLOGON ops and
the SCHANNEL bind. This changes a lot of files, and these will again
be changed when jelmer does the credentials work.
I also correct some schannel IDL to distinguish between workstation
names and account names. The distinction matters for domain trust
accounts.
Issues in handling this (issues with lifetime of talloc pointers)
caused me to change the 'creds_CredentialsState' and 'struct
dcerpc_binding' pointers to always be talloc()ed pointers.
In the schannel DB, we now store both the domain and computername, and
query on both. This should ensure we fault correctly when the domain
is specified incorrectly in the SCHANNEL bind.
In the RPC-SCHANNEL test, I finally fixed a bug that vl pointed out,
where the comment claimed we re-used a connection, but in fact we made
a new connection.
This was achived by breaking apart some of the
dcerpc_secondary_connection() logic.
The addition of workstation handling was also propogated to NTLMSSP
and GENSEC, for completeness.
The RPC-SAMSYNC test has been cleaned up a little, using a loop over
usernames/passwords rather than manually expanded tests. This will be
expanded further (the code in #if 0 in this patch) to use a newly
created user account for testing.
In making this test pass test_rpc.sh, I found a bug in the RPC-ECHO
server, caused by the removal of [ref] and the assoicated pointer from
the IDL. This has been re-added, until the underlying pidl issues are
solved.
(This used to be commit 824289dcc20908ddec957a4a892a103eec2da9b9)
2005-03-19 11:34:43 +03:00
2007-09-03 17:13:25 +04:00
if ( test_ClosePrinter ( tctx , p2 , handle ) ) {
torture_comment ( tctx , " ERROR: Allowed close on secondary connection! \n " ) ;
ret = false ;
2004-01-20 09:10:15 +03:00
}
2007-09-03 17:13:25 +04:00
torture_assert_int_equal ( tctx , p2 - > last_fault_code , DCERPC_FAULT_CONTEXT_MISMATCH ,
" Unexpected fault code " ) ;
2004-01-20 09:07:09 +03:00
2005-03-22 11:00:45 +03:00
talloc_free ( p2 ) ;
2004-01-20 09:07:09 +03:00
2007-09-03 17:13:25 +04:00
return true ;
2004-01-20 09:07:09 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_OpenPrinter_badname ( struct torture_context * tctx ,
struct dcerpc_pipe * p , const char * name )
2005-02-22 14:51:18 +03:00
{
NTSTATUS status ;
struct spoolss_OpenPrinter op ;
struct spoolss_OpenPrinterEx opEx ;
struct policy_handle handle ;
2007-09-03 17:13:25 +04:00
bool ret = true ;
2005-02-22 14:51:18 +03:00
op . in . printername = name ;
op . in . datatype = NULL ;
op . in . devmode_ctr . devmode = NULL ;
op . in . access_mask = 0 ;
op . out . handle = & handle ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " \n Testing OpenPrinter(%s) with bad name \n " , op . in . printername ) ;
2005-02-22 14:51:18 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_OpenPrinter ( p , tctx , & op ) ;
torture_assert_ntstatus_ok ( tctx , status , " OpenPrinter failed " ) ;
2005-02-22 14:51:18 +03:00
if ( ! W_ERROR_EQUAL ( WERR_INVALID_PRINTER_NAME , op . out . result ) ) {
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " OpenPrinter(%s) unexpected result[%s] should be WERR_INVALID_PRINTER_NAME \n " ,
2005-02-22 14:51:18 +03:00
name , win_errstr ( op . out . result ) ) ;
}
if ( W_ERROR_IS_OK ( op . out . result ) ) {
2007-09-03 17:13:25 +04:00
ret & = test_ClosePrinter ( tctx , p , & handle ) ;
2005-02-22 14:51:18 +03:00
}
opEx . in . printername = name ;
opEx . in . datatype = NULL ;
opEx . in . devmode_ctr . devmode = NULL ;
opEx . in . access_mask = 0 ;
opEx . in . level = 1 ;
opEx . in . userlevel . level1 = NULL ;
opEx . out . handle = & handle ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing OpenPrinterEx(%s) with bad name \n " , opEx . in . printername ) ;
2005-02-22 14:51:18 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_OpenPrinterEx ( p , tctx , & opEx ) ;
torture_assert_ntstatus_ok ( tctx , status , " OpenPrinter failed " ) ;
2005-02-22 14:51:18 +03:00
if ( ! W_ERROR_EQUAL ( WERR_INVALID_PRINTER_NAME , opEx . out . result ) ) {
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " OpenPrinterEx(%s) unexpected result[%s] should be WERR_INVALID_PRINTER_NAME \n " ,
2005-02-22 14:51:18 +03:00
name , win_errstr ( opEx . out . result ) ) ;
}
if ( W_ERROR_IS_OK ( opEx . out . result ) ) {
2007-09-03 17:13:25 +04:00
ret & = test_ClosePrinter ( tctx , p , & handle ) ;
2005-02-22 14:51:18 +03:00
}
return ret ;
}
2007-09-03 17:13:25 +04:00
static bool test_OpenPrinter ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2003-11-17 07:56:59 +03:00
const char * name )
2003-11-17 06:38:13 +03:00
{
NTSTATUS status ;
struct spoolss_OpenPrinter r ;
struct policy_handle handle ;
2003-11-17 07:56:59 +03:00
BOOL ret = True ;
2003-11-17 06:38:13 +03:00
2007-09-03 17:13:25 +04:00
r . in . printername = talloc_asprintf ( tctx , " \\ \\ %s \\ %s " , dcerpc_server_name ( p ) , name ) ;
2005-02-22 11:04:52 +03:00
r . in . datatype = NULL ;
r . in . devmode_ctr . devmode = NULL ;
r . in . access_mask = SEC_FLAG_MAXIMUM_ALLOWED ;
r . out . handle = & handle ;
2003-11-17 06:38:13 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing OpenPrinter(%s) \n " , r . in . printername ) ;
2003-11-17 06:38:13 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_OpenPrinter ( p , tctx , & r ) ;
2005-02-25 08:39:01 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " OpenPrinter failed " ) ;
2005-02-25 08:39:01 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " OpenPrinter failed " ) ;
2003-11-17 06:38:13 +03:00
2007-09-03 17:13:25 +04:00
if ( ! test_GetPrinter ( tctx , p , & handle ) ) {
ret = false ;
2003-11-17 07:56:59 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_SecondaryClosePrinter ( tctx , p , & handle ) ) {
ret = false ;
2004-01-20 09:07:09 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_ClosePrinter ( tctx , p , & handle ) ) {
ret = false ;
2003-11-17 07:56:59 +03:00
}
2005-02-22 11:04:52 +03:00
2003-11-22 14:49:22 +03:00
return ret ;
2003-11-17 07:56:59 +03:00
}
2007-09-03 17:13:25 +04:00
static bool call_OpenPrinterEx ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2003-11-30 14:57:40 +03:00
const char * name , struct policy_handle * handle )
2003-11-17 07:56:59 +03:00
{
struct spoolss_OpenPrinterEx r ;
struct spoolss_UserLevel1 userlevel1 ;
NTSTATUS status ;
2005-02-22 14:51:18 +03:00
if ( name & & name [ 0 ] ) {
2007-09-03 17:13:25 +04:00
r . in . printername = talloc_asprintf ( tctx , " \\ \\ %s \\ %s " ,
2003-11-30 14:57:40 +03:00
dcerpc_server_name ( p ) , name ) ;
2005-02-22 14:51:18 +03:00
} else {
2007-09-03 17:13:25 +04:00
r . in . printername = talloc_asprintf ( tctx , " \\ \\ %s " ,
2003-11-30 14:57:40 +03:00
dcerpc_server_name ( p ) ) ;
2005-02-22 14:51:18 +03:00
}
2003-11-30 14:57:40 +03:00
2005-02-22 14:51:18 +03:00
r . in . datatype = NULL ;
r . in . devmode_ctr . devmode = NULL ;
r . in . access_mask = SEC_FLAG_MAXIMUM_ALLOWED ;
r . in . level = 1 ;
r . in . userlevel . level1 = & userlevel1 ;
2003-11-30 14:57:40 +03:00
r . out . handle = handle ;
2003-11-17 07:56:59 +03:00
userlevel1 . size = 1234 ;
userlevel1 . client = " hello " ;
userlevel1 . user = " spottyfoot! " ;
userlevel1 . build = 1 ;
userlevel1 . major = 2 ;
userlevel1 . minor = 3 ;
userlevel1 . processor = 4 ;
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing OpenPrinterEx(%s) \n " , r . in . printername ) ;
2003-11-17 07:56:59 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_OpenPrinterEx ( p , tctx , & r ) ;
2003-11-17 07:56:59 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " OpenPrinterEx failed " ) ;
2003-11-30 14:57:40 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " OpenPrinterEx failed " ) ;
2003-11-17 07:56:59 +03:00
2007-09-03 17:13:25 +04:00
return true ;
2003-11-30 14:57:40 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_OpenPrinterEx ( struct torture_context * tctx ,
struct dcerpc_pipe * p ,
2003-11-30 14:57:40 +03:00
const char * name )
{
struct policy_handle handle ;
2007-09-03 17:13:25 +04:00
bool ret = true ;
2003-11-30 14:57:40 +03:00
2007-09-03 17:13:25 +04:00
if ( ! call_OpenPrinterEx ( tctx , p , name , & handle ) ) {
return false ;
2003-11-30 14:57:40 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_GetPrinter ( tctx , p , & handle ) ) {
ret = false ;
2003-11-17 07:56:59 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_EnumForms ( tctx , p , & handle , false ) ) {
ret = false ;
2003-11-26 09:26:18 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_AddForm ( tctx , p , & handle , false ) ) {
ret = false ;
2003-11-27 12:50:25 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_EnumPrinterData ( tctx , p , & handle ) ) {
ret = false ;
2003-11-18 08:54:14 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_EnumPrinterDataEx ( tctx , p , & handle ) ) {
ret = false ;
2005-03-02 03:15:06 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_PausePrinter ( tctx , p , & handle ) ) {
ret = false ;
2005-06-06 17:21:49 +04:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_DoPrintTest ( tctx , p , & handle ) ) {
ret = false ;
2003-11-28 08:02:32 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_ResumePrinter ( tctx , p , & handle ) ) {
ret = false ;
2005-06-06 17:21:49 +04:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_SetPrinterData ( tctx , p , & handle ) ) {
ret = false ;
2003-11-28 13:34:58 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_SecondaryClosePrinter ( tctx , p , & handle ) ) {
ret = false ;
2004-01-20 09:07:09 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_ClosePrinter ( tctx , p , & handle ) ) {
ret = false ;
2003-11-17 07:56:59 +03:00
}
2003-11-30 14:57:40 +03:00
2003-11-17 07:56:59 +03:00
return ret ;
2003-11-17 06:38:13 +03:00
}
2007-09-03 17:13:25 +04:00
static bool test_EnumPrinters_old ( struct torture_context * tctx , struct dcerpc_pipe * p )
2003-11-16 07:20:29 +03:00
{
struct spoolss_EnumPrinters r ;
NTSTATUS status ;
2004-05-25 21:24:24 +04:00
uint16_t levels [ ] = { 1 , 2 , 4 , 5 } ;
2003-11-16 16:49:14 +03:00
int i ;
2007-09-03 17:13:25 +04:00
bool ret = true ;
2003-11-16 07:20:29 +03:00
2003-11-16 16:49:14 +03:00
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
2003-11-17 07:56:59 +03:00
union spoolss_PrinterInfo * info ;
2003-11-17 05:18:11 +03:00
int j ;
2005-02-24 17:05:52 +03:00
r . in . flags = PRINTER_ENUM_LOCAL ;
r . in . server = " " ;
r . in . level = levels [ i ] ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-16 07:20:29 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumPrinters level %u \n " , r . in . level ) ;
2003-11-16 07:20:29 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinters ( p , tctx , & r ) ;
torture_assert_ntstatus_ok ( tctx , status , " EnumPrinters failed " ) ;
2005-02-24 17:05:52 +03:00
2003-11-17 05:58:10 +03:00
if ( W_ERROR_EQUAL ( r . out . result , WERR_INSUFFICIENT_BUFFER ) ) {
2007-09-03 17:13:25 +04:00
DATA_BLOB blob = data_blob_talloc ( tctx , NULL , r . out . needed ) ;
2003-11-17 05:18:11 +03:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinters ( p , tctx , & r ) ;
2003-11-16 16:49:14 +03:00
}
2005-02-24 17:05:52 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " EnumPrinters failed " ) ;
2005-02-25 08:39:01 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " EnumPrinters failed " ) ;
2003-11-16 14:36:59 +03:00
2005-02-21 16:54:06 +03:00
if ( ! r . out . info ) {
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " No printers returned \n " ) ;
return true ;
2003-11-18 12:19:34 +03:00
}
2005-05-31 02:44:17 +04:00
info = r . out . info ;
2003-11-17 06:38:13 +03:00
for ( j = 0 ; j < r . out . count ; j + + ) {
2003-11-17 07:56:59 +03:00
if ( r . in . level = = 1 ) {
/* the names appear to be comma-separated name lists? */
2007-09-03 17:13:25 +04:00
char * name = talloc_strdup ( tctx , info [ j ] . info1 . name ) ;
2003-11-17 07:56:59 +03:00
char * comma = strchr ( name , ' , ' ) ;
if ( comma ) * comma = 0 ;
2007-09-03 17:13:25 +04:00
if ( ! test_OpenPrinter ( tctx , p , name ) ) {
ret = false ;
2003-11-17 07:56:59 +03:00
}
2007-09-03 17:13:25 +04:00
if ( ! test_OpenPrinterEx ( tctx , p , name ) ) {
ret = false ;
2003-11-17 07:56:59 +03:00
}
2003-11-17 06:38:13 +03:00
}
}
2003-11-16 07:20:29 +03:00
}
2005-02-24 17:05:52 +03:00
2003-11-16 16:49:14 +03:00
return ret ;
2003-11-16 07:20:29 +03:00
}
2005-02-24 17:05:52 +03:00
#if 0
2007-09-03 17:13:25 +04:00
static BOOL test_GetPrinterDriver2 ( struct dcerpc_pipe * p ,
2004-10-28 17:40:50 +04:00
struct policy_handle * handle ,
const char * driver_name )
2003-11-30 14:57:40 +03:00
{
NTSTATUS status ;
struct spoolss_GetPrinterDriver2 r ;
r . in . handle = handle ;
r . in . architecture = " W32X86 " ;
r . in . level = 1 ;
2004-09-03 17:20:31 +04:00
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-30 14:57:40 +03:00
r . in . client_major_version = 0 ;
r . in . client_minor_version = 0 ;
printf ( " Testing GetPrinterDriver2 \n " ) ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinterDriver2 ( p , tctx , & r ) ;
2003-11-30 14:57:40 +03:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " GetPrinterDriver2 failed - %s \n " , nt_errstr ( status ) ) ;
return False ;
}
if ( W_ERROR_EQUAL ( r . out . result , WERR_INSUFFICIENT_BUFFER ) ) {
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_GetPrinterDriver2 ( p , tctx , & r ) ;
2003-11-30 14:57:40 +03:00
}
2005-02-25 08:39:01 +03:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
printf ( " GetPrinterDriver2 failed - %s \n " ,
nt_errstr ( status ) ) ;
return False ;
}
if ( ! W_ERROR_IS_OK ( r . out . result ) ) {
printf ( " GetPrinterDriver2 failed - %s \n " ,
win_errstr ( r . out . result ) ) ;
2003-11-30 14:57:40 +03:00
return False ;
}
return True ;
}
2005-02-24 17:05:52 +03:00
# endif
2005-04-02 10:51:54 +04:00
2007-09-03 17:13:25 +04:00
static bool test_EnumPrinterDrivers_old ( struct torture_context * tctx ,
struct dcerpc_pipe * p )
2003-11-30 14:57:40 +03:00
{
struct spoolss_EnumPrinterDrivers r ;
NTSTATUS status ;
2005-02-24 17:05:52 +03:00
uint16_t levels [ ] = { 1 , 2 , 3 , 4 , 5 , 6 } ;
2003-11-30 14:57:40 +03:00
int i ;
for ( i = 0 ; i < ARRAY_SIZE ( levels ) ; i + + ) {
2007-09-03 17:13:25 +04:00
r . in . server = talloc_asprintf ( tctx , " \\ \\ %s " , dcerpc_server_name ( p ) ) ;
2003-11-30 14:57:40 +03:00
r . in . environment = " Windows NT x86 " ;
r . in . level = levels [ i ] ;
r . in . buffer = NULL ;
2005-06-14 19:52:31 +04:00
r . in . offered = 0 ;
2003-11-30 14:57:40 +03:00
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " Testing EnumPrinterDrivers level %u \n " , r . in . level ) ;
2003-11-30 14:57:40 +03:00
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinterDrivers ( p , tctx , & r ) ;
2003-11-30 14:57:40 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " EnumPrinterDrivers failed " ) ;
2005-02-21 16:54:06 +03:00
2003-11-30 14:57:40 +03:00
if ( W_ERROR_EQUAL ( r . out . result , WERR_INSUFFICIENT_BUFFER ) ) {
2007-09-03 17:13:25 +04:00
DATA_BLOB blob = data_blob_talloc ( tctx , NULL , r . out . needed ) ;
2003-11-30 14:57:40 +03:00
data_blob_clear ( & blob ) ;
r . in . buffer = & blob ;
2005-06-14 19:52:31 +04:00
r . in . offered = r . out . needed ;
2007-09-03 17:13:25 +04:00
status = dcerpc_spoolss_EnumPrinterDrivers ( p , tctx , & r ) ;
2003-11-30 14:57:40 +03:00
}
2005-06-14 19:52:31 +04:00
2007-09-03 17:13:25 +04:00
torture_assert_ntstatus_ok ( tctx , status , " EnumPrinterDrivers failed " ) ;
2005-02-25 08:39:01 +03:00
2007-09-03 17:13:25 +04:00
torture_assert_werr_ok ( tctx , r . out . result , " EnumPrinterDrivers failed " ) ;
2003-11-30 14:57:40 +03:00
2005-02-21 16:54:06 +03:00
if ( ! r . out . info ) {
2007-09-03 17:13:25 +04:00
torture_comment ( tctx , " No printer drivers returned \n " ) ;
2005-02-21 16:54:06 +03:00
break ;
2003-11-30 14:57:40 +03:00
}
}
2005-02-21 16:54:06 +03:00
2007-09-03 17:13:25 +04:00
return true ;
}
/** Test that makes sure that calling ReplyOpenPrinter()
* on Samba 4 will cause an irpc broadcast call .
*/
static bool test_ReplyOpenPrinter ( struct torture_context * tctx ,
struct dcerpc_pipe * pipe )
{
struct spoolss_ReplyOpenPrinter r ;
struct spoolss_ReplyClosePrinter s ;
struct policy_handle h ;
r . in . server_name = " earth " ;
r . in . printer_local = 2 ;
r . in . type = REG_DWORD ;
r . in . unknown1 = 0 ;
r . in . unknown2 = 0 ;
r . out . handle = & h ;
torture_assert_ntstatus_ok ( tctx ,
dcerpc_spoolss_ReplyOpenPrinter ( pipe , tctx , & r ) ,
" spoolss_ReplyOpenPrinter call failed " ) ;
torture_assert_werr_ok ( tctx , r . out . result , " error return code " ) ;
s . in . handle = & h ;
s . out . handle = & h ;
torture_assert_ntstatus_ok ( tctx ,
dcerpc_spoolss_ReplyClosePrinter ( pipe , tctx , & s ) ,
" spoolss_ReplyClosePrinter call failed " ) ;
torture_assert_werr_ok ( tctx , r . out . result , " error return code " ) ;
return true ;
2003-11-30 14:57:40 +03:00
}
2007-08-28 16:54:27 +04:00
bool torture_rpc_spoolss ( struct torture_context * torture )
2003-11-15 08:42:49 +03:00
{
2007-09-03 17:13:25 +04:00
NTSTATUS status ;
struct dcerpc_pipe * p ;
2003-11-15 08:42:49 +03:00
BOOL ret = True ;
2005-04-02 10:51:54 +04:00
struct test_spoolss_context * ctx ;
2003-11-15 08:42:49 +03:00
2007-08-28 16:54:27 +04:00
status = torture_rpc_connection ( torture , & p , & ndr_table_spoolss ) ;
2003-11-15 08:42:49 +03:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
return False ;
}
2003-11-18 04:18:24 +03:00
2007-08-28 23:03:08 +04:00
ctx = talloc_zero ( torture , struct test_spoolss_context ) ;
2007-09-03 17:13:25 +04:00
ret & = test_OpenPrinter_server ( torture , p , ctx ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " W3SvcInstalled " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " BeepEnabled " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " EventLog " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " NetPopup " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " NetPopupToComputer " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " MajorVersion " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " MinorVersion " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " DefaultSpoolDirectory " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " Architecture " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " DsPresent " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " OSVersion " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " OSVersionEx " ) ;
ret & = test_GetPrinterData ( torture , p , & ctx - > server_handle , " DNSMachineName " ) ;
ret & = test_EnumForms ( torture , p , & ctx - > server_handle , true ) ;
ret & = test_AddForm ( torture , p , & ctx - > server_handle , true ) ;
ret & = test_EnumPorts ( torture , p , ctx ) ;
ret & = test_GetPrinterDriverDirectory ( torture , p , ctx ) ;
ret & = test_EnumPrinterDrivers ( torture , p , ctx ) ;
ret & = test_EnumMonitors ( torture , p , ctx ) ;
ret & = test_EnumPrintProcessors ( torture , p , ctx ) ;
ret & = test_EnumPrinters ( torture , p , ctx ) ;
ret & = test_OpenPrinter_badname ( torture , p , " __INVALID_PRINTER__ " ) ;
ret & = test_OpenPrinter_badname ( torture , p , " \\ \\ __INVALID_HOST__ " ) ;
ret & = test_OpenPrinter_badname ( torture , p , " " ) ;
ret & = test_OpenPrinter_badname ( torture , p , " \\ \\ \\ " ) ;
ret & = test_OpenPrinter_badname ( torture , p , " \\ \\ \\ __INVALID_PRINTER__ " ) ;
ret & = test_OpenPrinter_badname ( torture , p , talloc_asprintf ( torture , " \\ \\ %s \\ " , dcerpc_server_name ( p ) ) ) ;
ret & = test_OpenPrinter_badname ( torture , p ,
talloc_asprintf ( torture , " \\ \\ %s \\ __INVALID_PRINTER__ " , dcerpc_server_name ( p ) ) ) ;
ret & = test_AddPort ( torture , p ) ;
ret & = test_EnumPorts_old ( torture , p ) ;
ret & = test_EnumPrinters_old ( torture , p ) ;
ret & = test_EnumPrinterDrivers_old ( torture , p ) ;
ret & = test_ReplyOpenPrinter ( torture , p ) ;
2003-11-22 11:11:32 +03:00
2003-11-15 08:42:49 +03:00
return ret ;
}