summaryrefslogtreecommitdiffstats
path: root/source4/torture/rpc/iremotewinspool_driver.c
diff options
context:
space:
mode:
Diffstat (limited to 'source4/torture/rpc/iremotewinspool_driver.c')
-rw-r--r--source4/torture/rpc/iremotewinspool_driver.c840
1 files changed, 840 insertions, 0 deletions
diff --git a/source4/torture/rpc/iremotewinspool_driver.c b/source4/torture/rpc/iremotewinspool_driver.c
new file mode 100644
index 0000000..f88b13a
--- /dev/null
+++ b/source4/torture/rpc/iremotewinspool_driver.c
@@ -0,0 +1,840 @@
+/*
+ Unix SMB/CIFS implementation.
+ test suite for iremotewinspool driver rpc operations
+
+ Copyright (C) Justin Stephenson 2018
+
+ 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 <dirent.h>
+#include <talloc.h>
+#include <libgen.h>
+#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 "librpc/gen_ndr/ndr_winreg_c.h"
+#include "torture/rpc/torture_rpc.h"
+#include "libcli/registry/util_reg.h"
+#include "torture/rpc/iremotewinspool_common.h"
+#include "libcli/libcli.h"
+#include "param/param.h"
+#include "lib/registry/registry.h"
+#include "libcli/libcli.h"
+#include "libcli/raw/raw_proto.h"
+#include "libcli/resolve/resolve.h"
+#include "libcli/smb2/smb2.h"
+#include "libcli/smb2/smb2_calls.h"
+#include "lib/cmdline/cmdline.h"
+#include "system/filesys.h"
+#include "lib/util/tftw.h"
+
+/* Connect to print driver share //server_name/share */
+static bool smb_connect_print_share(struct torture_context *tctx,
+ const char *server_name,
+ const char *share_name,
+ struct smbcli_state **cli)
+{
+ NTSTATUS status;
+ bool ok = true;
+
+ struct smbcli_options smb_options;
+ struct smbcli_session_options smb_session_options;
+
+ torture_comment(tctx, "Connecting to printer driver share '//%s/%s'\n",
+ server_name, share_name);
+
+ lpcfg_smbcli_options(tctx->lp_ctx, &smb_options);
+ lpcfg_smbcli_session_options(tctx->lp_ctx, &smb_session_options);
+
+ /* On Windows, SMB1 must be enabled! */
+ status = smbcli_full_connection(tctx, cli, server_name,
+ lpcfg_smb_ports(tctx->lp_ctx),
+ share_name, NULL,
+ lpcfg_socket_options(tctx->lp_ctx),
+ samba_cmdline_get_creds(),
+ lpcfg_resolve_context(tctx->lp_ctx),
+ tctx->ev,
+ &smb_options,
+ &smb_session_options,
+ lpcfg_gensec_settings(tctx, tctx->lp_ctx));
+
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "Failed to connect to print$ share");
+
+done:
+
+ return ok;
+}
+
+/* Copy file to destination where dst_fpath is a smb share path,
+ * files are either created or overwritten */
+static bool smb_copy_files(TALLOC_CTX *tctx,
+ const char *fpath,
+ const char *dst_fpath,
+ struct test_driver_info *dinfo)
+{
+ FILE *fp;
+ int smbfp = 0;
+ char *buffer = NULL;
+ int maxwrite = 64512;
+ size_t nread;
+ ssize_t nwrote;
+ bool ok = true;
+ size_t total_read;
+
+ fp = fopen(fpath, "r");
+ torture_assert_goto(tctx, fp, ok, done, "Failed to open local file\n");
+
+ smbfp = smbcli_open(dinfo->cli->tree, dst_fpath, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
+ torture_assert_int_not_equal_goto(tctx, smbfp, -1, ok, done, "Failed to open dst file\n");
+
+ buffer = talloc_array(tctx, char, maxwrite);
+ torture_assert_not_null_goto(tctx, buffer, ok, done, "Failed to allocate buffer\n");
+
+ total_read = 0;
+
+ while (!feof(fp)) {
+ nread = fread(buffer, 1, maxwrite, fp);
+ if (ferror(fp)) {
+ torture_warning(tctx, "Error reading file [%s]\n", fpath);
+ continue;
+ }
+
+ nwrote = smbcli_write(dinfo->cli->tree, smbfp, 0, buffer, total_read, nread);
+ if (nwrote != nread) {
+ torture_warning(tctx, "Not all data in stream written!\n");
+ }
+
+ total_read += nread;
+ }
+
+ fclose(fp);
+ smbcli_close(dinfo->cli->tree, smbfp);
+done:
+
+ TALLOC_FREE(buffer);
+ return ok;
+}
+
+/* Callback function provided to tftw() to
+ * copy driver files to smb share */
+static int copy_driver_files(TALLOC_CTX *tctx,
+ const char *fpath,
+ const struct stat *sb,
+ enum tftw_flags_e flag,
+ void *userdata)
+{
+ char *dst_fpath = NULL;
+ struct test_driver_info *dinfo = userdata;
+ char *path = NULL;
+ NTSTATUS status;
+ bool ok = true;
+
+ path = talloc_strdup(tctx, fpath + dinfo->driver_path_len);
+ torture_assert_not_null_goto(tctx, path, ok, done, "Cannot allocate memory");
+
+ string_replace(path, '/', '\\');
+
+ dst_fpath = talloc_asprintf(tctx, "%s%s", dinfo->print_upload_guid_dir, path);
+ torture_assert_not_null_goto(tctx, dst_fpath, ok, done, "Cannot allocate memory");
+
+ switch (flag) {
+ case TFTW_FLAG_FILE:
+ ok = smb_copy_files(tctx, fpath, dst_fpath, dinfo);
+ torture_assert_goto(tctx, ok, ok, done, "Failed to copy files over smb");
+ break;
+ case TFTW_FLAG_DIR:
+ status = smbcli_mkdir(dinfo->cli->tree, dst_fpath);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "Failed to create directories");
+ break;
+ case TFTW_FLAG_SLINK:
+ case TFTW_FLAG_DNR:
+ case TFTW_FLAG_NSTAT:
+ case TFTW_FLAG_SPEC:
+ case TFTW_FLAG_DP:
+ case TFTW_FLAG_SLN:
+ torture_warning(tctx, "WARN: Unhandled typeflag [%s]\n", fpath);
+ break;
+ }
+
+done:
+ TALLOC_FREE(path);
+ TALLOC_FREE(dst_fpath);
+
+ if (ok == true) {
+ return 0;
+ } else {
+ return 1;
+ }
+}
+
+static bool test_get_driver_torture_options(struct torture_context *tctx,
+ const char **_local_driver_path,
+ const char **_inf_file,
+ const char **_driver_name,
+ const char **_driver_arch,
+ const char **_core_driver_inf)
+{
+ const char *local_driver_path = NULL;
+ const char *inf_file = NULL;
+ const char *driver_name = NULL;
+ const char *driver_arch = NULL;
+ const char *core_driver_inf = NULL;
+ const char *arches_list[] = {
+ SPOOLSS_ARCHITECTURE_x64,
+ SPOOLSS_ARCHITECTURE_NT_X86,
+ SPOOLSS_ARCHITECTURE_IA_64,
+ SPOOLSS_ARCHITECTURE_ARM,
+ SPOOLSS_ARCHITECTURE_4_0,
+ NULL,
+ };
+ const char **p;
+ bool valid = false;
+ bool ok = true;
+
+ local_driver_path = torture_setting_string(tctx, "driver_path", NULL);
+ if (local_driver_path == NULL) {
+ torture_fail(tctx,
+ "option --option=torture:driver_path="
+ "/full/path/to/local/driver/dir\n");
+ }
+
+ inf_file = torture_setting_string(tctx, "inf_file", NULL);
+ if (inf_file == NULL) {
+ torture_fail(tctx,
+ "option --option=torture:inf_file="
+ "filename.inf\n");
+ }
+
+ driver_name = torture_setting_string(tctx, "driver_name", NULL);
+ if (driver_name == NULL) {
+ torture_fail(tctx,
+ "option --option=torture:driver_name="
+ "driver name\n");
+ }
+
+ driver_arch = torture_setting_string(tctx, "driver_arch", NULL);
+ if (driver_arch == NULL) {
+ torture_fail(tctx,
+ "option --option=torture:driver_arch="
+ "driver arch\n");
+ }
+
+ core_driver_inf = torture_setting_string(tctx, "core_driver_inf", NULL);
+
+ for (p = arches_list; *p != NULL; p++) {
+ if (strequal(*p, driver_arch) == 0) {
+ valid = true;
+ break;
+ }
+ }
+ torture_assert_goto(tctx, valid, ok, done, "Invalid driver arch provided");
+
+ *_local_driver_path = local_driver_path;
+ *_inf_file = inf_file;
+ *_driver_name = driver_name;
+ *_driver_arch = driver_arch;
+ *_core_driver_inf = core_driver_inf;
+done:
+ return ok;
+}
+
+
+static bool test_get_misc_driver_info(struct torture_context *tctx,
+ struct test_driver_info *dinfo,
+ const char **_abs_inf_path,
+ size_t *_driver_path_len)
+{
+ const char *abs_inf_path;
+ size_t driver_path_len;
+ bool ok = true;
+
+ driver_path_len = strlen(dinfo->local_driver_path);
+ torture_assert_int_not_equal_goto(tctx, driver_path_len, 0, ok, done, "driver path length is 0");
+
+ abs_inf_path = talloc_asprintf(tctx, "%s/%s", dinfo->local_driver_path, dinfo->inf_file);
+ torture_assert_not_null_goto(tctx, abs_inf_path, ok, done, "Cannot allocate memory");
+
+ *_abs_inf_path = abs_inf_path;
+ *_driver_path_len = driver_path_len;
+done:
+
+ return ok;
+}
+
+/* Uninstall the previously installed print driver */
+static bool test_uninstall_printer_driver(struct torture_context *tctx,
+ struct test_iremotewinspool_context *ctx)
+{
+ struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+ struct winspool_AsyncDeletePrinterDriverEx r;
+ bool ok = true;
+ NTSTATUS status;
+
+ r.in.pName = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
+
+ r.in.pDriverName = talloc_strdup(tctx, ctx->dinfo->driver_name);
+ torture_assert_not_null_goto(tctx, r.in.pDriverName, ok, done, "Cannot allocate memory");
+
+ r.in.pEnvironment = SPOOLSS_ARCHITECTURE_x64;
+
+ r.in.dwDeleteFlag = 0;
+ r.in.dwVersionNum = 0;
+
+ status = dcerpc_winspool_AsyncDeletePrinterDriverEx_r(b, tctx, &r);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "AsyncDeletePrinterDriverEx failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "AsyncDeletePrinterDriverEx failed");
+done:
+
+ return ok;
+}
+
+/* Remove the leftover print driver package files from the driver store */
+static bool test_remove_driver_package(struct torture_context *tctx,
+ struct test_iremotewinspool_context *ctx)
+{
+ struct dcerpc_pipe *p = ctx->iremotewinspool_pipe;
+ struct dcerpc_binding_handle *b = p->binding_handle;
+ struct winspool_AsyncDeletePrinterDriverPackage r;
+ bool ok = true;
+ NTSTATUS status;
+
+ r.in.pszServer = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
+ torture_assert_not_null_goto(tctx, r.in.pszServer, ok, done, "Cannot allocate memory");
+
+ r.in.pszInfPath = ctx->dinfo->uploaded_inf_path;
+
+ r.in.pszEnvironment = SPOOLSS_ARCHITECTURE_x64;
+
+ status = dcerpc_winspool_AsyncDeletePrinterDriverPackage_r(b, tctx, &r);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "AsyncDeletePrinterPackage failed");
+
+ torture_assert_hresult_ok(tctx, r.out.result, "AsyncDeletePrinterDriverPackage failed");
+done:
+
+ return ok;
+}
+
+static bool test_winreg_iremotewinspool_openhklm(struct torture_context *tctx,
+ struct dcerpc_binding_handle *winreg_bh,
+ struct policy_handle *_hklm_handle)
+{
+ struct winreg_OpenHKLM r;
+ NTSTATUS status;
+ bool ok = true;
+
+ r.in.system_name = NULL;
+ r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
+ r.out.handle = _hklm_handle;
+
+ status = dcerpc_winreg_OpenHKLM_r(winreg_bh, tctx, &r);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "Failed to Open HKLM");
+
+ torture_assert_werr_ok(tctx, r.out.result, "Failed to Open HKLM");
+done:
+
+ return ok;
+}
+
+static bool test_winreg_iremotewinspool_openkey(struct torture_context *tctx,
+ struct dcerpc_binding_handle *winreg_bh,
+ struct policy_handle *hklm_handle,
+ const char *keyname,
+ struct policy_handle *_key_handle)
+{
+ struct winreg_OpenKey r;
+ NTSTATUS status;
+ bool ok = true;
+
+ r.in.parent_handle = hklm_handle;
+ init_winreg_String(&r.in.keyname, keyname);
+ r.in.options = REG_OPTION_NON_VOLATILE;
+ r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
+ r.out.handle = _key_handle;
+
+ status = dcerpc_winreg_OpenKey_r(winreg_bh, tctx, &r);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "OpenKey failed");
+
+ torture_assert_werr_ok(tctx, r.out.result, "OpenKey failed");
+done:
+
+ return ok;
+}
+
+static bool test_winreg_iremotewinspool_queryvalue(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b,
+ struct policy_handle *key_handle,
+ const char *value_name,
+ const char **_valuestr)
+{
+ struct winreg_QueryValue r;
+ enum winreg_Type type = REG_NONE;
+ struct winreg_String valuename;
+ DATA_BLOB blob;
+ const char *str;
+ uint32_t data_size = 0;
+ uint32_t data_length = 0;
+ uint8_t *data = NULL;
+ NTSTATUS status;
+ bool ok = true;
+
+ init_winreg_String(&valuename, value_name);
+
+ data = talloc_zero_array(tctx, uint8_t, 0);
+
+ r.in.handle = key_handle;
+ r.in.value_name = &valuename;
+ r.in.type = &type;
+ r.in.data_size = &data_size;
+ r.in.data_length = &data_length;
+ r.in.data = data;
+
+ r.out.type = &type;
+ r.out.data = data;
+ r.out.data_size = &data_size;
+ r.out.data_length = &data_length;
+
+ status = dcerpc_winreg_QueryValue_r(b, tctx, &r);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "winreg_QueryValue failure");
+
+ torture_assert_ntstatus_ok(tctx, dcerpc_winreg_QueryValue_r(b, tctx, &r), "QueryValue failed");
+ if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
+ *r.in.data_size = *r.out.data_size;
+ data = talloc_zero_array(tctx, uint8_t, *r.in.data_size);
+ r.in.data = data;
+ r.out.data = data;
+ status = dcerpc_winreg_QueryValue_r(b, tctx, &r);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "QueryValue failed");
+ }
+ torture_assert_werr_ok(tctx, r.out.result, "QueryValue failed");
+
+ torture_assert_int_equal_goto(tctx, *r.out.type, REG_SZ, ok, done, "unexpected type");
+ blob = data_blob(r.out.data, *r.out.data_size);
+ str = reg_val_data_string(tctx, REG_SZ, blob);
+
+ *_valuestr = str;
+done:
+
+ return ok;
+}
+
+/* Validate the installed driver subkey exists, and the InfPath
+ * value matches the pszDestInfPath from test_UploadPrinterDriverPackage */
+static bool test_winreg_validate_driver(struct torture_context *tctx,
+ struct dcerpc_pipe *winreg_pipe,
+ struct test_driver_info *dinfo)
+{
+ struct policy_handle hklm_handle;
+ struct policy_handle key_handle;
+ char *driver_key = NULL;
+ const char *val_name = NULL;
+ const char *val_str = NULL;
+ bool ok = true;
+
+ struct dcerpc_binding_handle *winreg_bh;
+ struct spoolss_AddDriverInfo8 *parsed_dinfo;
+
+ winreg_bh = winreg_pipe->binding_handle;
+ parsed_dinfo = dinfo->info;
+
+ /* OpenHKLM */
+ ok = test_winreg_iremotewinspool_openhklm(tctx, winreg_bh, &hklm_handle);
+ torture_assert_goto(tctx, ok, ok, done, "Failed to perform winreg OpenHKLM");
+
+ /* Open registry subkey for the installed print driver */
+ driver_key = talloc_asprintf(tctx, "%s\\Environments\\%s\\Drivers\\Version-%d\\%s",
+ REG_DRIVER_CONTROL_KEY,
+ parsed_dinfo->architecture,
+ parsed_dinfo->version,
+ parsed_dinfo->driver_name);
+ torture_assert_not_null_goto(tctx, driver_key, ok, done, "Cannot allocate driver_key string");
+ ok = test_winreg_iremotewinspool_openkey(tctx, winreg_bh, &hklm_handle,
+ driver_key,
+ &key_handle);
+ torture_assert_goto(tctx, ok, ok, done, "Failed to perform winreg OpenKey");
+
+ /* Read infpath value and validate this matches what was uploaded */
+ val_name = "InfPath";
+ ok = test_winreg_iremotewinspool_queryvalue(tctx, winreg_bh, &key_handle, val_name,
+ &val_str);
+ torture_assert_goto(tctx, ok, ok, done, "QueryValue failed");
+
+ torture_assert_casestr_equal(tctx, val_str,
+ dinfo->uploaded_inf_path,
+ "InfPath does not match uploaded inf");
+done:
+
+ return ok;
+}
+
+static bool test_init_iremotewinspool_conn(struct torture_context *tctx,
+ struct test_iremotewinspool_context *t)
+{
+ struct dcerpc_binding *binding = {0};
+ bool ok = true;
+ NTSTATUS status;
+
+ status = GUID_from_string(IREMOTEWINSPOOL_OBJECT_GUID, &t->object_uuid);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "failed to parse GUID");
+
+ status = torture_rpc_binding(tctx, &binding);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "failed to retrieve torture binding");
+
+ status = dcerpc_binding_set_object(binding, t->object_uuid);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "failed to set object_uuid");
+
+ status = torture_rpc_connection_with_binding(tctx, binding, &t->iremotewinspool_pipe,
+ &ndr_table_iremotewinspool);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "Error connecting to server");
+
+done:
+
+ return ok;
+
+}
+
+static bool test_init_iremotewinspool_openprinter(struct torture_context *tctx,
+ struct test_iremotewinspool_context *t)
+{
+ struct spoolss_UserLevel1 client_info = {0};
+ char *printer_name = NULL;
+ bool ok = true;
+
+ printer_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(t->iremotewinspool_pipe));
+ torture_assert_not_null_goto(tctx, printer_name, ok, done, "Cannot allocate memory");
+
+ client_info = test_get_client_info(tctx, WIN_7, 3, SPOOLSS_MINOR_VERSION_0,
+ "testclient_machine", "testclient_user");
+
+ ok = test_AsyncOpenPrinter_byprinter(tctx, t, t->iremotewinspool_pipe, printer_name,
+ client_info, &t->server_handle);
+ torture_assert_goto(tctx, ok, ok, done, "failed to open printserver");
+
+ ok = test_get_environment(tctx, t->iremotewinspool_pipe->binding_handle,
+ &t->server_handle, &t->environment);
+ torture_assert_goto(tctx, ok, ok, done, "failed to get environment");
+
+done:
+ TALLOC_FREE(printer_name);
+
+ return ok;
+}
+
+static bool test_init_driver_info(struct torture_context *tctx,
+ struct test_iremotewinspool_context *t)
+{
+ bool ok = true;
+ const char *abs_inf_path;
+ struct test_driver_info *drv_info = {0};
+
+ drv_info = talloc_zero(tctx, struct test_driver_info);
+ torture_assert_not_null_goto(tctx, drv_info, ok, done, "Cannot allocate memory");
+
+ t->dinfo = drv_info;
+
+ ok = test_get_driver_torture_options(tctx,
+ &drv_info->local_driver_path,
+ &drv_info->inf_file,
+ &drv_info->driver_name,
+ &drv_info->driver_arch,
+ &drv_info->core_driver_inf);
+ torture_assert_goto(tctx, ok, ok, done, "Failed to get driver torture options");
+
+ ok = test_get_misc_driver_info(tctx, drv_info,
+ &abs_inf_path,
+ &drv_info->driver_path_len);
+ torture_assert_goto(tctx, ok, ok, done, "Failed to get misc driver info");
+
+ ok = parse_inf_driver(tctx, drv_info->driver_name, abs_inf_path, drv_info->driver_arch,
+ drv_info->core_driver_inf, &drv_info->info);
+ torture_assert_goto(tctx, ok, ok, done, "Failed to parse inf driver");
+
+ /* Ensure that we are trying to install the correct device class:
+ * https://docs.microsoft.com/en-us/windows-hardware/drivers/install/system-defined-device-setup-classes-available-to-vendors
+ */
+ if (!(drv_info->info->printer_driver_attributes & PRINTER_DRIVER_CLASS)) {
+ ok = false;
+ torture_fail_goto(tctx, done, "Inf file Class value must be Printer");
+ }
+done:
+ return ok;
+
+}
+
+static bool test_init_server_and_share_info(struct torture_context *tctx,
+ struct test_iremotewinspool_context *t)
+{
+ struct GUID guid;
+ bool ok = true;
+
+ t->dinfo->server_name = talloc_asprintf(tctx, "%s", dcerpc_server_name(t->iremotewinspool_pipe));
+ torture_assert_not_null_goto(tctx, t->dinfo->server_name, ok, done, "Cannot allocate memory");
+
+ t->dinfo->share_name = talloc_strdup(tctx, "print$");
+ torture_assert_not_null_goto(tctx, t->dinfo->share_name, ok, done, "Cannot allocate memory");
+
+ guid = GUID_random();
+ t->dinfo->print_upload_guid_dir = GUID_string2(tctx, &guid);
+done:
+ return ok;
+}
+
+
+static bool torture_rpc_iremotewinspool_drv_setup_common(struct torture_context *tctx,
+ struct test_iremotewinspool_context *t)
+{
+ bool ok = true;
+ int ret = 0;
+
+ ok = test_init_driver_info(tctx, t);
+ torture_assert_goto(tctx, ok, ok, done, "failed to init driver info");
+
+ ok = test_init_iremotewinspool_conn(tctx, t);
+ torture_assert_goto(tctx, ok, ok, done, "failed to init iremotewinspool conn");
+
+ ok = test_init_iremotewinspool_openprinter(tctx, t);
+ torture_assert_goto(tctx, ok, ok, done, "failed to init iremotewinspool openprinter");
+
+ ok = test_init_server_and_share_info(tctx, t);
+ torture_assert_goto(tctx, ok, ok, done, "failed to init server and share info");
+
+ ret = smb_connect_print_share(tctx, t->dinfo->server_name, t->dinfo->share_name, &t->dinfo->cli);
+ torture_assert_goto(tctx, ret, ok, done, "Failed to connect to print share");
+
+done:
+
+ return ok;
+}
+
+static bool torture_rpc_iremotewinspool_drv_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_drv_setup_common(tctx, t);
+}
+
+static bool torture_rpc_iremotewinspool_drv_teardown_common(struct torture_context *tctx,
+ struct test_iremotewinspool_context *t)
+{
+ smbcli_deltree(t->dinfo->cli->tree, t->dinfo->print_upload_guid_dir);
+ smb_raw_exit(t->dinfo->cli->session);
+
+ test_uninstall_printer_driver(tctx, t);
+ test_remove_driver_package(tctx, t);
+
+ test_AsyncClosePrinter_byhandle(tctx, t, t->iremotewinspool_pipe, &t->server_handle);
+
+ return true;
+}
+
+static bool torture_rpc_iremotewinspool_drv_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_drv_teardown_common(tctx, t);
+ talloc_free(t);
+
+ return ret;
+}
+
+/* Creates {GUID} directory inside //server/print$ then copies driver files
+ * and directories from torture option driver_path to this directory over smb */
+static bool test_CopyDriverFiles(struct torture_context *tctx,
+ void *private_data)
+{
+ struct test_iremotewinspool_context *ctx =
+ talloc_get_type_abort(private_data, struct test_iremotewinspool_context);
+
+ bool ret = false;
+ bool ok = true;
+ NTSTATUS status;
+
+ status = smbcli_mkdir(ctx->dinfo->cli->tree, ctx->dinfo->print_upload_guid_dir);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "Failed to create upload directory");
+
+ /* Walk the provided torture option driver_path file tree, creating the directory heirarchy and
+ * copying all files to print$/{GUID}/ share */
+ ret = tftw(tctx, ctx->dinfo->local_driver_path, copy_driver_files, TFTW_MAX_DEPTH, ctx->dinfo);
+ torture_assert_int_equal_goto(tctx, ret, 0, ok, done, "Failed to copy driver files to print$/{GUID}/ dir");
+
+done:
+
+ return ok;
+}
+
+/*
+ * Upload print driver package files and inf file, preparing the print server
+ * for driver installation
+ */
+static bool test_UploadPrinterDriverPackage(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 spoolss_AddDriverInfo8 *parsed_dinfo;
+ struct winspool_AsyncUploadPrinterDriverPackage r;
+ uint32_t pcchDestInfPath = 0;
+ NTSTATUS status;
+ bool ok = true;
+
+ parsed_dinfo = ctx->dinfo->info;
+
+ r.in.pszServer = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
+ torture_assert_not_null_goto(tctx, r.in.pszServer, ok, done, "Cannot allocate memory");
+
+ r.in.pszInfPath = talloc_asprintf(tctx, "\\\\%s\\%s\\%s\\%s", ctx->dinfo->server_name,
+ ctx->dinfo->share_name,
+ ctx->dinfo->print_upload_guid_dir,
+ ctx->dinfo->inf_file);
+ torture_assert_not_null_goto(tctx, r.in.pszInfPath, ok, done, "Cannot allocate memory");
+
+ r.in.pszEnvironment = parsed_dinfo->architecture;
+ /* Upload driver package files even if the driver package is already present
+ * on the print server */
+ r.in.dwFlags = UPDP_UPLOAD_ALWAYS;
+ pcchDestInfPath = 260;
+ r.in.pszDestInfPath = NULL;
+ r.in.pcchDestInfPath = &pcchDestInfPath;
+ r.out.pszDestInfPath = NULL;
+ r.out.pcchDestInfPath = &pcchDestInfPath;
+
+ r.in.pszDestInfPath = talloc_zero(tctx, const char);
+ torture_assert_not_null_goto(tctx, r.in.pszDestInfPath, ok, done, "Cannot allocate memory");
+ r.out.pszDestInfPath = talloc_zero(tctx, const char);
+ torture_assert_not_null_goto(tctx, r.out.pszDestInfPath, ok, done, "Cannot allocate memory");
+
+ status = dcerpc_winspool_AsyncUploadPrinterDriverPackage_r(b, tctx, &r);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "AsyncUploadPrinterDriverPackage failed");
+
+ torture_assert_hresult_ok(tctx, r.out.result, "AsyncUploadPrinterDriverPackage failed");
+
+ ctx->dinfo->uploaded_inf_path = talloc_strdup(tctx, r.out.pszDestInfPath);
+ torture_assert_not_null_goto(tctx, ctx->dinfo->uploaded_inf_path, ok, done, "Cannot allocate memory");
+
+done:
+
+ return ok;
+}
+
+/* Install the driver that was successfully uploaded to the printer driver
+ * store, note that Windows validates the pszDriverName as mentioned below */
+static bool test_InstallPrinterDriverFromPackage(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;
+
+ char *abs_inf_path = NULL;
+ struct spoolss_AddDriverInfo8 *parsed_dinfo;
+ struct winspool_AsyncInstallPrinterDriverFromPackage r;
+ bool ok = true;
+ NTSTATUS status;
+
+ parsed_dinfo = ctx->dinfo->info;
+
+ r.in.pszServer = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
+ torture_assert_not_null_goto(tctx, r.in.pszServer, ok, done, "Cannot allocate memory");
+
+ /* output string(pszDestInfPath) from test_UploadPrinterDriverPackage() */
+ r.in.pszInfPath = talloc_strdup(tctx, ctx->dinfo->uploaded_inf_path);
+ torture_assert_not_null_goto(tctx, r.in.pszInfPath, ok, done, "Cannot allocate memory");
+
+ abs_inf_path = talloc_asprintf(tctx, "%s/%s", ctx->dinfo->local_driver_path, ctx->dinfo->inf_file);
+ torture_assert_not_null_goto(tctx, abs_inf_path, ok, done, "Cannot allocate memory");
+
+ r.in.pszEnvironment = parsed_dinfo->architecture;
+ torture_assert_not_null_goto(tctx, r.in.pszEnvironment, ok, done, "Cannot allocate memory");
+
+ /* Windows validates the print driver name by checking the pszDriverName input against the inf file:
+ * 1) "DriverName" value
+ * 2) "CompatName" value
+ * 3) left-hand-side value under the [Model] section
+ * otherwise ERROR_UNKNOWN_PRINTER_DRIVER is returned */
+ r.in.pszDriverName = parsed_dinfo->driver_name;
+ torture_assert_not_null_goto(tctx, r.in.pszDriverName, ok, done, "Cannot allocate memory");
+
+ /* All files should be installed, even if doing so would overwrite some newer
+ * versions */
+ r.in.dwFlags = IPDFP_COPY_ALL_FILES;
+
+ status = dcerpc_winspool_AsyncInstallPrinterDriverFromPackage_r(b, tctx, &r);
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "AsyncInstallPrinterDriverFromPackage failed");
+
+ torture_assert_hresult_ok(tctx, r.out.result, "AsyncInstallPrinterDriverFromPackage failed");
+done:
+ TALLOC_FREE(abs_inf_path);
+
+ return ok;
+}
+
+/* Check the registry to validate the print driver installed successfully */
+static bool test_ValidatePrinterDriverInstalled(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 *winreg_pipe = NULL;
+ NTSTATUS status;
+ bool ok = true;
+
+ /* winreg is not available over ncacn_ip_tcp */
+ status = torture_rpc_connection_transport(tctx, &winreg_pipe, &ndr_table_winreg, NCACN_NP, 0, 0);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_PIPE_NOT_AVAILABLE)) {
+ /* retry */
+ status = torture_rpc_connection_transport(tctx, &winreg_pipe, &ndr_table_winreg, NCACN_NP, 0, 0);
+ }
+ torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "Failed to connect to winreg");
+
+ ok = test_winreg_validate_driver(tctx, winreg_pipe, ctx->dinfo);
+ torture_assert_goto(tctx, ok, ok, done, "Failed to validate driver with winreg");
+
+done:
+ TALLOC_FREE(winreg_pipe);
+
+ return ok;
+}
+
+struct torture_suite *torture_rpc_iremotewinspool_drv(TALLOC_CTX *mem_ctx)
+{
+ struct torture_suite *suite = torture_suite_create(mem_ctx, "iremotewinspool_driver");
+ struct torture_tcase *tcase = torture_suite_add_tcase(suite, "drivers");
+
+ torture_tcase_set_fixture(tcase,
+ torture_rpc_iremotewinspool_drv_setup,
+ torture_rpc_iremotewinspool_drv_teardown);
+
+ torture_tcase_add_simple_test(tcase, "CopyDriverFiles", test_CopyDriverFiles);
+ torture_tcase_add_simple_test(tcase, "UploadPrinterDriverPackage", test_UploadPrinterDriverPackage);
+ torture_tcase_add_simple_test(tcase, "InstallPrinterDriverFromPackage", test_InstallPrinterDriverFromPackage);
+ torture_tcase_add_simple_test(tcase, "ValidatePrinterDriverInstalled", test_ValidatePrinterDriverInstalled);
+
+ return suite;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-23 19:05:01 +0000