utils.cpp File Reference

#include "precomp.h"
#include <lmcons.h>
#include <lmapibuf.h>
#include <lmaccess.h>
#include <lmserver.h>
#include <secext.h>

Include dependency graph for utils.cpp:

Go to the source code of this file.

Classes
class	CDummyOleWindow
struct	tagALIAS_MAPPING

Macros
#define	PATH_VALID_ELEMENT
#define	COPY_STREAM_DEFAULT_BUFFER_SIZE   0x4000
#define	COMPUTER_DESCRIPTIONS_KEY    L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ComputerDescriptions"

Typedefs
typedef struct tagALIAS_MAPPING	ALIAS_MAPPING
typedef struct tagALIAS_MAPPING *	PALIAS_MAPPING

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
static PCSTR	StrEndNA (_In_ PCSTR psz, _In_ INT_PTR cch)
static PCWSTR	StrEndNW (_In_ PCWSTR psz, _In_ INT_PTR cch)
static INT	_SHMergePopupMenus (HMENU hMenu, HMENU hPopupMenu, UINT uIDAdjust, UINT uIDAdjustMax)
static HMENU	SHLoadPopupMenu (HINSTANCE hInstance, UINT uMenuId)
EXTERN_C VOID WINAPI	CDefFolderMenu_MergeMenu (_In_ HINSTANCE hInstance, _In_ UINT uMainMerge, _In_ UINT uPopupMerge, _Inout_ LPQCMINFO lpQcmInfo)
EXTERN_C PSTR WINAPI	StrRStrA (_In_ PCSTR pszSrc, _In_opt_ PCSTR pszLast, _In_ PCSTR pszSearch)
EXTERN_C PWSTR WINAPI	StrRStrW (_In_ PCWSTR pszSrc, _In_opt_ PCWSTR pszLast, _In_ PCWSTR pszSearch)
BOOL	PathIsDotOrDotDotW (_In_ LPCWSTR pszPath)
BOOL	PathIsValidElement (_In_ LPCWSTR pszPath)
BOOL	PathIsDosDevice (_In_ LPCWSTR pszName)
HRESULT	SHILAppend (_Inout_ LPITEMIDLIST pidl, _Inout_ LPITEMIDLIST *ppidl)
EXTERN_C HRESULT WINAPI	SHShouldShowWizards (_In_ IUnknown *pUnknown)
static BOOL	OpenEffectiveToken (_In_ DWORD DesiredAccess, _Out_ HANDLE *phToken)
BOOL	BindCtx_ContainsObject (_In_ IBindCtx *pBindCtx, _In_ LPCWSTR pszName)
DWORD	BindCtx_GetMode (_In_ IBindCtx *pbc, _In_ DWORD dwDefault)
BOOL	SHSkipJunctionBinding (_In_ IBindCtx *pbc, _In_ CLSID *pclsid)
HRESULT	SHIsFileSysBindCtx (_In_ IBindCtx *pBindCtx, _Out_opt_ WIN32_FIND_DATAW *pFindData)
BOOL	Shell_FailForceReturn (_In_ HRESULT hr)
SHSTDAPI	SHBindToObject (_In_opt_ IShellFolder *pShellFolder, _In_ PCUIDLIST_RELATIVE pidl, _In_opt_ IBindCtx *pBindCtx, _In_ REFIID riid, _Out_ void **ppvObj)
EXTERN_C HRESULT	SHELL_GetUIObjectOfAbsoluteItem (_In_opt_ HWND hWnd, _In_ PCIDLIST_ABSOLUTE pidl, _In_ REFIID riid, _Out_ void **ppvObj)
HRESULT	SHELL_DisplayNameOf (_In_opt_ IShellFolder *psf, _In_ LPCITEMIDLIST pidl, _In_opt_ UINT Flags, _Out_ PWSTR *ppStr)
EXTERN_C HRESULT WINAPI	DisplayNameOfW (_In_ IShellFolder *psf, _In_ LPCITEMIDLIST pidl, _In_ DWORD dwFlags, _Out_ LPWSTR pszBuf, _In_ UINT cchBuf)
DWORD	SHGetAttributes (_In_ IShellFolder *psf, _In_ LPCITEMIDLIST pidl, _In_ DWORD dwAttributes)
HRESULT	SHELL_GetIDListTarget (_In_ LPCITEMIDLIST pidl, _Out_ PIDLIST_ABSOLUTE *ppidl)
HRESULT	SHCoInitializeAnyApartment (VOID)
HRESULT	SHGetNameAndFlagsW (_In_ LPCITEMIDLIST pidl, _In_ DWORD dwFlags, _Out_opt_ LPWSTR pszText, _In_ UINT cchBuf, _Inout_opt_ DWORD *pdwAttributes)
EXTERN_C HWND	BindCtx_GetUIWindow (_In_ IBindCtx *pBindCtx)
EXTERN_C HRESULT	BindCtx_RegisterObjectParam (_In_ IBindCtx *pBindCtx, _In_ LPOLESTR pszKey, _In_opt_ IUnknown *punk, _Out_ LPBC *ppbc)
EXTERN_C HRESULT WINAPI	SHSetFolderPathA (_In_ INT csidl, _In_ HANDLE hToken, _In_ DWORD dwFlags, _In_ LPCSTR pszPath)
EXTERN_C BOOL WINAPI	PathIsSlowW (_In_ LPCWSTR pszFile, _In_ DWORD dwAttr)
EXTERN_C BOOL WINAPI	PathIsSlowA (_In_ LPCSTR pszFile, _In_ DWORD dwAttr)
EXTERN_C WORD WINAPI	ExtractIconResInfoA (_In_ HANDLE hHandle, _In_ LPCSTR lpFileName, _In_ WORD wIndex, _Out_ LPWORD lpSize, _Out_ LPHANDLE lpIcon)
EXTERN_C LPWSTR WINAPI	ShortSizeFormatW (_In_ DWORD dwNumber, _Out_writes_(0x8FFF) LPWSTR pszBuffer)
EXTERN_C BOOL WINAPI	SHOpenEffectiveToken (_Out_ LPHANDLE phToken)
EXTERN_C DWORD WINAPI	SHGetUserSessionId (_In_opt_ HANDLE hToken)
EXTERN_C HRESULT WINAPI	SHInvokePrivilegedFunctionW (_In_ LPCWSTR pszName, _In_ PRIVILEGED_FUNCTION fn, _In_opt_ LPARAM lParam)
EXTERN_C BOOL WINAPI	SHTestTokenPrivilegeW (_In_opt_ HANDLE hToken, _In_ LPCWSTR lpName)
BOOL	IsShutdownAllowed (VOID)
BOOL WINAPI	IsSuspendAllowed (VOID)
EXTERN_C HINSTANCE WINAPI	SHGetShellStyleHInstance (VOID)
EXTERN_C HRESULT WINAPI	SHCreatePropertyBag (_In_ REFIID riid, _Out_ void **ppvObj)
static DWORD	SHELL_ReadSingleUnreadMailCount (_In_ HKEY hKey, _Out_opt_ PDWORD pdwCount, _Out_opt_ PFILETIME pFileTime, _Out_writes_opt_(cchShellExecuteCommand) LPWSTR pszShellExecuteCommand, _In_ INT cchShellExecuteCommand)
EXTERN_C HRESULT WINAPI	SHGetUnreadMailCountW (_In_opt_ HKEY hKeyUser, _In_opt_ PCWSTR pszMailAddress, _Out_opt_ PDWORD pdwCount, _Inout_opt_ PFILETIME pFileTime, _Out_writes_opt_(cchShellExecuteCommand) PWSTR pszShellExecuteCommand, _In_ INT cchShellExecuteCommand)
EXTERN_C HRESULT WINAPI	SHSetUnreadMailCountW (_In_ PCWSTR pszMailAddress, _In_ DWORD dwCount, _In_ PCWSTR pszShellExecuteCommand)
EXTERN_C LPSTR WINAPI	SheRemoveQuotesA (LPSTR psz)
EXTERN_C LPWSTR WINAPI	SheRemoveQuotesW (LPWSTR psz)
EXTERN_C HRESULT WINAPI	SHEnumerateUnreadMailAccountsW (_In_opt_ HKEY hKeyUser, _In_ DWORD dwIndex, _Out_writes_(cchMailAddress) PWSTR pszMailAddress, _In_ INT cchMailAddress)
EXTERN_C BOOL WINAPI	SHFindComputer (LPCITEMIDLIST pidlRoot, LPCITEMIDLIST pidlSavedSearch)
static HRESULT	Int64ToStr (_In_ LONGLONG llValue, _Out_writes_(cchValue) LPWSTR pszValue, _In_ UINT cchValue)
static VOID	Int64GetNumFormat (_Out_ NUMBERFMTW *pDest, _In_opt_ const NUMBERFMTW *pSrc, _In_ DWORD dwNumberFlags, _Out_writes_(cchDecimal) LPWSTR pszDecimal, _In_ INT cchDecimal, _Out_writes_(cchThousand) LPWSTR pszThousand, _In_ INT cchThousand)
EXTERN_C INT WINAPI	Int64ToString (_In_ LONGLONG llValue, _Out_writes_(cchOut) LPWSTR pszOut, _In_ UINT cchOut, _In_ BOOL bUseFormat, _In_opt_ const NUMBERFMTW *pNumberFormat, _In_ DWORD dwNumberFlags)
EXTERN_C INT WINAPI	LargeIntegerToString (_In_ const LARGE_INTEGER *pLargeInt, _Out_writes_(cchOut) LPWSTR pszOut, _In_ UINT cchOut, _In_ BOOL bUseFormat, _In_opt_ const NUMBERFMTW *pNumberFormat, _In_ DWORD dwNumberFlags)
EXTERN_C HRESULT WINAPI	CopyStreamUI (_In_ IStream *pSrc, _Out_ IStream *pDst, _Inout_opt_ IProgressDialog *pProgress, _In_opt_ DWORDLONG dwlSize)
EXTERN_C BOOL WINAPI	Activate_RunDLL (_In_ HWND hwnd, _In_ HINSTANCE hinst, _In_ LPCWSTR cmdline, _In_ INT cmdshow)
EXTERN_C HRESULT WINAPI	SHStartNetConnectionDialogA (_In_ HWND hwnd, _In_ LPCSTR pszRemoteName, _In_ DWORD dwType)
static INT	DynamicPathCommonPrefixW (_In_ LPCWSTR lpszPath1, _In_ LPCWSTR lpszPath2, _Out_ CStringW &strPath)
EXTERN_C HRESULT WINAPI	SHGetPathCchFromIDListW (LPCITEMIDLIST pidl, LPWSTR pszPath, SIZE_T cchPathMax)
static HRESULT	DynamicSHGetPathFromIDListW (_In_ LPCITEMIDLIST pidl, _Out_ CStringW &strPath)
static HRESULT	DynamicSHGetSpecialFolderPathW (_In_ HWND hwndOwner, _Out_ CStringW &strPath, _In_ INT nCSIDL, _In_ BOOL bCreate)
static VOID	DynamicPathRemoveBackslashW (_Out_ CStringW &strPath)
EXTERN_C BOOL WINAPI	PathIsEqualOrSubFolder (_In_ LPCWSTR pszPath1OrCSIDL, _In_ LPCWSTR pszPath2)
EXTERN_C HRESULT WINAPI	SHGetRealIDL (_In_ IShellFolder *psf, _In_ PCUITEMID_CHILD pidlSimple, _Outptr_ PITEMID_CHILD *ppidlReal)
EXTERN_C HRESULT	IUnknown_InitializeCommand (_In_ IUnknown *pUnk, _In_ PCWSTR pszCommandName, _In_opt_ IPropertyBag *pPB)
EXTERN_C HRESULT	InvokeIExecuteCommand (_In_ IExecuteCommand *pEC, _In_ PCWSTR pszCommandName, _In_opt_ IPropertyBag *pPB, _In_opt_ IShellItemArray *pSIA, _In_opt_ LPCMINVOKECOMMANDINFOEX pICI, _In_opt_ IUnknown *pSite)
EXTERN_C HRESULT	InvokeIExecuteCommandWithDataObject (_In_ IExecuteCommand *pEC, _In_ PCWSTR pszCommandName, _In_opt_ IPropertyBag *pPB, _In_ IDataObject *pDO, _In_opt_ LPCMINVOKECOMMANDINFOEX pICI, _In_opt_ IUnknown *pSite)
static HRESULT	GetCommandStringA (_In_ IContextMenu *pCM, _In_ UINT_PTR Id, _In_ UINT GCS, _Out_writes_(cchMax) LPSTR Buf, _In_ UINT cchMax)
UINT	GetDfmCmd (_In_ IContextMenu *pCM, _In_ LPCSTR verba)
HRESULT	SHELL_MapContextMenuVerbToCmdId (LPCMINVOKECOMMANDINFO pICI, const CMVERBMAP *pMap)
static const CMVERBMAP *	FindVerbMapEntry (UINT_PTR CmdId, const CMVERBMAP *pMap)
HRESULT	SHELL_GetCommandStringImpl (SIZE_T CmdId, UINT uFlags, LPSTR Buf, UINT cchBuf, const CMVERBMAP *pMap)
HRESULT	SHELL_CreateShell32DefaultExtractIcon (int IconIndex, REFIID riid, LPVOID *ppvOut)
int	DCIA_AddEntry (HDCIA hDCIA, REFCLSID rClsId)
void	DCIA_AddShellExSubkey (HDCIA hDCIA, HKEY hProgId, PCWSTR pszSubkey)
EXTERN_C BOOL WINAPI	SHIsBadInterfacePtr (_In_ LPCVOID pv, _In_ UINT_PTR ucb)
EXTERN_C HRESULT WINAPI	SHGetUserDisplayName (_Out_writes_to_(*puSize, *puSize) PWSTR pName, _Inout_ PULONG puSize)
static PCWSTR	SHELL_SkipServerSlashes (_In_ PCWSTR pszPath)
static HRESULT	SHELL_GetCachedComputerDescription (_Out_writes_z_(cchDescMax) PWSTR pszDesc, _In_ DWORD cchDescMax, _In_ PCWSTR pszServerName)
static VOID	SHELL_CacheComputerDescription (_In_ PCWSTR pszServerName, _In_ PCWSTR pszDesc)
static HRESULT	SHELL_GetComputerDescription (_Out_writes_z_(cchDescMax) PWSTR pszDesc, _In_ SIZE_T cchDescMax, _In_ PWSTR pszServerName)
static HRESULT	SHELL_BuildDisplayMachineName (_Out_writes_z_(cchNameMax) PWSTR pszName, _In_ DWORD cchNameMax, _In_ PCWSTR pszServerName, _In_ PCWSTR pszDescription)
EXTERN_C HRESULT WINAPI	SHGetComputerDisplayNameW (_In_opt_ PWSTR pszServerName, _In_ DWORD dwFlags, _Out_writes_z_(cchNameMax) PWSTR pszName, _In_ DWORD cchNameMax)
EXTERN_C BOOL	SHELL32_ReparentAsAliasPidl (_In_opt_ HWND hwnd, _In_opt_ HANDLE hToken, _In_ LPCITEMIDLIST pidlTarget, _Out_ LPITEMIDLIST *ppidlNew, _In_ DWORD dwFlags)
	Translate a PIDL to an "alias" PIDL.
EXTERN_C HRESULT WINAPI	SHSetLocalizedName (_In_ PCWSTR pszPath, _In_ PCWSTR pszResModule, _In_ INT idsRes)
EXTERN_C HRESULT	SHELL32_AliasTranslatePidl (_In_ LPCITEMIDLIST pidl, _Out_ LPITEMIDLIST *ppidlNew, _In_ DWORD dwFlags)
	Translate a PIDL to an "alias" PIDL.
EXTERN_C BOOL WINAPI	LinkWindow_RegisterClass (VOID)
EXTERN_C BOOL WINAPI	LinkWindow_UnregisterClass (_In_ DWORD dwUnused)

Variables
static const ALIAS_MAPPING	g_AliasTable []
	PIDL alias table.

Macro Definition Documentation

COMPUTER_DESCRIPTIONS_KEY

#define COMPUTER_DESCRIPTIONS_KEY    L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ComputerDescriptions"

Definition at line 2067 of file utils.cpp.

COPY_STREAM_DEFAULT_BUFFER_SIZE

#define COPY_STREAM_DEFAULT_BUFFER_SIZE   0x4000

PATH_VALID_ELEMENT

#define PATH_VALID_ELEMENT

Value:

    ( \
    PATH_CHAR_CLASS_DOT | PATH_CHAR_CLASS_SEMICOLON | PATH_CHAR_CLASS_COMMA | \
    PATH_CHAR_CLASS_SPACE | PATH_CHAR_CLASS_OTHER_VALID \
)

Definition at line 221 of file utils.cpp.

Typedef Documentation

ALIAS_MAPPING

typedef struct tagALIAS_MAPPING ALIAS_MAPPING

PALIAS_MAPPING

typedef struct tagALIAS_MAPPING * PALIAS_MAPPING

Function Documentation

_SHMergePopupMenus()

static INT _SHMergePopupMenus ( HMENU  hMenu, HMENU  hPopupMenu, UINT  uIDAdjust, UINT  uIDAdjustMax  )

static

Definition at line 35 of file utils.cpp.

{
    INT maxID = uIDAdjust;
    const INT itemCount = GetMenuItemCount(hPopupMenu);
    if (itemCount == -1)
        return maxID;
 
    MENUITEMINFOW mii = { sizeof(mii), MIIM_ID | MIIM_SUBMENU };
    for (INT i = itemCount - 1; i >= 0; --i)
    {
        if (!GetMenuItemInfoW(hPopupMenu, i, TRUE, &mii))
            continue;
 
        HMENU hTargetSubMenu = SHGetMenuFromID(hMenu, mii.wID);
        if (!hTargetSubMenu)
            continue;
 
        INT currentMax = Shell_MergeMenus(hTargetSubMenu, mii.hSubMenu, 0,
                                          uIDAdjust, uIDAdjustMax,
                                          MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS);
        maxID = max(maxID, currentMax);
    }
 
    return maxID;
}

Referenced by CDefFolderMenu_MergeMenu().

Activate_RunDLL()

EXTERN_C BOOL WINAPI Activate_RunDLL	(	_In_ HWND	hwnd,
		_In_ HINSTANCE	hinst,
		_In_ LPCWSTR	cmdline,
		_In_ INT	cmdshow
	)

Definition at line 1583 of file utils.cpp.

{
    DWORD dwProcessID;
 
    UNREFERENCED_PARAMETER(hwnd);
    UNREFERENCED_PARAMETER(hinst);
    UNREFERENCED_PARAMETER(cmdline);
    UNREFERENCED_PARAMETER(cmdshow);
 
    TRACE("(%p, %p, %s, %d)\n", hwnd, hinst, debugstr_w(cmdline), cmdline);
 
    GetWindowThreadProcessId(GetShellWindow(), &dwProcessID);
    return AllowSetForegroundWindow(dwProcessID);
}

BindCtx_ContainsObject()

BOOL BindCtx_ContainsObject	(	_In_ IBindCtx *	pBindCtx,
		_In_ LPCWSTR	pszName
	)

Definition at line 328 of file utils.cpp.

{
    CComPtr<IUnknown> punk;
    if (!pBindCtx || FAILED(pBindCtx->GetObjectParam(const_cast<LPWSTR>(pszName), &punk)))
        return FALSE;
    return TRUE;
}

Referenced by CDesktopFolder::_ParseDisplayNameByParent(), CDesktopFolder::ParseDisplayName(), and CDesktopFolder::ShellUrlParseDisplayName().

BindCtx_GetMode()

DWORD BindCtx_GetMode	(	_In_ IBindCtx *	pbc,
		_In_ DWORD	dwDefault
	)

Definition at line 336 of file utils.cpp.

{
    if (!pbc)
        return dwDefault;
 
    BIND_OPTS BindOpts = { sizeof(BindOpts) };
    HRESULT hr = pbc->GetBindOptions(&BindOpts);
    if (FAILED(hr))
        return dwDefault;
 
    return BindOpts.grfMode;
}

Referenced by CDrivesFolder::ParseDisplayName(), CFSFolder::ParseDisplayName(), and CRegFolder::ParseDisplayName().

BindCtx_GetUIWindow()

EXTERN_C HWND BindCtx_GetUIWindow

(

_In_ IBindCtx *

pBindCtx

)

Definition at line 585 of file utils.cpp.

{
    HWND hWnd = NULL;
 
    CComPtr<IUnknown> punk;
    if (pBindCtx && SUCCEEDED(pBindCtx->GetObjectParam((LPWSTR)L"UI During Binding", &punk)))
        IUnknown_GetWindow(punk, &hWnd);
 
    return hWnd;
}

Referenced by SHParseDisplayName().

BindCtx_RegisterObjectParam()

EXTERN_C HRESULT BindCtx_RegisterObjectParam	(	_In_ IBindCtx *	pBindCtx,
		_In_ LPOLESTR	pszKey,
		_In_opt_ IUnknown *	punk,
		_Out_ LPBC *	ppbc
	)

Definition at line 645 of file utils.cpp.

{
    HRESULT hr = S_OK;
    CDummyOleWindow *pUnknown = NULL;
 
    *ppbc = pBindCtx;
 
    if (pBindCtx)
    {
        pBindCtx->AddRef();
    }
    else
    {
        hr = CreateBindCtx(0, ppbc);
        if (FAILED(hr))
            return hr;
    }
 
    if (!punk)
        punk = pUnknown = new CDummyOleWindow();
 
    hr = (*ppbc)->RegisterObjectParam(pszKey, punk);
 
    if (pUnknown)
        pUnknown->Release();
 
    if (FAILED(hr))
    {
        (*ppbc)->Release();
        *ppbc = NULL;
    }
 
    return hr;
}

Referenced by SHParseDisplayName().

CDefFolderMenu_MergeMenu()

EXTERN_C VOID WINAPI CDefFolderMenu_MergeMenu	(	_In_ HINSTANCE	hInstance,
		_In_ UINT	uMainMerge,
		_In_ UINT	uPopupMerge,
		_Inout_ LPQCMINFO	lpQcmInfo
	)

Definition at line 77 of file utils.cpp.

{
    UINT idCmdFirst = lpQcmInfo->idCmdFirst;
    HMENU hPopupMenu;
 
    if (uMainMerge)
    {
        hPopupMenu = SHLoadPopupMenu(hInstance, uMainMerge);
        if (hPopupMenu)
        {
            enum { uFlags = MM_ADDSEPARATOR | MM_SUBMENUSHAVEIDS | MM_DONTREMOVESEPS };
            idCmdFirst = Shell_MergeMenus(lpQcmInfo->hmenu,
                                          hPopupMenu,
                                          lpQcmInfo->indexMenu,
                                          lpQcmInfo->idCmdFirst,
                                          lpQcmInfo->idCmdLast,
                                          uFlags);
            DestroyMenu(hPopupMenu);
        }
    }
 
    if (uPopupMerge)
    {
        hPopupMenu = LoadMenuW(hInstance, MAKEINTRESOURCEW(uPopupMerge));
        if (hPopupMenu)
        {
            UINT id = _SHMergePopupMenus(lpQcmInfo->hmenu, hPopupMenu,
                                         lpQcmInfo->idCmdFirst, lpQcmInfo->idCmdLast);
            idCmdFirst = max(idCmdFirst, id);
            DestroyMenu(hPopupMenu);
        }
    }
 
    lpQcmInfo->idCmdFirst = idCmdFirst;
}

CopyStreamUI()

EXTERN_C HRESULT WINAPI CopyStreamUI	(	_In_ IStream *	pSrc,
		_Out_ IStream *	pDst,
		_Inout_opt_ IProgressDialog *	pProgress,
		_In_opt_ DWORDLONG	dwlSize
	)

Definition at line 1465 of file utils.cpp.

{
    HRESULT hr = E_FAIL;
    DWORD cbBuff, cbRead, dwSizeToWrite;
    DWORDLONG cbDone;
    LPVOID pBuff;
    CComHeapPtr<BYTE> pHeapPtr;
    STATSTG Stat;
    BYTE abBuff[1024];
 
    TRACE("(%p, %p, %p, %I64u)\n", pSrc, pDst, pProgress, dwlSize);
 
    if (dwlSize == 0) // Invalid size?
    {
        // Get the stream size
        ZeroMemory(&Stat, sizeof(Stat));
        if (FAILED(pSrc->Stat(&Stat, STATFLAG_NONAME)))
            pProgress = NULL; // No size info. Disable progress
        else
            dwlSize = Stat.cbSize.QuadPart;
    }
 
    if (!pProgress) // Progress is disabled?
    {
        ULARGE_INTEGER uliSize;
 
        if (dwlSize > 0)
            uliSize.QuadPart = dwlSize;
        else
            uliSize.HighPart = uliSize.LowPart = INVALID_FILE_SIZE;
 
        return pSrc->CopyTo(pDst, uliSize, NULL, NULL); // One punch
    }
 
    // Allocate the buffer if necessary
    if (dwlSize > 0 && dwlSize <= sizeof(abBuff))
    {
        cbBuff = sizeof(abBuff);
        pBuff = abBuff;
    }
    else
    {
#define COPY_STREAM_DEFAULT_BUFFER_SIZE 0x4000
        cbBuff = COPY_STREAM_DEFAULT_BUFFER_SIZE;
        if (pHeapPtr.AllocateBytes(cbBuff))
        {
            pBuff = pHeapPtr;
        }
        else // Low memory?
        {
            cbBuff = sizeof(abBuff);
            pBuff = abBuff;
        }
#undef COPY_STREAM_DEFAULT_BUFFER_SIZE
    }
 
    // Start reading
    LARGE_INTEGER zero;
    zero.QuadPart = 0;
    pSrc->Seek(zero, 0, NULL);
    pDst->Seek(zero, 0, NULL);
    cbDone = 0;
    pProgress->SetProgress64(cbDone, dwlSize);
 
    // Repeat reading and writing until goal
    for (;;)
    {
        hr = pSrc->Read(pBuff, cbBuff, &cbRead);
        if (FAILED(hr))
            break;
 
        // Calculate the size to write
        if (dwlSize > 0)
            dwSizeToWrite = (DWORD)min((DWORDLONG)(dwlSize - cbDone), (DWORDLONG)cbRead);
        else
            dwSizeToWrite = cbRead;
 
        if (dwSizeToWrite == 0) // No need to write?
        {
            hr = S_OK;
            break;
        }
 
        hr = pDst->Write(pBuff, dwSizeToWrite, NULL);
        if (hr != S_OK)
            break;
 
        cbDone += dwSizeToWrite;
 
        if (pProgress->HasUserCancelled()) // Cancelled?
        {
            hr = HRESULT_FROM_WIN32(ERROR_CANCELLED);
            break;
        }
        pProgress->SetProgress64(cbDone, dwlSize);
 
        if (dwlSize > 0 && cbDone >= dwlSize) // Reached the goal?
        {
            hr = S_OK;
            break;
        }
    }
 
    return hr;
}

DCIA_AddEntry()

int DCIA_AddEntry	(	HDCIA	hDCIA,
		REFCLSID	rClsId
	)

Definition at line 1941 of file utils.cpp.

{
    for (UINT i = 0;; ++i)
    {
        const CLSID *pClsId = DCIA_GetEntry(hDCIA, i);
        if (!pClsId)
            break;
        if (IsEqualGUID(*pClsId, rClsId))
            return i; // Don't allow duplicates
    }
    return DSA_AppendItem((HDSA)hDCIA, const_cast<CLSID*>(&rClsId));
}

Referenced by DCIA_AddShellExSubkey().

DCIA_AddShellExSubkey()

void DCIA_AddShellExSubkey	(	HDCIA	hDCIA,
		HKEY	hProgId,
		PCWSTR	pszSubkey
	)

Definition at line 1954 of file utils.cpp.

{
    WCHAR szKey[200];
    PathCombineW(szKey, L"shellex", pszSubkey);
    HKEY hEnum;
    if (RegOpenKeyExW(hProgId, szKey, 0, KEY_READ, &hEnum) != ERROR_SUCCESS)
        return;
    for (UINT i = 0; RegEnumKeyW(hEnum, i++, szKey, _countof(szKey)) == ERROR_SUCCESS;)
    {
        CLSID clsid;
        if (SUCCEEDED(SHELL_GetShellExtensionRegCLSID(hEnum, szKey, &clsid)))
            DCIA_AddEntry(hDCIA, clsid);
    }
    RegCloseKey(hEnum);
}

Referenced by CFSDropTarget::_GetEffectFromMenu().

DisplayNameOfW()

EXTERN_C HRESULT WINAPI DisplayNameOfW	(	_In_ IShellFolder *	psf,
		_In_ LPCITEMIDLIST	pidl,
		_In_ DWORD	dwFlags,
		_Out_ LPWSTR	pszBuf,
		_In_ UINT	cchBuf
	)

Definition at line 480 of file utils.cpp.

{
    *pszBuf = UNICODE_NULL;
    STRRET sr;
    HRESULT hr = psf->GetDisplayNameOf(pidl, dwFlags, &sr);
    if (FAILED(hr))
        return hr;
    return StrRetToBufW(&sr, pidl, pszBuf, cchBuf);
}

Referenced by SHGetNameAndFlagsW().

DynamicPathCommonPrefixW()

static INT DynamicPathCommonPrefixW ( _In_ LPCWSTR  lpszPath1, _In_ LPCWSTR  lpszPath2, _Out_ CStringW &  strPath  )

static

Definition at line 1633 of file utils.cpp.

{
    SIZE_T cchPath1 = wcslen(lpszPath1);
    SIZE_T cchPath2 = wcslen(lpszPath2);
    LPWSTR lpszPath = strPath.GetBuffer((INT)max(cchPath1, cchPath2) + 16);
    INT ret = PathCommonPrefixW(lpszPath1, lpszPath2, lpszPath);
    strPath.ReleaseBuffer();
    return ret;
}

Referenced by PathIsEqualOrSubFolder().

DynamicPathRemoveBackslashW()

static VOID DynamicPathRemoveBackslashW ( _Out_ CStringW &  strPath )

static

Definition at line 1705 of file utils.cpp.

{
    INT nLength = strPath.GetLength();
    if (nLength > 0 && strPath[nLength - 1] == L'\\')
        strPath = strPath.Left(nLength - 1);
}

Referenced by PathIsEqualOrSubFolder().

DynamicSHGetPathFromIDListW()

static HRESULT DynamicSHGetPathFromIDListW ( _In_ LPCITEMIDLIST  pidl, _Out_ CStringW &  strPath  )

static

Definition at line 1650 of file utils.cpp.

{
    HRESULT hr;
 
    for (UINT cchPath = MAX_PATH;; cchPath *= 2)
    {
        LPWSTR lpszPath = strPath.GetBuffer(cchPath);
        if (!lpszPath)
            return E_OUTOFMEMORY;
 
        hr = SHGetPathCchFromIDListW(pidl, lpszPath, cchPath);
        strPath.ReleaseBuffer();
 
        if (hr != E_NOT_SUFFICIENT_BUFFER)
            break;
 
        if (cchPath >= MAXUINT / 2)
        {
            hr = E_FAIL;
            break;
        }
    }
 
    if (FAILED(hr))
        strPath.Empty();
 
    return hr;
}

Referenced by DynamicSHGetSpecialFolderPathW().

DynamicSHGetSpecialFolderPathW()

static HRESULT DynamicSHGetSpecialFolderPathW ( _In_ HWND  hwndOwner, _Out_ CStringW &  strPath, _In_ INT  nCSIDL, _In_ BOOL  bCreate  )

static

Definition at line 1682 of file utils.cpp.

{
    LPITEMIDLIST pidl;
    HRESULT hr = SHGetSpecialFolderLocation(hwndOwner, nCSIDL, &pidl);
    if (SUCCEEDED(hr))
    {
        hr = DynamicSHGetPathFromIDListW(pidl, strPath);
        CoTaskMemFree(pidl);
    }
 
    if (FAILED(hr))
        strPath.Empty();
    else if (bCreate)
        CreateDirectoryW(strPath, NULL);
 
    return hr;
}

Referenced by PathIsEqualOrSubFolder().

ExtractIconResInfoA()

EXTERN_C WORD WINAPI ExtractIconResInfoA	(	_In_ HANDLE	hHandle,
		_In_ LPCSTR	lpFileName,
		_In_ WORD	wIndex,
		_Out_ LPWORD	lpSize,
		_Out_ LPHANDLE	lpIcon
	)

Definition at line 781 of file utils.cpp.

{
    TRACE("(%p, %s, %u, %p, %p)\n", hHandle, debugstr_a(lpFileName), wIndex, lpSize, lpIcon);
 
    if (!lpFileName)
        return 0;
 
    CStringW strFileNameW(lpFileName);
    return ExtractIconResInfoW(hHandle, strFileNameW, wIndex, lpSize, lpIcon);
}

FindVerbMapEntry()

static const CMVERBMAP * FindVerbMapEntry ( UINT_PTR  CmdId, const CMVERBMAP *  pMap  )

static

Definition at line 1897 of file utils.cpp.

{
    for (SIZE_T i = 0; pMap[i].Verb; ++i)
    {
        if (pMap[i].CmdId == CmdId)
            return &pMap[i];
    }
    return NULL;
}

Referenced by SHELL_GetCommandStringImpl().

GetCommandStringA()

static HRESULT GetCommandStringA ( _In_ IContextMenu *  pCM, _In_ UINT_PTR  Id, _In_ UINT  GCS, _Out_writes_(cchMax) LPSTR  Buf, _In_ UINT  cchMax  )

static

Definition at line 1847 of file utils.cpp.

{
    HRESULT hr = pCM->GetCommandString(Id, GCS & ~GCS_UNICODE, NULL, Buf, cchMax);
    if (FAILED(hr))
    {
        WCHAR buf[MAX_PATH];
        hr = pCM->GetCommandString(Id, GCS | GCS_UNICODE, NULL, (LPSTR)buf, _countof(buf));
        if (SUCCEEDED(hr))
            hr = SHUnicodeToAnsi(buf, Buf, cchMax) > 0 ? S_OK : E_FAIL;
    }
    return hr;
}

Referenced by GetDfmCmd().

GetDfmCmd()

UINT GetDfmCmd	(	_In_ IContextMenu *	pCM,
		_In_ LPCSTR	verba
	)

Definition at line 1861 of file utils.cpp.

{
    CHAR buf[MAX_PATH];
    if (IS_INTRESOURCE(verba))
    {
        if (FAILED(GetCommandStringA(pCM, LOWORD(verba), GCS_VERB, buf, _countof(buf))))
            return 0;
        verba = buf;
    }
    return MapVerbToDfmCmd(verba); // Returns DFM_CMD_* or 0
}

Referenced by BrFolder_OnContextMenu().

Int64GetNumFormat()

static VOID Int64GetNumFormat ( _Out_ NUMBERFMTW *  pDest, _In_opt_ const NUMBERFMTW *  pSrc, _In_ DWORD  dwNumberFlags, _Out_writes_(cchDecimal) LPWSTR  pszDecimal, _In_ INT  cchDecimal, _Out_writes_(cchThousand) LPWSTR  pszThousand, _In_ INT  cchThousand  )

static

Definition at line 1348 of file utils.cpp.

{
    WCHAR szBuff[20];
 
    if (pSrc)
        *pDest = *pSrc;
    else
        dwNumberFlags = 0;
 
    if (!(dwNumberFlags & FMT_USE_NUMDIGITS))
    {
        GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IDIGITS, szBuff, _countof(szBuff));
        pDest->NumDigits = StrToIntW(szBuff);
    }
 
    if (!(dwNumberFlags & FMT_USE_LEADZERO))
    {
        GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_ILZERO, szBuff, _countof(szBuff));
        pDest->LeadingZero = StrToIntW(szBuff);
    }
 
    if (!(dwNumberFlags & FMT_USE_GROUPING))
    {
        GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SGROUPING, szBuff, _countof(szBuff));
        pDest->Grouping = StrToIntW(szBuff);
    }
 
    if (!(dwNumberFlags & FMT_USE_DECIMAL))
    {
        GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, pszDecimal, cchDecimal);
        pDest->lpDecimalSep = pszDecimal;
    }
 
    if (!(dwNumberFlags & FMT_USE_THOUSAND))
    {
        GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, pszThousand, cchThousand);
        pDest->lpThousandSep = pszThousand;
    }
 
    if (!(dwNumberFlags & FMT_USE_NEGNUMBER))
    {
        GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_INEGNUMBER, szBuff, _countof(szBuff));
        pDest->NegativeOrder = StrToIntW(szBuff);
    }
}

Referenced by Int64ToString().

Int64ToStr()

static HRESULT Int64ToStr ( _In_ LONGLONG  llValue, _Out_writes_(cchValue) LPWSTR  pszValue, _In_ UINT  cchValue  )

static

Definition at line 1303 of file utils.cpp.

{
    WCHAR szBuff[40];
    UINT ich = 0, ichValue;
#if (WINVER >= _WIN32_WINNT_VISTA)
    BOOL bMinus = (llValue < 0);
 
    if (bMinus)
        llValue = -llValue;
#endif
 
    if (cchValue <= 0)
        return E_FAIL;
 
    do
    {
        szBuff[ich++] = (WCHAR)(L'0' + (llValue % 10));
        llValue /= 10;
    } while (llValue != 0 && ich < _countof(szBuff) - 1);
 
#if (WINVER >= _WIN32_WINNT_VISTA)
    if (bMinus && ich < _countof(szBuff))
        szBuff[ich++] = '-';
#endif
 
    for (ichValue = 0; ich > 0 && ichValue < cchValue; ++ichValue)
    {
        --ich;
        pszValue[ichValue] = szBuff[ich];
    }
 
    if (ichValue >= cchValue)
    {
        pszValue[cchValue - 1] = UNICODE_NULL;
        return E_FAIL;
    }
 
    pszValue[ichValue] = UNICODE_NULL;
    return S_OK;
}

Referenced by Int64ToString().

Int64ToString()

EXTERN_C INT WINAPI Int64ToString	(	_In_ LONGLONG	llValue,
		_Out_writes_(cchOut) LPWSTR	pszOut,
		_In_ UINT	cchOut,
		_In_ BOOL	bUseFormat,
		_In_opt_ const NUMBERFMTW *	pNumberFormat,
		_In_ DWORD	dwNumberFlags
	)

Definition at line 1408 of file utils.cpp.

{
    INT ret;
    NUMBERFMTW NumFormat;
    WCHAR szValue[80], szDecimalSep[6], szThousandSep[6];
 
    Int64ToStr(llValue, szValue, _countof(szValue));
 
    if (bUseFormat)
    {
        Int64GetNumFormat(&NumFormat, pNumberFormat, dwNumberFlags,
                          szDecimalSep, _countof(szDecimalSep),
                          szThousandSep, _countof(szThousandSep));
        ret = GetNumberFormatW(LOCALE_USER_DEFAULT, 0, szValue, &NumFormat, pszOut, cchOut);
        if (ret)
            --ret;
        return ret;
    }
 
    if (FAILED(StringCchCopyW(pszOut, cchOut, szValue)))
        return 0;
 
    return lstrlenW(pszOut);
}

Referenced by DoTestEntry(), LargeIntegerToString(), and Test_Int64ToString().

InvokeIExecuteCommand()

EXTERN_C HRESULT InvokeIExecuteCommand	(	_In_ IExecuteCommand *	pEC,
		_In_ PCWSTR	pszCommandName,
		_In_opt_ IPropertyBag *	pPB,
		_In_opt_ IShellItemArray *	pSIA,
		_In_opt_ LPCMINVOKECOMMANDINFOEX	pICI,
		_In_opt_ IUnknown *	pSite
	)

Definition at line 1796 of file utils.cpp.

{
    if (!pEC)
        return E_INVALIDARG;
 
    CScopedSetObjectWithSite site(pEC, pSite);
    IUnknown_InitializeCommand(pEC, pszCommandName, pPB);
 
    CComPtr<IObjectWithSelection> pOWS;
    if (pSIA && SUCCEEDED(pEC->QueryInterface(IID_PPV_ARG(IObjectWithSelection, &pOWS))))
        pOWS->SetSelection(pSIA);
 
    DWORD dwKeyState = 0, fMask = pICI ? pICI->fMask : 0;
    pEC->SetNoShowUI((fMask & CMIC_MASK_FLAG_NO_UI) != 0);
    pEC->SetShowWindow(pICI ? pICI->nShow : SW_SHOW);
    if (fMask & CMIC_MASK_SHIFT_DOWN)
        dwKeyState |= MK_SHIFT;
    if (fMask & CMIC_MASK_CONTROL_DOWN)
        dwKeyState |= MK_CONTROL;
    pEC->SetKeyState(dwKeyState);
    if ((fMask & CMIC_MASK_UNICODE) && pICI->lpDirectoryW)
        pEC->SetDirectory(pICI->lpDirectoryW);
    if ((fMask & CMIC_MASK_UNICODE) && pICI->lpParametersW)
        pEC->SetParameters(pICI->lpParametersW);
    if (fMask & CMIC_MASK_PTINVOKE)
        pEC->SetPosition(pICI->ptInvoke);
 
    return pEC->Execute();
}

Referenced by InvokeIExecuteCommandWithDataObject().

InvokeIExecuteCommandWithDataObject()

EXTERN_C HRESULT InvokeIExecuteCommandWithDataObject	(	_In_ IExecuteCommand *	pEC,
		_In_ PCWSTR	pszCommandName,
		_In_opt_ IPropertyBag *	pPB,
		_In_ IDataObject *	pDO,
		_In_opt_ LPCMINVOKECOMMANDINFOEX	pICI,
		_In_opt_ IUnknown *	pSite
	)

Definition at line 1833 of file utils.cpp.

{
    CComPtr<IShellItemArray> pSIA;
    HRESULT hr = SHCreateShellItemArrayFromDataObject(pDO, IID_PPV_ARG(IShellItemArray, &pSIA));
    return SUCCEEDED(hr) ? InvokeIExecuteCommand(pEC, pszCommandName, pPB, pSIA, pICI, pSite) : hr;
}

Referenced by CDefaultContextMenu::InvokeRegVerb().

IsShutdownAllowed()

BOOL IsShutdownAllowed

(

VOID

)

Definition at line 948 of file utils.cpp.

{
    return SHTestTokenPrivilegeW(NULL, SE_SHUTDOWN_NAME);
}

Referenced by IsSuspendAllowed().

IsSuspendAllowed()

BOOL WINAPI IsSuspendAllowed

(

VOID

)

Definition at line 956 of file utils.cpp.

{
    TRACE("()\n");
    return IsShutdownAllowed() && IsPwrSuspendAllowed();
}

IUnknown_InitializeCommand()

EXTERN_C HRESULT IUnknown_InitializeCommand	(	_In_ IUnknown *	pUnk,
		_In_ PCWSTR	pszCommandName,
		_In_opt_ IPropertyBag *	pPB
	)

Definition at line 1783 of file utils.cpp.

{
    HRESULT hr;
    CComPtr<IInitializeCommand> pIC;
    if (SUCCEEDED(hr = pUnk->QueryInterface(IID_PPV_ARG(IInitializeCommand, &pIC))))
        hr = pIC->Initialize(pszCommandName, pPB);
    return hr;
}

Referenced by InvokeIExecuteCommand(), and CDefaultContextMenu::InvokeRegVerb().

LargeIntegerToString()

EXTERN_C INT WINAPI LargeIntegerToString	(	_In_ const LARGE_INTEGER *	pLargeInt,
		_Out_writes_(cchOut) LPWSTR	pszOut,
		_In_ UINT	cchOut,
		_In_ BOOL	bUseFormat,
		_In_opt_ const NUMBERFMTW *	pNumberFormat,
		_In_ DWORD	dwNumberFlags
	)

Definition at line 1446 of file utils.cpp.

{
    return Int64ToString(pLargeInt->QuadPart, pszOut, cchOut, bUseFormat,
                         pNumberFormat, dwNumberFlags);
}

Referenced by DoTestEntry(), and Test_LargeIntegerToString().

LinkWindow_RegisterClass()

EXTERN_C BOOL WINAPI LinkWindow_RegisterClass

(

VOID

)

Definition at line 2392 of file utils.cpp.

{
    INITCOMMONCONTROLSEX iccx = { sizeof(iccx), ICC_LINK_CLASS };
    InitCommonControlsEx(&iccx);
 
    WNDCLASSEXW wcx = { sizeof(wcx) };
    if (!GetClassInfoExW(NULL, L"SysLink", &wcx))
        return FALSE;
 
    /* Superclassing! */
    wcx.lpszClassName = L"Link Window";
    return RegisterClassExW(&wcx) || (GetLastError() == ERROR_CLASS_ALREADY_EXISTS);
}

LinkWindow_UnregisterClass()

EXTERN_C BOOL WINAPI LinkWindow_UnregisterClass

(

_In_ DWORD

dwUnused

)

Definition at line 2409 of file utils.cpp.

{
    /* Do nothing. This is correct. */
    return TRUE;
}

OpenEffectiveToken()

static BOOL OpenEffectiveToken ( _In_ DWORD  DesiredAccess, _Out_ HANDLE *  phToken  )

static

Definition at line 307 of file utils.cpp.

{
    BOOL ret;
 
    if (phToken == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    *phToken = NULL;
 
    ret = OpenThreadToken(GetCurrentThread(), DesiredAccess, FALSE, phToken);
    if (!ret && GetLastError() == ERROR_NO_TOKEN)
        ret = OpenProcessToken(GetCurrentProcess(), DesiredAccess, phToken);
 
    return ret;
}

Referenced by SHOpenEffectiveToken().

PathIsDosDevice()

BOOL PathIsDosDevice

(

_In_ LPCWSTR

pszName

)

Definition at line 240 of file utils.cpp.

{
    WCHAR szPath[MAX_PATH];
    StringCchCopyW(szPath, _countof(szPath), pszName);
    PathRemoveExtensionW(szPath);
 
    if (lstrcmpiW(szPath, L"NUL") == 0 || lstrcmpiW(szPath, L"PRN") == 0 ||
        lstrcmpiW(szPath, L"CON") == 0 || lstrcmpiW(szPath, L"AUX") == 0)
    {
        return TRUE;
    }
 
    if (_wcsnicmp(szPath, L"LPT", 3) == 0 || _wcsnicmp(szPath, L"COM", 3) == 0)
    {
        if ((L'0' <= szPath[3] && szPath[3] <= L'9') && szPath[4] == UNICODE_NULL)
            return TRUE;
    }
 
    return FALSE;
}

Referenced by CFSFolder::_CreateIDListFromName().

PathIsDotOrDotDotW()

BOOL PathIsDotOrDotDotW

(

_In_ LPCWSTR

pszPath

)

Definition at line 214 of file utils.cpp.

{
    if (pszPath[0] != L'.')
        return FALSE;
    return !pszPath[1] || (pszPath[1] == L'.' && !pszPath[2]);
}

Referenced by PathIsValidElement(), and CFileDefExt::WalkDirTree().

PathIsEqualOrSubFolder()

EXTERN_C BOOL WINAPI PathIsEqualOrSubFolder	(	_In_ LPCWSTR	pszPath1OrCSIDL,
		_In_ LPCWSTR	pszPath2
	)

Definition at line 1718 of file utils.cpp.

{
    CStringW strCommon, strPath1;
 
    TRACE("(%s %s)\n", debugstr_w(pszPath1OrCSIDL), debugstr_w(pszPath2));
 
    if (IS_INTRESOURCE(pszPath1OrCSIDL))
    {
        DynamicSHGetSpecialFolderPathW(
            NULL, strPath1, LOWORD(pszPath1OrCSIDL) | CSIDL_FLAG_DONT_VERIFY, FALSE);
    }
    else
    {
        strPath1 = pszPath1OrCSIDL;
    }
 
    DynamicPathRemoveBackslashW(strPath1);
 
    if (!DynamicPathCommonPrefixW(strPath1, pszPath2, strCommon))
        return FALSE;
 
    return strPath1.CompareNoCase(strCommon) == 0;
}

Referenced by PathIsTemporaryW(), and START_TEST().

PathIsSlowA()

EXTERN_C BOOL WINAPI PathIsSlowA	(	_In_ LPCSTR	pszFile,
		_In_ DWORD	dwAttr
	)

Definition at line 767 of file utils.cpp.

{
    TRACE("(%s, 0x%X)\n", debugstr_a(pszFile), dwAttr);
    CStringW strFileW(pszFile);
    return PathIsSlowW(strFileW, dwAttr);
}

Referenced by Test_PathIsSlowA().

PathIsSlowW()

EXTERN_C BOOL WINAPI PathIsSlowW	(	_In_ LPCWSTR	pszFile,
		_In_ DWORD	dwAttr
	)

Definition at line 718 of file utils.cpp.

{
    TRACE("PathIsSlowW(%s, %lx)\n", debugstr_w(pszFile), dwAttr);
 
    /* If we didn't get attributes, get them */
    if (dwAttr == INVALID_FILE_ATTRIBUTES)
        dwAttr = GetFileAttributesW(pszFile);
 
    /* Offline files are always considered slow */
    if (dwAttr != INVALID_FILE_ATTRIBUTES &&
        (dwAttr & FILE_ATTRIBUTE_OFFLINE))
    {
        return TRUE;
    }
 
    /* Only network paths can be slow bandwidth-wise */
    if (!PathIsNetworkPathW(pszFile))
        return FALSE;
 
    /* Query connection speed with MPR */
    NETRESOURCEW nr = {0};
    NETCONNECTINFOSTRUCT nci = { sizeof(nci) };
 
    WCHAR szRoot[MAX_PATH];
    if (FAILED(StringCchCopyW(szRoot, _countof(szRoot), pszFile)))
        return FALSE;
    PathStripToRootW(szRoot);
 
    nr.lpRemoteName = szRoot;
    nr.dwType = RESOURCETYPE_DISK;
 
    if (MultinetGetConnectionPerformanceW(&nr, &nci) == NO_ERROR)
    {
        if (nci.dwSpeed <= 400)
            return TRUE;
    }
 
    return FALSE;
}

Referenced by PathIsSlowA(), Test_PathIsSlowA(), and Test_PathIsSlowW().

PathIsValidElement()

BOOL PathIsValidElement

(

_In_ LPCWSTR

pszPath

)

Definition at line 226 of file utils.cpp.

{
    if (!*pszPath || PathIsDotOrDotDotW(pszPath))
        return FALSE;
 
    for (LPCWSTR pch = pszPath; *pch; ++pch)
    {
        if (!PathIsValidCharW(*pch, PATH_VALID_ELEMENT))
            return FALSE;
    }
 
    return TRUE;
}

Referenced by Shell_NextElement().

SHBindToObject()

SHSTDAPI SHBindToObject	(	_In_opt_ IShellFolder *	pShellFolder,
		_In_ PCUIDLIST_RELATIVE	pidl,
		_In_opt_ IBindCtx *	pBindCtx,
		_In_ REFIID	riid,
		_Out_ void **	ppvObj
	)

Definition at line 395 of file utils.cpp.

{
    CComPtr<IShellFolder> psfDesktop;
 
    *ppvObj = NULL;
 
    if (!pShellFolder)
    {
        SHGetDesktopFolder(&psfDesktop);
        if (!psfDesktop)
            return E_FAIL;
 
        pShellFolder = psfDesktop;
    }
 
    HRESULT hr;
    if (_ILIsDesktop(pidl))
        hr = pShellFolder->QueryInterface(riid, ppvObj);
    else
        hr = pShellFolder->BindToObject(pidl, pBindCtx, riid, ppvObj);
 
    if (SUCCEEDED(hr) && !*ppvObj)
        hr = E_FAIL;
 
    return hr;
}

Referenced by SHELL_GetIDListTarget().

SHCoInitializeAnyApartment()

HRESULT SHCoInitializeAnyApartment

(

VOID

)

Definition at line 542 of file utils.cpp.

{
    HRESULT hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
    if (FAILED(hr))
        hr = CoInitializeEx(NULL, COINIT_DISABLE_OLE1DDE);
    return hr;
}

Referenced by ShellExecuteExW(), SHGetNameAndFlagsW(), and SHSetLocalizedName().

SHCreatePropertyBag()

EXTERN_C HRESULT WINAPI SHCreatePropertyBag	(	_In_ REFIID	riid,
		_Out_ void **	ppvObj
	)

Definition at line 1009 of file utils.cpp.

{
    return SHCreatePropertyBagOnMemory(STGM_READWRITE, riid, ppvObj);
}

SHELL32_AliasTranslatePidl()

EXTERN_C HRESULT SHELL32_AliasTranslatePidl	(	_In_ LPCITEMIDLIST	pidl,
		_Out_ LPITEMIDLIST *	ppidlNew,
		_In_ DWORD	dwFlags
	)

Translate a PIDL to an "alias" PIDL.

Definition at line 2379 of file utils.cpp.

{
    return SHELL32_ReparentAsAliasPidl(NULL, NULL, pidl, ppidlNew, dwFlags) ? S_OK : E_FAIL;
}

Referenced by CreateNotificationParamAndSend(), CDesktopFolder::ParseDisplayName(), and SHLogILFromFSIL().

SHELL32_ReparentAsAliasPidl()

EXTERN_C BOOL SHELL32_ReparentAsAliasPidl	(	_In_opt_ HWND	hwnd,
		_In_opt_ HANDLE	hToken,
		_In_ LPCITEMIDLIST	pidlTarget,
		_Out_ LPITEMIDLIST *	ppidlNew,
		_In_ DWORD	dwFlags
	)

Translate a PIDL to an "alias" PIDL.

Definition at line 2240 of file utils.cpp.

{
    if (!pidlTarget || !ppidlNew)
        return FALSE;
 
    *ppidlNew = NULL;
 
    for (SIZE_T iEntry = 0; iEntry < _countof(g_AliasTable); ++iEntry)
    {
        const ALIAS_MAPPING *pEntry = &g_AliasTable[iEntry];
 
        if (!(dwFlags & pEntry->bFlagMask))
            continue;
 
        // Get the source root PIDL
        LPITEMIDLIST pidlSrcRoot = NULL;
        HRESULT hr = SHGetFolderLocation(hwnd, pEntry->nCsidlSrc, hToken, 0, &pidlSrcRoot);
        if (FAILED(hr))
            continue;
 
        // Check whether the input pidlTarget is under the source folder.
        // If it matches, ILFindChild returns the relative PIDL in the pidlTarget.
        LPCITEMIDLIST pidlRelative = ILFindChild(pidlSrcRoot, pidlTarget);
        if (!pidlRelative) // Not found?
        {
            ILFree(pidlSrcRoot);
            continue;
        }
 
        // Found. Get the destination root PIDL
        LPITEMIDLIST pidlDestRoot = NULL;
        hr = SHGetFolderLocation(hwnd, pEntry->nCsidlDest, hToken, 0, &pidlDestRoot);
        if (SUCCEEDED(hr))
        {
            // Create a new PIDL by combining the destination root PIDL and the relative PIDL
            *ppidlNew = ILCombine(pidlDestRoot, pidlRelative);
            if (*ppidlNew)
            {
                // Manipulate specific flags in the PIDL if necessary
                if (pEntry->bCommonDesktop && (*ppidlNew)->mkid.cb >= 3)
                {
                    (*ppidlNew)->mkid.abID[0] |= (PT_FS | PT_FS_COMMON_FLAG);
                }
            }
            ILFree(pidlDestRoot);
        }
 
        ILFree(pidlSrcRoot);
        break; // A match was found, so exit the loop
    }
 
    return (*ppidlNew != NULL);
}

Referenced by SHELL32_AliasTranslatePidl().

SHELL_BuildDisplayMachineName()

static HRESULT SHELL_BuildDisplayMachineName ( _Out_writes_z_(cchNameMax) PWSTR  pszName, _In_ DWORD  cchNameMax, _In_ PCWSTR  pszServerName, _In_ PCWSTR  pszDescription  )

static

Definition at line 2122 of file utils.cpp.

{
    if (!pszDescription || !*pszDescription)
        return E_FAIL;
 
    PCWSTR pszFormat = (SHRestricted(REST_ALLOWCOMMENTTOGGLE) ? L"%2 (%1)" : L"%1 (%2)");
    PCWSTR args[] = { pszDescription , SHELL_SkipServerSlashes(pszServerName) };
    return (FormatMessageW(FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_FROM_STRING,
                           pszFormat, 0, 0, pszName, cchNameMax, (va_list *)args) ? S_OK : E_FAIL);
}

Referenced by SHGetComputerDisplayNameW().

SHELL_CacheComputerDescription()

static VOID SHELL_CacheComputerDescription ( _In_ PCWSTR  pszServerName, _In_ PCWSTR  pszDesc  )

static

Definition at line 2085 of file utils.cpp.

{
    if (!pszDesc)
        return;
 
    SIZE_T cbDesc = (wcslen(pszDesc) + 1) * sizeof(WCHAR);
    SHSetValueW(HKEY_CURRENT_USER, COMPUTER_DESCRIPTIONS_KEY,
                SHELL_SkipServerSlashes(pszServerName), REG_SZ, pszDesc, (DWORD)cbDesc);
}

Referenced by SHGetComputerDisplayNameW().

SHELL_CreateShell32DefaultExtractIcon()

HRESULT SHELL_CreateShell32DefaultExtractIcon	(	int	IconIndex,
		REFIID	riid,
		LPVOID *	ppvOut
	)

Definition at line 1931 of file utils.cpp.

{
    CComPtr<IDefaultExtractIconInit> initIcon;
    HRESULT hr = SHCreateDefaultExtractIcon(IID_PPV_ARG(IDefaultExtractIconInit, &initIcon));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
    initIcon->SetNormalIcon(swShell32Name, IconIndex);
    return initIcon->QueryInterface(riid, ppvOut);
}

Referenced by SHELL_CreateFallbackExtractIconForFolder(), and SHELL_CreateFallbackExtractIconForNoAssocFile().

SHELL_DisplayNameOf()

HRESULT SHELL_DisplayNameOf	(	_In_opt_ IShellFolder *	psf,
		_In_ LPCITEMIDLIST	pidl,
		_In_opt_ UINT	Flags,
		_Out_ PWSTR *	ppStr
	)

Definition at line 454 of file utils.cpp.

{
    HRESULT hr;
    CComPtr<IShellFolder> psfRoot;
    if (!psf)
    {
        PCUITEMID_CHILD pidlChild;
        hr = SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &psfRoot), &pidlChild);
        if (FAILED(hr))
            return hr;
        psf = psfRoot;
        pidl = pidlChild;
    }
    STRRET sr;
    hr = psf->GetDisplayNameOf((PCUITEMID_CHILD)pidl, Flags, &sr);
    return SUCCEEDED(hr) ? StrRetToStrW(&sr, pidl, ppStr) : hr;
}

Referenced by CFolderItems::IncludeItem(), CFileDefExt::InitMultifilePageThread(), and CFolder::NewFolder().

Shell_FailForceReturn()

BOOL Shell_FailForceReturn

(

_In_ HRESULT

hr

)

Definition at line 378 of file utils.cpp.

{
    DWORD code = HRESULT_CODE(hr);
 
    switch (code)
    {
        case ERROR_BAD_NETPATH:
        case ERROR_BAD_NET_NAME:
        case ERROR_CANCELLED:
            return TRUE;
 
        default:
            return (ERROR_FILE_NOT_FOUND <= code && code <= ERROR_PATH_NOT_FOUND);
    }
}

Referenced by CDesktopFolder::ParseDisplayName(), and CDesktopFolder::ShellUrlParseDisplayName().

SHELL_GetCachedComputerDescription()

static HRESULT SHELL_GetCachedComputerDescription ( _Out_writes_z_(cchDescMax) PWSTR  pszDesc, _In_ DWORD  cchDescMax, _In_ PCWSTR  pszServerName  )

static

Definition at line 2072 of file utils.cpp.

{
    cchDescMax *= sizeof(WCHAR);
    DWORD error = SHGetValueW(HKEY_CURRENT_USER, COMPUTER_DESCRIPTIONS_KEY,
                              SHELL_SkipServerSlashes(pszServerName), NULL, pszDesc, &cchDescMax);
    return HRESULT_FROM_WIN32(error);
}

Referenced by SHGetComputerDisplayNameW().

SHELL_GetCommandStringImpl()

HRESULT SHELL_GetCommandStringImpl	(	SIZE_T	CmdId,
		UINT	uFlags,
		LPSTR	Buf,
		UINT	cchBuf,
		const CMVERBMAP *	pMap
	)

Definition at line 1908 of file utils.cpp.

{
    const CMVERBMAP* pEntry;
    switch (uFlags | GCS_UNICODE)
    {
        case GCS_VALIDATEW:
        case GCS_VERBW:
            pEntry = FindVerbMapEntry(CmdId, pMap);
            if ((uFlags | GCS_UNICODE) == GCS_VERBW)
            {
                if (!pEntry)
                    return E_INVALIDARG;
                else if (uFlags & GCS_UNICODE)
                    return SHAnsiToUnicode(pEntry->Verb, (LPWSTR)Buf, cchBuf) ? S_OK : E_FAIL;
                else
                    return StringCchCopyA(Buf, cchBuf, pEntry->Verb);
            }
            return pEntry ? S_OK : S_FALSE; // GCS_VALIDATE
    }
    return E_NOTIMPL;
}

Referenced by CCopyAsPathMenu::GetCommandString(), COpenWithMenu::GetCommandString(), CRecycleBinItemContextMenu::GetCommandString(), and CRecycleBin::GetCommandString().

SHELL_GetComputerDescription()

static HRESULT SHELL_GetComputerDescription ( _Out_writes_z_(cchDescMax) PWSTR  pszDesc, _In_ SIZE_T  cchDescMax, _In_ PWSTR  pszServerName  )

static

Definition at line 2099 of file utils.cpp.

{
    PSERVER_INFO_101 bufptr;
    NET_API_STATUS error = NetServerGetInfo(pszServerName, 101, (PBYTE*)&bufptr);
    HRESULT hr = (error > 0) ? HRESULT_FROM_WIN32(error) : error;
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    PCWSTR comment = bufptr->sv101_comment;
    if (comment && comment[0])
        StringCchCopyW(pszDesc, cchDescMax, comment);
    else
        hr = E_FAIL;
 
    NetApiBufferFree(bufptr);
    return hr;
}

Referenced by SHGetComputerDisplayNameW().

SHELL_GetIDListTarget()

HRESULT SHELL_GetIDListTarget	(	_In_ LPCITEMIDLIST	pidl,
		_Out_ PIDLIST_ABSOLUTE *	ppidl
	)

Definition at line 530 of file utils.cpp.

{
    IShellLink *pSL;
    HRESULT hr = SHBindToObject(NULL, pidl, NULL, IID_PPV_ARG(IShellLink, &pSL));
    if (SUCCEEDED(hr))
    {
        hr = pSL->GetIDList(ppidl); // Note: Returns S_FALSE if no target pidl
        pSL->Release();
    }
    return hr;
}

Referenced by SHBrowseForFolderW().

SHELL_GetUIObjectOfAbsoluteItem()

EXTERN_C HRESULT SHELL_GetUIObjectOfAbsoluteItem	(	_In_opt_ HWND	hWnd,
		_In_ PCIDLIST_ABSOLUTE	pidl,
		_In_ REFIID	riid,
		_Out_ void **	ppvObj
	)

Definition at line 428 of file utils.cpp.

{
    if (!ppvObj)
        return E_INVALIDARG;
    *ppvObj = NULL;
    IShellFolder *psf;
    PCUITEMID_CHILD pidlChild;
    HRESULT hr = SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlChild);
    if (SUCCEEDED(hr))
    {
        hr = psf->GetUIObjectOf(hWnd, 1, &pidlChild, riid, NULL, ppvObj);
        psf->Release();
        if (SUCCEEDED(hr))
        {
            if (*ppvObj)
                return hr;
            hr = E_FAIL;
        }
    }
    return hr;
}

Referenced by CShellLink::DragEnter(), CSendToMenu::GetUIObjectFromPidl(), CFolder::GetUIObjectFromVariant(), CFolderItemVerbs::Init(), SHELL_PidlGetIconLocationW(), and shellex_get_dataobj().

SHELL_MapContextMenuVerbToCmdId()

HRESULT SHELL_MapContextMenuVerbToCmdId	(	LPCMINVOKECOMMANDINFO	pICI,
		const CMVERBMAP *	pMap
	)

Definition at line 1874 of file utils.cpp.

{
    LPCSTR pVerbA = pICI->lpVerb;
    CHAR buf[MAX_PATH];
    LPCMINVOKECOMMANDINFOEX pICIX = (LPCMINVOKECOMMANDINFOEX)pICI;
    if (IsUnicode(*pICIX) && !IS_INTRESOURCE(pICIX->lpVerbW))
    {
        if (SHUnicodeToAnsi(pICIX->lpVerbW, buf, _countof(buf)))
            pVerbA = buf;
    }
 
    if (IS_INTRESOURCE(pVerbA))
        return LOWORD(pVerbA);
    for (SIZE_T i = 0; pMap[i].Verb; ++i)
    {
        assert(SUCCEEDED((int)(pMap[i].CmdId))); // The id must be >= 0 and ideally in the 0..0x7fff range
        if (!lstrcmpiA(pMap[i].Verb, pVerbA) && pVerbA[0])
            return pMap[i].CmdId;
    }
    return E_FAIL;
}

Referenced by CCopyAsPathMenu::InvokeCommand(), COpenWithMenu::InvokeCommand(), CRecycleBinItemContextMenu::InvokeCommand(), and CRecycleBin::InvokeCommand().

SHELL_ReadSingleUnreadMailCount()

static DWORD SHELL_ReadSingleUnreadMailCount ( _In_ HKEY  hKey, _Out_opt_ PDWORD  pdwCount, _Out_opt_ PFILETIME  pFileTime, _Out_writes_opt_(cchShellExecuteCommand) LPWSTR  pszShellExecuteCommand, _In_ INT  cchShellExecuteCommand  )

static

Definition at line 1016 of file utils.cpp.

{
    DWORD dwType, dwCount, cbSize = sizeof(dwCount);
    DWORD error = SHQueryValueExW(hKey, L"MessageCount", 0, &dwType, &dwCount, &cbSize);
    if (error)
        return error;
    if (pdwCount && dwType == REG_DWORD)
        *pdwCount = dwCount;
 
    FILETIME FileTime;
    cbSize = sizeof(FileTime);
    error = SHQueryValueExW(hKey, L"TimeStamp", 0, &dwType, &FileTime, &cbSize);
    if (error)
        return error;
    if (pFileTime && dwType == REG_BINARY)
        *pFileTime = FileTime;
 
    WCHAR szName[2 * MAX_PATH];
    cbSize = sizeof(szName);
    error = SHQueryValueExW(hKey, L"Application", 0, &dwType, szName, &cbSize);
    if (error)
        return error;
 
    if (pszShellExecuteCommand && dwType == REG_SZ &&
        FAILED(StringCchCopyW(pszShellExecuteCommand, cchShellExecuteCommand, szName)))
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }
 
    return ERROR_SUCCESS;
}

Referenced by SHGetUnreadMailCountW().

SHELL_SkipServerSlashes()

static PCWSTR SHELL_SkipServerSlashes ( _In_ PCWSTR  pszPath )

static

Definition at line 2057 of file utils.cpp.

{
    PCWSTR pch;
    for (pch = pszPath; *pch == L'\\'; ++pch)
        ;
    return pch;
}

Referenced by SHELL_BuildDisplayMachineName(), SHELL_CacheComputerDescription(), SHELL_GetCachedComputerDescription(), and SHGetComputerDisplayNameW().

SHEnumerateUnreadMailAccountsW()

EXTERN_C HRESULT WINAPI SHEnumerateUnreadMailAccountsW	(	_In_opt_ HKEY	hKeyUser,
		_In_ DWORD	dwIndex,
		_Out_writes_(cchMailAddress) PWSTR	pszMailAddress,
		_In_ INT	cchMailAddress
	)

Definition at line 1243 of file utils.cpp.

{
    if (!hKeyUser)
        hKeyUser = HKEY_CURRENT_USER;
 
    HKEY hKey;
    LSTATUS error = RegOpenKeyExW(hKeyUser,
                                  L"Software\\Microsoft\\Windows\\CurrentVersion\\UnreadMail",
                                  0, KEY_ENUMERATE_SUB_KEYS, &hKey);
    if (error)
        return HRESULT_FROM_WIN32(error);
 
    FILETIME FileTime;
    error = RegEnumKeyExW(hKey, dwIndex, pszMailAddress, (PDWORD)&cchMailAddress, NULL, NULL,
                          NULL, &FileTime);
    if (error)
        *pszMailAddress = UNICODE_NULL;
 
    RegCloseKey(hKey);
    return error ? HRESULT_FROM_WIN32(error) : S_OK;
}

Referenced by START_TEST().

SheRemoveQuotesA()

EXTERN_C LPSTR WINAPI SheRemoveQuotesA

(

LPSTR

psz

)

Definition at line 1193 of file utils.cpp.

{
    PCHAR pch;
 
    if (*psz == '"')
    {
        for (pch = psz + 1; *pch && *pch != '"'; ++pch)
        {
            *(pch - 1) = *pch;
        }
 
        if (*pch == '"')
            *(pch - 1) = ANSI_NULL;
    }
 
    return psz;
}

SheRemoveQuotesW()

EXTERN_C LPWSTR WINAPI SheRemoveQuotesW

(

LPWSTR

psz

)

Definition at line 1218 of file utils.cpp.

{
    PWCHAR pch;
 
    if (*psz == L'"')
    {
        for (pch = psz + 1; *pch && *pch != L'"'; ++pch)
        {
            *(pch - 1) = *pch;
        }
 
        if (*pch == L'"')
            *(pch - 1) = UNICODE_NULL;
    }
 
    return psz;
}

SHFindComputer()

EXTERN_C BOOL WINAPI SHFindComputer	(	LPCITEMIDLIST	pidlRoot,
		LPCITEMIDLIST	pidlSavedSearch
	)

Definition at line 1277 of file utils.cpp.

{
    UNREFERENCED_PARAMETER(pidlRoot);
    UNREFERENCED_PARAMETER(pidlSavedSearch);
 
    TRACE("%p %p\n", pidlRoot, pidlSavedSearch);
 
    IContextMenu *pCM;
    HRESULT hr = CoCreateInstance(CLSID_ShellSearchExt, NULL, CLSCTX_INPROC_SERVER,
                                  IID_IContextMenu, (void **)&pCM);
    if (FAILED(hr))
    {
        ERR("0x%08X\n", hr);
        return hr;
    }
 
    CMINVOKECOMMANDINFO InvokeInfo = { sizeof(InvokeInfo) };
    InvokeInfo.lpParameters = "{996E1EB1-B524-11D1-9120-00A0C98BA67D}";
    InvokeInfo.nShow = SW_SHOWNORMAL;
    hr = pCM->InvokeCommand(&InvokeInfo);
    pCM->Release();
 
    return SUCCEEDED(hr);
}

Referenced by CTrayWindow::HandleCommand(), and CTrayWindow::HandleHotKey().

SHGetAttributes()

DWORD SHGetAttributes	(	_In_ IShellFolder *	psf,
		_In_ LPCITEMIDLIST	pidl,
		_In_ DWORD	dwAttributes
	)

Definition at line 496 of file utils.cpp.

{
    LPCITEMIDLIST pidlLast = pidl;
    IShellFolder *release = NULL;
 
    if (!psf)
    {
        SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlLast);
        if (!psf)
            return 0;
        release = psf;
    }
 
    DWORD oldAttrs = dwAttributes;
    if (FAILED(psf->GetAttributesOf(1, &pidlLast, &dwAttributes)))
        dwAttributes = 0;
    else
        dwAttributes &= oldAttrs;
 
    if ((dwAttributes & SFGAO_FOLDER) &&
        (dwAttributes & SFGAO_STREAM) &&
        !(dwAttributes & SFGAO_STORAGEANCESTOR) &&
        (oldAttrs & SFGAO_STORAGEANCESTOR) &&
        (SHGetObjectCompatFlags(psf, NULL) & 0x200))
    {
        dwAttributes &= ~(SFGAO_STREAM | SFGAO_STORAGEANCESTOR);
        dwAttributes |= SFGAO_STORAGEANCESTOR;
    }
 
    if (release)
        release->Release();
    return dwAttributes;
}

Referenced by CFSDropTarget::_DoDrop(), BrFolder_InsertItem(), CRegItemContextMenu_CreateInstance(), CFolderItem::HasAttribute(), CFolder::NewFolder(), CDefView::OnCreate(), and SHGetNameAndFlagsW().

SHGetComputerDisplayNameW()

EXTERN_C HRESULT WINAPI SHGetComputerDisplayNameW	(	_In_opt_ PWSTR	pszServerName,
		_In_ DWORD	dwFlags,
		_Out_writes_z_(cchNameMax) PWSTR	pszName,
		_In_ DWORD	cchNameMax
	)

Definition at line 2142 of file utils.cpp.

{
    WCHAR szDesc[256], szCompName[MAX_COMPUTERNAME_LENGTH + 1];
 
    // If no server name is specified, retrieve the local computer name
    if (!pszServerName)
    {
        // Use computer name as server name
        DWORD cchCompName = _countof(szCompName);
        if (!GetComputerNameW(szCompName, &cchCompName))
            return E_FAIL;
        pszServerName = szCompName;
 
        // Don't use the cache for the local machine
        dwFlags |= SHGCDN_NOCACHE;
    }
 
    // Get computer description from cache if necessary
    HRESULT hr = E_FAIL;
    if (!(dwFlags & SHGCDN_NOCACHE))
        hr = SHELL_GetCachedComputerDescription(szDesc, _countof(szDesc), pszServerName);
 
    // Actually retrieve the computer description if it is not in the cache
    if (FAILED(hr))
    {
        hr = SHELL_GetComputerDescription(szDesc, _countof(szDesc), pszServerName);
        if (FAILED(hr))
            szDesc[0] = UNICODE_NULL;
 
        // Cache the description if necessary
        if (!(dwFlags & SHGCDN_NOCACHE))
            SHELL_CacheComputerDescription(pszServerName, szDesc);
    }
 
    // If getting the computer description failed, store the server name only
    if (FAILED(hr) || !szDesc[0])
    {
        if (dwFlags & SHGCDN_NOSERVERNAME)
            return hr; // Bail out if no server name is requested
 
        StringCchCopyW(pszName, cchNameMax, SHELL_SkipServerSlashes(pszServerName));
        return S_OK;
    }
 
    // If no server name is requested, store the description only
    if (dwFlags & SHGCDN_NOSERVERNAME)
    {
        StringCchCopyW(pszName, cchNameMax, szDesc);
        return S_OK;
    }
 
    // Build a string like "Description (SERVERNAME)"
    return SHELL_BuildDisplayMachineName(pszName, cchNameMax, pszServerName, szDesc);
}

SHGetNameAndFlagsW()

HRESULT SHGetNameAndFlagsW	(	_In_ LPCITEMIDLIST	pidl,
		_In_ DWORD	dwFlags,
		_Out_opt_ LPWSTR	pszText,
		_In_ UINT	cchBuf,
		_Inout_opt_ DWORD *	pdwAttributes
	)

Definition at line 551 of file utils.cpp.

{
    if (pszText)
        *pszText = UNICODE_NULL;
 
    HRESULT hrCoInit = SHCoInitializeAnyApartment();
 
    CComPtr<IShellFolder> psfFolder;
    LPCITEMIDLIST ppidlLast;
    HRESULT hr = SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &psfFolder), &ppidlLast);
    if (SUCCEEDED(hr))
    {
        if (pszText)
            hr = DisplayNameOfW(psfFolder, ppidlLast, dwFlags, pszText, cchBuf);
 
        if (SUCCEEDED(hr))
        {
            if (pdwAttributes)
                *pdwAttributes = SHGetAttributes(psfFolder, ppidlLast, *pdwAttributes);
        }
    }
 
    if (SUCCEEDED(hrCoInit))
        CoUninitialize();
 
    return hr;
}

Referenced by CDrvDefExt::AddMainPage(), DoGetFileTitle(), CShellLink::OnInitDialog(), SHELL_execute(), SHELL_GetCaptionFromDataObject(), and CDesktopFolder::ShellUrlParseDisplayName().

SHGetPathCchFromIDListW()

EXTERN_C HRESULT WINAPI SHGetPathCchFromIDListW	(	LPCITEMIDLIST	pidl,
		LPWSTR	pszPath,
		SIZE_T	cchPathMax
	)

Referenced by DynamicSHGetPathFromIDListW().

SHGetRealIDL()

EXTERN_C HRESULT WINAPI SHGetRealIDL	(	_In_ IShellFolder *	psf,
		_In_ PCUITEMID_CHILD	pidlSimple,
		_Outptr_ PITEMID_CHILD *	ppidlReal
	)

Definition at line 1749 of file utils.cpp.

{
    HRESULT hr;
    STRRET strret;
    WCHAR szPath[MAX_PATH];
    SFGAOF attrs;
 
    *ppidlReal = NULL;
 
    hr = IShellFolder_GetDisplayNameOf(psf, pidlSimple, SHGDN_INFOLDER | SHGDN_FORPARSING,
                                       &strret, 0);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    hr = StrRetToBufW(&strret, pidlSimple, szPath, _countof(szPath));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    attrs = SFGAO_FILESYSTEM;
    hr = psf->GetAttributesOf(1, &pidlSimple, &attrs);
    if (SUCCEEDED(hr) && !(attrs & SFGAO_FILESYSTEM))
        return SHILClone(pidlSimple, ppidlReal);
 
    hr = IShellFolder_ParseDisplayName(psf, NULL, NULL, szPath, NULL, ppidlReal, NULL);
    if (hr == E_INVALIDARG || hr == E_NOTIMPL)
        return SHILClone(pidlSimple, ppidlReal);
 
    return hr;
}

Referenced by CDefView::OnChangeNotify().

SHGetShellStyleHInstance()

EXTERN_C HINSTANCE WINAPI SHGetShellStyleHInstance

(

VOID

)

Definition at line 967 of file utils.cpp.

{
    HINSTANCE hInst = NULL;
    WCHAR szPath[MAX_PATH], szColorName[100];
    HRESULT hr;
    CStringW strShellStyle;
 
    TRACE("SHGetShellStyleHInstance called\n");
 
    /* First, attempt to load the shellstyle dll from the current active theme */
    hr = GetCurrentThemeName(szPath, _countof(szPath), szColorName, _countof(szColorName), NULL, 0);
    if (FAILED(hr))
        goto DoDefault;
 
    /* Strip the theme filename */
    PathRemoveFileSpecW(szPath);
 
    strShellStyle = szPath;
    strShellStyle += L"\\Shell\\";
    strShellStyle += szColorName;
    strShellStyle += L"\\ShellStyle.dll";
 
    hInst = LoadLibraryExW(strShellStyle, NULL, LOAD_LIBRARY_AS_DATAFILE);
    if (hInst)
        return hInst;
 
    /* Otherwise, use the version stored in the System32 directory */
DoDefault:
    if (!ExpandEnvironmentStringsW(L"%SystemRoot%\\System32\\ShellStyle.dll",
                                   szPath, _countof(szPath)))
    {
        ERR("Expand failed\n");
        return NULL;
    }
    return LoadLibraryExW(szPath, NULL, LOAD_LIBRARY_AS_DATAFILE);
}

SHGetUnreadMailCountW()

EXTERN_C HRESULT WINAPI SHGetUnreadMailCountW	(	_In_opt_ HKEY	hKeyUser,
		_In_opt_ PCWSTR	pszMailAddress,
		_Out_opt_ PDWORD	pdwCount,
		_Inout_opt_ PFILETIME	pFileTime,
		_Out_writes_opt_(cchShellExecuteCommand) PWSTR	pszShellExecuteCommand,
		_In_ INT	cchShellExecuteCommand
	)

Definition at line 1060 of file utils.cpp.

{
    LSTATUS error;
    HKEY hKey;
 
    if (!hKeyUser)
        hKeyUser = HKEY_CURRENT_USER;
 
    if (pszMailAddress)
    {
        CStringW strKey = L"Software\\Microsoft\\Windows\\CurrentVersion\\UnreadMail";
        strKey += L'\\';
        strKey += pszMailAddress;
 
        error = RegOpenKeyExW(hKeyUser, strKey, 0, KEY_QUERY_VALUE, &hKey);
        if (error)
            return HRESULT_FROM_WIN32(error);
 
        error = SHELL_ReadSingleUnreadMailCount(hKey, pdwCount, pFileTime,
                                                pszShellExecuteCommand, cchShellExecuteCommand);
    }
    else
    {
        if (pszShellExecuteCommand || cchShellExecuteCommand)
            return E_INVALIDARG;
 
        *pdwCount = 0;
 
        error = RegOpenKeyExW(hKeyUser, L"Software\\Microsoft\\Windows\\CurrentVersion\\UnreadMail",
                              0, KEY_ENUMERATE_SUB_KEYS, &hKey);
        if (error)
            return HRESULT_FROM_WIN32(error);
 
        for (DWORD dwIndex = 0; !error; ++dwIndex)
        {
            WCHAR Name[2 * MAX_PATH];
            DWORD cchName = _countof(Name);
            FILETIME LastWritten;
            error = RegEnumKeyExW(hKey, dwIndex, Name, &cchName, NULL, NULL, NULL, &LastWritten);
            if (error)
                break;
 
            HKEY hSubKey;
            error = RegOpenKeyExW(hKey, Name, 0, KEY_QUERY_VALUE, &hSubKey);
            if (error)
                break;
 
            FILETIME FileTime;
            DWORD dwCount;
            error = SHELL_ReadSingleUnreadMailCount(hSubKey, &dwCount, &FileTime, NULL, 0);
            if (!error && (!pFileTime || CompareFileTime(&FileTime, pFileTime) >= 0))
                *pdwCount += dwCount;
 
            RegCloseKey(hSubKey);
        }
 
        if (error == ERROR_NO_MORE_ITEMS)
            error = ERROR_SUCCESS;
    }
 
    RegCloseKey(hKey);
 
    return error ? HRESULT_FROM_WIN32(error) : S_OK;
}

Referenced by START_TEST().

SHGetUserDisplayName()

EXTERN_C HRESULT WINAPI SHGetUserDisplayName	(	_Out_writes_to_ *, *puSize PWSTR	pName,
		_Inout_ PULONG	puSize
	)

Definition at line 2001 of file utils.cpp.

{
    if (!pName || !puSize)
        return E_INVALIDARG;
 
    if (GetUserNameExW(NameDisplay, pName, puSize))
        return S_OK;
 
    LONG error = GetLastError(); // for ERROR_NONE_MAPPED
    HRESULT hr = HRESULT_FROM_WIN32(error);
 
    WCHAR UserName[MAX_PATH];
    DWORD cchUserName = _countof(UserName);
    if (!GetUserNameW(UserName, &cchUserName))
        return HRESULT_FROM_WIN32(GetLastError());
 
    // Was the user name not available in the specified format (NameDisplay)?
    if (error == ERROR_NONE_MAPPED)
    {
        // Try to get the user name by using Network API
        PUSER_INFO_2 UserInfo;
        DWORD NetError = NetUserGetInfo(NULL, UserName, 2, (PBYTE*)&UserInfo);
        if (NetError)
        {
            hr = HRESULT_FROM_WIN32(NetError);
        }
        else
        {
            if (UserInfo->usri2_full_name)
            {
                hr = StringCchCopyW(pName, *puSize, UserInfo->usri2_full_name);
                if (SUCCEEDED(hr))
                {
                    // Include the NUL-terminator
                    *puSize = lstrlenW(UserInfo->usri2_full_name) + 1;
                }
            }
 
            NetApiBufferFree(UserInfo);
        }
    }
 
    if (FAILED(hr))
    {
        hr = StringCchCopyW(pName, *puSize, UserName);
        if (SUCCEEDED(hr))
            *puSize = cchUserName;
    }
 
    return hr;
}

Referenced by START_TEST().

SHGetUserSessionId()

EXTERN_C DWORD WINAPI SHGetUserSessionId

(

_In_opt_ HANDLE

hToken

)

Definition at line 822 of file utils.cpp.

{
    DWORD dwSessionId, dwLength;
    BOOL bOpenToken = FALSE;
 
    TRACE("%p\n", hToken);
 
    if (!hToken)
        bOpenToken = SHOpenEffectiveToken(&hToken);
 
    if (!hToken ||
        !GetTokenInformation(hToken, TokenSessionId, &dwSessionId, sizeof(dwSessionId), &dwLength))
    {
        dwSessionId = 0;
    }
 
    if (bOpenToken)
        CloseHandle(hToken);
 
    return dwSessionId;
}

SHILAppend()

HRESULT SHILAppend	(	_Inout_ LPITEMIDLIST	pidl,
		_Inout_ LPITEMIDLIST *	ppidl
	)

Definition at line 261 of file utils.cpp.

{
    LPITEMIDLIST pidlOld = *ppidl;
    if (!pidlOld)
    {
        *ppidl = pidl;
        return S_OK;
    }
 
    HRESULT hr = SHILCombine(*ppidl, pidl, ppidl);
    ILFree(pidlOld);
    ILFree(pidl);
    return hr;
}

Referenced by CFSFolder::_ParseSimple(), BrFolder_Treeview_Rename(), CFSFolder::ParseDisplayName(), and CFolderItem::put_Name().

SHInvokePrivilegedFunctionW()

EXTERN_C HRESULT WINAPI SHInvokePrivilegedFunctionW	(	_In_ LPCWSTR	pszName,
		_In_ PRIVILEGED_FUNCTION	fn,
		_In_opt_ LPARAM	lParam
	)

Definition at line 849 of file utils.cpp.

{
    TRACE("(%s %p %p)\n", debugstr_w(pszName), fn, lParam);
 
    if (!pszName || !fn)
        return E_INVALIDARG;
 
    HANDLE hToken = NULL;
    TOKEN_PRIVILEGES NewPriv, PrevPriv;
    BOOL bAdjusted = FALSE;
 
    if (SHOpenEffectiveToken(&hToken) &&
        ::LookupPrivilegeValueW(NULL, pszName, &NewPriv.Privileges[0].Luid))
    {
        NewPriv.PrivilegeCount = 1;
        NewPriv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 
        DWORD dwReturnSize;
        bAdjusted = ::AdjustTokenPrivileges(hToken, FALSE, &NewPriv,
                                            sizeof(PrevPriv), &PrevPriv, &dwReturnSize);
    }
 
    HRESULT hr = fn(lParam);
 
    if (bAdjusted)
        ::AdjustTokenPrivileges(hToken, FALSE, &PrevPriv, 0, NULL, NULL);
 
    if (hToken)
        ::CloseHandle(hToken);
 
    return hr;
}

SHIsBadInterfacePtr()

EXTERN_C BOOL WINAPI SHIsBadInterfacePtr	(	_In_ LPCVOID	pv,
		_In_ UINT_PTR	ucb
	)

Definition at line 1977 of file utils.cpp.

{
    struct CUnknownVtbl
    {
        HRESULT (STDMETHODCALLTYPE *QueryInterface)(REFIID riid, LPVOID *ppvObj);
        ULONG (STDMETHODCALLTYPE *AddRef)();
        ULONG (STDMETHODCALLTYPE *Release)();
    };
    struct CUnknown { CUnknownVtbl *lpVtbl; };
    const CUnknown *punk = reinterpret_cast<const CUnknown *>(pv);
    return !punk || IsBadReadPtr(punk, sizeof(punk->lpVtbl)) ||
           IsBadReadPtr(punk->lpVtbl, ucb) ||
           IsBadCodePtr((FARPROC)punk->lpVtbl->Release);
}

Referenced by START_TEST().

SHIsFileSysBindCtx()

HRESULT SHIsFileSysBindCtx	(	_In_ IBindCtx *	pBindCtx,
		_Out_opt_ WIN32_FIND_DATAW *	pFindData
	)

Definition at line 361 of file utils.cpp.

{
    CComPtr<IUnknown> punk;
    CComPtr<IFileSystemBindData> pBindData;
 
    if (!pBindCtx || FAILED(pBindCtx->GetObjectParam((LPWSTR)STR_FILE_SYS_BIND_DATA, &punk)))
        return S_FALSE;
 
    if (FAILED(punk->QueryInterface(IID_PPV_ARG(IFileSystemBindData, &pBindData))))
        return S_FALSE;
 
    if (pFindData)
        pBindData->GetFindData(pFindData);
 
    return S_OK;
}

Referenced by CDesktopFolder::ParseDisplayName(), CDrivesFolder::ParseDisplayName(), and CFSFolder::ParseDisplayName().

SHLoadPopupMenu()

static HMENU SHLoadPopupMenu ( HINSTANCE  hInstance, UINT  uMenuId  )

static

Definition at line 61 of file utils.cpp.

{
    HMENU hMenu = LoadMenuW(hInstance, MAKEINTRESOURCEW(uMenuId));
    if (!hMenu)
        return NULL;
    HMENU hSubMenu = GetSubMenu(hMenu, 0);
    RemoveMenu(hMenu, 0, MF_BYPOSITION);
    DestroyMenu(hMenu);
    return hSubMenu;
}

Referenced by CDefFolderMenu_MergeMenu().

SHOpenEffectiveToken()

EXTERN_C BOOL WINAPI SHOpenEffectiveToken

(

_Out_ LPHANDLE

phToken

)

Definition at line 813 of file utils.cpp.

{
    TRACE("%p\n", phToken);
    return OpenEffectiveToken(TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, phToken);
}

Referenced by SHGetUserSessionId(), SHInvokePrivilegedFunctionW(), and SHTestTokenPrivilegeW().

ShortSizeFormatW()

EXTERN_C LPWSTR WINAPI ShortSizeFormatW	(	_In_ DWORD	dwNumber,
		_Out_writes_(0x8FFF) LPWSTR	pszBuffer
	)

Definition at line 802 of file utils.cpp.

{
    TRACE("(%lu, %p)\n", dwNumber, pszBuffer);
    return StrFormatByteSizeW(dwNumber, pszBuffer, 0x8FFF);
}

SHSetFolderPathA()

EXTERN_C HRESULT WINAPI SHSetFolderPathA	(	_In_ INT	csidl,
		_In_ HANDLE	hToken,
		_In_ DWORD	dwFlags,
		_In_ LPCSTR	pszPath
	)

Definition at line 691 of file utils.cpp.

{
    TRACE("(%d, %p, 0x%X, %s)\n", csidl, hToken, dwFlags, debugstr_a(pszPath));
    CStringW strPathW(pszPath);
    return SHSetFolderPathW(csidl, hToken, dwFlags, strPathW);
}

SHSetLocalizedName()

EXTERN_C HRESULT WINAPI SHSetLocalizedName	(	_In_ PCWSTR	pszPath,
		_In_ PCWSTR	pszResModule,
		_In_ INT	idsRes
	)

Definition at line 2306 of file utils.cpp.

{
    HRESULT hr;
    IShellFolder *pDesktop = NULL, *pParent = NULL;
    LPITEMIDLIST pidl = NULL;
    LPCITEMIDLIST pidlLast;
    HANDLE hProcessHeap;
    INT cchShortMax, cchShort, cchName;
    PWSTR pszShortPath = NULL, pszName = NULL;
 
    hr = SHCoInitializeAnyApartment();
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    hr = SHGetDesktopFolder(&pDesktop);
    if (FAILED_UNEXPECTEDLY(hr))
        goto Cleanup;
 
    hr = pDesktop->ParseDisplayName(NULL, NULL, (PWSTR)pszPath, NULL, &pidl, NULL);
    if (FAILED_UNEXPECTEDLY(hr))
        goto Cleanup;
 
    hr = SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &pParent), &pidlLast);
    if (FAILED_UNEXPECTEDLY(hr))
        goto Cleanup;
 
    hProcessHeap = GetProcessHeap();
    cchShortMax = lstrlenW(pszResModule) + 1;
    pszShortPath = (PWSTR)HeapAlloc(hProcessHeap, 0, cchShortMax * sizeof(WCHAR));
    if (!pszShortPath)
    {
        hr = E_OUTOFMEMORY;
        goto Cleanup;
    }
 
    cchShort = GetShortPathNameW(pszResModule, pszShortPath, cchShortMax);
    if (cchShort)
        pszResModule = pszShortPath;
    else
        cchShort = cchShortMax;
 
    /* 14 == '@' + ',' + '-' + (digits of max width 10) + NUL */
    cchName = cchShort + 14;
    pszName = (PWSTR)HeapAlloc(hProcessHeap, 0, cchName * sizeof(WCHAR));
    if (!pszName)
    {
        hr = E_OUTOFMEMORY;
        goto Cleanup;
    }
 
    wnsprintfW(pszName, cchName, L"@%s,%d", pszResModule, -idsRes);
    hr = pParent->SetNameOf(NULL, pidlLast, pszName, 0, NULL);
 
Cleanup:
    if (pszName)
        HeapFree(hProcessHeap, 0, pszName);
    if (pszShortPath)
        HeapFree(hProcessHeap, 0, pszShortPath);
    if (pParent)
        pParent->Release();
    if (pidl)
        SHFree(pidl);
    if (pDesktop)
        pDesktop->Release();
    CoUninitialize();
    return hr;
}

SHSetUnreadMailCountW()

EXTERN_C HRESULT WINAPI SHSetUnreadMailCountW	(	_In_ PCWSTR	pszMailAddress,
		_In_ DWORD	dwCount,
		_In_ PCWSTR	pszShellExecuteCommand
	)

Definition at line 1138 of file utils.cpp.

{
    CString strKey = L"Software\\Microsoft\\Windows\\CurrentVersion\\UnreadMail\\";
    strKey += pszMailAddress;
 
    HKEY hKey;
    DWORD dwDisposition;
    LSTATUS error = RegCreateKeyExW(HKEY_CURRENT_USER, strKey, 0, NULL, 0, KEY_SET_VALUE, NULL,
                                    &hKey, &dwDisposition);
    if (error)
        return HRESULT_FROM_WIN32(error);
 
    error = RegSetValueExW(hKey, L"MessageCount", 0, REG_DWORD, (PBYTE)&dwCount, sizeof(dwCount));
    if (error)
    {
        RegCloseKey(hKey);
        return HRESULT_FROM_WIN32(error);
    }
 
    FILETIME FileTime;
    GetSystemTimeAsFileTime(&FileTime);
 
    error = RegSetValueExW(hKey, L"TimeStamp", 0, REG_BINARY, (PBYTE)&FileTime, sizeof(FileTime));
    if (error)
    {
        RegCloseKey(hKey);
        return HRESULT_FROM_WIN32(error);
    }
 
    WCHAR szBuff[2 * MAX_PATH];
    if (!PathUnExpandEnvStringsW(pszShellExecuteCommand, szBuff, _countof(szBuff)))
    {
        HRESULT hr = StringCchCopyW(szBuff, _countof(szBuff), pszShellExecuteCommand);
        if (FAILED_UNEXPECTEDLY(hr))
        {
            RegCloseKey(hKey);
            return hr;
        }
    }
 
    DWORD cbValue = (lstrlenW(szBuff) + 1) * sizeof(WCHAR);
    error = RegSetValueExW(hKey, L"Application", 0, REG_SZ, (PBYTE)szBuff, cbValue);
 
    RegCloseKey(hKey);
    return (error ? HRESULT_FROM_WIN32(error) : S_OK);
}

Referenced by START_TEST().

SHShouldShowWizards()

EXTERN_C HRESULT WINAPI SHShouldShowWizards

(

_In_ IUnknown *

pUnknown

)

Definition at line 284 of file utils.cpp.

{
    HRESULT hr;
    IShellBrowser *pBrowser;
 
    hr = IUnknown_QueryService(pUnknown, SID_STopWindow, IID_PPV_ARG(IShellBrowser, &pBrowser));
    if (FAILED(hr))
        return hr;
 
    SHELLSTATE state;
    SHGetSetSettings(&state, SSF_WEBVIEW, FALSE);
    if (state.fWebView &&
        !SHRegGetBoolUSValueW(L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
                              L"ShowWizardsTEST", FALSE, FALSE))
    {
        hr = S_FALSE;
    }
 
    pBrowser->Release();
    return hr;
}

Referenced by START_TEST().

SHSkipJunctionBinding()

BOOL SHSkipJunctionBinding	(	_In_ IBindCtx *	pbc,
		_In_ CLSID *	pclsid
	)

Definition at line 349 of file utils.cpp.

{
    if (!pbc)
        return FALSE;
 
    BIND_OPTS BindOps = { sizeof(BindOps) };
    if (SUCCEEDED(pbc->GetBindOptions(&BindOps)) && BindOps.grfFlags == OLECONTF_LINKS)
        return TRUE;
 
    return pclsid && SHSkipJunction(pbc, pclsid);
}

Referenced by CDesktopFolder::_ParseDisplayNameByParent().

SHStartNetConnectionDialogA()

EXTERN_C HRESULT WINAPI SHStartNetConnectionDialogA	(	_In_ HWND	hwnd,
		_In_ LPCSTR	pszRemoteName,
		_In_ DWORD	dwType
	)

Definition at line 1609 of file utils.cpp.

{
    LPCWSTR pszRemoteNameW = NULL;
    CStringW strRemoteNameW;
 
    TRACE("(%p, %s, %lu)\n", hwnd, debugstr_a(pszRemoteName), dwType);
 
    if (pszRemoteName)
    {
        strRemoteNameW = pszRemoteName;
        pszRemoteNameW = strRemoteNameW;
    }
 
    return SHStartNetConnectionDialogW(hwnd, pszRemoteNameW, dwType);
}

Referenced by SHStartNetConnectionDialog().

SHTestTokenPrivilegeW()

EXTERN_C BOOL WINAPI SHTestTokenPrivilegeW	(	_In_opt_ HANDLE	hToken,
		_In_ LPCWSTR	lpName
	)

Definition at line 892 of file utils.cpp.

{
    LUID Luid;
    DWORD dwLength;
    PTOKEN_PRIVILEGES pTokenPriv;
    HANDLE hNewToken = NULL;
    BOOL ret = FALSE;
 
    TRACE("(%p, %s)\n", hToken, debugstr_w(lpName));
 
    if (!lpName)
        return FALSE;
 
    if (!hToken)
    {
        if (!SHOpenEffectiveToken(&hNewToken))
            goto Quit;
 
        if (!hNewToken)
            return FALSE;
 
        hToken = hNewToken;
    }
 
    if (!LookupPrivilegeValueW(NULL, lpName, &Luid))
        return FALSE;
 
    dwLength = 0;
    if (!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwLength))
        goto Quit;
 
    pTokenPriv = (PTOKEN_PRIVILEGES)LocalAlloc(LPTR, dwLength);
    if (!pTokenPriv)
        goto Quit;
 
    if (GetTokenInformation(hToken, TokenPrivileges, pTokenPriv, dwLength, &dwLength))
    {
        UINT iPriv, cPrivs;
        cPrivs = pTokenPriv->PrivilegeCount;
        for (iPriv = 0; !ret && iPriv < cPrivs; ++iPriv)
        {
            ret = RtlEqualLuid(&Luid, &pTokenPriv->Privileges[iPriv].Luid);
        }
    }
 
    LocalFree(pTokenPriv);
 
Quit:
    if (hToken == hNewToken)
        CloseHandle(hNewToken);
 
    return ret;
}

Referenced by IsShutdownAllowed(), and CStartMenuSite::ShowUndockMenuItem().

StrEndNA()

static PCSTR StrEndNA ( _In_ PCSTR  psz, _In_ INT_PTR  cch  )

static

Definition at line 17 of file utils.cpp.

{
    PCSTR pch, pchEnd = &psz[cch];
    for (pch = psz; *pch && pch < pchEnd; pch = CharNextA(pch))
        ;
    if (pchEnd < pch) // A double-byte character detected at last?
        pch -= 2; // The width of a double-byte character is 2
    return pch;
}

Referenced by StrRStrA().

StrEndNW()

static PCWSTR StrEndNW ( _In_ PCWSTR  psz, _In_ INT_PTR  cch  )

static

Definition at line 27 of file utils.cpp.

{
    PCWSTR pch, pchEnd = &psz[cch];
    for (pch = psz; *pch && pch < pchEnd; ++pch)
        ;
    return pch;
}

Referenced by StrRStrW().

StrRStrA()

EXTERN_C PSTR WINAPI StrRStrA	(	_In_ PCSTR	pszSrc,
		_In_opt_ PCSTR	pszLast,
		_In_ PCSTR	pszSearch
	)

Definition at line 122 of file utils.cpp.

{
    INT cchSearch = lstrlenA(pszSearch);
 
    PCSTR pchEnd = pszLast ? pszLast : &pszSrc[lstrlenA(pszSrc)];
    if (pchEnd == pszSrc)
        return NULL;
 
    INT_PTR cchEnd = pchEnd - pszSrc;
    for (;;)
    {
        --pchEnd;
        --cchEnd;
        if (!pchEnd)
            break;
        if (!StrCmpNA(pchEnd, pszSearch, cchSearch) && pchEnd == StrEndNA(pszSrc, cchEnd))
            break;
        if (pchEnd == pszSrc)
            return NULL;
    }
 
    return const_cast<PSTR>(pchEnd);
}

Referenced by TEST_StrRStrA().

StrRStrW()

EXTERN_C PWSTR WINAPI StrRStrW	(	_In_ PCWSTR	pszSrc,
		_In_opt_ PCWSTR	pszLast,
		_In_ PCWSTR	pszSearch
	)

Definition at line 154 of file utils.cpp.

{
    INT cchSearch = lstrlenW(pszSearch);
 
    PCWSTR pchEnd = pszLast ? pszLast : &pszSrc[lstrlenW(pszSrc)];
    if (pchEnd == pszSrc)
        return NULL;
 
    INT_PTR cchEnd = pchEnd - pszSrc;
    for (;;)
    {
        --pchEnd;
        --cchEnd;
        if (!pchEnd)
            break;
        if (!StrCmpNW(pchEnd, pszSearch, cchSearch) && pchEnd == StrEndNW(pszSrc, cchEnd))
            break;
        if (pchEnd == pszSrc)
            return NULL;
    }
 
    return const_cast<PWSTR>(pchEnd);
}

Referenced by TEST_StrRStrW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

Variable Documentation

g_AliasTable

const ALIAS_MAPPING g_AliasTable[]

static

Initial value:

=
{
    {
        ALIAS_USER_FOLDER,
        FALSE,
        CSIDL_PERSONAL | CSIDL_FLAG_NO_ALIAS,
        CSIDL_PERSONAL
    },
    {
        ALIAS_USER_FOLDER | ALIAS_DESKTOP,
        FALSE,
        CSIDL_COMMON_DOCUMENTS | CSIDL_FLAG_NO_ALIAS,
        CSIDL_COMMON_DOCUMENTS
    },
    {
        ALIAS_DESKTOP,
        FALSE,
        CSIDL_DESKTOPDIRECTORY,
        CSIDL_DESKTOP
    },
    {
        ALIAS_DESKTOP,
        TRUE,
        CSIDL_COMMON_DESKTOPDIRECTORY,
        CSIDL_DESKTOP
    }
}

PIDL alias table.

Definition at line 2210 of file utils.cpp.

Referenced by SHELL32_ReparentAsAliasPidl().