CShellLink.cpp File Reference

#include "precomp.h"
#include <appmgmt.h>
#include "pshpack1.h"
#include "poppack.h"

Include dependency graph for CShellLink.cpp:

Go to the source code of this file.

Classes
struct	LOCATION_INFO
struct	LOCAL_VOLUME_INFO
struct	volume_info

Macros
#define	ICON_LINK_WINDOWS_COMPAT
#define	SHLINK_LOCAL   0
#define	SHLINK_REMOTE   1

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
static HRESULT	ShellLink_UpdatePath (LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR *psPath)
static LPWSTR __inline	HEAP_strdupAtoW (HANDLE heap, DWORD flags, LPCSTR str)
static LPWSTR __inline	strdupW (LPCWSTR src)
static BOOL	PathEnvSubstIsDirectory (LPCWSTR pszPath)
static HRESULT	Stream_LoadString (IStream *stm, BOOL unicode, LPWSTR *pstr)
static BOOL	ShellLink_GetVolumeInfo (LPCWSTR path, CShellLink::volume_info *volume)
static HRESULT	Stream_ReadChunk (IStream *stm, LPVOID *data)
static BOOL	Stream_LoadVolume (LOCAL_VOLUME_INFO *vol, CShellLink::volume_info *volume)
static LPWSTR	Stream_LoadPath (LPCSTR p, DWORD maxlen)
static HRESULT	Stream_LoadLocation (IStream *stm, CShellLink::volume_info *volume, LPWSTR *path)
static HRESULT	Stream_WriteString (IStream *stm, LPCWSTR str)
static HRESULT	Stream_WriteLocationInfo (IStream *stm, LPCWSTR path, CShellLink::volume_info *volume)
static BOOL	SHELL_ExistsFileW (LPCWSTR path)
static LPWSTR	shelllink_get_msi_component_path (LPWSTR component)
static HRESULT	SHELL_PidlGetIconLocationW (PCIDLIST_ABSOLUTE pidl, UINT uFlags, PWSTR pszIconFile, UINT cchMax, int *piIndex, UINT *pwFlags)
static LPWSTR	GetAdvertisedArg (LPCWSTR str)
INT_PTR CALLBACK	ExtendedShortcutProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static void	GetTypeDescriptionByPath (PCWSTR pszFullPath, DWORD fAttributes, PWSTR szBuf, UINT cchBuf)
HRESULT WINAPI	IShellLink_ConstructFromPath (WCHAR *path, REFIID riid, LPVOID *ppv)
HRESULT WINAPI	IShellLink_ConstructFromFile (IShellFolder *psf, LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv)

Macro Definition Documentation

ICON_LINK_WINDOWS_COMPAT

#define ICON_LINK_WINDOWS_COMPAT

Definition at line 152 of file CShellLink.cpp.

SHLINK_LOCAL

#define SHLINK_LOCAL   0

Definition at line 154 of file CShellLink.cpp.

SHLINK_REMOTE

#define SHLINK_REMOTE   1

Definition at line 155 of file CShellLink.cpp.

Function Documentation

ExtendedShortcutProc()

INT_PTR CALLBACK ExtendedShortcutProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 2707 of file CShellLink.cpp.

{
    switch(uMsg)
    {
        case WM_INITDIALOG:
            if (lParam)
            {
                HWND hDlgCtrl = GetDlgItem(hwndDlg, IDC_SHORTEX_RUN_DIFFERENT);
                SendMessage(hDlgCtrl, BM_SETCHECK, BST_CHECKED, 0);
            }
            return TRUE;
        case WM_COMMAND:
        {
            HWND hDlgCtrl = GetDlgItem(hwndDlg, IDC_SHORTEX_RUN_DIFFERENT);
            if (LOWORD(wParam) == IDOK)
            {
                if (SendMessage(hDlgCtrl, BM_GETCHECK, 0, 0) == BST_CHECKED)
                    EndDialog(hwndDlg, 1);
                else
                    EndDialog(hwndDlg, 0);
            }
            else if (LOWORD(wParam) == IDCANCEL)
            {
                EndDialog(hwndDlg, -1);
            }
            else if (LOWORD(wParam) == IDC_SHORTEX_RUN_DIFFERENT)
            {
                if (SendMessage(hDlgCtrl, BM_GETCHECK, 0, 0) == BST_CHECKED)
                    SendMessage(hDlgCtrl, BM_SETCHECK, BST_UNCHECKED, 0);
                else
                    SendMessage(hDlgCtrl, BM_SETCHECK, BST_CHECKED, 0);
            }
        }
    }
    return FALSE;
}

Referenced by CShellLink::OnCommand().

GetAdvertisedArg()

static LPWSTR GetAdvertisedArg ( LPCWSTR  str )

static

Definition at line 2061 of file CShellLink.cpp.

{
    if (!str)
        return NULL;
 
    LPCWSTR p = wcschr(str, L':');
    if (!p)
        return NULL;
 
    DWORD len = p - str;
    LPWSTR ret = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (len + 1));
    if (!ret)
        return ret;
 
    memcpy(ret, str, sizeof(WCHAR)*len);
    ret[len] = 0;
    return ret;
}

Referenced by CShellLink::SetAdvertiseInfo().

GetTypeDescriptionByPath()

static void GetTypeDescriptionByPath ( PCWSTR  pszFullPath, DWORD  fAttributes, PWSTR  szBuf, UINT  cchBuf  )

static

Definition at line 2745 of file CShellLink.cpp.

{
    if (fAttributes == INVALID_FILE_ATTRIBUTES && !PathFileExistsAndAttributesW(pszFullPath, &fAttributes))
        fAttributes = 0;
 
    SHFILEINFOW fi;
    if (!SHGetFileInfoW(pszFullPath, fAttributes, &fi, sizeof(fi), SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES))
    {
        ERR("SHGetFileInfoW failed for %ls (%lu)\n", pszFullPath, GetLastError());
        fi.szTypeName[0] = UNICODE_NULL;
    }
 
    BOOL fFolder = (fAttributes & FILE_ATTRIBUTE_DIRECTORY);
    LPCWSTR pwszExt = fFolder ? L"" : PathFindExtensionW(pszFullPath);
    if (pwszExt[0])
    {
        if (!fi.szTypeName[0])
            StringCchPrintfW(szBuf, cchBuf, L"%s", pwszExt + 1);
        else
            StringCchPrintfW(szBuf, cchBuf, L"%s (%s)", fi.szTypeName, pwszExt);
    }
    else
    {
        StringCchPrintfW(szBuf, cchBuf, L"%s", fi.szTypeName);
    }
}

Referenced by CShellLink::OnInitDialog().

HEAP_strdupAtoW()

static LPWSTR __inline HEAP_strdupAtoW ( HANDLE  heap, DWORD  flags, LPCSTR  str  )

static

Definition at line 194 of file CShellLink.cpp.

{
    INT len;
    LPWSTR p;
 
    assert(str);
 
    len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
    p = (LPWSTR)HeapAlloc(heap, flags, len * sizeof(WCHAR));
    if (!p)
        return p;
    MultiByteToWideChar(CP_ACP, 0, str, -1, p, len);
    return p;
}

Referenced by CShellLink::Extract(), CShellLink::SetArguments(), CShellLink::SetDescription(), CShellLink::SetIconLocation(), CShellLink::SetPath(), CShellLink::SetRelativePath(), and CShellLink::SetWorkingDirectory().

IShellLink_ConstructFromFile()

HRESULT WINAPI IShellLink_ConstructFromFile	(	IShellFolder *	psf,
		LPCITEMIDLIST	pidl,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 3245 of file CShellLink.cpp.

{
    WCHAR path[MAX_PATH];
    if (!ILGetDisplayNameExW(psf, pidl, path, 0))
        return E_FAIL;
 
    return IShellLink_ConstructFromPath(path, riid, ppv);
}

IShellLink_ConstructFromPath()

HRESULT WINAPI IShellLink_ConstructFromPath	(	WCHAR *	path,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 3231 of file CShellLink.cpp.

{
    CComPtr<IPersistFile> ppf;
    HRESULT hr = CShellLink::_CreatorClass::CreateInstance(NULL, IID_PPV_ARG(IPersistFile, &ppf));
    if (FAILED(hr))
        return hr;
 
    hr = ppf->Load(path, 0);
    if (FAILED(hr))
        return hr;
 
    return ppf->QueryInterface(riid, ppv);
}

Referenced by CFSDropTarget::_DoDrop(), IShellLink_ConstructFromFile(), and SHAddToRecentDocs().

PathEnvSubstIsDirectory()

static BOOL PathEnvSubstIsDirectory ( LPCWSTR  pszPath )

static

Definition at line 219 of file CShellLink.cpp.

{
    // Note: Don't call SHExpandEnvironmentStringsW here, we need the required length
    WCHAR szStack[MAX_PATH];
    DWORD cch = ExpandEnvironmentStringsW(pszPath, szStack, _countof(szStack));
    if (cch <= _countof(szStack))
        return cch && PathIsDirectory(szStack);
 
    PWSTR szHeap = (PWSTR)SHAlloc(cch);
    if (!szHeap)
        return FALSE;
    BOOL bResult = ExpandEnvironmentStringsW(pszPath, szHeap, cch) && PathIsDirectory(szHeap);
    SHFree(szHeap);
    return bResult;
}

Referenced by CShellLink::DoOpen().

SHELL_ExistsFileW()

static BOOL SHELL_ExistsFileW ( LPCWSTR  path )

static

Definition at line 1056 of file CShellLink.cpp.

{
    if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(path))
        return FALSE;
 
    return TRUE;
}

Referenced by ShellLink_UpdatePath().

SHELL_PidlGetIconLocationW()

static HRESULT SHELL_PidlGetIconLocationW ( PCIDLIST_ABSOLUTE  pidl, UINT  uFlags, PWSTR  pszIconFile, UINT  cchMax, int *  piIndex, UINT *  pwFlags  )

static

Definition at line 1746 of file CShellLink.cpp.

{
    CComPtr<IExtractIconW> pei;
    HRESULT hr = SHELL_GetUIObjectOfAbsoluteItem(NULL, pidl, IID_PPV_ARG(IExtractIconW, &pei));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
    hr = pei->GetIconLocation(uFlags, pszIconFile, cchMax, piIndex, pwFlags);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return S_OK;
}

Referenced by CShellLink::GetIconLocation().

shelllink_get_msi_component_path()

static LPWSTR shelllink_get_msi_component_path ( LPWSTR  component )

static

Definition at line 1424 of file CShellLink.cpp.

{
    DWORD Result, sz = 0;
 
    Result = CommandLineFromMsiDescriptor(component, NULL, &sz);
    if (Result != ERROR_SUCCESS)
        return NULL;
 
    sz++;
    LPWSTR path = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR));
    Result = CommandLineFromMsiDescriptor(component, path, &sz);
    if (Result != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, path);
        path = NULL;
    }
 
    TRACE("returning %s\n", debugstr_w(path));
 
    return path;
}

Referenced by CShellLink::Resolve().

ShellLink_GetVolumeInfo()

static BOOL ShellLink_GetVolumeInfo ( LPCWSTR  path, CShellLink::volume_info *  volume  )

static

Definition at line 488 of file CShellLink.cpp.

{
    WCHAR drive[4] = { path[0], ':', '\\', 0 };
 
    volume->type = GetDriveTypeW(drive);
    BOOL bRet = GetVolumeInformationW(drive, volume->label, _countof(volume->label), &volume->serial, NULL, NULL, NULL, 0);
    TRACE("ret = %d type %d serial %08x name %s\n", bRet,
          volume->type, volume->serial, debugstr_w(volume->label));
    return bRet;
}

Referenced by CShellLink::SetTargetFromPIDLOrPath().

ShellLink_UpdatePath()

static HRESULT ShellLink_UpdatePath ( LPCWSTR  sPathRel, LPCWSTR  path, LPCWSTR  sWorkDir, LPWSTR *  psPath  )

static

Definition at line 1068 of file CShellLink.cpp.

{
    if (!path || !psPath)
        return E_INVALIDARG;
 
    if (!*psPath && sPathRel)
    {
        WCHAR buffer[2*MAX_PATH], abs_path[2*MAX_PATH];
        LPWSTR final = NULL;
 
        /* first try if [directory of link file] + [relative path] finds an existing file */
 
        GetFullPathNameW(path, MAX_PATH * 2, buffer, &final);
        if (!final)
            final = buffer;
        wcscpy(final, sPathRel);
 
        *abs_path = '\0';
 
        if (SHELL_ExistsFileW(buffer))
        {
            if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
                wcscpy(abs_path, buffer);
        }
        else
        {
            /* try if [working directory] + [relative path] finds an existing file */
            if (sWorkDir)
            {
                wcscpy(buffer, sWorkDir);
                wcscpy(PathAddBackslashW(buffer), sPathRel);
 
                if (SHELL_ExistsFileW(buffer))
                    if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
                        wcscpy(abs_path, buffer);
            }
        }
 
        /* FIXME: This is even not enough - not all shell links can be resolved using this algorithm. */
        if (!*abs_path)
            wcscpy(abs_path, sPathRel);
 
        *psPath = strdupW(abs_path);
        if (!*psPath)
            return E_OUTOFMEMORY;
    }
 
    return S_OK;
}

Referenced by CShellLink::Load(), and CShellLink::SetRelativePath().

strdupW()

static LPWSTR __inline strdupW ( LPCWSTR  src )

static

Definition at line 209 of file CShellLink.cpp.

{
    LPWSTR dest;
    if (!src) return NULL;
    dest = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wcslen(src) + 1) * sizeof(WCHAR));
    if (dest)
        wcscpy(dest, src);
    return dest;
}

Referenced by ShellLink_UpdatePath().

Stream_LoadLocation()

static HRESULT Stream_LoadLocation ( IStream *  stm, CShellLink::volume_info *  volume, LPWSTR *  path  )

static

Definition at line 569 of file CShellLink.cpp.

{
    char *p = NULL;
    HRESULT hr = Stream_ReadChunk(stm, (LPVOID*) &p);
    if (FAILED(hr))
        return hr;
 
    LOCATION_INFO *loc = reinterpret_cast<LOCATION_INFO *>(p);
    if (loc->dwTotalSize < sizeof(LOCATION_INFO))
    {
        HeapFree(GetProcessHeap(), 0, p);
        return E_FAIL;
    }
 
    /* if there's valid local volume information, load it */
    if (loc->dwVolTableOfs &&
        ((loc->dwVolTableOfs + sizeof(LOCAL_VOLUME_INFO)) <= loc->dwTotalSize))
    {
        LOCAL_VOLUME_INFO *volume_info;
 
        volume_info = (LOCAL_VOLUME_INFO*) &p[loc->dwVolTableOfs];
        Stream_LoadVolume(volume_info, volume);
    }
 
    /* if there's a local path, load it */
    DWORD n = loc->dwLocalPathOfs;
    if (n && n < loc->dwTotalSize)
        *path = Stream_LoadPath(&p[n], loc->dwTotalSize - n); // FIXME: Unicode offset (if present)
 
    TRACE("type %d serial %08x name %s path %s\n", volume->type,
          volume->serial, debugstr_w(volume->label), debugstr_w(*path));
 
    HeapFree(GetProcessHeap(), 0, p);
    return S_OK;
}

Referenced by CShellLink::Load().

Stream_LoadPath()

static LPWSTR Stream_LoadPath ( LPCSTR  p, DWORD  maxlen  )

static

Definition at line 552 of file CShellLink.cpp.

{
    UINT len = 0;
 
    while (len < maxlen && p[len])
        len++;
 
    UINT wlen = MultiByteToWideChar(CP_ACP, 0, p, len, NULL, 0);
    LPWSTR path = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wlen + 1) * sizeof(WCHAR));
    if (!path)
        return NULL;
    MultiByteToWideChar(CP_ACP, 0, p, len, path, wlen);
    path[wlen] = 0;
 
    return path;
}

Referenced by Stream_LoadLocation().

Stream_LoadString()

static HRESULT Stream_LoadString ( IStream *  stm, BOOL  unicode, LPWSTR *  pstr  )

static

Definition at line 431 of file CShellLink.cpp.

{
    TRACE("%p\n", stm);
 
    USHORT len;
    DWORD count = 0;
    HRESULT hr = stm->Read(&len, sizeof(len), &count);
    if (FAILED(hr) || count != sizeof(len))
        return E_FAIL;
 
    if (unicode)
        len *= sizeof(WCHAR);
 
    TRACE("reading %d\n", len);
    LPSTR temp = (LPSTR)HeapAlloc(GetProcessHeap(), 0, len + sizeof(WCHAR));
    if (!temp)
        return E_OUTOFMEMORY;
    count = 0;
    hr = stm->Read(temp, len, &count);
    if (FAILED(hr) || count != len)
    {
        HeapFree(GetProcessHeap(), 0, temp);
        return E_FAIL;
    }
 
    TRACE("read %s\n", debugstr_an(temp, len));
 
    /* convert to unicode if necessary */
    LPWSTR str;
    if (!unicode)
    {
        count = MultiByteToWideChar(CP_ACP, 0, temp, len, NULL, 0);
        str = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (count + 1) * sizeof(WCHAR));
        if (!str)
        {
            HeapFree(GetProcessHeap(), 0, temp);
            return E_OUTOFMEMORY;
        }
        MultiByteToWideChar(CP_ACP, 0, temp, len, str, count);
        HeapFree(GetProcessHeap(), 0, temp);
    }
    else
    {
        count /= sizeof(WCHAR);
        str = (LPWSTR)temp;
    }
    str[count] = 0;
 
    *pstr = str;
 
    return S_OK;
}

Referenced by CShellLink::Load().

Stream_LoadVolume()

static BOOL Stream_LoadVolume ( LOCAL_VOLUME_INFO *  vol, CShellLink::volume_info *  volume  )

static

Definition at line 534 of file CShellLink.cpp.

{
    volume->serial = vol->dwVolSerial;
    volume->type = vol->dwType;
 
    if (!vol->dwVolLabelOfs)
        return FALSE;
    if (vol->dwSize <= vol->dwVolLabelOfs)
        return FALSE;
    INT len = vol->dwSize - vol->dwVolLabelOfs;
 
    LPSTR label = (LPSTR)vol;
    label += vol->dwVolLabelOfs; // FIXME: 0x14 Unicode
    MultiByteToWideChar(CP_ACP, 0, label, len, volume->label, _countof(volume->label));
 
    return TRUE;
}

Referenced by Stream_LoadLocation().

Stream_ReadChunk()

static HRESULT Stream_ReadChunk ( IStream *  stm, LPVOID *  data  )

static

Definition at line 499 of file CShellLink.cpp.

{
    struct sized_chunk
    {
        DWORD size;
        unsigned char data[1];
    } *chunk;
 
    TRACE("%p\n", stm);
 
    DWORD size;
    ULONG count;
    HRESULT hr = stm->Read(&size, sizeof(size), &count);
    if (FAILED(hr) || count != sizeof(size))
        return E_FAIL;
 
    chunk = static_cast<sized_chunk *>(HeapAlloc(GetProcessHeap(), 0, size));
    if (!chunk)
        return E_OUTOFMEMORY;
 
    chunk->size = size;
    hr = stm->Read(chunk->data, size - sizeof(size), &count);
    if (FAILED(hr) || count != (size - sizeof(size)))
    {
        HeapFree(GetProcessHeap(), 0, chunk);
        return E_FAIL;
    }
 
    TRACE("Read %d bytes\n", chunk->size);
 
    *data = chunk;
 
    return S_OK;
}

Referenced by Stream_LoadLocation().

Stream_WriteLocationInfo()

static HRESULT Stream_WriteLocationInfo ( IStream *  stm, LPCWSTR  path, CShellLink::volume_info *  volume  )

static

Definition at line 851 of file CShellLink.cpp.

{
    LOCAL_VOLUME_INFO *vol;
    LOCATION_INFO *loc;
 
    TRACE("%p %s %p\n", stm, debugstr_w(path), volume);
 
    /* figure out the size of everything */
    DWORD label_size = WideCharToMultiByte(CP_ACP, 0, volume->label, -1,
                                      NULL, 0, NULL, NULL);
    DWORD path_size = WideCharToMultiByte(CP_ACP, 0, path, -1,
                                     NULL, 0, NULL, NULL);
    DWORD volume_info_size = sizeof(*vol) + label_size;
    DWORD final_path_size = 1;
    DWORD total_size = sizeof(*loc) + volume_info_size + path_size + final_path_size;
 
    /* create pointers to everything */
    loc = static_cast<LOCATION_INFO *>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, total_size));
    vol = (LOCAL_VOLUME_INFO*) &loc[1];
    LPSTR szLabel = (LPSTR) &vol[1];
    LPSTR szPath = &szLabel[label_size];
    LPSTR szFinalPath = &szPath[path_size];
 
    /* fill in the location information header */
    loc->dwTotalSize = total_size;
    loc->dwHeaderSize = sizeof(*loc);
    loc->dwFlags = 1;
    loc->dwVolTableOfs = sizeof(*loc);
    loc->dwLocalPathOfs = sizeof(*loc) + volume_info_size;
    loc->dwNetworkVolTableOfs = 0;
    loc->dwFinalPathOfs = sizeof(*loc) + volume_info_size + path_size;
 
    /* fill in the volume information */
    vol->dwSize = volume_info_size;
    vol->dwType = volume->type;
    vol->dwVolSerial = volume->serial;
    vol->dwVolLabelOfs = sizeof(*vol);
 
    /* copy in the strings */
    WideCharToMultiByte(CP_ACP, 0, volume->label, -1,
                         szLabel, label_size, NULL, NULL);
    WideCharToMultiByte(CP_ACP, 0, path, -1,
                         szPath, path_size, NULL, NULL);
    *szFinalPath = 0;
 
    ULONG count = 0;
    HRESULT hr = stm->Write(loc, total_size, &count);
    HeapFree(GetProcessHeap(), 0, loc);
 
    return hr;
}

Referenced by CShellLink::Save().

Stream_WriteString()

static HRESULT Stream_WriteString ( IStream *  stm, LPCWSTR  str  )

static

Definition at line 816 of file CShellLink.cpp.

{
    SIZE_T length;
    USHORT len;
    DWORD count;
 
    length = wcslen(str) + 1;
    if (length > MAXUSHORT)
    {
        return E_INVALIDARG;
    }
 
    len = (USHORT)length;
    HRESULT hr = stm->Write(&len, sizeof(len), &count);
    if (FAILED(hr))
        return hr;
 
    length *= sizeof(WCHAR);
 
    hr = stm->Write(str, (ULONG)length, &count);
    if (FAILED(hr))
        return hr;
 
    return S_OK;
}

Referenced by CShellLink::Save().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)