From 3abce73193dcc393fee5ca6e326678009e87cbd7 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sat, 2 Apr 2005 06:51:54 +0000 Subject: r6179: - add new spoolss tests for all spoolss_Enum*() calls which didn't need a handle as parameter, EnumPorts EnumPrinterDrivers EnumMonitors EnumPrintProcessors EnumPrinters we now do cross checks between the different info levels and sore the results in a global context, so that we later can add cross checks between the different object types - add idl for EnumMonitors and EnumPrintProcessors metze (This used to be commit 92a3721bc7a28d521090b10eb3b1eed089036432) --- source4/torture/rpc/spoolss.c | 633 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 626 insertions(+), 7 deletions(-) (limited to 'source4/torture') diff --git a/source4/torture/rpc/spoolss.c b/source4/torture/rpc/spoolss.c index acaa5828dc..c2be0b5324 100644 --- a/source4/torture/rpc/spoolss.c +++ b/source4/torture/rpc/spoolss.c @@ -3,6 +3,7 @@ test suite for spoolss rpc operations Copyright (C) Tim Potter 2003 + Copyright (C) Stefan Metzmacher 2005 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -22,6 +23,610 @@ #include "includes.h" #include "librpc/gen_ndr/ndr_spoolss.h" +struct test_spoolss_context { + struct dcerpc_pipe *p; + + /* for EnumPorts */ + uint32_t port_count[3]; + union spoolss_PortInfo **ports[3]; + + /* for EnumPrinterDrivers */ + uint32_t driver_count[7]; + union spoolss_DriverInfo **drivers[7]; + + /* for EnumMonitors */ + uint32_t monitor_count[3]; + union spoolss_MonitorInfo **monitors[3]; + + /* for EnumPrintProcessors */ + uint32_t print_processor_count[2]; + union spoolss_PrintProcessorInfo **print_processors[2]; + + /* for EnumPrinters */ + uint32_t printer_count[6]; + union spoolss_PrinterInfo **printers[6]; +}; + +#define COMPARE_STRING(c,r,e) do {\ + BOOL _ok = True;\ + if (c.e && !r.e) _ok = False;\ + if (!c.e && r.e) _ok = False;\ + if (c.e && r.e && strcmp_safe(c.e, r.e) != 0) _ok = False;\ + if (!_ok){\ + printf("%s: " #c "." #e " [%s] doesn't match " #r "." #e " [%s]\n",\ + __location__, c.e, r.e);\ + ret = False;\ + }\ +} while(0) + +#define COMPARE_UINT16(c,r,e) do {\ + if (c.e != r.e){\ + printf("%s: " #c "." #e " 0x%08X (%u) doesn't match " #r "." #e " 0x%08X (%u)\n",\ + __location__, c.e, c.e, r.e, r.e);\ + ret = False;\ + }\ +} while(0) + +#define COMPARE_UINT32(c,r,e) do {\ + if (c.e != r.e){\ + printf("%s: " #c "." #e " 0x%04X (%u) doesn't match " #r "." #e " 0x%04X (%u)\n",\ + __location__, c.e, c.e, r.e, r.e);\ + ret = False;\ + }\ +} while(0) + +#define COMPARE_UINT64(c,r,e) do {\ + if (c.e != r.e){\ + printf("%s: " #c "." #e " 0x%08X%08X (%llu) doesn't match " #r "." #e " 0x%08X%08X (%llu)\n",\ + __location__, (uint32_t)(c.e >> 32), (uint32_t)(c.e & 0xFFFFFFFF), c.e,\ + (uint32_t)(r.e >> 32), (uint32_t)(r.e & 0xFFFFFFFF), r.e);\ + ret = False;\ + }\ +} while(0) + +/* TODO: ! */ +#define COMPARE_SEC_DESC(c,r,e) +#define COMPARE_SPOOLSS_TIME(c,r,e) +#define COMPARE_STRING_ARRAY(c,r,e) + +static BOOL test_EnumPorts(struct test_spoolss_context *ctx) +{ + NTSTATUS status; + struct spoolss_EnumPorts r; + uint16_t levels[] = { 1, 2 }; + int i, j; + BOOL ret = True; + + for (i=0;ip, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumPorts failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) { + printf("EnumPorts unexspected return code %s, should be WERR_INSUFFICIENT_BUFFER\n", + win_errstr(r.out.result)); + ret = False; + continue; + } + + blob = data_blob_talloc(ctx, NULL, buf_size); + data_blob_clear(&blob); + r.in.buffer = &blob; + + status = dcerpc_spoolss_EnumPorts(ctx->p, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumPorts failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_IS_OK(r.out.result)) { + printf("EnumPorts failed - %s\n", + win_errstr(r.out.result)); + ret = False; + continue; + } + + ctx->port_count[level] = r.out.count; + ctx->ports[level] = r.out.info; + } + + for (i=1;iport_count[level] != ctx->port_count[old_level]) { + printf("EnumPorts level[%d] returns [%u] ports, but level[%d] returns [%u]\n", + level, ctx->port_count[level], old_level, ctx->port_count[old_level]); + ret = False; + } + } + /* if the array sizes are not the same we would maybe segfault in the following code */ + if (!ret) return ret; + + for (i=0;iport_count[level];j++) { + union spoolss_PortInfo *cur = &ctx->ports[level][0][j]; + union spoolss_PortInfo *ref = &ctx->ports[2][0][j]; + switch (level) { + case 1: + COMPARE_STRING(cur->info1, ref->info2, port_name); + break; + case 2: + /* level 2 is our reference, and it makes no sense to compare it to itself */ + break; + } + } + } + + return True; +} + +static BOOL test_EnumPrinterDrivers(struct test_spoolss_context *ctx) +{ + NTSTATUS status; + struct spoolss_EnumPrinterDrivers r; + uint16_t levels[] = { 1, 2, 3, 4, 5, 6 }; + int i, j; + BOOL ret = True; + + for (i=0;ip, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumPrinterDrivers failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) { + printf("EnumPrinterDrivers unexspected return code %s, should be WERR_INSUFFICIENT_BUFFER\n", + win_errstr(r.out.result)); + ret = False; + continue; + } + + blob = data_blob_talloc(ctx, NULL, buf_size); + data_blob_clear(&blob); + r.in.buffer = &blob; + + status = dcerpc_spoolss_EnumPrinterDrivers(ctx->p, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumPrinterDrivers failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_IS_OK(r.out.result)) { + printf("EnumPrinterDrivers failed - %s\n", + win_errstr(r.out.result)); + ret = False; + continue; + } + + ctx->driver_count[level] = r.out.count; + ctx->drivers[level] = r.out.info; + } + + for (i=1;idriver_count[level] != ctx->driver_count[old_level]) { + printf("EnumPrinterDrivers level[%d] returns [%u] drivers, but level[%d] returns [%u]\n", + level, ctx->driver_count[level], old_level, ctx->driver_count[old_level]); + ret = False; + } + } + /* if the array sizes are not the same we would maybe segfault in the following code */ + if (!ret) return ret; + + for (i=0;idriver_count[level];j++) { + union spoolss_DriverInfo *cur = &ctx->drivers[level][0][j]; + union spoolss_DriverInfo *ref = &ctx->drivers[6][0][j]; + switch (level) { + case 1: + COMPARE_STRING(cur->info1, ref->info6, driver_name); + break; + case 2: + COMPARE_UINT32(cur->info2, ref->info6, version); + COMPARE_STRING(cur->info2, ref->info6, driver_name); + COMPARE_STRING(cur->info2, ref->info6, architecture); + COMPARE_STRING(cur->info2, ref->info6, driver_path); + COMPARE_STRING(cur->info2, ref->info6, data_file); + COMPARE_STRING(cur->info2, ref->info6, config_file); + break; + case 3: + COMPARE_UINT32(cur->info3, ref->info6, version); + COMPARE_STRING(cur->info3, ref->info6, driver_name); + COMPARE_STRING(cur->info3, ref->info6, architecture); + COMPARE_STRING(cur->info3, ref->info6, driver_path); + COMPARE_STRING(cur->info3, ref->info6, data_file); + COMPARE_STRING(cur->info3, ref->info6, config_file); + COMPARE_STRING(cur->info3, ref->info6, help_file); + COMPARE_STRING_ARRAY(cur->info3, ref->info6, dependent_files); + COMPARE_STRING(cur->info3, ref->info6, monitor_name); + COMPARE_STRING(cur->info3, ref->info6, default_datatype); + break; + case 4: + COMPARE_UINT32(cur->info4, ref->info6, version); + COMPARE_STRING(cur->info4, ref->info6, driver_name); + COMPARE_STRING(cur->info4, ref->info6, architecture); + COMPARE_STRING(cur->info4, ref->info6, driver_path); + COMPARE_STRING(cur->info4, ref->info6, data_file); + COMPARE_STRING(cur->info4, ref->info6, config_file); + COMPARE_STRING(cur->info4, ref->info6, help_file); + COMPARE_STRING_ARRAY(cur->info4, ref->info6, dependent_files); + COMPARE_STRING(cur->info4, ref->info6, monitor_name); + COMPARE_STRING(cur->info4, ref->info6, default_datatype); + COMPARE_STRING_ARRAY(cur->info4, ref->info6, previous_names); + break; + case 5: + COMPARE_UINT32(cur->info5, ref->info6, version); + COMPARE_STRING(cur->info5, ref->info6, driver_name); + COMPARE_STRING(cur->info5, ref->info6, architecture); + COMPARE_STRING(cur->info5, ref->info6, driver_path); + COMPARE_STRING(cur->info5, ref->info6, data_file); + COMPARE_STRING(cur->info5, ref->info6, config_file); + /*COMPARE_UINT32(cur->info5, ref->info6, driver_attributes);*/ + /*COMPARE_UINT32(cur->info5, ref->info6, config_version);*/ + /*TODO: ! COMPARE_UINT32(cur->info5, ref->info6, driver_version); */ + break; + case 6: + /* level 6 is our reference, and it makes no sense to compare it to itself */ + break; + } + } + } + + return ret; +} + +static BOOL test_EnumMonitors(struct test_spoolss_context *ctx) +{ + NTSTATUS status; + struct spoolss_EnumMonitors r; + uint16_t levels[] = { 1, 2 }; + int i, j; + BOOL ret = True; + + for (i=0;ip, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumMonitors failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) { + printf("EnumMonitors unexspected return code %s, should be WERR_INSUFFICIENT_BUFFER\n", + win_errstr(r.out.result)); + ret = False; + continue; + } + + blob = data_blob_talloc(ctx, NULL, buf_size); + data_blob_clear(&blob); + r.in.buffer = &blob; + + status = dcerpc_spoolss_EnumMonitors(ctx->p, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumMonitors failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_IS_OK(r.out.result)) { + printf("EnumMonitors failed - %s\n", + win_errstr(r.out.result)); + ret = False; + continue; + } + + ctx->monitor_count[level] = r.out.count; + ctx->monitors[level] = r.out.info; + } + + for (i=1;imonitor_count[level] != ctx->monitor_count[old_level]) { + printf("EnumMonitors level[%d] returns [%u] monitors, but level[%d] returns [%u]\n", + level, ctx->monitor_count[level], old_level, ctx->monitor_count[old_level]); + ret = False; + } + } + /* if the array sizes are not the same we would maybe segfault in the following code */ + if (!ret) return ret; + + for (i=0;imonitor_count[level];j++) { + union spoolss_MonitorInfo *cur = &ctx->monitors[level][0][j]; + union spoolss_MonitorInfo *ref = &ctx->monitors[2][0][j]; + switch (level) { + case 1: + COMPARE_STRING(cur->info1, ref->info2, monitor_name); + break; + case 2: + /* level 2 is our reference, and it makes no sense to compare it to itself */ + break; + } + } + } + + return ret; +} + +static BOOL test_EnumPrintProcessors(struct test_spoolss_context *ctx) +{ + NTSTATUS status; + struct spoolss_EnumPrintProcessors r; + uint16_t levels[] = { 1 }; + int i, j; + BOOL ret = True; + + for (i=0;ip, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumPrintProcessors failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) { + printf("EnumPrintProcessors unexspected return code %s, should be WERR_INSUFFICIENT_BUFFER\n", + win_errstr(r.out.result)); + ret = False; + continue; + } + + blob = data_blob_talloc(ctx, NULL, buf_size); + data_blob_clear(&blob); + r.in.buffer = &blob; + + status = dcerpc_spoolss_EnumPrintProcessors(ctx->p, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumPrintProcessors failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_IS_OK(r.out.result)) { + printf("EnumPrintProcessors failed - %s\n", + win_errstr(r.out.result)); + ret = False; + continue; + } + + ctx->print_processor_count[level] = r.out.count; + ctx->print_processors[level] = r.out.info; + } + + for (i=1;iprint_processor_count[level] != ctx->print_processor_count[old_level]) { + printf("EnumPrintProcessors level[%d] returns [%u] print_processors, but level[%d] returns [%u]\n", + level, ctx->print_processor_count[level], old_level, ctx->print_processor_count[old_level]); + ret = False; + } + } + /* if the array sizes are not the same we would maybe segfault in the following code */ + if (!ret) return ret; + + for (i=0;iprint_processor_count[level];j++) { +#if 0 + union spoolss_PrintProcessorInfo *cur = &ctx->print_processors[level][0][j]; + union spoolss_PrintProcessorInfo *ref = &ctx->print_processors[1][0][j]; +#endif + switch (level) { + case 1: + /* level 1 is our reference, and it makes no sense to compare it to itself */ + break; + } + } + } + + return ret; +} + +static BOOL test_EnumPrinters(struct test_spoolss_context *ctx) +{ + struct spoolss_EnumPrinters r; + NTSTATUS status; + uint16_t levels[] = { 0, 1, 2, 4, 5 }; + int i, j; + BOOL ret = True; + + for (i=0;ip, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumPrinters failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) { + printf("EnumPrinters unexspected return code %s, should be WERR_INSUFFICIENT_BUFFER\n", + win_errstr(r.out.result)); + ret = False; + continue; + } + + blob = data_blob_talloc(ctx, NULL, buf_size); + data_blob_clear(&blob); + r.in.buffer = &blob; + status = dcerpc_spoolss_EnumPrinters(ctx->p, ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + printf("dcerpc_spoolss_EnumPrinters failed - %s\n", nt_errstr(status)); + ret = False; + continue; + } + + if (!W_ERROR_IS_OK(r.out.result)) { + printf("EnumPrinters failed - %s\n", + win_errstr(r.out.result)); + continue; + } + + ctx->printer_count[level] = r.out.count; + ctx->printers[level] = r.out.info; + } + + for (i=1;iprinter_count[level] != ctx->printer_count[old_level]) { + printf("EnumPrinters level[%d] returns [%u] printers, but level[%d] returns [%u]\n", + level, ctx->printer_count[level], old_level, ctx->printer_count[old_level]); + ret = False; + } + } + /* if the array sizes are not the same we would maybe segfault in the following code */ + if (!ret) return ret; + + for (i=0;iprinter_count[level];j++) { + union spoolss_PrinterInfo *cur = &ctx->printers[level][0][j]; + union spoolss_PrinterInfo *ref = &ctx->printers[2][0][j]; + switch (level) { + case 0: + COMPARE_STRING(cur->info0, ref->info2, printername); + COMPARE_STRING(cur->info0, ref->info2, servername); + COMPARE_UINT32(cur->info0, ref->info2, cjobs); + /*COMPARE_UINT32(cur->info0, ref->info2, total_jobs); + COMPARE_UINT32(cur->info0, ref->info2, total_bytes); + COMPARE_SPOOLSS_TIME(cur->info0, ref->info2, spoolss_Time time); + COMPARE_UINT32(cur->info0, ref->info2, global_counter); + COMPARE_UINT32(cur->info0, ref->info2, total_pages); + COMPARE_UINT32(cur->info0, ref->info2, version); + COMPARE_UINT32(cur->info0, ref->info2, unknown10); + COMPARE_UINT32(cur->info0, ref->info2, unknown11); + COMPARE_UINT32(cur->info0, ref->info2, unknown12); + COMPARE_UINT32(cur->info0, ref->info2, session_counter); + COMPARE_UINT32(cur->info0, ref->info2, unknown14); + COMPARE_UINT32(cur->info0, ref->info2, printer_errors); + COMPARE_UINT32(cur->info0, ref->info2, unknown16); + COMPARE_UINT32(cur->info0, ref->info2, unknown17); + COMPARE_UINT32(cur->info0, ref->info2, unknown18); + COMPARE_UINT32(cur->info0, ref->info2, unknown19); + COMPARE_UINT32(cur->info0, ref->info2, change_id); + COMPARE_UINT32(cur->info0, ref->info2, unknown21);*/ + COMPARE_UINT32(cur->info0, ref->info2, status); + /*COMPARE_UINT32(cur->info0, ref->info2, unknown23); + COMPARE_UINT32(cur->info0, ref->info2, c_setprinter); + COMPARE_UINT16(cur->info0, ref->info2, unknown25); + COMPARE_UINT16(cur->info0, ref->info2, unknown26); + COMPARE_UINT32(cur->info0, ref->info2, unknown27); + COMPARE_UINT32(cur->info0, ref->info2, unknown28); + COMPARE_UINT32(cur->info0, ref->info2, unknown29);*/ + break; + case 1: + /*COMPARE_UINT32(cur->info1, ref->info2, flags);*/ + /*COMPARE_STRING(cur->info1, ref->info2, name);*/ + /*COMPARE_STRING(cur->info1, ref->info2, description);*/ + COMPARE_STRING(cur->info1, ref->info2, comment); + break; + case 2: + /* level 2 is our reference, and it makes no sense to compare it to itself */ + break; + case 4: + COMPARE_STRING(cur->info4, ref->info2, printername); + COMPARE_STRING(cur->info4, ref->info2, servername); + COMPARE_UINT32(cur->info4, ref->info2, attributes); + break; + case 5: + COMPARE_STRING(cur->info5, ref->info2, printername); + COMPARE_STRING(cur->info5, ref->info2, portname); + COMPARE_UINT32(cur->info5, ref->info2, attributes); + /*COMPARE_UINT32(cur->info5, ref->info2, device_not_selected_timeout); + COMPARE_UINT32(cur->info5, ref->info2, transmission_retry_timeout);*/ + break; + } + } + } + + /* TODO: + * - verify that the port of a printer was in the list returned by EnumPorts + */ + + return ret; +} + static BOOL test_GetPrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *handle) { @@ -284,7 +889,7 @@ static BOOL test_AddForm(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, return ret; } -static BOOL test_EnumPorts(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) +static BOOL test_EnumPorts_old(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct spoolss_EnumPorts r; @@ -975,7 +1580,7 @@ static BOOL test_OpenPrinterEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, return ret; } -static BOOL test_EnumPrinters(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) +static BOOL test_EnumPrinters_old(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { struct spoolss_EnumPrinters r; NTSTATUS status; @@ -1095,8 +1700,8 @@ static BOOL test_GetPrinterDriver2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, return True; } #endif - -static BOOL test_EnumPrinterDrivers(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) + +static BOOL test_EnumPrinterDrivers_old(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { struct spoolss_EnumPrinterDrivers r; NTSTATUS status; @@ -1164,6 +1769,7 @@ BOOL torture_rpc_spoolss(void) struct dcerpc_pipe *p; TALLOC_CTX *mem_ctx; BOOL ret = True; + struct test_spoolss_context *ctx; mem_ctx = talloc_init("torture_rpc_spoolss"); @@ -1177,15 +1783,28 @@ BOOL torture_rpc_spoolss(void) return False; } + ctx = talloc_zero(mem_ctx, struct test_spoolss_context); + ctx->p = p; + + ret &= test_EnumPorts(ctx); + + ret &= test_EnumPrinterDrivers(ctx); + + ret &= test_EnumMonitors(ctx); + + ret &= test_EnumPrintProcessors(ctx); + + ret &= test_EnumPrinters(ctx); + ret &= test_OpenPrinter_badnames(p, mem_ctx); ret &= test_AddPort(p, mem_ctx); - ret &= test_EnumPorts(p, mem_ctx); + ret &= test_EnumPorts_old(p, mem_ctx); - ret &= test_EnumPrinters(p, mem_ctx); + ret &= test_EnumPrinters_old(p, mem_ctx); - ret &= test_EnumPrinterDrivers(p, mem_ctx); + ret &= test_EnumPrinterDrivers_old(p, mem_ctx); talloc_free(mem_ctx); -- cgit