libusb/os/windows_common.c

   1 /*
   2  * windows backend for libusb 1.0
   3  * Copyright © 2009-2012 Pete Batard <pete@akeo.ie>
   4  * With contributions from Michael Plante, Orin Eman et al.
   5  * Parts of this code adapted from libusb-win32-v1 by Stephan Meyer
   6  * HID Reports IOCTLs inspired from HIDAPI by Alan Ott, Signal 11 Software
   7  * Hash table functions adapted from glibc, by Ulrich Drepper et al.
   8  * Major code testing contribution by Xiaofan Chen
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 #include <config.h>
  26
  27 #include <errno.h>
  28 #include <inttypes.h>
  29 #include <process.h>
  30 #include <stdio.h>
  31
  32 #include "libusbi.h"
  33 #include "windows_common.h"
  34
  35 #define EPOCH_TIME      UINT64_C(116444736000000000)    // 1970.01.01 00:00:000 in MS Filetime
  36
  37 #define STATUS_SUCCESS  ((ULONG_PTR)0UL)
  38
  39 // Public
  40 enum windows_version windows_version = WINDOWS_UNDEFINED;
  41
  42 // Global variables for init/exit
  43 static unsigned int init_count;
  44 static bool usbdk_available;
  45
  46 #if !defined(HAVE_CLOCK_GETTIME)
  47 // Global variables for clock_gettime mechanism
  48 static uint64_t hires_ticks_to_ps;
  49 static uint64_t hires_frequency;
  50 #endif
  51
  52 /*
  53 * Converts a windows error to human readable string
  54 * uses retval as errorcode, or, if 0, use GetLastError()
  55 */
  56 #if defined(ENABLE_LOGGING)
  57 const char *windows_error_str(DWORD error_code)
  58 {
  59         static char err_string[256];
  60
  61         DWORD size;
  62         int len;
  63
  64         if (error_code == 0)
  65                 error_code = GetLastError();
  66
  67         len = sprintf(err_string, "[%lu] ", ULONG_CAST(error_code));
  68
  69         // Translate codes returned by SetupAPI. The ones we are dealing with are either
  70         // in 0x0000xxxx or 0xE000xxxx and can be distinguished from standard error codes.
  71         // See http://msdn.microsoft.com/en-us/library/windows/hardware/ff545011.aspx
  72         switch (error_code & 0xE0000000) {
  73         case 0:
  74                 error_code = HRESULT_FROM_WIN32(error_code); // Still leaves ERROR_SUCCESS unmodified
  75                 break;
  76         case 0xE0000000:
  77                 error_code = 0x80000000 | (FACILITY_SETUPAPI << 16) | (error_code & 0x0000FFFF);
  78                 break;
  79         default:
  80                 break;
  81         }
  82
  83         size = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
  84                         NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  85                         &err_string[len], sizeof(err_string) - len, NULL);
  86         if (size == 0) {
  87                 DWORD format_error = GetLastError();
  88                 if (format_error)
  89                         snprintf(err_string, sizeof(err_string),
  90                                 "Windows error code %lu (FormatMessage error code %lu)",
  91                                 ULONG_CAST(error_code), ULONG_CAST(format_error));
  92                 else
  93                         snprintf(err_string, sizeof(err_string), "Unknown error code %lu",
  94                                 ULONG_CAST(error_code));
  95         } else {
  96                 // Remove CRLF from end of message, if present
  97                 size_t pos = len + size - 2;
  98                 if (err_string[pos] == '\r')
  99                         err_string[pos] = '\0';
 100         }
 101
 102         return err_string;
 103 }
 104 #endif
 105
 106 /* Hash table functions - modified From glibc 2.3.2:
 107    [Aho,Sethi,Ullman] Compilers: Principles, Techniques and Tools, 1986
 108    [Knuth]            The Art of Computer Programming, part 3 (6.4)  */
 109
 110 #define HTAB_SIZE 1021UL        // *MUST* be a prime number!!
 111
 112 typedef struct htab_entry {
 113         unsigned long used;
 114         char *str;
 115 } htab_entry;
 116
 117 static htab_entry *htab_table;
 118 static usbi_mutex_t htab_mutex;
 119 static unsigned long htab_filled;
 120
 121 /* Before using the hash table we must allocate memory for it.
 122    We allocate one element more as the found prime number says.
 123    This is done for more effective indexing as explained in the
 124    comment for the hash function.  */
 125 static bool htab_create(struct libusb_context *ctx)
 126 {
 127         if (htab_table != NULL) {
 128                 usbi_err(ctx, "program assertion falied - hash table already allocated");
 129                 return true;
 130         }
 131
 132         // Create a mutex
 133         usbi_mutex_init(&htab_mutex);
 134
 135         usbi_dbg("using %lu entries hash table", HTAB_SIZE);
 136         htab_filled = 0;
 137
 138         // allocate memory and zero out.
 139         htab_table = calloc(HTAB_SIZE + 1, sizeof(htab_entry));
 140         if (htab_table == NULL) {
 141                 usbi_err(ctx, "could not allocate space for hash table");
 142                 return false;
 143         }
 144
 145         return true;
 146 }
 147
 148 /* After using the hash table it has to be destroyed.  */
 149 static void htab_destroy(void)
 150 {
 151         unsigned long i;
 152
 153         if (htab_table == NULL)
 154                 return;
 155
 156         for (i = 0; i < HTAB_SIZE; i++)
 157                 free(htab_table[i].str);
 158
 159         safe_free(htab_table);
 160
 161         usbi_mutex_destroy(&htab_mutex);
 162 }
 163
 164 /* This is the search function. It uses double hashing with open addressing.
 165    We use a trick to speed up the lookup. The table is created with one
 166    more element available. This enables us to use the index zero special.
 167    This index will never be used because we store the first hash index in
 168    the field used where zero means not used. Every other value means used.
 169    The used field can be used as a first fast comparison for equality of
 170    the stored and the parameter value. This helps to prevent unnecessary
 171    expensive calls of strcmp.  */
 172 unsigned long htab_hash(const char *str)
 173 {
 174         unsigned long hval, hval2;
 175         unsigned long idx;
 176         unsigned long r = 5381UL;
 177         int c;
 178         const char *sz = str;
 179
 180         if (str == NULL)
 181                 return 0;
 182
 183         // Compute main hash value (algorithm suggested by Nokia)
 184         while ((c = *sz++) != 0)
 185                 r = ((r << 5) + r) + c;
 186         if (r == 0)
 187                 ++r;
 188
 189         // compute table hash: simply take the modulus
 190         hval = r % HTAB_SIZE;
 191         if (hval == 0)
 192                 ++hval;
 193
 194         // Try the first index
 195         idx = hval;
 196
 197         // Mutually exclusive access (R/W lock would be better)
 198         usbi_mutex_lock(&htab_mutex);
 199
 200         if (htab_table[idx].used) {
 201                 if ((htab_table[idx].used == hval) && (strcmp(str, htab_table[idx].str) == 0))
 202                         goto out_unlock; // existing hash
 203
 204                 usbi_dbg("hash collision ('%s' vs '%s')", str, htab_table[idx].str);
 205
 206                 // Second hash function, as suggested in [Knuth]
 207                 hval2 = 1UL + hval % (HTAB_SIZE - 2);
 208
 209                 do {
 210                         // Because size is prime this guarantees to step through all available indexes
 211                         if (idx <= hval2)
 212                                 idx = HTAB_SIZE + idx - hval2;
 213                         else
 214                                 idx -= hval2;
 215
 216                         // If we visited all entries leave the loop unsuccessfully
 217                         if (idx == hval)
 218                                 break;
 219
 220                         // If entry is found use it.
 221                         if ((htab_table[idx].used == hval) && (strcmp(str, htab_table[idx].str) == 0))
 222                                 goto out_unlock;
 223                 } while (htab_table[idx].used);
 224         }
 225
 226         // Not found => New entry
 227
 228         // If the table is full return an error
 229         if (htab_filled >= HTAB_SIZE) {
 230                 usbi_err(NULL, "hash table is full (%lu entries)", HTAB_SIZE);
 231                 idx = 0UL;
 232                 goto out_unlock;
 233         }
 234
 235         htab_table[idx].str = _strdup(str);
 236         if (htab_table[idx].str == NULL) {
 237                 usbi_err(NULL, "could not duplicate string for hash table");
 238                 idx = 0UL;
 239                 goto out_unlock;
 240         }
 241
 242         htab_table[idx].used = hval;
 243         ++htab_filled;
 244
 245 out_unlock:
 246         usbi_mutex_unlock(&htab_mutex);
 247
 248         return idx;
 249 }
 250
 251 enum libusb_transfer_status usbd_status_to_libusb_transfer_status(USBD_STATUS status)
 252 {
 253         if (USBD_SUCCESS(status))
 254                 return LIBUSB_TRANSFER_COMPLETED;
 255
 256         switch (status) {
 257         case USBD_STATUS_TIMEOUT:
 258                 return LIBUSB_TRANSFER_TIMED_OUT;
 259         case USBD_STATUS_CANCELED:
 260                 return LIBUSB_TRANSFER_CANCELLED;
 261         case USBD_STATUS_ENDPOINT_HALTED:
 262                 return LIBUSB_TRANSFER_STALL;
 263         case USBD_STATUS_DEVICE_GONE:
 264                 return LIBUSB_TRANSFER_NO_DEVICE;
 265         default:
 266                 usbi_dbg("USBD_STATUS 0x%08lx translated to LIBUSB_TRANSFER_ERROR", ULONG_CAST(status));
 267                 return LIBUSB_TRANSFER_ERROR;
 268         }
 269 }
 270
 271 /*
 272  * Make a transfer complete synchronously
 273  */
 274 void windows_force_sync_completion(struct usbi_transfer *itransfer, ULONG size)
 275 {
 276         struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
 277         OVERLAPPED *overlapped = &transfer_priv->overlapped;
 278
 279         usbi_dbg("transfer %p, length %lu", USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer), size);
 280
 281         overlapped->Internal = (ULONG_PTR)STATUS_SUCCESS;
 282         overlapped->InternalHigh = (ULONG_PTR)size;
 283
 284         usbi_signal_transfer_completion(itransfer);
 285 }
 286
 287 static void windows_init_clock(void)
 288 {
 289 #if !defined(HAVE_CLOCK_GETTIME)
 290         LARGE_INTEGER li_frequency;
 291
 292         // Microsoft says that the QueryPerformanceFrequency() and
 293         // QueryPerformanceCounter() functions always succeed on XP and later
 294         QueryPerformanceFrequency(&li_frequency);
 295
 296         // The hires frequency can go as high as 4 GHz, so we'll use a conversion
 297         // to picoseconds to compute the tv_nsecs part in clock_gettime
 298         hires_frequency = li_frequency.QuadPart;
 299         hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
 300         usbi_dbg("hires timer frequency: %"PRIu64" Hz", hires_frequency);
 301 #endif
 302 }
 303
 304 /* Windows version detection */
 305 static BOOL is_x64(void)
 306 {
 307         BOOL ret = FALSE;
 308
 309         // Detect if we're running a 32 or 64 bit system
 310         if (sizeof(uintptr_t) < 8) {
 311                 IsWow64Process(GetCurrentProcess(), &ret);
 312         } else {
 313                 ret = TRUE;
 314         }
 315
 316         return ret;
 317 }
 318
 319 static enum windows_version get_windows_version(void)
 320 {
 321         enum windows_version winver;
 322         OSVERSIONINFOEXA vi, vi2;
 323         unsigned major, minor, version;
 324         ULONGLONG major_equal, minor_equal;
 325         const char *w, *arch;
 326         bool ws;
 327
 328         memset(&vi, 0, sizeof(vi));
 329         vi.dwOSVersionInfoSize = sizeof(vi);
 330         if (!GetVersionExA((OSVERSIONINFOA *)&vi)) {
 331                 memset(&vi, 0, sizeof(vi));
 332                 vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
 333                 if (!GetVersionExA((OSVERSIONINFOA *)&vi))
 334                         return WINDOWS_UNDEFINED;
 335         }
 336
 337         if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
 338                 return WINDOWS_UNDEFINED;
 339
 340         if ((vi.dwMajorVersion > 6) || ((vi.dwMajorVersion == 6) && (vi.dwMinorVersion >= 2))) {
 341                 // Starting with Windows 8.1 Preview, GetVersionEx() does no longer report the actual OS version
 342                 // See: http://msdn.microsoft.com/en-us/library/windows/desktop/dn302074.aspx
 343
 344                 major_equal = VerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL);
 345                 for (major = vi.dwMajorVersion; major <= 9; major++) {
 346                         memset(&vi2, 0, sizeof(vi2));
 347                         vi2.dwOSVersionInfoSize = sizeof(vi2);
 348                         vi2.dwMajorVersion = major;
 349                         if (!VerifyVersionInfoA(&vi2, VER_MAJORVERSION, major_equal))
 350                                 continue;
 351
 352                         if (vi.dwMajorVersion < major) {
 353                                 vi.dwMajorVersion = major;
 354                                 vi.dwMinorVersion = 0;
 355                         }
 356
 357                         minor_equal = VerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL);
 358                         for (minor = vi.dwMinorVersion; minor <= 9; minor++) {
 359                                 memset(&vi2, 0, sizeof(vi2));
 360                                 vi2.dwOSVersionInfoSize = sizeof(vi2);
 361                                 vi2.dwMinorVersion = minor;
 362                                 if (!VerifyVersionInfoA(&vi2, VER_MINORVERSION, minor_equal))
 363                                         continue;
 364
 365                                 vi.dwMinorVersion = minor;
 366                                 break;
 367                         }
 368
 369                         break;
 370                 }
 371         }
 372
 373         if ((vi.dwMajorVersion > 0xf) || (vi.dwMinorVersion > 0xf))
 374                 return WINDOWS_UNDEFINED;
 375
 376         ws = (vi.wProductType <= VER_NT_WORKSTATION);
 377         version = vi.dwMajorVersion << 4 | vi.dwMinorVersion;
 378         switch (version) {
 379         case 0x50: winver = WINDOWS_2000;  w = "2000"; break;
 380         case 0x51: winver = WINDOWS_XP;    w = "XP";   break;
 381         case 0x52: winver = WINDOWS_2003;  w = "2003"; break;
 382         case 0x60: winver = WINDOWS_VISTA; w = (ws ? "Vista" : "2008");  break;
 383         case 0x61: winver = WINDOWS_7;     w = (ws ? "7" : "2008_R2");   break;
 384         case 0x62: winver = WINDOWS_8;     w = (ws ? "8" : "2012");      break;
 385         case 0x63: winver = WINDOWS_8_1;   w = (ws ? "8.1" : "2012_R2"); break;
 386         case 0x64: // Early Windows 10 Insider Previews and Windows Server 2017 Technical Preview 1 used version 6.4
 387         case 0xA0: winver = WINDOWS_10;    w = (ws ? "10" : "2016");     break;
 388         default:
 389                 if (version < 0x50)
 390                         return WINDOWS_UNDEFINED;
 391                 winver = WINDOWS_11_OR_LATER;
 392                 w = "11 or later";
 393         }
 394
 395         arch = is_x64() ? "64-bit" : "32-bit";
 396
 397         if (vi.wServicePackMinor)
 398                 usbi_dbg("Windows %s SP%u.%u %s", w, vi.wServicePackMajor, vi.wServicePackMinor, arch);
 399         else if (vi.wServicePackMajor)
 400                 usbi_dbg("Windows %s SP%u %s", w, vi.wServicePackMajor, arch);
 401         else
 402                 usbi_dbg("Windows %s %s", w, arch);
 403
 404         return winver;
 405 }
 406
 407 static unsigned __stdcall windows_iocp_thread(void *arg)
 408 {
 409         struct libusb_context *ctx = arg;
 410         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 411         HANDLE iocp = priv->completion_port;
 412         DWORD num_bytes;
 413         ULONG_PTR completion_key;
 414         OVERLAPPED *overlapped;
 415         struct windows_transfer_priv *transfer_priv;
 416         struct usbi_transfer *itransfer;
 417
 418         usbi_dbg("I/O completion thread started");
 419
 420         while (true) {
 421                 if (!GetQueuedCompletionStatus(iocp, &num_bytes, &completion_key, &overlapped, INFINITE)) {
 422                         usbi_err(ctx, "GetQueuedCompletionStatus failed: %s", windows_error_str(0));
 423                         break;
 424                 }
 425
 426                 if (overlapped == NULL)
 427                         break; // Signal to quit
 428
 429                 transfer_priv = container_of(overlapped, struct windows_transfer_priv, overlapped);
 430                 itransfer = (struct usbi_transfer *)((unsigned char *)transfer_priv + PTR_ALIGN(sizeof(*transfer_priv)));
 431                 usbi_dbg("transfer %p completed, length %lu",
 432                          USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer), ULONG_CAST(num_bytes));
 433                 usbi_signal_transfer_completion(itransfer);
 434         }
 435
 436         usbi_dbg("I/O completion thread exiting");
 437
 438         return 0;
 439 }
 440
 441 static int windows_init(struct libusb_context *ctx)
 442 {
 443         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 444         char mutex_name[11 + 8 + 1]; // strlen("libusb_init") + (32-bit hex PID) + '\0'
 445         HANDLE mutex;
 446         bool winusb_backend_init = false;
 447         int r;
 448
 449         sprintf(mutex_name, "libusb_init%08lX", ULONG_CAST(GetCurrentProcessId() & 0xFFFFFFFFU));
 450         mutex = CreateMutexA(NULL, FALSE, mutex_name);
 451         if (mutex == NULL) {
 452                 usbi_err(ctx, "could not create mutex: %s", windows_error_str(0));
 453                 return LIBUSB_ERROR_NO_MEM;
 454         }
 455
 456         // A successful wait gives this thread ownership of the mutex
 457         // => any concurent wait stalls until the mutex is released
 458         if (WaitForSingleObject(mutex, INFINITE) != WAIT_OBJECT_0) {
 459                 usbi_err(ctx, "failure to access mutex: %s", windows_error_str(0));
 460                 CloseHandle(mutex);
 461                 return LIBUSB_ERROR_NO_MEM;
 462         }
 463
 464         // NB: concurrent usage supposes that init calls are equally balanced with
 465         // exit calls. If init is called more than exit, we will not exit properly
 466         if (++init_count == 1) { // First init?
 467                 windows_version = get_windows_version();
 468                 if (windows_version == WINDOWS_UNDEFINED) {
 469                         usbi_err(ctx, "failed to detect Windows version");
 470                         r = LIBUSB_ERROR_NOT_SUPPORTED;
 471                         goto init_exit;
 472                 } else if (windows_version < WINDOWS_VISTA) {
 473                         usbi_err(ctx, "Windows version is too old");
 474                         r = LIBUSB_ERROR_NOT_SUPPORTED;
 475                         goto init_exit;
 476                 }
 477
 478                 windows_init_clock();
 479
 480                 if (!htab_create(ctx)) {
 481                         r = LIBUSB_ERROR_NO_MEM;
 482                         goto init_exit;
 483                 }
 484
 485                 r = winusb_backend.init(ctx);
 486                 if (r != LIBUSB_SUCCESS)
 487                         goto init_exit;
 488                 winusb_backend_init = true;
 489
 490                 r = usbdk_backend.init(ctx);
 491                 if (r == LIBUSB_SUCCESS) {
 492                         usbi_dbg("UsbDk backend is available");
 493                         usbdk_available = true;
 494                 } else {
 495                         usbi_info(ctx, "UsbDk backend is not available");
 496                         // Do not report this as an error
 497                 }
 498         }
 499
 500         // By default, new contexts will use the WinUSB backend
 501         priv->backend = &winusb_backend;
 502
 503         r = LIBUSB_ERROR_NO_MEM;
 504
 505         // Use an I/O completion port to manage all transfers for this context
 506         priv->completion_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
 507         if (priv->completion_port == NULL) {
 508                 usbi_err(ctx, "failed to create I/O completion port: %s", windows_error_str(0));
 509                 goto init_exit;
 510         }
 511
 512         // And a dedicated thread to wait for I/O completions
 513         priv->completion_port_thread = (HANDLE)_beginthreadex(NULL, 0, windows_iocp_thread, ctx, 0, NULL);
 514         if (priv->completion_port_thread == NULL) {
 515                 usbi_err(ctx, "failed to create I/O completion port thread");
 516                 CloseHandle(priv->completion_port);
 517                 goto init_exit;
 518         }
 519
 520         r = LIBUSB_SUCCESS;
 521
 522 init_exit: // Holds semaphore here
 523         if ((init_count == 1) && (r != LIBUSB_SUCCESS)) { // First init failed?
 524                 if (usbdk_available) {
 525                         usbdk_backend.exit(ctx);
 526                         usbdk_available = false;
 527                 }
 528                 if (winusb_backend_init)
 529                         winusb_backend.exit(ctx);
 530                 htab_destroy();
 531                 --init_count;
 532         }
 533
 534         ReleaseMutex(mutex);
 535         CloseHandle(mutex);
 536         return r;
 537 }
 538
 539 static void windows_exit(struct libusb_context *ctx)
 540 {
 541         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 542         char mutex_name[11 + 8 + 1]; // strlen("libusb_init") + (32-bit hex PID) + '\0'
 543         HANDLE mutex;
 544
 545         sprintf(mutex_name, "libusb_init%08lX", ULONG_CAST(GetCurrentProcessId() & 0xFFFFFFFFU));
 546         mutex = CreateMutexA(NULL, FALSE, mutex_name);
 547         if (mutex == NULL)
 548                 return;
 549
 550         // A successful wait gives this thread ownership of the mutex
 551         // => any concurent wait stalls until the mutex is released
 552         if (WaitForSingleObject(mutex, INFINITE) != WAIT_OBJECT_0) {
 553                 usbi_err(ctx, "failed to access mutex: %s", windows_error_str(0));
 554                 CloseHandle(mutex);
 555                 return;
 556         }
 557
 558         // A NULL completion status will indicate to the thread that it is time to exit
 559         if (!PostQueuedCompletionStatus(priv->completion_port, 0, 0, NULL))
 560                 usbi_err(ctx, "failed to post I/O completion: %s", windows_error_str(0));
 561
 562         if (WaitForSingleObject(priv->completion_port_thread, INFINITE) == WAIT_FAILED)
 563                 usbi_err(ctx, "failed to wait for I/O completion port thread: %s", windows_error_str(0));
 564
 565         CloseHandle(priv->completion_port_thread);
 566         CloseHandle(priv->completion_port);
 567
 568         // Only works if exits and inits are balanced exactly
 569         if (--init_count == 0) { // Last exit
 570                 if (usbdk_available) {
 571                         usbdk_backend.exit(ctx);
 572                         usbdk_available = false;
 573                 }
 574                 winusb_backend.exit(ctx);
 575                 htab_destroy();
 576         }
 577
 578         ReleaseMutex(mutex);
 579         CloseHandle(mutex);
 580 }
 581
 582 static int windows_set_option(struct libusb_context *ctx, enum libusb_option option, va_list ap)
 583 {
 584         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 585
 586         UNUSED(ap);
 587
 588         switch ((int)option) {
 589         case LIBUSB_OPTION_USE_USBDK:
 590                 if (usbdk_available) {
 591                         usbi_dbg("switching context %p to use UsbDk backend", ctx);
 592                         priv->backend = &usbdk_backend;
 593                 } else {
 594                         usbi_err(ctx, "UsbDk backend not available");
 595                         return LIBUSB_ERROR_NOT_FOUND;
 596                 }
 597                 return LIBUSB_SUCCESS;
 598         default:
 599                 return LIBUSB_ERROR_NOT_SUPPORTED;
 600         }
 601 }
 602
 603 static int windows_get_device_list(struct libusb_context *ctx, struct discovered_devs **discdevs)
 604 {
 605         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 606         return priv->backend->get_device_list(ctx, discdevs);
 607 }
 608
 609 static int windows_open(struct libusb_device_handle *dev_handle)
 610 {
 611         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 612         return priv->backend->open(dev_handle);
 613 }
 614
 615 static void windows_close(struct libusb_device_handle *dev_handle)
 616 {
 617         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 618         priv->backend->close(dev_handle);
 619 }
 620
 621 static int windows_get_active_config_descriptor(struct libusb_device *dev,
 622         void *buffer, size_t len)
 623 {
 624         struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
 625         return priv->backend->get_active_config_descriptor(dev, buffer, len);
 626 }
 627
 628 static int windows_get_config_descriptor(struct libusb_device *dev,
 629         uint8_t config_index, void *buffer, size_t len)
 630 {
 631         struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
 632         return priv->backend->get_config_descriptor(dev, config_index, buffer, len);
 633 }
 634
 635 static int windows_get_config_descriptor_by_value(struct libusb_device *dev,
 636         uint8_t bConfigurationValue, void **buffer)
 637 {
 638         struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
 639         return priv->backend->get_config_descriptor_by_value(dev, bConfigurationValue, buffer);
 640 }
 641
 642 static int windows_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config)
 643 {
 644         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 645         return priv->backend->get_configuration(dev_handle, config);
 646 }
 647
 648 static int windows_set_configuration(struct libusb_device_handle *dev_handle, int config)
 649 {
 650         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 651         if (config == -1)
 652                 config = 0;
 653         return priv->backend->set_configuration(dev_handle, (uint8_t)config);
 654 }
 655
 656 static int windows_claim_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
 657 {
 658         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 659         return priv->backend->claim_interface(dev_handle, interface_number);
 660 }
 661
 662 static int windows_release_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
 663 {
 664         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 665         return priv->backend->release_interface(dev_handle, interface_number);
 666 }
 667
 668 static int windows_set_interface_altsetting(struct libusb_device_handle *dev_handle,
 669         uint8_t interface_number, uint8_t altsetting)
 670 {
 671         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 672         return priv->backend->set_interface_altsetting(dev_handle, interface_number, altsetting);
 673 }
 674
 675 static int windows_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
 676 {
 677         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 678         return priv->backend->clear_halt(dev_handle, endpoint);
 679 }
 680
 681 static int windows_reset_device(struct libusb_device_handle *dev_handle)
 682 {
 683         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 684         return priv->backend->reset_device(dev_handle);
 685 }
 686
 687 static void windows_destroy_device(struct libusb_device *dev)
 688 {
 689         struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
 690         priv->backend->destroy_device(dev);
 691 }
 692
 693 static int windows_submit_transfer(struct usbi_transfer *itransfer)
 694 {
 695         struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 696         struct libusb_context *ctx = TRANSFER_CTX(transfer);
 697         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 698         struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
 699         int r;
 700
 701         switch (transfer->type) {
 702         case LIBUSB_TRANSFER_TYPE_CONTROL:
 703         case LIBUSB_TRANSFER_TYPE_BULK:
 704         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
 705         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 706                 break;
 707         case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
 708                 usbi_warn(ctx, "bulk stream transfers are not yet supported on this platform");
 709                 return LIBUSB_ERROR_NOT_SUPPORTED;
 710         default:
 711                 usbi_err(ctx, "unknown endpoint type %d", transfer->type);
 712                 return LIBUSB_ERROR_INVALID_PARAM;
 713         }
 714
 715         if (transfer_priv->handle != NULL) {
 716                 usbi_err(ctx, "program assertion failed - transfer HANDLE is not NULL");
 717                 transfer_priv->handle = NULL;
 718         }
 719
 720         r = priv->backend->submit_transfer(itransfer);
 721         if (r != LIBUSB_SUCCESS) {
 722                 // Always call the backend's clear_transfer_priv() function on failure
 723                 priv->backend->clear_transfer_priv(itransfer);
 724                 transfer_priv->handle = NULL;
 725                 return r;
 726         }
 727
 728         // The backend should set the HANDLE used for each submitted transfer
 729         // by calling set_transfer_priv_handle()
 730         if (transfer_priv->handle == NULL)
 731                 usbi_err(ctx, "program assertion failed - transfer HANDLE is NULL after transfer was submitted");
 732
 733         return r;
 734 }
 735
 736 static int windows_cancel_transfer(struct usbi_transfer *itransfer)
 737 {
 738         struct windows_context_priv *priv = usbi_get_context_priv(ITRANSFER_CTX(itransfer));
 739         struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
 740
 741         // Try CancelIoEx() on the transfer
 742         // If that fails, fall back to the backend's cancel_transfer()
 743         // function if it is available
 744         if (CancelIoEx(transfer_priv->handle, &transfer_priv->overlapped))
 745                 return LIBUSB_SUCCESS;
 746         else if (GetLastError() == ERROR_NOT_FOUND)
 747                 return LIBUSB_ERROR_NOT_FOUND;
 748
 749         if (priv->backend->cancel_transfer)
 750                 return priv->backend->cancel_transfer(itransfer);
 751
 752         usbi_warn(ITRANSFER_CTX(itransfer), "cancellation not supported for this transfer's driver");
 753         return LIBUSB_ERROR_NOT_SUPPORTED;
 754 }
 755
 756 static int windows_handle_transfer_completion(struct usbi_transfer *itransfer)
 757 {
 758         struct libusb_context *ctx = ITRANSFER_CTX(itransfer);
 759         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 760         const struct windows_backend *backend = priv->backend;
 761         struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
 762         enum libusb_transfer_status status, istatus;
 763         DWORD result, bytes_transferred;
 764
 765         if (GetOverlappedResult(transfer_priv->handle, &transfer_priv->overlapped, &bytes_transferred, FALSE))
 766                 result = NO_ERROR;
 767         else
 768                 result = GetLastError();
 769
 770         usbi_dbg("handling transfer %p completion with errcode %lu, length %lu",
 771                  USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer), ULONG_CAST(result), ULONG_CAST(bytes_transferred));
 772
 773         switch (result) {
 774         case NO_ERROR:
 775                 status = backend->copy_transfer_data(itransfer, bytes_transferred);
 776                 break;
 777         case ERROR_GEN_FAILURE:
 778                 usbi_dbg("detected endpoint stall");
 779                 status = LIBUSB_TRANSFER_STALL;
 780                 break;
 781         case ERROR_SEM_TIMEOUT:
 782                 usbi_dbg("detected semaphore timeout");
 783                 status = LIBUSB_TRANSFER_TIMED_OUT;
 784                 break;
 785         case ERROR_OPERATION_ABORTED:
 786                 istatus = backend->copy_transfer_data(itransfer, bytes_transferred);
 787                 if (istatus != LIBUSB_TRANSFER_COMPLETED)
 788                         usbi_dbg("failed to copy partial data in aborted operation: %d", (int)istatus);
 789
 790                 usbi_dbg("detected operation aborted");
 791                 status = LIBUSB_TRANSFER_CANCELLED;
 792                 break;
 793         case ERROR_FILE_NOT_FOUND:
 794         case ERROR_DEVICE_NOT_CONNECTED:
 795         case ERROR_NO_SUCH_DEVICE:
 796                 usbi_dbg("detected device removed");
 797                 status = LIBUSB_TRANSFER_NO_DEVICE;
 798                 break;
 799         default:
 800                 usbi_err(ctx, "detected I/O error %lu: %s",
 801                         ULONG_CAST(result), windows_error_str(result));
 802                 status = LIBUSB_TRANSFER_ERROR;
 803                 break;
 804         }
 805
 806         transfer_priv->handle = NULL;
 807
 808         // Backend-specific cleanup
 809         backend->clear_transfer_priv(itransfer);
 810
 811         if (status == LIBUSB_TRANSFER_CANCELLED)
 812                 return usbi_handle_transfer_cancellation(itransfer);
 813         else
 814                 return usbi_handle_transfer_completion(itransfer, status);
 815 }
 816
 817 #if !defined(HAVE_CLOCK_GETTIME)
 818 int usbi_clock_gettime(int clk_id, struct timespec *tp)
 819 {
 820         LARGE_INTEGER hires_counter;
 821 #if !defined(_MSC_VER) || (_MSC_VER < 1900)
 822         FILETIME filetime;
 823         ULARGE_INTEGER rtime;
 824 #endif
 825
 826         switch (clk_id) {
 827         case USBI_CLOCK_MONOTONIC:
 828                 if (hires_frequency) {
 829                         QueryPerformanceCounter(&hires_counter);
 830                         tp->tv_sec = (long)(hires_counter.QuadPart / hires_frequency);
 831                         tp->tv_nsec = (long)(((hires_counter.QuadPart % hires_frequency) * hires_ticks_to_ps) / UINT64_C(1000));
 832                         return 0;
 833                 }
 834                 // Return real-time if monotonic was not detected @ timer init
 835                 // Fall through
 836         case USBI_CLOCK_REALTIME:
 837 #if defined(_MSC_VER) && (_MSC_VER >= 1900)
 838                 if (!timespec_get(tp, TIME_UTC)) {
 839                         errno = EIO;
 840                         return -1;
 841                 }
 842 #else
 843                 // We follow http://msdn.microsoft.com/en-us/library/ms724928%28VS.85%29.aspx
 844                 // with a predef epoch time to have an epoch that starts at 1970.01.01 00:00
 845                 // Note however that our resolution is bounded by the Windows system time
 846                 // functions and is at best of the order of 1 ms (or, usually, worse)
 847                 GetSystemTimeAsFileTime(&filetime);
 848                 rtime.LowPart = filetime.dwLowDateTime;
 849                 rtime.HighPart = filetime.dwHighDateTime;
 850                 rtime.QuadPart -= EPOCH_TIME;
 851                 tp->tv_sec = (long)(rtime.QuadPart / 10000000);
 852                 tp->tv_nsec = (long)((rtime.QuadPart % 10000000) * 100);
 853 #endif
 854                 return 0;
 855         default:
 856                 errno = EINVAL;
 857                 return -1;
 858         }
 859 }
 860 #endif
 861
 862 // NB: MSVC6 does not support named initializers.
 863 const struct usbi_os_backend usbi_backend = {
 864         "Windows",
 865         USBI_CAP_HAS_HID_ACCESS,
 866         windows_init,
 867         windows_exit,
 868         windows_set_option,
 869         windows_get_device_list,
 870         NULL,   /* hotplug_poll */
 871         NULL,   /* wrap_sys_device */
 872         windows_open,
 873         windows_close,
 874         windows_get_active_config_descriptor,
 875         windows_get_config_descriptor,
 876         windows_get_config_descriptor_by_value,
 877         windows_get_configuration,
 878         windows_set_configuration,
 879         windows_claim_interface,
 880         windows_release_interface,
 881         windows_set_interface_altsetting,
 882         windows_clear_halt,
 883         windows_reset_device,
 884         NULL,   /* alloc_streams */
 885         NULL,   /* free_streams */
 886         NULL,   /* dev_mem_alloc */
 887         NULL,   /* dev_mem_free */
 888         NULL,   /* kernel_driver_active */
 889         NULL,   /* detach_kernel_driver */
 890         NULL,   /* attach_kernel_driver */
 891         windows_destroy_device,
 892         windows_submit_transfer,
 893         windows_cancel_transfer,
 894         NULL,   /* clear_transfer_priv */
 895         NULL,   /* handle_events */
 896         windows_handle_transfer_completion,
 897         sizeof(struct windows_context_priv),
 898         sizeof(union windows_device_priv),
 899         sizeof(union windows_device_handle_priv),
 900         sizeof(struct windows_transfer_priv),
 901 };