dlls/ntoskrnl.exe/tests/ntoskrnl.c

   1 /*
   2  * ntoskrnl.exe testing framework
   3  *
   4  * Copyright 2015 Sebastian Lackner
   5  * Copyright 2015 Michael Müller
   6  * Copyright 2015 Christian Costa
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdio.h>
  24 #include "windows.h"
  25 #include "winsvc.h"
  26 #include "winioctl.h"
  27 #include "winternl.h"
  28 #include "wine/test.h"
  29 #include "wine/heap.h"
  30
  31 #include "driver.h"
  32
  33 static HANDLE device;
  34
  35 static BOOL     (WINAPI *pRtlDosPathNameToNtPathName_U)( LPCWSTR, PUNICODE_STRING, PWSTR*, CURDIR* );
  36
  37 static void load_resource(const char *name, char *filename)
  38 {
  39     static char path[MAX_PATH];
  40     DWORD written;
  41     HANDLE file;
  42     HRSRC res;
  43     void *ptr;
  44
  45     GetTempPathA(sizeof(path), path);
  46     GetTempFileNameA(path, name, 0, filename);
  47
  48     file = CreateFileA(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
  49     ok(file != INVALID_HANDLE_VALUE, "file creation failed, at %s, error %d\n", filename, GetLastError());
  50
  51     res = FindResourceA(NULL, name, "TESTDLL");
  52     ok( res != 0, "couldn't find resource\n" );
  53     ptr = LockResource( LoadResource( GetModuleHandleA(NULL), res ));
  54     WriteFile( file, ptr, SizeofResource( GetModuleHandleA(NULL), res ), &written, NULL );
  55     ok( written == SizeofResource( GetModuleHandleA(NULL), res ), "couldn't write resource\n" );
  56     CloseHandle( file );
  57 }
  58
  59 static void unload_driver(SC_HANDLE service)
  60 {
  61     SERVICE_STATUS status;
  62
  63     CloseHandle(device);
  64
  65     ControlService(service, SERVICE_CONTROL_STOP, &status);
  66     while (status.dwCurrentState == SERVICE_STOP_PENDING)
  67     {
  68         BOOL ret;
  69         Sleep(100);
  70         ret = QueryServiceStatus(service, &status);
  71         ok(ret, "QueryServiceStatus failed: %u\n", GetLastError());
  72     }
  73     ok(status.dwCurrentState == SERVICE_STOPPED,
  74        "expected SERVICE_STOPPED, got %d\n", status.dwCurrentState);
  75
  76     DeleteService(service);
  77     CloseServiceHandle(service);
  78 }
  79
  80 static SC_HANDLE load_driver(char *filename, const char *resname, const char *driver_name)
  81 {
  82     SC_HANDLE manager, service;
  83
  84     manager = OpenSCManagerA(NULL, NULL, SC_MANAGER_ALL_ACCESS);
  85     if (!manager && GetLastError() == ERROR_ACCESS_DENIED)
  86     {
  87         skip("Failed to open SC manager, not enough permissions\n");
  88         return FALSE;
  89     }
  90     ok(!!manager, "OpenSCManager failed\n");
  91
  92     /* stop any old drivers running under this name */
  93     service = OpenServiceA(manager, driver_name, SERVICE_ALL_ACCESS);
  94     if (service) unload_driver(service);
  95
  96     load_resource(resname, filename);
  97     trace("Trying to load driver %s\n", filename);
  98
  99     service = CreateServiceA(manager, driver_name, driver_name,
 100                              SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER,
 101                              SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
 102                              filename, NULL, NULL, NULL, NULL, NULL);
 103     ok(!!service, "CreateService failed: %u\n", GetLastError());
 104
 105     CloseServiceHandle(manager);
 106     return service;
 107 }
 108
 109 static BOOL start_driver(HANDLE service)
 110 {
 111     SERVICE_STATUS status;
 112     BOOL ret;
 113
 114     SetLastError(0xdeadbeef);
 115     ret = StartServiceA(service, 0, NULL);
 116     if (!ret && (GetLastError() == ERROR_DRIVER_BLOCKED || GetLastError() == ERROR_INVALID_IMAGE_HASH))
 117     {
 118         /* If Secure Boot is enabled or the machine is 64-bit, it will reject an unsigned driver. */
 119         skip("Failed to start service; probably your machine doesn't accept unsigned drivers.\n");
 120         DeleteService(service);
 121         CloseServiceHandle(service);
 122         return FALSE;
 123     }
 124     ok(ret, "StartService failed: %u\n", GetLastError());
 125
 126     /* wait for the service to start up properly */
 127     ret = QueryServiceStatus(service, &status);
 128     ok(ret, "QueryServiceStatus failed: %u\n", GetLastError());
 129     while (status.dwCurrentState == SERVICE_START_PENDING)
 130     {
 131         Sleep(100);
 132         ret = QueryServiceStatus(service, &status);
 133         ok(ret, "QueryServiceStatus failed: %u\n", GetLastError());
 134     }
 135     ok(status.dwCurrentState == SERVICE_RUNNING,
 136        "expected SERVICE_RUNNING, got %d\n", status.dwCurrentState);
 137
 138     return TRUE;
 139 }
 140
 141 static void main_test(void)
 142 {
 143     static const WCHAR dokW[] = {'d','o','k',0};
 144     WCHAR temppathW[MAX_PATH], pathW[MAX_PATH];
 145     struct test_input *test_input;
 146     UNICODE_STRING pathU;
 147     DWORD len, written, read;
 148     LONG new_failures;
 149     char buffer[512];
 150     HANDLE okfile;
 151     BOOL res;
 152
 153     /* Create a temporary file that the driver will write ok/trace output to. */
 154     GetTempPathW(MAX_PATH, temppathW);
 155     GetTempFileNameW(temppathW, dokW, 0, pathW);
 156     pRtlDosPathNameToNtPathName_U( pathW, &pathU, NULL, NULL );
 157
 158     len = pathU.Length + sizeof(WCHAR);
 159     test_input = heap_alloc( offsetof( struct test_input, path[len / sizeof(WCHAR)]) );
 160     test_input->running_under_wine = !strcmp(winetest_platform, "wine");
 161     test_input->winetest_report_success = winetest_report_success;
 162     test_input->winetest_debug = winetest_debug;
 163     memcpy(test_input->path, pathU.Buffer, len);
 164     res = DeviceIoControl(device, IOCTL_WINETEST_MAIN_TEST, test_input,
 165                           offsetof( struct test_input, path[len / sizeof(WCHAR)]),
 166                           &new_failures, sizeof(new_failures), &written, NULL);
 167     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 168     ok(written == sizeof(new_failures), "got size %x\n", written);
 169
 170     okfile = CreateFileW(pathW, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
 171     ok(okfile != INVALID_HANDLE_VALUE, "failed to create %s: %u\n", wine_dbgstr_w(pathW), GetLastError());
 172
 173     /* Print the ok/trace output and then add to our failure count. */
 174     do {
 175         ReadFile(okfile, buffer, sizeof(buffer), &read, NULL);
 176         printf("%.*s", read, buffer);
 177     } while (read == sizeof(buffer));
 178     winetest_add_failures(new_failures);
 179
 180     CloseHandle(okfile);
 181     DeleteFileW(pathW);
 182 }
 183
 184 static void test_basic_ioctl(void)
 185 {
 186     DWORD written;
 187     char buf[32];
 188     BOOL res;
 189
 190     res = DeviceIoControl(device, IOCTL_WINETEST_BASIC_IOCTL, NULL, 0, buf,
 191                           sizeof(buf), &written, NULL);
 192     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 193     ok(written == sizeof(teststr), "got size %d\n", written);
 194     ok(!strcmp(buf, teststr), "got '%s'\n", buf);
 195 }
 196
 197 static void test_load_driver(SC_HANDLE service)
 198 {
 199     SERVICE_STATUS status;
 200     BOOL load, res;
 201     DWORD sz;
 202
 203     res = QueryServiceStatus(service, &status);
 204     ok(res, "QueryServiceStatusEx failed: %u\n", GetLastError());
 205     ok(status.dwCurrentState == SERVICE_STOPPED, "got state %#x\n", status.dwCurrentState);
 206
 207     load = TRUE;
 208     res = DeviceIoControl(device, IOCTL_WINETEST_LOAD_DRIVER, &load, sizeof(load), NULL, 0, &sz, NULL);
 209     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 210
 211     res = QueryServiceStatus(service, &status);
 212     ok(res, "QueryServiceStatusEx failed: %u\n", GetLastError());
 213     ok(status.dwCurrentState == SERVICE_RUNNING, "got state %#x\n", status.dwCurrentState);
 214
 215     load = FALSE;
 216     res = DeviceIoControl(device, IOCTL_WINETEST_LOAD_DRIVER, &load, sizeof(load), NULL, 0, &sz, NULL);
 217     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 218
 219     res = QueryServiceStatus(service, &status);
 220     ok(res, "QueryServiceStatusEx failed: %u\n", GetLastError());
 221     ok(status.dwCurrentState == SERVICE_STOPPED, "got state %#x\n", status.dwCurrentState);
 222 }
 223
 224 static void test_driver3(void)
 225 {
 226     char filename[MAX_PATH];
 227     SC_HANDLE service;
 228     BOOL ret;
 229
 230     service = load_driver(filename, "driver3.dll", "WineTestDriver3");
 231     ok(service != NULL, "driver3 failed to load\n");
 232
 233     ret = StartServiceA(service, 0, NULL);
 234     ok(!ret, "driver3 should fail to start\n");
 235     ok(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED ||
 236        GetLastError() == ERROR_INVALID_FUNCTION ||
 237        GetLastError() == ERROR_PROC_NOT_FOUND /* XP */ ||
 238        GetLastError() == ERROR_FILE_NOT_FOUND /* Win7 */, "got %u\n", GetLastError());
 239
 240     DeleteService(service);
 241     CloseServiceHandle(service);
 242     DeleteFileA(filename);
 243 }
 244
 245 START_TEST(ntoskrnl)
 246 {
 247     char filename[MAX_PATH], filename2[MAX_PATH];
 248     SC_HANDLE service, service2;
 249
 250     HMODULE hntdll = GetModuleHandleA("ntdll.dll");
 251     pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U");
 252
 253     if (!(service = load_driver(filename, "driver.dll", "WineTestDriver")))
 254         return;
 255     if (!start_driver(service))
 256     {
 257         DeleteFileA(filename);
 258         return;
 259     }
 260     service2 = load_driver(filename2, "driver2.dll", "WineTestDriver2");
 261
 262     device = CreateFileA("\\\\.\\WineTestDriver", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
 263     ok(device != INVALID_HANDLE_VALUE, "failed to open device: %u\n", GetLastError());
 264
 265     test_basic_ioctl();
 266     main_test();
 267     test_load_driver(service2);
 268
 269     unload_driver(service2);
 270     unload_driver(service);
 271     ok(DeleteFileA(filename), "DeleteFile failed: %u\n", GetLastError());
 272     ok(DeleteFileA(filename2), "DeleteFile failed: %u\n", GetLastError());
 273
 274     test_driver3();
 275 }