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
#define	LNK_EXT_INDEX   4

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 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)
static BOOL	HACKISH_PathResolve (IN OUT PWSTR pszPath, IN PZPCWSTR dirs OPTIONAL, IN UINT fFlags)
INT_PTR CALLBACK	ExtendedShortcutProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
LPWSTR	SH_GetTargetTypeByPath (LPCWSTR lpcwFullPath)
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.

LNK_EXT_INDEX

#define LNK_EXT_INDEX   4

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 2734 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 2001 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().

HACKISH_PathResolve()

static BOOL HACKISH_PathResolve ( IN OUT PWSTR  pszPath, IN PZPCWSTR dirs  OPTIONAL, IN UINT  fFlags  )

static

Definition at line 2175 of file CShellLink.cpp.

{
    // FIXME: This is unimplemented!!!
#if 0
    return PathResolve(pszPath, dirs, fFlags);
#else
    BOOL Success = FALSE;
    USHORT i;
    LPWSTR fname = NULL;
    WCHAR szPath[MAX_PATH];

    /* First, search for a valid existing path */

    // NOTE: See also: SHELL_FindExecutable()

    /*
     * List of extensions searched for, by PathResolve with the flag
     * PRF_TRYPROGRAMEXTENSIONS == PRF_EXECUTABLE | PRF_VERIFYEXISTS set,
     * according to MSDN: https://msdn.microsoft.com/en-us/library/windows/desktop/bb776478(v=vs.85).aspx
     */
    static PCWSTR Extensions[] = {L".pif", L".com", L".bat", L".cmd", L".lnk", L".exe", NULL};
    #define LNK_EXT_INDEX   4   // ".lnk" has index 4 in the array above

    /*
     * Start at the beginning of the list if PRF_EXECUTABLE is set, otherwise
     * just use the last element 'NULL' (no extension checking).
     */
    i = ((fFlags & PRF_EXECUTABLE) ? 0 : _countof(Extensions) - 1);
    for (; i < _countof(Extensions); ++i)
    {
        /* Ignore shell links ".lnk" if needed */
        if ((fFlags & PRF_DONTFINDLNK) && (i == LNK_EXT_INDEX))
            continue;

        Success = (SearchPathW(NULL, pszPath, Extensions[i],
                               _countof(szPath), szPath, NULL) != 0);
        if (!Success)
        {
            ERR("SearchPathW(pszPath = '%S') failed. Error code: %lu\n", pszPath, GetLastError());
        }
        else
        {
            ERR("SearchPathW(pszPath = '%S', szPath = '%S') succeeded\n", pszPath, szPath);
            break;
        }
    }

    if (!Success)
    {
        ERR("SearchPathW(pszPath = '%S') failed. Error code: %lu\n", pszPath, GetLastError());

        /* We failed, try with PathFindOnPath, as explained by MSDN */
        // Success = PathFindOnPathW(pszPath, dirs);
        StringCchCopyW(szPath, _countof(szPath), pszPath);
        Success = PathFindOnPathW(szPath, dirs);
        if (!Success)
        {
            ERR("PathFindOnPathW(pszPath = '%S') failed\n", pszPath);

            /* We failed again, fall back to building a possible non-existing path */
            if (!GetFullPathNameW(pszPath, _countof(szPath), szPath, &fname))
            {
                ERR("GetFullPathNameW(pszPath = '%S') failed. Error code: %lu\n", pszPath, GetLastError());
                return FALSE;
            }

            Success = PathFileExistsW(szPath);
            if (!Success)
                ERR("PathFileExistsW(szPath = '%S') failed. Error code: %lu\n", szPath, GetLastError());

            /******************************************************/
            /* Question: Why this line is needed only for files?? */
            if (fname && (_wcsicmp(pszPath, fname) == 0))
                *szPath = L'\0';
            /******************************************************/
        }
        else
        {
            ERR("PathFindOnPathW(pszPath = '%S' ==> '%S') succeeded\n", pszPath, szPath);
        }
    }

    /* Copy back the results to the caller */
    StringCchCopyW(pszPath, MAX_PATH, szPath);

    /*
     * Since the called functions always checked whether the file path existed,
     * we do not need to redo a final check: we can use instead the cached
     * result in 'Success'.
     */
    return ((fFlags & PRF_VERIFYEXISTS) ? Success : TRUE);
#endif
}

Referenced by CShellLink::SetTargetFromPIDLOrPath().

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 3178 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 3164 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().

SH_GetTargetTypeByPath()

LPWSTR SH_GetTargetTypeByPath

(

LPCWSTR

lpcwFullPath

)

Definition at line 2777 of file CShellLink.cpp.

{
    LPCWSTR pwszExt;
    static WCHAR wszBuf[MAX_PATH];

    /* Get file information */
    SHFILEINFOW fi;
    if (!SHGetFileInfoW(lpcwFullPath, 0, &fi, sizeof(fi), SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES))
    {
        ERR("SHGetFileInfoW failed for %ls (%lu)\n", lpcwFullPath, GetLastError());
        fi.szTypeName[0] = L'\0';
        fi.hIcon = NULL;
    }

    pwszExt = PathFindExtensionW(lpcwFullPath);
    if (pwszExt[0])
    {
        if (!fi.szTypeName[0])
        {
            /* The file type is unknown, so default to string "FileExtension File" */
            size_t cchRemaining = 0;
            LPWSTR pwszEnd = NULL;

            StringCchPrintfExW(wszBuf, _countof(wszBuf), &pwszEnd, &cchRemaining, 0, L"%s ", pwszExt + 1);
        }
        else
        {
            /* Update file type */
            StringCbPrintfW(wszBuf, sizeof(wszBuf), L"%s (%s)", fi.szTypeName, pwszExt);
        }
    }

    return wszBuf;
}

Referenced by CShellLink::OnInitDialog().

SHELL_ExistsFileW()

static BOOL SHELL_ExistsFileW ( LPCWSTR  path )

static

Definition at line 989 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 1679 of file CShellLink.cpp.

{
    LPCITEMIDLIST pidlLast;
    CComPtr<IShellFolder> psf;

    HRESULT hr = SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlLast);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;

    CComPtr<IExtractIconW> pei;
    hr = psf->GetUIObjectOf(0, 1, &pidlLast, IID_NULL_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 1357 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 462 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 1001 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 CShellLink::DoOpen(), CShellLink::GetIconLocation(), CShellLink::Load(), CShellLink::OnNotify(), CShellLink::Resolve(), CShellLink::Save(), CShellLink::SetArguments(), CShellLink::SetDescription(), CShellLink::SetIconLocation(), CShellLink::SetPath(), CShellLink::SetRelativePath(), CShellLink::SetTargetFromPIDLOrPath(), CShellLink::SetWorkingDirectory(), and ShellLink_UpdatePath().

Stream_LoadLocation()

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

static

Definition at line 543 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);

    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 526 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 405 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 508 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;
    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 473 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 801 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 774 of file CShellLink.cpp.

{
    USHORT len = wcslen(str) + 1; // FIXME: Possible overflows?
    DWORD count;

    HRESULT hr = stm->Write(&len, sizeof(len), &count);
    if (FAILED(hr))
        return hr;

    len *= sizeof(WCHAR);

    hr = stm->Write(str, len, &count);
    if (FAILED(hr))
        return hr;

    return S_OK;
}

Referenced by CShellLink::Save().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)