bool CD3DEffect::CreateEffect()
{
HRESULT hr;
LPD3DXBUFFER pError = NULL;
std::vector<D3DXMACRO> definemacros;
for( DefinesMap::const_iterator it = m_defines.begin(); it != m_defines.end(); ++it )
{
D3DXMACRO m;
m.Name = it->first.c_str();
if (it->second.IsEmpty())
m.Definition = NULL;
else
m.Definition = it->second.c_str();
definemacros.push_back( m );
}
definemacros.push_back(D3DXMACRO());
definemacros.back().Name = 0;
definemacros.back().Definition = 0;
hr = D3DXCreateEffect(g_Windowing.Get3DDevice(), m_effectString, m_effectString.length(), &definemacros[0], NULL, 0, NULL, &m_effect, &pError );
if(hr == S_OK)
return true;
else if(pError)
{
CStdString error;
error.assign((const char*)pError->GetBufferPointer(), pError->GetBufferSize());
CLog::Log(LOGERROR, "CD3DEffect::CreateEffect(): %s", error.c_str());
}
else
CLog::Log(LOGERROR, "CD3DEffect::CreateEffect(): call to D3DXCreateEffect() failed with %" PRId32, hr);
return false;
}
void CURL::Decode(CStdString& strURLData)
//modified to be more accomodating - if a non hex value follows a % take the characters directly and don't raise an error.
// However % characters should really be escaped like any other non safe character (www.rfc-editor.org/rfc/rfc1738.txt)
{
CStdString strResult;
/* result will always be less than source */
strResult.reserve( strURLData.length() );
for (unsigned int i = 0; i < strURLData.size(); ++i)
{
int kar = (unsigned char)strURLData[i];
if (kar == '+') strResult += ' ';
else if (kar == '%')
{
if (i < strURLData.size() - 2)
{
CStdString strTmp;
strTmp.assign(strURLData.substr(i + 1, 2));
int dec_num=-1;
sscanf(strTmp,"%x",(unsigned int *)&dec_num);
if (dec_num<0 || dec_num>255)
strResult += kar;
else
{
strResult += (char)dec_num;
i += 2;
}
}
else
strResult += kar;
}
else strResult += kar;
}
strURLData = strResult;
}
bool CFTPDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CFileCurl reader;
CURL url(strPath);
CStdString path = url.GetFileName();
if( !path.IsEmpty() && !path.Right(1).Equals("/") )
{
path += "/";
url.SetFileName(path);
}
if (!reader.Open(url))
return false;
char buffer[MAX_PATH + 1024];
while( reader.ReadString(buffer, sizeof(buffer)) )
{
CStdString strBuffer = buffer;
StringUtils::RemoveCRLF(strBuffer);
CFTPParse parse;
if (parse.FTPParse(strBuffer))
{
if( parse.getName().length() == 0 )
continue;
if( parse.getFlagtrycwd() == 0 && parse.getFlagtryretr() == 0 )
continue;
/* buffer name */
CStdString name;
name.assign(parse.getName());
if( name.Equals("..") || name.Equals(".") )
continue;
/* this should be conditional if we ever add */
/* support for the utf8 extension in ftp client */
g_charsetConverter.unknownToUTF8(name);
CFileItemPtr pItem(new CFileItem(name));
pItem->m_strPath = path + name;
pItem->m_bIsFolder = (bool)(parse.getFlagtrycwd() != 0);
if (pItem->m_bIsFolder)
CUtil::AddSlashAtEnd(pItem->m_strPath);
/* qualify the url with host and all */
url.SetFileName(pItem->m_strPath);
pItem->m_strPath = url.Get();
pItem->m_dwSize = parse.getSize();
pItem->m_dateTime=parse.getTime();
items.Add(pItem);
}
}
return true;
}
uint8_t CUSBCECAdapterDetection::FindAdapters(cec_adapter_descriptor *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].strComName, bsdPath))
{
snprintf(deviceList[iFound].strComPath, sizeof(deviceList[iFound].strComPath), "%s", bsdPath);
snprintf(deviceList[iFound].strComName, sizeof(deviceList[iFound].strComName), "%s", bsdPath);
deviceList[iFound].iVendorId = iVendor;
deviceList[iFound].iProductId = iProduct;
deviceList[iFound].adapterType = ADAPTERTYPE_P8_EXTERNAL; // will be overridden when not doing a "quick scan" by the actual type
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].strComName, strComm.c_str())))
{
snprintf(deviceList[iFound].strComPath, sizeof(deviceList[iFound].strComPath), "%s", strPath.c_str());
snprintf(deviceList[iFound].strComName, sizeof(deviceList[iFound].strComName), "%s", strComm.c_str());
deviceList[iFound].iVendorId = iVendor;
deviceList[iFound].iProductId = iProduct;
deviceList[iFound].adapterType = ADAPTERTYPE_P8_EXTERNAL; // will be overridden when not doing a "quick scan" by the actual type
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].strComName, sizeof(deviceList[iFound].strComName)))
{
snprintf(deviceList[iFound].strComPath, sizeof(deviceList[iFound].strComPath), "%s", devicedetailData->DevicePath);
deviceList[iFound].iVendorId = (uint16_t)iVendor;
deviceList[iFound].iProductId = (uint16_t)iProduct;
deviceList[iFound].adapterType = ADAPTERTYPE_P8_EXTERNAL; // will be overridden when not doing a "quick scan" by the actual type
iFound++;
}
}
else if (GetComPortFromHandle(hDevHandle, &devInfoData, deviceList[iFound].strComName, sizeof(deviceList[iFound].strComName)))
{
snprintf(deviceList[iFound].strComPath, sizeof(deviceList[iFound].strComPath), "%s", devicedetailData->DevicePath);
deviceList[iFound].iVendorId = (uint16_t)iVendor;
deviceList[iFound].iProductId = (uint16_t)iProduct;
deviceList[iFound].adapterType = ADAPTERTYPE_P8_EXTERNAL; // will be overridden when not doing a "quick scan" by the actual type
iFound++;
}
}
#elif defined(__FreeBSD__)
char devicePath[PATH_MAX + 1];
char infos[512];
char sysctlname[32];
char ttyname[8];
char *pos;
size_t infos_size = sizeof(infos);
int i;
for (i = 0; ; ++i)
{
unsigned int iVendor, iProduct;
memset(infos, 0, sizeof(infos));
(void)snprintf(sysctlname, sizeof(sysctlname),
"dev.umodem.%d.%%pnpinfo", i);
if (sysctlbyname(sysctlname, infos, &infos_size,
NULL, 0) != 0)
break;
pos = strstr(infos, "vendor=");
if (pos == NULL)
continue;
sscanf(pos, "vendor=%x ", &iVendor);
pos = strstr(infos, "product=");
if (pos == NULL)
continue;
sscanf(pos, "product=%x ", &iProduct);
if (iVendor != CEC_VID || (iProduct != CEC_PID && iProduct != CEC_PID2))
continue;
pos = strstr(infos, "ttyname=");
if (pos == NULL)
continue;
sscanf(pos, "ttyname=%s ", ttyname);
(void)snprintf(devicePath, sizeof(devicePath),
"/dev/tty%s", ttyname);
if (strDevicePath) {
char currStrDevicePath[512];
int port = 0;
int devaddr = 0;
memset(currStrDevicePath, 0, sizeof(currStrDevicePath));
memset(infos, 0, sizeof(infos));
(void)snprintf(sysctlname, sizeof(sysctlname),
"dev.umodem.%d.%%location", i);
if (sysctlbyname(sysctlname, infos, &infos_size,
NULL, 0) != 0)
break;
pos = strstr(infos, "port=");
if (pos == NULL)
continue;
sscanf(pos, "port=%d ", &port);
pos = strstr(infos, "devaddr=");
if (pos == NULL)
continue;
sscanf(pos, "devaddr=%d ", &devaddr);
(void)snprintf(currStrDevicePath, sizeof(currStrDevicePath),
"/dev/ugen%d.%d", port, devaddr);
if (strcmp(currStrDevicePath, strDevicePath) != 0)
continue;
}
snprintf(deviceList[iFound].strComPath, sizeof(deviceList[iFound].strComPath), "%s", devicePath);
snprintf(deviceList[iFound].strComName, sizeof(deviceList[iFound].strComName), "%s", devicePath);
deviceList[iFound].iVendorId = iVendor;
deviceList[iFound].iProductId = iProduct;
deviceList[iFound].adapterType = ADAPTERTYPE_P8_EXTERNAL; // will be overridden when not doing a "quick scan" by the actual type
iFound++;
}
#else
//silence "unused" warnings
((void)deviceList);
((void) strDevicePath);
#endif
iBufSize = 0; if(!iBufSize){} /* silence "unused" warning on linux/osx */
return iFound;
}
HRESULT CSaveAsObject::ImportDocumentWithoutAutoProfile(INRTSessionPtr spSession, INRTDocumentPtr spBaseDocument, const CStdString& filename, bool populateProfile, INRTDocumentPtr& spImportedDocument)
{
LOG_WS_INFO(_T("Importing document for Interwoven"));
try
{
IContextItemsPtr spContextItems;
HRESULT hr = spContextItems.CreateInstance(__uuidof(ContextItems));
if(FAILED(hr))
{
LOG_WS_ERROR(_T("Failed to create instance of ContextItems"));
return hr;
}
if(!m_hWnd)
{
m_hWnd = GetDesktopWindow();
}
hr = spContextItems->Add(_bstr_t(L"ParentWindow"), _variant_t(((long)m_hWnd)).Detach());
if (FAILED(hr))
{
LOG_WS_ERROR(_T("Failed to add parent window to ContextItems"));
return hr;
}
_variant_t destinationObject;
if(spBaseDocument == NULL) //New document
{
destinationObject = (IDispatch*)spSession.GetInterfacePtr();
}
else
{
destinationObject = (IDispatch*)(spBaseDocument->GetDatabase().GetInterfacePtr());
}
hr = spContextItems->Add(L"DestinationObject", destinationObject.Detach());
if(FAILED(hr))
{
LOG_WS_ERROR(_T("Failed to add DestinationObject to ContextItems"));
return hr;
}
hr = spContextItems->Add(L"IManExt.Import.FileName", _variant_t(filename).Detach());
if(FAILED(hr))
{
LOG_WS_ERROR(_T("Failed to add FileName to ContextItems"));
return hr;
}
if(populateProfile)
{
CStdString applicationId = GetApplicationIDFromFileName(spSession->PreferredDatabase, filename);
if(FAILED(spContextItems->Add(L"IManExt.Import.DocType", _variant_t(applicationId).Detach())))
{
LOG_WS_ERROR(_T("Failed to add DocType to ContextItems"));
}
CStdString user;
if(!CIManageUtils::GetUser(user))
{
LOG_WS_ERROR(_T("Not logged into session; cannot set profile"));
return E_IM_NOT_LOGGED_INTO_SESSION;
}
if(user.length() == 0)
{
TCHAR userName[MAX_PATH] = {0};
DWORD size = MAX_PATH;
if(::GetUserName((LPTSTR)userName, &size))
{
user.assign(userName);
}
}
if(FAILED(spContextItems->Add(L"IManExt.Import.DocAuthor", _variant_t(user).Detach())))
{
LOG_WS_ERROR(_T("Failed to add DocType to ContextItems"));
}
}
ICommandPtr spImportCmd;
hr = spImportCmd.CreateInstance(__uuidof(ImportCmd));
if(FAILED(hr))
{
LOG_WS_ERROR(_T("Failed to create instance of ImportCmd"));
return hr;
}
hr = spImportCmd->Initialize(spContextItems);
if(FAILED(hr))
{
LOG_WS_ERROR(_T("Failed in ImportCmd initialise"));
return hr;
}
hr = spImportCmd->Update();
if(FAILED(hr))
{
LOG_WS_ERROR(_T("Failed update ImportCommand"));
return hr;
}
long status = spImportCmd->Status;
if(status != nrActiveCommand && ((status & nrGrayedCommand) != nrGrayedCommand))
{
CStdString sError;
sError.Format(_T("Failed to update the import command. Unexpected status [%d]"), status);
LOG_WS_ERROR(sError.c_str());
return E_FAIL;
}
hr = spImportCmd->Execute();
if(FAILED(hr))
{
LOG_WS_ERROR(_T("Failed to execute the import command"));
return hr;
}
spImportedDocument = spContextItems->Item(L"ImportedDocument");
spContextItems->Remove(L"ImportedDocument");
return S_OK;
}
catch(const _com_error& e)
{
CStdString sMsg;
sMsg.Format(_T("Error description : %s"), e.ErrorMessage());
LOG_WS_ERROR(sMsg.c_str());
return S_FALSE;
}
}
bool CFTPDirectory::GetDirectory(const CURL& url2, CFileItemList &items)
{
CCurlFile reader;
CURL url(url2);
CStdString path = url.GetFileName();
if( !path.empty() && !StringUtils::EndsWith(path, "/") )
{
path += "/";
url.SetFileName(path);
}
if (!reader.Open(url))
return false;
bool serverNotUseUTF8 = url.GetProtocolOption("utf8") == "0";
char buffer[MAX_PATH + 1024];
while( reader.ReadString(buffer, sizeof(buffer)) )
{
CStdString strBuffer = buffer;
StringUtils::RemoveCRLF(strBuffer);
CFTPParse parse;
if (parse.FTPParse(strBuffer))
{
if( parse.getName().length() == 0 )
continue;
if( parse.getFlagtrycwd() == 0 && parse.getFlagtryretr() == 0 )
continue;
/* buffer name */
CStdString name;
name.assign(parse.getName());
if( name.Equals("..") || name.Equals(".") )
continue;
// server returned filename could in utf8 or non-utf8 encoding
// we need utf8, so convert it to utf8 anyway
g_charsetConverter.unknownToUTF8(name);
// convert got empty result, ignore it
if (name.empty())
continue;
if (serverNotUseUTF8 || name != parse.getName())
// non-utf8 name path, tag it with protocol option.
// then we can talk to server with the same encoding in CurlFile according to this tag.
url.SetProtocolOption("utf8", "0");
else
url.RemoveProtocolOption("utf8");
CFileItemPtr pItem(new CFileItem(name));
pItem->m_bIsFolder = (bool)(parse.getFlagtrycwd() != 0);
CStdString filePath = path + name;
if (pItem->m_bIsFolder)
URIUtils::AddSlashAtEnd(filePath);
/* qualify the url with host and all */
url.SetFileName(filePath);
pItem->SetPath(url.Get());
pItem->m_dwSize = parse.getSize();
pItem->m_dateTime=parse.getTime();
items.Add(pItem);
}
}
return true;
}
void CRssReader::Process()
{
while (GetQueueSize())
{
CSingleLock lock(m_critical);
int iFeed = m_vecQueue.front();
m_vecQueue.erase(m_vecQueue.begin());
m_strFeed[iFeed] = "";
m_strColors[iFeed] = "";
CCurlFile http;
http.SetUserAgent(g_advancedSettings.m_userAgent);
http.SetTimeout(2);
CStdString strXML;
CStdString strUrl = m_vecUrls[iFeed];
lock.Leave();
int nRetries = 3;
CURL url(strUrl);
std::string fileCharset;
// we wait for the network to come up
if ((url.GetProtocol() == "http" || url.GetProtocol() == "https") &&
!g_application.getNetwork().IsAvailable(true))
{
CLog::Log(LOGWARNING, "RSS: No network connection");
strXML = "<rss><item><title>"+g_localizeStrings.Get(15301)+"</title></item></rss>";
}
else
{
XbmcThreads::EndTime timeout(15000);
while (!m_bStop && nRetries > 0)
{
if (timeout.IsTimePast())
{
CLog::Log(LOGERROR, "Timeout whilst retrieving %s", strUrl.c_str());
http.Cancel();
break;
}
nRetries--;
if (url.GetProtocol() != "http" && url.GetProtocol() != "https")
{
CFile file;
auto_buffer buffer;
if (file.LoadFile(strUrl, buffer))
{
strXML.assign(buffer.get(), buffer.length());
break;
}
}
else
if (http.Get(strUrl, strXML))
{
fileCharset = http.GetServerReportedCharset();
CLog::Log(LOGDEBUG, "Got rss feed: %s", strUrl.c_str());
break;
}
}
http.Cancel();
}
if (!strXML.empty() && m_pObserver)
{
// erase any <content:encoded> tags (also unsupported by tinyxml)
size_t iStart = strXML.find("<content:encoded>");
size_t iEnd = 0;
while (iStart != std::string::npos)
{
// get <content:encoded> end position
iEnd = strXML.find("</content:encoded>", iStart) + 18;
// erase the section
strXML = strXML.erase(iStart, iEnd - iStart);
iStart = strXML.find("<content:encoded>");
}
if (Parse(strXML, iFeed, fileCharset))
CLog::Log(LOGDEBUG, "Parsed rss feed: %s", strUrl.c_str());
}
}
UpdateObserver();
}
bool CFTPDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CFileCurl reader;
CURL url(strPath);
CStdString path = url.GetFileName();
if( !path.IsEmpty() && !path.Right(1).Equals("/") )
{
path += "/";
url.SetFileName(path);
}
if (!reader.Open(url))
return false;
char buffer[MAX_PATH + 1024];
while( reader.ReadString(buffer, sizeof(buffer)) )
{
CStdString strBuffer = buffer;
StringUtils::RemoveCRLF(strBuffer);
struct ftpparse lp = {};
if (ftpparse(&lp, (char*)strBuffer.c_str(), strBuffer.size()) == 1)
{
if( lp.namelen == 0 )
continue;
if( lp.flagtrycwd == 0 && lp.flagtryretr == 0 )
continue;
/* buffer name as it's not allways null terminated */
CStdString name;
name.assign(lp.name, lp.namelen);
if( name.Equals("..") || name.Equals(".") )
continue;
/* this should be conditional if we ever add */
/* support for the utf8 extension in ftp client */
g_charsetConverter.stringCharsetToUtf8(name);
CFileItemPtr pItem(new CFileItem(name));
pItem->m_strPath = path + name;
pItem->m_bIsFolder = (bool)(lp.flagtrycwd != 0);
if (pItem->m_bIsFolder)
if (!CUtil::HasSlashAtEnd(pItem->m_strPath)) pItem->m_strPath += "/";
/* qualify the url with host and all */
url.SetFileName(pItem->m_strPath);
url.GetURL(pItem->m_strPath);
pItem->m_dwSize = lp.size;
pItem->m_dateTime=lp.mtime;
items.Add(pItem);
}
}
return true;
}
uint8_t CAdapterDetection::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)
{
if (!strDevicePath || !strcmp(bsdPath, strDevicePath))
{
// on darwin, the device path is the same as the comm path.
snprintf(deviceList[iFound ].path, sizeof(deviceList[iFound].path), "%s", bsdPath);
snprintf(deviceList[iFound++].comm, sizeof(deviceList[iFound].path), "%s", bsdPath);
}
}
}
IOObjectRelease(serialService);
}
}
IOObjectRelease(serialPortIterator);
}
#elif !defined(__WINDOWS__)
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)
{
CStdString strPath(udev_device_get_syspath(pdev));
if (!strDevicePath || !strcmp(strPath.c_str(), strDevicePath))
{
CStdString strComm(strPath);
if (FindComPort(strComm))
{
snprintf(deviceList[iFound ].path, sizeof(deviceList[iFound].path), "%s", strPath.c_str());
snprintf(deviceList[iFound++].comm, sizeof(deviceList[iFound].path), "%s", strComm.c_str());
}
}
}
udev_device_unref(dev);
}
udev_enumerate_unref(enumerate);
udev_unref(udev);
#else
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);
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)
{
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;
if (strDevicePath && strcmp(strDevicePath, devicedetailData->DevicePath) != 0)
continue;
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);
if (iVendor != CEC_VID || iProduct != CEC_PID)
continue;
HKEY hDeviceKey = SetupDiOpenDevRegKey(hDevHandle, &devInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
if (!hDeviceKey)
continue;
TCHAR strPortName[256];
strPortName[0] = _T('\0');
DWORD dwSize = sizeof(strPortName);
DWORD dwType = 0;
/* search the registry */
if ((RegQueryValueEx(hDeviceKey, _T("PortName"), NULL, &dwType, reinterpret_cast<LPBYTE>(strPortName), &dwSize) == ERROR_SUCCESS) && (dwType == REG_SZ))
{
if (_tcslen(strPortName) > 3 && _tcsnicmp(strPortName, _T("COM"), 3) == 0 &&
_ttoi(&(strPortName[3])) > 0)
{
snprintf(deviceList[iFound ].path, sizeof(deviceList[iFound].path), "%s", devicedetailData->DevicePath);
snprintf(deviceList[iFound++].comm, sizeof(deviceList[iFound].path), "%s", strPortName);
}
}
RegCloseKey(hDeviceKey);
}
#endif
return iFound;
}
void CRssReader::Process()
{
while (GetQueueSize())
{
CSingleLock lock(m_critical);
int iFeed = m_vecQueue.front();
m_vecQueue.erase(m_vecQueue.begin());
m_strFeed[iFeed] = "";
m_strColors[iFeed] = "";
CCurlFile http;
http.SetUserAgent(g_advancedSettings.m_userAgent);
http.SetTimeout(2);
CStdString strXML;
CStdString strUrl = m_vecUrls[iFeed];
lock.Leave();
int nRetries = 3;
CURL url(strUrl);
// we wait for the network to come up
if ((url.GetProtocol() == "http" || url.GetProtocol() == "https") &&
!g_application.getNetwork().IsAvailable(true))
strXML = "<rss><item><title>"+g_localizeStrings.Get(15301)+"</title></item></rss>";
else
{
XbmcThreads::EndTime timeout(15000);
while (!m_bStop && nRetries > 0)
{
if (timeout.IsTimePast())
{
CLog::Log(LOGERROR, "Timeout whilst retrieving %s", strUrl.c_str());
http.Cancel();
break;
}
nRetries--;
if (url.GetProtocol() != "http" && url.GetProtocol() != "https")
{
void* bufferPtr;
const unsigned int fsize = CFileUtils::LoadFile(strUrl, bufferPtr);
if (fsize != 0)
{
strXML.assign((const char*)bufferPtr, fsize);
free(bufferPtr);
break;
}
}
else
if (http.Get(strUrl, strXML))
{
CLog::Log(LOGDEBUG, "Got rss feed: %s", strUrl.c_str());
break;
}
}
http.Cancel();
}
if (!strXML.IsEmpty() && m_pObserver)
{
// erase any <content:encoded> tags (also unsupported by tinyxml)
int iStart = strXML.Find("<content:encoded>");
int iEnd = 0;
while (iStart > 0)
{
// get <content:encoded> end position
iEnd = strXML.Find("</content:encoded>", iStart) + 18;
// erase the section
strXML = strXML.erase(iStart, iEnd - iStart);
iStart = strXML.Find("<content:encoded>");
}
if (Parse((LPSTR)strXML.c_str(), iFeed))
CLog::Log(LOGDEBUG, "Parsed rss feed: %s", strUrl.c_str());
}
}
UpdateObserver();
}