[libsigrok.git] / libusbhp.c

/*
 * This file is part of the DSLogic project.
 */

#include "libsigrok.h"
#include "hardware/DSLogic/dslogic.h"

#ifdef __linux__
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#endif/*__linux__*/

#ifdef _WIN32
#include <windows.h>

#include <initguid.h>
#include <ddk/usbiodef.h>
#include <Setupapi.h>

#include <tchar.h>
#include <conio.h>
#include <dbt.h>
#include <stdio.h>
#include <winuser.h>

#endif/*_WIN32*/


#ifdef __linux__
static void dev_list_add(struct libusbhp_t *h, const char *path,
                         unsigned short vid, unsigned short pid)
{
  struct dev_list_t *dev =
    (struct dev_list_t*)malloc(sizeof(struct dev_list_t));
  dev->path = strdup(path);
  dev->vid = vid;
  dev->pid = pid;
  dev->next = NULL;

  struct dev_list_t *p = h->devlist;
  if(!p) {
    h->devlist = dev;
    return;
  }

  while(p->next) {
    p = p->next;
  }

  p->next = dev;
}

static int dev_list_remove(struct libusbhp_t *h, const char *path)
{
  struct dev_list_t *p = h->devlist;
  if(!p) return 1;

  if(!strcmp(p->path, path)) {
    h->devlist = p->next;
    free(p->path);
    free(p);
    return 0;
  }

  while(p->next) {
    if(!strcmp(p->next->path, path)) {
      struct dev_list_t *pp = p->next;
      p->next = pp->next;
      free(pp->path);
      free(pp->next);
      free(pp);
      return 0;
    }
    p = p->next;
  }

  // Not found
  return 1;
}

static int dev_list_find(struct libusbhp_t *h, const char *path,
                         unsigned short *vid, unsigned short *pid)
{
  struct dev_list_t *p = h->devlist;
  while(p) {
    if(!strcmp(p->path, path)) {
      *vid = p->vid;
      *pid = p->pid;
      return 0;
    }
    p = p->next;
  }

  // Not found
  return 1;
}
#endif/*__linux__*/

#ifdef _WIN32
SR_PRIV LRESULT CALLBACK WinProcCallback(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
  struct libusbhp_t *h = (struct libusbhp_t*)GetWindowLong(hwnd, GWL_USERDATA);

  switch(msg) {
  case WM_DEVICECHANGE:
    {
      PDEV_BROADCAST_HDR phdr = (PDEV_BROADCAST_HDR)lp;

      if(!phdr || phdr->dbch_devicetype != DBT_DEVTYP_DEVICEINTERFACE) break;

      PDEV_BROADCAST_DEVICEINTERFACE devif =
        (PDEV_BROADCAST_DEVICEINTERFACE)lp;

      HDEVINFO devinfolist = SetupDiCreateDeviceInfoList(NULL, NULL);
      
      SP_DEVICE_INTERFACE_DATA devifdata;
      memset(&devifdata, 0, sizeof(devifdata));
      devifdata.cbSize = sizeof(devifdata);
      BOOL b = SetupDiOpenDeviceInterface(devinfolist, devif->dbcc_name, 0,
                                          &devifdata);
      
      DWORD required;
      SP_DEVICE_INTERFACE_DETAIL_DATA devdetaildata;
      memset(&devdetaildata, 0, sizeof(devdetaildata));
      devdetaildata.cbSize = sizeof(devdetaildata);

      SP_DEVINFO_DATA devinfodata;
      memset(&devinfodata, 0, sizeof(devinfodata));
      devinfodata.cbSize = sizeof(devinfodata);
      b = SetupDiGetDeviceInterfaceDetail(devinfolist, &devifdata,
                                          &devdetaildata,
                                          sizeof(devdetaildata),
                                          &required, &devinfodata);
     
      TCHAR deviceidw[1024];
      b = SetupDiGetDeviceInstanceIdW(devinfolist, &devinfodata, deviceidw,
                                      sizeof(deviceidw), NULL);

      char deviceid[1024];
      //size_t sz;
      //wcstombs_s(&sz, deviceid, deviceidw, sizeof(deviceid) - 1);
      wcstombs(deviceid, deviceidw, sizeof(deviceid) - 1);

      char *vid = strstr(deviceid, "VID_");
      if(vid != NULL) vid += 4;

      char *pid = strstr(deviceid, "PID_");
      if(pid != NULL)  pid += 4;

      struct libusbhp_device_t *device = NULL;

      if(pid || vid) {
        device =
          (struct libusbhp_device_t*)malloc(sizeof(struct libusbhp_device_t));
      }

      if(pid) {
        pid[4] = '\0';
        device->idProduct = (unsigned short)strtol(pid, NULL, 16); 
      }

      if(vid) {
        vid[4] = '\0';
        device->idVendor = (unsigned short)strtol(vid, NULL, 16);
      }

      if ((device->idVendor == supported_fx2[0].vid) &&
          (device->idProduct == supported_fx2[0].pid)) {
          switch(wp) {
          case DBT_DEVICEARRIVAL:
            if(h->attach) h->attach(device, h->user_data);
            break;
          case DBT_DEVICEREMOVECOMPLETE:
            if(h->detach) h->detach(device, h->user_data);
            break;
          case DBT_DEVNODES_CHANGED:
          default:
            break;
          }
      }

      if(device) free(device);
    }
    break;
  default:
    break;
  }
  
  return DefWindowProc(hwnd, msg, wp, lp);
}
#endif/*OS_WINDOWS*/

SR_API int libusbhp_init(struct libusbhp_t **handle)
{
  struct libusbhp_t *h = (struct libusbhp_t *)malloc(sizeof(struct libusbhp_t));

  h->attach = NULL;
  h->detach = NULL;
  h->user_data = NULL;

#ifdef __linux__
  h->devlist = NULL;

  // create the udev object
  h->hotplug = udev_new();
  if(!h->hotplug)
  {
    printf("Cannot create udev object\n");
    free(h);
    return 1;
  }

  // create the udev monitor
  h->hotplug_monitor = udev_monitor_new_from_netlink(h->hotplug, "udev");

  // start receiving hotplug events
  udev_monitor_filter_add_match_subsystem_devtype(h->hotplug_monitor,
                                                  "usb", "usb_device");
  udev_monitor_enable_receiving(h->hotplug_monitor);

  struct udev_enumerate *de = udev_enumerate_new (h->hotplug);
  udev_enumerate_add_match_subsystem(de, "usb");
  udev_enumerate_scan_devices(de);

  struct udev_list_entry *lst = udev_enumerate_get_list_entry(de);
  while(lst) {
    struct udev_device *dev =
      udev_device_new_from_syspath(h->hotplug,
                                   udev_list_entry_get_name(lst));

    if(udev_device_get_devnode(dev)) {
      unsigned short idVendor =
        strtol(udev_device_get_sysattr_value(dev, "idVendor"), NULL, 16); 
      unsigned short idProduct =
        strtol(udev_device_get_sysattr_value(dev, "idProduct"), NULL, 16); 

      dev_list_add(h, udev_device_get_devnode(dev), idVendor, idProduct);
    }

    udev_device_unref(dev);

    lst = udev_list_entry_get_next(lst);
  }

  udev_enumerate_unref(de);

#endif/*__linux__*/

#ifdef _WIN32
  memset(&h->wcex, 0, sizeof(h->wcex));
  h->wcex.cbSize = sizeof(WNDCLASSEX);
  h->wcex.lpfnWndProc = WinProcCallback;
  h->wcex.hInstance = GetModuleHandle(NULL);  
  h->wcex.lpszClassName = TEXT("UsbHotplugClass");
  h->wcex.cbWndExtra = sizeof(struct libusbhp_t*); // Size of data.

  RegisterClassEx(&h->wcex);

  h->hwnd =
    CreateWindowEx(0, h->wcex.lpszClassName, TEXT("UsbHotplug"), 0, 0, 0, 0,
                   0, 0, NULL, GetModuleHandle(NULL), NULL);

  SetWindowLong(h->hwnd, GWL_USERDATA, (LONG)h);


  DEV_BROADCAST_DEVICEINTERFACE *filter =
  (DEV_BROADCAST_DEVICEINTERFACE*)malloc(sizeof(DEV_BROADCAST_DEVICEINTERFACE));

  memset(filter, 0, sizeof(DEV_BROADCAST_DEVICEINTERFACE));
  filter->dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
  filter->dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
  filter->dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;

  h->hDeviceNotify =
    RegisterDeviceNotification(h->hwnd, filter, DEVICE_NOTIFY_WINDOW_HANDLE);
  
  if(h->hDeviceNotify == 0) {
    //printf("RegisterDeviceNotification error\n");
    free(h);
    return 1;
  }
#endif/*_WIN32*/

  *handle = h;
  return 0;
}

SR_API void libusbhp_exit(struct libusbhp_t *h)
{
#ifdef __linux__
  // destroy the udev monitor
  udev_monitor_unref(h->hotplug_monitor);

  // destroy the udev object
  udev_unref(h->hotplug);
#endif/*__linux__*/

#ifdef _WIN32
  UnregisterDeviceNotification(h->hDeviceNotify);
  DestroyWindow(h->hwnd);
  UnregisterClass(h->wcex.lpszClassName, h->wcex.hInstance);
#endif/*_WIN32*/

  free(h);
}

SR_API int libusbhp_handle_events_timeout(struct libusbhp_t *h, struct timeval *tv)
{
  int ms = tv->tv_sec * 1000 + tv->tv_usec / 1000;

#ifdef __linux__
  // create the poll item
  struct pollfd items[1];
  items[0].fd = udev_monitor_get_fd(h->hotplug_monitor);
  items[0].events = POLLIN;
  items[0].revents = 0;

  // while there are hotplug events to process
  while(poll(items, 1, ms) > 0) {    
    // receive the relevant device
    struct udev_device* dev = udev_monitor_receive_device(h->hotplug_monitor);
    if(!dev) {
      // error receiving device, skip it
      continue;
    }

    if(!strcmp(udev_device_get_action(dev), "add")) {
      struct libusbhp_device_t device;

      device.idVendor =
        strtol(udev_device_get_sysattr_value(dev, "idVendor"), NULL, 16); 
      device.idProduct =
        strtol(udev_device_get_sysattr_value(dev, "idProduct"), NULL, 16); 

      dev_list_add(h, udev_device_get_devnode(dev),
                   device.idVendor, device.idProduct);

      if(h->attach) h->attach(&device, h->user_data);
    }

    if(!strcmp(udev_device_get_action(dev), "remove")) {
      struct libusbhp_device_t device;

      int res = dev_list_find(h, udev_device_get_devnode(dev),
                              &device.idVendor, &device.idProduct);

      if(res) {
        if(h->detach) h->detach(NULL, h->user_data);
      } else {
	dev_list_remove(h, udev_device_get_devnode(dev));
        if(h->detach) h->detach(&device, h->user_data);
      }
    }

    // destroy the relevant device
    udev_device_unref(dev);

    // clear the revents
    items[0].revents = 0;
  }
#endif/*__linux__*/

#ifdef _WIN32
  UINT_PTR timer = SetTimer(h->hwnd, 0, ms, NULL);

  MSG msg; 
  int ret = GetMessage(&msg, NULL, 0, 0);

  if(ret <= 0) return 0;
  
  TranslateMessage(&msg);
  DispatchMessage(&msg);

  KillTimer(h->hwnd, timer);
#endif/*_WIN32*/

  return 0;
}

SR_API void libusbhp_register_hotplug_listeners(struct libusbhp_t *handle,
                                         libusbhp_hotplug_cb_fn connected_cb,
                                         libusbhp_hotplug_cb_fn disconnected_cb,
                                         void *user_data)
{
  handle->attach = connected_cb;
  handle->detach = disconnected_cb;
  handle->user_data = user_data;
}
Commit	Line	Data
f1b296fc BV	1	/*
	2	* This file is part of the DSLogic project.
	3	*/
	4
	5	#include "libsigrok.h"
	6	#include "hardware/DSLogic/dslogic.h"
	7
	8	#ifdef __linux__
	9	#include <poll.h>
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <string.h>
	13	#include <unistd.h>
	14	#endif/__linux__/
	15
	16	#ifdef _WIN32
	17	#include <windows.h>
	18
	19	#include <initguid.h>
	20	#include <ddk/usbiodef.h>
	21	#include <Setupapi.h>
	22
	23	#include <tchar.h>
	24	#include <conio.h>
	25	#include <dbt.h>
	26	#include <stdio.h>
	27	#include <winuser.h>
	28
	29	#endif/_WIN32/
	30
	31
	32
	33	#ifdef __linux__
	34	static void dev_list_add(struct libusbhp_t h, const char path,
	35	unsigned short vid, unsigned short pid)
	36	{
	37	struct dev_list_t *dev =
	38	(struct dev_list_t*)malloc(sizeof(struct dev_list_t));
	39	dev->path = strdup(path);
	40	dev->vid = vid;
	41	dev->pid = pid;
	42	dev->next = NULL;
	43
	44	struct dev_list_t *p = h->devlist;
	45	if(!p) {
	46	h->devlist = dev;
	47	return;
	48	}
	49
	50	while(p->next) {
	51	p = p->next;
	52	}
	53
	54	p->next = dev;
	55	}
	56
	57	static int dev_list_remove(struct libusbhp_t h, const char path)
	58	{
	59	struct dev_list_t *p = h->devlist;
	60	if(!p) return 1;
	61
	62	if(!strcmp(p->path, path)) {
	63	h->devlist = p->next;
	64	free(p->path);
65	free(p);
66	return 0;
67	}
68
69	while(p->next) {
70	if(!strcmp(p->next->path, path)) {
71	struct dev_list_t *pp = p->next;
72	p->next = pp->next;
73	free(pp->path);
74	free(pp->next);
75	free(pp);
76	return 0;
77	}
78	p = p->next;
79	}
80
81	// Not found
82	return 1;
83	}
84
85	static int dev_list_find(struct libusbhp_t h, const char path,
86	unsigned short vid, unsigned short pid)
87	{
88	struct dev_list_t *p = h->devlist;
89	while(p) {
90	if(!strcmp(p->path, path)) {
91	*vid = p->vid;
92	*pid = p->pid;
93	return 0;
94	}
95	p = p->next;
96	}
97
98	// Not found
99	return 1;
100	}
101	#endif/__linux__/
102
103	#ifdef _WIN32
104	SR_PRIV LRESULT CALLBACK WinProcCallback(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
105	{
106	struct libusbhp_t h = (struct libusbhp_t)GetWindowLong(hwnd, GWL_USERDATA);
107
108	switch(msg) {
109	case WM_DEVICECHANGE:
110	{
111	PDEV_BROADCAST_HDR phdr = (PDEV_BROADCAST_HDR)lp;
112
113	if(!phdr \|\| phdr->dbch_devicetype != DBT_DEVTYP_DEVICEINTERFACE) break;
114
115	PDEV_BROADCAST_DEVICEINTERFACE devif =
116	(PDEV_BROADCAST_DEVICEINTERFACE)lp;
117
118	HDEVINFO devinfolist = SetupDiCreateDeviceInfoList(NULL, NULL);
119
120	SP_DEVICE_INTERFACE_DATA devifdata;
121	memset(&devifdata, 0, sizeof(devifdata));
122	devifdata.cbSize = sizeof(devifdata);
123	BOOL b = SetupDiOpenDeviceInterface(devinfolist, devif->dbcc_name, 0,
124	&devifdata);
125
126	DWORD required;
127	SP_DEVICE_INTERFACE_DETAIL_DATA devdetaildata;
128	memset(&devdetaildata, 0, sizeof(devdetaildata));
129	devdetaildata.cbSize = sizeof(devdetaildata);
130
131	SP_DEVINFO_DATA devinfodata;
132	memset(&devinfodata, 0, sizeof(devinfodata));
133	devinfodata.cbSize = sizeof(devinfodata);
134	b = SetupDiGetDeviceInterfaceDetail(devinfolist, &devifdata,
135	&devdetaildata,
136	sizeof(devdetaildata),
137	&required, &devinfodata);
138
139	TCHAR deviceidw[1024];
140	b = SetupDiGetDeviceInstanceIdW(devinfolist, &devinfodata, deviceidw,
141	sizeof(deviceidw), NULL);
142
143	char deviceid[1024];
144	//size_t sz;
145	//wcstombs_s(&sz, deviceid, deviceidw, sizeof(deviceid) - 1);
146	wcstombs(deviceid, deviceidw, sizeof(deviceid) - 1);
147
148	char *vid = strstr(deviceid, "VID_");
149	if(vid != NULL) vid += 4;
150
151	char *pid = strstr(deviceid, "PID_");
152	if(pid != NULL) pid += 4;
153
154	struct libusbhp_device_t *device = NULL;
155
156	if(pid \|\| vid) {
157	device =
158	(struct libusbhp_device_t*)malloc(sizeof(struct libusbhp_device_t));
159	}
160
161	if(pid) {
162	pid[4] = '\0';
163	device->idProduct = (unsigned short)strtol(pid, NULL, 16);
164	}
165
166	if(vid) {
167	vid[4] = '\0';
168	device->idVendor = (unsigned short)strtol(vid, NULL, 16);
169	}
170
171	if ((device->idVendor == supported_fx2[0].vid) &&
172	(device->idProduct == supported_fx2[0].pid)) {
173	switch(wp) {
174	case DBT_DEVICEARRIVAL:
175	if(h->attach) h->attach(device, h->user_data);
176	break;
177	case DBT_DEVICEREMOVECOMPLETE:
178	if(h->detach) h->detach(device, h->user_data);
179	break;
180	case DBT_DEVNODES_CHANGED:
181	default:
182	break;
183	}
184	}
185
186	if(device) free(device);
187	}
188	break;
189	default:
190	break;
191	}
192
193	return DefWindowProc(hwnd, msg, wp, lp);
194	}
195	#endif/OS_WINDOWS/
196
197	SR_API int libusbhp_init(struct libusbhp_t **handle)
198	{
199	struct libusbhp_t h = (struct libusbhp_t )malloc(sizeof(struct libusbhp_t));
200
201	h->attach = NULL;
202	h->detach = NULL;
203	h->user_data = NULL;
204
205	#ifdef __linux__
206	h->devlist = NULL;
207
208	// create the udev object
209	h->hotplug = udev_new();
210	if(!h->hotplug)
211	{
212	printf("Cannot create udev object\n");
213	free(h);
214	return 1;
215	}
216
217	// create the udev monitor
218	h->hotplug_monitor = udev_monitor_new_from_netlink(h->hotplug, "udev");
219
220	// start receiving hotplug events
221	udev_monitor_filter_add_match_subsystem_devtype(h->hotplug_monitor,
222	"usb", "usb_device");
223	udev_monitor_enable_receiving(h->hotplug_monitor);
224
225	struct udev_enumerate *de = udev_enumerate_new (h->hotplug);
226	udev_enumerate_add_match_subsystem(de, "usb");
227	udev_enumerate_scan_devices(de);
228
229	struct udev_list_entry *lst = udev_enumerate_get_list_entry(de);
230	while(lst) {
231	struct udev_device *dev =
232	udev_device_new_from_syspath(h->hotplug,
233	udev_list_entry_get_name(lst));
234
235	if(udev_device_get_devnode(dev)) {
236	unsigned short idVendor =
237	strtol(udev_device_get_sysattr_value(dev, "idVendor"), NULL, 16);
238	unsigned short idProduct =
239	strtol(udev_device_get_sysattr_value(dev, "idProduct"), NULL, 16);
240
241	dev_list_add(h, udev_device_get_devnode(dev), idVendor, idProduct);
242	}
243
244	udev_device_unref(dev);
245
246	lst = udev_list_entry_get_next(lst);
247	}
248
249	udev_enumerate_unref(de);
250
251	#endif/__linux__/
252
253	#ifdef _WIN32
254	memset(&h->wcex, 0, sizeof(h->wcex));
255	h->wcex.cbSize = sizeof(WNDCLASSEX);
256	h->wcex.lpfnWndProc = WinProcCallback;
257	h->wcex.hInstance = GetModuleHandle(NULL);
258	h->wcex.lpszClassName = TEXT("UsbHotplugClass");
259	h->wcex.cbWndExtra = sizeof(struct libusbhp_t*); // Size of data.
260
261	RegisterClassEx(&h->wcex);
262
263	h->hwnd =
264	CreateWindowEx(0, h->wcex.lpszClassName, TEXT("UsbHotplug"), 0, 0, 0, 0,
265	0, 0, NULL, GetModuleHandle(NULL), NULL);
266
267	SetWindowLong(h->hwnd, GWL_USERDATA, (LONG)h);
268
269
270	DEV_BROADCAST_DEVICEINTERFACE *filter =
271	(DEV_BROADCAST_DEVICEINTERFACE*)malloc(sizeof(DEV_BROADCAST_DEVICEINTERFACE));
272
273	memset(filter, 0, sizeof(DEV_BROADCAST_DEVICEINTERFACE));
274	filter->dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
275	filter->dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
276	filter->dbcc_classguid = GUID_DEVINTERFACE_USB_DEVICE;
277
278	h->hDeviceNotify =
279	RegisterDeviceNotification(h->hwnd, filter, DEVICE_NOTIFY_WINDOW_HANDLE);
280
281	if(h->hDeviceNotify == 0) {
282	//printf("RegisterDeviceNotification error\n");
283	free(h);
284	return 1;
285	}
286	#endif/_WIN32/
287
288	*handle = h;
289	return 0;
290	}
291
292	SR_API void libusbhp_exit(struct libusbhp_t *h)
293	{
294	#ifdef __linux__
295	// destroy the udev monitor
296	udev_monitor_unref(h->hotplug_monitor);
297
298	// destroy the udev object
299	udev_unref(h->hotplug);
300	#endif/__linux__/
301
302	#ifdef _WIN32
303	UnregisterDeviceNotification(h->hDeviceNotify);
304	DestroyWindow(h->hwnd);
305	UnregisterClass(h->wcex.lpszClassName, h->wcex.hInstance);
306	#endif/_WIN32/
307
308	free(h);
309	}
310
311	SR_API int libusbhp_handle_events_timeout(struct libusbhp_t h, struct timeval tv)
312	{
313	int ms = tv->tv_sec * 1000 + tv->tv_usec / 1000;
314
315	#ifdef __linux__
316	// create the poll item
317	struct pollfd items[1];
318	items[0].fd = udev_monitor_get_fd(h->hotplug_monitor);
319	items[0].events = POLLIN;
320	items[0].revents = 0;
321
322	// while there are hotplug events to process
323	while(poll(items, 1, ms) > 0) {
324	// receive the relevant device
325	struct udev_device* dev = udev_monitor_receive_device(h->hotplug_monitor);
326	if(!dev) {
327	// error receiving device, skip it
328	continue;
329	}
330
331	if(!strcmp(udev_device_get_action(dev), "add")) {
332	struct libusbhp_device_t device;
333
334	device.idVendor =
335	strtol(udev_device_get_sysattr_value(dev, "idVendor"), NULL, 16);
336	device.idProduct =
337	strtol(udev_device_get_sysattr_value(dev, "idProduct"), NULL, 16);
338
339	dev_list_add(h, udev_device_get_devnode(dev),
340	device.idVendor, device.idProduct);
341
342	if(h->attach) h->attach(&device, h->user_data);
343	}
344
345	if(!strcmp(udev_device_get_action(dev), "remove")) {
346	struct libusbhp_device_t device;
347
348	int res = dev_list_find(h, udev_device_get_devnode(dev),
349	&device.idVendor, &device.idProduct);
350
351	if(res) {
352	if(h->detach) h->detach(NULL, h->user_data);
353	} else {
354	dev_list_remove(h, udev_device_get_devnode(dev));
355	if(h->detach) h->detach(&device, h->user_data);
356	}
357	}
358
359	// destroy the relevant device
360	udev_device_unref(dev);
361
362	// clear the revents
363	items[0].revents = 0;
364	}
365	#endif/__linux__/
366
367	#ifdef _WIN32
368	UINT_PTR timer = SetTimer(h->hwnd, 0, ms, NULL);
369
370	MSG msg;
371	int ret = GetMessage(&msg, NULL, 0, 0);
372
373	if(ret <= 0) return 0;
374
375	TranslateMessage(&msg);
376	DispatchMessage(&msg);
377
378	KillTimer(h->hwnd, timer);
379	#endif/_WIN32/
380
381	return 0;
382	}
383
384	SR_API void libusbhp_register_hotplug_listeners(struct libusbhp_t *handle,
385	libusbhp_hotplug_cb_fn connected_cb,
386	libusbhp_hotplug_cb_fn disconnected_cb,
387	void *user_data)
388	{
389	handle->attach = connected_cb;
390	handle->detach = disconnected_cb;
391	handle->user_data = user_data;
392	}