-/*
+/*
Unix SMB/CIFS implementation.
test suite for spoolss rpc operations
Copyright (C) Tim Potter 2003
Copyright (C) Stefan Metzmacher 2005
Copyright (C) Jelmer Vernooij 2007
-
+ Copyright (C) Guenther Deschner 2009
+
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 3 of the License, or
(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
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#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)
+static bool test_OpenPrinter_server(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *server_handle)
{
NTSTATUS status;
struct spoolss_OpenPrinter op;
- op.in.printername = talloc_asprintf(ctx, "\\\\%s", dcerpc_server_name(p));
+ op.in.printername = talloc_asprintf(tctx, "\\\\%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;
+ op.out.handle = server_handle;
torture_comment(tctx, "Testing OpenPrinter(%s)\n", op.in.printername);
- status = dcerpc_spoolss_OpenPrinter(p, ctx, &op);
+ status = dcerpc_spoolss_OpenPrinter(p, tctx, &op);
torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_OpenPrinter failed");
- torture_assert_werr_ok(tctx, op.out.result, "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,
+static bool test_EnumPorts(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct test_spoolss_context *ctx)
{
NTSTATUS status;
for (i=0;i<ARRAY_SIZE(levels);i++) {
int level = levels[i];
DATA_BLOB blob;
+ uint32_t needed;
+ uint32_t count;
+ union spoolss_PortInfo *info;
r.in.servername = "";
r.in.level = level;
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
torture_comment(tctx, "Testing EnumPorts level %u\n", r.in.level);
/* TODO: do some more checks here */
continue;
}
- torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
"EnumPorts unexpected return code");
- blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ blob = data_blob_talloc(ctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = 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;
+ torture_assert(tctx, info, "EnumPorts returned no info");
+
+ ctx->port_count[level] = count;
+ ctx->ports[level] = 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],
+ 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 */
return true;
}
-static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_GetPrintProcessorDirectory(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct test_spoolss_context *ctx)
+{
+ NTSTATUS status;
+ struct spoolss_GetPrintProcessorDirectory 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 GetPrintProcessorDirectory level %u\n", r.in.level);
+
+ status = dcerpc_spoolss_GetPrintProcessorDirectory(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status,
+ "dcerpc_spoolss_GetPrintProcessorDirectory failed");
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ "GetPrintProcessorDirectory 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_GetPrintProcessorDirectory(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrintProcessorDirectory failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "GetPrintProcessorDirectory failed");
+ }
+
+ return true;
+}
+
+
+static bool test_GetPrinterDriverDirectory(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct test_spoolss_context *ctx)
{
NTSTATUS status;
}
};
int i;
+ uint32_t needed;
for (i=0;i<ARRAY_SIZE(levels);i++) {
int level = levels[i].level;
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,
+ torture_assert_ntstatus_ok(tctx, status,
"dcerpc_spoolss_GetPrinterDriverDirectory failed");
- torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
"GetPrinterDriverDirectory unexpected return code");
- blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ blob = data_blob_talloc(ctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
status = dcerpc_spoolss_GetPrinterDriverDirectory(p, ctx, &r);
torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_GetPrinterDriverDirectory failed");
return true;
}
-static bool test_EnumPrinterDrivers(struct torture_context *tctx,
+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;
+ int i, j, a;
+ const char *architectures[] = {
+ SPOOLSS_ARCHITECTURE_NT_X86,
+ SPOOLSS_ARCHITECTURE_ALL
+ };
for (i=0;i<ARRAY_SIZE(levels);i++) {
+ for (a=0;a<ARRAY_SIZE(architectures);a++) {
int level = levels[i];
DATA_BLOB blob;
+ uint32_t needed;
+ uint32_t count;
+ union spoolss_DriverInfo *info;
- r.in.server = "";
- r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
+ /* FIXME: gd, come back and fix "" as server, and handle
+ * priority of returned error codes in torture test and samba 3
+ * server */
+
+ r.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
+ r.in.environment = architectures[a];
r.in.level = level;
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
- torture_comment(tctx, "Testing EnumPrinterDrivers level %u\n", r.in.level);
+ torture_comment(tctx, "Testing EnumPrinterDrivers level %u (%s)\n", r.in.level, r.in.environment);
status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
- torture_assert_ntstatus_ok(tctx, status,
+ 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;
+ if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
+ blob = data_blob_talloc(ctx, NULL, needed);
+ data_blob_clear(&blob);
+ r.in.buffer = &blob;
+ r.in.offered = needed;
- status = dcerpc_spoolss_EnumPrinterDrivers(p, ctx, &r);
- torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrinterDrivers failed");
+ 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;
+ /* don't do cross-architecture comparison */
+ if (strequal(r.in.environment, SPOOLSS_ARCHITECTURE_ALL)) {
+ continue;
+ }
+
+ ctx->driver_count[level] = count;
+ ctx->drivers[level] = info;
+ }
}
for (i=1;i<ARRAY_SIZE(levels);i++) {
int level = levels[i];
int old_level = levels[i-1];
+
+ /* don't do cross-architecture comparison */
+ if (strequal(r.in.environment, SPOOLSS_ARCHITECTURE_ALL)) {
+ continue;
+ }
+
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];
+
+ /* don't do cross-architecture comparison */
+ if (strequal(r.in.environment, SPOOLSS_ARCHITECTURE_ALL)) {
+ continue;
+ }
+
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];
return true;
}
-static bool test_EnumMonitors(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_EnumMonitors(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct test_spoolss_context *ctx)
{
NTSTATUS status;
for (i=0;i<ARRAY_SIZE(levels);i++) {
int level = levels[i];
DATA_BLOB blob;
+ uint32_t needed;
+ uint32_t count;
+ union spoolss_MonitorInfo *info;
r.in.servername = "";
r.in.level = level;
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
torture_comment(tctx, "Testing EnumMonitors level %u\n", r.in.level);
/* TODO: do some more checks here */
continue;
}
- torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
"EnumMonitors failed");
- blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ blob = data_blob_talloc(ctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = 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;
+ ctx->monitor_count[level] = count;
+ ctx->monitors[level] = 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->monitor_count[level], ctx->monitor_count[old_level],
+ torture_assert_int_equal(tctx, ctx->monitor_count[level], ctx->monitor_count[old_level],
"EnumMonitors invalid value");
}
return true;
}
-static bool test_EnumPrintProcessors(struct torture_context *tctx,
+static bool test_EnumPrintProcessors(struct torture_context *tctx,
struct dcerpc_pipe *p,
struct test_spoolss_context *ctx)
{
for (i=0;i<ARRAY_SIZE(levels);i++) {
int level = levels[i];
DATA_BLOB blob;
+ uint32_t needed;
+ uint32_t count;
+ union spoolss_PrintProcessorInfo *info;
r.in.servername = "";
- r.in.environment = "Windows NT x86";
+ r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
r.in.level = level;
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
torture_comment(tctx, "Testing EnumPrintProcessors level %u\n", r.in.level);
/* TODO: do some more checks here */
continue;
}
- torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
"EnumPrintProcessors unexpected return code");
- blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ blob = data_blob_talloc(ctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = 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;
+ ctx->print_processor_count[level] = count;
+ ctx->print_processors[level] = info;
}
for (i=1;i<ARRAY_SIZE(levels);i++) {
return true;
}
-static bool test_EnumPrinters(struct torture_context *tctx,
+static bool test_EnumPrintProcDataTypes(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct test_spoolss_context *ctx)
+{
+ NTSTATUS status;
+ struct spoolss_EnumPrintProcDataTypes r;
+ uint16_t levels[] = { 1 };
+ int i;
+
+ for (i=0;i<ARRAY_SIZE(levels);i++) {
+ int level = levels[i];
+ DATA_BLOB blob;
+ uint32_t needed;
+ uint32_t count;
+ union spoolss_PrintProcDataTypesInfo *info;
+
+ r.in.servername = "";
+ r.in.print_processor_name = "winprint";
+ r.in.level = level;
+ r.in.buffer = NULL;
+ r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
+
+ torture_comment(tctx, "Testing EnumPrintProcDataTypes level %u\n", r.in.level);
+
+ status = dcerpc_spoolss_EnumPrintProcDataTypes(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataType 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,
+ "EnumPrintProcDataTypes 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_EnumPrintProcDataTypes(p, ctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EnumPrintProcDataTypes failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "EnumPrintProcDataTypes failed");
+ }
+
+ return true;
+}
+
+
+static bool test_EnumPrinters(struct torture_context *tctx,
struct dcerpc_pipe *p,
struct test_spoolss_context *ctx)
{
for (i=0;i<ARRAY_SIZE(levels);i++) {
int level = levels[i];
DATA_BLOB blob;
+ uint32_t needed;
+ uint32_t count;
+ union spoolss_PrinterInfo *info;
r.in.flags = PRINTER_ENUM_LOCAL;
r.in.server = "";
r.in.level = level;
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
/* TODO: do some more checks here */
continue;
}
- torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
"EnumPrinters unexpected return code");
- blob = data_blob_talloc(ctx, NULL, r.out.needed);
+ blob = data_blob_talloc(ctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = 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;
+ ctx->printer_count[level] = count;
+ ctx->printers[level] = info;
}
for (i=1;i<ARRAY_SIZE(levels);i++) {
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_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);
return true;
}
-static bool test_GetPrinter(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+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[] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
int i;
-
+ uint32_t needed;
+
for (i=0;i<ARRAY_SIZE(levels);i++) {
r.in.handle = handle;
r.in.level = levels[i];
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
torture_comment(tctx, "Testing GetPrinter level %u\n", r.in.level);
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(tctx, NULL, r.out.needed);
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
status = dcerpc_spoolss_GetPrinter(p, tctx, &r);
}
-
+
torture_assert_ntstatus_ok(tctx, status, "GetPrinter failed");
torture_assert_werr_ok(tctx, r.out.result, "GetPrinter failed");
}
-static bool test_ClosePrinter(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_ClosePrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
return true;
}
-static bool test_GetForm(struct torture_context *tctx,
- struct dcerpc_pipe *p,
- struct policy_handle *handle,
- const char *form_name)
+static bool test_GetForm(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle,
+ const char *form_name,
+ uint32_t level)
{
NTSTATUS status;
struct spoolss_GetForm r;
+ uint32_t needed;
r.in.handle = handle;
r.in.form_name = form_name;
- r.in.level = 1;
+ r.in.level = level;
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
- torture_comment(tctx, "Testing GetForm\n");
+ torture_comment(tctx, "Testing GetForm level %d\n", r.in.level);
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(tctx, NULL, r.out.needed);
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
status = dcerpc_spoolss_GetForm(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "GetForm failed");
return true;
}
-static bool test_EnumForms(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+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;
bool ret = true;
+ uint32_t needed;
+ uint32_t count;
+ uint32_t levels[] = { 1, 2 };
+ int i;
- r.in.handle = handle;
- r.in.level = 1;
- r.in.buffer = NULL;
- r.in.offered = 0;
-
- torture_comment(tctx, "Testing EnumForms\n");
+ for (i=0; i<ARRAY_SIZE(levels); i++) {
- status = dcerpc_spoolss_EnumForms(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
+ union spoolss_FormInfo *info;
- 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)");
+ r.in.handle = handle;
+ r.in.level = levels[i];
+ r.in.buffer = NULL;
+ r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
- if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- 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;
+ torture_comment(tctx, "Testing EnumForms level %d\n", levels[i]);
status = dcerpc_spoolss_EnumForms(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
+
+ if ((r.in.level == 2) && (W_ERROR_EQUAL(r.out.result, WERR_UNKNOWN_LEVEL))) {
+ break;
+ }
- torture_assert(tctx, r.out.info, "No forms returned");
+ 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)");
- info = r.out.info;
+ if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
+ int j;
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
+ data_blob_clear(&blob);
+ r.in.buffer = &blob;
+ r.in.offered = needed;
+
+ status = dcerpc_spoolss_EnumForms(p, tctx, &r);
- for (j = 0; j < r.out.count; j++) {
- if (!print_server)
- ret &= test_GetForm(tctx, p, handle, info[j].info1.form_name);
+ torture_assert(tctx, info, "No forms returned");
+
+ for (j = 0; j < count; j++) {
+ if (!print_server)
+ ret &= test_GetForm(tctx, p, handle, info[j].info1.form_name, levels[i]);
+ }
}
- }
- torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
+ torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
- torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
+ torture_assert_werr_ok(tctx, r.out.result, "EnumForms failed");
+ }
return true;
}
-static bool test_DeleteForm(struct torture_context *tctx,
- struct dcerpc_pipe *p,
- struct policy_handle *handle,
+static bool test_DeleteForm(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle,
const char *form_name)
{
NTSTATUS status;
return true;
}
-static bool test_AddForm(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_AddForm(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle, bool print_server)
{
struct spoolss_AddForm r;
torture_assert_werr_ok(tctx, r.out.result, "AddForm failed");
- if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name);
+ if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name, 1);
{
struct spoolss_SetForm sf;
torture_assert_werr_ok(tctx, r.out.result, "SetForm failed");
}
- if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name);
+ if (!print_server) ret &= test_GetForm(tctx, p, handle, form_name, 1);
+
+ {
+ struct spoolss_EnumForms e;
+ union spoolss_FormInfo *info;
+ uint32_t needed;
+ uint32_t count;
+ bool found = false;
+
+ e.in.handle = handle;
+ e.in.level = 1;
+ e.in.buffer = NULL;
+ e.in.offered = 0;
+ e.out.needed = &needed;
+ e.out.count = &count;
+ e.out.info = &info;
+
+ torture_comment(tctx, "Testing EnumForms level 1\n");
+
+ status = dcerpc_spoolss_EnumForms(p, tctx, &e);
+ torture_assert_ntstatus_ok(tctx, status, "EnumForms failed");
+
+ if (print_server && W_ERROR_EQUAL(e.out.result, WERR_BADFID))
+ torture_fail(tctx, "EnumForms on the PrintServer isn't supported by test server (NT4)");
+
+ if (W_ERROR_EQUAL(e.out.result, WERR_INSUFFICIENT_BUFFER)) {
+ int j;
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
+ data_blob_clear(&blob);
+ e.in.buffer = &blob;
+ e.in.offered = needed;
+
+ status = dcerpc_spoolss_EnumForms(p, tctx, &e);
+
+ torture_assert(tctx, info, "No forms returned");
+
+ for (j = 0; j < count; j++) {
+ if (strequal(form_name, info[j].info1.form_name)) {
+ found = true;
+ break;
+ }
+ }
+ }
+ torture_assert(tctx, found, "Newly added form not found in enum call");
+ }
if (!test_DeleteForm(tctx, p, handle, form_name)) {
ret = false;
return ret;
}
-static bool test_EnumPorts_old(struct torture_context *tctx,
+static bool test_EnumPorts_old(struct torture_context *tctx,
struct dcerpc_pipe *p)
{
NTSTATUS status;
struct spoolss_EnumPorts r;
+ uint32_t needed;
+ uint32_t count;
+ union spoolss_PortInfo *info;
- r.in.servername = talloc_asprintf(tctx, "\\\\%s",
+ r.in.servername = talloc_asprintf(tctx, "\\\\%s",
dcerpc_server_name(p));
r.in.level = 2;
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
torture_comment(tctx, "Testing EnumPorts\n");
torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
status = dcerpc_spoolss_EnumPorts(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "EnumPorts failed");
- torture_assert(tctx, r.out.info, "No ports returned");
+ torture_assert(tctx, info, "No ports returned");
}
return true;
}
-static bool test_AddPort(struct torture_context *tctx,
+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",
+ r.in.server_name = talloc_asprintf(tctx, "\\\\%s",
dcerpc_server_name(p));
r.in.unknown = 0;
r.in.monitor_name = "foo";
return true;
}
-static bool test_GetJob(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+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;
+ union spoolss_JobInfo info;
+ uint32_t needed;
+ uint32_t levels[] = {1, 2 /* 3, 4 */};
+ uint32_t i;
r.in.handle = handle;
r.in.job_id = job_id;
- r.in.level = 1;
+ r.in.level = 0;
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.info = &info;
- torture_comment(tctx, "Testing GetJob\n");
+ torture_comment(tctx, "Testing GetJob level %d\n", r.in.level);
status = dcerpc_spoolss_GetJob(p, tctx, &r);
- torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
+ torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "Unexpected return code");
- if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- 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;
+ for (i = 0; i < ARRAY_SIZE(levels); i++) {
+
+ torture_comment(tctx, "Testing GetJob level %d\n", r.in.level);
+
+ needed = 0;
+
+ r.in.level = levels[i];
+ r.in.offered = 0;
+ r.in.buffer = NULL;
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(tctx, NULL, needed);
+ data_blob_clear(&blob);
+ r.in.buffer = &blob;
+ r.in.offered = needed;
+
+ status = dcerpc_spoolss_GetJob(p, tctx, &r);
+ torture_assert_ntstatus_ok(tctx, status, "GetJob failed");
+
+ }
torture_assert(tctx, r.out.info, "No job info returned");
+ torture_assert_werr_ok(tctx, r.out.result, "GetJob failed");
}
return true;
}
-static bool test_SetJob(struct torture_context *tctx,
- struct dcerpc_pipe *p,
- struct policy_handle *handle, uint32_t job_id,
+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;
r.in.ctr = NULL;
r.in.command = command;
- torture_comment(tctx, "Testing SetJob\n");
+ switch (command) {
+ case SPOOLSS_JOB_CONTROL_PAUSE:
+ torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_PAUSE\n");
+ break;
+ case SPOOLSS_JOB_CONTROL_RESUME:
+ torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RESUME\n");
+ break;
+ case SPOOLSS_JOB_CONTROL_CANCEL:
+ torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_CANCEL\n");
+ break;
+ case SPOOLSS_JOB_CONTROL_RESTART:
+ torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RESTART\n");
+ break;
+ case SPOOLSS_JOB_CONTROL_DELETE:
+ torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_DELETE\n");
+ break;
+ case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER:
+ torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER\n");
+ break;
+ case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED:
+ torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED\n");
+ break;
+ case SPOOLSS_JOB_CONTROL_RETAIN:
+ torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RETAIN\n");
+ break;
+ case SPOOLSS_JOB_CONTROL_RELEASE:
+ torture_comment(tctx, "Testing SetJob: SPOOLSS_JOB_CONTROL_RELEASE\n");
+ break;
+ default:
+ torture_comment(tctx, "Testing SetJob\n");
+ break;
+ }
status = dcerpc_spoolss_SetJob(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "SetJob failed");
return true;
}
-static bool test_EnumJobs(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_AddJob(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle)
+{
+ NTSTATUS status;
+ struct spoolss_AddJob r;
+ uint32_t needed;
+
+ r.in.level = 0;
+ r.in.handle = handle;
+ r.in.offered = 0;
+ r.out.needed = &needed;
+ r.in.buffer = r.out.buffer = NULL;
+
+ torture_comment(tctx, "Testing AddJob\n");
+
+ status = dcerpc_spoolss_AddJob(p, tctx, &r);
+ torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "AddJob failed");
+
+ r.in.level = 1;
+
+ status = dcerpc_spoolss_AddJob(p, tctx, &r);
+ torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM, "AddJob failed");
+
+ return true;
+}
+
+
+static bool test_EnumJobs(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_EnumJobs r;
+ uint32_t needed;
+ uint32_t count;
+ union spoolss_JobInfo *info;
r.in.handle = handle;
r.in.firstjob = 0;
r.in.level = 1;
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
torture_comment(tctx, "Testing EnumJobs\n");
torture_assert_ntstatus_ok(tctx, status, "EnumJobs failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- union spoolss_JobInfo *info;
int j;
- DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
status = dcerpc_spoolss_EnumJobs(p, tctx, &r);
- torture_assert(tctx, r.out.info, "No jobs returned");
+ torture_assert(tctx, info, "No jobs returned");
- info = r.out.info;
+ for (j = 0; j < count; j++) {
- for (j = 0; j < r.out.count; j++) {
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);
+
+ /* FIXME - gd */
+ if (!torture_setting_bool(tctx, "samba3", false)) {
+ 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 {
return true;
}
-static bool test_DoPrintTest(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_DoPrintTest(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
bool ret = true;
struct spoolss_EndDocPrinter e;
int i;
uint32_t job_id;
+ uint32_t num_written;
torture_comment(tctx, "Testing StartDocPrinter\n");
s.in.handle = handle;
s.in.level = 1;
s.in.info.info1 = &info1;
+ s.out.job_id = &job_id;
info1.document_name = "TorturePrintJob";
info1.output_file = NULL;
info1.datatype = "RAW";
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,
+ torture_assert_ntstatus_ok(tctx, status,
"dcerpc_spoolss_StartPagePrinter failed");
torture_assert_werr_ok(tctx, sp.out.result, "StartPagePrinter failed");
w.in.handle = handle;
w.in.data = data_blob_string_const(talloc_asprintf(tctx,"TortureTestPage: %d\nData\n",i));
+ w.out.num_written = &num_written;
status = dcerpc_spoolss_WritePrinter(p, tctx, &w);
torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_WritePrinter failed");
torture_assert_ntstatus_ok(tctx, status, "dcerpc_spoolss_EndDocPrinter failed");
torture_assert_werr_ok(tctx, e.out.result, "EndDocPrinter failed");
+ ret &= test_AddJob(tctx, p, handle);
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,
+static bool test_PausePrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_SetPrinter r;
+ struct spoolss_SetPrinterInfoCtr info_ctr;
+ struct spoolss_DevmodeContainer devmode_ctr;
+ struct sec_desc_buf secdesc_ctr;
+
+ info_ctr.level = 0;
+ info_ctr.info.info0 = NULL;
+
+ ZERO_STRUCT(devmode_ctr);
+ ZERO_STRUCT(secdesc_ctr);
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.info_ctr = &info_ctr;
+ r.in.devmode_ctr = &devmode_ctr;
+ r.in.secdesc_ctr = &secdesc_ctr;
r.in.command = SPOOLSS_PRINTER_CONTROL_PAUSE;
torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_PAUSE\n");
return true;
}
-static bool test_ResumePrinter(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_ResumePrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_SetPrinter r;
+ struct spoolss_SetPrinterInfoCtr info_ctr;
+ struct spoolss_DevmodeContainer devmode_ctr;
+ struct sec_desc_buf secdesc_ctr;
+
+ info_ctr.level = 0;
+ info_ctr.info.info0 = NULL;
+
+ ZERO_STRUCT(devmode_ctr);
+ ZERO_STRUCT(secdesc_ctr);
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.info_ctr = &info_ctr;
+ r.in.devmode_ctr = &devmode_ctr;
+ r.in.secdesc_ctr = &secdesc_ctr;
r.in.command = SPOOLSS_PRINTER_CONTROL_RESUME;
torture_comment(tctx, "Testing SetPrinter: SPOOLSS_PRINTER_CONTROL_RESUME\n");
return true;
}
-static bool test_GetPrinterData(struct torture_context *tctx,
- struct dcerpc_pipe *p,
- struct policy_handle *handle,
+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 needed;
+ enum winreg_Type type;
+ union spoolss_PrinterData data;
r.in.handle = handle;
r.in.value_name = value_name;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.type = &type;
+ r.out.data = &data;
torture_comment(tctx, "Testing GetPrinterData\n");
torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
status = dcerpc_spoolss_GetPrinterData(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed");
return true;
}
-static bool test_GetPrinterDataEx(struct torture_context *tctx,
- struct dcerpc_pipe *p,
- struct policy_handle *handle,
+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;
+ enum winreg_Type type;
+ uint32_t needed;
r.in.handle = handle;
r.in.key_name = key_name;
r.in.value_name = value_name;
r.in.offered = 0;
+ r.out.type = &type;
+ r.out.needed = &needed;
+ r.out.buffer = NULL;
torture_comment(tctx, "Testing GetPrinterDataEx\n");
}
if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
+ r.out.buffer = talloc_array(tctx, uint8_t, needed);
status = dcerpc_spoolss_GetPrinterDataEx(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "GetPrinterDataEx failed");
return true;
}
-static bool test_EnumPrinterData(struct torture_context *tctx, struct dcerpc_pipe *p,
+static bool test_EnumPrinterData(struct torture_context *tctx, struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
do {
uint32_t value_size = 0;
uint32_t data_size = 0;
- uint32_t printerdata_type = 0;
- DATA_BLOB data = data_blob(NULL,0);
+ enum winreg_Type type = 0;
r.in.value_offered = value_size;
r.out.value_needed = &value_size;
r.in.data_offered = data_size;
r.out.data_needed = &data_size;
- r.out.printerdata_type = &printerdata_type;
- r.out.buffer = &data;
+ r.out.type = &type;
+ r.out.data = talloc_zero_array(tctx, uint8_t, 0);
torture_comment(tctx, "Testing EnumPrinterData\n");
torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
r.in.value_offered = value_size;
+ r.out.value_name = talloc_zero_array(tctx, const char, value_size);
r.in.data_offered = data_size;
+ r.out.data = talloc_zero_array(tctx, uint8_t, data_size);
status = dcerpc_spoolss_EnumPrinterData(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "EnumPrinterData failed");
-
+
test_GetPrinterData(tctx, p, handle, r.out.value_name);
- test_GetPrinterDataEx(tctx,
- p, handle, "PrinterDriverData",
+ test_GetPrinterDataEx(tctx,
+ p, handle, "PrinterDriverData",
r.out.value_name);
r.in.enum_index++;
return true;
}
-static bool test_EnumPrinterDataEx(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_EnumPrinterDataEx(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_EnumPrinterDataEx r;
+ struct spoolss_PrinterEnumValues *info;
+ uint32_t needed;
+ uint32_t count;
r.in.handle = handle;
r.in.key_name = "PrinterDriverData";
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
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;
+ r.in.offered = needed;
status = dcerpc_spoolss_EnumPrinterDataEx(p, tctx, &r);
}
-static bool test_DeletePrinterData(struct torture_context *tctx,
- struct dcerpc_pipe *p,
- struct policy_handle *handle,
+static bool test_DeletePrinterData(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
+ struct policy_handle *handle,
const char *value_name)
{
NTSTATUS status;
return true;
}
-static bool test_SetPrinterData(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_SetPrinterData(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
struct spoolss_SetPrinterData r;
const char *value_name = "spottyfoot";
-
+
r.in.handle = handle;
r.in.value_name = value_name;
- r.in.type = SPOOLSS_PRINTER_DATA_TYPE_STRING;
+ r.in.type = REG_SZ;
r.in.data.string = "dog";
torture_comment(tctx, "Testing SetPrinterData\n");
return true;
}
-static bool test_SecondaryClosePrinter(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_SecondaryClosePrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
struct policy_handle *handle)
{
NTSTATUS status;
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,
+ 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 torture_context *tctx,
+static bool test_OpenPrinter_badname(struct torture_context *tctx,
struct dcerpc_pipe *p, const char *name)
{
NTSTATUS status;
return ret;
}
-static bool test_OpenPrinter(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_OpenPrinter(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
const char *name)
{
NTSTATUS status;
ret = false;
}
- if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
- ret = false;
+ if (!torture_setting_bool(tctx, "samba3", false)) {
+ if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
+ ret = false;
+ }
}
if (!test_ClosePrinter(tctx, p, &handle)) {
return ret;
}
-static bool call_OpenPrinterEx(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+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(tctx, "\\\\%s\\%s",
+ r.in.printername = talloc_asprintf(tctx, "\\\\%s\\%s",
dcerpc_server_name(p), name);
} else {
- r.in.printername = talloc_asprintf(tctx, "\\\\%s",
+ r.in.printername = talloc_asprintf(tctx, "\\\\%s",
dcerpc_server_name(p));
}
status = dcerpc_spoolss_OpenPrinterEx(p, tctx, &r);
torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");
-
+
torture_assert_werr_ok(tctx, r.out.result, "OpenPrinterEx failed");
return true;
}
-static bool test_OpenPrinterEx(struct torture_context *tctx,
- struct dcerpc_pipe *p,
+static bool test_OpenPrinterEx(struct torture_context *tctx,
+ struct dcerpc_pipe *p,
const char *name)
{
struct policy_handle handle;
ret = false;
}
- if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
- ret = false;
+ if (!torture_setting_bool(tctx, "samba3", false)) {
+ if (!test_SecondaryClosePrinter(tctx, p, &handle)) {
+ ret = false;
+ }
}
if (!test_ClosePrinter(tctx, p, &handle)) {
ret = false;
}
-
+
return ret;
}
for (i=0;i<ARRAY_SIZE(levels);i++) {
union spoolss_PrinterInfo *info;
int j;
+ uint32_t needed;
+ uint32_t count;
r.in.flags = PRINTER_ENUM_LOCAL;
r.in.server = "";
r.in.level = levels[i];
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
torture_comment(tctx, "Testing EnumPrinters level %u\n", r.in.level);
torture_assert_ntstatus_ok(tctx, status, "EnumPrinters failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
status = dcerpc_spoolss_EnumPrinters(p, tctx, &r);
}
torture_assert_werr_ok(tctx, r.out.result, "EnumPrinters failed");
- if (!r.out.info) {
+ if (!info) {
torture_comment(tctx, "No printers returned\n");
return true;
}
- info = r.out.info;
-
- for (j=0;j<r.out.count;j++) {
+ for (j=0;j<count;j++) {
if (r.in.level == 1) {
- /* the names appear to be comma-separated name lists? */
- char *name = talloc_strdup(tctx, info[j].info1.name);
- char *comma = strchr(name, ',');
- if (comma) *comma = 0;
+ char *unc = talloc_strdup(tctx, info[j].info1.name);
+ char *slash, *name;
+ name = unc;
+ if (unc[0] == '\\' && unc[1] == '\\') {
+ unc +=2;
+ }
+ slash = strchr(unc, '\\');
+ if (slash) {
+ slash++;
+ name = slash;
+ }
if (!test_OpenPrinter(tctx, p, name)) {
ret = false;
}
}
#if 0
-static bool test_GetPrinterDriver2(struct dcerpc_pipe *p,
- struct policy_handle *handle,
+static bool test_GetPrinterDriver2(struct dcerpc_pipe *p,
+ struct policy_handle *handle,
const char *driver_name)
{
NTSTATUS status;
struct spoolss_GetPrinterDriver2 r;
+ uint32_t needed;
+ uint32_t server_major_version;
+ uint32_t server_minor_version;
r.in.handle = handle;
r.in.architecture = "W32X86";
r.in.offered = 0;
r.in.client_major_version = 0;
r.in.client_minor_version = 0;
+ r.out.needed = &needed;
+ r.out.server_major_version = &server_major_version;
+ r.out.server_minor_version = &server_minor_version;
printf("Testing GetPrinterDriver2\n");
}
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
status = dcerpc_spoolss_GetPrinterDriver2(p, tctx, &r);
}
-
+
if (!NT_STATUS_IS_OK(status)) {
- printf("GetPrinterDriver2 failed - %s\n",
+ printf("GetPrinterDriver2 failed - %s\n",
nt_errstr(status));
return false;
}
if (!W_ERROR_IS_OK(r.out.result)) {
- printf("GetPrinterDriver2 failed - %s\n",
+ printf("GetPrinterDriver2 failed - %s\n",
win_errstr(r.out.result));
return false;
}
}
#endif
-static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
+static bool test_EnumPrinterDrivers_old(struct torture_context *tctx,
struct dcerpc_pipe *p)
{
struct spoolss_EnumPrinterDrivers r;
for (i=0;i<ARRAY_SIZE(levels);i++) {
+ uint32_t needed;
+ uint32_t count;
+ union spoolss_DriverInfo *info;
+
r.in.server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
- r.in.environment = "Windows NT x86";
+ r.in.environment = SPOOLSS_ARCHITECTURE_NT_X86;
r.in.level = levels[i];
r.in.buffer = NULL;
r.in.offered = 0;
+ r.out.needed = &needed;
+ r.out.count = &count;
+ r.out.info = &info;
torture_comment(tctx, "Testing EnumPrinterDrivers level %u\n", r.in.level);
torture_assert_ntstatus_ok(tctx, status, "EnumPrinterDrivers failed");
if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
- DATA_BLOB blob = data_blob_talloc(tctx, NULL, r.out.needed);
+ DATA_BLOB blob = data_blob_talloc(tctx, NULL, needed);
data_blob_clear(&blob);
r.in.buffer = &blob;
- r.in.offered = r.out.needed;
+ r.in.offered = needed;
status = dcerpc_spoolss_EnumPrinterDrivers(p, tctx, &r);
}
torture_assert_werr_ok(tctx, r.out.result, "EnumPrinterDrivers failed");
- if (!r.out.info) {
+ if (!info) {
torture_comment(tctx, "No printer drivers returned\n");
break;
}
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;
-}
-
bool torture_rpc_spoolss(struct torture_context *torture)
{
NTSTATUS status;
ctx = talloc_zero(torture, struct test_spoolss_context);
- ret &= test_OpenPrinter_server(torture, p, ctx);
+ ret &= test_OpenPrinter_server(torture, p, &ctx->server_handle);
ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "W3SvcInstalled");
ret &= test_GetPrinterData(torture, p, &ctx->server_handle, "BeepEnabled");
ret &= test_AddForm(torture, p, &ctx->server_handle, true);
ret &= test_EnumPorts(torture, p, ctx);
ret &= test_GetPrinterDriverDirectory(torture, p, ctx);
+ ret &= test_GetPrintProcessorDirectory(torture, p, ctx);
ret &= test_EnumPrinterDrivers(torture, p, ctx);
ret &= test_EnumMonitors(torture, p, ctx);
ret &= test_EnumPrintProcessors(torture, p, ctx);
+ ret &= test_EnumPrintProcDataTypes(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, "\\\\\\__INVALID_PRINTER__");
ret &= test_OpenPrinter_badname(torture, p, talloc_asprintf(torture, "\\\\%s\\", dcerpc_server_name(p)));
- ret &= test_OpenPrinter_badname(torture, p,
+ ret &= test_OpenPrinter_badname(torture, p,
talloc_asprintf(torture, "\\\\%s\\__INVALID_PRINTER__", dcerpc_server_name(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 / ira / wip.git / blobdiff