extern "C" bool ArchExtractFilesW(HZIP hZip,WCHAR *pstrPath) { bool r=false; ZIPDECOMPRESSION *p=(ZIPDECOMPRESSION*)hZip; if ((hZip) && (pstrPath) && (p->bHandleType == HT_DECOMPRESSOR)) { lstrcpyW(p->strOutputDir,pstrPath); unzGoToFirstFile(p->hZip); if (!p->bInMem) { WCHAR filePath[MAX_PATH],fileName[MAX_PATH],*pstrFile; lstrcpyW(filePath,p->strZipFile); pstrFile=PathFindFileNameW(filePath); PathRemoveFileSpecW(filePath); lstrcpyW(fileName,pstrFile); PathAddBackslashW(filePath); } r=(InternalEnumFiles(hZip) < 0) ? false : true; } else ArchSetLastError(ARCH_INVALID_PARAMETER); return r; }
std::wstring BaseTest::MakeDataPath(LPCWSTR folder, LPCWSTR file) { WCHAR filename[MAX_PATH]; if (folder && *folder) { lstrcpynW(filename, s_datapath, MAX_PATH); PathAppendW(filename, folder); } else { lstrcpynW(filename, s_temppath, MAX_PATH); ::CreateDirectoryW(s_temppath, NULL); } if (file && *file) { PathAppendW(filename, file); } else { PathAddBackslashW(filename); } return filename; }
void BaseTest::MakeRootPath(LPWSTR path, LPCWSTR name) { WCHAR filename[MAX_PATH]; if (0 == path[0]) { GetModuleFileNameW(NULL, filename, MAX_PATH); PathRemoveFileSpecW(filename); PathAppendW(filename, L"UnitTests.ini"); lstrcpynW(path, filename, MAX_PATH); PathRemoveFileSpecW(path); // bin\vc80\debug\tests PathRemoveFileSpecW(path); // bin\vc80\debug PathRemoveFileSpecW(path); // bin\vc80 PathRemoveFileSpecW(path); // bin PathAppendW(path, name); // bin\name GetPrivateProfileStringW(L"Path", name, path, path, MAX_PATH, filename); PathAddBackslashW(path); SetFileAttributesW(filename, FILE_ATTRIBUTE_NORMAL); WritePrivateProfileStringW(L"Path", name, path, filename); } }
/************************************************************************** * CreateFolderEnumList() */ BOOL CreateFolderEnumList(IEnumIDListImpl *list, LPCWSTR lpszPath, DWORD dwFlags) { LPITEMIDLIST pidl=NULL; WIN32_FIND_DATAW stffile; HANDLE hFile; WCHAR szPath[MAX_PATH]; BOOL succeeded = TRUE; static const WCHAR stars[] = { '*','.','*',0 }; static const WCHAR dot[] = { '.',0 }; static const WCHAR dotdot[] = { '.','.',0 }; TRACE("(%p)->(path=%s flags=0x%08x)\n", list, debugstr_w(lpszPath), dwFlags); if(!lpszPath || !lpszPath[0]) return FALSE; strcpyW(szPath, lpszPath); PathAddBackslashW(szPath); strcatW(szPath,stars); hFile = FindFirstFileW(szPath,&stffile); if ( hFile != INVALID_HANDLE_VALUE ) { BOOL findFinished = FALSE; do { if ( !(stffile.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) || (dwFlags & SHCONTF_INCLUDEHIDDEN) ) { if ( (stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && dwFlags & SHCONTF_FOLDERS && strcmpW(stffile.cFileName, dot) && strcmpW(stffile.cFileName, dotdot)) { pidl = _ILCreateFromFindDataW(&stffile); succeeded = succeeded && AddToEnumList(list, pidl); } else if (!(stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && dwFlags & SHCONTF_NONFOLDERS) { pidl = _ILCreateFromFindDataW(&stffile); succeeded = succeeded && AddToEnumList(list, pidl); } } if (succeeded) { if (!FindNextFileW(hFile, &stffile)) { if (GetLastError() == ERROR_NO_MORE_FILES) findFinished = TRUE; else succeeded = FALSE; } } } while (succeeded && !findFinished); FindClose(hFile); } return succeeded; }
/*********************************************************************** * SHELL32_CoCreateInitSF * * Creates a shell folder and initializes it with a pidl and a root folder * via IPersistFolder3 or IPersistFolder. * * NOTES * pathRoot can be NULL for Folders being a drive. * In this case the absolute path is built from pidlChild (eg. C:) */ static HRESULT SHELL32_CoCreateInitSF (LPCITEMIDLIST pidlRoot, LPCWSTR pathRoot, LPCITEMIDLIST pidlChild, REFCLSID clsid, IShellFolder** ppsfOut) { HRESULT hr; CComPtr<IShellFolder> pShellFolder; TRACE ("%p %s %p\n", pidlRoot, debugstr_w(pathRoot), pidlChild); hr = SHCoCreateInstance(NULL, &clsid, NULL, IID_PPV_ARG(IShellFolder, &pShellFolder)); if (SUCCEEDED (hr)) { LPITEMIDLIST pidlAbsolute = ILCombine (pidlRoot, pidlChild); CComPtr<IPersistFolder> ppf; CComPtr<IPersistFolder3> ppf3; if (SUCCEEDED(pShellFolder->QueryInterface(IID_PPV_ARG(IPersistFolder3, &ppf3)))) { PERSIST_FOLDER_TARGET_INFO ppfti; ZeroMemory (&ppfti, sizeof (ppfti)); /* fill the PERSIST_FOLDER_TARGET_INFO */ ppfti.dwAttributes = -1; ppfti.csidl = -1; /* build path */ if (pathRoot) { lstrcpynW (ppfti.szTargetParsingName, pathRoot, MAX_PATH - 1); PathAddBackslashW(ppfti.szTargetParsingName); /* FIXME: why have drives a backslash here ? */ } if (pidlChild) { int len = wcslen(ppfti.szTargetParsingName); if (!_ILSimpleGetTextW(pidlChild, ppfti.szTargetParsingName + len, MAX_PATH - len)) hr = E_INVALIDARG; } ppf3->InitializeEx(NULL, pidlAbsolute, &ppfti); } else if (SUCCEEDED((hr = pShellFolder->QueryInterface(IID_PPV_ARG(IPersistFolder, &ppf))))) { ppf->Initialize(pidlAbsolute); } ILFree (pidlAbsolute); } *ppsfOut = pShellFolder.Detach(); TRACE ("-- (%p) ret=0x%08x\n", *ppsfOut, hr); return hr; }
/************************************************************************** * ISF_ControlPanel_fnGetDisplayNameOf */ static HRESULT WINAPI ISF_ControlPanel_fnGetDisplayNameOf(IShellFolder2 * iface, LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet) { ICPanelImpl *This = (ICPanelImpl *)iface; CHAR szPath[MAX_PATH]; WCHAR wszPath[MAX_PATH+1]; /* +1 for potential backslash */ PIDLCPanelStruct* pcpanel; *szPath = '\0'; TRACE("(%p)->(pidl=%p,0x%08lx,%p)\n", This, pidl, dwFlags, strRet); pdump(pidl); if (!pidl || !strRet) return E_INVALIDARG; pcpanel = _ILGetCPanelPointer(pidl); if (pcpanel) { lstrcpyA(szPath, pcpanel->szName+pcpanel->offsDispName); if (!(dwFlags & SHGDN_FORPARSING)) FIXME("retrieve display name from control panel app\n"); } /* take names of special folders only if its only this folder */ else if (_ILIsSpecialFolder(pidl)) { BOOL bSimplePidl = _ILIsPidlSimple(pidl); if (bSimplePidl) { _ILSimpleGetTextW(pidl, wszPath, MAX_PATH); /* append my own path */ } else { FIXME("special pidl\n"); } if ((dwFlags & SHGDN_FORPARSING) && !bSimplePidl) { /* go deeper if needed */ int len = 0; PathAddBackslashW(wszPath); len = lstrlenW(wszPath); if (!SUCCEEDED (SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags | SHGDN_INFOLDER, wszPath + len, MAX_PATH + 1 - len))) return E_OUTOFMEMORY; if (!WideCharToMultiByte(CP_ACP, 0, wszPath, -1, szPath, MAX_PATH, NULL, NULL)) wszPath[0] = '\0'; } } strRet->uType = STRRET_CSTR; lstrcpynA(strRet->u.cStr, szPath, MAX_PATH); TRACE("--(%p)->(%s)\n", This, szPath); return S_OK; }
/*************************************************************************** * SHELL32_GetCustomFolderAttribute (internal function) * * Gets a value from the folder's desktop.ini file, if one exists. * * PARAMETERS * pidl [I] Folder containing the desktop.ini file. * pwszHeading [I] Heading in .ini file. * pwszAttribute [I] Attribute in .ini file. * pwszValue [O] Buffer to store value into. * cchValue [I] Size in characters including NULL of buffer pointed to * by pwszValue. * * RETURNS * TRUE if returned non-NULL value. * FALSE otherwise. */ static inline BOOL SHELL32_GetCustomFolderAttributeFromPath( LPWSTR pwszFolderPath, LPCWSTR pwszHeading, LPCWSTR pwszAttribute, LPWSTR pwszValue, DWORD cchValue) { static const WCHAR wszDesktopIni[] = {'d','e','s','k','t','o','p','.','i','n','i',0}; static const WCHAR wszDefault[] = {0}; PathAddBackslashW(pwszFolderPath); PathAppendW(pwszFolderPath, wszDesktopIni); return GetPrivateProfileStringW(pwszHeading, pwszAttribute, wszDefault, pwszValue, cchValue, pwszFolderPath); }
/************************************************************************** * RenderHDROP * * creates a CF_HDROP structure */ HGLOBAL RenderHDROP(LPITEMIDLIST pidlRoot, LPITEMIDLIST * apidl, UINT cidl) { UINT i; int rootlen = 0,size = 0; WCHAR wszRootPath[MAX_PATH]; WCHAR wszFileName[MAX_PATH]; HGLOBAL hGlobal; DROPFILES *pDropFiles; int offset; TRACE("(%p,%p,%u)\n", pidlRoot, apidl, cidl); /* get the size needed */ size = sizeof(DROPFILES); SHGetPathFromIDListW(pidlRoot, wszRootPath); PathAddBackslashW(wszRootPath); rootlen = strlenW(wszRootPath); for (i=0; i<cidl;i++) { _ILSimpleGetTextW(apidl[i], wszFileName, MAX_PATH); size += (rootlen + strlenW(wszFileName) + 1) * sizeof(WCHAR); } size += sizeof(WCHAR); /* Fill the structure */ hGlobal = GlobalAlloc(GHND|GMEM_SHARE, size); if(!hGlobal) return hGlobal; pDropFiles = (DROPFILES *)GlobalLock(hGlobal); offset = (sizeof(DROPFILES) + sizeof(WCHAR) - 1) / sizeof(WCHAR); pDropFiles->pFiles = offset * sizeof(WCHAR); pDropFiles->fWide = TRUE; strcpyW(wszFileName, wszRootPath); for (i=0; i<cidl;i++) { _ILSimpleGetTextW(apidl[i], wszFileName + rootlen, MAX_PATH - rootlen); strcpyW(((WCHAR*)pDropFiles)+offset, wszFileName); offset += strlenW(wszFileName) + 1; } ((WCHAR*)pDropFiles)[offset] = 0; GlobalUnlock(hGlobal); return hGlobal; }
/************************************************************************** * CDesktopFolderEnumZ::CreateFontsEnumList() */ BOOL CDesktopFolderEnumZ::CreateFontsEnumList(DWORD dwFlags) { WCHAR szPath[MAX_PATH]; WCHAR szName[LF_FACESIZE+20]; WCHAR szFile[MAX_PATH]; LPWSTR pszPath; UINT Length; LONG ret; DWORD dwType, dwName, dwFile, dwIndex; LPITEMIDLIST pidl; HKEY hKey; if (dwFlags & SHCONTF_NONFOLDERS) { if (!SHGetSpecialFolderPathW(NULL, szPath, CSIDL_FONTS, FALSE)) return FALSE; pszPath = PathAddBackslashW(szPath); if (!pszPath) return FALSE; if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts", 0, KEY_READ, &hKey) != ERROR_SUCCESS) return FALSE; Length = pszPath - szPath; dwIndex = 0; do { dwName = sizeof(szName) / sizeof(WCHAR); dwFile = sizeof(szFile) / sizeof(WCHAR); ret = RegEnumValueW(hKey, dwIndex++, szName, &dwName, NULL, &dwType, (LPBYTE)szFile, &dwFile); if (ret == ERROR_SUCCESS) { szFile[(sizeof(szFile)/sizeof(WCHAR))-1] = L'\0'; if (dwType == REG_SZ && wcslen(szFile) + Length + 1 < (sizeof(szPath) / sizeof(WCHAR))) { wcscpy(&szPath[Length], szFile); pidl = _ILCreateFontItem(szName, szPath); TRACE("pidl %p name %s path %s\n", pidl, debugstr_w(szName), debugstr_w(szPath)); if (pidl) { if (!AddToEnumList(pidl)) SHFree(pidl); } } } } while(ret != ERROR_NO_MORE_ITEMS); RegCloseKey(hKey); } return TRUE; }
/*********************************************************************** * SHELL32_CoCreateInitSF * * Creates a shell folder and initializes it with a pidl and a root folder * via IPersistFolder3 or IPersistFolder. * * NOTES * pathRoot can be NULL for Folders being a drive. * In this case the absolute path is built from pidlChild (eg. C:) */ static HRESULT SHELL32_CoCreateInitSF (LPCITEMIDLIST pidlRoot, LPCWSTR pathRoot, LPCITEMIDLIST pidlChild, REFCLSID clsid, LPVOID * ppvOut) { HRESULT hr; TRACE ("(%p %s %p %s %p)\n", pidlRoot, debugstr_w(pathRoot), pidlChild, debugstr_guid(clsid), ppvOut); hr = SHCoCreateInstance(NULL, clsid, NULL, &IID_IShellFolder, ppvOut); if (SUCCEEDED (hr)) { LPITEMIDLIST pidlAbsolute = ILCombine (pidlRoot, pidlChild); IPersistFolder *pPF; IPersistFolder3 *ppf; if (_ILIsFolder(pidlChild) && SUCCEEDED (IUnknown_QueryInterface ((IUnknown *) * ppvOut, &IID_IPersistFolder3, (LPVOID *) & ppf))) { PERSIST_FOLDER_TARGET_INFO ppfti; ZeroMemory (&ppfti, sizeof (ppfti)); /* fill the PERSIST_FOLDER_TARGET_INFO */ ppfti.dwAttributes = -1; ppfti.csidl = -1; /* build path */ if (pathRoot) { lstrcpynW (ppfti.szTargetParsingName, pathRoot, MAX_PATH - 1); PathAddBackslashW(ppfti.szTargetParsingName); /* FIXME: why have drives a backslash here ? */ } if (pidlChild) { int len = lstrlenW(ppfti.szTargetParsingName); if (!_ILSimpleGetTextW(pidlChild, ppfti.szTargetParsingName + len, MAX_PATH - len)) hr = E_INVALIDARG; } IPersistFolder3_InitializeEx (ppf, NULL, pidlAbsolute, &ppfti); IPersistFolder3_Release (ppf); } else if (SUCCEEDED ((hr = IUnknown_QueryInterface ((IUnknown *) * ppvOut, &IID_IPersistFolder, (LPVOID *) & pPF)))) { IPersistFolder_Initialize (pPF, pidlAbsolute); IPersistFolder_Release (pPF); } ILFree (pidlAbsolute); } TRACE ("-- (%p) ret=0x%08x\n", *ppvOut, hr); return hr; }
void Cx_PluginLoader::MakeFullPath(wchar_t* fullpath, HMODULE instance, const wchar_t* path) { if (!path || 0 == path[0] || PathIsRelativeW(path)) { GetModuleFileNameW(instance, fullpath, MAX_PATH); PathRemoveFileSpecW(fullpath); PathAppendW(fullpath, path); } else { wcscpy_s(fullpath, MAX_PATH, path); } ReplaceSlashes(fullpath); PathAddBackslashW(fullpath); }
HRESULT CDesktopFolder::_GetSFFromPidl(LPCITEMIDLIST pidl, IShellFolder2** psf) { WCHAR szFileName[MAX_PATH]; lstrcpynW(szFileName, sPathTarget, MAX_PATH - 1); PathAddBackslashW(szFileName); int cLen = wcslen(szFileName); if (!_ILSimpleGetTextW(pidl, szFileName + cLen, MAX_PATH - cLen)) return E_FAIL; ERR("%S\n", szFileName); if (GetFileAttributes(szFileName) == INVALID_FILE_ATTRIBUTES) return m_SharedDesktopFSFolder->QueryInterface(IID_PPV_ARG(IShellFolder2, psf)); else return m_DesktopFSFolder->QueryInterface(IID_PPV_ARG(IShellFolder2, psf)); }
void SHELL32_GetCLSIDForDirectory(LPCWSTR pathRoot, LPCITEMIDLIST pidl, CLSID* pclsidFolder) { static const WCHAR wszDotShellClassInfo[] = { '.','S','h','e','l','l','C','l','a','s','s','I','n','f','o',0 }; static const WCHAR wszCLSID[] = {'C','L','S','I','D',0}; WCHAR wszCLSIDValue[CHARS_IN_GUID], wszFolderPath[MAX_PATH], *pwszPathTail = wszFolderPath; /* see if folder CLSID should be overridden by desktop.ini file */ if (pathRoot) { lstrcpynW(wszFolderPath, pathRoot, MAX_PATH); pwszPathTail = PathAddBackslashW(wszFolderPath); } _ILSimpleGetTextW(pidl,pwszPathTail,MAX_PATH - (int)(pwszPathTail - wszFolderPath)); if (SHELL32_GetCustomFolderAttributeFromPath (wszFolderPath, wszDotShellClassInfo, wszCLSID, wszCLSIDValue, CHARS_IN_GUID)) CLSIDFromString (wszCLSIDValue, pclsidFolder); }
static LPWSTR app_search_file(LPWSTR path, MSISIGNATURE *sig) { VS_FIXEDFILEINFO *info; DWORD attr, handle, size; LPWSTR val = NULL; LPBYTE buffer; if (!sig->File) { PathRemoveFileSpecW(path); PathAddBackslashW(path); attr = GetFileAttributesW(path); if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY)) return strdupW(path); return NULL; } attr = GetFileAttributesW(path); if (attr == INVALID_FILE_ATTRIBUTES || (attr & FILE_ATTRIBUTE_DIRECTORY)) return NULL; size = GetFileVersionInfoSizeW(path, &handle); if (!size) return strdupW(path); buffer = msi_alloc(size); if (!buffer) return NULL; if (!GetFileVersionInfoW(path, 0, size, buffer)) goto done; if (!VerQueryValueW(buffer, szBackSlash, (LPVOID)&info, &size) || !info) goto done; if (sig->MinVersionLS || sig->MinVersionMS) { if (info->dwFileVersionMS < sig->MinVersionMS) goto done; if (info->dwFileVersionMS == sig->MinVersionMS && info->dwFileVersionLS < sig->MinVersionLS) goto done; } if (sig->MaxVersionLS || sig->MaxVersionMS) { if (info->dwFileVersionMS > sig->MaxVersionMS) goto done; if (info->dwFileVersionMS == sig->MaxVersionMS && info->dwFileVersionLS > sig->MaxVersionLS) goto done; } val = strdupW(path); done: msi_free(buffer); return val; }
DWORD MMSYS_InstallDevice(HDEVINFO hDevInfo, PSP_DEVINFO_DATA pspDevInfoData) { UINT Length; LPWSTR pBuffer; WCHAR szBuffer[MAX_PATH]; HINF hInf; PVOID Context; BOOL Result; SC_HANDLE hSCManager, hService; WCHAR WaveName[20]; HKEY hKey; DWORD BufferSize; ULONG Index; if (!IsEqualIID(&pspDevInfoData->ClassGuid, &GUID_DEVCLASS_SOUND) && !IsEqualIID(&pspDevInfoData->ClassGuid, &GUID_DEVCLASS_MEDIA)) return ERROR_DI_DO_DEFAULT; Length = GetWindowsDirectoryW(szBuffer, MAX_PATH); if (!Length || Length >= MAX_PATH - 14) { return ERROR_GEN_FAILURE; } pBuffer = PathAddBackslashW(szBuffer); if (!pBuffer) { return ERROR_GEN_FAILURE; } wcscpy(pBuffer, L"inf\\audio.inf"); hInf = SetupOpenInfFileW(szBuffer, NULL, INF_STYLE_WIN4, NULL); if (hInf == INVALID_HANDLE_VALUE) { return ERROR_GEN_FAILURE; } Context = SetupInitDefaultQueueCallback(NULL); if (Context == NULL) { SetupCloseInfFile(hInf); return ERROR_GEN_FAILURE; } Result = SetupInstallFromInfSectionW(NULL, hInf, L"AUDIO_Inst.NT", SPINST_ALL, NULL, NULL, SP_COPY_NEWER, SetupDefaultQueueCallbackW, Context, NULL, NULL); if (Result) { Result = SetupInstallServicesFromInfSectionW(hInf, L"Audio_Inst.NT.Services", 0); } SetupTermDefaultQueueCallback(Context); SetupCloseInfFile(hInf); hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT); if (!hSCManager) { return ERROR_DI_DO_DEFAULT; } hService = OpenService(hSCManager, L"RosAudioSrv", SERVICE_ALL_ACCESS); if (hService) { /* Make RosAudioSrv start automatically */ ChangeServiceConfig(hService, SERVICE_NO_CHANGE, SERVICE_AUTO_START, SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL); StartService(hService, 0, NULL); CloseServiceHandle(hService); } CloseServiceHandle(hSCManager); if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32", 0, GENERIC_READ | GENERIC_WRITE, &hKey) == ERROR_SUCCESS) { szBuffer[Length] = '\0'; pBuffer = PathAddBackslashW(szBuffer); wcscpy(pBuffer, L"system32\\wdmaud.drv"); for(Index = 1; Index <= 4; Index++) { swprintf(WaveName, L"wave%u", Index); if (RegQueryValueExW(hKey, WaveName, 0, NULL, NULL, &BufferSize) != ERROR_MORE_DATA) { /* Store new audio driver entry */ RegSetValueExW(hKey, WaveName, 0, REG_SZ, (LPBYTE)szBuffer, (wcslen(szBuffer)+1) * sizeof(WCHAR)); break; } else { WCHAR Buffer[MAX_PATH]; BufferSize = sizeof(Buffer); if (RegQueryValueExW(hKey, WaveName, 0, NULL, (LPBYTE)Buffer, &BufferSize) == ERROR_SUCCESS) { /* Make sure the buffer is zero terminated */ Buffer[MAX_PATH-1] = L'\0'; if (!wcsicmp(Buffer, szBuffer)) { /* An entry already exists */ break; } } } } RegCloseKey(hKey); } InstallSystemSoundScheme(); return ERROR_DI_DO_DEFAULT; }
/************************************************************************** * ISF_Desktop_fnGetDisplayNameOf * * NOTES * special case: pidl = null gives desktop-name back */ static HRESULT WINAPI ISF_Desktop_fnGetDisplayNameOf (IShellFolder2 * iface, LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet) { IDesktopFolderImpl *This = impl_from_IShellFolder2(iface); HRESULT hr = S_OK; LPWSTR pszPath; TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", This, pidl, dwFlags, strRet); pdump (pidl); if (!strRet) return E_INVALIDARG; pszPath = CoTaskMemAlloc((MAX_PATH +1) * sizeof(WCHAR)); if (!pszPath) return E_OUTOFMEMORY; if (_ILIsDesktop (pidl)) { if ((GET_SHGDN_RELATION (dwFlags) == SHGDN_NORMAL) && (GET_SHGDN_FOR (dwFlags) & SHGDN_FORPARSING)) strcpyW(pszPath, This->sPathTarget); else HCR_GetClassNameW(&CLSID_ShellDesktop, pszPath, MAX_PATH); } else if (_ILIsPidlSimple (pidl)) { GUID const *clsid; if ((clsid = _ILGetGUIDPointer (pidl))) { if (GET_SHGDN_FOR (dwFlags) & SHGDN_FORPARSING) { int bWantsForParsing; /* * We can only get a filesystem path from a shellfolder if the * value WantsFORPARSING in CLSID\\{...}\\shellfolder exists. * * Exception: The MyComputer folder doesn't have this key, * but any other filesystem backed folder it needs it. */ if (IsEqualIID (clsid, &CLSID_MyComputer)) { bWantsForParsing = TRUE; } else { /* get the "WantsFORPARSING" flag from the registry */ static const WCHAR clsidW[] = { 'C','L','S','I','D','\\',0 }; static const WCHAR shellfolderW[] = { '\\','s','h','e','l','l','f','o','l','d','e','r',0 }; static const WCHAR wantsForParsingW[] = { 'W','a','n','t','s','F','o','r','P','a','r','s','i','n', 'g',0 }; WCHAR szRegPath[100]; LONG r; lstrcpyW (szRegPath, clsidW); SHELL32_GUIDToStringW (clsid, &szRegPath[6]); lstrcatW (szRegPath, shellfolderW); r = SHGetValueW(HKEY_CLASSES_ROOT, szRegPath, wantsForParsingW, NULL, NULL, NULL); if (r == ERROR_SUCCESS) bWantsForParsing = TRUE; else bWantsForParsing = FALSE; } if ((GET_SHGDN_RELATION (dwFlags) == SHGDN_NORMAL) && bWantsForParsing) { /* * we need the filesystem path to the destination folder. * Only the folder itself can know it */ hr = SHELL32_GetDisplayNameOfChild (iface, pidl, dwFlags, pszPath, MAX_PATH); } else { /* parsing name like ::{...} */ pszPath[0] = ':'; pszPath[1] = ':'; SHELL32_GUIDToStringW (clsid, &pszPath[2]); } } else { /* user friendly name */ HCR_GetClassNameW (clsid, pszPath, MAX_PATH); } } else { int cLen = 0; /* file system folder or file rooted at the desktop */ if ((GET_SHGDN_FOR(dwFlags) == SHGDN_FORPARSING) && (GET_SHGDN_RELATION(dwFlags) != SHGDN_INFOLDER)) { lstrcpynW(pszPath, This->sPathTarget, MAX_PATH - 1); PathAddBackslashW(pszPath); cLen = lstrlenW(pszPath); } _ILSimpleGetTextW(pidl, pszPath + cLen, MAX_PATH - cLen); if (!_ILIsFolder(pidl)) SHELL_FS_ProcessDisplayFilename(pszPath, dwFlags); } } else { /* a complex pidl, let the subfolder do the work */ hr = SHELL32_GetDisplayNameOfChild (iface, pidl, dwFlags, pszPath, MAX_PATH); } if (SUCCEEDED(hr)) { /* Win9x always returns ANSI strings, NT always returns Unicode strings */ if (GetVersion() & 0x80000000) { strRet->uType = STRRET_CSTR; if (!WideCharToMultiByte(CP_ACP, 0, pszPath, -1, strRet->u.cStr, MAX_PATH, NULL, NULL)) strRet->u.cStr[0] = '\0'; CoTaskMemFree(pszPath); } else { strRet->uType = STRRET_WSTR; strRet->u.pOleStr = pszPath; } } else CoTaskMemFree(pszPath); TRACE ("-- (%p)->(%s,0x%08x)\n", This, strRet->uType == STRRET_CSTR ? strRet->u.cStr : debugstr_w(strRet->u.pOleStr), hr); return hr; }
/************************************************************************** * ISF_Desktop_fnParseDisplayName * * NOTES * "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" and "" binds * to MyComputer */ static HRESULT WINAPI ISF_Desktop_fnParseDisplayName (IShellFolder2 * iface, HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName, DWORD * pchEaten, LPITEMIDLIST * ppidl, DWORD * pdwAttributes) { IDesktopFolderImpl *This = impl_from_IShellFolder2(iface); IShellFolder *shell_folder = (IShellFolder*)iface; WCHAR szElement[MAX_PATH]; LPCWSTR szNext = NULL; LPITEMIDLIST pidlTemp = NULL; PARSEDURLW urldata; HRESULT hr = S_OK; CLSID clsid; TRACE ("(%p)->(HWND=%p,%p,%p=%s,%p,pidl=%p,%p)\n", This, hwndOwner, pbc, lpszDisplayName, debugstr_w(lpszDisplayName), pchEaten, ppidl, pdwAttributes); if (!ppidl) return E_INVALIDARG; *ppidl = 0; if (!lpszDisplayName) return E_INVALIDARG; if (pchEaten) *pchEaten = 0; /* strange but like the original */ urldata.cbSize = sizeof(urldata); if (lpszDisplayName[0] == ':' && lpszDisplayName[1] == ':') { szNext = GetNextElementW (lpszDisplayName, szElement, MAX_PATH); TRACE ("-- element: %s\n", debugstr_w (szElement)); SHCLSIDFromStringW (szElement + 2, &clsid); pidlTemp = _ILCreateGuid (PT_GUID, &clsid); } else if (PathGetDriveNumberW (lpszDisplayName) >= 0) { /* it's a filesystem path with a drive. Let MyComputer/UnixDosFolder parse it */ if (UNIXFS_is_rooted_at_desktop()) pidlTemp = _ILCreateGuid(PT_GUID, &CLSID_UnixDosFolder); else pidlTemp = _ILCreateMyComputer (); szNext = lpszDisplayName; } else if (PathIsUNCW(lpszDisplayName)) { pidlTemp = _ILCreateNetwork(); szNext = lpszDisplayName; } else if( (pidlTemp = SHELL32_CreatePidlFromBindCtx(pbc, lpszDisplayName)) ) { *ppidl = pidlTemp; return S_OK; } else if (SUCCEEDED(ParseURLW(lpszDisplayName, &urldata))) { if (urldata.nScheme == URL_SCHEME_SHELL) /* handle shell: urls */ { TRACE ("-- shell url: %s\n", debugstr_w(urldata.pszSuffix)); SHCLSIDFromStringW (urldata.pszSuffix+2, &clsid); pidlTemp = _ILCreateGuid (PT_GUID, &clsid); } else return IEParseDisplayNameWithBCW(CP_ACP,lpszDisplayName,pbc,ppidl); } else { /* it's a filesystem path on the desktop. Let a FSFolder parse it */ if (*lpszDisplayName) { if (*lpszDisplayName == '/') { /* UNIX paths should be parsed by unixfs */ IShellFolder *unixFS; hr = UnixFolder_Constructor(NULL, &IID_IShellFolder, (LPVOID*)&unixFS); if (SUCCEEDED(hr)) { hr = IShellFolder_ParseDisplayName(unixFS, NULL, NULL, lpszDisplayName, NULL, &pidlTemp, NULL); IShellFolder_Release(unixFS); } } else { /* build a complete path to create a simple pidl */ WCHAR szPath[MAX_PATH]; LPWSTR pathPtr; lstrcpynW(szPath, This->sPathTarget, MAX_PATH); pathPtr = PathAddBackslashW(szPath); if (pathPtr) { lstrcpynW(pathPtr, lpszDisplayName, MAX_PATH - (pathPtr - szPath)); hr = _ILCreateFromPathW(szPath, &pidlTemp); } else { /* should never reach here, but for completeness */ hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER); } } } else pidlTemp = _ILCreateMyComputer(); szNext = NULL; } if (SUCCEEDED(hr) && pidlTemp) { if (szNext && *szNext) { hr = SHELL32_ParseNextElement(iface, hwndOwner, pbc, &pidlTemp, (LPOLESTR) szNext, pchEaten, pdwAttributes); } else { if (pdwAttributes && *pdwAttributes) hr = SHELL32_GetItemAttributes(shell_folder, pidlTemp, pdwAttributes); } } *ppidl = pidlTemp; TRACE ("(%p)->(-- ret=0x%08x)\n", This, hr); return hr; }
int PASCAL wWinMain(HINSTANCE hInstance, HINSTANCE prev, LPWSTR cmdline, int show) { LPWSTR *argv; int argc; int i; WCHAR check, cmd = 0; WCHAR path[MAX_PATH]; LPCWSTR cabfile = NULL; path[0] = 0; /* Do not use CommandLineToArgvW() or __wgetmainargs() to parse * command line for this program. It should treat each quote as argument * delimiter. This doesn't match with behavior of mentioned functions. * Do not use args provided by wmain() for the same reason. */ argv = get_extrac_args(cmdline, &argc); if(!argv) { WINE_ERR("Command line parsing failed\n"); return 0; } /* Parse arguments */ for(i = 0; i < argc; i++) { /* Get cabfile */ if (argv[i][0] != '/' && argv[i][0] != '-') { if (!cabfile) { cabfile = argv[i]; continue; } else break; } /* Get parameters for commands */ check = toupperW( argv[i][1] ); switch(check) { case 'A': WINE_FIXME("/A not implemented\n"); break; case 'Y': force_mode = TRUE; break; case 'L': if ((i + 1) >= argc) return 0; if (!GetFullPathNameW(argv[++i], MAX_PATH, path, NULL)) return 0; break; case 'C': case 'E': case 'D': if (cmd) return 0; cmd = check; break; default: return 0; } } if (!cabfile) return 0; if (cmd == 'C') { if ((i + 1) != argc) return 0; if (!GetFullPathNameW(argv[i], MAX_PATH, path, NULL)) return 0; } else if (!cmd) /* Use extraction by default if names of required files presents */ cmd = i < argc ? 'E' : 'D'; if (cmd == 'E' && !path[0]) GetCurrentDirectoryW(MAX_PATH, path); PathAddBackslashW(path); /* Execute the specified command */ switch(cmd) { case 'C': /* Copy file */ copy_file(cabfile, path); break; case 'D': /* Display CAB archive */ show_content = TRUE; /* Fall through */ case 'E': /* Extract CAB archive */ extract(cabfile, path); break; } return 0; }
int TraverseDirectoryTreeW ( LPCWSTR pszPath, LPCWSTR pszPattern, DWORD fdwFlags, PFNTraverseDirectoryTreeCallbackW pfnCallback, LPVOID pvUser, int nCurrentDepth) { bool fSubdirs = (fdwFlags & TDT_SUBDIRS) != 0; bool fDiagnostic = (fdwFlags & TDT_DIAGNOSTIC) != 0; //bool fDirFirst = (fdwFlags & TDT_DIRFIRST) != 0; //bool fDirLast = (fdwFlags & TDT_DIRLAST) != 0; if (fDiagnostic) { if (pszPattern) bprintfl(*g_pbpDiag, "TDT[%d]: %04x path = '%s' pattern = '%s' subdirs = %d", nCurrentDepth, fdwFlags, pszPath, pszPattern, fSubdirs); else bprintfl(*g_pbpDiag, "TDT[%d]: %04x path = '%s' pattern = NULL subdirs = %d", nCurrentDepth, fdwFlags, pszPath, fSubdirs); } // build a string containing path\pattern, we will pass this // into FindFirstFile. there are some special cases. // we treat paths that end in \ as meaning path\*. // we replace *.* with * since it means the same thing and // is easier to parse. (this is a special case go back to DOS). // int cchPath = lstrlenW(pszPath); int cchMax = cchPath + MAX_PATH + 2; LPWSTR psz = (LPWSTR)malloc(cchMax * sizeof(WCHAR)); lstrcpyW(psz, pszPath); LPWSTR pszNext = psz + lstrlenW(psz); bool fMatchAll = false; if (pszPattern && pszPattern[0]) { if (0 == lstrcmpW(pszPattern, L"*.*") || 0 == lstrcmpW(pszPattern, L"*")) { fMatchAll = true; } pszNext = PathAddBackslashW(psz); lstrcpyW(pszNext, pszPattern); } else if (pszNext > psz && (pszNext[-1] == '\\' || pszNext[-1] == '/')) { fMatchAll = true; pszNext[0] = '*'; pszNext[1] = 0; } HRESULT hr = S_OK; int err = ERROR_SUCCESS; int ixCurrentItem = 0; DWORD dwFirst = TDT_FIRST; LinkedFindData * pdirs = NULL; WIN32_FIND_DATAW wfd; HANDLE hFind = FindFirstFileW(psz, &wfd); if (INVALID_HANDLE_VALUE == hFind) { err = GetLastError(); // if we can't open the directory because of an access denied error // it might be the DACLs that are causing the problem. If so, then // just remove the dacls. we are going to be deleting the directory // anway... // if (ERROR_ACCESS_DENIED == err) { int errT = RemoveFileDACLs(pszPath, fdwFlags & TDT_DIAGNOSTIC, g_pbpDiag); if (errT) err = errT; else { hFind = FindFirstFileW(psz, &wfd); if (INVALID_HANDLE_VALUE == hFind) { errT = GetLastError(); if (errT != err) ReportErrorW(errT, "FindFirstFile ", psz); } else { err = 0; } } } if (err) ReportErrorW(err, "FindFirstFile ", psz); } if (hFind && INVALID_HANDLE_VALUE != hFind) { do { // ignore . and .. if (IsDotOrDotDot(wfd.cFileName)) continue; ++ixCurrentItem; bool fSkip = false; if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // if we are recursing, and we happen to be matching all, then remember this // directory for later (so we don't need to enumerate again for dirs). // otherwise we will have to re-enumerate in this directory to get subdirs. if (fSubdirs && fMatchAll) { LinkedFindData * pdir = (LinkedFindData*)malloc(sizeof(LinkedFindData)); pdir->wfd = wfd; pdir->next = pdirs; pdirs = pdir; fSkip = true; // we will do the callback for this directory later, if at all. } else if (fdwFlags & TDT_NODIRS) fSkip = true; } else { if (fdwFlags & TDT_NOFILES) fSkip = true; } if (fDiagnostic) bprintfl (*g_pbpDiag, "TDT[%d]: 0x%08x %s %s", nCurrentDepth, wfd.dwFileAttributes, wfd.cFileName, fSkip ? "<skip>" : ""); if ( ! fSkip) { lstrcpyW(pszNext, wfd.cFileName); if ( ! pfnCallback(pvUser, psz, pszNext - psz, (fdwFlags & ~(TDT_DIRLAST | TDT_DIRFIRST)) | dwFirst, nCurrentDepth, ixCurrentItem, wfd)) break; dwFirst = 0; } } while (FindNextFileW(hFind, &wfd)); if (fDiagnostic) bprintfl (*g_pbpDiag, "TDT[%d]: Done with %s %s", nCurrentDepth, pszPath, pszPattern); } // we want to traverse subdirs, but we were unable to build a list of dirs when we // enumerated the files, so re-enumerate with * to get the directories. if (fSubdirs && ! fMatchAll) { if (hFind && INVALID_HANDLE_VALUE != hFind) FindClose(hFind); lstrcpyW(pszNext, L"*"); hFind = FindFirstFileW(psz, &wfd); if (INVALID_HANDLE_VALUE != hFind) { do { if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && ! IsDotOrDotDot(wfd.cFileName)) { LinkedFindData * pdir = (LinkedFindData*)malloc(sizeof(LinkedFindData)); pdir->wfd = wfd; pdir->next = pdirs; pdirs = pdir; } } while (FindNextFileW(hFind, &wfd)); } } err = GetLastError(); if (ERROR_NO_MORE_FILES == err) err = ERROR_SUCCESS; // now traverse and callback subdirectories. // if (fSubdirs && pdirs) { pdirs = ReverseLinkedList(pdirs); while (pdirs) { LinkedFindData * pdir = pdirs; pdirs = pdirs->next; lstrcpyW(pszNext, pdir->wfd.cFileName); if ((fdwFlags & TDT_DIRFIRST) && ! (fdwFlags & TDT_NODIRS)) { if (fDiagnostic) bprintfl (*g_pbpDiag, "TDT[%d]: DIRFIRST 0x%08x %s %s", nCurrentDepth, pszPath, pszPattern); if ( ! pfnCallback(pvUser, psz, pszNext - psz, TDT_DIRFIRST | (fdwFlags & ~TDT_DIRLAST) | dwFirst, nCurrentDepth, ixCurrentItem, pdir->wfd)) break; dwFirst = 0; } err = TraverseDirectoryTreeW(psz, pszPattern, fdwFlags, pfnCallback, pvUser, nCurrentDepth+1); if ((fdwFlags & TDT_DIRLAST) && ! (fdwFlags & TDT_NODIRS)) { if (fDiagnostic) bprintfl (*g_pbpDiag, "TDT[%d]: DIRLAST 0x%08x %s %s", nCurrentDepth, pszPath, pszPattern); if ( ! pfnCallback(pvUser, psz, pszNext - psz, TDT_DIRLAST | (fdwFlags & ~TDT_DIRFIRST) | dwFirst, nCurrentDepth, ixCurrentItem, pdir->wfd)) break; dwFirst = 0; } } } if (hFind && INVALID_HANDLE_VALUE != hFind) FindClose(hFind); return err; }
static WCHAR *search_file( MSIPACKAGE *package, WCHAR *path, MSISIGNATURE *sig ) { VS_FIXEDFILEINFO *info; DWORD attr, size; LPWSTR val = NULL; LPBYTE buffer; if (!sig->File) { PathRemoveFileSpecW(path); PathAddBackslashW(path); attr = msi_get_file_attributes( package, path ); if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY)) return strdupW(path); return NULL; } attr = msi_get_file_attributes( package, path ); if (attr == INVALID_FILE_ATTRIBUTES || (attr & FILE_ATTRIBUTE_DIRECTORY)) return NULL; size = msi_get_file_version_info( package, path, 0, NULL ); if (!size) return strdupW(path); buffer = msi_alloc(size); if (!buffer) return NULL; size = msi_get_file_version_info( package, path, size, buffer ); if (!size) goto done; if (!VerQueryValueW(buffer, szBackSlash, (LPVOID)&info, &size) || !info) goto done; if (sig->MinVersionLS || sig->MinVersionMS) { if (info->dwFileVersionMS < sig->MinVersionMS) goto done; if (info->dwFileVersionMS == sig->MinVersionMS && info->dwFileVersionLS < sig->MinVersionLS) goto done; } if (sig->MaxVersionLS || sig->MaxVersionMS) { if (info->dwFileVersionMS > sig->MaxVersionMS) goto done; if (info->dwFileVersionMS == sig->MaxVersionMS && info->dwFileVersionLS > sig->MaxVersionLS) goto done; } val = strdupW(path); done: msi_free(buffer); return val; }
/*********************************************************************** * SHELL32_BindToChild [Internal] * * Common code for IShellFolder_BindToObject. * * PARAMS * pidlRoot [I] The parent shell folder's absolute pidl. * pathRoot [I] Absolute dos path of the parent shell folder. * pidlComplete [I] PIDL of the child. Relative to pidlRoot. * riid [I] GUID of the interface, which ppvOut shall be bound to. * ppvOut [O] A reference to the child's interface (riid). * * NOTES * pidlComplete has to contain at least one non empty SHITEMID. * This function makes special assumptions on the shell namespace, which * means you probably can't use it for your IShellFolder implementation. */ HRESULT SHELL32_BindToChild (LPCITEMIDLIST pidlRoot, LPCWSTR pathRoot, LPCITEMIDLIST pidlComplete, REFIID riid, LPVOID * ppvOut) { GUID const *clsid; IShellFolder *pSF; HRESULT hr; LPITEMIDLIST pidlChild; TRACE("(%p %s %p %s %p)\n", pidlRoot, debugstr_w(pathRoot), pidlComplete, debugstr_guid(riid), ppvOut); if (!pidlRoot || !ppvOut || _ILIsEmpty(pidlComplete)) return E_INVALIDARG; *ppvOut = NULL; pidlChild = ILCloneFirst (pidlComplete); if ((clsid = _ILGetGUIDPointer (pidlChild))) { /* virtual folder */ hr = SHELL32_CoCreateInitSF (pidlRoot, pathRoot, pidlChild, clsid, (LPVOID *)&pSF); } else if (_ILIsValue(pidlChild)) { /* Don't bind to files */ hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND); } else { /* file system folder */ CLSID clsidFolder = CLSID_ShellFSFolder; static const WCHAR wszCLSID[] = {'C','L','S','I','D',0}; WCHAR wszCLSIDValue[CHARS_IN_GUID], wszFolderPath[MAX_PATH], *pwszPathTail = wszFolderPath; /* see if folder CLSID should be overridden by desktop.ini file */ if (pathRoot) { lstrcpynW(wszFolderPath, pathRoot, MAX_PATH); pwszPathTail = PathAddBackslashW(wszFolderPath); } _ILSimpleGetTextW(pidlChild,pwszPathTail,MAX_PATH - (int)(pwszPathTail - wszFolderPath)); if (SHELL32_GetCustomFolderAttributeFromPath (wszFolderPath, wszDotShellClassInfo, wszCLSID, wszCLSIDValue, CHARS_IN_GUID)) CLSIDFromString (wszCLSIDValue, &clsidFolder); hr = SHELL32_CoCreateInitSF (pidlRoot, pathRoot, pidlChild, &clsidFolder, (LPVOID *)&pSF); } ILFree (pidlChild); if (SUCCEEDED (hr)) { if (_ILIsPidlSimple (pidlComplete)) { /* no sub folders */ hr = IShellFolder_QueryInterface (pSF, riid, ppvOut); } else { /* go deeper */ hr = IShellFolder_BindToObject (pSF, ILGetNext (pidlComplete), NULL, riid, ppvOut); } IShellFolder_Release (pSF); } TRACE ("-- returning (%p) 0x%08x\n", *ppvOut, hr); return hr; }
/************************************************************************** * CControlPanelFolder::GetDisplayNameOf */ HRESULT WINAPI CControlPanelFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet) { CHAR szName[MAX_PATH]; WCHAR wszName[MAX_PATH+1]; /* +1 for potential backslash */ PIDLCPanelStruct *pCPanel; HRESULT hr; *szName = '\0'; TRACE("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet); pdump(pidl); if (!pidl) return S_FALSE; pCPanel = _ILGetCPanelPointer(pidl); if (pCPanel) { /* copy display name from pidl - it was retrived from applet before; SHGDN_FORPARSING does not need special handling */ lstrcpyA(szName, pCPanel->szName + pCPanel->offsDispName); } /* take names of special folders only if it's only this folder */ else if (_ILIsSpecialFolder(pidl)) { BOOL bSimplePidl = _ILIsPidlSimple(pidl); SFGAOF Attr = SFGAO_FILESYSTEM; SHELL32_GetItemAttributes(this, pidl, &Attr); if (Attr & SFGAO_FILESYSTEM) { hr = SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, wszName, sizeof(wszName)); if (FAILED(hr)) return hr; } else if (bSimplePidl) { _ILSimpleGetTextW(pidl, wszName, MAX_PATH); /* append my own path */ } else { FIXME("special pidl\n"); if (dwFlags & SHGDN_FORPARSING) { /* go deeper if needed */ int cchName; PathAddBackslashW(wszName); cchName = wcslen(wszName); hr = SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, wszName + cchName, MAX_PATH + 1 - cchName); if (FAILED(hr)) return hr; } } if (!WideCharToMultiByte(CP_ACP, 0, wszName, -1, szName, MAX_PATH, NULL, NULL)) szName[0] = '\0'; } strRet->uType = STRRET_CSTR; lstrcpynA(strRet->cStr, szName, MAX_PATH); TRACE("--(%p)->(%s)\n", this, szName); return S_OK; }
static UINT ACTION_SearchDirectory(MSIPACKAGE *package, MSISIGNATURE *sig, LPCWSTR path, int depth, LPWSTR *appValue) { UINT rc; DWORD attr; LPWSTR val = NULL; TRACE("%p, %p, %s, %d, %p\n", package, sig, debugstr_w(path), depth, appValue); if (ACTION_IsFullPath(path)) { if (sig->File) rc = ACTION_RecurseSearchDirectory(package, &val, sig, path, depth); else { /* Recursively searching a directory makes no sense when the * directory to search is the thing you're trying to find. */ rc = ACTION_CheckDirectory(package, path, &val); } } else { WCHAR pathWithDrive[MAX_PATH] = { 'C',':','\\',0 }; DWORD drives = GetLogicalDrives(); int i; rc = ERROR_SUCCESS; for (i = 0; rc == ERROR_SUCCESS && !val && i < 26; i++) { if (!(drives & (1 << i))) continue; pathWithDrive[0] = 'A' + i; if (GetDriveTypeW(pathWithDrive) != DRIVE_FIXED) continue; lstrcpynW(pathWithDrive + 3, path, sizeof(pathWithDrive) / sizeof(pathWithDrive[0]) - 3); if (sig->File) rc = ACTION_RecurseSearchDirectory(package, &val, sig, pathWithDrive, depth); else rc = ACTION_CheckDirectory(package, pathWithDrive, &val); } } attr = GetFileAttributesW(val); if (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY) && val && val[lstrlenW(val) - 1] != '\\') { val = msi_realloc(val, (lstrlenW(val) + 2) * sizeof(WCHAR)); if (!val) rc = ERROR_OUTOFMEMORY; else PathAddBackslashW(val); } *appValue = val; TRACE("returning %d\n", rc); return rc; }
/************************************************************************** * ICPanel_IContextMenu_InvokeCommand() */ HRESULT WINAPI CControlPanelFolder::InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi) { WCHAR szPath[MAX_PATH]; char szTarget[MAX_PATH]; STRRET strret; WCHAR* pszPath; INT Length, cLength; CComPtr<IPersistFile> ppf; CComPtr<IShellLinkA> isl; HRESULT hResult; PIDLCPanelStruct *pcpanel = _ILGetCPanelPointer(apidl[0]); TRACE("(%p)->(invcom=%p verb=%p wnd=%p)\n", this, lpcmi, lpcmi->lpVerb, lpcmi->hwnd); if (lpcmi->lpVerb == MAKEINTRESOURCEA(IDS_OPEN)) //FIXME { LPITEMIDLIST lpIDList = ILCombine(pidlRoot, apidl[0]); if (!pcpanel) { /* UGLY HACK! */ LPSHELLBROWSER lpSB = (LPSHELLBROWSER)SendMessageW(lpcmi->hwnd, CWM_GETISHELLBROWSER, 0, 0); HRESULT hr; if (lpSB == NULL) return E_FAIL; hr = lpSB->BrowseObject(lpIDList, 0); return hr; } /* Note: we pass the applet name to Control_RunDLL to distinguish between multiple applets in one .cpl file */ ShellExecuteA(NULL, "cplopen", pcpanel->szName, pcpanel->szName + pcpanel->offsDispName, NULL, 0); } else if (lpcmi->lpVerb == MAKEINTRESOURCEA(IDS_CREATELINK)) //FIXME { if (!SHGetSpecialFolderPathW(NULL, szPath, CSIDL_DESKTOPDIRECTORY, FALSE)) return E_FAIL; pszPath = PathAddBackslashW(szPath); if (!pszPath) return E_FAIL; if (GetDisplayNameOf(apidl[0], SHGDN_FORPARSING, &strret) != S_OK) return E_FAIL; Length = MAX_PATH - (pszPath - szPath); cLength = strlen(strret.cStr); if (Length < cLength + 5) { FIXME("\n"); return E_FAIL; } if (MultiByteToWideChar(CP_ACP, 0, strret.cStr, cLength + 1, pszPath, Length)) { pszPath += cLength; Length -= cLength; } if (Length > 10) { wcscpy(pszPath, L" - "); cLength = LoadStringW(shell32_hInstance, IDS_LNK_FILE, &pszPath[3], Length - 4) + 3; if (cLength + 5 > Length) cLength = Length - 5; Length -= cLength; pszPath += cLength; } wcscpy(pszPath, L".lnk"); pcpanel = _ILGetCPanelPointer(ILFindLastID(apidl[0])); if (pcpanel) { strncpy(szTarget, pcpanel->szName, MAX_PATH); } else { FIXME("Couldn't retrieve pointer to cpl structure\n"); return E_FAIL; } hResult = CShellLink::_CreatorClass::CreateInstance(NULL, IID_PPV_ARG(IShellLinkA, &isl)); if (SUCCEEDED(hResult)) { isl->SetPath(szTarget); if (SUCCEEDED(isl->QueryInterface(IID_PPV_ARG(IPersistFile,&ppf)))) ppf->Save(szPath, TRUE); } return NOERROR; } return S_OK; }
static UINT ACTION_AppSearchComponents(MSIPACKAGE *package, LPWSTR *appValue, MSISIGNATURE *sig) { static const WCHAR query[] = { 'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ', '`','C','o','m','p','L','o','c','a','t','o','r','`',' ', 'W','H','E','R','E',' ','`','S','i','g','n','a','t','u','r','e','_','`',' ','=',' ', '\'','%','s','\'',0}; static const WCHAR sigquery[] = { 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ', '`','S','i','g','n','a','t','u','r','e','`',' ', 'W','H','E','R','E',' ','`','S','i','g','n','a','t','u','r','e','`',' ','=',' ', '\'','%','s','\'',0}; MSIRECORD *row, *rec; LPCWSTR signature, guid; BOOL sigpresent = TRUE; BOOL isdir; UINT type; WCHAR path[MAX_PATH]; DWORD size = MAX_PATH; LPWSTR ptr; DWORD attr; TRACE("%s\n", debugstr_w(sig->Name)); *appValue = NULL; row = MSI_QueryGetRecord(package->db, query, sig->Name); if (!row) { TRACE("failed to query CompLocator for %s\n", debugstr_w(sig->Name)); return ERROR_SUCCESS; } signature = MSI_RecordGetString(row, 1); guid = MSI_RecordGetString(row, 2); type = MSI_RecordGetInteger(row, 3); rec = MSI_QueryGetRecord(package->db, sigquery, signature); if (!rec) sigpresent = FALSE; *path = '\0'; MsiLocateComponentW(guid, path, &size); if (!*path) goto done; attr = GetFileAttributesW(path); if (attr == INVALID_FILE_ATTRIBUTES) goto done; isdir = (attr & FILE_ATTRIBUTE_DIRECTORY); if (type != msidbLocatorTypeDirectory && sigpresent && !isdir) { *appValue = app_search_file(path, sig); } else if (!sigpresent && (type != msidbLocatorTypeDirectory || isdir)) { if (type == msidbLocatorTypeFileName) { ptr = strrchrW(path, '\\'); *(ptr + 1) = '\0'; } else PathAddBackslashW(path); *appValue = strdupW(path); } else if (sigpresent) { PathAddBackslashW(path); lstrcatW(path, MSI_RecordGetString(rec, 2)); attr = GetFileAttributesW(path); if (attr != INVALID_FILE_ATTRIBUTES && !(attr & FILE_ATTRIBUTE_DIRECTORY)) *appValue = strdupW(path); } done: if (rec) msiobj_release(&rec->hdr); msiobj_release(&row->hdr); return ERROR_SUCCESS; }
INT_PTR CALLBACK DriveExtraDlg( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) { STARTUPINFOW si; PROCESS_INFORMATION pi; WCHAR szPath[MAX_PATH + 10]; WCHAR szArg[MAX_PATH]; WCHAR * szDrive; LPPROPSHEETPAGEW ppsp; DWORD dwSize; FORMAT_DRIVE_CONTEXT Context; switch (uMsg) { case WM_INITDIALOG: ppsp = (LPPROPSHEETPAGEW)lParam; SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)ppsp->lParam); return TRUE; case WM_COMMAND: ZeroMemory( &si, sizeof(si) ); si.cb = sizeof(si); ZeroMemory( &pi, sizeof(pi) ); szDrive = (WCHAR*)GetWindowLongPtr(hwndDlg, DWLP_USER); switch(LOWORD(wParam)) { case 14000: if (InitializeFmifsLibrary(&Context)) { Context.Drive = szDrive[0]; DialogBoxParamW(shell32_hInstance, L"CHKDSK_DLG", hwndDlg, ChkDskDlg, (LPARAM)&Context); FreeLibrary(Context.hLibrary); } break; case 14001: dwSize = sizeof(szPath); if (RegGetValueW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MyComputer\\DefragPath", NULL, RRF_RT_REG_EXPAND_SZ, NULL, (PVOID)szPath, &dwSize) == S_OK) { swprintf(szArg, szPath, szDrive[0]); if (!GetSystemDirectoryW(szPath, MAX_PATH)) break; szDrive = PathAddBackslashW(szPath); if (!szDrive) break; wcscat(szDrive, L"mmc.exe"); if (CreateProcessW(szPath, szArg, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } } break; case 14002: dwSize = sizeof(szPath); if (RegGetValueW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MyComputer\\BackupPath", NULL, RRF_RT_REG_EXPAND_SZ, NULL, (PVOID)szPath, &dwSize) == S_OK) { if (CreateProcessW(szPath, NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) { CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } } } break; } return FALSE; }
/* Recursively searches the directory dir for files that match the signature * sig, up to (depth + 1) levels deep. That is, if depth is 0, it searches dir * (and only dir). If depth is 1, searches dir and its immediate * subdirectories. * Assumes sig->File is not NULL. * Returns ERROR_SUCCESS on success (which may include non-critical errors), * something else on failures which should halt the install. */ static UINT ACTION_RecurseSearchDirectory(MSIPACKAGE *package, LPWSTR *appValue, MSISIGNATURE *sig, LPCWSTR dir, int depth) { HANDLE hFind; WIN32_FIND_DATAW findData; UINT rc = ERROR_SUCCESS; size_t dirLen = lstrlenW(dir), fileLen = lstrlenW(sig->File); WCHAR subpath[MAX_PATH]; WCHAR *buf; DWORD len; static const WCHAR starDotStarW[] = { '*','.','*',0 }; TRACE("Searching directory %s for file %s, depth %d\n", debugstr_w(dir), debugstr_w(sig->File), depth); if (depth < 0) return ERROR_SUCCESS; *appValue = NULL; /* We need the buffer in both paths below, so go ahead and allocate it * here. Add two because we might need to add a backslash if the dir name * isn't backslash-terminated. */ len = dirLen + max(fileLen, strlenW(starDotStarW)) + 2; buf = msi_alloc(len * sizeof(WCHAR)); if (!buf) return ERROR_OUTOFMEMORY; lstrcpyW(buf, dir); PathAddBackslashW(buf); lstrcatW(buf, sig->File); hFind = FindFirstFileW(buf, &findData); if (hFind != INVALID_HANDLE_VALUE) { if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { BOOL matches; rc = ACTION_FileMatchesSig(sig, &findData, buf, &matches); if (rc == ERROR_SUCCESS && matches) { TRACE("found file, returning %s\n", debugstr_w(buf)); *appValue = buf; } } FindClose(hFind); } if (rc == ERROR_SUCCESS && !*appValue) { lstrcpyW(buf, dir); PathAddBackslashW(buf); lstrcatW(buf, starDotStarW); hFind = FindFirstFileW(buf, &findData); if (hFind != INVALID_HANDLE_VALUE) { if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY && lstrcmpW(findData.cFileName, szDot) && lstrcmpW(findData.cFileName, szDotDot)) { lstrcpyW(subpath, dir); PathAppendW(subpath, findData.cFileName); rc = ACTION_RecurseSearchDirectory(package, appValue, sig, subpath, depth - 1); } while (rc == ERROR_SUCCESS && !*appValue && FindNextFileW(hFind, &findData) != 0) { if (!lstrcmpW(findData.cFileName, szDot) || !lstrcmpW(findData.cFileName, szDotDot)) continue; lstrcpyW(subpath, dir); PathAppendW(subpath, findData.cFileName); if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) rc = ACTION_RecurseSearchDirectory(package, appValue, sig, subpath, depth - 1); } FindClose(hFind); } } if (*appValue != buf) msi_free(buf); return rc; }
/* * @unimplemented */ BOOL WINAPI AddMonitorW(LPWSTR Name, DWORD Level, PBYTE Monitors) { WCHAR szPath[MAX_PATH]; HMODULE hLibrary = NULL; FARPROC InitProc; HKEY hKey, hSubKey; MONITOR_INFO_2W * pMonitor; if (Level != 2 || !Monitors) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } pMonitor = (MONITOR_INFO_2W*)Monitors; if (pMonitor->pDLLName == NULL || pMonitor->pName == NULL) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } if (wcschr(pMonitor->pDLLName, L'\\')) { hLibrary = LoadLibraryExW(pMonitor->pDLLName, NULL, 0); } else if (GetSystemDirectoryW(szPath, MAX_PATH) && PathAddBackslashW(szPath)) { wcscat(szPath, pMonitor->pDLLName); hLibrary = LoadLibraryExW(szPath, NULL, 0); } if (!hLibrary) { return FALSE; } InitProc = GetProcAddress(hLibrary, "InitializePrintMonitor"); if (!InitProc) { InitProc = GetProcAddress(hLibrary, "InitializePrintMonitor2"); if (!InitProc) { FreeLibrary(hLibrary); SetLastError(ERROR_PROC_NOT_FOUND); return FALSE; } } // FIXME // Initialize monitor FreeLibrary(hLibrary); if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors", 0, KEY_WRITE, &hKey) == ERROR_SUCCESS) { if (RegCreateKeyExW(hKey, pMonitor->pName, 0, NULL, 0, KEY_WRITE, NULL, &hSubKey, NULL) == ERROR_SUCCESS) { RegSetValueExW(hSubKey, L"Driver", 0, REG_SZ, (LPBYTE)pMonitor->pDLLName, (wcslen(pMonitor->pDLLName)+1)*sizeof(WCHAR)); RegCloseKey(hSubKey); } RegCloseKey(hKey); } return TRUE; }
static UINT ACTION_AppSearchDr(MSIPACKAGE *package, LPWSTR *appValue, MSISIGNATURE *sig) { static const WCHAR query[] = { 's','e','l','e','c','t',' ','*',' ', 'f','r','o','m',' ', 'D','r','L','o','c','a','t','o','r',' ', 'w','h','e','r','e',' ', 'S','i','g','n','a','t','u','r','e','_',' ','=',' ', '\'','%','s','\'',0}; LPWSTR parent = NULL; LPCWSTR parentName; WCHAR path[MAX_PATH]; WCHAR expanded[MAX_PATH]; MSIRECORD *row; int depth; DWORD sz, attr; UINT rc; TRACE("%s\n", debugstr_w(sig->Name)); *appValue = NULL; row = MSI_QueryGetRecord( package->db, query, sig->Name ); if (!row) { TRACE("failed to query DrLocator for %s\n", debugstr_w(sig->Name)); return ERROR_SUCCESS; } /* check whether parent is set */ parentName = MSI_RecordGetString(row, 2); if (parentName) { MSISIGNATURE parentSig; rc = ACTION_AppSearchSigName(package, parentName, &parentSig, &parent); ACTION_FreeSignature(&parentSig); if (!parent) { msiobj_release(&row->hdr); return ERROR_SUCCESS; } } sz = MAX_PATH; MSI_RecordGetStringW(row, 3, path, &sz); if (MSI_RecordIsNull(row,4)) depth = 0; else depth = MSI_RecordGetInteger(row,4); if (sz) ACTION_ExpandAnyPath(package, path, expanded, MAX_PATH); else strcpyW(expanded, path); if (parent) { attr = GetFileAttributesW(parent); if (attr != INVALID_FILE_ATTRIBUTES && !(attr & FILE_ATTRIBUTE_DIRECTORY)) { PathRemoveFileSpecW(parent); PathAddBackslashW(parent); } strcpyW(path, parent); strcatW(path, expanded); } else if (sz) strcpyW(path, expanded); PathAddBackslashW(path); rc = ACTION_SearchDirectory(package, sig, path, depth, appValue); msi_free(parent); msiobj_release(&row->hdr); TRACE("returning %d\n", rc); return rc; }
/************************************************************************** * ISF_Desktop_fnSetNameOf * Changes the name of a file object or subfolder, possibly changing its item * identifier in the process. * * PARAMETERS * HWND hwndOwner, //[in ] Owner window for output * LPCITEMIDLIST pidl, //[in ] simple pidl of item to change * LPCOLESTR lpszName, //[in ] the items new display name * DWORD dwFlags, //[in ] SHGNO formatting flags * LPITEMIDLIST* ppidlOut) //[out] simple pidl returned */ static HRESULT WINAPI ISF_Desktop_fnSetNameOf (IShellFolder2 * iface, HWND hwndOwner, LPCITEMIDLIST pidl, /* simple pidl */ LPCOLESTR lpName, DWORD dwFlags, LPITEMIDLIST * pPidlOut) { IGenericSFImpl *This = (IGenericSFImpl *)iface; IShellFolder2 * psf; HRESULT hr; WCHAR szSrc[MAX_PATH + 1], szDest[MAX_PATH + 1]; LPWSTR ptr; BOOL bIsFolder = _ILIsFolder (ILFindLastID (pidl)); TRACE ("(%p)->(%p,pidl=%p,%s,%u,%p)\n", This, hwndOwner, pidl, debugstr_w (lpName), dwFlags, pPidlOut); if (_ILGetGUIDPointer(pidl)) { if (SUCCEEDED(IShellFolder2_BindToObject(iface, pidl, NULL, &IID_IShellFolder2, (LPVOID*)&psf))) { hr = IShellFolder2_SetNameOf(psf, hwndOwner, pidl, lpName, dwFlags, pPidlOut); IShellFolder2_Release(psf); return hr; } } /* build source path */ lstrcpynW(szSrc, This->sPathTarget, MAX_PATH); ptr = PathAddBackslashW (szSrc); if (ptr) _ILSimpleGetTextW (pidl, ptr, MAX_PATH + 1 - (ptr - szSrc)); /* build destination path */ if (dwFlags == SHGDN_NORMAL || dwFlags & SHGDN_INFOLDER) { lstrcpynW(szDest, This->sPathTarget, MAX_PATH); ptr = PathAddBackslashW (szDest); if (ptr) lstrcpynW(ptr, lpName, MAX_PATH + 1 - (ptr - szDest)); } else lstrcpynW(szDest, lpName, MAX_PATH); if(!(dwFlags & SHGDN_FORPARSING) && SHELL_FS_HideExtension(szSrc)) { WCHAR *ext = PathFindExtensionW(szSrc); if(*ext != '\0') { INT len = wcslen(szDest); lstrcpynW(szDest + len, ext, MAX_PATH - len); } } if (!memcmp(szSrc, szDest, (wcslen(szDest)+1) * sizeof(WCHAR))) { /* src and destination is the same */ hr = S_OK; if (pPidlOut) hr = _ILCreateFromPathW(szDest, pPidlOut); return hr; } TRACE ("src=%s dest=%s\n", debugstr_w(szSrc), debugstr_w(szDest)); if (MoveFileW (szSrc, szDest)) { hr = S_OK; if (pPidlOut) hr = _ILCreateFromPathW(szDest, pPidlOut); SHChangeNotify (bIsFolder ? SHCNE_RENAMEFOLDER : SHCNE_RENAMEITEM, SHCNF_PATHW, szSrc, szDest); return hr; } return E_FAIL; }