dlls/user32/rawinput.c

   1 /*
   2  * Raw Input
   3  *
   4  * Copyright 2012 Henri Verbeet
   5  * Copyright 2018 Zebediah Figura for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winnls.h"
  30 #include "winreg.h"
  31 #include "winuser.h"
  32 #include "setupapi.h"
  33 #include "ddk/hidsdi.h"
  34 #include "wine/debug.h"
  35 #include "wine/server.h"
  36 #include "wine/hid.h"
  37
  38 #include "user_private.h"
  39
  40 #include "initguid.h"
  41 #include "devpkey.h"
  42 #include "ntddmou.h"
  43 #include "ntddkbd.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(rawinput);
  46
  47 DEFINE_DEVPROPKEY(DEVPROPKEY_HID_HANDLE, 0xbc62e415, 0xf4fe, 0x405c, 0x8e, 0xda, 0x63, 0x6f, 0xb5, 0x9f, 0x08, 0x98, 2);
  48
  49 struct device
  50 {
  51     SP_DEVICE_INTERFACE_DETAIL_DATA_W *detail;
  52     HANDLE file;
  53     HANDLE handle;
  54     RID_DEVICE_INFO info;
  55     PHIDP_PREPARSED_DATA data;
  56 };
  57
  58 static struct device *rawinput_devices;
  59 static unsigned int rawinput_devices_count, rawinput_devices_max;
  60
  61 static CRITICAL_SECTION rawinput_devices_cs;
  62 static CRITICAL_SECTION_DEBUG rawinput_devices_cs_debug =
  63 {
  64     0, 0, &rawinput_devices_cs,
  65     { &rawinput_devices_cs_debug.ProcessLocksList, &rawinput_devices_cs_debug.ProcessLocksList },
  66       0, 0, { (DWORD_PTR)(__FILE__ ": rawinput_devices_cs") }
  67 };
  68 static CRITICAL_SECTION rawinput_devices_cs = { &rawinput_devices_cs_debug, -1, 0, 0, 0, 0 };
  69
  70 static BOOL array_reserve(void **elements, unsigned int *capacity, unsigned int count, unsigned int size)
  71 {
  72     unsigned int new_capacity, max_capacity;
  73     void *new_elements;
  74
  75     if (count <= *capacity)
  76         return TRUE;
  77
  78     max_capacity = ~(SIZE_T)0 / size;
  79     if (count > max_capacity)
  80         return FALSE;
  81
  82     new_capacity = max(4, *capacity);
  83     while (new_capacity < count && new_capacity <= max_capacity / 2)
  84         new_capacity *= 2;
  85     if (new_capacity < count)
  86         new_capacity = max_capacity;
  87
  88     if (!(new_elements = realloc(*elements, new_capacity * size)))
  89         return FALSE;
  90
  91     *elements = new_elements;
  92     *capacity = new_capacity;
  93
  94     return TRUE;
  95 }
  96
  97 static struct device *add_device(HDEVINFO set, SP_DEVICE_INTERFACE_DATA *iface)
  98 {
  99     SP_DEVINFO_DATA device_data = {sizeof(device_data)};
 100     SP_DEVICE_INTERFACE_DETAIL_DATA_W *detail;
 101     struct device *device = NULL;
 102     UINT32 handle;
 103     HANDLE file;
 104     WCHAR *pos;
 105     DWORD i, size, type;
 106
 107     SetupDiGetDeviceInterfaceDetailW(set, iface, NULL, 0, &size, &device_data);
 108     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 109     {
 110         ERR("Failed to get device path, error %#x.\n", GetLastError());
 111         return FALSE;
 112     }
 113
 114     if (!SetupDiGetDevicePropertyW(set, &device_data, &DEVPROPKEY_HID_HANDLE, &type, (BYTE *)&handle, sizeof(handle), NULL, 0) ||
 115         type != DEVPROP_TYPE_UINT32)
 116     {
 117         ERR("Failed to get device handle, error %#x.\n", GetLastError());
 118         return NULL;
 119     }
 120
 121     if (!(detail = malloc(size)))
 122     {
 123         ERR("Failed to allocate memory.\n");
 124         return FALSE;
 125     }
 126     detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
 127     SetupDiGetDeviceInterfaceDetailW(set, iface, detail, size, NULL, NULL);
 128
 129     /* upper case everything but the GUID */
 130     for (pos = detail->DevicePath; *pos && *pos != '{'; pos++) *pos = towupper(*pos);
 131
 132     file = CreateFileW(detail->DevicePath, GENERIC_READ | GENERIC_WRITE,
 133             FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
 134     if (file == INVALID_HANDLE_VALUE)
 135     {
 136         ERR("Failed to open device file %s, error %u.\n", debugstr_w(detail->DevicePath), GetLastError());
 137         free(detail);
 138         return NULL;
 139     }
 140
 141     for (i = 0; i < rawinput_devices_count && !device; ++i)
 142         if (rawinput_devices[i].handle == UlongToHandle(handle))
 143             device = rawinput_devices + i;
 144
 145     if (device)
 146     {
 147         TRACE("Updating device %x / %s.\n", handle, debugstr_w(detail->DevicePath));
 148         HidD_FreePreparsedData(device->data);
 149         CloseHandle(device->file);
 150         free(device->detail);
 151     }
 152     else if (array_reserve((void **)&rawinput_devices, &rawinput_devices_max,
 153                            rawinput_devices_count + 1, sizeof(*rawinput_devices)))
 154     {
 155         device = &rawinput_devices[rawinput_devices_count++];
 156         TRACE("Adding device %x / %s.\n", handle, debugstr_w(detail->DevicePath));
 157     }
 158     else
 159     {
 160         ERR("Failed to allocate memory.\n");
 161         CloseHandle(file);
 162         free(detail);
 163         return NULL;
 164     }
 165
 166     device->detail = detail;
 167     device->file = file;
 168     device->handle = ULongToHandle(handle);
 169     device->info.cbSize = sizeof(RID_DEVICE_INFO);
 170     device->data = NULL;
 171
 172     return device;
 173 }
 174
 175 void rawinput_update_device_list(void)
 176 {
 177     SP_DEVICE_INTERFACE_DATA iface = { sizeof(iface) };
 178     struct device *device;
 179     HIDD_ATTRIBUTES attr;
 180     HIDP_CAPS caps;
 181     GUID hid_guid;
 182     HDEVINFO set;
 183     DWORD idx;
 184
 185     TRACE("\n");
 186
 187     HidD_GetHidGuid(&hid_guid);
 188
 189     EnterCriticalSection(&rawinput_devices_cs);
 190
 191     /* destroy previous list */
 192     for (idx = 0; idx < rawinput_devices_count; ++idx)
 193     {
 194         HidD_FreePreparsedData(rawinput_devices[idx].data);
 195         CloseHandle(rawinput_devices[idx].file);
 196         free(rawinput_devices[idx].detail);
 197     }
 198     rawinput_devices_count = 0;
 199
 200     set = SetupDiGetClassDevsW(&hid_guid, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
 201
 202     for (idx = 0; SetupDiEnumDeviceInterfaces(set, NULL, &hid_guid, idx, &iface); ++idx)
 203     {
 204         if (!(device = add_device(set, &iface)))
 205             continue;
 206
 207         attr.Size = sizeof(HIDD_ATTRIBUTES);
 208         if (!HidD_GetAttributes(device->file, &attr))
 209             WARN("Failed to get attributes.\n");
 210
 211         device->info.dwType = RIM_TYPEHID;
 212         device->info.hid.dwVendorId = attr.VendorID;
 213         device->info.hid.dwProductId = attr.ProductID;
 214         device->info.hid.dwVersionNumber = attr.VersionNumber;
 215
 216         if (!HidD_GetPreparsedData(device->file, &device->data))
 217             WARN("Failed to get preparsed data.\n");
 218
 219         if (!HidP_GetCaps(device->data, &caps))
 220             WARN("Failed to get caps.\n");
 221
 222         device->info.hid.usUsagePage = caps.UsagePage;
 223         device->info.hid.usUsage = caps.Usage;
 224     }
 225
 226     SetupDiDestroyDeviceInfoList(set);
 227
 228     set = SetupDiGetClassDevsW(&GUID_DEVINTERFACE_MOUSE, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
 229
 230     for (idx = 0; SetupDiEnumDeviceInterfaces(set, NULL, &GUID_DEVINTERFACE_MOUSE, idx, &iface); ++idx)
 231     {
 232         static const RID_DEVICE_INFO_MOUSE mouse_info = {1, 5, 0, FALSE};
 233
 234         if (!(device = add_device(set, &iface)))
 235             continue;
 236
 237         device->info.dwType = RIM_TYPEMOUSE;
 238         device->info.mouse = mouse_info;
 239     }
 240
 241     SetupDiDestroyDeviceInfoList(set);
 242
 243     set = SetupDiGetClassDevsW(&GUID_DEVINTERFACE_KEYBOARD, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
 244
 245     for (idx = 0; SetupDiEnumDeviceInterfaces(set, NULL, &GUID_DEVINTERFACE_KEYBOARD, idx, &iface); ++idx)
 246     {
 247         static const RID_DEVICE_INFO_KEYBOARD keyboard_info = {0, 0, 1, 12, 3, 101};
 248
 249         if (!(device = add_device(set, &iface)))
 250             continue;
 251
 252         device->info.dwType = RIM_TYPEKEYBOARD;
 253         device->info.keyboard = keyboard_info;
 254     }
 255
 256     SetupDiDestroyDeviceInfoList(set);
 257
 258     LeaveCriticalSection(&rawinput_devices_cs);
 259 }
 260
 261
 262 static struct device *find_device_from_handle(HANDLE handle)
 263 {
 264     UINT i;
 265     for (i = 0; i < rawinput_devices_count; ++i)
 266         if (rawinput_devices[i].handle == handle)
 267             return rawinput_devices + i;
 268     rawinput_update_device_list();
 269     for (i = 0; i < rawinput_devices_count; ++i)
 270         if (rawinput_devices[i].handle == handle)
 271             return rawinput_devices + i;
 272     return NULL;
 273 }
 274
 275
 276 BOOL rawinput_device_get_usages(HANDLE handle, USAGE *usage_page, USAGE *usage)
 277 {
 278     struct device *device;
 279
 280     *usage_page = *usage = 0;
 281
 282     if (!(device = find_device_from_handle(handle))) return FALSE;
 283     if (device->info.dwType != RIM_TYPEHID) return FALSE;
 284
 285     *usage_page = device->info.hid.usUsagePage;
 286     *usage = device->info.hid.usUsage;
 287     return TRUE;
 288 }
 289
 290
 291 struct rawinput_thread_data *rawinput_thread_data(void)
 292 {
 293     struct user_thread_info *thread_info = get_user_thread_info();
 294     struct rawinput_thread_data *data = thread_info->rawinput;
 295     if (data) return data;
 296     data = thread_info->rawinput = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 297                                               RAWINPUT_BUFFER_SIZE + sizeof(struct user_thread_info) );
 298     return data;
 299 }
 300
 301
 302 BOOL rawinput_from_hardware_message(RAWINPUT *rawinput, const struct hardware_msg_data *msg_data)
 303 {
 304     SIZE_T size;
 305
 306     rawinput->header.dwType = msg_data->rawinput.type;
 307     if (msg_data->rawinput.type == RIM_TYPEMOUSE)
 308     {
 309         static const unsigned int button_flags[] =
 310         {
 311             0,                              /* MOUSEEVENTF_MOVE */
 312             RI_MOUSE_LEFT_BUTTON_DOWN,      /* MOUSEEVENTF_LEFTDOWN */
 313             RI_MOUSE_LEFT_BUTTON_UP,        /* MOUSEEVENTF_LEFTUP */
 314             RI_MOUSE_RIGHT_BUTTON_DOWN,     /* MOUSEEVENTF_RIGHTDOWN */
 315             RI_MOUSE_RIGHT_BUTTON_UP,       /* MOUSEEVENTF_RIGHTUP */
 316             RI_MOUSE_MIDDLE_BUTTON_DOWN,    /* MOUSEEVENTF_MIDDLEDOWN */
 317             RI_MOUSE_MIDDLE_BUTTON_UP,      /* MOUSEEVENTF_MIDDLEUP */
 318         };
 319         unsigned int i;
 320
 321         rawinput->header.dwSize  = FIELD_OFFSET(RAWINPUT, data) + sizeof(RAWMOUSE);
 322         rawinput->header.hDevice = WINE_MOUSE_HANDLE;
 323         rawinput->header.wParam  = 0;
 324
 325         rawinput->data.mouse.usFlags           = MOUSE_MOVE_RELATIVE;
 326         rawinput->data.mouse.usButtonFlags = 0;
 327         rawinput->data.mouse.usButtonData  = 0;
 328         for (i = 1; i < ARRAY_SIZE(button_flags); ++i)
 329         {
 330             if (msg_data->flags & (1 << i))
 331                 rawinput->data.mouse.usButtonFlags |= button_flags[i];
 332         }
 333         if (msg_data->flags & MOUSEEVENTF_WHEEL)
 334         {
 335             rawinput->data.mouse.usButtonFlags |= RI_MOUSE_WHEEL;
 336             rawinput->data.mouse.usButtonData   = msg_data->rawinput.mouse.data;
 337         }
 338         if (msg_data->flags & MOUSEEVENTF_HWHEEL)
 339         {
 340             rawinput->data.mouse.usButtonFlags |= RI_MOUSE_HORIZONTAL_WHEEL;
 341             rawinput->data.mouse.usButtonData   = msg_data->rawinput.mouse.data;
 342         }
 343         if (msg_data->flags & MOUSEEVENTF_XDOWN)
 344         {
 345             if (msg_data->rawinput.mouse.data == XBUTTON1)
 346                 rawinput->data.mouse.usButtonFlags |= RI_MOUSE_BUTTON_4_DOWN;
 347             else if (msg_data->rawinput.mouse.data == XBUTTON2)
 348                 rawinput->data.mouse.usButtonFlags |= RI_MOUSE_BUTTON_5_DOWN;
 349         }
 350         if (msg_data->flags & MOUSEEVENTF_XUP)
 351         {
 352             if (msg_data->rawinput.mouse.data == XBUTTON1)
 353                 rawinput->data.mouse.usButtonFlags |= RI_MOUSE_BUTTON_4_UP;
 354             else if (msg_data->rawinput.mouse.data == XBUTTON2)
 355                 rawinput->data.mouse.usButtonFlags |= RI_MOUSE_BUTTON_5_UP;
 356         }
 357
 358         rawinput->data.mouse.ulRawButtons       = 0;
 359         rawinput->data.mouse.lLastX             = msg_data->rawinput.mouse.x;
 360         rawinput->data.mouse.lLastY             = msg_data->rawinput.mouse.y;
 361         rawinput->data.mouse.ulExtraInformation = msg_data->info;
 362     }
 363     else if (msg_data->rawinput.type == RIM_TYPEKEYBOARD)
 364     {
 365         rawinput->header.dwSize  = FIELD_OFFSET(RAWINPUT, data) + sizeof(RAWKEYBOARD);
 366         rawinput->header.hDevice = WINE_KEYBOARD_HANDLE;
 367         rawinput->header.wParam  = 0;
 368
 369         rawinput->data.keyboard.MakeCode = msg_data->rawinput.kbd.scan;
 370         rawinput->data.keyboard.Flags    = msg_data->flags & KEYEVENTF_KEYUP ? RI_KEY_BREAK : RI_KEY_MAKE;
 371         if (msg_data->flags & KEYEVENTF_EXTENDEDKEY) rawinput->data.keyboard.Flags |= RI_KEY_E0;
 372         rawinput->data.keyboard.Reserved = 0;
 373
 374         switch (msg_data->rawinput.kbd.vkey)
 375         {
 376         case VK_LSHIFT:
 377         case VK_RSHIFT:
 378             rawinput->data.keyboard.VKey   = VK_SHIFT;
 379             rawinput->data.keyboard.Flags &= ~RI_KEY_E0;
 380             break;
 381         case VK_LCONTROL:
 382         case VK_RCONTROL:
 383             rawinput->data.keyboard.VKey = VK_CONTROL;
 384             break;
 385         case VK_LMENU:
 386         case VK_RMENU:
 387             rawinput->data.keyboard.VKey = VK_MENU;
 388             break;
 389         default:
 390             rawinput->data.keyboard.VKey = msg_data->rawinput.kbd.vkey;
 391             break;
 392         }
 393
 394         rawinput->data.keyboard.Message          = msg_data->rawinput.kbd.message;
 395         rawinput->data.keyboard.ExtraInformation = msg_data->info;
 396     }
 397     else if (msg_data->rawinput.type == RIM_TYPEHID)
 398     {
 399         size = msg_data->size - sizeof(*msg_data);
 400         if (size > rawinput->header.dwSize - sizeof(*rawinput)) return FALSE;
 401
 402         rawinput->header.dwSize  = FIELD_OFFSET( RAWINPUT, data.hid.bRawData ) + size;
 403         rawinput->header.hDevice = ULongToHandle( msg_data->rawinput.hid.device );
 404         rawinput->header.wParam  = 0;
 405
 406         rawinput->data.hid.dwCount = msg_data->rawinput.hid.count;
 407         rawinput->data.hid.dwSizeHid = msg_data->rawinput.hid.length;
 408         memcpy( rawinput->data.hid.bRawData, msg_data + 1, size );
 409     }
 410     else
 411     {
 412         FIXME("Unhandled rawinput type %#x.\n", msg_data->rawinput.type);
 413         return FALSE;
 414     }
 415
 416     return TRUE;
 417 }
 418
 419
 420 /***********************************************************************
 421  *              GetRawInputDeviceList   (USER32.@)
 422  */
 423 UINT WINAPI GetRawInputDeviceList(RAWINPUTDEVICELIST *devices, UINT *device_count, UINT size)
 424 {
 425     static UINT last_check;
 426     UINT i, ticks = GetTickCount();
 427
 428     TRACE("devices %p, device_count %p, size %u.\n", devices, device_count, size);
 429
 430     if (size != sizeof(*devices))
 431     {
 432         SetLastError(ERROR_INVALID_PARAMETER);
 433         return ~0U;
 434     }
 435
 436     if (!device_count)
 437     {
 438         SetLastError(ERROR_NOACCESS);
 439         return ~0U;
 440     }
 441
 442     if (ticks - last_check > 2000)
 443     {
 444         last_check = ticks;
 445         rawinput_update_device_list();
 446     }
 447
 448     if (!devices)
 449     {
 450         *device_count = rawinput_devices_count;
 451         return 0;
 452     }
 453
 454     if (*device_count < rawinput_devices_count)
 455     {
 456         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 457         *device_count = rawinput_devices_count;
 458         return ~0U;
 459     }
 460
 461     for (i = 0; i < rawinput_devices_count; ++i)
 462     {
 463         devices[i].hDevice = rawinput_devices[i].handle;
 464         devices[i].dwType = rawinput_devices[i].info.dwType;
 465     }
 466
 467     return rawinput_devices_count;
 468 }
 469
 470 /***********************************************************************
 471  *              RegisterRawInputDevices   (USER32.@)
 472  */
 473 BOOL WINAPI DECLSPEC_HOTPATCH RegisterRawInputDevices(RAWINPUTDEVICE *devices, UINT device_count, UINT size)
 474 {
 475     struct rawinput_device *d;
 476     BOOL ret;
 477     UINT i;
 478
 479     TRACE("devices %p, device_count %u, size %u.\n", devices, device_count, size);
 480
 481     if (size != sizeof(*devices))
 482     {
 483         WARN("Invalid structure size %u.\n", size);
 484         SetLastError(ERROR_INVALID_PARAMETER);
 485         return FALSE;
 486     }
 487
 488     for (i = 0; i < device_count; ++i)
 489     {
 490         if ((devices[i].dwFlags & RIDEV_INPUTSINK) &&
 491             (devices[i].hwndTarget == NULL))
 492         {
 493             SetLastError(ERROR_INVALID_PARAMETER);
 494             return FALSE;
 495         }
 496
 497         if ((devices[i].dwFlags & RIDEV_REMOVE) &&
 498             (devices[i].hwndTarget != NULL))
 499         {
 500             SetLastError(ERROR_INVALID_PARAMETER);
 501             return FALSE;
 502         }
 503     }
 504
 505     if (!(d = HeapAlloc( GetProcessHeap(), 0, device_count * sizeof(*d) ))) return FALSE;
 506
 507     for (i = 0; i < device_count; ++i)
 508     {
 509         TRACE("device %u: page %#x, usage %#x, flags %#x, target %p.\n",
 510                 i, devices[i].usUsagePage, devices[i].usUsage,
 511                 devices[i].dwFlags, devices[i].hwndTarget);
 512         if (devices[i].dwFlags & ~(RIDEV_REMOVE|RIDEV_NOLEGACY|RIDEV_INPUTSINK|RIDEV_DEVNOTIFY))
 513             FIXME("Unhandled flags %#x for device %u.\n", devices[i].dwFlags, i);
 514
 515         d[i].usage_page = devices[i].usUsagePage;
 516         d[i].usage = devices[i].usUsage;
 517         d[i].flags = devices[i].dwFlags;
 518         d[i].target = wine_server_user_handle( devices[i].hwndTarget );
 519     }
 520
 521     SERVER_START_REQ( update_rawinput_devices )
 522     {
 523         wine_server_add_data( req, d, device_count * sizeof(*d) );
 524         ret = !wine_server_call( req );
 525     }
 526     SERVER_END_REQ;
 527
 528     HeapFree( GetProcessHeap(), 0, d );
 529
 530     return ret;
 531 }
 532
 533 /***********************************************************************
 534  *              GetRawInputData   (USER32.@)
 535  */
 536 UINT WINAPI GetRawInputData(HRAWINPUT rawinput, UINT command, void *data, UINT *data_size, UINT header_size)
 537 {
 538     struct rawinput_thread_data *thread_data = rawinput_thread_data();
 539     UINT size;
 540
 541     TRACE("rawinput %p, command %#x, data %p, data_size %p, header_size %u.\n",
 542             rawinput, command, data, data_size, header_size);
 543
 544     if (!rawinput || thread_data->hw_id != (UINT_PTR)rawinput)
 545     {
 546         SetLastError(ERROR_INVALID_HANDLE);
 547         return ~0U;
 548     }
 549
 550     if (header_size != sizeof(RAWINPUTHEADER))
 551     {
 552         WARN("Invalid structure size %u.\n", header_size);
 553         SetLastError(ERROR_INVALID_PARAMETER);
 554         return ~0U;
 555     }
 556
 557     switch (command)
 558     {
 559     case RID_INPUT:
 560         size = thread_data->buffer->header.dwSize;
 561         break;
 562     case RID_HEADER:
 563         size = sizeof(RAWINPUTHEADER);
 564         break;
 565     default:
 566         SetLastError(ERROR_INVALID_PARAMETER);
 567         return ~0U;
 568     }
 569
 570     if (!data)
 571     {
 572         *data_size = size;
 573         return 0;
 574     }
 575
 576     if (*data_size < size)
 577     {
 578         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 579         return ~0U;
 580     }
 581     memcpy(data, thread_data->buffer, size);
 582     return size;
 583 }
 584
 585 #ifdef _WIN64
 586 typedef RAWINPUT RAWINPUT64;
 587 #else
 588 typedef struct
 589 {
 590     RAWINPUTHEADER header;
 591     char pad[8];
 592     union {
 593         RAWMOUSE    mouse;
 594         RAWKEYBOARD keyboard;
 595         RAWHID      hid;
 596     } data;
 597 } RAWINPUT64;
 598 #endif
 599
 600 /***********************************************************************
 601  *              GetRawInputBuffer   (USER32.@)
 602  */
 603 UINT WINAPI DECLSPEC_HOTPATCH GetRawInputBuffer(RAWINPUT *data, UINT *data_size, UINT header_size)
 604 {
 605     struct hardware_msg_data *msg_data;
 606     struct rawinput_thread_data *thread_data;
 607     RAWINPUT *rawinput;
 608     UINT count = 0, remaining, rawinput_size, next_size, overhead;
 609     BOOL is_wow64;
 610     int i;
 611
 612     if (IsWow64Process( GetCurrentProcess(), &is_wow64 ) && is_wow64)
 613         rawinput_size = sizeof(RAWINPUT64);
 614     else
 615         rawinput_size = sizeof(RAWINPUT);
 616     overhead = rawinput_size - sizeof(RAWINPUT);
 617
 618     if (header_size != sizeof(RAWINPUTHEADER))
 619     {
 620         WARN("Invalid structure size %u.\n", header_size);
 621         SetLastError(ERROR_INVALID_PARAMETER);
 622         return ~0U;
 623     }
 624
 625     if (!data_size)
 626     {
 627         SetLastError(ERROR_INVALID_PARAMETER);
 628         return ~0U;
 629     }
 630
 631     if (!data)
 632     {
 633         TRACE("data %p, data_size %p (%u), header_size %u\n", data, data_size, *data_size, header_size);
 634         SERVER_START_REQ( get_rawinput_buffer )
 635         {
 636             req->rawinput_size = rawinput_size;
 637             req->buffer_size = 0;
 638             if (wine_server_call( req )) return ~0U;
 639             *data_size = reply->next_size;
 640         }
 641         SERVER_END_REQ;
 642         return 0;
 643     }
 644
 645     if (!(thread_data = rawinput_thread_data())) return ~0U;
 646     rawinput = thread_data->buffer;
 647
 648     /* first RAWINPUT block in the buffer is used for WM_INPUT message data */
 649     msg_data = (struct hardware_msg_data *)NEXTRAWINPUTBLOCK(rawinput);
 650     SERVER_START_REQ( get_rawinput_buffer )
 651     {
 652         req->rawinput_size = rawinput_size;
 653         req->buffer_size = *data_size;
 654         wine_server_set_reply( req, msg_data, RAWINPUT_BUFFER_SIZE - rawinput->header.dwSize );
 655         if (wine_server_call( req )) return ~0U;
 656         next_size = reply->next_size;
 657         count = reply->count;
 658     }
 659     SERVER_END_REQ;
 660
 661     remaining = *data_size;
 662     for (i = 0; i < count; ++i)
 663     {
 664         data->header.dwSize = remaining;
 665         if (!rawinput_from_hardware_message(data, msg_data)) break;
 666         if (overhead) memmove((char *)&data->data + overhead, &data->data,
 667                               data->header.dwSize - sizeof(RAWINPUTHEADER));
 668         data->header.dwSize += overhead;
 669         remaining -= data->header.dwSize;
 670         data = NEXTRAWINPUTBLOCK(data);
 671         msg_data = (struct hardware_msg_data *)((char *)msg_data + msg_data->size);
 672     }
 673
 674     if (count == 0 && next_size == 0) *data_size = 0;
 675     else if (next_size == 0) next_size = rawinput_size;
 676
 677     if (next_size && *data_size <= next_size)
 678     {
 679         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 680         *data_size = next_size;
 681         count = ~0U;
 682     }
 683
 684     if (count) TRACE("data %p, data_size %p (%u), header_size %u, count %u\n", data, data_size, *data_size, header_size, count);
 685     return count;
 686 }
 687
 688 /***********************************************************************
 689  *              GetRawInputDeviceInfoA   (USER32.@)
 690  */
 691 UINT WINAPI GetRawInputDeviceInfoA(HANDLE device, UINT command, void *data, UINT *data_size)
 692 {
 693     TRACE("device %p, command %#x, data %p, data_size %p.\n",
 694             device, command, data, data_size);
 695
 696     /* RIDI_DEVICENAME data_size is in chars, not bytes */
 697     if (command == RIDI_DEVICENAME)
 698     {
 699         WCHAR *nameW;
 700         UINT ret, nameW_sz;
 701
 702         if (!data_size) return ~0U;
 703
 704         nameW_sz = *data_size;
 705
 706         if (data && nameW_sz > 0)
 707             nameW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * nameW_sz);
 708         else
 709             nameW = NULL;
 710
 711         ret = GetRawInputDeviceInfoW(device, command, nameW, &nameW_sz);
 712
 713         if (ret && ret != ~0U)
 714             WideCharToMultiByte(CP_ACP, 0, nameW, -1, data, *data_size, NULL, NULL);
 715
 716         *data_size = nameW_sz;
 717
 718         HeapFree(GetProcessHeap(), 0, nameW);
 719
 720         return ret;
 721     }
 722
 723     return GetRawInputDeviceInfoW(device, command, data, data_size);
 724 }
 725
 726 /***********************************************************************
 727  *              GetRawInputDeviceInfoW   (USER32.@)
 728  */
 729 UINT WINAPI GetRawInputDeviceInfoW(HANDLE handle, UINT command, void *data, UINT *data_size)
 730 {
 731     struct hid_preparsed_data *preparsed;
 732     RID_DEVICE_INFO info;
 733     struct device *device;
 734     DWORD len, data_len;
 735
 736     TRACE("handle %p, command %#x, data %p, data_size %p.\n",
 737             handle, command, data, data_size);
 738
 739     if (!data_size)
 740     {
 741         SetLastError(ERROR_NOACCESS);
 742         return ~0U;
 743     }
 744     if (!(device = find_device_from_handle(handle)))
 745     {
 746         SetLastError(ERROR_INVALID_HANDLE);
 747         return ~0U;
 748     }
 749
 750     data_len = *data_size;
 751     switch (command)
 752     {
 753     case RIDI_DEVICENAME:
 754         if ((len = wcslen(device->detail->DevicePath) + 1) <= data_len && data)
 755             memcpy(data, device->detail->DevicePath, len * sizeof(WCHAR));
 756         *data_size = len;
 757         break;
 758
 759     case RIDI_DEVICEINFO:
 760         if ((len = sizeof(info)) <= data_len && data)
 761             memcpy(data, &device->info, len);
 762         *data_size = len;
 763         break;
 764
 765     case RIDI_PREPARSEDDATA:
 766         if (!(preparsed = (struct hid_preparsed_data *)device->data)) len = 0;
 767         else len = preparsed->caps_size + FIELD_OFFSET(struct hid_preparsed_data, value_caps[0]) +
 768                    preparsed->number_link_collection_nodes * sizeof(struct hid_collection_node);
 769
 770         if (device->data && len <= data_len && data)
 771             memcpy(data, device->data, len);
 772         *data_size = len;
 773         break;
 774
 775     default:
 776         FIXME("command %#x not supported\n", command);
 777         SetLastError(ERROR_INVALID_PARAMETER);
 778         return ~0U;
 779     }
 780
 781     if (!data)
 782         return 0;
 783
 784     if (data_len < len)
 785     {
 786         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 787         return ~0U;
 788     }
 789
 790     return *data_size;
 791 }
 792
 793 static int __cdecl compare_raw_input_devices(const void *ap, const void *bp)
 794 {
 795     const RAWINPUTDEVICE a = *(const RAWINPUTDEVICE *)ap;
 796     const RAWINPUTDEVICE b = *(const RAWINPUTDEVICE *)bp;
 797
 798     if (a.usUsagePage != b.usUsagePage) return a.usUsagePage - b.usUsagePage;
 799     if (a.usUsage != b.usUsage) return a.usUsage - b.usUsage;
 800     return 0;
 801 }
 802
 803 /***********************************************************************
 804  *              GetRegisteredRawInputDevices   (USER32.@)
 805  */
 806 UINT WINAPI DECLSPEC_HOTPATCH GetRegisteredRawInputDevices(RAWINPUTDEVICE *devices, UINT *device_count, UINT size)
 807 {
 808     struct rawinput_device *buffer = NULL;
 809     unsigned int i, status, count = ~0U, buffer_size;
 810
 811     TRACE("devices %p, device_count %p, size %u\n", devices, device_count, size);
 812
 813     if (size != sizeof(RAWINPUTDEVICE) || !device_count || (devices && !*device_count))
 814     {
 815         SetLastError(ERROR_INVALID_PARAMETER);
 816         return ~0U;
 817     }
 818
 819     buffer_size = *device_count * sizeof(*buffer);
 820     if (devices && !(buffer = HeapAlloc(GetProcessHeap(), 0, buffer_size)))
 821         return ~0U;
 822
 823     SERVER_START_REQ(get_rawinput_devices)
 824     {
 825         if (buffer) wine_server_set_reply(req, buffer, buffer_size);
 826         status = wine_server_call_err(req);
 827         *device_count = reply->device_count;
 828     }
 829     SERVER_END_REQ;
 830
 831     if (buffer && !status)
 832     {
 833         for (i = 0, count = *device_count; i < count; ++i)
 834         {
 835             devices[i].usUsagePage = buffer[i].usage_page;
 836             devices[i].usUsage = buffer[i].usage;
 837             devices[i].dwFlags = buffer[i].flags;
 838             devices[i].hwndTarget = wine_server_ptr_handle(buffer[i].target);
 839         }
 840
 841         qsort(devices, count, sizeof(*devices), compare_raw_input_devices);
 842     }
 843
 844     if (buffer) HeapFree(GetProcessHeap(), 0, buffer);
 845     else count = 0;
 846     return count;
 847 }
 848
 849
 850 /***********************************************************************
 851  *              DefRawInputProc   (USER32.@)
 852  */
 853 LRESULT WINAPI DefRawInputProc(RAWINPUT **data, INT data_count, UINT header_size)
 854 {
 855     FIXME("data %p, data_count %d, header_size %u stub!\n", data, data_count, header_size);
 856
 857     return 0;
 858 }