[deb_libcec.git] / src / lib / adapter / Pulse-Eight / USBCECAdapterDetection.cpp

/*
 * This file is part of the libCEC(R) library.
 *
 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited.  All rights reserved.
 * libCEC(R) is an original work, containing original code.
 *
 * libCEC(R) is a trademark of Pulse-Eight Limited.
 *
 * This program is dual-licensed; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 *
 * Alternatively, you can license this library under a commercial license,
 * please contact Pulse-Eight Licensing for more information.
 *
 * For more information contact:
 * Pulse-Eight Licensing       <license@pulse-eight.com>
 *     http://www.pulse-eight.com/
 *     http://www.pulse-eight.net/
 */

#include "env.h"
#include "USBCECAdapterDetection.h"
#include "lib/platform/util/StdString.h"

#if defined(__APPLE__)
#include <dirent.h>
#include <sys/param.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOCFPlugIn.h>
#include <IOKit/usb/IOUSBLib.h>
#include <IOKit/serial/IOSerialKeys.h>
#include <CoreFoundation/CoreFoundation.h>
#elif defined(__WINDOWS__)
#pragma comment(lib, "advapi32.lib")
#pragma comment(lib, "setupapi.lib")
#pragma comment(lib, "cfgmgr32.lib")
#include <setupapi.h>
#include <cfgmgr32.h>

// the virtual COM port only shows up when requesting devices with the raw device guid!
static GUID USB_RAW_GUID = { 0xA5DCBF10, 0x6530, 0x11D2, { 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED } };
static GUID USB_CDC_GUID = { 0x4D36E978, 0xE325, 0x11CE, { 0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18 } };

#elif defined(HAVE_LIBUDEV)
#include <dirent.h>
#include <poll.h>
extern "C" {
#include <libudev.h>
}
#elif defined(__FreeBSD__)
#include <stdio.h>
#include <unistd.h>
#endif

#define CEC_VID  0x2548
#define CEC_PID  0x1001
#define CEC_PID2 0x1002

using namespace CEC;
using namespace std;

#if defined(HAVE_LIBUDEV)
bool TranslateComPort(CStdString &strString)
{
  CStdString strTmp(strString);
  strTmp.MakeReverse();
  int iSlash = strTmp.Find('/');
  if (iSlash >= 0)
  {
    strTmp = strTmp.Left(iSlash);
    strTmp.MakeReverse();
    strString.Format("%s/%s:1.0/tty", strString.c_str(), strTmp.c_str());
    return true;
  }

  return false;
}

bool FindComPort(CStdString &strLocation)
{
  CStdString strPort = strLocation;
  bool bReturn(!strPort.IsEmpty());
  CStdString strConfigLocation(strLocation);
  if (TranslateComPort(strConfigLocation))
  {
    DIR *dir;
    struct dirent *dirent;
    if((dir = opendir(strConfigLocation.c_str())) == NULL)
      return bReturn;

    while ((dirent = readdir(dir)) != NULL)
    {
      if(strcmp((char*)dirent->d_name, "." ) != 0 && strcmp((char*)dirent->d_name, ".." ) != 0)
      {
        strPort.Format("/dev/%s", dirent->d_name);
        if (!strPort.IsEmpty())
        {
          strLocation = strPort;
          bReturn = true;
          break;
        }
      }
    }
    closedir(dir);
  }

  return bReturn;
}
#endif

bool CUSBCECAdapterDetection::CanAutodetect(void)
{
#if defined(__APPLE__) || defined(HAVE_LIBUDEV) || defined(__WINDOWS__) || defined(__FreeBSD__)
  return true;
#else
  return false;
#endif
}

#if defined(__WINDOWS__)
static bool GetComPortFromHandle(HDEVINFO hDevHandle, PSP_DEVINFO_DATA devInfoData, char* strPortName, unsigned int iSize)
{
  bool bReturn(false);
  TCHAR strRegPortName[256];
  strRegPortName[0] = _T('\0');
  DWORD dwSize = sizeof(strRegPortName);
  DWORD dwType = 0;

  HKEY hDeviceKey = SetupDiOpenDevRegKey(hDevHandle, devInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
  if (!hDeviceKey)
    return bReturn;

  // locate the PortName
  if ((RegQueryValueEx(hDeviceKey, _T("PortName"), NULL, &dwType, reinterpret_cast<LPBYTE>(strRegPortName), &dwSize) == ERROR_SUCCESS) &&
      (dwType == REG_SZ) &&
      _tcslen(strRegPortName) > 3 &&
      _tcsnicmp(strRegPortName, _T("COM"), 3) == 0 &&
      _ttoi(&(strRegPortName[3])) > 0)
  {
    // return the port name
    snprintf(strPortName, iSize, "%s", strRegPortName);
    bReturn = true;
  }

  RegCloseKey(hDeviceKey);

  return bReturn;
}

static bool FindComPortForComposite(const char* strLocation, char* strPortName, unsigned int iSize)
{
  bool bReturn(false);

  // find all devices of the CDC class
  HDEVINFO hDevHandle = SetupDiGetClassDevs(&USB_CDC_GUID, NULL, NULL, DIGCF_PRESENT);
  if (hDevHandle == INVALID_HANDLE_VALUE)
    return bReturn;

  // check all devices, whether they match the location or not
  char strId[512];
  bool bGetNext(true);
  for (int iPtr = 0; !bReturn && bGetNext && iPtr < 1024 ; iPtr++)
  {
    strId[0] = 0;

    SP_DEVINFO_DATA devInfoData;
    devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

    // no more devices
    if (!SetupDiEnumDeviceInfo(hDevHandle, iPtr, &devInfoData))
      bGetNext = false;
    else
    {
      // check if the location of the _parent_ device matches
      DEVINST parentDevInst;
      if (CM_Get_Parent(&parentDevInst, devInfoData.DevInst, 0) == CR_SUCCESS)
      {
        CM_Get_Device_ID(parentDevInst, strId, 512, 0);

        // match
        if (!strncmp(strId, strLocation, strlen(strLocation)))
          bReturn = GetComPortFromHandle(hDevHandle, &devInfoData, strPortName, iSize);
      }
    }
  }

  SetupDiDestroyDeviceInfoList(hDevHandle);
  return bReturn;
}
#endif

uint8_t CUSBCECAdapterDetection::FindAdapters(cec_adapter *deviceList, uint8_t iBufSize, const char *strDevicePath /* = NULL */)
{
  uint8_t iFound(0);

#if defined(__APPLE__)
  kern_return_t	kresult;
  char bsdPath[MAXPATHLEN] = {0};
  io_iterator_t	serialPortIterator;

  CFMutableDictionaryRef classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
  if (classesToMatch)
  {
    CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDModemType));
    kresult = IOServiceGetMatchingServices(kIOMasterPortDefault, classesToMatch, &serialPortIterator);    
    if (kresult == KERN_SUCCESS)
    {
      io_object_t serialService;
      while ((serialService = IOIteratorNext(serialPortIterator)))
      {
        int iVendor = 0, iProduct = 0;
        CFTypeRef	bsdPathAsCFString;

        // fetch the device path.
        bsdPathAsCFString = IORegistryEntryCreateCFProperty(serialService,
          CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
        if (bsdPathAsCFString)
        {
          // convert the path from a CFString to a C (NUL-terminated) string.
          CFStringGetCString((CFStringRef)bsdPathAsCFString, bsdPath, MAXPATHLEN - 1, kCFStringEncodingUTF8);
          CFRelease(bsdPathAsCFString);
          
          // now walk up the hierarchy until we find the entry with vendor/product IDs
          io_registry_entry_t parent;
          CFTypeRef vendorIdAsCFNumber  = NULL;
          CFTypeRef productIdAsCFNumber = NULL;
          kern_return_t kresult = IORegistryEntryGetParentEntry(serialService, kIOServicePlane, &parent);
          while (kresult == KERN_SUCCESS)
          {
            vendorIdAsCFNumber  = IORegistryEntrySearchCFProperty(parent,
              kIOServicePlane, CFSTR(kUSBVendorID),  kCFAllocatorDefault, 0);
            productIdAsCFNumber = IORegistryEntrySearchCFProperty(parent,
              kIOServicePlane, CFSTR(kUSBProductID), kCFAllocatorDefault, 0);
            if (vendorIdAsCFNumber && productIdAsCFNumber)
            {
              CFNumberGetValue((CFNumberRef)vendorIdAsCFNumber, kCFNumberIntType, &iVendor);
              CFRelease(vendorIdAsCFNumber);
              CFNumberGetValue((CFNumberRef)productIdAsCFNumber, kCFNumberIntType, &iProduct);
              CFRelease(productIdAsCFNumber);
              IOObjectRelease(parent);
              break;
            }
            io_registry_entry_t oldparent = parent;
            kresult = IORegistryEntryGetParentEntry(parent, kIOServicePlane, &parent);
            IOObjectRelease(oldparent);
          }
          if (strlen(bsdPath) && iVendor == CEC_VID && (iProduct == CEC_PID || iProduct == CEC_PID2))
          {
            if (!strDevicePath || !strcmp(bsdPath, strDevicePath))
            {
              // on darwin, the device path is the same as the comm path.
              if (iFound == 0 || strcmp(deviceList[iFound-1].comm, bsdPath))
              {
                snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", bsdPath);
                snprintf(deviceList[iFound].comm, sizeof(deviceList[iFound].path), "%s", bsdPath);
                iFound++;
              }
            }
          }
        }
        IOObjectRelease(serialService);
      }
    }
    IOObjectRelease(serialPortIterator);
  }
#elif defined(HAVE_LIBUDEV)
  struct udev *udev;
  if (!(udev = udev_new()))
    return -1;

  struct udev_enumerate *enumerate;
  struct udev_list_entry *devices, *dev_list_entry;
  struct udev_device *dev, *pdev;
  enumerate = udev_enumerate_new(udev);
  udev_enumerate_scan_devices(enumerate);
  devices = udev_enumerate_get_list_entry(enumerate);
  udev_list_entry_foreach(dev_list_entry, devices)
  {
    const char *strPath;
    strPath = udev_list_entry_get_name(dev_list_entry);

    dev = udev_device_new_from_syspath(udev, strPath);
    if (!dev)
      continue;

    pdev = udev_device_get_parent(udev_device_get_parent(dev));
    if (!pdev || !udev_device_get_sysattr_value(pdev,"idVendor") || !udev_device_get_sysattr_value(pdev, "idProduct"))
    {
      udev_device_unref(dev);
      continue;
    }

    int iVendor, iProduct;
    sscanf(udev_device_get_sysattr_value(pdev, "idVendor"), "%x", &iVendor);
    sscanf(udev_device_get_sysattr_value(pdev, "idProduct"), "%x", &iProduct);
    if (iVendor == CEC_VID && (iProduct == CEC_PID || iProduct == CEC_PID2))
    {
      CStdString strPath(udev_device_get_syspath(pdev));
      if (!strDevicePath || !strcmp(strPath.c_str(), strDevicePath))
      {
        CStdString strComm(strPath);
        if (FindComPort(strComm) && (iFound == 0 || strcmp(deviceList[iFound-1].comm, strComm.c_str())))
        {
          snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", strPath.c_str());
          snprintf(deviceList[iFound].comm, sizeof(deviceList[iFound].path), "%s", strComm.c_str());
          iFound++;
        }
      }
    }
    udev_device_unref(dev);
  }

  udev_enumerate_unref(enumerate);
  udev_unref(udev);
#elif defined(__WINDOWS__)
  HDEVINFO hDevHandle;
  DWORD    required = 0, iMemberIndex = 0;
  int      nBufferSize = 0;

  SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
  deviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);

  SP_DEVINFO_DATA devInfoData;
  devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

  // find all devices
  if ((hDevHandle = SetupDiGetClassDevs(&USB_RAW_GUID, 0, 0, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE)) == INVALID_HANDLE_VALUE)
    return iFound;

  BOOL bResult = true;
  TCHAR *buffer = NULL;
  PSP_DEVICE_INTERFACE_DETAIL_DATA devicedetailData;
  while(bResult && iFound < iBufSize)
  {
    bResult = SetupDiEnumDeviceInfo(hDevHandle, iMemberIndex, &devInfoData);

    if (bResult)
      bResult = SetupDiEnumDeviceInterfaces(hDevHandle, 0, &USB_RAW_GUID, iMemberIndex, &deviceInterfaceData);

    if(!bResult)
    {
      // no (more) results
      SetupDiDestroyDeviceInfoList(hDevHandle);
      delete []buffer;
      buffer = NULL;
      return iFound;
    }

    iMemberIndex++;
    BOOL bDetailResult = false;
    {
      // As per MSDN, Get the required buffer size. Call SetupDiGetDeviceInterfaceDetail with a 
      // NULL DeviceInterfaceDetailData pointer, a DeviceInterfaceDetailDataSize of zero, 
      // and a valid RequiredSize variable. In response to such a call, this function returns 
      // the required buffer size at RequiredSize and fails with GetLastError returning 
      // ERROR_INSUFFICIENT_BUFFER. 
      // Allocate an appropriately sized buffer and call the function again to get the interface details. 

      SetupDiGetDeviceInterfaceDetail(hDevHandle, &deviceInterfaceData, NULL, 0, &required, NULL);

      buffer = new TCHAR[required];
      devicedetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) buffer;
      devicedetailData->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
      nBufferSize = required;
    }

    bDetailResult = SetupDiGetDeviceInterfaceDetail(hDevHandle, &deviceInterfaceData, devicedetailData, nBufferSize , &required, NULL);
    if(!bDetailResult)
      continue;

    // check whether the path matches, if a path was given
    if (strDevicePath && strcmp(strDevicePath, devicedetailData->DevicePath) != 0)
      continue;

    // get the vid and pid
    CStdString strVendorId;
    CStdString strProductId;
    CStdString strTmp(devicedetailData->DevicePath);
    strVendorId.assign(strTmp.substr(strTmp.Find("vid_") + 4, 4));
    strProductId.assign(strTmp.substr(strTmp.Find("pid_") + 4, 4));
    if (strTmp.Find("&mi_") >= 0 && strTmp.Find("&mi_00") < 0)
      continue;

    int iVendor, iProduct;
    sscanf(strVendorId, "%x", &iVendor);
    sscanf(strProductId, "%x", &iProduct);

    // no match
    if (iVendor != CEC_VID || (iProduct != CEC_PID && iProduct != CEC_PID2))
      continue;


    if (iProduct == CEC_PID2)
    {
      // the 1002 pid indicates a composite device, that needs special treatment
      char strId[512];
      CM_Get_Device_ID(devInfoData.DevInst, strId, 512, 0);
      if (FindComPortForComposite(strId, deviceList[iFound].comm, sizeof(deviceList[iFound].comm)))
      {
        snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", devicedetailData->DevicePath);
        iFound++;
      }
    }
    else if (GetComPortFromHandle(hDevHandle, &devInfoData, deviceList[iFound].comm, sizeof(deviceList[iFound].comm)))
    {
      snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", devicedetailData->DevicePath);
      iFound++;
    }
  }
#elif defined(__FreeBSD__)
  char devicePath[PATH_MAX + 1];
  int i;

  for (i = 0; i < 8; ++i)
  {
    (void)snprintf(devicePath, sizeof(devicePath), "/dev/ttyU%d", i);
    if (!access(devicePath, 0))
    {
      snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", devicePath);
      snprintf(deviceList[iFound].comm, sizeof(deviceList[iFound].path), "%s", devicePath);
      iFound++;
    }
  }
#else
  //silence "unused" warnings
  void *tmp = (void*)deviceList;
  tmp = (void *)strDevicePath;
#endif

  iBufSize = 0; if(!iBufSize){} /* silence "unused" warning on linux/osx */

  return iFound;
}
Commit	Line	Data
	1	/*
	2	* This file is part of the libCEC(R) library.
	3	*
	4	* libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
	5	* libCEC(R) is an original work, containing original code.
	6	*
	7	* libCEC(R) is a trademark of Pulse-Eight Limited.
	8	*
	9	* This program is dual-licensed; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	22	*
	23	*
	24	* Alternatively, you can license this library under a commercial license,
	25	* please contact Pulse-Eight Licensing for more information.
	26	*
	27	* For more information contact:
	28	* Pulse-Eight Licensing <license@pulse-eight.com>
	29	* http://www.pulse-eight.com/
	30	* http://www.pulse-eight.net/
	31	*/
	32
	33	#include "env.h"
	34	#include "USBCECAdapterDetection.h"
	35	#include "lib/platform/util/StdString.h"
	36
	37	#if defined(__APPLE__)
	38	#include <dirent.h>
	39	#include <sys/param.h>
	40	#include <IOKit/IOKitLib.h>
	41	#include <IOKit/IOMessage.h>
	42	#include <IOKit/IOCFPlugIn.h>
	43	#include <IOKit/usb/IOUSBLib.h>
	44	#include <IOKit/serial/IOSerialKeys.h>
	45	#include <CoreFoundation/CoreFoundation.h>
	46	#elif defined(__WINDOWS__)
	47	#pragma comment(lib, "advapi32.lib")
	48	#pragma comment(lib, "setupapi.lib")
	49	#pragma comment(lib, "cfgmgr32.lib")
	50	#include <setupapi.h>
	51	#include <cfgmgr32.h>
	52
	53	// the virtual COM port only shows up when requesting devices with the raw device guid!
	54	static GUID USB_RAW_GUID = { 0xA5DCBF10, 0x6530, 0x11D2, { 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED } };
	55	static GUID USB_CDC_GUID = { 0x4D36E978, 0xE325, 0x11CE, { 0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18 } };
	56
	57	#elif defined(HAVE_LIBUDEV)
	58	#include <dirent.h>
	59	#include <poll.h>
	60	extern "C" {
	61	#include <libudev.h>
	62	}
	63	#elif defined(__FreeBSD__)
	64	#include <stdio.h>
	65	#include <unistd.h>
	66	#endif
	67
	68	#define CEC_VID 0x2548
	69	#define CEC_PID 0x1001
	70	#define CEC_PID2 0x1002
	71
	72	using namespace CEC;
	73	using namespace std;
	74
	75	#if defined(HAVE_LIBUDEV)
	76	bool TranslateComPort(CStdString &strString)
	77	{
	78	CStdString strTmp(strString);
	79	strTmp.MakeReverse();
	80	int iSlash = strTmp.Find('/');
	81	if (iSlash >= 0)
	82	{
	83	strTmp = strTmp.Left(iSlash);
	84	strTmp.MakeReverse();
	85	strString.Format("%s/%s:1.0/tty", strString.c_str(), strTmp.c_str());
	86	return true;
	87	}
	88
	89	return false;
	90	}
	91
	92	bool FindComPort(CStdString &strLocation)
	93	{
	94	CStdString strPort = strLocation;
	95	bool bReturn(!strPort.IsEmpty());
	96	CStdString strConfigLocation(strLocation);
	97	if (TranslateComPort(strConfigLocation))
	98	{
	99	DIR *dir;
	100	struct dirent *dirent;
	101	if((dir = opendir(strConfigLocation.c_str())) == NULL)
	102	return bReturn;
	103
	104	while ((dirent = readdir(dir)) != NULL)
	105	{
	106	if(strcmp((char)dirent->d_name, "." ) != 0 && strcmp((char)dirent->d_name, ".." ) != 0)
	107	{
	108	strPort.Format("/dev/%s", dirent->d_name);
	109	if (!strPort.IsEmpty())
	110	{
	111	strLocation = strPort;
	112	bReturn = true;
	113	break;
	114	}
	115	}
	116	}
	117	closedir(dir);
	118	}
	119
	120	return bReturn;
	121	}
	122	#endif
	123
	124	bool CUSBCECAdapterDetection::CanAutodetect(void)
	125	{
	126	#if defined(__APPLE__) \|\| defined(HAVE_LIBUDEV) \|\| defined(__WINDOWS__) \|\| defined(__FreeBSD__)
	127	return true;
	128	#else
	129	return false;
	130	#endif
	131	}
	132
	133	#if defined(__WINDOWS__)
	134	static bool GetComPortFromHandle(HDEVINFO hDevHandle, PSP_DEVINFO_DATA devInfoData, char* strPortName, unsigned int iSize)
	135	{
	136	bool bReturn(false);
	137	TCHAR strRegPortName[256];
	138	strRegPortName[0] = _T('\0');
	139	DWORD dwSize = sizeof(strRegPortName);
	140	DWORD dwType = 0;
	141
	142	HKEY hDeviceKey = SetupDiOpenDevRegKey(hDevHandle, devInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
	143	if (!hDeviceKey)
	144	return bReturn;
	145
	146	// locate the PortName
	147	if ((RegQueryValueEx(hDeviceKey, _T("PortName"), NULL, &dwType, reinterpret_cast<LPBYTE>(strRegPortName), &dwSize) == ERROR_SUCCESS) &&
	148	(dwType == REG_SZ) &&
	149	_tcslen(strRegPortName) > 3 &&
	150	_tcsnicmp(strRegPortName, _T("COM"), 3) == 0 &&
	151	_ttoi(&(strRegPortName[3])) > 0)
	152	{
	153	// return the port name
	154	snprintf(strPortName, iSize, "%s", strRegPortName);
	155	bReturn = true;
	156	}
	157
	158	RegCloseKey(hDeviceKey);
	159
	160	return bReturn;
	161	}
	162
	163	static bool FindComPortForComposite(const char* strLocation, char* strPortName, unsigned int iSize)
	164	{
	165	bool bReturn(false);
	166
	167	// find all devices of the CDC class
	168	HDEVINFO hDevHandle = SetupDiGetClassDevs(&USB_CDC_GUID, NULL, NULL, DIGCF_PRESENT);
	169	if (hDevHandle == INVALID_HANDLE_VALUE)
	170	return bReturn;
	171
	172	// check all devices, whether they match the location or not
	173	char strId[512];
	174	bool bGetNext(true);
	175	for (int iPtr = 0; !bReturn && bGetNext && iPtr < 1024 ; iPtr++)
	176	{
	177	strId[0] = 0;
	178
	179	SP_DEVINFO_DATA devInfoData;
	180	devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
	181
	182	// no more devices
	183	if (!SetupDiEnumDeviceInfo(hDevHandle, iPtr, &devInfoData))
	184	bGetNext = false;
	185	else
	186	{
	187	// check if the location of the _parent_ device matches
	188	DEVINST parentDevInst;
	189	if (CM_Get_Parent(&parentDevInst, devInfoData.DevInst, 0) == CR_SUCCESS)
	190	{
	191	CM_Get_Device_ID(parentDevInst, strId, 512, 0);
	192
	193	// match
	194	if (!strncmp(strId, strLocation, strlen(strLocation)))
	195	bReturn = GetComPortFromHandle(hDevHandle, &devInfoData, strPortName, iSize);
	196	}
	197	}
	198	}
	199
	200	SetupDiDestroyDeviceInfoList(hDevHandle);
	201	return bReturn;
	202	}
	203	#endif
	204
	205	uint8_t CUSBCECAdapterDetection::FindAdapters(cec_adapter deviceList, uint8_t iBufSize, const char strDevicePath /* = NULL */)
	206	{
	207	uint8_t iFound(0);
	208
	209	#if defined(__APPLE__)
	210	kern_return_t kresult;
	211	char bsdPath[MAXPATHLEN] = {0};
	212	io_iterator_t serialPortIterator;
	213
	214	CFMutableDictionaryRef classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
	215	if (classesToMatch)
	216	{
	217	CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDModemType));
	218	kresult = IOServiceGetMatchingServices(kIOMasterPortDefault, classesToMatch, &serialPortIterator);
	219	if (kresult == KERN_SUCCESS)
	220	{
	221	io_object_t serialService;
	222	while ((serialService = IOIteratorNext(serialPortIterator)))
	223	{
	224	int iVendor = 0, iProduct = 0;
	225	CFTypeRef bsdPathAsCFString;
	226
	227	// fetch the device path.
	228	bsdPathAsCFString = IORegistryEntryCreateCFProperty(serialService,
	229	CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
	230	if (bsdPathAsCFString)
	231	{
	232	// convert the path from a CFString to a C (NUL-terminated) string.
	233	CFStringGetCString((CFStringRef)bsdPathAsCFString, bsdPath, MAXPATHLEN - 1, kCFStringEncodingUTF8);
	234	CFRelease(bsdPathAsCFString);
	235
	236	// now walk up the hierarchy until we find the entry with vendor/product IDs
	237	io_registry_entry_t parent;
	238	CFTypeRef vendorIdAsCFNumber = NULL;
	239	CFTypeRef productIdAsCFNumber = NULL;
	240	kern_return_t kresult = IORegistryEntryGetParentEntry(serialService, kIOServicePlane, &parent);
	241	while (kresult == KERN_SUCCESS)
	242	{
	243	vendorIdAsCFNumber = IORegistryEntrySearchCFProperty(parent,
	244	kIOServicePlane, CFSTR(kUSBVendorID), kCFAllocatorDefault, 0);
	245	productIdAsCFNumber = IORegistryEntrySearchCFProperty(parent,
	246	kIOServicePlane, CFSTR(kUSBProductID), kCFAllocatorDefault, 0);
	247	if (vendorIdAsCFNumber && productIdAsCFNumber)
	248	{
	249	CFNumberGetValue((CFNumberRef)vendorIdAsCFNumber, kCFNumberIntType, &iVendor);
	250	CFRelease(vendorIdAsCFNumber);
	251	CFNumberGetValue((CFNumberRef)productIdAsCFNumber, kCFNumberIntType, &iProduct);
	252	CFRelease(productIdAsCFNumber);
	253	IOObjectRelease(parent);
	254	break;
	255	}
	256	io_registry_entry_t oldparent = parent;
	257	kresult = IORegistryEntryGetParentEntry(parent, kIOServicePlane, &parent);
	258	IOObjectRelease(oldparent);
	259	}
	260	if (strlen(bsdPath) && iVendor == CEC_VID && (iProduct == CEC_PID \|\| iProduct == CEC_PID2))
	261	{
	262	if (!strDevicePath \|\| !strcmp(bsdPath, strDevicePath))
	263	{
	264	// on darwin, the device path is the same as the comm path.
	265	if (iFound == 0 \|\| strcmp(deviceList[iFound-1].comm, bsdPath))
	266	{
	267	snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", bsdPath);
	268	snprintf(deviceList[iFound].comm, sizeof(deviceList[iFound].path), "%s", bsdPath);
	269	iFound++;
	270	}
	271	}
	272	}
	273	}
	274	IOObjectRelease(serialService);
	275	}
	276	}
	277	IOObjectRelease(serialPortIterator);
	278	}
	279	#elif defined(HAVE_LIBUDEV)
	280	struct udev *udev;
	281	if (!(udev = udev_new()))
	282	return -1;
	283
	284	struct udev_enumerate *enumerate;
	285	struct udev_list_entry devices, dev_list_entry;
	286	struct udev_device dev, pdev;
	287	enumerate = udev_enumerate_new(udev);
	288	udev_enumerate_scan_devices(enumerate);
	289	devices = udev_enumerate_get_list_entry(enumerate);
	290	udev_list_entry_foreach(dev_list_entry, devices)
	291	{
	292	const char *strPath;
	293	strPath = udev_list_entry_get_name(dev_list_entry);
	294
	295	dev = udev_device_new_from_syspath(udev, strPath);
	296	if (!dev)
	297	continue;
	298
	299	pdev = udev_device_get_parent(udev_device_get_parent(dev));
	300	if (!pdev \|\| !udev_device_get_sysattr_value(pdev,"idVendor") \|\| !udev_device_get_sysattr_value(pdev, "idProduct"))
	301	{
	302	udev_device_unref(dev);
	303	continue;
	304	}
	305
	306	int iVendor, iProduct;
	307	sscanf(udev_device_get_sysattr_value(pdev, "idVendor"), "%x", &iVendor);
	308	sscanf(udev_device_get_sysattr_value(pdev, "idProduct"), "%x", &iProduct);
	309	if (iVendor == CEC_VID && (iProduct == CEC_PID \|\| iProduct == CEC_PID2))
	310	{
	311	CStdString strPath(udev_device_get_syspath(pdev));
	312	if (!strDevicePath \|\| !strcmp(strPath.c_str(), strDevicePath))
	313	{
	314	CStdString strComm(strPath);
	315	if (FindComPort(strComm) && (iFound == 0 \|\| strcmp(deviceList[iFound-1].comm, strComm.c_str())))
	316	{
	317	snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", strPath.c_str());
	318	snprintf(deviceList[iFound].comm, sizeof(deviceList[iFound].path), "%s", strComm.c_str());
	319	iFound++;
	320	}
	321	}
	322	}
	323	udev_device_unref(dev);
	324	}
	325
	326	udev_enumerate_unref(enumerate);
	327	udev_unref(udev);
	328	#elif defined(__WINDOWS__)
	329	HDEVINFO hDevHandle;
	330	DWORD required = 0, iMemberIndex = 0;
	331	int nBufferSize = 0;
	332
	333	SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
	334	deviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
	335
	336	SP_DEVINFO_DATA devInfoData;
	337	devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
	338
	339	// find all devices
	340	if ((hDevHandle = SetupDiGetClassDevs(&USB_RAW_GUID, 0, 0, DIGCF_PRESENT \| DIGCF_DEVICEINTERFACE)) == INVALID_HANDLE_VALUE)
	341	return iFound;
	342
	343	BOOL bResult = true;
	344	TCHAR *buffer = NULL;
	345	PSP_DEVICE_INTERFACE_DETAIL_DATA devicedetailData;
	346	while(bResult && iFound < iBufSize)
	347	{
	348	bResult = SetupDiEnumDeviceInfo(hDevHandle, iMemberIndex, &devInfoData);
	349
	350	if (bResult)
	351	bResult = SetupDiEnumDeviceInterfaces(hDevHandle, 0, &USB_RAW_GUID, iMemberIndex, &deviceInterfaceData);
	352
	353	if(!bResult)
	354	{
	355	// no (more) results
	356	SetupDiDestroyDeviceInfoList(hDevHandle);
	357	delete []buffer;
	358	buffer = NULL;
	359	return iFound;
	360	}
	361
	362	iMemberIndex++;
	363	BOOL bDetailResult = false;
	364	{
	365	// As per MSDN, Get the required buffer size. Call SetupDiGetDeviceInterfaceDetail with a
	366	// NULL DeviceInterfaceDetailData pointer, a DeviceInterfaceDetailDataSize of zero,
	367	// and a valid RequiredSize variable. In response to such a call, this function returns
	368	// the required buffer size at RequiredSize and fails with GetLastError returning
	369	// ERROR_INSUFFICIENT_BUFFER.
	370	// Allocate an appropriately sized buffer and call the function again to get the interface details.
	371
	372	SetupDiGetDeviceInterfaceDetail(hDevHandle, &deviceInterfaceData, NULL, 0, &required, NULL);
	373
	374	buffer = new TCHAR[required];
	375	devicedetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) buffer;
	376	devicedetailData->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
	377	nBufferSize = required;
	378	}
	379
	380	bDetailResult = SetupDiGetDeviceInterfaceDetail(hDevHandle, &deviceInterfaceData, devicedetailData, nBufferSize , &required, NULL);
	381	if(!bDetailResult)
	382	continue;
	383
	384	// check whether the path matches, if a path was given
	385	if (strDevicePath && strcmp(strDevicePath, devicedetailData->DevicePath) != 0)
	386	continue;
	387
	388	// get the vid and pid
	389	CStdString strVendorId;
	390	CStdString strProductId;
	391	CStdString strTmp(devicedetailData->DevicePath);
	392	strVendorId.assign(strTmp.substr(strTmp.Find("vid_") + 4, 4));
	393	strProductId.assign(strTmp.substr(strTmp.Find("pid_") + 4, 4));
	394	if (strTmp.Find("&mi_") >= 0 && strTmp.Find("&mi_00") < 0)
	395	continue;
	396
	397	int iVendor, iProduct;
	398	sscanf(strVendorId, "%x", &iVendor);
	399	sscanf(strProductId, "%x", &iProduct);
	400
	401	// no match
	402	if (iVendor != CEC_VID \|\| (iProduct != CEC_PID && iProduct != CEC_PID2))
	403	continue;
	404
	405
	406	if (iProduct == CEC_PID2)
	407	{
	408	// the 1002 pid indicates a composite device, that needs special treatment
	409	char strId[512];
	410	CM_Get_Device_ID(devInfoData.DevInst, strId, 512, 0);
	411	if (FindComPortForComposite(strId, deviceList[iFound].comm, sizeof(deviceList[iFound].comm)))
	412	{
	413	snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", devicedetailData->DevicePath);
	414	iFound++;
	415	}
	416	}
	417	else if (GetComPortFromHandle(hDevHandle, &devInfoData, deviceList[iFound].comm, sizeof(deviceList[iFound].comm)))
	418	{
	419	snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", devicedetailData->DevicePath);
	420	iFound++;
	421	}
	422	}
	423	#elif defined(__FreeBSD__)
	424	char devicePath[PATH_MAX + 1];
	425	int i;
	426
	427	for (i = 0; i < 8; ++i)
	428	{
	429	(void)snprintf(devicePath, sizeof(devicePath), "/dev/ttyU%d", i);
	430	if (!access(devicePath, 0))
	431	{
	432	snprintf(deviceList[iFound].path, sizeof(deviceList[iFound].path), "%s", devicePath);
	433	snprintf(deviceList[iFound].comm, sizeof(deviceList[iFound].path), "%s", devicePath);
	434	iFound++;
	435	}
	436	}
	437	#else
	438	//silence "unused" warnings
	439	void tmp = (void)deviceList;
	440	tmp = (void *)strDevicePath;
	441	#endif
	442
	443	iBufSize = 0; if(!iBufSize){} /* silence "unused" warning on linux/osx */
	444
	445	return iFound;
	446	}