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(OVERLAPPED *overlapped, ULONG size)
 275 {
 276         overlapped->Internal = (ULONG_PTR)STATUS_SUCCESS;
 277         overlapped->InternalHigh = (ULONG_PTR)size;
 278         SetEvent(overlapped->hEvent);
 279 }
 280
 281 static void windows_init_clock(void)
 282 {
 283 #if !defined(HAVE_CLOCK_GETTIME)
 284         LARGE_INTEGER li_frequency;
 285
 286         // Microsoft says that the QueryPerformanceFrequency() and
 287         // QueryPerformanceCounter() functions always succeed on XP and later
 288         QueryPerformanceFrequency(&li_frequency);
 289
 290         // The hires frequency can go as high as 4 GHz, so we'll use a conversion
 291         // to picoseconds to compute the tv_nsecs part in clock_gettime
 292         hires_frequency = li_frequency.QuadPart;
 293         hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency;
 294         usbi_dbg("hires timer frequency: %"PRIu64" Hz", hires_frequency);
 295 #endif
 296 }
 297
 298 /* Windows version detection */
 299 static BOOL is_x64(void)
 300 {
 301         BOOL ret = FALSE;
 302
 303         // Detect if we're running a 32 or 64 bit system
 304         if (sizeof(uintptr_t) < 8) {
 305                 IsWow64Process(GetCurrentProcess(), &ret);
 306         } else {
 307                 ret = TRUE;
 308         }
 309
 310         return ret;
 311 }
 312
 313 static void get_windows_version(void)
 314 {
 315         OSVERSIONINFOEXA vi, vi2;
 316         const char *arch, *w = NULL;
 317         unsigned major, minor, version;
 318         ULONGLONG major_equal, minor_equal;
 319         bool ws;
 320
 321         windows_version = WINDOWS_UNDEFINED;
 322
 323         memset(&vi, 0, sizeof(vi));
 324         vi.dwOSVersionInfoSize = sizeof(vi);
 325         if (!GetVersionExA((OSVERSIONINFOA *)&vi)) {
 326                 memset(&vi, 0, sizeof(vi));
 327                 vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
 328                 if (!GetVersionExA((OSVERSIONINFOA *)&vi))
 329                         return;
 330         }
 331
 332         if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
 333                 return;
 334
 335         if ((vi.dwMajorVersion > 6) || ((vi.dwMajorVersion == 6) && (vi.dwMinorVersion >= 2))) {
 336                 // Starting with Windows 8.1 Preview, GetVersionEx() does no longer report the actual OS version
 337                 // See: http://msdn.microsoft.com/en-us/library/windows/desktop/dn302074.aspx
 338
 339                 major_equal = VerSetConditionMask(0, VER_MAJORVERSION, VER_EQUAL);
 340                 for (major = vi.dwMajorVersion; major <= 9; major++) {
 341                         memset(&vi2, 0, sizeof(vi2));
 342                         vi2.dwOSVersionInfoSize = sizeof(vi2);
 343                         vi2.dwMajorVersion = major;
 344                         if (!VerifyVersionInfoA(&vi2, VER_MAJORVERSION, major_equal))
 345                                 continue;
 346
 347                         if (vi.dwMajorVersion < major) {
 348                                 vi.dwMajorVersion = major;
 349                                 vi.dwMinorVersion = 0;
 350                         }
 351
 352                         minor_equal = VerSetConditionMask(0, VER_MINORVERSION, VER_EQUAL);
 353                         for (minor = vi.dwMinorVersion; minor <= 9; minor++) {
 354                                 memset(&vi2, 0, sizeof(vi2));
 355                                 vi2.dwOSVersionInfoSize = sizeof(vi2);
 356                                 vi2.dwMinorVersion = minor;
 357                                 if (!VerifyVersionInfoA(&vi2, VER_MINORVERSION, minor_equal))
 358                                         continue;
 359
 360                                 vi.dwMinorVersion = minor;
 361                                 break;
 362                         }
 363
 364                         break;
 365                 }
 366         }
 367
 368         if ((vi.dwMajorVersion > 0xf) || (vi.dwMinorVersion > 0xf))
 369                 return;
 370
 371         ws = (vi.wProductType <= VER_NT_WORKSTATION);
 372         version = vi.dwMajorVersion << 4 | vi.dwMinorVersion;
 373         switch (version) {
 374         case 0x50: windows_version = WINDOWS_2000;  w = "2000"; break;
 375         case 0x51: windows_version = WINDOWS_XP;    w = "XP";   break;
 376         case 0x52: windows_version = WINDOWS_2003;  w = "2003"; break;
 377         case 0x60: windows_version = WINDOWS_VISTA; w = (ws ? "Vista" : "2008");  break;
 378         case 0x61: windows_version = WINDOWS_7;     w = (ws ? "7" : "2008_R2");   break;
 379         case 0x62: windows_version = WINDOWS_8;     w = (ws ? "8" : "2012");      break;
 380         case 0x63: windows_version = WINDOWS_8_1;   w = (ws ? "8.1" : "2012_R2"); break;
 381         case 0x64: // Early Windows 10 Insider Previews and Windows Server 2017 Technical Preview 1 used version 6.4
 382         case 0xA0: windows_version = WINDOWS_10;    w = (ws ? "10" : "2016");     break;
 383         default:
 384                 if (version < 0x50) {
 385                         return;
 386                 } else {
 387                         windows_version = WINDOWS_11_OR_LATER;
 388                         w = "11 or later";
 389                 }
 390         }
 391
 392         arch = is_x64() ? "64-bit" : "32-bit";
 393
 394         if (vi.wServicePackMinor)
 395                 usbi_dbg("Windows %s SP%u.%u %s", w, vi.wServicePackMajor, vi.wServicePackMinor, arch);
 396         else if (vi.wServicePackMajor)
 397                 usbi_dbg("Windows %s SP%u %s", w, vi.wServicePackMajor, arch);
 398         else
 399                 usbi_dbg("Windows %s %s", w, arch);
 400 }
 401
 402 static void windows_transfer_callback(const struct windows_backend *backend,
 403         struct usbi_transfer *itransfer, DWORD error, DWORD bytes_transferred)
 404 {
 405         struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
 406         enum libusb_transfer_status status, istatus;
 407
 408         usbi_dbg("handling I/O completion with errcode %lu, length %lu",
 409                 ULONG_CAST(error), ULONG_CAST(bytes_transferred));
 410
 411         switch (error) {
 412         case NO_ERROR:
 413                 status = backend->copy_transfer_data(itransfer, bytes_transferred);
 414                 break;
 415         case ERROR_GEN_FAILURE:
 416                 usbi_dbg("detected endpoint stall");
 417                 status = LIBUSB_TRANSFER_STALL;
 418                 break;
 419         case ERROR_SEM_TIMEOUT:
 420                 usbi_dbg("detected semaphore timeout");
 421                 status = LIBUSB_TRANSFER_TIMED_OUT;
 422                 break;
 423         case ERROR_OPERATION_ABORTED:
 424                 istatus = backend->copy_transfer_data(itransfer, bytes_transferred);
 425                 if (istatus != LIBUSB_TRANSFER_COMPLETED)
 426                         usbi_dbg("failed to copy partial data in aborted operation: %d", (int)istatus);
 427
 428                 usbi_dbg("detected operation aborted");
 429                 status = LIBUSB_TRANSFER_CANCELLED;
 430                 break;
 431         case ERROR_FILE_NOT_FOUND:
 432         case ERROR_DEVICE_NOT_CONNECTED:
 433         case ERROR_NO_SUCH_DEVICE:
 434                 usbi_dbg("detected device removed");
 435                 status = LIBUSB_TRANSFER_NO_DEVICE;
 436                 break;
 437         default:
 438                 usbi_err(ITRANSFER_CTX(itransfer), "detected I/O error %lu: %s",
 439                         ULONG_CAST(error), windows_error_str(error));
 440                 status = LIBUSB_TRANSFER_ERROR;
 441                 break;
 442         }
 443
 444         // Cancel polling
 445         usbi_close(transfer_priv->pollable_fd.fd);
 446         transfer_priv->pollable_fd = INVALID_WINFD;
 447         transfer_priv->handle = NULL;
 448
 449         // Backend-specific cleanup
 450         backend->clear_transfer_priv(itransfer);
 451
 452         if (status == LIBUSB_TRANSFER_CANCELLED)
 453                 usbi_handle_transfer_cancellation(itransfer);
 454         else
 455                 usbi_handle_transfer_completion(itransfer, status);
 456 }
 457
 458 static int windows_init(struct libusb_context *ctx)
 459 {
 460         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 461         char mutex_name[11 + 8 + 1]; // strlen("libusb_init") + (32-bit hex PID) + '\0'
 462         HANDLE mutex;
 463         int r = LIBUSB_ERROR_OTHER;
 464         bool winusb_backend_init = false;
 465
 466         sprintf(mutex_name, "libusb_init%08lX", ULONG_CAST(GetCurrentProcessId() & 0xFFFFFFFFU));
 467         mutex = CreateMutexA(NULL, FALSE, mutex_name);
 468         if (mutex == NULL) {
 469                 usbi_err(ctx, "could not create mutex: %s", windows_error_str(0));
 470                 return LIBUSB_ERROR_NO_MEM;
 471         }
 472
 473         // A successful wait gives this thread ownership of the mutex
 474         // => any concurent wait stalls until the mutex is released
 475         if (WaitForSingleObject(mutex, INFINITE) != WAIT_OBJECT_0) {
 476                 usbi_err(ctx, "failure to access mutex: %s", windows_error_str(0));
 477                 CloseHandle(mutex);
 478                 return LIBUSB_ERROR_NO_MEM;
 479         }
 480
 481         // NB: concurrent usage supposes that init calls are equally balanced with
 482         // exit calls. If init is called more than exit, we will not exit properly
 483         if (++init_count == 1) { // First init?
 484                 get_windows_version();
 485
 486                 if (windows_version == WINDOWS_UNDEFINED) {
 487                         usbi_err(ctx, "failed to detect Windows version");
 488                         r = LIBUSB_ERROR_NOT_SUPPORTED;
 489                         goto init_exit;
 490                 }
 491
 492                 windows_init_clock();
 493
 494                 if (!htab_create(ctx))
 495                         goto init_exit;
 496
 497                 r = winusb_backend.init(ctx);
 498                 if (r != LIBUSB_SUCCESS)
 499                         goto init_exit;
 500                 winusb_backend_init = true;
 501
 502                 r = usbdk_backend.init(ctx);
 503                 if (r == LIBUSB_SUCCESS) {
 504                         usbi_dbg("UsbDk backend is available");
 505                         usbdk_available = true;
 506                 } else {
 507                         usbi_info(ctx, "UsbDk backend is not available");
 508                         // Do not report this as an error
 509                         r = LIBUSB_SUCCESS;
 510                 }
 511         }
 512
 513         // By default, new contexts will use the WinUSB backend
 514         priv->backend = &winusb_backend;
 515
 516         r = LIBUSB_SUCCESS;
 517
 518 init_exit: // Holds semaphore here
 519         if ((init_count == 1) && (r != LIBUSB_SUCCESS)) { // First init failed?
 520                 if (winusb_backend_init)
 521                         winusb_backend.exit(ctx);
 522                 htab_destroy();
 523                 --init_count;
 524         }
 525
 526         ReleaseMutex(mutex);
 527         CloseHandle(mutex);
 528         return r;
 529 }
 530
 531 static void windows_exit(struct libusb_context *ctx)
 532 {
 533         char mutex_name[11 + 8 + 1]; // strlen("libusb_init") + (32-bit hex PID) + '\0'
 534         HANDLE mutex;
 535
 536         sprintf(mutex_name, "libusb_init%08lX", ULONG_CAST(GetCurrentProcessId() & 0xFFFFFFFFU));
 537         mutex = CreateMutexA(NULL, FALSE, mutex_name);
 538         if (mutex == NULL)
 539                 return;
 540
 541         // A successful wait gives this thread ownership of the mutex
 542         // => any concurent wait stalls until the mutex is released
 543         if (WaitForSingleObject(mutex, INFINITE) != WAIT_OBJECT_0) {
 544                 usbi_err(ctx, "failed to access mutex: %s", windows_error_str(0));
 545                 CloseHandle(mutex);
 546                 return;
 547         }
 548
 549         // Only works if exits and inits are balanced exactly
 550         if (--init_count == 0) { // Last exit
 551                 if (usbdk_available) {
 552                         usbdk_backend.exit(ctx);
 553                         usbdk_available = false;
 554                 }
 555                 winusb_backend.exit(ctx);
 556                 htab_destroy();
 557         }
 558
 559         ReleaseMutex(mutex);
 560         CloseHandle(mutex);
 561 }
 562
 563 static int windows_set_option(struct libusb_context *ctx, enum libusb_option option, va_list ap)
 564 {
 565         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 566
 567         UNUSED(ap);
 568
 569         switch ((int)option) {
 570         case LIBUSB_OPTION_USE_USBDK:
 571                 if (usbdk_available) {
 572                         usbi_dbg("switching context %p to use UsbDk backend", ctx);
 573                         priv->backend = &usbdk_backend;
 574                 } else {
 575                         usbi_err(ctx, "UsbDk backend not available");
 576                         return LIBUSB_ERROR_NOT_FOUND;
 577                 }
 578                 return LIBUSB_SUCCESS;
 579         default:
 580                 return LIBUSB_ERROR_NOT_SUPPORTED;
 581         }
 582 }
 583
 584 static int windows_get_device_list(struct libusb_context *ctx, struct discovered_devs **discdevs)
 585 {
 586         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 587         return priv->backend->get_device_list(ctx, discdevs);
 588 }
 589
 590 static int windows_open(struct libusb_device_handle *dev_handle)
 591 {
 592         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 593         return priv->backend->open(dev_handle);
 594 }
 595
 596 static void windows_close(struct libusb_device_handle *dev_handle)
 597 {
 598         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 599         priv->backend->close(dev_handle);
 600 }
 601
 602 static int windows_get_active_config_descriptor(struct libusb_device *dev,
 603         void *buffer, size_t len)
 604 {
 605         struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
 606         return priv->backend->get_active_config_descriptor(dev, buffer, len);
 607 }
 608
 609 static int windows_get_config_descriptor(struct libusb_device *dev,
 610         uint8_t config_index, void *buffer, size_t len)
 611 {
 612         struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
 613         return priv->backend->get_config_descriptor(dev, config_index, buffer, len);
 614 }
 615
 616 static int windows_get_config_descriptor_by_value(struct libusb_device *dev,
 617         uint8_t bConfigurationValue, void **buffer)
 618 {
 619         struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
 620         return priv->backend->get_config_descriptor_by_value(dev, bConfigurationValue, buffer);
 621 }
 622
 623 static int windows_get_configuration(struct libusb_device_handle *dev_handle, uint8_t *config)
 624 {
 625         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 626         return priv->backend->get_configuration(dev_handle, config);
 627 }
 628
 629 static int windows_set_configuration(struct libusb_device_handle *dev_handle, int config)
 630 {
 631         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 632         if (config == -1)
 633                 config = 0;
 634         return priv->backend->set_configuration(dev_handle, (uint8_t)config);
 635 }
 636
 637 static int windows_claim_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
 638 {
 639         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 640         return priv->backend->claim_interface(dev_handle, interface_number);
 641 }
 642
 643 static int windows_release_interface(struct libusb_device_handle *dev_handle, uint8_t interface_number)
 644 {
 645         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 646         return priv->backend->release_interface(dev_handle, interface_number);
 647 }
 648
 649 static int windows_set_interface_altsetting(struct libusb_device_handle *dev_handle,
 650         uint8_t interface_number, uint8_t altsetting)
 651 {
 652         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 653         return priv->backend->set_interface_altsetting(dev_handle, interface_number, altsetting);
 654 }
 655
 656 static int windows_clear_halt(struct libusb_device_handle *dev_handle, unsigned char endpoint)
 657 {
 658         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 659         return priv->backend->clear_halt(dev_handle, endpoint);
 660 }
 661
 662 static int windows_reset_device(struct libusb_device_handle *dev_handle)
 663 {
 664         struct windows_context_priv *priv = usbi_get_context_priv(HANDLE_CTX(dev_handle));
 665         return priv->backend->reset_device(dev_handle);
 666 }
 667
 668 static void windows_destroy_device(struct libusb_device *dev)
 669 {
 670         struct windows_context_priv *priv = usbi_get_context_priv(DEVICE_CTX(dev));
 671         priv->backend->destroy_device(dev);
 672 }
 673
 674 static int windows_submit_transfer(struct usbi_transfer *itransfer)
 675 {
 676         struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
 677         struct libusb_context *ctx = TRANSFER_CTX(transfer);
 678         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 679         struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
 680         short events;
 681         int r;
 682
 683         switch (transfer->type) {
 684         case LIBUSB_TRANSFER_TYPE_CONTROL:
 685                 events = (transfer->buffer[0] & LIBUSB_ENDPOINT_IN) ? POLLIN : POLLOUT;
 686                 break;
 687         case LIBUSB_TRANSFER_TYPE_BULK:
 688         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
 689         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 690                 events = IS_XFERIN(transfer) ? POLLIN : POLLOUT;
 691                 break;
 692         case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
 693                 usbi_warn(ctx, "bulk stream transfers are not yet supported on this platform");
 694                 return LIBUSB_ERROR_NOT_SUPPORTED;
 695         default:
 696                 usbi_err(ctx, "unknown endpoint type %d", transfer->type);
 697                 return LIBUSB_ERROR_INVALID_PARAM;
 698         }
 699
 700         // Because a Windows OVERLAPPED is used for poll emulation,
 701         // a pollable fd is created and stored with each transfer
 702         transfer_priv->pollable_fd = usbi_create_fd();
 703         if (transfer_priv->pollable_fd.fd < 0) {
 704                 usbi_err(ctx, "failed to create pollable fd");
 705                 return LIBUSB_ERROR_NO_MEM;
 706         }
 707
 708         if (transfer_priv->handle != NULL) {
 709                 usbi_err(ctx, "program assertion failed - transfer HANDLE is not NULL");
 710                 transfer_priv->handle = NULL;
 711         }
 712
 713         r = priv->backend->submit_transfer(itransfer);
 714         if (r != LIBUSB_SUCCESS) {
 715                 // Always call the backend's clear_transfer_priv() function on failure
 716                 priv->backend->clear_transfer_priv(itransfer);
 717                 // Release the pollable fd since it won't be used
 718                 usbi_close(transfer_priv->pollable_fd.fd);
 719                 transfer_priv->pollable_fd = INVALID_WINFD;
 720                 transfer_priv->handle = NULL;
 721                 return r;
 722         }
 723
 724         // The backend should set the HANDLE used for each submitted transfer
 725         // by calling set_transfer_priv_handle()
 726         if (transfer_priv->handle == NULL)
 727                 usbi_err(ctx, "program assertion failed - transfer HANDLE is NULL after transfer was submitted");
 728
 729         // We don't want to start monitoring the pollable fd before the transfer
 730         // has been submitted, so start monitoring it now.  Note that if the
 731         // usbi_add_pollfd() function fails, the user will never get notified
 732         // that the transfer has completed.  We don't attempt any cleanup if this
 733         // happens because the transfer is already in progress and could even have
 734         // completed
 735         if (usbi_add_pollfd(ctx, transfer_priv->pollable_fd.fd, events))
 736                 usbi_err(ctx, "failed to add pollable fd %d for transfer %p",
 737                         transfer_priv->pollable_fd.fd, transfer);
 738
 739         return r;
 740 }
 741
 742 static int windows_cancel_transfer(struct usbi_transfer *itransfer)
 743 {
 744         struct windows_context_priv *priv = usbi_get_context_priv(ITRANSFER_CTX(itransfer));
 745         struct windows_transfer_priv *transfer_priv = usbi_get_transfer_priv(itransfer);
 746
 747         // Try CancelIoEx() on the transfer
 748         // If that fails, fall back to the backend's cancel_transfer()
 749         // function if it is available
 750         if (CancelIoEx(transfer_priv->handle, transfer_priv->pollable_fd.overlapped))
 751                 return LIBUSB_SUCCESS;
 752         else if (GetLastError() == ERROR_NOT_FOUND)
 753                 return LIBUSB_ERROR_NOT_FOUND;
 754
 755         if (priv->backend->cancel_transfer)
 756                 return priv->backend->cancel_transfer(itransfer);
 757
 758         usbi_warn(ITRANSFER_CTX(itransfer), "cancellation not supported for this transfer's driver");
 759         return LIBUSB_ERROR_NOT_SUPPORTED;
 760 }
 761
 762 static int windows_handle_events(struct libusb_context *ctx, struct pollfd *fds, usbi_nfds_t nfds, int num_ready)
 763 {
 764         struct windows_context_priv *priv = usbi_get_context_priv(ctx);
 765         struct usbi_transfer *itransfer;
 766         struct windows_transfer_priv *transfer_priv;
 767         DWORD result, bytes_transferred;
 768         usbi_nfds_t i;
 769         int r = LIBUSB_SUCCESS;
 770
 771         usbi_mutex_lock(&ctx->open_devs_lock);
 772         for (i = 0; i < nfds && num_ready > 0; i++) {
 773                 usbi_dbg("checking fd %d with revents = %04x", fds[i].fd, fds[i].revents);
 774
 775                 if (!fds[i].revents)
 776                         continue;
 777
 778                 num_ready--;
 779
 780                 transfer_priv = NULL;
 781                 usbi_mutex_lock(&ctx->flying_transfers_lock);
 782                 for_each_transfer(ctx, itransfer) {
 783                         transfer_priv = usbi_get_transfer_priv(itransfer);
 784                         if (transfer_priv->pollable_fd.fd == fds[i].fd)
 785                                 break;
 786                         transfer_priv = NULL;
 787                 }
 788                 usbi_mutex_unlock(&ctx->flying_transfers_lock);
 789
 790                 if (transfer_priv == NULL) {
 791                         usbi_err(ctx, "could not find a matching transfer for fd %d", fds[i].fd);
 792                         r = LIBUSB_ERROR_NOT_FOUND;
 793                         break;
 794                 }
 795
 796                 usbi_remove_pollfd(ctx, transfer_priv->pollable_fd.fd);
 797
 798                 if (GetOverlappedResult(transfer_priv->handle, transfer_priv->pollable_fd.overlapped, &bytes_transferred, FALSE))
 799                         result = NO_ERROR;
 800                 else
 801                         result = GetLastError();
 802
 803                 windows_transfer_callback(priv->backend, itransfer, result, bytes_transferred);
 804         }
 805         usbi_mutex_unlock(&ctx->open_devs_lock);
 806
 807         return r;
 808 }
 809
 810 #if !defined(HAVE_CLOCK_GETTIME)
 811 int usbi_clock_gettime(int clk_id, struct timespec *tp)
 812 {
 813         LARGE_INTEGER hires_counter;
 814 #if !defined(_MSC_VER) || (_MSC_VER < 1900)
 815         FILETIME filetime;
 816         ULARGE_INTEGER rtime;
 817 #endif
 818
 819         switch (clk_id) {
 820         case USBI_CLOCK_MONOTONIC:
 821                 if (hires_frequency) {
 822                         QueryPerformanceCounter(&hires_counter);
 823                         tp->tv_sec = (long)(hires_counter.QuadPart / hires_frequency);
 824                         tp->tv_nsec = (long)(((hires_counter.QuadPart % hires_frequency) * hires_ticks_to_ps) / UINT64_C(1000));
 825                         return 0;
 826                 }
 827                 // Return real-time if monotonic was not detected @ timer init
 828                 // Fall through
 829         case USBI_CLOCK_REALTIME:
 830 #if defined(_MSC_VER) && (_MSC_VER >= 1900)
 831                 if (!timespec_get(tp, TIME_UTC)) {
 832                         errno = EIO;
 833                         return -1;
 834                 }
 835 #else
 836                 // We follow http://msdn.microsoft.com/en-us/library/ms724928%28VS.85%29.aspx
 837                 // with a predef epoch time to have an epoch that starts at 1970.01.01 00:00
 838                 // Note however that our resolution is bounded by the Windows system time
 839                 // functions and is at best of the order of 1 ms (or, usually, worse)
 840                 GetSystemTimeAsFileTime(&filetime);
 841                 rtime.LowPart = filetime.dwLowDateTime;
 842                 rtime.HighPart = filetime.dwHighDateTime;
 843                 rtime.QuadPart -= EPOCH_TIME;
 844                 tp->tv_sec = (long)(rtime.QuadPart / 10000000);
 845                 tp->tv_nsec = (long)((rtime.QuadPart % 10000000) * 100);
 846 #endif
 847                 return 0;
 848         default:
 849                 errno = EINVAL;
 850                 return -1;
 851         }
 852 }
 853 #endif
 854
 855 // NB: MSVC6 does not support named initializers.
 856 const struct usbi_os_backend usbi_backend = {
 857         "Windows",
 858         USBI_CAP_HAS_HID_ACCESS,
 859         windows_init,
 860         windows_exit,
 861         windows_set_option,
 862         windows_get_device_list,
 863         NULL,   /* hotplug_poll */
 864         NULL,   /* wrap_sys_device */
 865         windows_open,
 866         windows_close,
 867         windows_get_active_config_descriptor,
 868         windows_get_config_descriptor,
 869         windows_get_config_descriptor_by_value,
 870         windows_get_configuration,
 871         windows_set_configuration,
 872         windows_claim_interface,
 873         windows_release_interface,
 874         windows_set_interface_altsetting,
 875         windows_clear_halt,
 876         windows_reset_device,
 877         NULL,   /* alloc_streams */
 878         NULL,   /* free_streams */
 879         NULL,   /* dev_mem_alloc */
 880         NULL,   /* dev_mem_free */
 881         NULL,   /* kernel_driver_active */
 882         NULL,   /* detach_kernel_driver */
 883         NULL,   /* attach_kernel_driver */
 884         windows_destroy_device,
 885         windows_submit_transfer,
 886         windows_cancel_transfer,
 887         NULL,   /* clear_transfer_priv */
 888         windows_handle_events,
 889         NULL,   /* handle_transfer_completion */
 890         sizeof(struct windows_context_priv),
 891         sizeof(union windows_device_priv),
 892         sizeof(union windows_device_handle_priv),
 893         sizeof(struct windows_transfer_priv),
 894 };