////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// EXECute executable file
HRESULT EXEC(PTSTR ptzCmd)
{
STARTUPINFO si = {0};
PROCESS_INFORMATION pi;
si.cb = sizeof(STARTUPINFO);
si.lpDesktop = TEXT("WinSta0\\Default");
BOOL bWait = FALSE;
BOOL bRunKey = FALSE;
while (TRUE)
{
if (*ptzCmd == '!') si.dwFlags = STARTF_USESHOWWINDOW;
else if (*ptzCmd == '@') si.lpDesktop = TEXT("WinSta0\\WinLogon");
else if (*ptzCmd == '=') bWait = TRUE;
else if (*ptzCmd == '&') bRunKey = TRUE;
else break;
ptzCmd++;
}
if (bRunKey)
{
PTSTR ptzName = UStrRChr(ptzCmd, '\\');
ptzName = ptzName ? (ptzName + 1) : ptzCmd;
HKEY hKey = bWait ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
return SHSetValue(hKey, TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run"), ptzName, REG_SZ, ptzCmd, UStrLen(ptzCmd) * sizeof(TCHAR));
}
TCHAR tzCurDir[MAX_PATH];
UStrCopy(tzCurDir, ptzCmd);
PTSTR ptzEnd;
if (tzCurDir[0] == '"')
{
ptzEnd = UStrChr(tzCurDir + 1, '"');
}
else if ((ptzEnd = UStrChr(tzCurDir + 1, ' ')) == NULL)
{
ptzEnd = tzCurDir + UStrLen(tzCurDir);
}
while ((ptzEnd >= tzCurDir) && (*ptzEnd != '\\')) ptzEnd--;
*ptzEnd = 0;
BOOL bResult = CreateProcess(NULL, ptzCmd, NULL, NULL, FALSE, 0, NULL, tzCurDir, &si, &pi);
if (bResult)
{
if (bWait)
{
WaitForSingleObject(pi.hProcess, INFINITE);
}
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
}
return bResult ? S_OK : S_FALSE;
}
T_VOID Fwl_RemoveEndFileSymbol(T_U16* filename)
{
T_U16 i = UStrLen(filename);
while(i--)
{
if (UNICODE_DOT == filename[i])
{
filename[i] = UNICODE_END;
break;
}
}
return;
}
//like A: is error path ,must be A:/
T_BOOL Fwl_GetLongPath(T_U16 lPathName[], const T_U16 basePath[], const T_U16 rltPath[])
{
T_U16 basePathLen= UStrLen(basePath);
T_U16 endChar= basePath[basePathLen- 1];
T_U16 pathSymbol= basePath[2];
UStrCpy(lPathName, basePath); //A:/ A:/record the second char is the path symbol
if(endChar != UNICODE_SOLIDUS && endChar != UNICODE_RES_SOLIDUS)
{
lPathName[basePathLen]= pathSymbol;
lPathName[basePathLen+ 1]= '\0';
}
UStrCat(lPathName, rltPath);
return AK_TRUE;
}
/**************************************************************************
* @brief if dir is disk path then do nothing else remove the directory Symbol
* '/' or '\'
* @author zhao_xiaowei
* @date 2008
* @param dir a file or directory
* @return T_VOID
***************************************************************************/
static T_VOID Fwl_RemoveEndDirSymbol(T_U16 dir[])
{
T_U16 len= UStrLen(dir);
if(len <= 2)
{
return ;
}
if(dir[len- 1] == UNICODE_SOLIDUS || dir[len- 1] == UNICODE_RES_SOLIDUS)
{
if(len != 3)//A:/
{
dir[len- 1]= 0;
}
}
}
UINT DevDir(PCTSTR ptzDir, PCTSTR ptzDevID, PCTSTR ptzClass)
{
TCHAR tzPath[MAX_NAME];
if (ptzDir[0] == '\\')
{
ptzDir++;
TCHAR tzDrives[MAX_NAME];
GetLogicalDriveStrings(MAX_NAME, tzDrives);
for (PTSTR p = tzDrives; *p; p += UStrLen(p) + 1)
{
UStrPrint(tzPath, TEXT("%s%s"), p, ptzDir);
DevDir(tzPath, ptzDevID, ptzClass);
}
return S_OK;
}
WIN32_FIND_DATA fd;
UStrPrint(tzPath, TEXT("%s\\INF\\*.INF"), ptzDir);
HANDLE hFind = FindFirstFile(tzPath, &fd);
if (hFind == INVALID_HANDLE_VALUE)
{
return ERROR_FILE_NOT_FOUND;
}
do
{
UStrPrint(tzPath, TEXT("%s\\INF\\%s"), ptzDir, fd.cFileName);
if (ptzClass)
{
GUID idClass;
TCHAR tzClass[MAX_NAME];
SetupDiGetINFClass(tzPath, &idClass, tzClass, MAX_NAME, NULL);
if (UStrCmpI(tzClass, ptzClass))
{
continue;
}
}
PCTSTR p = DevGetInf(ptzDevID, tzPath);
if (p)
{
DevIns(p, tzPath, 0);
}
}
while (FindNextFile(hFind, &fd));
FindClose(hFind);
return S_OK;
}
// Lookup device ID from INFs
PCTSTR DevGetInf(PCTSTR ptzDevID, PCTSTR ptzSrcInf)
{
PVOID pvFile = UFileLoad(ptzSrcInf, NULL, NULL);
if (pvFile)
{
BOOL bASCII = ((PBYTE) pvFile)[3];//!IsTextUnicode(pvFile, -1, NULL); // Trick for UNICODE
for (ptzDevID++; ptzDevID[-1]; ptzDevID += UStrLen(ptzDevID) + 2)
{
if (bASCII ? TStrStr((PSTR) pvFile, ptzDevID, ptzDevID[-1]) : TStrStr((PWSTR) pvFile, ptzDevID, ptzDevID[-1]))
{
Log(IDS_FoundDriver, ptzDevID, ptzSrcInf);
UMemFree(pvFile);
return ptzDevID;
}
}
UMemFree(pvFile);
}
return NULL;
}
/**************************************************************************
* @brief if lFileName is file then get the directory else if lFileName is
* directory then get the parent directory
* @author zhao_xiaowei
* @date 2008
* @param longDir[out]
* @param lFileName[in]
* @return T_BOOL
* @retval AK_TURE is success
* @retval
***************************************************************************/
static T_BOOL Fwl_GetFileDir(T_U16 longDir[], T_U16 lFileName[])
{
T_S16 pos;
T_U16 len;
T_BOOL bRet;
len= UStrLen(lFileName);
if(len <= 3) //A A: A:\ disk path have no parent dir
{
return AK_FALSE;
}
else
{
Fwl_RemoveEndDirSymbol(lFileName);
}
pos= UStrRevFndR(strUSolidus, lFileName, 0);
if(pos < 0)
{
pos= UStrRevFndR(strURevSolidus, lFileName, 0);
if(pos < 0)
{
return AK_FALSE;
}
}
if(pos == 2)
{
pos++; // A:/ pos=2 len=2+1
}
bRet= UStrSub(longDir, lFileName, 0, pos);
if(bRet)
{
bRet= Fwl_FsIsDir(longDir);//justify is file or not
}
return bRet;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// REGistry eXecution
HRESULT REGX(PTSTR ptzCmd)
{
HKEY hRoot = GetRootKey(ptzCmd);
if (!hRoot)
{
return E_INVALIDARG;
}
PTSTR ptzVal = UStrChr(ptzCmd, '=');
if (ptzVal)
{
*ptzVal++ = 0;
}
PTSTR ptzName = UStrRChr(ptzCmd, '\\');
if (!ptzName)
{
return E_INVALIDARG;
}
else
{
*ptzName++ = 0;
}
HKEY hKey;
HRESULT hResult = RegCreateKeyEx(hRoot, ptzCmd, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hKey, NULL);
if (hResult != S_OK)
{
return hResult;
}
if (ptzVal)
{
if (*ptzName == '#')
{
DWORD dwData = UStrToInt(ptzVal);
hResult = RegSetValueEx(hKey, ptzName + 1, 0, REG_DWORD, (PBYTE) &dwData, sizeof(DWORD));
}
else if (*ptzName == '@')
{
UINT i = 0;
PBYTE pbVal = (PBYTE) ptzVal;
while (*ptzVal)
{
pbVal[i++] = (UChrToHex(ptzVal[0]) << 4) | UChrToHex(ptzVal[1]);
while (*ptzVal && (*ptzVal++ != ','));
}
hResult = RegSetValueEx(hKey, ptzName + 1, 0, REG_BINARY, pbVal, i);
}
else
{
hResult = RegSetValueEx(hKey, ptzName, 0, REG_SZ, (PBYTE) ptzVal, (UStrLen(ptzVal) + 1) * sizeof(TCHAR));
}
}
else
{
if (*ptzName == '-')
{
if (ptzName[1])
{
hResult = RegDeleteValue(hKey, ptzName + 1);
}
else
{
RegCloseKey(hKey);
return SHDeleteKey(hRoot, ptzCmd);
}
}
else if (*ptzName == '#')
{
DWORD dwSize = sizeof(hResult);
RegQueryValueEx(hKey, ptzName + 1, NULL, NULL, (PBYTE) &hResult, &dwSize);
}
else
{
g_tzXVar[0][0] = 0;
DWORD dwSize = sizeof(g_tzXVar[0]);
hResult = RegQueryValueEx(hKey, ptzName, NULL, NULL, (PBYTE) g_tzXVar[0], &dwSize);
}
}
RegCloseKey(hKey);
return hResult;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// FILE or directory operation
HRESULT FILe(PTSTR ptzCmd, UINT uLen = -1)
{
SHFILEOPSTRUCT so = {0};
so.pFrom = ptzCmd;
so.wFunc = FO_DELETE;
so.fFlags = FOF_NOCONFIRMATION | FOF_NOCONFIRMMKDIR | FOF_SILENT;
BOOL bAppend;
PTSTR p = ptzCmd;
for (; *p; p++)
{
switch (*p)
{
case ';':
*p = 0;
break;
case '\\':
if (!p[1])
{
return !UDirCreate(ptzCmd);
}
break;
case '>':
if (p[-1] == '=')
{
p[-1] = 0;
so.pTo = p + 1;
so.wFunc = FO_COPY;
}
else if (p[-1] == '-')
{
p[-1] = 0;
so.pTo = p + 1;
so.wFunc = FO_MOVE;
}
*p = 0;
break;
case '<':
*p++ = 0;
bAppend = (*p++ == '=');
uLen = ((uLen == -1) ? UStrLen(p) : (uLen - (UINT) (p - ptzCmd)));
#ifdef _UNICODE
CHAR szFile[MAX_STR];
uLen = WideCharToMultiByte(CP_ACP, 0, p, uLen, szFile, sizeof(szFile), NULL, NULL);
p = (PTSTR) szFile;
#endif
return !UFileSave(ptzCmd, p, uLen, bAppend);
case '{':
*p++ = 0;
bAppend = (*p++ == '=');
uLen = ((uLen == -1) ? UStrLen(p) : (uLen - (UINT) (p - ptzCmd)));
#ifndef _UNICODE
WCHAR wzFile[MAX_STR];
uLen = MultiByteToWideChar(CP_ACP, 0, p, uLen, wzFile, _NumOf(wzFile));
p = (PTSTR) wzFile;
#endif
return !UFileSave(ptzCmd, p, uLen * sizeof(WCHAR), bAppend);
}
}
#ifdef _COPY
if ((so.wFunc == FO_COPY) && UDirExist(so.pFrom))
{
return !CopyDir(so.pFrom, so.pTo);
}
#endif
TCHAR t = p[1];
p[1] = 0;
HRESULT hResult = SHFileOperation(&so);
p[1] = t;
return hResult;
}
HRESULT LINK(PTSTR ptzCmd)
{
// Parse Shortcut,Target,Param,IconPath,IconIndex
PTSTR ptzTarget = UStrChr(ptzCmd, CC_SEP);
if (ptzTarget == NULL)
{
return ERROR_PATH_NOT_FOUND;
}
INT iIcon = 0;
PTSTR ptzIcon = NULL;
*ptzTarget++ = 0;
PTSTR ptzParam = UStrChr(ptzTarget, CC_SEP);
if (ptzParam)
{
*ptzParam++ = 0;
ptzIcon = UStrChr(ptzParam, CC_SEP);
if (ptzIcon)
{
*ptzIcon++ = 0;
PTSTR ptzIndex = UStrChr(ptzIcon, CC_SEP);
if (ptzIndex)
{
*ptzIndex++ = 0;
iIcon = UStrToInt(ptzIndex);
}
}
}
// Search target
if (*ptzCmd == '*')
{
ptzCmd++;
}
else
{
TCHAR tzTarget[MAX_PATH];
if (SearchPath(NULL, ptzTarget, NULL, MAX_PATH, tzTarget, NULL))
{
ptzTarget = tzTarget;
}
else if (!UDirExist(ptzTarget))
{
return ERROR_PATH_NOT_FOUND;
}
}
// Create shortcut
IShellLink *pLink;
CoInitialize(NULL);
HRESULT hResult = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (PVOID *) &pLink);
if (hResult == S_OK)
{
IPersistFile *pFile;
hResult = pLink->QueryInterface(IID_IPersistFile, (PVOID *) &pFile);
if (hResult == S_OK)
{
if (*ptzCmd == '!')
{
ptzCmd++;
hResult = pLink->SetShowCmd(SW_SHOWMINIMIZED);
}
// Shortcut settings
hResult = pLink->SetPath(ptzTarget);
hResult = pLink->SetArguments(ptzParam);
hResult = pLink->SetIconLocation(ptzIcon, iIcon);
if (UPathSplit(ptzTarget) != ptzTarget)
{
hResult = pLink->SetWorkingDirectory(ptzTarget);
}
// Save link
WCHAR wzLink[MAX_PATH];
if (UStrCmpI(ptzCmd + UStrLen(ptzCmd) - 4, TEXT(".LNK")))
{
UStrCat(ptzCmd, TEXT(".LNK"));
}
UStrToWStr(wzLink, ptzCmd, MAX_PATH);
UDirCreate(ptzCmd);
hResult = pFile->Save(wzLink, FALSE);
pFile->Release();
}
pLink->Release();
}
CoUninitialize();
return hResult;
}
PTSTR Expand(PTSTR ptzDst, TCHAR tMacro, CXT& XT)
{
INT i;
switch (tMacro)
{
case 'E':
for (PCTSTR p = XT.ptzFile; *p; *ptzDst++ = *p++);
return ptzDst;
case 'C':
if (PCTSTR q = UStrRChr(XT.ptzFile, '\\'))
{
for (PCTSTR p = XT.ptzFile; p < q; *ptzDst++ = *p++);
}
return ptzDst;
case 'T':
ptzDst += GetTimeFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL, ptzDst, MAX_NAME) - 1;
return ptzDst;
case 'D':
ptzDst += GetDateFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL, ptzDst, MAX_NAME) - 1;
return ptzDst;
case 'X':
case 'x':
ptzDst += UStrPrint(ptzDst, (tMacro == 'X') ? TEXT("%#X") : TEXT("%d"), XT.hXVar);
return ptzDst;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
for (PTSTR p = g_tzXVar[tMacro - '0']; *p; p++) *ptzDst++ = *p;
return ptzDst;
case 'A': i = CSIDL_APPDATA; break;
case 'Y': i = CSIDL_MYDOCUMENTS; break;
case 'S': i = CSIDL_STARTUP; break;
case 'M': i = CSIDL_STARTMENU; break;
case 'P': i = CSIDL_PROGRAMS; break;
case 'V': i = CSIDL_FAVORITES; break;
case 'Z': i = CSIDL_MYPICTURES; break;
case 'U': i = CSIDL_MYMUSIC; break;
case 'I': i = CSIDL_MYVIDEO; break;
case 'F': i = CSIDL_PROGRAM_FILES; break;
case 'O': i = CSIDL_SENDTO; break;
case 'o': i = CSIDL_DESKTOPDIRECTORY; break;
case 'd': i = CSIDL_COMMON_DESKTOPDIRECTORY; break;
case 'a': i = CSIDL_COMMON_APPDATA; break;
case 'y': i = CSIDL_COMMON_DOCUMENTS; break;
case 's': i = CSIDL_COMMON_STARTUP; break;
case 'm': i = CSIDL_COMMON_STARTMENU; break;
case 'p': i = CSIDL_COMMON_PROGRAMS; break;
case 'v': i = CSIDL_COMMON_FAVORITES; break;
case 'z': i = CSIDL_COMMON_PICTURES; break;
case 'u': i = CSIDL_COMMON_MUSIC; break;
case 'i': i = CSIDL_COMMON_VIDEO; break;
case 'f': i = CSIDL_PROGRAM_FILES_COMMON; break;
case 'W': case 'w': i = CSIDL_WINDOWS; break;
case 'R': *ptzDst++ = '\r'; return ptzDst;
case 'N': *ptzDst++ = '\n'; return ptzDst;
default: *ptzDst++ = tMacro; return ptzDst;
}
SHGetSpecialFolderPath(NULL, ptzDst, i, TRUE);
ptzDst += UStrLen(ptzDst);
return ptzDst;
}
// ENVIronment
HRESULT ENVI(PTSTR ptzEnv, BOOL bSystem)
{
TCHAR tzStr[MAX_STR];
if (!ptzEnv[0] || (ptzEnv[0] == '='))
{
for (UINT i = 0; i < _NumOf(c_sMacro); i++)
{
if (ptzEnv[0]/* == '='*/)
{
ENVI((PTSTR) c_sMacro[i].ptzMacro, bSystem);
continue;
}
PTSTR p = tzStr + UStrPrint(tzStr, TEXT("%s="), c_sMacro[i].ptzMacro);
if (SHGetSpecialFolderPath(NULL, p, c_sMacro[i].iFolder, TRUE))
{
if (c_sMacro[i].iFolder == CSIDL_APPDATA)
{
// Trick
UStrCat(p, TEXT("\\Microsoft\\Internet Explorer\\Quick Launch\\"));
UDirCreate(p);
CreateDirectory(p, NULL);
}
ENVI(tzStr, bSystem);
}
}
if (ptzEnv[0]/* == '='*/)
{
return ENVI((PTSTR) STR_AppName, bSystem);
}
else
{
UStrPrint(tzStr, TEXT("%s=%s/%s"), STR_AppName, STR_VersionStamp, STR_BuildStamp);
return ENVI(tzStr, bSystem);
}
}
if (bSystem)
{
UStrPrint(tzStr, TEXT("HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment\\%s"), ptzEnv);
REGX(tzStr);
}
PTSTR ptzValue = UStrChr(ptzEnv, '=');
if (ptzValue)
{
// Trick : If no '=', ptzEnv can be a constant string.
*ptzValue++ = 0;
}
HRESULT hResult = SetEnvironmentVariable(ptzEnv, ptzValue) ? S_OK : GetLastError();
if (bSystem)
{
if (!ptzValue)
{
ptzValue = ptzEnv + UStrLen(ptzEnv) + 1;
}
DWORD dwResult = 0;
SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, 0, (LPARAM) TEXT("Environment"), SMTO_ABORTIFHUNG, 5000, &dwResult);
}
return hResult;
}
HRESULT DEVI(PTSTR ptzCmd)
{
// Lookup device
HDEVINFO hDev = SetupDiGetClassDevs(NULL, NULL, 0, DIGCF_ALLCLASSES);
if (hDev == INVALID_HANDLE_VALUE)
{
return E_FAIL;
}
// Build SPDRP_HARDWAREID list
TCHAR tzDevID[MAX_DevID];
PTSTR p = tzDevID + 1;
SP_DEVINFO_DATA sdDev = {sizeof(SP_DEVINFO_DATA)};
for (UINT i = 0; (NUM_DevID < MAX_DevID) && SetupDiEnumDeviceInfo(hDev, i, &sdDev); i++)
{
#if (_MSC_VER < 1300)
PCM_Get_DevNode_Status CM_Get_DevNode_Status = (PCM_Get_DevNode_Status) GetProcAddress(GetModuleHandle(TEXT("SetupAPI")), "CM_Get_DevNode_Status");
if (CM_Get_DevNode_Status)
#endif
{
// Exclude configured device
ULONG uProblem = 0;
ULONG uStatus = DN_HAS_PROBLEM;
CM_Get_DevNode_Status(&uStatus, &uProblem, sdDev.DevInst, 0);
if (uProblem != CM_PROB_NOT_CONFIGURED)
{
#ifndef _DEBUG
continue;
#endif
}
}
// Get device ID
if (SetupDiGetDeviceRegistryProperty(hDev, &sdDev, SPDRP_HARDWAREID, NULL, (PBYTE) p, MAX_DevID - NUM_DevID, NULL) && UStrCmpNI(p, TEXT("ACPI"), 4))
{
Log(IDS_FoundDevice, p);
// Trim some stuff for quick search
UINT j = 0;
for (UINT k = 0; p[j]; j++)
{
if ((p[j] == '&') && (++k == 2))
{
break;
}
}
p[-1] = j;
for (p += j; *p; p++);
p += 2;
}
}
p[-1] = 0;
SetupDiDestroyDeviceInfoList(hDev);
if (tzDevID[0] == 0)
{
// No device
return ERROR_NO_MATCH;
}
// Parse param
BOOL bInstall = (ptzCmd[0] == '$');
if (bInstall) ptzCmd++;
PTSTR ptzClass = UStrChr(ptzCmd, ',');
if (ptzClass) *ptzClass++ = 0;
if (UStrCmpI(ptzCmd + UStrLen(ptzCmd) - 4, TEXT(".CAB")))
{
// Lookup driver from directory
return DevDir(ptzCmd, tzDevID, ptzClass);
}
else
{
// Lookup CAB file
TCHAR tzDevInf[MAX_PATH * 16];
g_ptzDevInf = tzDevInf;
HRESULT hResult = SetupIterateCabinet(ptzCmd, 0, (PSP_FILE_CALLBACK) DevCab, tzDevID) ? S_OK : E_FAIL;
if (bInstall)
{
for (PTSTR p = tzDevInf; p < g_ptzDevInf; p += UStrLen(p) + 1)
{
PTSTR ptzDevID = p;
p += UStrLen(p) + 1;
DevIns(ptzDevID, p);
}
}
return hResult;
}
}
UINT CALLBACK DevCab(PVOID pvContext, UINT uMsg, UINT_PTR upParam1, UINT_PTR upParam2)
{
static UINT s_uExtract = 0;
if (uMsg == SPFILENOTIFY_FILEINCABINET)
{
PTSTR ptzTarget = ((FILE_IN_CABINET_INFO*) upParam1)->FullTargetName;
PCTSTR ptzName = ((FILE_IN_CABINET_INFO*) upParam1)->NameInCabinet;
PCTSTR p = UStrRChr(ptzName, '\\');
if (p)
{
ptzName = p + 1;
}
// Extract INF or driver file
p = ptzName + UStrLen(ptzName) - 4;
if (UStrCmpI(p, TEXT(".INF")) == 0)
{
p = TEXT("%SystemRoot%\\INF\\");
}
else if (s_uExtract)
{
if (UStrCmpI(p, TEXT(".SYS")) == 0)
{
p = TEXT("%SystemRoot%\\SYSTEM32\\DRIVERS\\");
}
else if (UStrCmpI(p, TEXT(".DLL")) == 0)
{
p = TEXT("%SystemRoot%\\SYSTEM32\\");
}
else
{
p = TEXT("%SystemRoot%\\");
}
}
else
{
// Skip
return FILEOP_SKIP;
}
ExpandEnvironmentStrings(p, ptzTarget, MAX_PATH);
UStrCat(ptzTarget, ptzName);
UStrRep(ptzTarget, '#', '\\');
UDirCreate(ptzTarget);
return FILEOP_DOIT;
}
else if (uMsg == SPFILENOTIFY_FILEEXTRACTED)
{
PCTSTR ptzTarget = ((FILEPATHS*) upParam1)->Target;
if (UStrCmpI(ptzTarget + UStrLen(ptzTarget) - 4, TEXT(".INF")))
{
// Not INF
s_uExtract++;
return NO_ERROR;
}
// Get Device from INF
PCTSTR ptzDevID = DevGetInf((PCTSTR) pvContext, ptzTarget);
if (ptzDevID)
{
// Found Driver
s_uExtract = 1;
do {*g_ptzDevInf++ = *ptzDevID;} while (*ptzDevID++);
do {*g_ptzDevInf++ = *ptzTarget;} while (*ptzTarget++);
return NO_ERROR;
}
// Delete INF
if (s_uExtract != 1)
{
// Driver has been extracted completely.
s_uExtract = 0;
UFileDelete(ptzTarget);
}
}
return NO_ERROR;
}
T_BOOL Fwl_FsExistDeepMatch(T_pCWSTR path, T_U16 *pattern, T_U16 *outPath, T_U32 deep)
{
T_FINDBUFCTRL bufCtrl;
T_U32 FindHandle;
T_U32 FileCnt = 0;
T_U32 FolderCnt = 0;
#ifdef SUPPORT_MUSIC_PLAY
T_U32 count = 0;
#endif
T_hFILEINFO hFileInfo;
T_U16 SubDirLen;
T_BOOL FindFlag = AK_FALSE;
AK_ASSERT_PTR(outPath, "DeepMatch", AK_FALSE);
if(path == AK_NULL)
{
return AK_FALSE;
}
if(deep >= FS_FIND_MAX_DEEP)
{
return AK_FALSE;
}
bufCtrl.NodeCnt = 1;
bufCtrl.pattern = pattern;
bufCtrl.patternLen = UStrLen(pattern);
bufCtrl.type = FILTER_NOTITERATE | FILTER_FOLDER;
FindHandle = File_FindFirst(path, &bufCtrl);
if(0 == FindHandle)
{
return AK_FALSE;
}
if(outPath != path)
{
UStrCpy(outPath, path);
}
do
{
hFileInfo = (T_hFILEINFO)File_FindInfo(FindHandle, 0, &FileCnt, &FolderCnt);
if((0 != FileCnt) || (!Fwl_IsFolder(hFileInfo)))
{
FindFlag = AK_TRUE;
break;
}
else
{
SubDirLen = UStrLen(outPath);
if(outPath[SubDirLen - 1] != '\\' && outPath[SubDirLen - 1] != '/')
{
outPath[SubDirLen] = '\\';
outPath[SubDirLen+1] = 0;
}
if(MAX_FILE_LEN > SubDirLen + 1)
{ //限制字符串长度
Utl_UStrCatN(outPath, Fwl_GetName(hFileInfo), MAX_FILE_LEN - SubDirLen - 1);
if(AK_TRUE == Fwl_FsExistDeepMatch(outPath, pattern, outPath, deep+1))
{
FindFlag = AK_TRUE;
break;
}
}
}
outPath[SubDirLen] = 0;
} while(File_FindNext(FindHandle, 1));
File_FindClose(FindHandle);
return FindFlag;
}
