test suite for spoolss rpc operations
Copyright (C) Tim Potter 2003
+ Copyright (C) Stefan Metzmacher 2005
+ Copyright (C) Jelmer Vernooij 2007
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
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
-#include "librpc/gen_ndr/ndr_spoolss.h"
+#include "torture/torture.h"
+#include "torture/rpc/rpc.h"
+#include "librpc/gen_ndr/ndr_spoolss_c.h"
+
+struct test_spoolss_context {
+ /* print server handle */
+ struct policy_handle server_handle;
+
+ /* 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(tctx, c,r,e) \
+ torture_assert_str_equal(tctx, c.e, r.e, "invalid value")
+
+/* not every compiler supports __typeof__() */
+#if (__GNUC__ >= 3)
+#define _CHECK_FIELD_SIZE(c,r,e,type) do {\
+ if (sizeof(__typeof__(c.e)) != sizeof(type)) { \
+ torture_fail(tctx, #c "." #e "field is not " #type "\n"); \
+ }\
+ if (sizeof(__typeof__(r.e)) != sizeof(type)) { \
+ torture_fail(tctx, #r "." #e "field is not " #type "\n"); \
+ }\
+} while(0)
+#else
+#define _CHECK_FIELD_SIZE(c,r,e,type) do {} while(0)
+#endif
+
+#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"); \
+} while(0)
+
+#define COMPARE_STRING_ARRAY(tctx, c,r,e)
+
+static bool test_OpenPrinter_server(struct torture_context *tctx, struct dcerpc_pipe *p, struct test_spoolss_context *ctx)
+{
+ NTSTATUS status;
+ struct spoolss_OpenPrinter op;
+
+ op.in.printername = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p));
+ op.in.datatype = NULL;
+ op.in.devmode_ctr.devmode= NULL;
+ op.in.access_mask = 0;
+ op.out.handle = &ctx->server_handle;
+
+ torture_comment(tctx, "Testing OpenPrinter(%s)\n", op.in.printername);
+
+ 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");
+
+ return true;
+}
+
+static bool test_EnumPorts(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct test_spoolss_context *ctx)
+{
+ 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;
+ r.in.offered = 0;
+
+ torture_comment(tctx, "Testing EnumPorts level %u\n", r.in.level);
+
+ status = dcerpc_spoolss_EnumPorts(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
+ if (W_ERROR_IS_OK(r.out.result)) {
+ /* TODO: do some more checks here */
+ continue;
+ }
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ "EnumPorts unexpected return code");
+
+ blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ data_blob_clear(&blob);
+ r.in.buffer = &blob;
+ r.in.offered = r.out.needed;
+
+ status = dcerpc_spoolss_EnumPorts(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPorts failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "EnumPorts failed");
+
+ 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];
+ torture_assert_int_equal(tctx, ctx->port_count[level], ctx->port_count[old_level],
+ "EnumPorts invalid value");
+ }
+ /* 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++) {
+ union spoolss_PortInfo *cur = &ctx->ports[level][j];
+ union spoolss_PortInfo *ref = &ctx->ports[2][j];
+ switch (level) {
+ case 1:
+ COMPARE_STRING(tctx, 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_GetPrinterDriverDirectory(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct test_spoolss_context *ctx)
+{
+ NTSTATUS status;
+ struct spoolss_GetPrinterDriverDirectory r;
+ struct {
+ uint16_t level;
+ const char *server;
+ } levels[] = {{
+ .level = 1,
+ .server = NULL
+ },{
+ .level = 1,
+ .server = ""
+ },{
+ .level = 78,
+ .server = ""
+ },{
+ .level = 1,
+ .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
+ },{
+ .level = 1024,
+ .server = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p))
+ }
+ };
+ int i;
+ uint32_t needed;
+
+ 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;
+ r.out.needed = &needed;
+
+ torture_comment(tctx, "Testing GetPrinterDriverDirectory level %u\n", r.in.level);
+
+ 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");
+
+ blob = data_blob_talloc(ctx, NULL, needed);
+ data_blob_clear(&blob);
+ r.in.buffer = &blob;
+ r.in.offered = needed;
+
+ status = dcerpc_spoolss_GetPrinterDriverDirectory(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrinterDriverDirectory failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDriverDirectory failed");
+ }
+
+ return true;
+}
+
+static bool test_EnumPrinterDrivers(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct test_spoolss_context *ctx)
+{
+ 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;
+
+ r.in.server = "";
+ r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
+ r.in.level = level;
+ r.in.buffer = NULL;
+ r.in.offered = 0;
+
+ torture_comment(tctx, "Testing EnumPrinterDrivers level %u\n", r.in.level);
+
+ status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status,
+ "dcerpc_spoolss_EnumPrinterDrivers failed");
+ if (W_ERROR_IS_OK(r.out.result)) {
+ /* TODO: do some more checks here */
+ continue;
+ }
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ "EnumPrinterDrivers failed");
+
+ blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ data_blob_clear(&blob);
+ r.in.buffer = &blob;
+ r.in.offered = r.out.needed;
+
+ status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinterDrivers failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
+
+ 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];
+ torture_assert_int_equal(tctx, ctx->driver_count[level], ctx->driver_count[old_level],
+ "EnumPrinterDrivers invalid value");
+ }
+
+ for (i=0;i<ARRAY_SIZE(levels);i++) {
+ int level = levels[i];
+ for (j=0;j<ctx->driver_count[level];j++) {
+ union spoolss_DriverInfo *cur = &ctx->drivers[level][j];
+ union spoolss_DriverInfo *ref = &ctx->drivers[6][j];
+ switch (level) {
+ case 1:
+ COMPARE_STRING(tctx, cur->info1, ref->info6, driver_name);
+ break;
+ case 2:
+ 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);
+ break;
+ case 3:
+ 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);
+ break;
+ case 4:
+ 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);
+ break;
+ case 5:
+ 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); */
+ break;
+ case 6:
+ /* level 6 is our reference, and it makes no sense to compare it to itself */
+ break;
+ }
+ }
+ }
+
+ return true;
+}
+
+static bool test_EnumMonitors(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct test_spoolss_context *ctx)
+{
+ 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;
+ r.in.offered = 0;
+
+ torture_comment(tctx, "Testing EnumMonitors level %u\n", r.in.level);
+
+ status = dcerpc_spoolss_EnumMonitors(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
+ if (W_ERROR_IS_OK(r.out.result)) {
+ /* TODO: do some more checks here */
+ continue;
+ }
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ "EnumMonitors failed");
+
+ blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ data_blob_clear(&blob);
+ r.in.buffer = &blob;
+ r.in.offered = r.out.needed;
+
+ status = dcerpc_spoolss_EnumMonitors(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumMonitors failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "EnumMonitors failed");
+
+ ctx->monitor_count[level] = r.out.count;
+ ctx->monitors[level] = r.out.info;
+ }
-static BOOL test_GetPrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+ for (i=1;i<ARRAY_SIZE(levels);i++) {
+ int level = levels[i];
+ int old_level = levels[i-1];
+ torture_assert_int_equal(tctx, ctx->monitor_count[level], ctx->monitor_count[old_level],
+ "EnumMonitors invalid value");
+ }
+
+ for (i=0;i<ARRAY_SIZE(levels);i++) {
+ int level = levels[i];
+ for (j=0;j<ctx->monitor_count[level];j++) {
+ union spoolss_MonitorInfo *cur = &ctx->monitors[level][j];
+ union spoolss_MonitorInfo *ref = &ctx->monitors[2][j];
+ switch (level) {
+ case 1:
+ COMPARE_STRING(tctx, 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 true;
+}
+
+static bool test_EnumPrintProcessors(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct test_spoolss_context *ctx)
+{
+ 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;
+ r.in.offered = 0;
+
+ torture_comment(tctx, "Testing EnumPrintProcessors level %u\n", r.in.level);
+
+ status = dcerpc_spoolss_EnumPrintProcessors(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
+ if (W_ERROR_IS_OK(r.out.result)) {
+ /* TODO: do some more checks here */
+ continue;
+ }
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ "EnumPrintProcessors unexpected return code");
+
+ blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ data_blob_clear(&blob);
+ r.in.buffer = &blob;
+ r.in.offered = r.out.needed;
+
+ status = dcerpc_spoolss_EnumPrintProcessors(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcessors failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcessors failed");
+
+ 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];
+ torture_assert_int_equal(tctx, ctx->print_processor_count[level], ctx->print_processor_count[old_level],
+ "EnumPrintProcessors failed");
+ }
+
+ for (i=0;i<ARRAY_SIZE(levels);i++) {
+ int level = levels[i];
+ for (j=0;j<ctx->print_processor_count[level];j++) {
+#if 0
+ union spoolss_PrintProcessorInfo *cur = &ctx->print_processors[level][j];
+ union spoolss_PrintProcessorInfo *ref = &ctx->print_processors[1][j];
+#endif
+ switch (level) {
+ case 1:
+ /* level 1 is our reference, and it makes no sense to compare it to itself */
+ break;
+ }
+ }
+ }
+
+ return true;
+}
+
+static bool test_EnumPrinters(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct test_spoolss_context *ctx)
+{
+ 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;
+ r.in.offered = 0;
+
+ torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
+
+ status = dcerpc_spoolss_EnumPrinters(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
+ if (W_ERROR_IS_OK(r.out.result)) {
+ /* TODO: do some more checks here */
+ continue;
+ }
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ "EnumPrinters unexpected return code");
+
+ blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ data_blob_clear(&blob);
+ r.in.buffer = &blob;
+ r.in.offered = r.out.needed;
+
+ status = dcerpc_spoolss_EnumPrinters(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinters failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
+
+ 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];
+ torture_assert_int_equal(tctx, ctx->printer_count[level], ctx->printer_count[old_level],
+ "EnumPrinters invalid value");
+ }
+
+ for (i=0;i<ARRAY_SIZE(levels);i++) {
+ int level = levels[i];
+ for (j=0;j<ctx->printer_count[level];j++) {
+ union spoolss_PrinterInfo *cur = &ctx->printers[level][j];
+ union spoolss_PrinterInfo *ref = &ctx->printers[2][j];
+ switch (level) {
+ case 0:
+ 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);
+ COMPARE_SPOOLSS_TIME(cur->info0, ref->info2, spoolss_Time time);
+ 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);
+ COMPARE_UINT16(cur->info0, ref->info2, unknown25);
+ COMPARE_UINT16(cur->info0, ref->info2, unknown26);
+ COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown27);
+ COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown28);
+ COMPARE_UINT32(tctx, cur->info0, ref->info2, unknown29);*/
+ break;
+ case 1:
+ /*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);
+ break;
+ case 2:
+ /* level 2 is our reference, and it makes no sense to compare it to itself */
+ break;
+ case 4:
+ COMPARE_STRING(tctx, cur->info4, ref->info2, printername);
+ COMPARE_STRING(tctx, cur->info4, ref->info2, servername);
+ COMPARE_UINT32(tctx, cur->info4, ref->info2, attributes);
+ break;
+ case 5:
+ 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);*/
+ break;
+ }
+ }
+ }
+
+ /* TODO:
+ * - verify that the port of a printer was in the list returned by EnumPorts
+ */
+
+ return true;
+}
+
+static bool test_GetPrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_GetPrinter r;
- uint16_t levels[] = {1, 2, 3, 4, 5, 6, 7};
+ uint16_t levels[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
int i;
- BOOL ret = True;
+ uint32_t needed;
for (i=0;i<ARRAY_SIZE(levels);i++) {
- uint32_t buf_size = 0;
r.in.handle = handle;
r.in.level = levels[i];
r.in.buffer = NULL;
- r.in.buf_size = &buf_size;
- r.out.buf_size = &buf_size;
+ r.in.offered = 0;
+ r.out.needed = &needed;
- printf("Testing GetPrinter level %u\n", r.in.level);
+ torture_comment(tctx, "Testing GetPrinter level %u\n", r.in.level);
- status = dcerpc_spoolss_GetPrinter(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("GetPrinter failed - %s\n", nt_errstr(status));
- ret = False;
- continue;
- }
+ status = dcerpc_spoolss_GetPrinter(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- status = dcerpc_spoolss_GetPrinter(p, mem_ctx, &r);
+ r.in.offered = needed;
+ status = dcerpc_spoolss_GetPrinter(p, tctx, &r);
}
- if (!NT_STATUS_IS_OK(status) ||
- !W_ERROR_IS_OK(r.out.result)) {
- printf("GetPrinter failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- ret = False;
- continue;
- }
+ torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
}
- return ret;
+ return true;
}
-static BOOL test_ClosePrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_ClosePrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_ClosePrinter r;
r.in.handle = handle;
r.out.handle = handle;
- printf("Testing ClosePrinter\n");
+ torture_comment(tctx, "Testing ClosePrinter\n");
- status = dcerpc_spoolss_ClosePrinter(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("ClosePrinter failed - %s\n", nt_errstr(status));
- return False;
- }
+ status = dcerpc_spoolss_ClosePrinter(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "ClosePrinter failed");
- return True;
+ return true;
}
-static BOOL test_GetForm(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_GetForm(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle,
- const char *formname)
+ const char *form_name)
{
NTSTATUS status;
struct spoolss_GetForm r;
- uint32_t buf_size;
r.in.handle = handle;
- r.in.formname = formname;
+ r.in.form_name = form_name;
r.in.level = 1;
r.in.buffer = NULL;
- buf_size = 0;
- r.in.buf_size = r.out.buf_size = &buf_size;
+ r.in.offered = 0;
- printf("Testing GetForm\n");
+ torture_comment(tctx, "Testing GetForm\n");
- status = dcerpc_spoolss_GetForm(p, mem_ctx, &r);
-
- if (!NT_STATUS_IS_OK(status)) {
- printf("GetForm failed - %s\n", nt_errstr(status));
- return False;
- }
+ status = dcerpc_spoolss_GetForm(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
-
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
+ r.in.offered = r.out.needed;
+ status = dcerpc_spoolss_GetForm(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
- status = dcerpc_spoolss_GetForm(p, mem_ctx, &r);
+ torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
- if (!r.out.info) {
- printf("No form info returned");
- return False;
- }
+ torture_assert(tctx, r.out.info, "No form info returned");
}
- return True;
+ torture_assert_werr_ok(tctx, r.out.result, "GetForm failed");
+
+ return true;
}
-static BOOL test_EnumForms(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_EnumForms(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle, bool print_server)
{
NTSTATUS status;
struct spoolss_EnumForms r;
- uint32_t buf_size;
+ bool ret = true;
r.in.handle = handle;
r.in.level = 1;
r.in.buffer = NULL;
- buf_size = 0;
- r.in.buf_size = &buf_size;
- r.out.buf_size = &buf_size;
+ r.in.offered = 0;
- printf("Testing EnumForms\n");
+ torture_comment(tctx, "Testing EnumForms\n");
- status = dcerpc_spoolss_EnumForms(p, mem_ctx, &r);
+ status = dcerpc_spoolss_EnumForms(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
- if (!NT_STATUS_IS_OK(status)) {
- printf("EnumForms failed - %s\n", nt_errstr(status));
- return False;
- }
+ 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)");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
union spoolss_FormInfo *info;
int j;
-
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
+ r.in.offered = r.out.needed;
- status = dcerpc_spoolss_EnumForms(p, mem_ctx, &r);
+ status = dcerpc_spoolss_EnumForms(p, tctx, &r);
- if (!r.out.info) {
- printf("No forms returned");
- return False;
- }
+ torture_assert(tctx, r.out.info, "No forms returned");
- info = *r.out.info;
+ info = r.out.info;
for (j = 0; j < r.out.count; j++) {
- test_GetForm(p, mem_ctx, handle, info[j].info1.formname);
+ if (!print_server)
+ ret &= test_GetForm(tctx, p, handle, info[j].info1.form_name);
}
}
- if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
- printf("EnumForms failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
- return True;
+ return true;
}
-static BOOL test_DeleteForm(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_DeleteForm(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle,
- const char *formname)
+ const char *form_name)
{
NTSTATUS status;
struct spoolss_DeleteForm r;
r.in.handle = handle;
- r.in.formname = formname;
+ r.in.form_name = form_name;
- status = dcerpc_spoolss_DeleteForm(p, mem_ctx, &r);
+ status = dcerpc_spoolss_DeleteForm(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
- printf("DeleteForm failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "DeleteForm failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "DeleteForm failed");
- return True;
+ return true;
}
-static BOOL test_AddForm(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_AddForm(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle, bool print_server)
{
struct spoolss_AddForm r;
- struct spoolss_AddFormInfo1 form;
+ struct spoolss_AddFormInfo1 addform;
+ const char *form_name = "testform3";
NTSTATUS status;
- const char *formname = "testform3";
- BOOL ret = True;
+ bool ret = true;
- r.in.handle = handle;
- r.in.level = 1;
- form.flags = 2; /* User form */
- form.formname = formname;
- form.width = 1;
- form.length = 2;
- form.left = 3;
- form.top = 4;
- form.right = 5;
- form.bottom = 6;
- r.in.info.info1 = &form;
-
- status = dcerpc_spoolss_AddForm(p, mem_ctx, &r);
+ 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;
- if (!NT_STATUS_IS_OK(status)) {
- printf("AddForm failed - %s\n", nt_errstr(status));
- return False;
- }
+ status = dcerpc_spoolss_AddForm(p, tctx, &r);
- if (!W_ERROR_IS_OK(r.out.result)) {
- printf("AddForm failed - %s\n", nt_errstr(status));
- goto done;
- }
+ torture_assert_ntstatus_ok(tctx, status, "AddForm failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "AddForm failed");
+
+ if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name);
{
struct spoolss_SetForm sf;
+ struct spoolss_AddFormInfo1 setform;
- sf.in.handle = handle;
- sf.in.formname = formname;
- sf.in.level = 1;
- sf.in.info.info1 = &form;
- form.width = 1234;
+ 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;
- status = dcerpc_spoolss_SetForm(p, mem_ctx, &sf);
+ setform.size.width = 1234;
- if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
- printf("SetForm failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- ret = False;
- /* Fall through to delete */
- }
+ status = dcerpc_spoolss_SetForm(p, tctx, &sf);
+
+ torture_assert_ntstatus_ok(tctx, status, "SetForm failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "SetForm failed");
}
- done:
- if (!test_DeleteForm(p, mem_ctx, handle, formname)) {
- printf("DeleteForm failed\n");
- ret = False;
+ if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name);
+
+ if (!test_DeleteForm(tctx, p, handle, form_name)) {
+ ret = false;
}
return ret;
}
-static BOOL test_EnumPorts(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_EnumPorts_old(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
NTSTATUS status;
struct spoolss_EnumPorts r;
- uint32_t buf_size;
- r.in.servername = talloc_asprintf(mem_ctx, "\\\\%s",
+ r.in.servername = talloc_asprintf(tctx, "\\\\%s",
dcerpc_server_name(p));
r.in.level = 2;
r.in.buffer = NULL;
- buf_size = 0;
- r.in.buf_size = &buf_size;
- r.out.buf_size = &buf_size;
+ r.in.offered = 0;
- printf("Testing EnumPorts\n");
+ torture_comment(tctx, "Testing EnumPorts\n");
- status = dcerpc_spoolss_EnumPorts(p, mem_ctx, &r);
+ status = dcerpc_spoolss_EnumPorts(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("EnumPorts failed -- %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
-
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
+ r.in.offered = r.out.needed;
- status = dcerpc_spoolss_EnumPorts(p, mem_ctx, &r);
+ status = dcerpc_spoolss_EnumPorts(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
- if (!NT_STATUS_IS_OK(status)) {
- printf("EnumPorts failed -- %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert(tctx, r.out.info, "No ports returned");
+ }
- if (!r.out.info) {
- printf("No ports returned");
- return False;
- }
+ return true;
+}
+
+static bool test_AddPort(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
+{
+ NTSTATUS status;
+ struct spoolss_AddPort r;
+
+ r.in.server_name = talloc_asprintf(tctx, "\\\\%s",
+ dcerpc_server_name(p));
+ r.in.unknown = 0;
+ r.in.monitor_name = "foo";
+
+ torture_comment(tctx, "Testing AddPort\n");
+
+ status = dcerpc_spoolss_AddPort(p, tctx, &r);
+
+ torture_assert_ntstatus_ok(tctx, status, "AddPort failed");
+
+ /* 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;
}
- return True;
+#endif
+
+ return true;
}
-static BOOL test_GetJob(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle, uint32_t job_id)
+static bool test_GetJob(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle, uint32_t job_id)
{
NTSTATUS status;
struct spoolss_GetJob r;
- uint32_t buf_size;
+ uint32_t needed;
r.in.handle = handle;
r.in.job_id = job_id;
r.in.level = 1;
r.in.buffer = NULL;
- buf_size = 0;
- r.in.buf_size = r.out.buf_size = &buf_size;
-
- printf("Testing GetJob\n");
+ r.in.offered = 0;
+ r.out.needed = &needed;
- status = dcerpc_spoolss_GetJob(p, mem_ctx, &r);
+ torture_comment(tctx, "Testing GetJob\n");
- if (!NT_STATUS_IS_OK(status)) {
- printf("GetJob failed - %s\n", nt_errstr(status));
- return False;
- }
+ status = dcerpc_spoolss_GetJob(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
-
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
+ r.in.offered = needed;
- status = dcerpc_spoolss_GetJob(p, mem_ctx, &r);
+ status = dcerpc_spoolss_GetJob(p, tctx, &r);
- if (!r.out.info) {
- printf("No job info returned");
- return False;
- }
+ torture_assert(tctx, r.out.info, "No job info returned");
}
- return True;
+ return true;
}
-static BOOL test_SetJob(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle, uint32_t job_id, uint32_t command)
+static bool test_SetJob(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle, uint32_t job_id,
+ enum spoolss_JobControl command)
{
NTSTATUS status;
struct spoolss_SetJob r;
- r.in.handle = handle;
- r.in.job_id = job_id;
- r.in.level = 0;
- r.in.command = command;
+ r.in.handle = handle;
+ r.in.job_id = job_id;
+ r.in.ctr = NULL;
+ r.in.command = command;
- printf("Testing SetJob\n");
+ torture_comment(tctx, "Testing SetJob\n");
- status = dcerpc_spoolss_SetJob(p, mem_ctx, &r);
+ 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");
- if (!NT_STATUS_IS_OK(status)) {
- printf("SetJob failed - %s\n", nt_errstr(status));
- return False;
- }
-
- return True;
+ return true;
}
-static BOOL test_EnumJobs(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_EnumJobs(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_EnumJobs r;
- uint32_t buf_size;
r.in.handle = handle;
r.in.firstjob = 0;
r.in.numjobs = 0xffffffff;
r.in.level = 1;
r.in.buffer = NULL;
- buf_size = 0;
- r.in.buf_size = &buf_size;
- r.out.buf_size = &buf_size;
+ r.in.offered = 0;
- printf("Testing EnumJobs\n");
+ torture_comment(tctx, "Testing EnumJobs\n");
- status = dcerpc_spoolss_EnumJobs(p, mem_ctx, &r);
+ status = dcerpc_spoolss_EnumJobs(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("EnumJobs failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
union spoolss_JobInfo *info;
int j;
-
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
+ r.in.offered = r.out.needed;
- status = dcerpc_spoolss_EnumJobs(p, mem_ctx, &r);
+ status = dcerpc_spoolss_EnumJobs(p, tctx, &r);
- if (!r.out.info) {
- printf("No jobs returned");
- return True;
- }
+ torture_assert(tctx, r.out.info, "No jobs returned");
- info = *r.out.info;
+ info = r.out.info;
for (j = 0; j < r.out.count; j++) {
- test_GetJob(p, mem_ctx, handle, info[j].info1.job_id);
- test_SetJob(p, mem_ctx, handle, info[j].info1.job_id, 1);
+ 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);
}
- } else if (!W_ERROR_IS_OK(r.out.result)) {
- printf("EnumJobs failed - %s\n", win_errstr(r.out.result));
- return False;
+ } else {
+ torture_assert_werr_ok(tctx, r.out.result, "EnumJobs failed");
}
- return True;
+ return true;
}
-static BOOL test_GetPrinterData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_DoPrintTest(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle)
+{
+ bool ret = true;
+ NTSTATUS status;
+ struct spoolss_StartDocPrinter s;
+ struct spoolss_DocumentInfo1 info1;
+ struct spoolss_StartPagePrinter sp;
+ struct spoolss_WritePrinter w;
+ struct spoolss_EndPagePrinter ep;
+ struct spoolss_EndDocPrinter e;
+ int i;
+ uint32_t job_id;
+
+ torture_comment(tctx, "Testing StartDocPrinter\n");
+
+ s.in.handle = handle;
+ s.in.level = 1;
+ s.in.info.info1 = &info1;
+ info1.document_name = "TorturePrintJob";
+ info1.output_file = NULL;
+ info1.datatype = "RAW";
+
+ 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");
+
+ job_id = s.out.job_id;
+
+ for (i=1; i < 4; i++) {
+ torture_comment(tctx, "Testing StartPagePrinter: Page[%d]\n", i);
+
+ sp.in.handle = handle;
+
+ 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");
+
+ torture_comment(tctx, "Testing WritePrinter: Page[%d]\n", i);
+
+ w.in.handle = handle;
+ w.in.data = data_blob_string_const(talloc_asprintf(tctx,"TortureTestPage: %d\nData\n",i));
+
+ 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");
+
+ torture_comment(tctx, "Testing EndPagePrinter: Page[%d]\n", i);
+
+ ep.in.handle = handle;
+
+ 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");
+ }
+
+ torture_comment(tctx, "Testing EndDocPrinter\n");
+
+ e.in.handle = handle;
+
+ 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");
+
+ ret &= test_EnumJobs(tctx, p, handle);
+
+ ret &= test_SetJob(tctx, p, handle, job_id, SPOOLSS_JOB_CONTROL_DELETE);
+
+ return ret;
+}
+
+static bool test_PausePrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle)
+{
+ 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;
+
+ torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE\n");
+
+ status = dcerpc_spoolss_SetPrinter(p, tctx, &r);
+
+ torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
+
+ return true;
+}
+
+static bool test_ResumePrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle)
+{
+ 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;
+
+ torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME\n");
+
+ status = dcerpc_spoolss_SetPrinter(p, tctx, &r);
+
+ torture_assert_ntstatus_ok(tctx, status, "SetPrinter failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
+
+ return true;
+}
+
+static bool test_GetPrinterData(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle,
const char *value_name)
{
NTSTATUS status;
struct spoolss_GetPrinterData r;
- uint32_t buf_size;
r.in.handle = handle;
r.in.value_name = value_name;
- buf_size = 0;
- r.in.buf_size = r.out.buf_size = &buf_size;
-
- printf("Testing GetPrinterData\n");
+ r.in.offered = 0;
- status = dcerpc_spoolss_GetPrinterData(p, mem_ctx, &r);
+ torture_comment(tctx, "Testing GetPrinterData\n");
- if (!NT_STATUS_IS_OK(status)) {
- printf("GetPrinterData failed - %s\n", nt_errstr(status));
- return False;
- }
+ status = dcerpc_spoolss_GetPrinterData(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
+ r.in.offered = r.out.needed;
- status = dcerpc_spoolss_GetPrinterData(p, mem_ctx, &r);
+ status = dcerpc_spoolss_GetPrinterData(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
- if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
- printf("GetPrinterData failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- return False;
- }
+ torture_assert_werr_ok(tctx, r.out.result, "GetPrinterData failed");
}
- return True;
+ return true;
}
-static BOOL test_GetPrinterDataEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_GetPrinterDataEx(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle,
const char *key_name,
const char *value_name)
{
NTSTATUS status;
struct spoolss_GetPrinterDataEx r;
- uint32_t buf_size;
r.in.handle = handle;
r.in.key_name = key_name;
r.in.value_name = value_name;
- buf_size = 0;
- r.in.buf_size = r.out.buf_size = &buf_size;
+ r.in.offered = 0;
- printf("Testing GetPrinterDataEx\n");
+ torture_comment(tctx, "Testing GetPrinterDataEx\n");
- status = dcerpc_spoolss_GetPrinterDataEx(p, mem_ctx, &r);
+ status = dcerpc_spoolss_GetPrinterDataEx(p, tctx, &r);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_NET_WRITE_FAULT) &&
p->last_fault_code == DCERPC_FAULT_OP_RNG_ERROR) {
- printf("GetPrinterDataEx not supported by server\n");
- return True;
+ torture_skip(tctx, "GetPrinterDataEx not supported by server\n");
}
- printf("GetPrinterDataEx failed - %s\n", nt_errstr(status));
- return False;
+ torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
}
if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
+ r.in.offered = r.out.needed;
- status = dcerpc_spoolss_GetPrinterDataEx(p, mem_ctx, &r);
+ status = dcerpc_spoolss_GetPrinterDataEx(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
- if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
- printf("GetPrinterDataEx failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- return False;
- }
+ torture_assert_werr_ok(tctx, r.out.result, "GetPrinterDataEx failed");
}
- return True;
+ return true;
}
-static BOOL test_EnumPrinterData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_EnumPrinterData(struct torture_context *tctx, struct dcerpc_pipe *p,
+ struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_EnumPrinterData r;
+ ZERO_STRUCT(r);
r.in.handle = handle;
r.in.enum_index = 0;
do {
- uint32_t data_size;
-
- r.in.value_offered = 0;
- data_size = 0;
- r.in.data_size = &data_size;
- r.out.data_size = &data_size;
+ uint32_t value_size = 0;
+ uint32_t data_size = 0;
+ uint32_t printerdata_type = 0;
+ DATA_BLOB data = data_blob(NULL,0);
- printf("Testing EnumPrinterData\n");
+ r.in.value_offered = value_size;
+ r.out.value_needed = &value_size;
+ r.in.data_offered = data_size;
+ r.out.data_needed = &data_size;
- status = dcerpc_spoolss_EnumPrinterData(p, mem_ctx, &r);
+ r.out.printerdata_type = &printerdata_type;
+ r.out.buffer = &data;
- if (!NT_STATUS_IS_OK(status)) {
- printf("EnumPrinterData failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_comment(tctx, "Testing EnumPrinterData\n");
- r.in.value_offered = r.out.value_needed;
+ status = dcerpc_spoolss_EnumPrinterData(p, tctx, &r);
- status = dcerpc_spoolss_EnumPrinterData(p, mem_ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
- if (!NT_STATUS_IS_OK(status)) {
- printf("EnumPrinterData failed - %s\n", nt_errstr(status));
- return False;
- }
+ r.in.value_offered = value_size;
+ r.in.data_offered = data_size;
+
+ status = dcerpc_spoolss_EnumPrinterData(p, tctx, &r);
+
+ torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
- test_GetPrinterData(p, mem_ctx, handle, r.out.value_name);
+ test_GetPrinterData(tctx, p, handle, r.out.value_name);
- test_GetPrinterDataEx(
- p, mem_ctx, handle, "PrinterDriverData",
+ test_GetPrinterDataEx(tctx,
+ p, handle, "PrinterDriverData",
r.out.value_name);
r.in.enum_index++;
} while (W_ERROR_IS_OK(r.out.result));
- return True;
+ return true;
+}
+
+static bool test_EnumPrinterDataEx(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle)
+{
+ NTSTATUS status;
+ struct spoolss_EnumPrinterDataEx r;
+
+ r.in.handle = handle;
+ r.in.key_name = "PrinterDriverData";
+ r.in.offered = 0;
+
+ torture_comment(tctx, "Testing EnumPrinterDataEx\n");
+
+ status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDataEx failed");
+
+ r.in.offered = r.out.needed;
+
+ status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r);
+
+ torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDataEx failed");
+
+ return true;
}
-static BOOL test_DeletePrinterData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+
+static bool test_DeletePrinterData(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle,
const char *value_name)
{
r.in.handle = handle;
r.in.value_name = value_name;
- printf("Testing DeletePrinterData\n");
+ torture_comment(tctx, "Testing DeletePrinterData\n");
- status = dcerpc_spoolss_DeletePrinterData(p, mem_ctx, &r);
+ status = dcerpc_spoolss_DeletePrinterData(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("DeletePrinterData failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "DeletePrinterData failed");
- return True;
+ return true;
}
-static BOOL test_SetPrinterData(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
- struct policy_handle *handle)
+static bool test_SetPrinterData(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_SetPrinterData r;
r.in.handle = handle;
r.in.value_name = value_name;
- r.in.type = 0;
- r.in.buffer = data_blob_talloc(mem_ctx, "dog", 4);
- r.in.real_len = 4;
+ r.in.type = SPOOLSS_PRINTER_DATA_TYPE_STRING;
+ r.in.data.string = "dog";
- printf("Testing SetPrinterData\n");
+ torture_comment(tctx, "Testing SetPrinterData\n");
- status = dcerpc_spoolss_SetPrinterData(p, mem_ctx, &r);
+ status = dcerpc_spoolss_SetPrinterData(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("SetPrinterData failed - %s\n", nt_errstr(status));
- return False;
+ torture_assert_ntstatus_ok(tctx, status, "SetPrinterData failed");
+
+ if (!test_GetPrinterData(tctx, p, handle, value_name)) {
+ return false;
}
- if (!test_DeletePrinterData(p, mem_ctx, handle, value_name)) {
- return False;
+ if (!test_DeletePrinterData(tctx, p, handle, value_name)) {
+ return false;
}
- return True;
+ return true;
}
-static BOOL test_SecondaryClosePrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_SecondaryClosePrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
+ struct dcerpc_binding *b;
struct dcerpc_pipe *p2;
- BOOL ret = True;
+ struct spoolss_ClosePrinter cp;
/* only makes sense on SMB */
if (p->conn->transport.transport != NCACN_NP) {
- return True;
+ return true;
}
- printf("testing close on secondary pipe\n");
+ torture_comment(tctx, "testing close on secondary pipe\n");
- status = dcerpc_secondary_connection(p, &p2,
- DCERPC_SPOOLSS_NAME,
- DCERPC_SPOOLSS_UUID,
- DCERPC_SPOOLSS_VERSION);
- if (!NT_STATUS_IS_OK(status)) {
- printf("Failed to create secondary connection\n");
- return False;
- }
+ status = dcerpc_parse_binding(tctx, p->conn->binding_string, &b);
+ torture_assert_ntstatus_ok(tctx, status, "Failed to parse dcerpc binding");
- if (test_ClosePrinter(p2, mem_ctx, handle)) {
- printf("ERROR: Allowed close on secondary connection!\n");
- ret = False;
- }
+ status = dcerpc_secondary_connection(p, &p2, b);
+ torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
- if (p2->last_fault_code != DCERPC_FAULT_CONTEXT_MISMATCH) {
- printf("Unexpected fault code 0x%x - expected 0x%x\n",
- p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH);
- ret = False;
- }
+ status = dcerpc_bind_auth_none(p2, &ndr_table_spoolss);
+ torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
- dcerpc_pipe_close(p2);
+ cp.in.handle = handle;
+ cp.out.handle = handle;
- return ret;
+ status = dcerpc_spoolss_ClosePrinter(p2, tctx, &cp);
+ torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NET_WRITE_FAULT,
+ "ERROR: Allowed close on secondary connection");
+
+ torture_assert_int_equal(tctx, p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
+ "Unexpected fault code");
+
+ talloc_free(p2);
+
+ return true;
}
-static BOOL test_OpenPrinter_badname(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, const char *name)
+static bool test_OpenPrinter_badname(struct torture_context *tctx,
+ struct dcerpc_pipe *p, const char *name)
{
NTSTATUS status;
struct spoolss_OpenPrinter op;
struct spoolss_OpenPrinterEx opEx;
struct policy_handle handle;
- BOOL ret = True;
+ bool ret = true;
op.in.printername = name;
op.in.datatype = NULL;
- op.in.devmode_ctr.size = 0;
op.in.devmode_ctr.devmode= NULL;
op.in.access_mask = 0;
op.out.handle = &handle;
- printf("\nTesting OpenPrinter(%s) with bad name\n", op.in.printername);
+ torture_comment(tctx, "\nTesting OpenPrinter(%s) with bad name\n", op.in.printername);
- status = dcerpc_spoolss_OpenPrinter(p, mem_ctx, &op);
- if (!NT_STATUS_IS_OK(status)) {
- printf("OpenPrinter failed - %s\n", nt_errstr(status));
- ret = False;
- }
+ status = dcerpc_spoolss_OpenPrinter(p, tctx, &op);
+ torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
if (!W_ERROR_EQUAL(WERR_INVALID_PRINTER_NAME,op.out.result)) {
- printf("OpenPrinter(%s) unexpected result[%s] should be WERR_INVALID_PRINTER_NAME\n",
+ torture_comment(tctx, "OpenPrinter(%s) unexpected result[%s] should be WERR_INVALID_PRINTER_NAME\n",
name, win_errstr(op.out.result));
}
if (W_ERROR_IS_OK(op.out.result)) {
- ret &=test_ClosePrinter(p, mem_ctx, &handle);
+ ret &=test_ClosePrinter(tctx, p, &handle);
}
opEx.in.printername = name;
opEx.in.datatype = NULL;
- opEx.in.devmode_ctr.size = 0;
opEx.in.devmode_ctr.devmode = NULL;
opEx.in.access_mask = 0;
opEx.in.level = 1;
opEx.in.userlevel.level1 = NULL;
opEx.out.handle = &handle;
- printf("\nTesting OpenPrinter(%s) with bad name\n", opEx.in.printername);
+ torture_comment(tctx, "Testing OpenPrinterEx(%s) with bad name\n", opEx.in.printername);
- status = dcerpc_spoolss_OpenPrinterEx(p, mem_ctx, &opEx);
- if (!NT_STATUS_IS_OK(status)) {
- printf("OpenPrinter failed - %s\n", nt_errstr(status));
- ret = False;
- }
- if (!W_ERROR_EQUAL(WERR_INVALID_PRINTER_NAME,opEx.out.result)) {
- printf("OpenPrinterEx(%s) unexpected result[%s] should be WERR_INVALID_PRINTER_NAME\n",
+ status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &opEx);
+ torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
+ if (!W_ERROR_EQUAL(WERR_INVALID_PARAM,opEx.out.result)) {
+ torture_comment(tctx, "OpenPrinterEx(%s) unexpected result[%s] should be WERR_INVALID_PARAM\n",
name, win_errstr(opEx.out.result));
}
if (W_ERROR_IS_OK(opEx.out.result)) {
- ret &=test_ClosePrinter(p, mem_ctx, &handle);
+ ret &=test_ClosePrinter(tctx, p, &handle);
}
return ret;
}
-static BOOL test_OpenPrinter_badnames(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
-{
- BOOL ret = True;
- char *name;
-
- ret &= test_OpenPrinter_badname(p, mem_ctx, "__INVALID_PRINTER__");
- ret &= test_OpenPrinter_badname(p, mem_ctx, "\\\\127.0.0.1");
- ret &= test_OpenPrinter_badname(p, mem_ctx, "\\\\localhost");
-
- name = talloc_asprintf(mem_ctx, "\\\\%s\\", dcerpc_server_name(p));
- ret &= test_OpenPrinter_badname(p, mem_ctx, name);
- talloc_free(name);
-
- name = talloc_asprintf(mem_ctx, "\\\\%s\\__INVALID_PRINTER__", dcerpc_server_name(p));
- ret &= test_OpenPrinter_badname(p, mem_ctx, name);
- talloc_free(name);
-
- return ret;
-}
-
-static BOOL test_OpenPrinter(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_OpenPrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
const char *name)
{
NTSTATUS status;
struct spoolss_OpenPrinter r;
struct policy_handle handle;
- BOOL ret = True;
+ bool ret = true;
- r.in.printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
+ r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
r.in.datatype = NULL;
- r.in.devmode_ctr.size = 0;
r.in.devmode_ctr.devmode= NULL;
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
r.out.handle = &handle;
- printf("\nTesting OpenPrinter(%s)\n", r.in.printername);
+ torture_comment(tctx, "Testing OpenPrinter(%s)\n", r.in.printername);
- status = dcerpc_spoolss_OpenPrinter(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
- printf("OpenPrinter failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- return False;
- }
+ status = dcerpc_spoolss_OpenPrinter(p, tctx, &r);
+
+ torture_assert_ntstatus_ok(tctx, status, "OpenPrinter failed");
- if (!test_GetPrinter(p, mem_ctx, &handle)) {
- ret = False;
+ torture_assert_werr_ok(tctx, r.out.result, "OpenPrinter failed");
+
+ if (!test_GetPrinter(tctx, p, &handle)) {
+ ret = false;
}
- if (!test_SecondaryClosePrinter(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
+ ret = false;
}
- if (!test_ClosePrinter(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_ClosePrinter(tctx, p, &handle)) {
+ ret = false;
}
return ret;
}
-static BOOL call_OpenPrinterEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool call_OpenPrinterEx(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
const char *name, struct policy_handle *handle)
{
struct spoolss_OpenPrinterEx r;
NTSTATUS status;
if (name && name[0]) {
- r.in.printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
+ r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s",
dcerpc_server_name(p), name);
} else {
- r.in.printername = talloc_asprintf(mem_ctx, "\\\\%s",
+ r.in.printername = talloc_asprintf(tctx, "\\\\%s",
dcerpc_server_name(p));
}
r.in.datatype = NULL;
- r.in.devmode_ctr.size = 0;
r.in.devmode_ctr.devmode= NULL;
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
r.in.level = 1;
userlevel1.minor = 3;
userlevel1.processor = 4;
- printf("Testing OpenPrinterEx(%s)\n", r.in.printername);
+ torture_comment(tctx, "Testing OpenPrinterEx(%s)\n", r.in.printername);
- status = dcerpc_spoolss_OpenPrinterEx(p, mem_ctx, &r);
+ status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("OpenPrinterEx failed - %s\n", nt_errstr(status));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
- if (!W_ERROR_IS_OK(r.out.result)) {
- printf("OpenPrinterEx failed - %s\n", win_errstr(r.out.result));
- return False;
- }
+ torture_assert_werr_ok(tctx, r.out.result, "OpenPrinterEx failed");
- return True;
+ return true;
}
-static BOOL test_OpenPrinterEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_OpenPrinterEx(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
const char *name)
{
struct policy_handle handle;
- BOOL ret = True;
+ bool ret = true;
+
+ if (!call_OpenPrinterEx(tctx, p, name, &handle)) {
+ return false;
+ }
+
+ if (!test_GetPrinter(tctx, p, &handle)) {
+ ret = false;
+ }
- if (!call_OpenPrinterEx(p, mem_ctx, name, &handle)) {
- return False;
+ if (!test_EnumForms(tctx, p, &handle, false)) {
+ ret = false;
}
- if (!test_GetPrinter(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_AddForm(tctx, p, &handle, false)) {
+ ret = false;
}
- if (!test_EnumForms(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_EnumPrinterData(tctx, p, &handle)) {
+ ret = false;
}
- if (!test_AddForm(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_EnumPrinterDataEx(tctx, p, &handle)) {
+ ret = false;
}
- if (!test_EnumPrinterData(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_PausePrinter(tctx, p, &handle)) {
+ ret = false;
}
- if (!test_EnumJobs(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_DoPrintTest(tctx, p, &handle)) {
+ ret = false;
}
- if (!test_SetPrinterData(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_ResumePrinter(tctx, p, &handle)) {
+ ret = false;
}
- if (!test_SecondaryClosePrinter(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_SetPrinterData(tctx, p, &handle)) {
+ ret = false;
}
- if (!test_ClosePrinter(p, mem_ctx, &handle)) {
- ret = False;
+ if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
+ ret = false;
+ }
+
+ if (!test_ClosePrinter(tctx, p, &handle)) {
+ ret = false;
}
return ret;
}
-static BOOL test_EnumPrinters(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+static bool test_EnumPrinters_old(struct torture_context *tctx, struct dcerpc_pipe *p)
{
struct spoolss_EnumPrinters r;
NTSTATUS status;
uint16_t levels[] = {1, 2, 4, 5};
int i;
- BOOL ret = True;
+ bool ret = true;
for (i=0;i<ARRAY_SIZE(levels);i++) {
- uint32_t buf_size = 0;
union spoolss_PrinterInfo *info;
int j;
- r.in.flags = 0x02;
- r.in.server = "";
- r.in.level = levels[i];
- r.in.buffer = NULL;
- r.in.buf_size = &buf_size;
- r.out.buf_size = &buf_size;
+ r.in.flags = PRINTER_ENUM_LOCAL;
+ r.in.server = "";
+ r.in.level = levels[i];
+ r.in.buffer = NULL;
+ r.in.offered = 0;
- printf("\nTesting EnumPrinters level %u\n", r.in.level);
+ torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
+
+ status = dcerpc_spoolss_EnumPrinters(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
- status = dcerpc_spoolss_EnumPrinters(p, mem_ctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("EnumPrinters failed - %s\n", nt_errstr(status));
- ret = False;
- continue;
- }
-
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, buf_size);
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- status = dcerpc_spoolss_EnumPrinters(p, mem_ctx, &r);
- }
-
- if (!NT_STATUS_IS_OK(status) ||
- !W_ERROR_IS_OK(r.out.result)) {
- printf("EnumPrinters failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- continue;
+ r.in.offered = r.out.needed;
+ status = dcerpc_spoolss_EnumPrinters(p, tctx, &r);
}
+ torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
+
if (!r.out.info) {
- printf("No printers returned");
- continue;
+ torture_comment(tctx, "No printers returned\n");
+ return true;
}
- info = *r.out.info;
+ info = r.out.info;
for (j=0;j<r.out.count;j++) {
if (r.in.level == 1) {
/* the names appear to be comma-separated name lists? */
- char *name = talloc_strdup(mem_ctx, info[j].info1.name);
+ char *name = talloc_strdup(tctx, info[j].info1.name);
char *comma = strchr(name, ',');
if (comma) *comma = 0;
- if (!test_OpenPrinter(p, mem_ctx, name)) {
- ret = False;
+ if (!test_OpenPrinter(tctx, p, name)) {
+ ret = false;
}
- if (!test_OpenPrinterEx(p, mem_ctx, name)) {
- ret = False;
+ if (!test_OpenPrinterEx(tctx, p, name)) {
+ ret = false;
}
}
}
}
-
+
return ret;
}
-static BOOL test_GetPrinterDriver2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+#if 0
+static bool test_GetPrinterDriver2(struct dcerpc_pipe *p,
struct policy_handle *handle,
const char *driver_name)
{
NTSTATUS status;
struct spoolss_GetPrinterDriver2 r;
- uint32_t buf_size;
r.in.handle = handle;
r.in.architecture = "W32X86";
r.in.level = 1;
- buf_size = 0;
r.in.buffer = NULL;
- r.in.buf_size = r.out.buf_size = &buf_size;
+ r.in.offered = 0;
r.in.client_major_version = 0;
r.in.client_minor_version = 0;
printf("Testing GetPrinterDriver2\n");
- status = dcerpc_spoolss_GetPrinterDriver2(p, mem_ctx, &r);
-
+ status = dcerpc_spoolss_GetPrinterDriver2(p, tctx, &r);
if (!NT_STATUS_IS_OK(status)) {
printf("GetPrinterDriver2 failed - %s\n", nt_errstr(status));
- return False;
+ return false;
}
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- status = dcerpc_spoolss_GetPrinterDriver2(p, mem_ctx, &r);
+ r.in.offered = r.out.needed;
+ status = dcerpc_spoolss_GetPrinterDriver2(p, tctx, &r);
}
- if (!NT_STATUS_IS_OK(status) ||
- !W_ERROR_IS_OK(r.out.result)) {
- printf("GetPrinterDriver2 failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- return False;
+ 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));
+ return false;
}
- return True;
+ return true;
}
-
-static BOOL test_EnumPrinterDrivers(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
+#endif
+
+static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
+ struct dcerpc_pipe *p)
{
struct spoolss_EnumPrinterDrivers r;
NTSTATUS status;
- uint16_t levels[] = {1, 2, 3};
+ uint16_t levels[] = {1, 2, 3, 4, 5, 6};
int i;
- BOOL ret = True;
for (i=0;i<ARRAY_SIZE(levels);i++) {
- uint32_t buf_size;
- union spoolss_DriverInfo *info;
- uint32_t j;
- r.in.server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
+ r.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
r.in.environment = "Windows NT x86";
r.in.level = levels[i];
r.in.buffer = NULL;
- buf_size = 0;
- r.in.buf_size = &buf_size;
- r.out.buf_size = &buf_size;
+ r.in.offered = 0;
- printf("\nTesting EnumPrinterDrivers level %u\n", r.in.level);
+ torture_comment(tctx, "Testing EnumPrinterDrivers level %u\n", r.in.level);
- status = dcerpc_spoolss_EnumPrinterDrivers(p, mem_ctx, &r);
+ status = dcerpc_spoolss_EnumPrinterDrivers(p, tctx, &r);
- if (!NT_STATUS_IS_OK(status)) {
- printf("EnumPrinterDrivers failed - %s\n",
- nt_errstr(status));
- ret = False;
- continue;
- }
+ torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(
- mem_ctx, NULL, buf_size);
-
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- status = dcerpc_spoolss_EnumPrinterDrivers(p, mem_ctx, &r);
- }
-
- if (!NT_STATUS_IS_OK(status) ||
- !W_ERROR_IS_OK(r.out.result)) {
- printf("EnumPrinterDrivers failed - %s/%s\n",
- nt_errstr(status), win_errstr(r.out.result));
- break;
- }
-
- if (!r.out.info) {
- printf("No printer drivers returned");
- break;
+ r.in.offered = r.out.needed;
+ status = dcerpc_spoolss_EnumPrinterDrivers(p, tctx, &r);
}
- info = *r.out.info;
-
- if (r.in.level != 1) continue;
+ torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
- for (j=0;j<r.out.count;j++) {
- struct policy_handle handle;
+ torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
- if (!call_OpenPrinterEx(p, mem_ctx, "",&handle)) {
- continue;
- }
- ret &=test_GetPrinterDriver2(p, mem_ctx, &handle, info[j].info1.driver_name);
+ if (!r.out.info) {
+ torture_comment(tctx, "No printer drivers returned\n");
+ break;
}
}
- return ret;
+ return true;
}
-BOOL torture_rpc_spoolss(void)
+/** 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)
{
- NTSTATUS status;
- struct dcerpc_pipe *p;
- TALLOC_CTX *mem_ctx;
- BOOL ret = True;
-
- status = torture_rpc_connection(&p,
- DCERPC_SPOOLSS_NAME,
- DCERPC_SPOOLSS_UUID,
- DCERPC_SPOOLSS_VERSION);
- if (!NT_STATUS_IS_OK(status)) {
- return False;
- }
+ 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");
- mem_ctx = talloc_init("torture_rpc_spoolss");
+ torture_assert_werr_ok(tctx, r.out.result, "error return code");
- ret &= test_OpenPrinter_badnames(p, mem_ctx);
+ s.in.handle = &h;
+ s.out.handle = &h;
- ret &= test_EnumPorts(p, mem_ctx);
+ torture_assert_ntstatus_ok(tctx,
+ dcerpc_spoolss_ReplyClosePrinter(pipe, tctx, &s),
+ "spoolss_ReplyClosePrinter call failed");
- ret &= test_EnumPrinters(p, mem_ctx);
+ torture_assert_werr_ok(tctx, r.out.result, "error return code");
- ret &= test_EnumPrinterDrivers(p, mem_ctx);
+ return true;
+}
+
+bool torture_rpc_spoolss(struct torture_context *torture)
+{
+ NTSTATUS status;
+ struct dcerpc_pipe *p;
+ bool ret = true;
+ struct test_spoolss_context *ctx;
- talloc_free(mem_ctx);
+ status = torture_rpc_connection(torture, &p, &ndr_table_spoolss);
+ if (!NT_STATUS_IS_OK(status)) {
+ return false;
+ }
- torture_rpc_close(p);
+ ctx = talloc_zero(torture, struct test_spoolss_context);
+
+ 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);
return ret;
}
git.samba.org / kai / samba-autobuild / .git / blobdiff