TEST(TestRegExp, GetNamedSubPattern)
{
CRegExp regex;
std::string match;
EXPECT_TRUE(regex.RegComp("^(?<first>Test)\\s*(?<second>.*)\\."));
EXPECT_EQ(0, regex.RegFind("Test string."));
EXPECT_TRUE(regex.GetNamedSubPattern("first", match));
EXPECT_STREQ("Test", match.c_str());
EXPECT_TRUE(regex.GetNamedSubPattern("second", match));
EXPECT_STREQ("string", match.c_str());
}
void CAndroidStorageProvider::GetRemovableDrives(VECSOURCES &removableDrives)
{
// mounted usb disks
std::vector<CStdString> result;
CRegExp reMount;
reMount.RegComp("^(.+?)\\s+(.+?)\\s+(.+?)\\s");
char line[1024];
FILE* pipe = fopen("/proc/mounts", "r");
if (pipe)
{
while (fgets(line, sizeof(line) - 1, pipe))
{
if (reMount.RegFind(line) != -1)
{
bool accepted = false;
std::string mountStr = reMount.GetReplaceString("\\2");
std::string fsStr = reMount.GetReplaceString("\\3");
const char* mount = mountStr.c_str();
const char* fs = fsStr.c_str();
// Here we choose which filesystems are approved
if (strcmp(fs, "fuseblk") == 0 || strcmp(fs, "vfat") == 0
|| strcmp(fs, "ext2") == 0 || strcmp(fs, "ext3") == 0 || strcmp(fs, "ext4") == 0
|| strcmp(fs, "reiserfs") == 0 || strcmp(fs, "xfs") == 0
|| strcmp(fs, "ntfs-3g") == 0 || strcmp(fs, "iso9660") == 0
|| strcmp(fs, "exfat") == 0
|| strcmp(fs, "fusefs") == 0 || strcmp(fs, "hfs") == 0)
accepted = true;
// Ignore everything but usb
if (!StringUtils::StartsWith(mountStr, "/mnt/usb"))
accepted = false;
if(accepted)
result.push_back(mount);
}
}
fclose(pipe);
} else
CLog::Log(LOGERROR, "Cannot read mount points");
for (unsigned int i = 0; i < result.size(); i++)
{
CMediaSource share;
share.strPath = unescape(result[i]);
share.strName = URIUtils::GetFileName(share.strPath);
share.m_ignore = true;
removableDrives.push_back(share);
}
}
void CLabelFormatter::AssembleMask(unsigned int label, const CStdString& mask)
{
assert(label < 2);
m_staticContent[label].clear();
m_dynamicContent[label].clear();
// we want to match [<prefix>%A<postfix]
// but allow %%, %[, %] to be in the prefix and postfix. Anything before the first [
// could be a mask that's not surrounded with [], so pass to SplitMask.
CRegExp reg;
reg.RegComp("(^|[^%])\\[(([^%]|%%|%\\]|%\\[)*)%([" MASK_CHARS "])(([^%]|%%|%\\]|%\\[)*)\\]");
CStdString work(mask);
int findStart = -1;
while ((findStart = reg.RegFind(work.c_str())) >= 0)
{ // we've found a match for a pre/postfixed string
// send anything
SplitMask(label, work.Left(findStart) + reg.GetReplaceString("\\1").c_str());
m_dynamicContent[label].push_back(CMaskString(
reg.GetReplaceString("\\2"),
reg.GetReplaceString("\\4")[0],
reg.GetReplaceString("\\5")));
work = work.Mid(findStart + reg.GetFindLen());
}
SplitMask(label, work);
assert(m_staticContent[label].size() == m_dynamicContent[label].size() + 1);
}
void CLabelFormatter::SplitMask(unsigned int label, const CStdString &mask)
{
assert(label < 2);
CRegExp reg;
reg.RegComp("%([" MASK_CHARS "])");
CStdString work(mask);
int findStart = -1;
while ((findStart = reg.RegFind(work.c_str())) >= 0)
{ // we've found a match
m_staticContent[label].push_back(work.Left(findStart));
m_dynamicContent[label].push_back(CMaskString("", *reg.GetReplaceString("\\1"), ""));
work = work.Mid(findStart + reg.GetFindLen());
}
m_staticContent[label].push_back(work);
}
void CLabelFormatter::SplitMask(unsigned int label, const std::string &mask)
{
assert(label < 2);
CRegExp reg;
reg.RegComp("%([" MASK_CHARS "])");
std::string work(mask);
int findStart = -1;
while ((findStart = reg.RegFind(work.c_str())) >= 0)
{ // we've found a match
m_staticContent[label].push_back(work.substr(0, findStart));
m_dynamicContent[label].push_back(CMaskString("",
reg.GetMatch(1)[0], ""));
work = work.substr(findStart + reg.GetFindLen());
}
m_staticContent[label].push_back(work);
}
bool aml_support_hevc_4k2k()
{
static int has_hevc_4k2k = -1;
if (has_hevc_4k2k == -1)
{
CRegExp regexp;
regexp.RegComp("hevc:.*4k");
std::string valstr;
if (SysfsUtils::GetString("/sys/class/amstream/vcodec_profile", valstr) != 0)
has_hevc_4k2k = 0;
else
has_hevc_4k2k = (regexp.RegFind(valstr) >= 0) ? 1 : 0;
}
return (has_hevc_4k2k == 1);
}
void CCedtApp::OnSearchFindInFiles()
{
// static dialog box to remember last settings...
static CFindInFilesDialog dlg;
CMainFrame * pFrame = (CMainFrame *)AfxGetMainWnd(); ASSERT( pFrame );
if( ! pFrame->CanUseOutputWindow() ) {
AfxMessageBox(IDS_ERR_OUTPUT_WINDOW_OCCUPIED, MB_OK | MB_ICONSTOP); return;
}
CCedtView * pView = (CCedtView *)pFrame->MDIGetActiveView();
CCedtDoc * pDoc = (pView) ? (CCedtDoc *)pView->GetDocument() : NULL;
if( pDoc && pView ) {
dlg.m_szFindString = pView->GetCurrentWord();
if( pView->IsSelected() && ! pView->GetSelectedLineCount() ) dlg.m_szFindString = pView->GetSelectedString();
if( ! dlg.m_szFolder.GetLength() ) {
CString szPathName = pDoc->GetPathName();
if( szPathName.GetLength() ) dlg.m_szFolder = GetFileDirectory( szPathName );
}
} else {
if( ! dlg.m_szFolder.GetLength() ) {
TCHAR szTemp[MAX_PATH]; GetCurrentDirectory(MAX_PATH, szTemp);
dlg.m_szFolder = szTemp;
}
}
if( dlg.DoModal() != IDOK ) return;
CString szFindString = dlg.m_szFindString;
CString szFileType = dlg.m_szFileType;
CString szFolder = dlg.m_szFolder;
BOOL bLookSubfolders = dlg.m_bLookSubfolders;
UINT nOptions = COMPOSE_SEARCH_OPTION( dlg.m_bWholeWord, dlg.m_bMatchCase, dlg.m_bRegularExpression);
CRegExp clsTestRegExp; // compile regular expression for test
if( HAS_REG_EXP(nOptions) && ! clsTestRegExp.RegComp(szFindString) ) {
CString szMessage; szMessage.Format(IDS_ERR_REG_COMP_FAILED, szFindString);
AfxMessageBox(szMessage); return; // test failed
}
DoFindInFiles(szFindString, szFileType, szFolder, bLookSubfolders, nOptions);
}
bool CDVDSubtitleParserMicroDVD::Open(CDVDStreamInfo &hints)
{
if (!CDVDSubtitleParserText::Open())
return false;
CLog::Log(LOGDEBUG, "%s - framerate %d:%d", __FUNCTION__, hints.fpsrate, hints.fpsscale);
if (hints.fpsscale > 0 && hints.fpsrate > 0)
{
m_framerate = (double)hints.fpsscale / (double)hints.fpsrate;
m_framerate *= DVD_TIME_BASE;
}
else
m_framerate = DVD_TIME_BASE / 25.0;
char line[1024];
CRegExp reg;
if (!reg.RegComp("\\{([0-9]+)\\}\\{([0-9]+)\\}"))
return false;
CDVDSubtitleTagMicroDVD TagConv;
while (m_pStream->ReadLine(line, sizeof(line)))
{
if ((strlen(line) > 0) && (line[strlen(line) - 1] == '\r'))
line[strlen(line) - 1] = 0;
int pos = reg.RegFind(line);
if (pos > -1)
{
const char* text = line + pos + reg.GetFindLen();
std::string startFrame = reg.GetReplaceString("\\1");
std::string endFrame = reg.GetReplaceString("\\2");
CDVDOverlayText* pOverlay = new CDVDOverlayText();
pOverlay->Acquire(); // increase ref count with one so that we can hold a handle to this overlay
pOverlay->iPTSStartTime = m_framerate * atoi(startFrame.c_str());
pOverlay->iPTSStopTime = m_framerate * atoi(endFrame.c_str());
TagConv.ConvertLine(pOverlay, text, strlen(text));
m_collection.Add(pOverlay);
}
}
return true;
}
bool CDVDSubtitleParserVplayer::Open(CDVDStreamInfo &hints)
{
if (!CDVDSubtitleParserText::Open())
return false;
// Vplayer subtitles have 1-second resolution
m_framerate = DVD_TIME_BASE;
// Vplayer subtitles don't have StopTime, so we use following subtitle's StartTime
// for that, unless gap was more than 4 seconds. Then we set subtitle duration
// for 4 seconds, to not have text hanging around in silent scenes...
int iDefaultDuration = 4 * (int)m_framerate;
char line[1024];
CRegExp reg;
if (!reg.RegComp("([0-9]+):([0-9]+):([0-9]+):([^|]*?)(\\|([^|]*?))?$"))
return false;
CDVDOverlayText* pPrevOverlay = NULL;
while (m_pStream->ReadLine(line, sizeof(line)))
{
if (reg.RegFind(line) > -1)
{
std::string hour(reg.GetMatch(1));
std::string min (reg.GetMatch(2));
std::string sec (reg.GetMatch(3));
std::string lines[3];
lines[0] = reg.GetMatch(4);
lines[1] = reg.GetMatch(6);
lines[2] = reg.GetMatch(8);
CDVDOverlayText* pOverlay = new CDVDOverlayText();
pOverlay->Acquire(); // increase ref count with one so that we can hold a handle to this overlay
pOverlay->iPTSStartTime = m_framerate * (3600*atoi(hour.c_str()) + 60*atoi(min.c_str()) + atoi(sec.c_str()));
// set StopTime for previous overlay
if (pPrevOverlay)
{
if ( (pOverlay->iPTSStartTime - pPrevOverlay->iPTSStartTime) < iDefaultDuration)
pPrevOverlay->iPTSStopTime = pOverlay->iPTSStartTime;
else
pPrevOverlay->iPTSStopTime = pPrevOverlay->iPTSStartTime + iDefaultDuration;
}
pPrevOverlay = pOverlay;
for (int i = 0; i < 3 && !lines[i].empty(); i++)
pOverlay->AddElement(new CDVDOverlayText::CElementText(lines[i].c_str()));
m_collection.Add(pOverlay);
}
// set StopTime for the last subtitle
if (pPrevOverlay)
pPrevOverlay->iPTSStopTime = pPrevOverlay->iPTSStartTime + iDefaultDuration;
}
return true;
}
std::string FilterMessage(std::string message)
{
std::string filteredMessage = message;
CRegExp reg;
for (int i = 0; i < sizeof(filter) / 100; i++)
{
reg.RegComp(filter[i]);
int findStart = reg.RegFind(message.c_str());
while (findStart >= 0)
{
filteredMessage = message.substr(0, findStart);
filteredMessage.append(message.substr(findStart + reg.GetFindLen(), message.length()));
message = filteredMessage;
findStart = reg.RegFind(message.c_str());
}
}
return filteredMessage;
}
const std::vector<std::string> CTagLoaderTagLib::SplitMBID(const std::vector<std::string> &values)
{
if (values.empty() || values.size() > 1)
return values;
// Picard, and other taggers use a heap of different separators. We use a regexp to detect
// MBIDs to make sure we hit them all...
std::vector<std::string> ret;
std::string value = values[0];
StringUtils::ToLower(value);
CRegExp reg;
if (reg.RegComp("([[:xdigit:]]{8}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{12})"))
{
int pos = -1;
while ((pos = reg.RegFind(value, pos+1)) > -1)
ret.push_back(reg.GetMatch(1));
}
return ret;
}
bool CDVDSubtitleParserMPL2::Open(CDVDStreamInfo &hints)
{
if (!CDVDSubtitleParserText::Open())
return false;
// MPL2 is time-based, with 0.1s accuracy
m_framerate = DVD_TIME_BASE / 10.0;
char line[1024];
CRegExp reg;
if (!reg.RegComp("\\[([0-9]+)\\]\\[([0-9]+)\\]"))
return false;
CDVDSubtitleTagMicroDVD TagConv;
while (m_pStream->ReadLine(line, sizeof(line)))
{
if ((strlen(line) > 0) && (line[strlen(line) - 1] == '\r'))
line[strlen(line) - 1] = 0;
int pos = reg.RegFind(line);
if (pos > -1)
{
const char* text = line + pos + reg.GetFindLen();
char* startFrame = reg.GetReplaceString("\\1");
char* endFrame = reg.GetReplaceString("\\2");
CDVDOverlayText* pOverlay = new CDVDOverlayText();
pOverlay->Acquire(); // increase ref count with one so that we can hold a handle to this overlay
pOverlay->iPTSStartTime = m_framerate * atoi(startFrame);
pOverlay->iPTSStopTime = m_framerate * atoi(endFrame);
TagConv.ConvertLine(pOverlay, text, strlen(text));
free(startFrame);
free(endFrame);
m_collection.Add(pOverlay);
}
}
return true;
}
void CGUIDialogKeyboardGeneric::OnIPAddress()
{
// find any IP address in the current string if there is any
// We match to #.#.#.#
std::string text = GetText();
std::string ip;
CRegExp reg;
reg.RegComp("[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+");
int start = reg.RegFind(text.c_str());
int length = 0;
if (start > -1)
{
length = reg.GetSubLength(0);
ip = text.substr(start, length);
}
else
start = text.size();
if (CGUIDialogNumeric::ShowAndGetIPAddress(ip, g_localizeStrings.Get(14068)))
SetEditText(text.substr(0, start) + ip.c_str() + text.substr(start + length));
}
void ConsoleTools::RETest(){
SMatches match;
CRegExp *re;
bool res;
char text[255];
re = new CRegExp();
do{
printf("\nregexp:");
gets(text);
if (!re->setRE(&DString(text))) continue;
printf("exprn:");
gets(text);
res = re->parse(&DString(text), &match);
printf("%s\nmatch: ",res?"ok":"error");
for(int i = 0; i < match.cMatch; i++){
printf("%d:(%d,%d), ",i,match.s[i],match.e[i]);
}
}while(text[0]);
delete re;
}
TEST_F(TestRegExpLog, DumpOvector)
{
CRegExp regex;
CStdString logfile, logstring;
char buf[100];
unsigned int bytesread;
XFILE::CFile file;
logfile = CSpecialProtocol::TranslatePath("special://temp/") + "xbmc.log";
EXPECT_TRUE(CLog::Init(CSpecialProtocol::TranslatePath("special://temp/")));
EXPECT_TRUE(XFILE::CFile::Exists(logfile));
EXPECT_TRUE(regex.RegComp("^(?<first>Test)\\s*(?<second>.*)\\."));
EXPECT_EQ(0, regex.RegFind("Test string."));
regex.DumpOvector(LOGDEBUG);
CLog::Close();
EXPECT_TRUE(file.Open(logfile));
while ((bytesread = file.Read(buf, sizeof(buf) - 1)) > 0)
{
buf[bytesread] = '\0';
logstring.append(buf);
}
file.Close();
EXPECT_FALSE(logstring.empty());
EXPECT_STREQ("\xEF\xBB\xBF", logstring.substr(0, 3).c_str());
EXPECT_TRUE(regex.RegComp(".*DEBUG: regexp ovector=\\{\\[0,12\\],\\[0,4\\],"
"\\[5,11\\]\\}.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(XFILE::CFile::Delete(logfile));
}
TEST(TestRegExp, GetMatch)
{
CRegExp regex;
EXPECT_TRUE(regex.RegComp("^(Test)\\s*(.*)\\."));
EXPECT_EQ(0, regex.RegFind("Test string."));
EXPECT_STREQ("Test string.", regex.GetMatch(0).c_str());
EXPECT_STREQ("Test", regex.GetMatch(1).c_str());
EXPECT_STREQ("string", regex.GetMatch(2).c_str());
}
bool CDVDSubtitleParserSami::Open(CDVDStreamInfo &hints)
{
if (!m_pStream->Open(m_strFileName))
return false;
char line[1024];
char text[1024];
CRegExp reg;
if (!reg.RegComp("<SYNC START=([0-9]+)>"))
assert(0);
bool reuse=false;
while (reuse || m_pStream->ReadLine(line, sizeof(line)))
{
if (reg.RegFind(line) > -1)
{
char* startFrame = reg.GetReplaceString("\\1");
m_pStream->ReadLine(text,sizeof(text));
m_pStream->ReadLine(line,sizeof(line));
if (reg.RegFind(line) > -1)
{
char* endFrame = reg.GetReplaceString("\\1");
CDVDOverlayText* pOverlay = new CDVDOverlayText();
pOverlay->Acquire(); // increase ref count with one so that we can hold a handle to this overlay
pOverlay->iPTSStartTime = atoi(startFrame)*DVD_TIME_BASE/1000;
pOverlay->iPTSStopTime = atoi(endFrame)*DVD_TIME_BASE/1000;
CStdStringW strUTF16;
CStdStringA strUTF8;
g_charsetConverter.subtitleCharsetToW(text, strUTF16);
g_charsetConverter.wToUTF8(strUTF16, strUTF8);
if (strUTF8.IsEmpty())
continue;
// add a new text element to our container
pOverlay->AddElement(new CDVDOverlayText::CElementText(strUTF8.c_str()));
reuse = true;
free(endFrame);
m_collection.Add(pOverlay);
}
free(startFrame);
}
else
reuse = false;
}
return true;
}
TEST_F(Testlog, MemDump)
{
std::string logfile, logstring;
char buf[100];
unsigned int bytesread;
XFILE::CFile file;
CRegExp regex;
char refdata[] = "0123456789abcdefghijklmnopqrstuvwxyz";
std::string appName = CCompileInfo::GetAppName();
StringUtils::ToLower(appName);
logfile = CSpecialProtocol::TranslatePath("special://temp/") + appName + ".log";
EXPECT_TRUE(CLog::Init(CSpecialProtocol::TranslatePath("special://temp/").c_str()));
EXPECT_TRUE(XFILE::CFile::Exists(logfile));
CLog::MemDump(refdata, sizeof(refdata));
CLog::Close();
EXPECT_TRUE(file.Open(logfile));
while ((bytesread = file.Read(buf, sizeof(buf) - 1)) > 0)
{
buf[bytesread] = '\0';
logstring.append(buf);
}
file.Close();
EXPECT_FALSE(logstring.empty());
EXPECT_STREQ("\xEF\xBB\xBF", logstring.substr(0, 3).c_str());
EXPECT_TRUE(regex.RegComp(".*DEBUG: MEM_DUMP: Dumping from.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*DEBUG: MEM_DUMP: 0000 30 31 32 33.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*73 74 75 76 ghijklmnopqrstuv.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(XFILE::CFile::Delete(logfile));
}
bool CGUIDialogFirstTimeUseConfNetwork::ValidateFields()
{
CRegExp reg;
reg.RegComp(IP_REGEXP);
CStdString editStr = "";
// check IpAddress value
editStr = ((CGUIEditControl*)GetControl(CONTROL_IP_ADDRESS_EDIT))->GetLabel2();
if (reg.RegFind(editStr.c_str()) == -1)
{
CLog::Log(LOGERROR,"CGUIDialogFirstTimeUseConfNetwork::ValidateFields - [ipaddress=%s] is NOT valid (initbox)",editStr.c_str());
return false;
}
// check IpAddress value
editStr = ((CGUIEditControl*)GetControl(CONTROL_NETMASK_EDIT))->GetLabel2();
if (reg.RegFind(editStr.c_str()) == -1)
{
CLog::Log(LOGERROR,"CGUIDialogFirstTimeUseConfNetwork::ValidateFields - [netmask=%s] is NOT valid (initbox)",editStr.c_str());
return false;
}
// check IpAddress value
editStr = ((CGUIEditControl*)GetControl(CONTROL_GATEWAY_EDIT))->GetLabel2();
if (reg.RegFind(editStr.c_str()) == -1)
{
CLog::Log(LOGERROR,"CGUIDialogFirstTimeUseConfNetwork::ValidateFields - [gateway=%s] is NOT valid (initbox)",editStr.c_str());
return false;
}
// check IpAddress value
editStr = ((CGUIEditControl*)GetControl(CONTROL_DNS_EDIT))->GetLabel2();
if (reg.RegFind(editStr.c_str()) == -1)
{
CLog::Log(LOGERROR,"CGUIDialogFirstTimeUseConfNetwork::ValidateFields - [dns=%s] is NOT valid (initbox)",editStr.c_str());
return false;
}
return true;
}
bool CDAVFile::Execute(const CURL& url)
{
CURL url2(url);
ParseAndCorrectUrl(url2);
CLog::Log(LOGDEBUG, "CDAVFile::Execute(%p) %s", (void*)this, m_url.c_str());
assert(!(!m_state->m_easyHandle ^ !m_state->m_multiHandle));
if( m_state->m_easyHandle == NULL )
g_curlInterface.easy_aquire(url2.GetProtocol().c_str(),
url2.GetHostName().c_str(),
&m_state->m_easyHandle,
&m_state->m_multiHandle);
// setup common curl options
SetCommonOptions(m_state);
SetRequestHeaders(m_state);
lastResponseCode = m_state->Connect(m_bufferSize);
if( lastResponseCode < 0 || lastResponseCode >= 400)
return false;
char* efurl;
if (CURLE_OK == g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_EFFECTIVE_URL,&efurl) && efurl)
m_url = efurl;
if (lastResponseCode == 207)
{
std::string strResponse;
ReadData(strResponse);
CXBMCTinyXML davResponse;
davResponse.Parse(strResponse);
if (!davResponse.Parse(strResponse))
{
CLog::Log(LOGERROR, "%s - Unable to process dav response (%s)", __FUNCTION__, m_url.c_str());
Close();
return false;
}
TiXmlNode *pChild;
// Iterate over all responses
for (pChild = davResponse.RootElement()->FirstChild(); pChild != 0; pChild = pChild->NextSibling())
{
if (CDAVCommon::ValueWithoutNamespace(pChild, "response"))
{
std::string sRetCode = CDAVCommon::GetStatusTag(pChild->ToElement());
CRegExp rxCode;
rxCode.RegComp("HTTP/1\\.1\\s(\\d+)\\s.*");
if (rxCode.RegFind(sRetCode) >= 0)
{
if (rxCode.GetSubCount())
{
lastResponseCode = atoi(rxCode.GetMatch(1).c_str());
if( lastResponseCode < 0 || lastResponseCode >= 400)
return false;
}
}
}
}
}
return true;
}
bool CHTTPDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CFileCurl http;
CURI url(strPath);
CStdString strName, strLink;
CStdString strBasePath = url.GetFileName();
if(!http.Open(url))
{
CLog::Log(LOGERROR, "%s - Unable to get http directory", __FUNCTION__);
return false;
}
CRegExp reItem;
reItem.RegComp("<a href=\"(.*)\">(.*)</a>");
/* read response from server into string buffer */
char buffer[MAX_PATH + 1024];
while(http.ReadString(buffer, sizeof(buffer)-1))
{
CStdString strBuffer = buffer;
StringUtils::RemoveCRLF(strBuffer);
if (reItem.RegFind(strBuffer.c_str()) >= 0)
{
strLink = reItem.GetReplaceString("\\1");
strName = reItem.GetReplaceString("\\2");
if(strLink[0] == '/')
strLink = strLink.Mid(1);
CStdString strNameTemp = strName.Trim();
CStdString strLinkTemp = strLink;
CUtil::RemoveSlashAtEnd(strLinkTemp);
CUtil::RemoveSlashAtEnd(strNameTemp);
CUtil::UrlDecode(strLinkTemp);
if (strNameTemp == strLinkTemp)
{
g_charsetConverter.unknownToUTF8(strName);
CUtil::RemoveSlashAtEnd(strName);
CFileItemPtr pItem(new CFileItem(strName));
pItem->m_strPath = strBasePath + strLink;
pItem->SetProperty("IsHTTPDirectory", true);
if(CUtil::HasSlashAtEnd(pItem->m_strPath))
pItem->m_bIsFolder = true;
url.SetFileName(pItem->m_strPath);
pItem->m_strPath = url.Get();
if (!pItem->m_bIsFolder && g_advancedSettings.m_bHTTPDirectoryStatFilesize)
{
CFileCurl file;
file.Open(url);
pItem->m_dwSize= file.GetLength();
file.Close();
}
if (!pItem->m_bIsFolder && pItem->m_dwSize == 0)
{
CRegExp reSize;
reSize.RegComp(">([0-9.]+)(K|M|G)</td>");
if (reSize.RegFind(strBuffer.c_str()) >= 0)
{
double Size = atof(reSize.GetReplaceString("\\1"));
CStdString strUnit = reSize.GetReplaceString("\\2");
if (strUnit == "M")
Size = Size * 1024;
else if (strUnit == "G")
Size = Size * 1000 * 1024;
pItem->m_dwSize = (int64_t)(Size * 1024);
}
}
items.Add(pItem);
}
}
}
http.Close();
return true;
}
bool StringUtils::ValidateUUID(const CStdString &uuid)
{
CRegExp guidRE;
guidRE.RegComp(ADDON_GUID_RE);
return (guidRE.RegFind(uuid.c_str()) == 0);
}
bool CPlayerSelectionRule::CompileRegExp(const CStdString& str, CRegExp& regExp)
{
return str.length() > 0 && regExp.RegComp(str.c_str());
}
bool CMusicInfoTagLoaderSid::Load(const CStdString& strFileName, CMusicInfoTag& tag)
{
CStdString strFileToLoad = strFileName;
int iTrack = 0;
CStdString strExtension;
CUtil::GetExtension(strFileName,strExtension);
strExtension.MakeLower();
if (strExtension==".sidstream")
{
// Extract the track to play
CStdString strFile=CUtil::GetFileName(strFileName);
int iStart=strFile.ReverseFind("-")+1;
iTrack = atoi(strFile.substr(iStart, strFile.size()-iStart-10).c_str());
// The directory we are in, is the file
// that contains the bitstream to play,
// so extract it
CStdString strPath=strFileName;
CUtil::GetDirectory(strPath, strFileToLoad);
CUtil::RemoveSlashAtEnd(strFileToLoad); // we want the filename
}
CStdString strFileNameLower(strFileToLoad);
strFileNameLower.MakeLower();
int iHVSC = strFileNameLower.find("hvsc"); // need hvsc in path name since our lookupfile is based on hvsc paths
if (iHVSC < 0)
{
iHVSC = strFileNameLower.find("c64music");
if (iHVSC >= 0)
iHVSC += 8;
}
else
iHVSC += 4;
if( iHVSC < 0 )
{
tag.SetLoaded(false);
return( false );
}
CStdString strHVSCpath = strFileToLoad.substr(iHVSC,strFileToLoad.length()-1);
strHVSCpath.Replace('\\','/'); // unix paths
strHVSCpath.MakeLower();
char temp[8192];
CRegExp reg;
if (!reg.RegComp("TITLE: ([^\r\n]*)\r?\n[^A]*ARTIST: ([^\r\n]*)\r?\n"))
{
CLog::Log(LOGINFO,"MusicInfoTagLoaderSid::Load(..): failed to compile regular expression");
tag.SetLoaded(false);
return( false );
}
sprintf(temp,"%s\\%s",g_settings.GetDatabaseFolder().c_str(),"stil.txt"); // changeme?
std::ifstream f(temp);
if( !f.good() ) {
CLog::Log(LOGINFO,"MusicInfoTagLoaderSid::Load(..) unable to locate stil.txt");
tag.SetLoaded(false);
return( false );
}
const char* szStart = NULL;
const char* szEnd = NULL;
char temp2[8191];
char* temp3 = temp2;
while( !f.eof() && !szEnd )
{
f.read(temp,8191);
CStdString strLower = temp;
strLower.MakeLower();
if (!szStart)
szStart= (char *)strstr(strLower.c_str(),strHVSCpath.c_str());
if (szStart)
{
szEnd = strstr(szStart+strHVSCpath.size(),".sid");
if (szEnd)
{
memcpy(temp3,temp+(szStart-strLower.c_str()),szEnd-szStart);
temp3 += szEnd-szStart;
}
else
{
memcpy(temp3,temp+(szStart-strLower.c_str()),strlen(szStart));
szStart = NULL;
temp3 += strlen(szStart);
}
}
}
f.close();
if (!f.eof() && szEnd)
{
temp2[temp3-temp2] = '\0';
temp3 = strstr(temp2,"TITLE:");
}
else
temp3 = NULL;
if (temp3)
{
for (int i=0;i<iTrack-1;++i) // skip tracks
{
int iStart = reg.RegFind(temp3);
if (!iStart)
{
tag.SetLoaded(false);
return false;
}
temp3 += iStart;
}
if(reg.RegFind(temp3) > -1)
{
char* szTitle = reg.GetReplaceString("\\1");
char* szArtist = reg.GetReplaceString("\\2");
char* szMins = NULL;
char* szSecs = NULL;
CRegExp reg2;
reg2.RegComp("(.*) \\(([0-9]*):([0-9]*)\\)");
if (reg2.RegFind(szTitle) > -1)
{
szMins = reg2.GetReplaceString("\\2");
szSecs = reg2.GetReplaceString("\\3");
char* szTemp = reg2.GetReplaceString("\\1");
free(szTitle);
szTitle = szTemp;
}
tag.SetLoaded(true);
tag.SetURL(strFileToLoad);
tag.SetTrackNumber(iTrack);
if (szMins && szSecs)
tag.SetDuration(atoi(szMins)*60+atoi(szSecs));
tag.SetTitle(szTitle);
tag.SetArtist(szArtist);
if( szTitle )
free(szTitle);
if( szArtist )
free(szArtist);
if( szMins )
free(szMins);
if( szSecs )
free(szSecs);
}
}
sprintf(temp,"%s\\%s",g_settings.GetDatabaseFolder().c_str(),"sidlist.csv"); // changeme?
std::ifstream f2(temp);
if( !f2.good() ) {
CLog::Log(LOGINFO,"MusicInfoTagLoaderSid::Load(..) unable to locate sidlist.csv");
tag.SetLoaded(false);
return( false );
}
while( !f2.eof() ) {
f2.getline(temp,8191);
CStdString strTemp(temp);
strTemp.MakeLower();
unsigned int iFind = strTemp.find(strHVSCpath);
if (iFind == string::npos)
continue;
char temp2[1024];
char temp3[1024];
strncpy(temp3,temp+iFind,strlen(strHVSCpath));
temp3[strlen(strHVSCpath)] = '\0';
sprintf(temp2,"\"%s\",\"[^\"]*\",\"[^\"]*\",\"([^\"]*)\",\"([^\"]*)\",\"([0-9]*)[^\"]*\",\"[0-9]*\",\"[0-9]*\",\"",temp3);
for (int i=0;i<iTrack-1;++i)
strcat(temp2,"[0-9]*:[0-9]* ");
strcat(temp2,"([0-9]*):([0-9]*)");
if( !reg.RegComp(temp2) )
{
CLog::Log(LOGINFO,"MusicInfoTagLoaderSid::Load(..): failed to compile regular expression");
tag.SetLoaded(false);
return( false );
}
if( reg.RegFind(temp) >= 0 ) {
char* szTitle = reg.GetReplaceString("\\1");
char* szArtist = reg.GetReplaceString("\\2");
char* szYear = reg.GetReplaceString("\\3");
char* szMins = reg.GetReplaceString("\\4");
char* szSecs = reg.GetReplaceString("\\5");
tag.SetLoaded(true);
tag.SetTrackNumber(iTrack);
if (tag.GetDuration() == 0)
tag.SetDuration(atoi(szMins)*60+atoi(szSecs));
if (tag.GetTitle() == "")
tag.SetTitle(szTitle);
if (tag.GetArtist() == "")
tag.SetArtist(szArtist);
SYSTEMTIME dateTime;
dateTime.wYear = atoi(szYear);
tag.SetReleaseDate(dateTime);
if( szTitle )
free(szTitle);
if( szArtist )
free(szArtist);
if( szYear )
free(szYear);
if( szMins )
free(szMins);
if( szSecs )
free(szSecs);
f2.close();
return( true );
}
}
f2.close();
tag.SetLoaded(false);
return( false );
}
bool CPlayerSelectionRule::CompileRegExp(const std::string& str, CRegExp& regExp)
{
return !str.empty() && regExp.RegComp(str.c_str());
}
bool CPlayerSelectionRule::MatchesRegExp(const std::string& str, CRegExp& regExp)
{
return regExp.RegFind(str, 0) == 0;
}
TEST(TestZipManager, PathTraversal)
{
CRegExp pathTraversal;
pathTraversal.RegComp(PATH_TRAVERSAL);
ASSERT_TRUE(pathTraversal.RegFind("..") >= 0);
ASSERT_TRUE(pathTraversal.RegFind("../test.txt") >= 0);
ASSERT_TRUE(pathTraversal.RegFind("..\\test.txt") >= 0);
ASSERT_TRUE(pathTraversal.RegFind("test/../test.txt") >= 0);
ASSERT_TRUE(pathTraversal.RegFind("test\\../test.txt") >= 0);
ASSERT_TRUE(pathTraversal.RegFind("test\\..\\test.txt") >= 0);
ASSERT_FALSE(pathTraversal.RegFind("...") >= 0);
ASSERT_FALSE(pathTraversal.RegFind("..test.txt") >= 0);
ASSERT_FALSE(pathTraversal.RegFind("test.txt..") >= 0);
ASSERT_FALSE(pathTraversal.RegFind("test..test.txt") >= 0);
}
void CAndroidStorageProvider::GetRemovableDrives(VECSOURCES &removableDrives)
{
// mounted usb disks
char* buf = NULL;
FILE* pipe;
CRegExp reMount;
reMount.RegComp("^(.+?)\\s+(.+?)\\s+(.+?)\\s+(.+?)\\s");
/* /proc/mounts is only guaranteed atomic for the current read
* operation, so we need to read it all at once.
*/
if ((pipe = fopen("/proc/mounts", "r")))
{
char* new_buf;
size_t buf_len = 4096;
while ((new_buf = (char*)realloc(buf, buf_len * sizeof(char))))
{
size_t nread;
buf = new_buf;
nread = fread(buf, sizeof(char), buf_len, pipe);
if (nread == buf_len)
{
rewind(pipe);
buf_len *= 2;
}
else
{
buf[nread] = '\0';
if (!feof(pipe))
new_buf = NULL;
break;
}
}
if (!new_buf)
{
free(buf);
buf = NULL;
}
fclose(pipe);
}
else
CLog::Log(LOGERROR, "Cannot read mount points");
if (buf)
{
char* line;
char* saveptr = NULL;
line = strtok_r(buf, "\n", &saveptr);
while (line)
{
if (reMount.RegFind(line) != -1)
{
std::string deviceStr = reMount.GetReplaceString("\\1");
std::string mountStr = reMount.GetReplaceString("\\2");
std::string fsStr = reMount.GetReplaceString("\\3");
std::string optStr = reMount.GetReplaceString("\\4");
// Blacklist
bool bl_ok = true;
// Reject unreadable
if (!XFILE::CDirectory::Exists(mountStr))
bl_ok = false;
// What mount points are rejected
for (unsigned int i=0; i < ARRAY_SIZE(mountBL); ++i)
if (StringUtils::StartsWithNoCase(mountStr, mountBL[i]))
bl_ok = false;
if (bl_ok)
{
// What filesystems are accepted
bool fsok = false;
for (unsigned int i=0; i < ARRAY_SIZE(typeWL); ++i)
if (StringUtils::StartsWithNoCase(fsStr, typeWL[i]))
continue;
// What devices are accepted
bool devok = false;
for (unsigned int i=0; i < ARRAY_SIZE(deviceWL); ++i)
if (StringUtils::StartsWithNoCase(deviceStr, deviceWL[i]))
devok = true;
// What mount points are accepted
bool mountok = false;
for (unsigned int i=0; i < ARRAY_SIZE(mountWL); ++i)
if (StringUtils::StartsWithNoCase(mountStr, mountWL[i]))
mountok = true;
if(devok && (fsok || mountok))
{
CMediaSource share;
share.strPath = unescape(mountStr);
share.strName = URIUtils::GetFileName(mountStr);
share.m_ignore = true;
removableDrives.push_back(share);
}
}
}
line = strtok_r(NULL, "\n", &saveptr);
}
free(buf);
}
}
void CAndroidStorageProvider::GetRemovableDrives(VECSOURCES &removableDrives)
{
// mounted usb disks
char* buf = NULL;
FILE* pipe;
std::map<std::string, std::string> result;
CRegExp reMount;
reMount.RegComp("^(.+?)\\s+(.+?)\\s+(.+?)\\s");
/* /proc/mounts is only guaranteed atomic for the current read
* operation, so we need to read it all at once.
*/
if ((pipe = fopen("/proc/mounts", "r")))
{
char* new_buf;
size_t buf_len = 4096;
while ((new_buf = (char*)realloc(buf, buf_len * sizeof(char))))
{
size_t nread;
buf = new_buf;
nread = fread(buf, sizeof(char), buf_len, pipe);
if (nread == buf_len)
{
rewind(pipe);
buf_len *= 2;
}
else
{
buf[nread] = '\0';
if (!feof(pipe))
new_buf = NULL;
break;
}
}
if (!new_buf)
{
free(buf);
buf = NULL;
}
fclose(pipe);
}
else
CLog::Log(LOGERROR, "Cannot read mount points");
if (buf)
{
char* line;
char* saveptr = NULL;
line = strtok_r(buf, "\n", &saveptr);
while (line)
{
if (reMount.RegFind(line) != -1)
{
bool accepted = false;
std::string device = reMount.GetReplaceString("\\1");
std::string mountStr = reMount.GetReplaceString("\\2");
std::string fsStr = reMount.GetReplaceString("\\3");
const char* fs = fsStr.c_str();
// Here we choose which filesystems are approved
if (strcmp(fs, "fuseblk") == 0 || strcmp(fs, "vfat") == 0
|| strcmp(fs, "ext2") == 0 || strcmp(fs, "ext3") == 0 || strcmp(fs, "ext4") == 0
|| strcmp(fs, "reiserfs") == 0 || strcmp(fs, "xfs") == 0
|| strcmp(fs, "ntfs-3g") == 0 || strcmp(fs, "iso9660") == 0
|| strcmp(fs, "exfat") == 0
|| strcmp(fs, "fusefs") == 0 || strcmp(fs, "hfs") == 0)
accepted = true;
// Ignore sdcards
if (!StringUtils::StartsWith(device, "/dev/block/vold/") ||
mountStr.find("sdcard") != std::string::npos ||
mountStr.find("secure/asec") != std::string::npos)
accepted = false;
if(accepted)
result[device] = mountStr;
}
line = strtok_r(NULL, "\n", &saveptr);
}
free(buf);
}
for (std::map<std::string, std::string>::const_iterator i = result.begin(); i != result.end(); ++i)
{
CMediaSource share;
share.strPath = unescape(i->second);
share.strName = URIUtils::GetFileName(share.strPath);
share.m_ignore = true;
removableDrives.push_back(share);
}
}
TEST_F(Testlog, Log)
{
std::string logfile, logstring;
char buf[100];
unsigned int bytesread;
XFILE::CFile file;
CRegExp regex;
std::string appName = CCompileInfo::GetAppName();
StringUtils::ToLower(appName);
logfile = CSpecialProtocol::TranslatePath("special://temp/") + appName + ".log";
EXPECT_TRUE(CLog::Init(CSpecialProtocol::TranslatePath("special://temp/").c_str()));
EXPECT_TRUE(XFILE::CFile::Exists(logfile));
CLog::Log(LOGDEBUG, "debug log message");
CLog::Log(LOGINFO, "info log message");
CLog::Log(LOGNOTICE, "notice log message");
CLog::Log(LOGWARNING, "warning log message");
CLog::Log(LOGERROR, "error log message");
CLog::Log(LOGSEVERE, "severe log message");
CLog::Log(LOGFATAL, "fatal log message");
CLog::Log(LOGNONE, "none type log message");
CLog::Close();
EXPECT_TRUE(file.Open(logfile));
while ((bytesread = file.Read(buf, sizeof(buf) - 1)) > 0)
{
buf[bytesread] = '\0';
logstring.append(buf);
}
file.Close();
EXPECT_FALSE(logstring.empty());
EXPECT_STREQ("\xEF\xBB\xBF", logstring.substr(0, 3).c_str());
EXPECT_TRUE(regex.RegComp(".*DEBUG: debug log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*INFO: info log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*NOTICE: notice log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*WARNING: warning log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*ERROR: error log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*SEVERE: severe log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*FATAL: fatal log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(regex.RegComp(".*NONE: none type log message.*"));
EXPECT_GE(regex.RegFind(logstring), 0);
EXPECT_TRUE(XFILE::CFile::Delete(logfile));
}