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 "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26 #include "windows.h"
  27 #include "winsvc.h"
  28 #include "winioctl.h"
  29 #include "winternl.h"
  30 #include "winsock2.h"
  31 #include "wincrypt.h"
  32 #include "ntsecapi.h"
  33 #include "mscat.h"
  34 #include "mssip.h"
  35 #include "setupapi.h"
  36 #include "newdev.h"
  37 #include "initguid.h"
  38 #include "devguid.h"
  39 #include "wine/test.h"
  40 #include "wine/heap.h"
  41 #include "wine/mssign.h"
  42
  43 #include "driver.h"
  44
  45 static const GUID GUID_NULL;
  46
  47 static HANDLE device;
  48
  49 static BOOL (WINAPI *pRtlDosPathNameToNtPathName_U)(const WCHAR *, UNICODE_STRING *, WCHAR **, CURDIR *);
  50 static BOOL (WINAPI *pRtlFreeUnicodeString)(UNICODE_STRING *);
  51 static BOOL (WINAPI *pCancelIoEx)(HANDLE, OVERLAPPED *);
  52 static BOOL (WINAPI *pIsWow64Process)(HANDLE, BOOL *);
  53 static BOOL (WINAPI *pSetFileCompletionNotificationModes)(HANDLE, UCHAR);
  54 static HRESULT (WINAPI *pSignerSign)(SIGNER_SUBJECT_INFO *subject, SIGNER_CERT *cert,
  55         SIGNER_SIGNATURE_INFO *signature, SIGNER_PROVIDER_INFO *provider,
  56         const WCHAR *timestamp, CRYPT_ATTRIBUTES *attr, void *sip_data);
  57
  58 static void load_resource(const WCHAR *name, WCHAR *filename)
  59 {
  60     static WCHAR path[MAX_PATH];
  61     DWORD written;
  62     HANDLE file;
  63     HRSRC res;
  64     void *ptr;
  65
  66     GetTempPathW(ARRAY_SIZE(path), path);
  67     GetTempFileNameW(path, name, 0, filename);
  68
  69     file = CreateFileW(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
  70     ok(file != INVALID_HANDLE_VALUE, "failed to create %s, error %u\n", debugstr_w(filename), GetLastError());
  71
  72     res = FindResourceW(NULL, name, L"TESTDLL");
  73     ok( res != 0, "couldn't find resource\n" );
  74     ptr = LockResource( LoadResource( GetModuleHandleA(NULL), res ));
  75     WriteFile( file, ptr, SizeofResource( GetModuleHandleA(NULL), res ), &written, NULL );
  76     ok( written == SizeofResource( GetModuleHandleA(NULL), res ), "couldn't write resource\n" );
  77     CloseHandle( file );
  78 }
  79
  80 struct testsign_context
  81 {
  82     HCRYPTPROV provider;
  83     const CERT_CONTEXT *cert, *root_cert, *publisher_cert;
  84     HCERTSTORE root_store, publisher_store;
  85 };
  86
  87 static BOOL testsign_create_cert(struct testsign_context *ctx)
  88 {
  89     BYTE encoded_name[100], encoded_key_id[200], public_key_info_buffer[1000];
  90     WCHAR container_name[26];
  91     BYTE hash_buffer[16], cert_buffer[1000], provider_nameA[100], serial[16];
  92     CERT_PUBLIC_KEY_INFO *public_key_info = (CERT_PUBLIC_KEY_INFO *)public_key_info_buffer;
  93     CRYPT_KEY_PROV_INFO provider_info = {0};
  94     CRYPT_ALGORITHM_IDENTIFIER algid = {0};
  95     CERT_AUTHORITY_KEY_ID_INFO key_info;
  96     CERT_INFO cert_info = {0};
  97     WCHAR provider_nameW[100];
  98     CERT_EXTENSION extension;
  99     HCRYPTKEY key;
 100     DWORD size;
 101     BOOL ret;
 102
 103     memset(ctx, 0, sizeof(*ctx));
 104
 105     srand(time(NULL));
 106     swprintf(container_name, ARRAY_SIZE(container_name), L"wine_testsign%u", rand());
 107
 108     ret = CryptAcquireContextW(&ctx->provider, container_name, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET);
 109     ok(ret, "Failed to create container, error %#x\n", GetLastError());
 110
 111     ret = CryptGenKey(ctx->provider, AT_SIGNATURE, CRYPT_EXPORTABLE, &key);
 112     ok(ret, "Failed to create key, error %#x\n", GetLastError());
 113     ret = CryptDestroyKey(key);
 114     ok(ret, "Failed to destroy key, error %#x\n", GetLastError());
 115     ret = CryptGetUserKey(ctx->provider, AT_SIGNATURE, &key);
 116     ok(ret, "Failed to get user key, error %#x\n", GetLastError());
 117     ret = CryptDestroyKey(key);
 118     ok(ret, "Failed to destroy key, error %#x\n", GetLastError());
 119
 120     size = sizeof(encoded_name);
 121     ret = CertStrToNameA(X509_ASN_ENCODING, "CN=winetest_cert", CERT_X500_NAME_STR, NULL, encoded_name, &size, NULL);
 122     ok(ret, "Failed to convert name, error %#x\n", GetLastError());
 123     key_info.CertIssuer.cbData = size;
 124     key_info.CertIssuer.pbData = encoded_name;
 125
 126     size = sizeof(public_key_info_buffer);
 127     ret = CryptExportPublicKeyInfo(ctx->provider, AT_SIGNATURE, X509_ASN_ENCODING, public_key_info, &size);
 128     ok(ret, "Failed to export public key, error %#x\n", GetLastError());
 129     cert_info.SubjectPublicKeyInfo = *public_key_info;
 130
 131     size = sizeof(hash_buffer);
 132     ret = CryptHashPublicKeyInfo(ctx->provider, CALG_MD5, 0, X509_ASN_ENCODING, public_key_info, hash_buffer, &size);
 133     ok(ret, "Failed to hash public key, error %#x\n", GetLastError());
 134
 135     key_info.KeyId.cbData = size;
 136     key_info.KeyId.pbData = hash_buffer;
 137
 138     RtlGenRandom(serial, sizeof(serial));
 139     key_info.CertSerialNumber.cbData = sizeof(serial);
 140     key_info.CertSerialNumber.pbData = serial;
 141
 142     size = sizeof(encoded_key_id);
 143     ret = CryptEncodeObject(X509_ASN_ENCODING, X509_AUTHORITY_KEY_ID, &key_info, encoded_key_id, &size);
 144     ok(ret, "Failed to convert name, error %#x\n", GetLastError());
 145
 146     extension.pszObjId = (char *)szOID_AUTHORITY_KEY_IDENTIFIER;
 147     extension.fCritical = TRUE;
 148     extension.Value.cbData = size;
 149     extension.Value.pbData = encoded_key_id;
 150
 151     cert_info.dwVersion = CERT_V3;
 152     cert_info.SerialNumber = key_info.CertSerialNumber;
 153     cert_info.SignatureAlgorithm.pszObjId = (char *)szOID_RSA_SHA1RSA;
 154     cert_info.Issuer = key_info.CertIssuer;
 155     GetSystemTimeAsFileTime(&cert_info.NotBefore);
 156     GetSystemTimeAsFileTime(&cert_info.NotAfter);
 157     cert_info.NotAfter.dwHighDateTime += 1;
 158     cert_info.Subject = key_info.CertIssuer;
 159     cert_info.cExtension = 1;
 160     cert_info.rgExtension = &extension;
 161     algid.pszObjId = (char *)szOID_RSA_SHA1RSA;
 162     size = sizeof(cert_buffer);
 163     ret = CryptSignAndEncodeCertificate(ctx->provider, AT_SIGNATURE, X509_ASN_ENCODING,
 164             X509_CERT_TO_BE_SIGNED, &cert_info, &algid, NULL, cert_buffer, &size);
 165     ok(ret, "Failed to create certificate, error %#x\n", GetLastError());
 166
 167     ctx->cert = CertCreateCertificateContext(X509_ASN_ENCODING, cert_buffer, size);
 168     ok(!!ctx->cert, "Failed to create context, error %#x\n", GetLastError());
 169
 170     size = sizeof(provider_nameA);
 171     ret = CryptGetProvParam(ctx->provider, PP_NAME, provider_nameA, &size, 0);
 172     ok(ret, "Failed to get prov param, error %#x\n", GetLastError());
 173     MultiByteToWideChar(CP_ACP, 0, (char *)provider_nameA, -1, provider_nameW, ARRAY_SIZE(provider_nameW));
 174
 175     provider_info.pwszContainerName = (WCHAR *)container_name;
 176     provider_info.pwszProvName = provider_nameW;
 177     provider_info.dwProvType = PROV_RSA_FULL;
 178     provider_info.dwKeySpec = AT_SIGNATURE;
 179     ret = CertSetCertificateContextProperty(ctx->cert, CERT_KEY_PROV_INFO_PROP_ID, 0, &provider_info);
 180     ok(ret, "Failed to set provider info, error %#x\n", GetLastError());
 181
 182     ctx->root_store = CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY_A, 0, 0, CERT_SYSTEM_STORE_LOCAL_MACHINE, "root");
 183     if (!ctx->root_store && GetLastError() == ERROR_ACCESS_DENIED)
 184     {
 185         skip("Failed to open root store.\n");
 186
 187         ret = CertFreeCertificateContext(ctx->cert);
 188         ok(ret, "Failed to free certificate, error %u\n", GetLastError());
 189         ret = CryptReleaseContext(ctx->provider, 0);
 190         ok(ret, "failed to release context, error %u\n", GetLastError());
 191
 192         return FALSE;
 193     }
 194     ok(!!ctx->root_store, "Failed to open store, error %u\n", GetLastError());
 195     ret = CertAddCertificateContextToStore(ctx->root_store, ctx->cert, CERT_STORE_ADD_ALWAYS, &ctx->root_cert);
 196     if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
 197     {
 198         skip("Failed to add self-signed certificate to store.\n");
 199
 200         ret = CertFreeCertificateContext(ctx->cert);
 201         ok(ret, "Failed to free certificate, error %u\n", GetLastError());
 202         ret = CertCloseStore(ctx->root_store, CERT_CLOSE_STORE_CHECK_FLAG);
 203         ok(ret, "Failed to close store, error %u\n", GetLastError());
 204         ret = CryptReleaseContext(ctx->provider, 0);
 205         ok(ret, "failed to release context, error %u\n", GetLastError());
 206
 207         return FALSE;
 208     }
 209     ok(ret, "Failed to add certificate, error %u\n", GetLastError());
 210
 211     ctx->publisher_store = CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY_A, 0, 0,
 212             CERT_SYSTEM_STORE_LOCAL_MACHINE, "trustedpublisher");
 213     ok(!!ctx->publisher_store, "Failed to open store, error %u\n", GetLastError());
 214     ret = CertAddCertificateContextToStore(ctx->publisher_store, ctx->cert,
 215             CERT_STORE_ADD_ALWAYS, &ctx->publisher_cert);
 216     ok(ret, "Failed to add certificate, error %u\n", GetLastError());
 217
 218     return TRUE;
 219 }
 220
 221 static void testsign_cleanup(struct testsign_context *ctx)
 222 {
 223     BOOL ret;
 224
 225     ret = CertFreeCertificateContext(ctx->cert);
 226     ok(ret, "Failed to free certificate, error %u\n", GetLastError());
 227
 228     ret = CertDeleteCertificateFromStore(ctx->root_cert);
 229     ok(ret, "Failed to remove certificate, error %u\n", GetLastError());
 230     ret = CertFreeCertificateContext(ctx->root_cert);
 231     ok(ret, "Failed to free certificate, error %u\n", GetLastError());
 232     ret = CertCloseStore(ctx->root_store, CERT_CLOSE_STORE_CHECK_FLAG);
 233     ok(ret, "Failed to close store, error %u\n", GetLastError());
 234
 235     ret = CertDeleteCertificateFromStore(ctx->publisher_cert);
 236     ok(ret, "Failed to remove certificate, error %u\n", GetLastError());
 237     ret = CertFreeCertificateContext(ctx->publisher_cert);
 238     ok(ret, "Failed to free certificate, error %u\n", GetLastError());
 239     ret = CertCloseStore(ctx->publisher_store, CERT_CLOSE_STORE_CHECK_FLAG);
 240     ok(ret, "Failed to close store, error %u\n", GetLastError());
 241
 242     ret = CryptReleaseContext(ctx->provider, 0);
 243     ok(ret, "failed to release context, error %u\n", GetLastError());
 244 }
 245
 246 static void testsign_sign(struct testsign_context *ctx, const WCHAR *filename)
 247 {
 248     SIGNER_ATTR_AUTHCODE authcode = {sizeof(authcode)};
 249     SIGNER_SIGNATURE_INFO signature = {sizeof(signature)};
 250     SIGNER_SUBJECT_INFO subject = {sizeof(subject)};
 251     SIGNER_CERT_STORE_INFO store = {sizeof(store)};
 252     SIGNER_CERT cert_info = {sizeof(cert_info)};
 253     SIGNER_FILE_INFO file = {sizeof(file)};
 254     DWORD index = 0;
 255     HRESULT hr;
 256
 257     subject.dwSubjectChoice = 1;
 258     subject.pdwIndex = &index;
 259     subject.pSignerFileInfo = &file;
 260     file.pwszFileName = (WCHAR *)filename;
 261     cert_info.dwCertChoice = 2;
 262     cert_info.pCertStoreInfo = &store;
 263     store.pSigningCert = ctx->cert;
 264     store.dwCertPolicy = 0;
 265     signature.algidHash = CALG_SHA_256;
 266     signature.dwAttrChoice = SIGNER_AUTHCODE_ATTR;
 267     signature.pAttrAuthcode = &authcode;
 268     authcode.pwszName = L"";
 269     authcode.pwszInfo = L"";
 270     hr = pSignerSign(&subject, &cert_info, &signature, NULL, NULL, NULL, NULL);
 271     todo_wine ok(hr == S_OK || broken(hr == NTE_BAD_ALGID) /* < 7 */, "Failed to sign, hr %#x\n", hr);
 272 }
 273
 274 static void unload_driver(SC_HANDLE service)
 275 {
 276     SERVICE_STATUS status;
 277
 278     ControlService(service, SERVICE_CONTROL_STOP, &status);
 279     while (status.dwCurrentState == SERVICE_STOP_PENDING)
 280     {
 281         BOOL ret;
 282         Sleep(100);
 283         ret = QueryServiceStatus(service, &status);
 284         ok(ret, "QueryServiceStatus failed: %u\n", GetLastError());
 285     }
 286     ok(status.dwCurrentState == SERVICE_STOPPED,
 287        "expected SERVICE_STOPPED, got %d\n", status.dwCurrentState);
 288
 289     DeleteService(service);
 290     CloseServiceHandle(service);
 291 }
 292
 293 static SC_HANDLE load_driver(struct testsign_context *ctx, WCHAR *filename,
 294         const WCHAR *resname, const WCHAR *driver_name)
 295 {
 296     SC_HANDLE manager, service;
 297
 298     manager = OpenSCManagerA(NULL, NULL, SC_MANAGER_ALL_ACCESS);
 299     if (!manager && GetLastError() == ERROR_ACCESS_DENIED)
 300     {
 301         skip("Failed to open SC manager, not enough permissions\n");
 302         return FALSE;
 303     }
 304     ok(!!manager, "OpenSCManager failed\n");
 305
 306     /* stop any old drivers running under this name */
 307     service = OpenServiceW(manager, driver_name, SERVICE_ALL_ACCESS);
 308     if (service) unload_driver(service);
 309
 310     load_resource(resname, filename);
 311     testsign_sign(ctx, filename);
 312     trace("Trying to load driver %s\n", debugstr_w(filename));
 313
 314     service = CreateServiceW(manager, driver_name, driver_name,
 315                              SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER,
 316                              SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
 317                              filename, NULL, NULL, NULL, NULL, NULL);
 318     ok(!!service, "CreateService failed: %u\n", GetLastError());
 319
 320     CloseServiceHandle(manager);
 321     return service;
 322 }
 323
 324 static BOOL start_driver(HANDLE service, BOOL vista_plus)
 325 {
 326     SERVICE_STATUS status;
 327     BOOL ret;
 328
 329     SetLastError(0xdeadbeef);
 330     ret = StartServiceA(service, 0, NULL);
 331     if (!ret && (GetLastError() == ERROR_DRIVER_BLOCKED || GetLastError() == ERROR_INVALID_IMAGE_HASH
 332             || (vista_plus && GetLastError() == ERROR_FILE_NOT_FOUND)))
 333     {
 334         if (vista_plus && GetLastError() == ERROR_FILE_NOT_FOUND)
 335         {
 336             skip("Windows Vista or newer is required to run this service.\n");
 337         }
 338         else
 339         {
 340             /* If Secure Boot is enabled or the machine is 64-bit, it will reject an unsigned driver. */
 341             skip("Failed to start service; probably your machine doesn't accept unsigned drivers.\n");
 342         }
 343         DeleteService(service);
 344         CloseServiceHandle(service);
 345         return FALSE;
 346     }
 347     ok(ret, "StartService failed: %u\n", GetLastError());
 348
 349     /* wait for the service to start up properly */
 350     ret = QueryServiceStatus(service, &status);
 351     ok(ret, "QueryServiceStatus failed: %u\n", GetLastError());
 352     while (status.dwCurrentState == SERVICE_START_PENDING)
 353     {
 354         Sleep(100);
 355         ret = QueryServiceStatus(service, &status);
 356         ok(ret, "QueryServiceStatus failed: %u\n", GetLastError());
 357     }
 358     ok(status.dwCurrentState == SERVICE_RUNNING,
 359        "expected SERVICE_RUNNING, got %d\n", status.dwCurrentState);
 360     ok(status.dwServiceType == SERVICE_KERNEL_DRIVER,
 361        "expected SERVICE_KERNEL_DRIVER, got %#x\n", status.dwServiceType);
 362
 363     return TRUE;
 364 }
 365
 366 static ULONG64 modified_value;
 367
 368 static void main_test(void)
 369 {
 370     struct test_input *test_input;
 371     DWORD written, read;
 372     LONG new_failures;
 373     char buffer[512];
 374     HANDLE okfile;
 375     BOOL res;
 376
 377     /* Create a temporary file that the driver will write ok/trace output to. */
 378
 379     okfile = CreateFileA("C:\\windows\\winetest_ntoskrnl_okfile", GENERIC_READ,
 380             FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
 381     ok(okfile != INVALID_HANDLE_VALUE, "failed to create file, error %u\n", GetLastError());
 382
 383     test_input = heap_alloc( sizeof(*test_input) );
 384     test_input->running_under_wine = !strcmp(winetest_platform, "wine");
 385     test_input->winetest_report_success = winetest_report_success;
 386     test_input->winetest_debug = winetest_debug;
 387     test_input->process_id = GetCurrentProcessId();
 388     test_input->teststr_offset = (SIZE_T)((BYTE *)&teststr - (BYTE *)NtCurrentTeb()->Peb->ImageBaseAddress);
 389     test_input->modified_value = &modified_value;
 390     modified_value = 0;
 391
 392     res = DeviceIoControl(device, IOCTL_WINETEST_MAIN_TEST, test_input, sizeof(*test_input),
 393                           &new_failures, sizeof(new_failures), &written, NULL);
 394     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 395     ok(written == sizeof(new_failures), "got size %x\n", written);
 396
 397     /* Print the ok/trace output and then add to our failure count. */
 398     do {
 399         ReadFile(okfile, buffer, sizeof(buffer), &read, NULL);
 400         printf("%.*s", read, buffer);
 401     } while (read == sizeof(buffer));
 402     winetest_add_failures(new_failures);
 403
 404     heap_free(test_input);
 405     CloseHandle(okfile);
 406     DeleteFileA("C:\\windows\\winetest_ntoskrnl_okfile");
 407 }
 408
 409 static void test_basic_ioctl(void)
 410 {
 411     char inbuf[64], buf[32];
 412     DWORD written;
 413     BOOL res;
 414
 415     res = DeviceIoControl(device, IOCTL_WINETEST_BASIC_IOCTL, NULL, 0, buf,
 416                           sizeof(buf), &written, NULL);
 417     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 418     ok(written == sizeof(teststr), "got size %d\n", written);
 419     ok(!strcmp(buf, teststr), "got '%s'\n", buf);
 420
 421     memset(buf, 0, sizeof(buf));
 422     res = DeviceIoControl(device, IOCTL_WINETEST_BASIC_IOCTL, inbuf,
 423             sizeof(inbuf), buf, 10, &written, NULL);
 424     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 425     ok(written == 10, "got size %d\n", written);
 426     ok(!strcmp(buf, "Wine is no"), "got '%s'\n", buf);
 427 }
 428
 429 static void test_mismatched_status_ioctl(void)
 430 {
 431     DWORD written;
 432     char buf[32];
 433     BOOL res;
 434
 435     res = DeviceIoControl(device, IOCTL_WINETEST_MISMATCHED_STATUS, NULL, 0, buf,
 436                           sizeof(buf), &written, NULL);
 437     todo_wine ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 438     todo_wine ok(!strcmp(buf, teststr), "got '%s'\n", buf);
 439 }
 440
 441 static void test_overlapped(void)
 442 {
 443     OVERLAPPED overlapped, overlapped2, *o;
 444     DWORD cancel_cnt, size;
 445     HANDLE file, port;
 446     ULONG_PTR key;
 447     BOOL res;
 448
 449     overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 450     overlapped2.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 451
 452     file = CreateFileA("\\\\.\\WineTestDriver", FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
 453                        0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 454     ok(file != INVALID_HANDLE_VALUE, "failed to open device: %u\n", GetLastError());
 455
 456     /* test cancelling all device requests */
 457     res = DeviceIoControl(file, IOCTL_WINETEST_RESET_CANCEL, NULL, 0, NULL, 0, NULL, &overlapped);
 458     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 459
 460     res = DeviceIoControl(file, IOCTL_WINETEST_TEST_CANCEL, NULL, 0, NULL, 0, NULL, &overlapped);
 461     ok(!res && GetLastError() == ERROR_IO_PENDING, "DeviceIoControl failed: %u\n", GetLastError());
 462
 463     res = DeviceIoControl(file, IOCTL_WINETEST_TEST_CANCEL, NULL, 0, NULL, 0, NULL, &overlapped2);
 464     ok(!res && GetLastError() == ERROR_IO_PENDING, "DeviceIoControl failed: %u\n", GetLastError());
 465
 466     cancel_cnt = 0xdeadbeef;
 467     res = DeviceIoControl(file, IOCTL_WINETEST_GET_CANCEL_COUNT, NULL, 0, &cancel_cnt, sizeof(cancel_cnt), NULL, &overlapped);
 468     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 469     ok(cancel_cnt == 0, "cancel_cnt = %u\n", cancel_cnt);
 470
 471     CancelIo(file);
 472
 473     cancel_cnt = 0xdeadbeef;
 474     res = DeviceIoControl(file, IOCTL_WINETEST_GET_CANCEL_COUNT, NULL, 0, &cancel_cnt, sizeof(cancel_cnt), NULL, &overlapped);
 475     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 476     ok(cancel_cnt == 2, "cancel_cnt = %u\n", cancel_cnt);
 477
 478     /* test cancelling selected overlapped event */
 479     if (pCancelIoEx)
 480     {
 481         res = DeviceIoControl(file, IOCTL_WINETEST_RESET_CANCEL, NULL, 0, NULL, 0, NULL, &overlapped);
 482         ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 483
 484         res = DeviceIoControl(file, IOCTL_WINETEST_TEST_CANCEL, NULL, 0, NULL, 0, NULL, &overlapped);
 485         ok(!res && GetLastError() == ERROR_IO_PENDING, "DeviceIoControl failed: %u\n", GetLastError());
 486
 487         res = DeviceIoControl(file, IOCTL_WINETEST_TEST_CANCEL, NULL, 0, NULL, 0, NULL, &overlapped2);
 488         ok(!res && GetLastError() == ERROR_IO_PENDING, "DeviceIoControl failed: %u\n", GetLastError());
 489
 490         pCancelIoEx(file, &overlapped);
 491
 492         cancel_cnt = 0xdeadbeef;
 493         res = DeviceIoControl(file, IOCTL_WINETEST_GET_CANCEL_COUNT, NULL, 0, &cancel_cnt, sizeof(cancel_cnt), NULL, &overlapped);
 494         ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 495         ok(cancel_cnt == 1, "cancel_cnt = %u\n", cancel_cnt);
 496
 497         pCancelIoEx(file, &overlapped2);
 498
 499         cancel_cnt = 0xdeadbeef;
 500         res = DeviceIoControl(file, IOCTL_WINETEST_GET_CANCEL_COUNT, NULL, 0, &cancel_cnt, sizeof(cancel_cnt), NULL, &overlapped);
 501         ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 502         ok(cancel_cnt == 2, "cancel_cnt = %u\n", cancel_cnt);
 503     }
 504
 505     port = CreateIoCompletionPort(file, NULL, 0xdeadbeef, 0);
 506     ok(port != NULL, "CreateIoCompletionPort failed, error %u\n", GetLastError());
 507     res = GetQueuedCompletionStatus(port, &size, &key, &o, 0);
 508     ok(!res && GetLastError() == WAIT_TIMEOUT, "GetQueuedCompletionStatus returned %x(%u)\n", res, GetLastError());
 509
 510     res = DeviceIoControl(file, IOCTL_WINETEST_RESET_CANCEL, NULL, 0, NULL, 0, NULL, &overlapped);
 511     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 512     res = GetQueuedCompletionStatus(port, &size, &key, &o, 0);
 513     ok(res, "GetQueuedCompletionStatus failed: %u\n", GetLastError());
 514     ok(o == &overlapped, "o != overlapped\n");
 515
 516     if (pSetFileCompletionNotificationModes)
 517     {
 518         res = pSetFileCompletionNotificationModes(file, FILE_SKIP_COMPLETION_PORT_ON_SUCCESS);
 519         ok(res, "SetFileCompletionNotificationModes failed: %u\n", GetLastError());
 520
 521         res = DeviceIoControl(file, IOCTL_WINETEST_RESET_CANCEL, NULL, 0, NULL, 0, NULL, &overlapped);
 522         ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 523         res = GetQueuedCompletionStatus(port, &size, &key, &o, 0);
 524         ok(!res && GetLastError() == WAIT_TIMEOUT, "GetQueuedCompletionStatus returned %x(%u)\n", res, GetLastError());
 525     }
 526
 527     CloseHandle(port);
 528     CloseHandle(overlapped.hEvent);
 529     CloseHandle(overlapped2.hEvent);
 530     CloseHandle(file);
 531 }
 532
 533 static void test_load_driver(SC_HANDLE service)
 534 {
 535     SERVICE_STATUS status;
 536     BOOL load, res;
 537     DWORD sz;
 538
 539     res = QueryServiceStatus(service, &status);
 540     ok(res, "QueryServiceStatusEx failed: %u\n", GetLastError());
 541     ok(status.dwCurrentState == SERVICE_STOPPED, "got state %#x\n", status.dwCurrentState);
 542
 543     load = TRUE;
 544     res = DeviceIoControl(device, IOCTL_WINETEST_LOAD_DRIVER, &load, sizeof(load), NULL, 0, &sz, NULL);
 545     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 546
 547     res = QueryServiceStatus(service, &status);
 548     ok(res, "QueryServiceStatusEx failed: %u\n", GetLastError());
 549     ok(status.dwCurrentState == SERVICE_RUNNING, "got state %#x\n", status.dwCurrentState);
 550
 551     load = FALSE;
 552     res = DeviceIoControl(device, IOCTL_WINETEST_LOAD_DRIVER, &load, sizeof(load), NULL, 0, &sz, NULL);
 553     ok(res, "DeviceIoControl failed: %u\n", GetLastError());
 554
 555     res = QueryServiceStatus(service, &status);
 556     ok(res, "QueryServiceStatusEx failed: %u\n", GetLastError());
 557     ok(status.dwCurrentState == SERVICE_STOPPED, "got state %#x\n", status.dwCurrentState);
 558 }
 559
 560 static void test_file_handles(void)
 561 {
 562     DWORD count, ret_size;
 563     HANDLE file, dup, file2;
 564     BOOL ret;
 565
 566     ret = DeviceIoControl(device, IOCTL_WINETEST_GET_CREATE_COUNT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 567     ok(ret, "ioctl failed: %u\n", GetLastError());
 568     ok(count == 2, "got %u\n", count);
 569
 570     ret = DeviceIoControl(device, IOCTL_WINETEST_GET_CLOSE_COUNT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 571     ok(ret, "ioctl failed: %u\n", GetLastError());
 572     ok(count == 1, "got %u\n", count);
 573
 574     file = CreateFileA("\\\\.\\WineTestDriver", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
 575     ok(file != INVALID_HANDLE_VALUE, "failed to open device: %u\n", GetLastError());
 576
 577     ret = DeviceIoControl(device, IOCTL_WINETEST_GET_CREATE_COUNT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 578     ok(ret, "ioctl failed: %u\n", GetLastError());
 579     ok(count == 3, "got %u\n", count);
 580
 581     file2 = CreateFileA("\\\\.\\WineTestDriver", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
 582     ok(file2 != INVALID_HANDLE_VALUE, "failed to open device: %u\n", GetLastError());
 583
 584     ret = DeviceIoControl(device, IOCTL_WINETEST_GET_CREATE_COUNT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 585     ok(ret, "ioctl failed: %u\n", GetLastError());
 586     ok(count == 4, "got %u\n", count);
 587
 588     ret = DuplicateHandle(GetCurrentProcess(), file, GetCurrentProcess(), &dup, 0, FALSE, DUPLICATE_SAME_ACCESS);
 589     ok(ret, "failed to duplicate handle: %u\n", GetLastError());
 590
 591     ret = DeviceIoControl(device, IOCTL_WINETEST_GET_CREATE_COUNT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 592     ok(ret, "ioctl failed: %u\n", GetLastError());
 593     ok(count == 4, "got %u\n", count);
 594
 595     ret = DeviceIoControl(device, IOCTL_WINETEST_GET_FSCONTEXT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 596     ok(ret, "ioctl failed: %u\n", GetLastError());
 597     ok(count == 1, "got %u\n", count);
 598
 599     ret = DeviceIoControl(file, IOCTL_WINETEST_GET_FSCONTEXT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 600     ok(ret, "ioctl failed: %u\n", GetLastError());
 601     ok(count == 3, "got %u\n", count);
 602
 603     ret = DeviceIoControl(file2, IOCTL_WINETEST_GET_FSCONTEXT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 604     ok(ret, "ioctl failed: %u\n", GetLastError());
 605     ok(count == 4, "got %u\n", count);
 606
 607     ret = DeviceIoControl(dup, IOCTL_WINETEST_GET_FSCONTEXT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 608     ok(ret, "ioctl failed: %u\n", GetLastError());
 609     ok(count == 3, "got %u\n", count);
 610
 611     CloseHandle(dup);
 612
 613     ret = DeviceIoControl(device, IOCTL_WINETEST_GET_CLOSE_COUNT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 614     ok(ret, "ioctl failed: %u\n", GetLastError());
 615     ok(count == 1, "got %u\n", count);
 616
 617     CloseHandle(file2);
 618
 619     ret = DeviceIoControl(device, IOCTL_WINETEST_GET_CLOSE_COUNT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 620     ok(ret, "ioctl failed: %u\n", GetLastError());
 621     ok(count == 2, "got %u\n", count);
 622
 623     CloseHandle(file);
 624
 625     ret = DeviceIoControl(device, IOCTL_WINETEST_GET_CLOSE_COUNT, NULL, 0, &count, sizeof(count), &ret_size, NULL);
 626     ok(ret, "ioctl failed: %u\n", GetLastError());
 627     ok(count == 3, "got %u\n", count);
 628 }
 629
 630 static void test_return_status(void)
 631 {
 632     NTSTATUS status;
 633     char buffer[7];
 634     DWORD ret_size;
 635     BOOL ret;
 636
 637     strcpy(buffer, "abcdef");
 638     status = STATUS_SUCCESS;
 639     SetLastError(0xdeadbeef);
 640     ret = DeviceIoControl(device, IOCTL_WINETEST_RETURN_STATUS, &status,
 641             sizeof(status), buffer, sizeof(buffer), &ret_size, NULL);
 642     ok(ret, "ioctl failed\n");
 643     ok(GetLastError() == 0xdeadbeef, "got error %u\n", GetLastError());
 644     ok(!strcmp(buffer, "ghidef"), "got buffer %s\n", buffer);
 645     ok(ret_size == 3, "got size %u\n", ret_size);
 646
 647     strcpy(buffer, "abcdef");
 648     status = STATUS_TIMEOUT;
 649     SetLastError(0xdeadbeef);
 650     ret = DeviceIoControl(device, IOCTL_WINETEST_RETURN_STATUS, &status,
 651             sizeof(status), buffer, sizeof(buffer), &ret_size, NULL);
 652     todo_wine ok(ret, "ioctl failed\n");
 653     todo_wine ok(GetLastError() == 0xdeadbeef, "got error %u\n", GetLastError());
 654     ok(!strcmp(buffer, "ghidef"), "got buffer %s\n", buffer);
 655     ok(ret_size == 3, "got size %u\n", ret_size);
 656
 657     strcpy(buffer, "abcdef");
 658     status = 0x0eadbeef;
 659     SetLastError(0xdeadbeef);
 660     ret = DeviceIoControl(device, IOCTL_WINETEST_RETURN_STATUS, &status,
 661             sizeof(status), buffer, sizeof(buffer), &ret_size, NULL);
 662     todo_wine ok(ret, "ioctl failed\n");
 663     todo_wine ok(GetLastError() == 0xdeadbeef, "got error %u\n", GetLastError());
 664     ok(!strcmp(buffer, "ghidef"), "got buffer %s\n", buffer);
 665     ok(ret_size == 3, "got size %u\n", ret_size);
 666
 667     strcpy(buffer, "abcdef");
 668     status = 0x4eadbeef;
 669     SetLastError(0xdeadbeef);
 670     ret = DeviceIoControl(device, IOCTL_WINETEST_RETURN_STATUS, &status,
 671             sizeof(status), buffer, sizeof(buffer), &ret_size, NULL);
 672     todo_wine ok(ret, "ioctl failed\n");
 673     todo_wine ok(GetLastError() == 0xdeadbeef, "got error %u\n", GetLastError());
 674     ok(!strcmp(buffer, "ghidef"), "got buffer %s\n", buffer);
 675     ok(ret_size == 3, "got size %u\n", ret_size);
 676
 677     strcpy(buffer, "abcdef");
 678     status = 0x8eadbeef;
 679     SetLastError(0xdeadbeef);
 680     ret = DeviceIoControl(device, IOCTL_WINETEST_RETURN_STATUS, &status,
 681             sizeof(status), buffer, sizeof(buffer), &ret_size, NULL);
 682     ok(!ret, "ioctl succeeded\n");
 683     ok(GetLastError() == ERROR_MR_MID_NOT_FOUND, "got error %u\n", GetLastError());
 684     ok(!strcmp(buffer, "ghidef"), "got buffer %s\n", buffer);
 685     ok(ret_size == 3, "got size %u\n", ret_size);
 686
 687     strcpy(buffer, "abcdef");
 688     status = 0xceadbeef;
 689     SetLastError(0xdeadbeef);
 690     ret = DeviceIoControl(device, IOCTL_WINETEST_RETURN_STATUS, &status,
 691             sizeof(status), buffer, sizeof(buffer), &ret_size, NULL);
 692     ok(!ret, "ioctl succeeded\n");
 693     ok(GetLastError() == ERROR_MR_MID_NOT_FOUND, "got error %u\n", GetLastError());
 694     ok(!strcmp(buffer, "abcdef"), "got buffer %s\n", buffer);
 695     ok(ret_size == 3, "got size %u\n", ret_size);
 696 }
 697
 698 static BOOL compare_unicode_string(const WCHAR *buffer, ULONG len, const WCHAR *expect)
 699 {
 700     return len == wcslen(expect) * sizeof(WCHAR) && !memcmp(buffer, expect, len);
 701 }
 702
 703 static void test_object_info(void)
 704 {
 705     char buffer[200];
 706     OBJECT_NAME_INFORMATION *name_info = (OBJECT_NAME_INFORMATION *)buffer;
 707     OBJECT_TYPE_INFORMATION *type_info = (OBJECT_TYPE_INFORMATION *)buffer;
 708     FILE_FS_VOLUME_INFORMATION *volume_info = (FILE_FS_VOLUME_INFORMATION *)buffer;
 709     FILE_NAME_INFORMATION *file_info = (FILE_NAME_INFORMATION *)buffer;
 710     HANDLE file;
 711     NTSTATUS status;
 712     IO_STATUS_BLOCK io;
 713     ULONG size;
 714
 715     status = NtQueryObject(device, ObjectNameInformation, buffer, sizeof(buffer), NULL);
 716     ok(!status, "got %#x\n", status);
 717     ok(compare_unicode_string(name_info->Name.Buffer, name_info->Name.Length, L"\\Device\\WineTestDriver"),
 718             "wrong name %s\n", debugstr_w(name_info->Name.Buffer));
 719
 720     status = NtQueryObject(device, ObjectTypeInformation, buffer, sizeof(buffer), NULL);
 721     ok(!status, "got %#x\n", status);
 722     ok(compare_unicode_string(type_info->TypeName.Buffer, type_info->TypeName.Length, L"File"),
 723             "wrong name %s\n", debugstr_wn(type_info->TypeName.Buffer, type_info->TypeName.Length / sizeof(WCHAR)));
 724
 725     status = NtQueryInformationFile(device, &io, buffer, sizeof(buffer), FileNameInformation);
 726     todo_wine ok(status == STATUS_INVALID_DEVICE_REQUEST, "got %#x\n", status);
 727
 728     status = NtQueryVolumeInformationFile(device, &io, buffer, sizeof(buffer), FileFsVolumeInformation);
 729     todo_wine ok(status == STATUS_INVALID_DEVICE_REQUEST, "got %#x\n", status);
 730
 731     file = CreateFileA("\\\\.\\WineTestDriver\\subfile", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
 732     todo_wine ok(file != INVALID_HANDLE_VALUE, "got error %u\n", GetLastError());
 733     if (file == INVALID_HANDLE_VALUE) return;
 734
 735     memset(buffer, 0xcc, sizeof(buffer));
 736     status = NtQueryObject(file, ObjectNameInformation, buffer, sizeof(buffer), &size);
 737     ok(!status, "got %#x\n", status);
 738     ok(size == sizeof(*name_info) + sizeof(L"\\Device\\WineTestDriver\\subfile"), "wrong size %u\n", size);
 739     ok(compare_unicode_string(name_info->Name.Buffer, name_info->Name.Length, L"\\Device\\WineTestDriver\\subfile"),
 740             "wrong name %s\n", debugstr_w(name_info->Name.Buffer));
 741
 742     memset(buffer, 0xcc, sizeof(buffer));
 743     status = NtQueryObject(file, ObjectNameInformation, buffer, size - 2, &size);
 744     ok(status == STATUS_BUFFER_OVERFLOW, "got %#x\n", status);
 745     ok(size == sizeof(*name_info) + sizeof(L"\\Device\\WineTestDriver\\subfile"), "wrong size %u\n", size);
 746     ok(compare_unicode_string(name_info->Name.Buffer, name_info->Name.Length, L"\\Device\\WineTestDriver\\subfil"),
 747             "wrong name %s\n", debugstr_w(name_info->Name.Buffer));
 748
 749     memset(buffer, 0xcc, sizeof(buffer));
 750     status = NtQueryObject(file, ObjectNameInformation, buffer, sizeof(*name_info), &size);
 751     ok(status == STATUS_BUFFER_OVERFLOW, "got %#x\n", status);
 752     ok(size == sizeof(*name_info) + sizeof(L"\\Device\\WineTestDriver\\subfile"), "wrong size %u\n", size);
 753
 754     status = NtQueryObject(file, ObjectTypeInformation, buffer, sizeof(buffer), NULL);
 755     ok(!status, "got %#x\n", status);
 756     ok(compare_unicode_string(type_info->TypeName.Buffer, type_info->TypeName.Length, L"File"),
 757             "wrong name %s\n", debugstr_wn(type_info->TypeName.Buffer, type_info->TypeName.Length / sizeof(WCHAR)));
 758
 759     status = NtQueryInformationFile(file, &io, buffer, sizeof(buffer), FileNameInformation);
 760     ok(!status, "got %#x\n", status);
 761     ok(compare_unicode_string(file_info->FileName, file_info->FileNameLength, L"\\subfile"),
 762             "wrong name %s\n", debugstr_wn(file_info->FileName, file_info->FileNameLength / sizeof(WCHAR)));
 763
 764     status = NtQueryVolumeInformationFile(file, &io, buffer, sizeof(buffer), FileFsVolumeInformation);
 765     ok(!status, "got %#x\n", status);
 766     ok(volume_info->VolumeSerialNumber == 0xdeadbeef,
 767             "wrong serial number 0x%08x\n", volume_info->VolumeSerialNumber);
 768     ok(compare_unicode_string(volume_info->VolumeLabel, volume_info->VolumeLabelLength, L"WineTestDriver"),
 769             "wrong name %s\n", debugstr_wn(volume_info->VolumeLabel, volume_info->VolumeLabelLength / sizeof(WCHAR)));
 770
 771     CloseHandle(file);
 772
 773     file = CreateFileA("\\\\.\\WineTestDriver\\notimpl", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
 774     ok(file != INVALID_HANDLE_VALUE, "got error %u\n", GetLastError());
 775
 776     status = NtQueryObject(file, ObjectNameInformation, buffer, sizeof(buffer), NULL);
 777     ok(!status, "got %#x\n", status);
 778     ok(compare_unicode_string(name_info->Name.Buffer, name_info->Name.Length, L"\\Device\\WineTestDriver"),
 779             "wrong name %s\n", debugstr_w(name_info->Name.Buffer));
 780
 781     status = NtQueryInformationFile(file, &io, buffer, sizeof(buffer), FileNameInformation);
 782     ok(status == STATUS_NOT_IMPLEMENTED, "got %#x\n", status);
 783
 784     CloseHandle(file);
 785
 786     file = CreateFileA("\\\\.\\WineTestDriver\\badparam", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
 787     ok(file != INVALID_HANDLE_VALUE, "got error %u\n", GetLastError());
 788
 789     status = NtQueryObject(file, ObjectNameInformation, buffer, sizeof(buffer), NULL);
 790     ok(!status, "got %#x\n", status);
 791     ok(compare_unicode_string(name_info->Name.Buffer, name_info->Name.Length, L"\\Device\\WineTestDriver"),
 792             "wrong name %s\n", debugstr_w(name_info->Name.Buffer));
 793
 794     status = NtQueryInformationFile(file, &io, buffer, sizeof(buffer), FileNameInformation);
 795     ok(status == STATUS_INVALID_PARAMETER, "got %#x\n", status);
 796
 797     CloseHandle(file);
 798
 799     file = CreateFileA("\\\\.\\WineTestDriver\\genfail", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
 800     ok(file != INVALID_HANDLE_VALUE, "got error %u\n", GetLastError());
 801
 802     status = NtQueryObject(file, ObjectNameInformation, buffer, sizeof(buffer), NULL);
 803     ok(status == STATUS_UNSUCCESSFUL, "got %#x\n", status);
 804
 805     status = NtQueryInformationFile(file, &io, buffer, sizeof(buffer), FileNameInformation);
 806     ok(status == STATUS_UNSUCCESSFUL, "got %#x\n", status);
 807
 808     CloseHandle(file);
 809
 810     file = CreateFileA("\\\\.\\WineTestDriver\\badtype", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
 811     ok(file != INVALID_HANDLE_VALUE, "got error %u\n", GetLastError());
 812
 813     status = NtQueryObject(file, ObjectNameInformation, buffer, sizeof(buffer), NULL);
 814     ok(status == STATUS_OBJECT_TYPE_MISMATCH, "got %#x\n", status);
 815
 816     status = NtQueryInformationFile(file, &io, buffer, sizeof(buffer), FileNameInformation);
 817     ok(status == STATUS_OBJECT_TYPE_MISMATCH, "got %#x\n", status);
 818
 819     CloseHandle(file);
 820 }
 821
 822 static void test_driver3(struct testsign_context *ctx)
 823 {
 824     WCHAR filename[MAX_PATH];
 825     SC_HANDLE service;
 826     BOOL ret;
 827
 828     service = load_driver(ctx, filename, L"driver3.dll", L"WineTestDriver3");
 829     ok(service != NULL, "driver3 failed to load\n");
 830
 831     ret = StartServiceA(service, 0, NULL);
 832     ok(!ret, "driver3 should fail to start\n");
 833     ok(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED ||
 834        GetLastError() == ERROR_INVALID_FUNCTION ||
 835        GetLastError() == ERROR_PROC_NOT_FOUND /* XP */ ||
 836        GetLastError() == ERROR_FILE_NOT_FOUND /* Win7 */, "got %u\n", GetLastError());
 837
 838     DeleteService(service);
 839     CloseServiceHandle(service);
 840     DeleteFileW(filename);
 841 }
 842
 843 static DWORD WINAPI wsk_test_thread(void *parameter)
 844 {
 845     static const char test_send_string[] = "Client test string 1.";
 846     static const WORD version = MAKEWORD(2, 2);
 847     SOCKET s_listen, s_accept, s_connect;
 848     struct sockaddr_in addr;
 849     char buffer[256];
 850     int ret, err;
 851     WSADATA data;
 852     int opt_val;
 853
 854     ret = WSAStartup(version, &data);
 855     ok(!ret, "WSAStartup() failed, ret %u.\n", ret);
 856
 857     s_connect = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 858     ok(s_connect != INVALID_SOCKET, "Error creating socket, WSAGetLastError() %u.\n", WSAGetLastError());
 859
 860     s_listen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 861     ok(s_listen != INVALID_SOCKET, "Error creating socket, WSAGetLastError() %u.\n", WSAGetLastError());
 862
 863     opt_val = 1;
 864     setsockopt(s_listen, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt_val, sizeof(opt_val));
 865
 866     memset(&addr, 0, sizeof(addr));
 867     addr.sin_family = AF_INET;
 868     addr.sin_port = htons(CLIENT_LISTEN_PORT);
 869     addr.sin_addr.s_addr = htonl(0x7f000001);
 870     ret = bind(s_listen, (struct sockaddr *)&addr, sizeof(addr));
 871     ok(!ret, "Got unexpected ret %d, WSAGetLastError() %u.\n", ret, WSAGetLastError());
 872
 873     ret = listen(s_listen, SOMAXCONN);
 874     ok(!ret, "Got unexpected ret %d, WSAGetLastError() %u.\n", ret, WSAGetLastError());
 875
 876     addr.sin_port = htons(SERVER_LISTEN_PORT);
 877
 878     ret = connect(s_connect, (struct sockaddr *)&addr, sizeof(addr));
 879     while (ret && ((err = WSAGetLastError()) == WSAECONNREFUSED || err == WSAECONNABORTED))
 880     {
 881         SwitchToThread();
 882         ret = connect(s_connect, (struct sockaddr *)&addr, sizeof(addr));
 883     }
 884     ok(!ret, "Error connecting, WSAGetLastError() %u.\n", WSAGetLastError());
 885
 886     ret = send(s_connect, test_send_string, sizeof(test_send_string), 0);
 887     ok(ret == sizeof(test_send_string), "Got unexpected ret %d.\n", ret);
 888
 889     ret = recv(s_connect, buffer, sizeof(buffer), 0);
 890     ok(ret == sizeof(buffer), "Got unexpected ret %d.\n", ret);
 891     ok(!strcmp(buffer, "Server test string 1."), "Received unexpected data.\n");
 892
 893     s_accept = accept(s_listen, NULL, NULL);
 894     ok(s_accept != INVALID_SOCKET, "Error creating socket, WSAGetLastError() %u.\n", WSAGetLastError());
 895
 896     closesocket(s_accept);
 897     closesocket(s_connect);
 898     closesocket(s_listen);
 899     return TRUE;
 900 }
 901
 902 static void test_driver4(struct testsign_context *ctx)
 903 {
 904     WCHAR filename[MAX_PATH];
 905     SC_HANDLE service;
 906     HANDLE hthread;
 907     DWORD written;
 908     BOOL ret;
 909
 910     if (!(service = load_driver(ctx, filename, L"driver4.dll", L"WineTestDriver4")))
 911         return;
 912
 913     if (!start_driver(service, TRUE))
 914     {
 915         DeleteFileW(filename);
 916         return;
 917     }
 918
 919     device = CreateFileA("\\\\.\\WineTestDriver4", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
 920     ok(device != INVALID_HANDLE_VALUE, "failed to open device: %u\n", GetLastError());
 921
 922     hthread = CreateThread(NULL, 0, wsk_test_thread, NULL, 0, NULL);
 923     main_test();
 924     WaitForSingleObject(hthread, INFINITE);
 925
 926     ret = DeviceIoControl(device, IOCTL_WINETEST_DETACH, NULL, 0, NULL, 0, &written, NULL);
 927     ok(ret, "DeviceIoControl failed: %u\n", GetLastError());
 928
 929     CloseHandle(device);
 930
 931     unload_driver(service);
 932     ret = DeleteFileW(filename);
 933     ok(ret, "DeleteFile failed: %u\n", GetLastError());
 934 }
 935
 936 static void add_file_to_catalog(HANDLE catalog, const WCHAR *file)
 937 {
 938     SIP_SUBJECTINFO subject_info = {sizeof(SIP_SUBJECTINFO)};
 939     SIP_INDIRECT_DATA *indirect_data;
 940     const WCHAR *filepart = file;
 941     CRYPTCATMEMBER *member;
 942     WCHAR hash_buffer[100];
 943     GUID subject_guid;
 944     unsigned int i;
 945     DWORD size;
 946     BOOL ret;
 947
 948     ret = CryptSIPRetrieveSubjectGuidForCatalogFile(file, NULL, &subject_guid);
 949     todo_wine ok(ret, "Failed to get subject guid, error %u\n", GetLastError());
 950
 951     size = 0;
 952     subject_info.pgSubjectType = &subject_guid;
 953     subject_info.pwsFileName = file;
 954     subject_info.DigestAlgorithm.pszObjId = (char *)szOID_OIWSEC_sha1;
 955     subject_info.dwFlags = SPC_INC_PE_RESOURCES_FLAG | SPC_INC_PE_IMPORT_ADDR_TABLE_FLAG | SPC_EXC_PE_PAGE_HASHES_FLAG | 0x10000;
 956     ret = CryptSIPCreateIndirectData(&subject_info, &size, NULL);
 957     todo_wine ok(ret, "Failed to get indirect data size, error %u\n", GetLastError());
 958
 959     indirect_data = malloc(size);
 960     ret = CryptSIPCreateIndirectData(&subject_info, &size, indirect_data);
 961     todo_wine ok(ret, "Failed to get indirect data, error %u\n", GetLastError());
 962     if (ret)
 963     {
 964         memset(hash_buffer, 0, sizeof(hash_buffer));
 965         for (i = 0; i < indirect_data->Digest.cbData; ++i)
 966             swprintf(&hash_buffer[i * 2], 2, L"%02X", indirect_data->Digest.pbData[i]);
 967
 968         member = CryptCATPutMemberInfo(catalog, (WCHAR *)file,
 969                 hash_buffer, &subject_guid, 0, size, (BYTE *)indirect_data);
 970         ok(!!member, "Failed to write member, error %u\n", GetLastError());
 971
 972         if (wcsrchr(file, '\\'))
 973             filepart = wcsrchr(file, '\\') + 1;
 974
 975         ret = !!CryptCATPutAttrInfo(catalog, member, (WCHAR *)L"File",
 976                 CRYPTCAT_ATTR_NAMEASCII | CRYPTCAT_ATTR_DATAASCII | CRYPTCAT_ATTR_AUTHENTICATED,
 977                 (wcslen(filepart) + 1) * 2, (BYTE *)filepart);
 978         ok(ret, "Failed to write attr, error %u\n", GetLastError());
 979
 980         ret = !!CryptCATPutAttrInfo(catalog, member, (WCHAR *)L"OSAttr",
 981                 CRYPTCAT_ATTR_NAMEASCII | CRYPTCAT_ATTR_DATAASCII | CRYPTCAT_ATTR_AUTHENTICATED,
 982                 sizeof(L"2:6.0"), (BYTE *)L"2:6.0");
 983         ok(ret, "Failed to write attr, error %u\n", GetLastError());
 984     }
 985 }
 986
 987 static void test_pnp_devices(void)
 988 {
 989     static const GUID control_class = {0xdeadbeef, 0x29ef, 0x4538, {0xa5, 0xfd, 0xb6, 0x95, 0x73, 0xa3, 0x62, 0xc0}};
 990
 991     char buffer[200];
 992     SP_DEVICE_INTERFACE_DETAIL_DATA_A *iface_detail = (void *)buffer;
 993     SP_DEVICE_INTERFACE_DATA iface = {sizeof(iface)};
 994     SP_DEVINFO_DATA device = {sizeof(device)};
 995     HDEVINFO set;
 996     HANDLE bus;
 997     BOOL ret;
 998
 999     set = SetupDiGetClassDevsA(&control_class, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
1000     ok(set != INVALID_HANDLE_VALUE, "failed to get device list, error %#x\n", GetLastError());
1001
1002     ret = SetupDiEnumDeviceInfo(set, 0, &device);
1003     ok(ret, "failed to get device, error %#x\n", GetLastError());
1004     ok(IsEqualGUID(&device.ClassGuid, &GUID_DEVCLASS_SYSTEM), "wrong class %s\n", debugstr_guid(&device.ClassGuid));
1005
1006     ret = SetupDiGetDeviceInstanceIdA(set, &device, buffer, sizeof(buffer), NULL);
1007     ok(ret, "failed to get device ID, error %#x\n", GetLastError());
1008     ok(!strcasecmp(buffer, "root\\winetest\\0"), "got ID %s\n", debugstr_a(buffer));
1009
1010     ret = SetupDiEnumDeviceInterfaces(set, NULL, &control_class, 0, &iface);
1011     ok(ret, "failed to get interface, error %#x\n", GetLastError());
1012     ok(IsEqualGUID(&iface.InterfaceClassGuid, &control_class),
1013             "wrong class %s\n", debugstr_guid(&iface.InterfaceClassGuid));
1014     ok(iface.Flags == SPINT_ACTIVE, "got flags %#x\n", iface.Flags);
1015
1016     iface_detail->cbSize = sizeof(*iface_detail);
1017     ret = SetupDiGetDeviceInterfaceDetailA(set, &iface, iface_detail, sizeof(buffer), NULL, NULL);
1018     ok(ret, "failed to get interface path, error %#x\n", GetLastError());
1019     ok(!strcasecmp(iface_detail->DevicePath, "\\\\?\\root#winetest#0#{deadbeef-29ef-4538-a5fd-b69573a362c0}"),
1020             "wrong path %s\n", debugstr_a(iface_detail->DevicePath));
1021
1022     SetupDiDestroyDeviceInfoList(set);
1023
1024     bus = CreateFileA(iface_detail->DevicePath, 0, 0, NULL, OPEN_EXISTING, 0, NULL);
1025     ok(bus != INVALID_HANDLE_VALUE, "got error %u\n", GetLastError());
1026
1027     CloseHandle(bus);
1028 }
1029
1030 static void test_pnp_driver(struct testsign_context *ctx)
1031 {
1032     static const char hardware_id[] = "test_hardware_id\0";
1033     char path[MAX_PATH], dest[MAX_PATH], *filepart;
1034     SP_DEVINFO_DATA device = {sizeof(device)};
1035     char cwd[MAX_PATH], tempdir[MAX_PATH];
1036     WCHAR driver_filename[MAX_PATH];
1037     SC_HANDLE manager, service;
1038     BOOL ret, need_reboot;
1039     HANDLE catalog, file;
1040     HDEVINFO set;
1041     FILE *f;
1042
1043 #ifdef __i386__
1044 #define EXT "x86"
1045 #elif defined(__x86_64__)
1046 #define EXT "amd64"
1047 #elif defined(__arm__)
1048 #define EXT "arm"
1049 #elif defined(__aarch64__)
1050 #define EXT "arm64"
1051 #else
1052 #define EXT
1053 #endif
1054
1055     static const char inf_text[] =
1056         "[Version]\n"
1057         "Signature=$Chicago$\n"
1058         "ClassGuid={4d36e97d-e325-11ce-bfc1-08002be10318}\n"
1059         "CatalogFile=winetest.cat\n"
1060         "DriverVer=09/21/2006,6.0.5736.1\n"
1061
1062         "[Manufacturer]\n"
1063         "Wine=mfg_section,NT" EXT "\n"
1064
1065         "[mfg_section.NT" EXT "]\n"
1066         "Wine test root driver=device_section,test_hardware_id\n"
1067
1068         "[device_section.NT" EXT "]\n"
1069         "CopyFiles=file_section\n"
1070
1071         "[device_section.NT" EXT ".Services]\n"
1072         "AddService=winetest,0x2,svc_section\n"
1073
1074         "[file_section]\n"
1075         "winetest.sys\n"
1076
1077         "[SourceDisksFiles]\n"
1078         "winetest.sys=1\n"
1079
1080         "[SourceDisksNames]\n"
1081         "1=,winetest.sys\n"
1082
1083         "[DestinationDirs]\n"
1084         "DefaultDestDir=12\n"
1085
1086         "[svc_section]\n"
1087         "ServiceBinary=%12%\\winetest.sys\n"
1088         "ServiceType=1\n"
1089         "StartType=3\n"
1090         "ErrorControl=1\n"
1091         "LoadOrderGroup=Extended Base\n"
1092         "DisplayName=\"winetest bus driver\"\n"
1093         "; they don't sleep anymore, on the beach\n";
1094
1095     GetCurrentDirectoryA(ARRAY_SIZE(cwd), cwd);
1096     GetTempPathA(ARRAY_SIZE(tempdir), tempdir);
1097     SetCurrentDirectoryA(tempdir);
1098
1099     load_resource(L"driver_pnp.dll", driver_filename);
1100     ret = MoveFileExW(driver_filename, L"winetest.sys", MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING);
1101     ok(ret, "failed to move file, error %u\n", GetLastError());
1102
1103     f = fopen("winetest.inf", "w");
1104     ok(!!f, "failed to open winetest.inf: %s\n", strerror(errno));
1105     fputs(inf_text, f);
1106     fclose(f);
1107
1108     /* Create the catalog file. */
1109
1110     catalog = CryptCATOpen((WCHAR *)L"winetest.cat", CRYPTCAT_OPEN_CREATENEW, 0, CRYPTCAT_VERSION_1, 0);
1111     ok(catalog != INVALID_HANDLE_VALUE, "Failed to create catalog, error %#x\n", GetLastError());
1112
1113     ret = !!CryptCATPutCatAttrInfo(catalog, (WCHAR *)L"HWID1",
1114             CRYPTCAT_ATTR_NAMEASCII | CRYPTCAT_ATTR_DATAASCII | CRYPTCAT_ATTR_AUTHENTICATED,
1115             sizeof(L"test_hardware_id"), (BYTE *)L"test_hardware_id");
1116     todo_wine ok(ret, "failed to add attribute, error %#x\n", GetLastError());
1117
1118     ret = !!CryptCATPutCatAttrInfo(catalog, (WCHAR *)L"OS",
1119             CRYPTCAT_ATTR_NAMEASCII | CRYPTCAT_ATTR_DATAASCII | CRYPTCAT_ATTR_AUTHENTICATED,
1120             sizeof(L"VistaX64"), (BYTE *)L"VistaX64");
1121     todo_wine ok(ret, "failed to add attribute, error %#x\n", GetLastError());
1122
1123     add_file_to_catalog(catalog, L"winetest.sys");
1124     add_file_to_catalog(catalog, L"winetest.inf");
1125
1126     ret = CryptCATPersistStore(catalog);
1127     todo_wine ok(ret, "Failed to write catalog, error %u\n", GetLastError());
1128
1129     ret = CryptCATClose(catalog);
1130     ok(ret, "Failed to close catalog, error %u\n", GetLastError());
1131
1132     testsign_sign(ctx, L"winetest.cat");
1133
1134     /* Install the driver. */
1135
1136     set = SetupDiCreateDeviceInfoList(NULL, NULL);
1137     ok(set != INVALID_HANDLE_VALUE, "failed to create device list, error %#x\n", GetLastError());
1138
1139     ret = SetupDiCreateDeviceInfoA(set, "root\\winetest\\0", &GUID_NULL, NULL, NULL, 0, &device);
1140     ok(ret, "failed to create device, error %#x\n", GetLastError());
1141
1142     ret = SetupDiSetDeviceRegistryPropertyA( set, &device, SPDRP_HARDWAREID,
1143             (const BYTE *)hardware_id, sizeof(hardware_id) );
1144     ok(ret, "failed to create set hardware ID, error %#x\n", GetLastError());
1145
1146     ret = SetupDiCallClassInstaller(DIF_REGISTERDEVICE, set, &device);
1147     ok(ret, "failed to register device, error %#x\n", GetLastError());
1148
1149     GetFullPathNameA("winetest.inf", sizeof(path), path, NULL);
1150     ret = UpdateDriverForPlugAndPlayDevicesA(NULL, hardware_id, path, INSTALLFLAG_FORCE, &need_reboot);
1151     ok(ret, "failed to install device, error %#x\n", GetLastError());
1152     ok(!need_reboot, "expected no reboot necessary\n");
1153
1154     /* Tests. */
1155
1156     test_pnp_devices();
1157
1158     /* Clean up. */
1159
1160     ret = SetupDiCallClassInstaller(DIF_REMOVE, set, &device);
1161     ok(ret, "failed to remove device, error %#x\n", GetLastError());
1162
1163     file = CreateFileA("\\\\?\\root#winetest#0#{deadbeef-29ef-4538-a5fd-b69573a362c0}", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
1164     ok(file == INVALID_HANDLE_VALUE, "expected failure\n");
1165     ok(GetLastError() == ERROR_FILE_NOT_FOUND, "got error %u\n", GetLastError());
1166
1167     ret = SetupDiDestroyDeviceInfoList(set);
1168     ok(ret, "failed to destroy set, error %#x\n", GetLastError());
1169
1170     /* Windows stops the service but does not delete it. */
1171     manager = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
1172     ok(!!manager, "failed to open service manager, error %u\n", GetLastError());
1173     service = OpenServiceA(manager, "winetest", SERVICE_STOP | DELETE);
1174     ok(!!service, "failed to open service, error %u\n", GetLastError());
1175     unload_driver(service);
1176     CloseServiceHandle(manager);
1177
1178     GetFullPathNameA("winetest.inf", sizeof(path), path, NULL);
1179     ret = SetupCopyOEMInfA(path, NULL, 0, 0, dest, sizeof(dest), NULL, &filepart);
1180     ok(ret, "Failed to copy INF, error %#x\n", GetLastError());
1181     ret = SetupUninstallOEMInfA(filepart, 0, NULL);
1182     ok(ret, "Failed to uninstall INF, error %u\n", GetLastError());
1183
1184     ret = DeleteFileA("winetest.cat");
1185     ok(ret, "Failed to delete file, error %u\n", GetLastError());
1186     ret = DeleteFileA("winetest.inf");
1187     ok(ret, "Failed to delete file, error %u\n", GetLastError());
1188     ret = DeleteFileA("winetest.sys");
1189     ok(ret, "Failed to delete file, error %u\n", GetLastError());
1190     /* Windows 10 apparently deletes the image in SetupUninstallOEMInf(). */
1191     ret = DeleteFileA("C:/windows/system32/drivers/winetest.sys");
1192     ok(ret || GetLastError() == ERROR_FILE_NOT_FOUND, "Failed to delete file, error %u\n", GetLastError());
1193
1194     SetCurrentDirectoryA(cwd);
1195 }
1196
1197 START_TEST(ntoskrnl)
1198 {
1199     WCHAR filename[MAX_PATH], filename2[MAX_PATH];
1200     struct testsign_context ctx;
1201     SC_HANDLE service, service2;
1202     BOOL ret, is_wow64;
1203     DWORD written;
1204
1205     pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(GetModuleHandleA("ntdll"), "RtlDosPathNameToNtPathName_U");
1206     pRtlFreeUnicodeString = (void *)GetProcAddress(GetModuleHandleA("ntdll"), "RtlFreeUnicodeString");
1207     pCancelIoEx = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"), "CancelIoEx");
1208     pIsWow64Process = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsWow64Process");
1209     pSetFileCompletionNotificationModes = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"),
1210                                                                  "SetFileCompletionNotificationModes");
1211     pSignerSign = (void *)GetProcAddress(LoadLibraryA("mssign32"), "SignerSign");
1212
1213     if (IsWow64Process(GetCurrentProcess(), &is_wow64) && is_wow64)
1214     {
1215         skip("Running in WoW64.\n");
1216         return;
1217     }
1218
1219     if (!testsign_create_cert(&ctx))
1220         return;
1221
1222     subtest("driver");
1223     if (!(service = load_driver(&ctx, filename, L"driver.dll", L"WineTestDriver")))
1224     {
1225         testsign_cleanup(&ctx);
1226         return;
1227     }
1228
1229     if (!start_driver(service, FALSE))
1230     {
1231         DeleteFileW(filename);
1232         testsign_cleanup(&ctx);
1233         return;
1234     }
1235     service2 = load_driver(&ctx, filename2, L"driver2.dll", L"WineTestDriver2");
1236
1237     device = CreateFileA("\\\\.\\WineTestDriver", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
1238     ok(device != INVALID_HANDLE_VALUE, "failed to open device: %u\n", GetLastError());
1239
1240     test_basic_ioctl();
1241     test_mismatched_status_ioctl();
1242
1243     main_test();
1244     todo_wine ok(modified_value == 0xdeadbeeffeedcafe, "Got unexpected value %#I64x.\n", modified_value);
1245
1246     test_overlapped();
1247     test_load_driver(service2);
1248     test_file_handles();
1249     test_return_status();
1250     test_object_info();
1251
1252     /* We need a separate ioctl to call IoDetachDevice(); calling it in the
1253      * driver unload routine causes a live-lock. */
1254     ret = DeviceIoControl(device, IOCTL_WINETEST_DETACH, NULL, 0, NULL, 0, &written, NULL);
1255     ok(ret, "DeviceIoControl failed: %u\n", GetLastError());
1256
1257     CloseHandle(device);
1258
1259     unload_driver(service2);
1260     unload_driver(service);
1261     ret = DeleteFileW(filename);
1262     ok(ret, "DeleteFile failed: %u\n", GetLastError());
1263     ret = DeleteFileW(filename2);
1264     ok(ret, "DeleteFile failed: %u\n", GetLastError());
1265
1266     test_driver3(&ctx);
1267     subtest("driver4");
1268     test_driver4(&ctx);
1269
1270     test_pnp_driver(&ctx);
1271
1272     testsign_cleanup(&ctx);
1273 }