mirror of
https://github.com/samba-team/samba.git
synced 2024-12-22 13:34:15 +03:00
a396b705c8
Instead of ‘int’ or ‘uint32_t’, neither of which convey much meaning, consistently use a newly added type to hold NDR_ flags. Update the NDR 4.0.0 ABI. Signed-off-by: Joseph Sutton <josephsutton@catalyst.net.nz> Reviewed-by: Andrew Bartlett <abartlet@samba.org>
1091 lines
34 KiB
C
1091 lines
34 KiB
C
/*
|
|
Unix SMB/CIFS implementation.
|
|
test suite for iremotewinspool rpc operations
|
|
|
|
Copyright (C) Guenther Deschner 2013,2023
|
|
|
|
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/>.
|
|
*/
|
|
|
|
#include "includes.h"
|
|
#include "torture/torture.h"
|
|
#include "librpc/gen_ndr/ndr_winspool.h"
|
|
#include "librpc/gen_ndr/ndr_winspool_c.h"
|
|
#include "librpc/gen_ndr/ndr_spoolss_c.h"
|
|
#include "torture/rpc/torture_rpc.h"
|
|
#include "libcli/registry/util_reg.h"
|
|
#include "torture/rpc/iremotewinspool_common.h"
|
|
|
|
static bool torture_rpc_iremotewinspool_setup_common(struct torture_context *tctx,
|
|
struct test_iremotewinspool_context *t)
|
|
{
|
|
const char *printer_name;
|
|
struct spoolss_UserLevel1 client_info;
|
|
struct dcerpc_binding *binding;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
GUID_from_string(IREMOTEWINSPOOL_OBJECT_GUID, &t->object_uuid),
|
|
"failed to parse GUID");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
torture_rpc_binding(tctx, &binding),
|
|
"failed to retrieve torture binding");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_binding_set_object(binding, t->object_uuid),
|
|
"failed to set object_uuid");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
torture_rpc_connection_with_binding(tctx, binding, &t->iremotewinspool_pipe, &ndr_table_iremotewinspool),
|
|
"Error connecting to server");
|
|
|
|
printer_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(t->iremotewinspool_pipe));
|
|
|
|
client_info = test_get_client_info(tctx, WIN_7, 6, 1, "testclient_machine", "testclient_user");
|
|
|
|
torture_assert(tctx,
|
|
test_AsyncOpenPrinter_byprinter(tctx, t,
|
|
t->iremotewinspool_pipe, printer_name,
|
|
client_info, &t->server_handle),
|
|
"failed to open printserver");
|
|
torture_assert(tctx,
|
|
test_get_environment(tctx,
|
|
t->iremotewinspool_pipe->binding_handle,
|
|
&t->server_handle, &t->environment),
|
|
"failed to get environment");
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool torture_rpc_iremotewinspool_setup(struct torture_context *tctx,
|
|
void **data)
|
|
{
|
|
struct test_iremotewinspool_context *t;
|
|
|
|
*data = t = talloc_zero(tctx, struct test_iremotewinspool_context);
|
|
|
|
return torture_rpc_iremotewinspool_setup_common(tctx, t);
|
|
}
|
|
|
|
static bool torture_rpc_iremotewinspool_teardown_common(struct torture_context *tctx,
|
|
struct test_iremotewinspool_context *t)
|
|
{
|
|
|
|
test_AsyncClosePrinter_byhandle(tctx, t, t->iremotewinspool_pipe, &t->server_handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool torture_rpc_iremotewinspool_teardown(struct torture_context *tctx,
|
|
void *data)
|
|
{
|
|
struct test_iremotewinspool_context *t = talloc_get_type(data, struct test_iremotewinspool_context);
|
|
bool ret;
|
|
|
|
ret = torture_rpc_iremotewinspool_teardown_common(tctx, t);
|
|
talloc_free(t);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static bool test_AsyncClosePrinter(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
const char *printer_name;
|
|
struct spoolss_UserLevel1 client_info;
|
|
struct policy_handle handle;
|
|
|
|
printer_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
|
|
client_info = test_get_client_info(tctx, WIN_7, 6, 1, "testclient_machine", "testclient_user");
|
|
|
|
torture_assert(tctx,
|
|
test_AsyncOpenPrinter_byprinter(tctx, ctx, p, printer_name, client_info, &handle),
|
|
"failed to test AsyncOpenPrinter");
|
|
|
|
torture_assert(tctx,
|
|
test_AsyncClosePrinter_byhandle(tctx, ctx, p, &handle),
|
|
"failed to test AsyncClosePrinter");
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_AsyncOpenPrinter(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
const char *printer_name;
|
|
struct spoolss_UserLevel1 client_info;
|
|
struct policy_handle handle;
|
|
|
|
printer_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
|
|
client_info = test_get_client_info(tctx, WIN_7, 6, 1, "testclient_machine", "testclient_user");
|
|
|
|
torture_assert(tctx,
|
|
test_AsyncOpenPrinter_byprinter(tctx, ctx, p, printer_name, client_info, &handle),
|
|
"failed to test AsyncOpenPrinter");
|
|
|
|
test_AsyncClosePrinter_byhandle(tctx, ctx, p, &handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Validate the result of AsyncOpenPrinter calls based on client info
|
|
* build number. Windows Server 2016 rejects an advertised build
|
|
* number less than 6000(Windows Vista and Windows Server 2008, or older)
|
|
*/
|
|
static bool test_AsyncOpenPrinterValidateBuildNumber(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
const char *printer_name;
|
|
struct spoolss_UserLevel1 client_info;
|
|
struct policy_handle handle;
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
struct spoolss_DevmodeContainer devmode_ctr;
|
|
struct spoolss_UserLevelCtr client_info_ctr = {
|
|
.level = 1,
|
|
};
|
|
uint32_t access_mask = SERVER_ALL_ACCESS;
|
|
struct winspool_AsyncOpenPrinter r;
|
|
NTSTATUS status;
|
|
bool ok = false;
|
|
|
|
printer_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
torture_assert_not_null(tctx, printer_name, "Cannot allocate memory");
|
|
|
|
/* fail with Windows 2000 build number */
|
|
client_info = test_get_client_info(tctx, WIN_2000, 3, SPOOLSS_MINOR_VERSION_0,
|
|
"testclient_machine", "testclient_user");
|
|
|
|
ZERO_STRUCT(devmode_ctr);
|
|
|
|
client_info_ctr.user_info.level1 = &client_info;
|
|
|
|
r.in.pPrinterName = printer_name;
|
|
r.in.pDatatype = NULL;
|
|
r.in.pDevModeContainer = &devmode_ctr;
|
|
r.in.AccessRequired = access_mask;
|
|
r.in.pClientInfo = &client_info_ctr;
|
|
r.out.pHandle = &handle;
|
|
|
|
status = dcerpc_winspool_AsyncOpenPrinter_r(b, tctx, &r);
|
|
torture_assert_ntstatus_ok(tctx, status, "AsyncOpenPrinter failed");
|
|
torture_assert_werr_equal(tctx, r.out.result, WERR_ACCESS_DENIED,
|
|
"AsyncOpenPrinter should have failed");
|
|
|
|
/* succeed with Windows 7 build number */
|
|
client_info = test_get_client_info(tctx, WIN_7, 6, 1,
|
|
"testclient_machine", "testclient_user");
|
|
client_info_ctr.user_info.level1 = &client_info;
|
|
r.in.pClientInfo = &client_info_ctr;
|
|
|
|
status = dcerpc_winspool_AsyncOpenPrinter_r(b, tctx, &r);
|
|
torture_assert_ntstatus_ok(tctx, status, "AsyncOpenPrinter failed");
|
|
torture_assert_werr_ok(tctx, r.out.result,
|
|
"AsyncOpenPrinter failed");
|
|
|
|
ok = test_AsyncClosePrinter_byhandle(tctx, ctx, p, &handle);
|
|
torture_assert(tctx, ok, "failed to AsyncClosePrinter handle");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
static struct spoolss_NotifyOption *setup_printserver_NotifyOption(struct torture_context *tctx)
|
|
{
|
|
struct spoolss_NotifyOption *o;
|
|
|
|
o = talloc_zero(tctx, struct spoolss_NotifyOption);
|
|
if (o == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
o->version = 2;
|
|
o->flags = PRINTER_NOTIFY_OPTIONS_REFRESH;
|
|
|
|
o->count = 2;
|
|
o->types = talloc_zero_array(o, struct spoolss_NotifyOptionType, o->count);
|
|
if (o->types == NULL) {
|
|
talloc_free(o);
|
|
return NULL;
|
|
}
|
|
|
|
o->types[0].type = PRINTER_NOTIFY_TYPE;
|
|
o->types[0].count = 1;
|
|
o->types[0].fields = talloc_array(o->types, union spoolss_Field, o->types[0].count);
|
|
if (o->types[0].fields == NULL) {
|
|
talloc_free(o);
|
|
return NULL;
|
|
}
|
|
o->types[0].fields[0].field = PRINTER_NOTIFY_FIELD_SERVER_NAME;
|
|
|
|
o->types[1].type = JOB_NOTIFY_TYPE;
|
|
o->types[1].count = 1;
|
|
o->types[1].fields = talloc_array(o->types, union spoolss_Field, o->types[1].count);
|
|
if (o->types[1].fields == NULL) {
|
|
talloc_free(o);
|
|
return NULL;
|
|
}
|
|
o->types[1].fields[0].field = JOB_NOTIFY_FIELD_MACHINE_NAME;
|
|
|
|
return o;
|
|
}
|
|
|
|
static bool test_SyncUnRegisterForRemoteNotifications_args(struct torture_context *tctx,
|
|
struct dcerpc_pipe *p,
|
|
struct policy_handle *notify_handle)
|
|
{
|
|
struct winspool_SyncUnRegisterForRemoteNotifications r;
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
|
|
r.in.phRpcHandle = notify_handle;
|
|
r.out.phRpcHandle = notify_handle;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_SyncUnRegisterForRemoteNotifications_r(b, tctx, &r),
|
|
"SyncUnRegisterForRemoteNotifications failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"SyncUnRegisterForRemoteNotifications failed");
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_SyncRegisterForRemoteNotifications_args(struct torture_context *tctx,
|
|
struct dcerpc_pipe *p,
|
|
struct policy_handle *server_handle,
|
|
struct policy_handle *notify_handle);
|
|
|
|
static bool test_SyncUnRegisterForRemoteNotifications(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
struct policy_handle notify_handle;
|
|
|
|
torture_assert(tctx,
|
|
test_SyncRegisterForRemoteNotifications_args(tctx,
|
|
ctx->iremotewinspool_pipe,
|
|
&ctx->server_handle,
|
|
¬ify_handle),
|
|
"failed to test SyncRegisterForRemoteNotifications");
|
|
|
|
torture_assert(tctx,
|
|
test_SyncUnRegisterForRemoteNotifications_args(tctx,
|
|
ctx->iremotewinspool_pipe,
|
|
¬ify_handle),
|
|
"failed to test UnSyncRegisterForRemoteNotifications");
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_SyncRegisterForRemoteNotifications_args(struct torture_context *tctx,
|
|
struct dcerpc_pipe *p,
|
|
struct policy_handle *server_handle,
|
|
struct policy_handle *notify_handle)
|
|
{
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
|
|
struct winspool_SyncRegisterForRemoteNotifications r;
|
|
struct winspool_PrintPropertiesCollection NotifyFilter;
|
|
struct winspool_PrintNamedProperty *c;
|
|
struct spoolss_NotifyOption *options;
|
|
|
|
ZERO_STRUCT(NotifyFilter);
|
|
|
|
options = setup_printserver_NotifyOption(tctx);
|
|
torture_assert(tctx, options, "out of memory");
|
|
|
|
c = talloc_zero_array(tctx, struct winspool_PrintNamedProperty, 4);
|
|
torture_assert(tctx, c, "out of memory");
|
|
|
|
c[0].propertyName = "RemoteNotifyFilter Flags";
|
|
c[0].propertyValue.PropertyType = winspool_PropertyTypeInt32;
|
|
c[0].propertyValue.value.propertyInt32 = 0xff;
|
|
|
|
c[1].propertyName = "RemoteNotifyFilter Options";
|
|
c[1].propertyValue.PropertyType = winspool_PropertyTypeInt32;
|
|
c[1].propertyValue.value.propertyInt32 = 0;
|
|
|
|
c[2].propertyName = "RemoteNotifyFilter Color";
|
|
c[2].propertyValue.PropertyType = winspool_PropertyTypeInt32;
|
|
c[2].propertyValue.value.propertyInt32 = 0;
|
|
|
|
c[3].propertyName = "RemoteNotifyFilter NotifyOptions";
|
|
c[3].propertyValue.PropertyType = winspool_PropertyTypeNotificationOptions;
|
|
c[3].propertyValue.value.propertyOptionsContainer.pOptions = options;
|
|
|
|
NotifyFilter.numberOfProperties = 4;
|
|
NotifyFilter.propertiesCollection = c;
|
|
|
|
r.in.hPrinter = *server_handle;
|
|
r.in.pNotifyFilter = &NotifyFilter;
|
|
r.out.phRpcHandle = notify_handle;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_SyncRegisterForRemoteNotifications_r(b, tctx, &r),
|
|
"SyncRegisterForRemoteNotifications failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"SyncRegisterForRemoteNotifications failed");
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_SyncRegisterForRemoteNotifications(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
struct policy_handle notify_handle;
|
|
|
|
torture_assert(tctx,
|
|
test_SyncRegisterForRemoteNotifications_args(tctx,
|
|
ctx->iremotewinspool_pipe,
|
|
&ctx->server_handle,
|
|
¬ify_handle),
|
|
"failed to test SyncRegisterForRemoteNotifications");
|
|
|
|
test_SyncUnRegisterForRemoteNotifications_args(tctx, ctx->iremotewinspool_pipe, ¬ify_handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_AsyncUploadPrinterDriverPackage(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
|
|
struct winspool_AsyncUploadPrinterDriverPackage r;
|
|
uint32_t pcchDestInfPath = 0;
|
|
|
|
r.in.pszServer = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
r.in.pszInfPath = "";
|
|
r.in.pszEnvironment = "";
|
|
r.in.dwFlags = 0;
|
|
r.in.pszDestInfPath = NULL;
|
|
r.in.pcchDestInfPath = &pcchDestInfPath;
|
|
r.out.pszDestInfPath = NULL;
|
|
r.out.pcchDestInfPath = &pcchDestInfPath;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncUploadPrinterDriverPackage_r(b, tctx, &r),
|
|
"AsyncUploadPrinterDriverPackage failed");
|
|
torture_assert_hresult_equal(tctx, r.out.result, HRES_E_INVALIDARG,
|
|
"AsyncUploadPrinterDriverPackage failed");
|
|
|
|
pcchDestInfPath = 260;
|
|
r.in.pszDestInfPath = talloc_zero(tctx, const char);
|
|
r.out.pszDestInfPath = talloc_zero(tctx, const char);
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncUploadPrinterDriverPackage_r(b, tctx, &r),
|
|
"AsyncUploadPrinterDriverPackage failed");
|
|
torture_assert_werr_equal(tctx,
|
|
W_ERROR(WIN32_FROM_HRESULT(r.out.result)), WERR_INVALID_ENVIRONMENT,
|
|
"AsyncUploadPrinterDriverPackage failed");
|
|
|
|
r.in.pszEnvironment = SPOOLSS_ARCHITECTURE_x64;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncUploadPrinterDriverPackage_r(b, tctx, &r),
|
|
"AsyncUploadPrinterDriverPackage failed");
|
|
torture_assert_werr_equal(tctx,
|
|
W_ERROR(WIN32_FROM_HRESULT(r.out.result)), WERR_FILE_NOT_FOUND,
|
|
"AsyncUploadPrinterDriverPackage failed");
|
|
|
|
r.in.pszInfPath = "\\\\mthelena\\print$\\x64\\{BD443844-ED00-4D96-8CAE-95E49492312A}\\prnbrcl1.inf";
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncUploadPrinterDriverPackage_r(b, tctx, &r),
|
|
"AsyncUploadPrinterDriverPackage failed");
|
|
torture_assert_werr_equal(tctx,
|
|
W_ERROR(WIN32_FROM_HRESULT(r.out.result)), WERR_FILE_NOT_FOUND,
|
|
"AsyncUploadPrinterDriverPackage failed");
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_AsyncEnumPrinters(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
|
|
struct winspool_AsyncEnumPrinters r;
|
|
uint32_t levels[] = { 1, 2, /*3,*/ 4, 5 };
|
|
int i;
|
|
|
|
uint32_t needed;
|
|
uint32_t returned;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(levels); i++) {
|
|
|
|
r.in.Flags = PRINTER_ENUM_LOCAL;
|
|
r.in.pName = NULL;
|
|
r.in.Level = levels[i];
|
|
r.in.cbBuf = 0;
|
|
r.in.pPrinterEnum = NULL;
|
|
r.out.pcbNeeded = &needed;
|
|
r.out.pcReturned = &returned;
|
|
r.out.pPrinterEnum = NULL;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncEnumPrinters_r(b, tctx, &r),
|
|
"AsyncEnumPrinters failed");
|
|
torture_assert_werr_equal(tctx, r.out.result, WERR_INSUFFICIENT_BUFFER,
|
|
"AsyncEnumPrinters failed");
|
|
|
|
r.in.cbBuf = needed;
|
|
r.in.pPrinterEnum = talloc_zero_array(tctx, uint8_t, r.in.cbBuf);
|
|
r.out.pPrinterEnum = r.in.pPrinterEnum;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncEnumPrinters_r(b, tctx, &r),
|
|
"AsyncEnumPrinters failed");
|
|
torture_assert_werr_ok(tctx, r.out.result,
|
|
"AsyncEnumPrinters failed");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_AsyncGetPrinterData(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
DATA_BLOB blob;
|
|
const char *s;
|
|
bool ok;
|
|
|
|
uint32_t pType;
|
|
uint32_t pcbNeeded;
|
|
uint8_t *pData;
|
|
|
|
torture_assert(tctx,
|
|
test_AsyncGetPrinterData_args(tctx, b, &ctx->server_handle,
|
|
"MajorVersion",
|
|
&pType, &pData, &pcbNeeded),
|
|
"failed to check for MajorVersion");
|
|
|
|
torture_assert_int_equal(tctx, pcbNeeded, 4, "pcbNeeded");
|
|
torture_assert_int_equal(tctx, pType, REG_DWORD, "pType");
|
|
torture_assert_int_equal(tctx, IVAL(pData, 0), 3, "pData");
|
|
|
|
torture_assert(tctx,
|
|
test_AsyncGetPrinterData_args(tctx, b, &ctx->server_handle,
|
|
"Architecture",
|
|
&pType, &pData, &pcbNeeded),
|
|
"failed to check for Architecture");
|
|
|
|
blob = data_blob_const(pData, pcbNeeded);
|
|
|
|
torture_assert_int_equal(tctx, pType, REG_SZ, "pType");
|
|
torture_assert(tctx, pull_reg_sz(tctx, &blob, &s), "");
|
|
ok = strequal(s, SPOOLSS_ARCHITECTURE_x64) || strequal(s, SPOOLSS_ARCHITECTURE_NT_X86);
|
|
torture_assert(tctx, ok, "unexpected architecture returned");
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_AsyncCorePrinterDriverInstalled(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
|
|
struct winspool_AsyncCorePrinterDriverInstalled r;
|
|
int32_t pbDriverInstalled;
|
|
struct GUID guid;
|
|
|
|
r.in.pszServer = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
r.in.pszEnvironment = "";
|
|
r.in.CoreDriverGUID = GUID_zero();
|
|
r.in.ftDriverDate = 0;
|
|
r.in.dwlDriverVersion = 0;
|
|
r.out.pbDriverInstalled = &pbDriverInstalled;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncCorePrinterDriverInstalled_r(b, tctx, &r),
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_werr_equal(tctx,
|
|
W_ERROR(WIN32_FROM_HRESULT(r.out.result)), WERR_INVALID_ENVIRONMENT,
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
|
|
r.in.pszEnvironment = SPOOLSS_ARCHITECTURE_x64;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncCorePrinterDriverInstalled_r(b, tctx, &r),
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_int_equal(tctx, *r.out.pbDriverInstalled, false,
|
|
"unexpected driver installed");
|
|
|
|
r.in.CoreDriverGUID = GUID_random();
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncCorePrinterDriverInstalled_r(b, tctx, &r),
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_int_equal(tctx, *r.out.pbDriverInstalled, false,
|
|
"unexpected driver installed");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
GUID_from_string(SPOOLSS_CORE_PRINT_PACKAGE_FILES_XPSDRV, &guid), "");
|
|
|
|
r.in.CoreDriverGUID = guid;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncCorePrinterDriverInstalled_r(b, tctx, &r),
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_int_equal(tctx, *r.out.pbDriverInstalled, true,
|
|
"xps core driver not installed?");
|
|
|
|
r.in.dwlDriverVersion = 0xffffffff;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncCorePrinterDriverInstalled_r(b, tctx, &r),
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_int_equal(tctx, *r.out.pbDriverInstalled, true,
|
|
"xps core driver not installed?");
|
|
|
|
r.in.dwlDriverVersion = 1234;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncCorePrinterDriverInstalled_r(b, tctx, &r),
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_int_equal(tctx, *r.out.pbDriverInstalled, true,
|
|
"xps core driver not installed?");
|
|
|
|
r.in.ftDriverDate = unix_timespec_to_nt_time(timespec_current());
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncCorePrinterDriverInstalled_r(b, tctx, &r),
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_int_equal(tctx, *r.out.pbDriverInstalled, false,
|
|
"driver too old ?");
|
|
|
|
r.in.dwlDriverVersion = 0;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncCorePrinterDriverInstalled_r(b, tctx, &r),
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"AsyncCorePrinterDriverInstalled failed");
|
|
torture_assert_int_equal(tctx, *r.out.pbDriverInstalled, false,
|
|
"unexpected driver installed");
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_get_core_printer_drivers_arch_guid(struct torture_context *tctx,
|
|
struct dcerpc_pipe *p,
|
|
const char *architecture,
|
|
const char *guid_str,
|
|
const char **package_id)
|
|
{
|
|
struct winspool_AsyncGetCorePrinterDrivers r;
|
|
DATA_BLOB blob;
|
|
const char **s;
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
|
|
s = talloc_zero_array(tctx, const char *, 2);
|
|
s[0] = guid_str;
|
|
|
|
torture_assert(tctx,
|
|
push_reg_multi_sz(tctx, &blob, s),
|
|
"push_reg_multi_sz failed");
|
|
|
|
r.in.pszServer = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
r.in.pszEnvironment = architecture;
|
|
r.in.cchCoreDrivers = blob.length/2;
|
|
r.in.pszzCoreDriverDependencies = (uint16_t *)blob.data;
|
|
r.in.cCorePrinterDrivers = 1;
|
|
r.out.pCorePrinterDrivers = talloc_zero_array(tctx, struct spoolss_CorePrinterDriver, r.in.cCorePrinterDrivers);
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncGetCorePrinterDrivers_r(b, tctx, &r),
|
|
"winspool_AsyncCorePrinterDrivers failed");
|
|
torture_assert_hresult_ok(tctx, r.out.result,
|
|
"winspool_AsyncCorePrinterDrivers failed");
|
|
|
|
if (package_id) {
|
|
*package_id = r.out.pCorePrinterDrivers[0].szPackageID;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_AsyncDeletePrintDriverPackage(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
struct winspool_AsyncDeletePrinterDriverPackage r;
|
|
|
|
const char *architectures[] = {
|
|
/* SPOOLSS_ARCHITECTURE_NT_X86, */
|
|
SPOOLSS_ARCHITECTURE_x64
|
|
};
|
|
int i;
|
|
|
|
for (i=0; i < ARRAY_SIZE(architectures); i++) {
|
|
|
|
const char *package_id;
|
|
|
|
torture_assert(tctx,
|
|
test_get_core_printer_drivers_arch_guid(tctx, p,
|
|
architectures[i],
|
|
SPOOLSS_CORE_PRINT_PACKAGE_FILES_XPSDRV,
|
|
&package_id),
|
|
"failed to get core printer driver");
|
|
|
|
r.in.pszServer = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
r.in.pszEnvironment = "";
|
|
r.in.pszInfPath = "";
|
|
|
|
torture_comment(tctx, "Testing AsyncDeletePrinterDriverPackage(%s, %s, %s)\n",
|
|
r.in.pszServer, architectures[i], package_id);
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncDeletePrinterDriverPackage_r(b, tctx, &r),
|
|
"AsyncDeletePrinterDriverPackage failed");
|
|
torture_assert_werr_equal(tctx,
|
|
W_ERROR(WIN32_FROM_HRESULT(r.out.result)), WERR_NOT_FOUND,
|
|
"AsyncDeletePrinterDriverPackage failed");
|
|
|
|
r.in.pszInfPath = package_id;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncDeletePrinterDriverPackage_r(b, tctx, &r),
|
|
"AsyncDeletePrinterDriverPackage failed");
|
|
torture_assert_werr_equal(tctx,
|
|
W_ERROR(WIN32_FROM_HRESULT(r.out.result)), WERR_INVALID_ENVIRONMENT,
|
|
"AsyncDeletePrinterDriverPackage failed");
|
|
|
|
r.in.pszEnvironment = architectures[i];
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncDeletePrinterDriverPackage_r(b, tctx, &r),
|
|
"AsyncDeletePrinterDriverPackage failed");
|
|
torture_assert_hresult_equal(tctx, r.out.result, HRES_E_ACCESSDENIED,
|
|
"AsyncDeletePrinterDriverPackage failed");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_AsyncGetPrinterDriverDirectory(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
struct dcerpc_binding_handle *b = p->binding_handle;
|
|
struct winspool_AsyncGetPrinterDriverDirectory r;
|
|
uint32_t pcbNeeded;
|
|
DATA_BLOB blob;
|
|
const char *s;
|
|
|
|
r.in.pName = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
r.in.pEnvironment = ctx->environment;
|
|
r.in.Level = 1;
|
|
r.in.cbBuf = 0x200;
|
|
r.in.pDriverDirectory = talloc_zero_array(tctx, uint8_t, r.in.cbBuf);
|
|
r.out.pcbNeeded = &pcbNeeded;
|
|
r.out.pDriverDirectory = r.in.pDriverDirectory;
|
|
|
|
torture_comment(tctx, "Testing AsyncGetPrinterDriverDirectory(%s, %s)\n",
|
|
r.in.pName, r.in.pEnvironment);
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_winspool_AsyncGetPrinterDriverDirectory_r(b, tctx, &r),
|
|
"AsyncGetPrinterDriverDirectory failed");
|
|
torture_assert_werr_ok(tctx, r.out.result,
|
|
"AsyncGetPrinterDriverDirectory failed");
|
|
|
|
blob = data_blob_const(r.out.pDriverDirectory, pcbNeeded);
|
|
|
|
torture_assert(tctx,
|
|
pull_reg_sz(tctx, &blob, &s),
|
|
"failed to pull reg_sz");
|
|
|
|
torture_comment(tctx, "got: %s\n", s);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Test if one can close a printserver handle that has been acquired via
|
|
* winspool_AsyncOpenPrinter with a spoolss_ClosePrinter operation.
|
|
*/
|
|
|
|
static bool test_OpenPrinter(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct test_iremotewinspool_context *ctx =
|
|
talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
|
|
|
|
struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
|
|
const char *printer_name;
|
|
struct policy_handle handle;
|
|
struct dcerpc_pipe *s;
|
|
struct dcerpc_binding *binding;
|
|
struct spoolss_UserLevel1 client_info;
|
|
struct spoolss_ClosePrinter r;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
torture_rpc_binding(tctx, &binding),
|
|
"failed to get binding");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_binding_set_transport(binding, NCACN_NP),
|
|
"failed to set ncacn_np transport");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_binding_set_object(binding, GUID_zero()),
|
|
"failed to set object uuid to zero");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
torture_rpc_connection_with_binding(tctx, binding, &s, &ndr_table_spoolss),
|
|
"failed to connect to spoolss");
|
|
|
|
printer_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
|
|
client_info = test_get_client_info(tctx, WIN_7, 6, 1, "testclient_machine", "testclient_user");
|
|
|
|
torture_assert(tctx,
|
|
test_AsyncOpenPrinter_byprinter(tctx, ctx, p, printer_name, client_info, &handle),
|
|
"failed to open printserver via winspool");
|
|
|
|
|
|
r.in.handle = &handle;
|
|
r.out.handle = &handle;
|
|
|
|
torture_assert_ntstatus_equal(tctx,
|
|
dcerpc_spoolss_ClosePrinter_r(s->binding_handle, tctx, &r),
|
|
NT_STATUS_RPC_SS_CONTEXT_MISMATCH,
|
|
"ClosePrinter failed");
|
|
|
|
talloc_free(s);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_object_one_uuid(struct torture_context *tctx,
|
|
const struct GUID *object_uuid,
|
|
NTSTATUS expected_status,
|
|
uint32_t expected_fault_code)
|
|
{
|
|
const char *printer_name;
|
|
struct spoolss_UserLevel1 client_info;
|
|
struct dcerpc_binding *binding;
|
|
struct dcerpc_pipe *p;
|
|
struct policy_handle server_handle;
|
|
|
|
torture_comment(tctx, "Testing with object_uuid: %s\n",
|
|
GUID_string(tctx, object_uuid));
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
torture_rpc_binding(tctx, &binding),
|
|
"failed to retrieve torture binding");
|
|
|
|
if (object_uuid) {
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_binding_set_object(binding, *object_uuid),
|
|
"failed to set object_uuid");
|
|
}
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
torture_rpc_connection_with_binding(tctx, binding, &p,
|
|
&ndr_table_iremotewinspool),
|
|
"Error connecting to server");
|
|
|
|
printer_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
|
|
torture_assert(tctx, printer_name, "out of memory");
|
|
|
|
client_info = test_get_client_info(tctx,
|
|
WIN_7, 6, 1, "testclient_machine", "testclient_user");
|
|
|
|
torture_assert(tctx,
|
|
test_AsyncOpenPrinter_byprinter_expect(tctx, NULL,
|
|
p,
|
|
printer_name,
|
|
SEC_FLAG_MAXIMUM_ALLOWED,
|
|
client_info,
|
|
expected_status,
|
|
WERR_OK,
|
|
expected_fault_code,
|
|
&server_handle),
|
|
"failed to open printserver");
|
|
if (NT_STATUS_IS_OK(expected_status)) {
|
|
test_AsyncClosePrinter_byhandle(tctx, NULL, p, &server_handle);
|
|
}
|
|
|
|
talloc_free(p);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_object_uuid(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
struct GUID object_uuid;
|
|
|
|
torture_assert(tctx,
|
|
test_object_one_uuid(tctx, NULL,
|
|
NT_STATUS_RPC_NOT_RPC_ERROR,
|
|
DCERPC_NCA_S_UNSUPPORTED_TYPE),
|
|
"failed to test NULL object uuid");
|
|
|
|
object_uuid = GUID_zero();
|
|
torture_assert(tctx,
|
|
test_object_one_uuid(tctx, &object_uuid,
|
|
NT_STATUS_RPC_NOT_RPC_ERROR,
|
|
DCERPC_NCA_S_UNSUPPORTED_TYPE),
|
|
"failed to test zeroed object uuid");
|
|
|
|
object_uuid = GUID_random();
|
|
torture_assert(tctx,
|
|
test_object_one_uuid(tctx, &object_uuid,
|
|
NT_STATUS_RPC_NOT_RPC_ERROR,
|
|
DCERPC_NCA_S_UNSUPPORTED_TYPE),
|
|
"failed to test random object uuid");
|
|
|
|
GUID_from_string(IREMOTEWINSPOOL_OBJECT_GUID, &object_uuid);
|
|
torture_assert(tctx,
|
|
test_object_one_uuid(tctx, &object_uuid,
|
|
NT_STATUS_OK,
|
|
0),
|
|
"failed to test IREMOTEWINSPOOL_OBJECT_GUID");
|
|
|
|
torture_assert(tctx,
|
|
test_object_one_uuid(tctx, &ndr_table_spoolss.syntax_id.uuid,
|
|
NT_STATUS_RPC_NOT_RPC_ERROR,
|
|
DCERPC_NCA_S_UNSUPPORTED_TYPE),
|
|
"failed to test spoolss interface uuid");
|
|
|
|
torture_assert(tctx,
|
|
test_object_one_uuid(tctx, &ndr_table_iremotewinspool.syntax_id.uuid,
|
|
NT_STATUS_RPC_NOT_RPC_ERROR,
|
|
DCERPC_NCA_S_UNSUPPORTED_TYPE),
|
|
"failed to test iremotewinspool interface uuid");
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_setup_binding_handle(struct torture_context *tctx,
|
|
struct GUID object_uuid,
|
|
enum dcerpc_transport_t transport,
|
|
const struct ndr_interface_table *table,
|
|
struct dcerpc_pipe **p)
|
|
{
|
|
struct dcerpc_binding *binding;
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
torture_rpc_binding(tctx, &binding),
|
|
"failed to retrieve torture binding");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_binding_set_object(binding, object_uuid),
|
|
"failed to set object_uuid");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
dcerpc_binding_set_transport(binding, transport),
|
|
"failed to set transport");
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
torture_rpc_connection_with_binding(tctx, binding, p, table),
|
|
"Error connecting to server");
|
|
|
|
return true;
|
|
}
|
|
|
|
static enum ndr_err_code ndr_push_inout_blob(DATA_BLOB *blob,
|
|
TALLOC_CTX *mem_ctx,
|
|
ndr_flags_type flags,
|
|
const void *p,
|
|
ndr_push_flags_fn_t fn)
|
|
{
|
|
struct ndr_push *ndr;
|
|
ndr = ndr_push_init_ctx(mem_ctx);
|
|
NDR_ERR_HAVE_NO_MEMORY(ndr);
|
|
|
|
NDR_CHECK_FREE(fn(ndr, flags, p));
|
|
|
|
*blob = ndr_push_blob(ndr);
|
|
talloc_steal(mem_ctx, blob->data);
|
|
talloc_free(ndr);
|
|
|
|
return NDR_ERR_SUCCESS;
|
|
}
|
|
|
|
static bool test_compare_spoolss(struct torture_context *tctx,
|
|
void *private_data)
|
|
{
|
|
DATA_BLOB reply_iremotewinspool, reply_spoolss, request_spoolss;
|
|
struct dcerpc_pipe *iremotewinspool_pipe, *spoolss_pipe;
|
|
struct GUID object_uuid;
|
|
uint32_t out_flags;
|
|
NTSTATUS status;
|
|
struct spoolss_EnumPrinters r;
|
|
DATA_BLOB blob;
|
|
|
|
/* setup two dcerpc pipes */
|
|
|
|
torture_assert_ntstatus_ok(tctx,
|
|
GUID_from_string(IREMOTEWINSPOOL_OBJECT_GUID, &object_uuid),
|
|
"failed to parse GUID");
|
|
|
|
torture_assert(tctx,
|
|
test_setup_binding_handle(tctx, object_uuid, NCACN_IP_TCP,
|
|
&ndr_table_iremotewinspool, &iremotewinspool_pipe),
|
|
"failed to setup binding handle");
|
|
|
|
torture_assert(tctx,
|
|
test_setup_binding_handle(tctx, GUID_zero(), NCACN_NP,
|
|
&ndr_table_spoolss, &spoolss_pipe),
|
|
"failed to setup binding handle");
|
|
|
|
|
|
/* create a spoolss enumprinters request */
|
|
|
|
ZERO_STRUCT(r);
|
|
|
|
blob = data_blob_talloc_zero(tctx, 0x1000);
|
|
|
|
r.in.flags = PRINTER_ENUM_LOCAL;
|
|
r.in.server = talloc_asprintf(tctx, "\\\\%s",
|
|
dcerpc_server_name(spoolss_pipe));
|
|
r.in.level = 1;
|
|
r.in.buffer = &blob;
|
|
r.in.offered = blob.length;
|
|
|
|
torture_assert_ndr_success(tctx,
|
|
ndr_push_inout_blob(&request_spoolss, tctx, NDR_IN | NDR_SET_VALUES, &r,
|
|
(ndr_push_flags_fn_t)ndr_push_spoolss_EnumPrinters),
|
|
"failed to push EnumPrinters request");
|
|
|
|
/* send same request to both endpoints */
|
|
|
|
status = dcerpc_binding_handle_raw_call(iremotewinspool_pipe->binding_handle,
|
|
NULL,
|
|
NDR_WINSPOOL_ASYNCENUMPRINTERS,
|
|
0, /* in_flags */
|
|
request_spoolss.data,
|
|
request_spoolss.length,
|
|
tctx,
|
|
&reply_iremotewinspool.data,
|
|
&reply_iremotewinspool.length,
|
|
&out_flags);
|
|
torture_assert_ntstatus_ok(tctx, status, "dcerpc_binding_handle_raw_call failed");
|
|
|
|
status = dcerpc_binding_handle_raw_call(spoolss_pipe->binding_handle,
|
|
NULL,
|
|
NDR_SPOOLSS_ENUMPRINTERS,
|
|
0, /* in_flags */
|
|
request_spoolss.data,
|
|
request_spoolss.length,
|
|
tctx,
|
|
&reply_spoolss.data,
|
|
&reply_spoolss.length,
|
|
&out_flags);
|
|
torture_assert_ntstatus_ok(tctx, status, "dcerpc_binding_handle_raw_call failed");
|
|
|
|
torture_assert_data_blob_equal(tctx,
|
|
reply_iremotewinspool,
|
|
reply_spoolss,
|
|
"unexpected difference in replies from spoolss and iremotewinspool servers");
|
|
|
|
talloc_free(iremotewinspool_pipe);
|
|
talloc_free(spoolss_pipe);
|
|
|
|
return true;
|
|
}
|
|
|
|
struct torture_suite *torture_rpc_iremotewinspool(TALLOC_CTX *mem_ctx)
|
|
{
|
|
struct torture_suite *suite = torture_suite_create(mem_ctx, "iremotewinspool");
|
|
struct torture_tcase *tcase = torture_suite_add_tcase(suite, "printserver");
|
|
|
|
torture_tcase_set_fixture(tcase,
|
|
torture_rpc_iremotewinspool_setup,
|
|
torture_rpc_iremotewinspool_teardown);
|
|
|
|
torture_tcase_add_simple_test(tcase, "AsyncOpenPrinter", test_AsyncOpenPrinter);
|
|
torture_tcase_add_simple_test(tcase, "SyncRegisterForRemoteNotifications", test_SyncRegisterForRemoteNotifications);
|
|
torture_tcase_add_simple_test(tcase, "SyncUnRegisterForRemoteNotifications", test_SyncUnRegisterForRemoteNotifications);
|
|
torture_tcase_add_simple_test(tcase, "AsyncClosePrinter", test_AsyncClosePrinter);
|
|
torture_tcase_add_simple_test(tcase, "AsyncUploadPrinterDriverPackage", test_AsyncUploadPrinterDriverPackage);
|
|
torture_tcase_add_simple_test(tcase, "AsyncEnumPrinters", test_AsyncEnumPrinters);
|
|
torture_tcase_add_simple_test(tcase, "AsyncGetPrinterData", test_AsyncGetPrinterData);
|
|
torture_tcase_add_simple_test(tcase, "AsyncCorePrinterDriverInstalled", test_AsyncCorePrinterDriverInstalled);
|
|
torture_tcase_add_simple_test(tcase, "AsyncDeletePrintDriverPackage", test_AsyncDeletePrintDriverPackage);
|
|
torture_tcase_add_simple_test(tcase, "AsyncGetPrinterDriverDirectory", test_AsyncGetPrinterDriverDirectory);
|
|
torture_tcase_add_simple_test(tcase, "AsyncOpenPrinterValidateBuildNumber", test_AsyncOpenPrinterValidateBuildNumber);
|
|
|
|
tcase = torture_suite_add_tcase(suite, "handles");
|
|
|
|
torture_tcase_set_fixture(tcase,
|
|
torture_rpc_iremotewinspool_setup,
|
|
torture_rpc_iremotewinspool_teardown);
|
|
|
|
torture_tcase_add_simple_test(tcase, "OpenPrinter", test_OpenPrinter);
|
|
|
|
tcase = torture_suite_add_tcase(suite, "protocol");
|
|
torture_tcase_add_simple_test(tcase, "object_uuid", test_object_uuid);
|
|
torture_tcase_add_simple_test(tcase, "compare_spoolss", test_compare_spoolss);
|
|
|
|
return suite;
|
|
}
|