/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * RemoteFX USB Redirection

 *

 * Copyright 2012 Atrust corp.

 * Copyright 2012 Alfred Liu <alfred.liu@atruscorp.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <winpr/sysinfo.h>

#include <winpr/collections.h>

#include <errno.h>

#include "libusb_udevice.h"

#include "../common/urbdrc_types.h"

#define BASIC_STATE_FUNC_DEFINED(_arg, _type)             \

	static _type udev_get_##_arg(IUDEVICE* idev)          \

	{                                                     \

		UDEVICE* pdev = (UDEVICE*)idev;                   \

		return pdev->_arg;                                \

	}                                                     \

	static void udev_set_##_arg(IUDEVICE* idev, _type _t) \

	{                                                     \

		UDEVICE* pdev = (UDEVICE*)idev;                   \

		pdev->_arg = _t;                                  \

	}

#define BASIC_POINT_FUNC_DEFINED(_arg, _type)               \

	static _type udev_get_p_##_arg(IUDEVICE* idev)          \

	{                                                       \

		UDEVICE* pdev = (UDEVICE*)idev;                     \

		return pdev->_arg;                                  \

	}                                                       \

	static void udev_set_p_##_arg(IUDEVICE* idev, _type _t) \

	{                                                       \

		UDEVICE* pdev = (UDEVICE*)idev;                     \

		pdev->_arg = _t;                                    \

	}

#define BASIC_STATE_FUNC_REGISTER(_arg, _dev) \

	_dev->iface.get_##_arg = udev_get_##_arg; \

	_dev->iface.set_##_arg = udev_set_##_arg

#if LIBUSB_API_VERSION >= 0x01000103

#define HAVE_STREAM_ID_API 1

#endif

typedef struct _ASYNC_TRANSFER_USER_DATA ASYNC_TRANSFER_USER_DATA;

struct _ASYNC_TRANSFER_USER_DATA

{

	wStream* data;

	BOOL noack;

	UINT32 MessageId;

	UINT32 StartFrame;

	UINT32 ErrorCount;

	IUDEVICE* idev;

	UINT32 OutputBufferSize;

	URBDRC_CHANNEL_CALLBACK* callback;

	t_isoch_transfer_cb cb;

	wHashTable* queue;

#if !defined(HAVE_STREAM_ID_API)

	UINT32 streamID;

#endif

};

const char* usb_interface_class_to_string(uint8_t class)

{

	switch (class)

	{

		case LIBUSB_CLASS_PER_INTERFACE:

			return "LIBUSB_CLASS_PER_INTERFACE";

		case LIBUSB_CLASS_AUDIO:

			return "LIBUSB_CLASS_AUDIO";

		case LIBUSB_CLASS_COMM:

			return "LIBUSB_CLASS_COMM";

		case LIBUSB_CLASS_HID:

			return "LIBUSB_CLASS_HID";

		case LIBUSB_CLASS_PHYSICAL:

			return "LIBUSB_CLASS_PHYSICAL";

		case LIBUSB_CLASS_PRINTER:

			return "LIBUSB_CLASS_PRINTER";

		case LIBUSB_CLASS_IMAGE:

			return "LIBUSB_CLASS_IMAGE";

		case LIBUSB_CLASS_MASS_STORAGE:

			return "LIBUSB_CLASS_MASS_STORAGE";

		case LIBUSB_CLASS_HUB:

			return "LIBUSB_CLASS_HUB";

		case LIBUSB_CLASS_DATA:

			return "LIBUSB_CLASS_DATA";

		case LIBUSB_CLASS_SMART_CARD:

			return "LIBUSB_CLASS_SMART_CARD";

		case LIBUSB_CLASS_CONTENT_SECURITY:

			return "LIBUSB_CLASS_CONTENT_SECURITY";

		case LIBUSB_CLASS_VIDEO:

			return "LIBUSB_CLASS_VIDEO";

		case LIBUSB_CLASS_PERSONAL_HEALTHCARE:

			return "LIBUSB_CLASS_PERSONAL_HEALTHCARE";

		case LIBUSB_CLASS_DIAGNOSTIC_DEVICE:

			return "LIBUSB_CLASS_DIAGNOSTIC_DEVICE";

		case LIBUSB_CLASS_WIRELESS:

			return "LIBUSB_CLASS_WIRELESS";

		case LIBUSB_CLASS_APPLICATION:

			return "LIBUSB_CLASS_APPLICATION";

		case LIBUSB_CLASS_VENDOR_SPEC:

			return "LIBUSB_CLASS_VENDOR_SPEC";

		default:

			return "UNKNOWN_DEVICE_CLASS";

	}

}

static ASYNC_TRANSFER_USER_DATA* async_transfer_user_data_new(IUDEVICE* idev, UINT32 MessageId,

                                                              size_t offset, size_t BufferSize,

                                                              size_t packetSize, BOOL NoAck,

                                                              t_isoch_transfer_cb cb,

                                                              URBDRC_CHANNEL_CALLBACK* callback)

{

	ASYNC_TRANSFER_USER_DATA* user_data = calloc(1, sizeof(ASYNC_TRANSFER_USER_DATA));

	UDEVICE* pdev = (UDEVICE*)idev;

	if (!user_data)

		return NULL;

	user_data->data = Stream_New(NULL, offset + BufferSize + packetSize);

	if (!user_data->data)

	{

		free(user_data);

		return NULL;

	}

	Stream_Seek(user_data->data, offset); /* Skip header offset */

	user_data->noack = NoAck;

	user_data->cb = cb;

	user_data->callback = callback;

	user_data->idev = idev;

	user_data->MessageId = MessageId;

	user_data->OutputBufferSize = BufferSize;

	user_data->queue = pdev->request_queue;

	return user_data;

}

static void async_transfer_user_data_free(ASYNC_TRANSFER_USER_DATA* user_data)

{

	if (user_data)

	{

		Stream_Free(user_data->data, TRUE);

		free(user_data);

	}

}

static void func_iso_callback(struct libusb_transfer* transfer)

{

	ASYNC_TRANSFER_USER_DATA* user_data = (ASYNC_TRANSFER_USER_DATA*)transfer->user_data;

#if defined(HAVE_STREAM_ID_API)

	const UINT32 streamID = libusb_transfer_get_stream_id(transfer);

#else

	const UINT32 streamID = user_data->streamID;

#endif

	switch (transfer->status)

	{

		case LIBUSB_TRANSFER_COMPLETED:

		{

			int i;

			UINT32 index = 0;

			BYTE* dataStart = Stream_Pointer(user_data->data);

			Stream_SetPosition(user_data->data,

			                   40); /* TS_URB_ISOCH_TRANSFER_RESULT IsoPacket offset */

			for (i = 0; i < transfer->num_iso_packets; i++)

			{

				const UINT32 act_len = transfer->iso_packet_desc[i].actual_length;

				Stream_Write_UINT32(user_data->data, index);

				Stream_Write_UINT32(user_data->data, act_len);

				Stream_Write_UINT32(user_data->data, transfer->iso_packet_desc[i].status);

				if (transfer->iso_packet_desc[i].status != USBD_STATUS_SUCCESS)

					user_data->ErrorCount++;

				else

				{

					const unsigned char* packetBuffer =

					    libusb_get_iso_packet_buffer_simple(transfer, i);

					BYTE* data = dataStart + index;

					if (data != packetBuffer)

						memmove(data, packetBuffer, act_len);

					index += act_len;

				}

			}

		}

			/* fallthrough */

		case LIBUSB_TRANSFER_CANCELLED:

		case LIBUSB_TRANSFER_TIMED_OUT:

		case LIBUSB_TRANSFER_ERROR:

		{

			const UINT32 InterfaceId =

			    ((STREAM_ID_PROXY << 30) | user_data->idev->get_ReqCompletion(user_data->idev));

			if (HashTable_Contains(user_data->queue, (void*)(size_t)streamID))

			{

				if (!user_data->noack)

				{

					const UINT32 RequestID = streamID & INTERFACE_ID_MASK;

					user_data->cb(user_data->idev, user_data->callback, user_data->data,

					              InterfaceId, user_data->noack, user_data->MessageId, RequestID,

					              transfer->num_iso_packets, transfer->status,

					              user_data->StartFrame, user_data->ErrorCount,

					              user_data->OutputBufferSize);

					user_data->data = NULL;

				}

				HashTable_Remove(user_data->queue, (void*)(size_t)streamID);

			}

		}

		break;

		default:

			break;

	}

}

static const LIBUSB_ENDPOINT_DESCEIPTOR* func_get_ep_desc(LIBUSB_CONFIG_DESCRIPTOR* LibusbConfig,

                                                          MSUSB_CONFIG_DESCRIPTOR* MsConfig,

                                                          UINT32 EndpointAddress)

{

	BYTE alt;

	UINT32 inum, pnum;

	MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces;

	const LIBUSB_INTERFACE* interface;

	const LIBUSB_ENDPOINT_DESCEIPTOR* endpoint;

	MsInterfaces = MsConfig->MsInterfaces;

	interface = LibusbConfig->interface;

	for (inum = 0; inum < MsConfig->NumInterfaces; inum++)

	{

		alt = MsInterfaces[inum]->AlternateSetting;

		endpoint = interface[inum].altsetting[alt].endpoint;

		for (pnum = 0; pnum < MsInterfaces[inum]->NumberOfPipes; pnum++)

		{

			if (endpoint[pnum].bEndpointAddress == EndpointAddress)

			{

				return &endpoint[pnum];

			}

		}

	}

	return NULL;

}

static void func_bulk_transfer_cb(struct libusb_transfer* transfer)

{

	ASYNC_TRANSFER_USER_DATA* user_data;

	uint32_t streamID;

	user_data = (ASYNC_TRANSFER_USER_DATA*)transfer->user_data;

	if (!user_data)

	{

		WLog_ERR(TAG, "[%s]: Invalid transfer->user_data!");

		return;

	}

#if defined(HAVE_STREAM_ID_API)

	streamID = libusb_transfer_get_stream_id(transfer);

#else

	streamID = user_data->streamID;

#endif

	if (HashTable_Contains(user_data->queue, (void*)(size_t)streamID))

	{

		const UINT32 InterfaceId =

		    ((STREAM_ID_PROXY << 30) | user_data->idev->get_ReqCompletion(user_data->idev));

		const UINT32 RequestID = streamID & INTERFACE_ID_MASK;

		user_data->cb(user_data->idev, user_data->callback, user_data->data, InterfaceId,

		              user_data->noack, user_data->MessageId, RequestID, transfer->num_iso_packets,

		              transfer->status, user_data->StartFrame, user_data->ErrorCount,

		              user_data->OutputBufferSize);

		user_data->data = NULL;

		HashTable_Remove(user_data->queue, (void*)(size_t)streamID);

	}

}

static BOOL func_set_usbd_status(URBDRC_PLUGIN* urbdrc, UDEVICE* pdev, UINT32* status,

                                 int err_result)

{

	if (!urbdrc || !status)

		return FALSE;

	switch (err_result)

	{

		case LIBUSB_SUCCESS:

			*status = USBD_STATUS_SUCCESS;

			break;

		case LIBUSB_ERROR_IO:

			*status = USBD_STATUS_STALL_PID;

			break;

		case LIBUSB_ERROR_INVALID_PARAM:

			*status = USBD_STATUS_INVALID_PARAMETER;

			break;

		case LIBUSB_ERROR_ACCESS:

			*status = USBD_STATUS_NOT_ACCESSED;

			break;

		case LIBUSB_ERROR_NO_DEVICE:

			*status = USBD_STATUS_DEVICE_GONE;

			if (pdev)

			{

				if (!(pdev->status & URBDRC_DEVICE_NOT_FOUND))

					pdev->status |= URBDRC_DEVICE_NOT_FOUND;

			}

			break;

		case LIBUSB_ERROR_NOT_FOUND:

			*status = USBD_STATUS_STALL_PID;

			break;

		case LIBUSB_ERROR_BUSY:

			*status = USBD_STATUS_STALL_PID;

			break;

		case LIBUSB_ERROR_TIMEOUT:

			*status = USBD_STATUS_TIMEOUT;

			break;

		case LIBUSB_ERROR_OVERFLOW:

			*status = USBD_STATUS_STALL_PID;

			break;

		case LIBUSB_ERROR_PIPE:

			*status = USBD_STATUS_STALL_PID;

			break;

		case LIBUSB_ERROR_INTERRUPTED:

			*status = USBD_STATUS_STALL_PID;

			break;

		case LIBUSB_ERROR_NO_MEM:

			*status = USBD_STATUS_NO_MEMORY;

			break;

		case LIBUSB_ERROR_NOT_SUPPORTED:

			*status = USBD_STATUS_NOT_SUPPORTED;

			break;

		case LIBUSB_ERROR_OTHER:

			*status = USBD_STATUS_STALL_PID;

			break;

		default:

			*status = USBD_STATUS_SUCCESS;

			break;

	}

	return TRUE;

}

static int func_config_release_all_interface(URBDRC_PLUGIN* urbdrc,

                                             LIBUSB_DEVICE_HANDLE* libusb_handle,

                                             UINT32 NumInterfaces)

{

	UINT32 i;

	for (i = 0; i < NumInterfaces; i++)

	{

		int ret = libusb_release_interface(libusb_handle, i);

		if (ret < 0)

		{

			WLog_Print(urbdrc->log, WLOG_ERROR, "config_release_all_interface: error num %d", ret);

			return -1;

		}

	}

	return 0;

}

static int func_claim_all_interface(URBDRC_PLUGIN* urbdrc, LIBUSB_DEVICE_HANDLE* libusb_handle,

                                    int NumInterfaces)

{

	int i, ret;

	for (i = 0; i < NumInterfaces; i++)

	{

		ret = libusb_claim_interface(libusb_handle, i);

		if (ret < 0)

		{

			WLog_Print(urbdrc->log, WLOG_ERROR, "claim_all_interface: error num %d", ret);

			return -1;

		}

	}

	return 0;

}

static LIBUSB_DEVICE* udev_get_libusb_dev(libusb_context* context, uint8_t bus_number,

                                          uint8_t dev_number)

{

	ssize_t i, total_device;

	LIBUSB_DEVICE** libusb_list;

	LIBUSB_DEVICE* device = NULL;

	total_device = libusb_get_device_list(context, &libusb_list);

	for (i = 0; i < total_device; i++)

	{

		uint8_t cbus = libusb_get_bus_number(libusb_list[i]);

		uint8_t caddr = libusb_get_device_address(libusb_list[i]);

		if ((bus_number == cbus) && (dev_number == caddr))

		{

			device = libusb_list[i];

			break;

		}

	}

	libusb_free_device_list(libusb_list, 1);

	return device;

}

static LIBUSB_DEVICE_DESCRIPTOR* udev_new_descript(URBDRC_PLUGIN* urbdrc, LIBUSB_DEVICE* libusb_dev)

{

	int ret;

	LIBUSB_DEVICE_DESCRIPTOR* descriptor;

	descriptor = (LIBUSB_DEVICE_DESCRIPTOR*)malloc(sizeof(LIBUSB_DEVICE_DESCRIPTOR));

	ret = libusb_get_device_descriptor(libusb_dev, descriptor);

	if (ret < 0)

	{

		WLog_Print(urbdrc->log, WLOG_ERROR, "libusb_get_device_descriptor: error %s [%d]",

		           libusb_error_name(ret), ret);

		free(descriptor);

		return NULL;

	}

	return descriptor;

}

static int libusb_udev_select_interface(IUDEVICE* idev, BYTE InterfaceNumber, BYTE AlternateSetting)

{

	int error = 0, diff = 1;

	UDEVICE* pdev = (UDEVICE*)idev;

	URBDRC_PLUGIN* urbdrc;

	MSUSB_CONFIG_DESCRIPTOR* MsConfig;

	MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces;

	if (!pdev || !pdev->urbdrc)

		return -1;

	urbdrc = pdev->urbdrc;

	MsConfig = pdev->MsConfig;

	if (MsConfig)

	{

		MsInterfaces = MsConfig->MsInterfaces;

		if ((MsInterfaces) && (MsInterfaces[InterfaceNumber]->AlternateSetting == AlternateSetting))

		{

			diff = 0;

		}

	}

	if (diff)

	{

		error = libusb_set_interface_alt_setting(pdev->libusb_handle, InterfaceNumber,

		                                         AlternateSetting);

		if (error < 0)

		{

			WLog_Print(urbdrc->log, WLOG_ERROR, "Set interface altsetting get error num %d", error);

		}

	}

	return error;

}

static MSUSB_CONFIG_DESCRIPTOR*

libusb_udev_complete_msconfig_setup(IUDEVICE* idev, MSUSB_CONFIG_DESCRIPTOR* MsConfig)

{

	UDEVICE* pdev = (UDEVICE*)idev;

	MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces;

	MSUSB_INTERFACE_DESCRIPTOR* MsInterface;

	MSUSB_PIPE_DESCRIPTOR** MsPipes;

	MSUSB_PIPE_DESCRIPTOR* MsPipe;

	MSUSB_PIPE_DESCRIPTOR** t_MsPipes;

	MSUSB_PIPE_DESCRIPTOR* t_MsPipe;

	LIBUSB_CONFIG_DESCRIPTOR* LibusbConfig;

	const LIBUSB_INTERFACE* LibusbInterface;

	const LIBUSB_INTERFACE_DESCRIPTOR* LibusbAltsetting;

	const LIBUSB_ENDPOINT_DESCEIPTOR* LibusbEndpoint;

	BYTE LibusbNumEndpoint;

	URBDRC_PLUGIN* urbdrc;

	UINT32 inum = 0, pnum = 0, MsOutSize = 0;

	if (!pdev || !pdev->LibusbConfig || !pdev->urbdrc || !MsConfig)

		return NULL;

	urbdrc = pdev->urbdrc;

	LibusbConfig = pdev->LibusbConfig;

	if (LibusbConfig->bNumInterfaces != MsConfig->NumInterfaces)

	{

		WLog_Print(urbdrc->log, WLOG_ERROR,

		           "Select Configuration: Libusb NumberInterfaces(%" PRIu8 ") is different "

		           "with MsConfig NumberInterfaces(%" PRIu32 ")",

		           LibusbConfig->bNumInterfaces, MsConfig->NumInterfaces);

	}

	/* replace MsPipes for libusb */

	MsInterfaces = MsConfig->MsInterfaces;

	for (inum = 0; inum < MsConfig->NumInterfaces; inum++)

	{

		MsInterface = MsInterfaces[inum];

		/* get libusb's number of endpoints */

		LibusbInterface = &LibusbConfig->interface[MsInterface->InterfaceNumber];

		LibusbAltsetting = &LibusbInterface->altsetting[MsInterface->AlternateSetting];

		LibusbNumEndpoint = LibusbAltsetting->bNumEndpoints;

		t_MsPipes =

		    (MSUSB_PIPE_DESCRIPTOR**)calloc(LibusbNumEndpoint, sizeof(MSUSB_PIPE_DESCRIPTOR*));

		for (pnum = 0; pnum < LibusbNumEndpoint; pnum++)

		{

			t_MsPipe = (MSUSB_PIPE_DESCRIPTOR*)malloc(sizeof(MSUSB_PIPE_DESCRIPTOR));

			memset(t_MsPipe, 0, sizeof(MSUSB_PIPE_DESCRIPTOR));

			if (pnum < MsInterface->NumberOfPipes && MsInterface->MsPipes)

			{

				MsPipe = MsInterface->MsPipes[pnum];

				t_MsPipe->MaximumPacketSize = MsPipe->MaximumPacketSize;

				t_MsPipe->MaximumTransferSize = MsPipe->MaximumTransferSize;

				t_MsPipe->PipeFlags = MsPipe->PipeFlags;

			}

			else

			{

				t_MsPipe->MaximumPacketSize = 0;

				t_MsPipe->MaximumTransferSize = 0xffffffff;

				t_MsPipe->PipeFlags = 0;

			}

			t_MsPipe->PipeHandle = 0;

			t_MsPipe->bEndpointAddress = 0;

			t_MsPipe->bInterval = 0;

			t_MsPipe->PipeType = 0;

			t_MsPipe->InitCompleted = 0;

			t_MsPipes[pnum] = t_MsPipe;

		}

		msusb_mspipes_replace(MsInterface, t_MsPipes, LibusbNumEndpoint);

	}

	/* setup configuration */

	MsOutSize = 8;

	/* ConfigurationHandle:  4 bytes

	 * ---------------------------------------------------------------

	 * ||<<< 1 byte >>>|<<< 1 byte >>>|<<<<<<<<<< 2 byte >>>>>>>>>>>||

	 * ||  bus_number  |  dev_number  |      bConfigurationValue    ||

	 * ---------------------------------------------------------------

	 * ***********************/

	MsConfig->ConfigurationHandle =

	    MsConfig->bConfigurationValue | (pdev->bus_number << 24) | (pdev->dev_number << 16);

	MsInterfaces = MsConfig->MsInterfaces;

	for (inum = 0; inum < MsConfig->NumInterfaces; inum++)

	{

		MsOutSize += 16;

		MsInterface = MsInterfaces[inum];

		/* get libusb's interface */

		LibusbInterface = &LibusbConfig->interface[MsInterface->InterfaceNumber];

		LibusbAltsetting = &LibusbInterface->altsetting[MsInterface->AlternateSetting];

		/* InterfaceHandle:  4 bytes

		 * ---------------------------------------------------------------

		 * ||<<< 1 byte >>>|<<< 1 byte >>>|<<< 1 byte >>>|<<< 1 byte >>>||

		 * ||  bus_number  |  dev_number  |  altsetting  | interfaceNum ||

		 * ---------------------------------------------------------------

		 * ***********************/

		MsInterface->InterfaceHandle = LibusbAltsetting->bInterfaceNumber |

		                               (LibusbAltsetting->bAlternateSetting << 8) |

		                               (pdev->dev_number << 16) | (pdev->bus_number << 24);

		MsInterface->Length = 16 + (MsInterface->NumberOfPipes * 20);

		MsInterface->bInterfaceClass = LibusbAltsetting->bInterfaceClass;

		MsInterface->bInterfaceSubClass = LibusbAltsetting->bInterfaceSubClass;

		MsInterface->bInterfaceProtocol = LibusbAltsetting->bInterfaceProtocol;

		MsInterface->InitCompleted = 1;

		MsPipes = MsInterface->MsPipes;

		LibusbNumEndpoint = LibusbAltsetting->bNumEndpoints;

		for (pnum = 0; pnum < LibusbNumEndpoint; pnum++)

		{

			MsOutSize += 20;

			MsPipe = MsPipes[pnum];

			/* get libusb's endpoint */

			LibusbEndpoint = &LibusbAltsetting->endpoint[pnum];

			/* PipeHandle:  4 bytes

			 * ---------------------------------------------------------------

			 * ||<<< 1 byte >>>|<<< 1 byte >>>|<<<<<<<<<< 2 byte >>>>>>>>>>>||

			 * ||  bus_number  |  dev_number  |      bEndpointAddress       ||

			 * ---------------------------------------------------------------

			 * ***********************/

			MsPipe->PipeHandle = LibusbEndpoint->bEndpointAddress | (pdev->dev_number << 16) |

			                     (pdev->bus_number << 24);

			/* count endpoint max packet size */

			int max = LibusbEndpoint->wMaxPacketSize & 0x07ff;

			BYTE attr = LibusbEndpoint->bmAttributes;

			if ((attr & 0x3) == 1 || (attr & 0x3) == 3)

			{

				max *= (1 + ((LibusbEndpoint->wMaxPacketSize >> 11) & 3));

			}

			MsPipe->MaximumPacketSize = max;

			MsPipe->bEndpointAddress = LibusbEndpoint->bEndpointAddress;

			MsPipe->bInterval = LibusbEndpoint->bInterval;

			MsPipe->PipeType = attr & 0x3;

			MsPipe->InitCompleted = 1;

		}

	}

	MsConfig->MsOutSize = MsOutSize;

	MsConfig->InitCompleted = 1;

	/* replace device's MsConfig */

	if (MsConfig != pdev->MsConfig)

	{

		msusb_msconfig_free(pdev->MsConfig);

		pdev->MsConfig = MsConfig;

	}

	return MsConfig;

}

static int libusb_udev_select_configuration(IUDEVICE* idev, UINT32 bConfigurationValue)

{

	UDEVICE* pdev = (UDEVICE*)idev;

	MSUSB_CONFIG_DESCRIPTOR* MsConfig;

	LIBUSB_DEVICE_HANDLE* libusb_handle;

	LIBUSB_DEVICE* libusb_dev;

	URBDRC_PLUGIN* urbdrc;

	LIBUSB_CONFIG_DESCRIPTOR** LibusbConfig;

	int ret = 0;

	if (!pdev || !pdev->MsConfig || !pdev->LibusbConfig || !pdev->urbdrc)

		return -1;

	urbdrc = pdev->urbdrc;

	MsConfig = pdev->MsConfig;

	libusb_handle = pdev->libusb_handle;

	libusb_dev = pdev->libusb_dev;

	LibusbConfig = &pdev->LibusbConfig;

	if (MsConfig->InitCompleted)

	{

		func_config_release_all_interface(pdev->urbdrc, libusb_handle,

		                                  (*LibusbConfig)->bNumInterfaces);

	}

	/* The configuration value -1 is mean to put the device in unconfigured state. */

	if (bConfigurationValue == 0)

		ret = libusb_set_configuration(libusb_handle, -1);

	else

		ret = libusb_set_configuration(libusb_handle, bConfigurationValue);

	if (ret < 0)

	{

		WLog_Print(urbdrc->log, WLOG_ERROR, "libusb_set_configuration: error %s [%d]",

		           libusb_error_name(ret), ret);

		func_claim_all_interface(urbdrc, libusb_handle, (*LibusbConfig)->bNumInterfaces);

		return -1;

	}

	else

	{

		ret = libusb_get_active_config_descriptor(libusb_dev, LibusbConfig);

		if (ret < 0)

		{

			WLog_Print(urbdrc->log, WLOG_ERROR, "libusb_set_configuration: error %s [%d]",

			           libusb_error_name(ret), ret);

			func_claim_all_interface(urbdrc, libusb_handle, (*LibusbConfig)->bNumInterfaces);

			return -1;

		}

	}

	func_claim_all_interface(urbdrc, libusb_handle, (*LibusbConfig)->bNumInterfaces);

	return 0;

}

static int libusb_udev_control_pipe_request(IUDEVICE* idev, UINT32 RequestId,

                                            UINT32 EndpointAddress, UINT32* UsbdStatus, int command)

{

	int error = 0;

	UDEVICE* pdev = (UDEVICE*)idev;

	/*

	pdev->request_queue->register_request(pdev->request_queue, RequestId, NULL, 0);

	*/

	switch (command)

	{

		case PIPE_CANCEL:

			/** cancel bulk or int transfer */

			idev->cancel_all_transfer_request(idev);

			// dummy_wait_s_obj(1);

			/** set feature to ep (set halt)*/

			error = libusb_control_transfer(

			    pdev->libusb_handle, LIBUSB_ENDPOINT_OUT | LIBUSB_RECIPIENT_ENDPOINT,

			    LIBUSB_REQUEST_SET_FEATURE, ENDPOINT_HALT, EndpointAddress, NULL, 0, 1000);

			break;

		case PIPE_RESET:

			idev->cancel_all_transfer_request(idev);

			error = libusb_clear_halt(pdev->libusb_handle, EndpointAddress);

			// func_set_usbd_status(pdev, UsbdStatus, error);

			break;

		default:

			error = -0xff;

			break;

	}

	*UsbdStatus = 0;

	return error;

}

static UINT32 libusb_udev_control_query_device_text(IUDEVICE* idev, UINT32 TextType,

                                                    UINT16 LocaleId, UINT8* BufferSize,

                                                    BYTE* Buffer)

{

	UDEVICE* pdev = (UDEVICE*)idev;

	LIBUSB_DEVICE_DESCRIPTOR* devDescriptor;

	const char* strDesc = "Generic Usb String";

	char deviceLocation[25] = { 0 };

	BYTE bus_number;

	BYTE device_address;

	int ret = 0;

	size_t i, len;

	URBDRC_PLUGIN* urbdrc;

	WCHAR* text = (WCHAR*)Buffer;

	BYTE slen, locale;

	const UINT8 inSize = *BufferSize;

	*BufferSize = 0;

	if (!pdev || !pdev->devDescriptor || !pdev->urbdrc)

		return ERROR_INVALID_DATA;

	urbdrc = pdev->urbdrc;

	devDescriptor = pdev->devDescriptor;

	switch (TextType)

	{

		case DeviceTextDescription:

		{

			BYTE data[0x100] = { 0 };

			ret = libusb_get_string_descriptor(pdev->libusb_handle, devDescriptor->iProduct,

			                                   LocaleId, data, 0xFF);

			/* The returned data in the buffer is:

			 * 1 byte  length of following data

			 * 1 byte  descriptor type, must be 0x03 for strings

			 * n WCHAR unicode string (of length / 2 characters) including '\0'

			 */

			slen = data[0];

			locale = data[1];

			if ((ret <= 0) || (ret < 4) || (slen < 4) || (locale != LIBUSB_DT_STRING) ||

			    (ret > UINT8_MAX))

			{

				WLog_Print(urbdrc->log, WLOG_DEBUG,

				           "libusb_get_string_descriptor: "

				           "ERROR num %d, iProduct: %" PRIu8 "!",

				           ret, devDescriptor->iProduct);

				len = MIN(sizeof(strDesc), inSize);

				for (i = 0; i < len; i++)

					text[i] = (WCHAR)strDesc[i];

				*BufferSize = (BYTE)(len * 2);

			}

			else

			{

				/* ret and slen should be equals, but you never know creativity

				 * of device manufacturers...

				 * So also check the string length returned as server side does

				 * not honor strings with multi '\0' characters well.

				 */

				const size_t rchar = _wcsnlen((WCHAR*)&data[2], sizeof(data) / 2);

				len = MIN((BYTE)ret, slen);

				len = MIN(len, inSize);

				len = MIN(len, rchar * 2 + sizeof(WCHAR));

				memcpy(Buffer, &data[2], len);

				/* Just as above, the returned WCHAR string should be '\0'

				 * terminated, but never trust hardware to conform to specs... */

				Buffer[len - 2] = '\0';

				Buffer[len - 1] = '\0';

				*BufferSize = (BYTE)len;

			}

		}

		break;

		case DeviceTextLocationInformation:

			bus_number = libusb_get_bus_number(pdev->libusb_dev);

			device_address = libusb_get_device_address(pdev->libusb_dev);

			sprintf_s(deviceLocation, sizeof(deviceLocation),

			          "Port_#%04" PRIu8 ".Hub_#%04" PRIu8 "", device_address, bus_number);

			len = strnlen(deviceLocation, MIN(sizeof(deviceLocation), inSize - 1));

			for (i = 0; i < len; i++)

				text[i] = (WCHAR)deviceLocation[i];

			text[len++] = '\0';

			*BufferSize = (UINT8)(len * sizeof(WCHAR));

			break;

		default:

			WLog_Print(urbdrc->log, WLOG_DEBUG, "Query Text: unknown TextType %" PRIu32 "",

			           TextType);

			return ERROR_INVALID_DATA;

	}

	return S_OK;

}

static int libusb_udev_os_feature_descriptor_request(IUDEVICE* idev, UINT32 RequestId,

                                                     BYTE Recipient, BYTE InterfaceNumber,

                                                     BYTE Ms_PageIndex, UINT16 Ms_featureDescIndex,

                                                     UINT32* UsbdStatus, UINT32* BufferSize,

                                                     BYTE* Buffer, int Timeout)

{

	UDEVICE* pdev = (UDEVICE*)idev;

	BYTE ms_string_desc[0x13];

	int error = 0;

	/*

	pdev->request_queue->register_request(pdev->request_queue, RequestId, NULL, 0);

	*/

	memset(ms_string_desc, 0, 0x13);

	error = libusb_control_transfer(pdev->libusb_handle, LIBUSB_ENDPOINT_IN | Recipient,

	                                LIBUSB_REQUEST_GET_DESCRIPTOR, 0x03ee, 0, ms_string_desc, 0x12,

	                                Timeout);

	// WLog_Print(urbdrc->log, WLOG_ERROR,  "Get ms string: result number %d", error);

	if (error > 0)

	{

		const BYTE bMS_Vendorcode = ms_string_desc[16];

		// WLog_Print(urbdrc->log, WLOG_ERROR,  "bMS_Vendorcode:0x%x", bMS_Vendorcode);

		/** get os descriptor */

		error = libusb_control_transfer(pdev->libusb_handle,

		                                LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | Recipient,

		                                bMS_Vendorcode, (InterfaceNumber << 8) | Ms_PageIndex,

		                                Ms_featureDescIndex, Buffer, *BufferSize, Timeout);

		*BufferSize = error;

	}

	if (error < 0)

		*UsbdStatus = USBD_STATUS_STALL_PID;

	else