mirror of
https://github.com/reactos/reactos.git
synced 2024-10-30 03:27:31 +00:00
792 lines
24 KiB
C++
792 lines
24 KiB
C++
/*
|
|
* IQueryAssociations object and helper functions
|
|
*
|
|
* Copyright 2002 Jon Griffiths
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(shell);
|
|
|
|
/**************************************************************************
|
|
* IQueryAssociations
|
|
*
|
|
* DESCRIPTION
|
|
* This object provides a layer of abstraction over the system registry in
|
|
* order to simplify the process of parsing associations between files.
|
|
* Associations in this context means the registry entries that link (for
|
|
* example) the extension of a file with its description, list of
|
|
* applications to open the file with, and actions that can be performed on it
|
|
* (the shell displays such information in the context menu of explorer
|
|
* when you right-click on a file).
|
|
*
|
|
* HELPERS
|
|
* You can use this object transparently by calling the helper functions
|
|
* AssocQueryKeyA(), AssocQueryStringA() and AssocQueryStringByKeyA(). These
|
|
* create an IQueryAssociations object, perform the requested actions
|
|
* and then dispose of the object. Alternatively, you can create an instance
|
|
* of the object using AssocCreate() and call the following methods on it:
|
|
*
|
|
* METHODS
|
|
*/
|
|
|
|
CQueryAssociations::CQueryAssociations() : hkeySource(0), hkeyProgID(0)
|
|
{
|
|
}
|
|
|
|
CQueryAssociations::~CQueryAssociations()
|
|
{
|
|
}
|
|
|
|
/**************************************************************************
|
|
* IQueryAssociations_Init
|
|
*
|
|
* Initialise an IQueryAssociations object.
|
|
*
|
|
* PARAMS
|
|
* cfFlags [I] ASSOCF_ flags from "shlwapi.h"
|
|
* pszAssoc [I] String for the root key name, or NULL if hkeyProgid is given
|
|
* hkeyProgid [I] Handle for the root key, or NULL if pszAssoc is given
|
|
* hWnd [I] Reserved, must be NULL.
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK. iface is initialised with the parameters given.
|
|
* Failure: An HRESULT error code indicating the error.
|
|
*/
|
|
HRESULT STDMETHODCALLTYPE CQueryAssociations::Init(
|
|
ASSOCF cfFlags,
|
|
LPCWSTR pszAssoc,
|
|
HKEY hkeyProgid,
|
|
HWND hWnd)
|
|
{
|
|
static const WCHAR szProgID[] = L"ProgID";
|
|
|
|
TRACE("(%p)->(%d,%s,%p,%p)\n", this,
|
|
cfFlags,
|
|
debugstr_w(pszAssoc),
|
|
hkeyProgid,
|
|
hWnd);
|
|
|
|
if (hWnd != NULL)
|
|
{
|
|
FIXME("hwnd != NULL not supported\n");
|
|
}
|
|
|
|
if (cfFlags != 0)
|
|
{
|
|
FIXME("unsupported flags: %x\n", cfFlags);
|
|
}
|
|
|
|
RegCloseKey(this->hkeySource);
|
|
RegCloseKey(this->hkeyProgID);
|
|
this->hkeySource = this->hkeyProgID = NULL;
|
|
if (pszAssoc != NULL)
|
|
{
|
|
WCHAR *progId;
|
|
HRESULT hr;
|
|
|
|
LONG ret = RegOpenKeyExW(HKEY_CLASSES_ROOT,
|
|
pszAssoc,
|
|
0,
|
|
KEY_READ,
|
|
&this->hkeySource);
|
|
if (ret)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
/* if this is a progid */
|
|
if (*pszAssoc != '.' && *pszAssoc != '{')
|
|
{
|
|
this->hkeyProgID = this->hkeySource;
|
|
return S_OK;
|
|
}
|
|
|
|
/* if it's not a progid, it's a file extension or clsid */
|
|
if (*pszAssoc == '.')
|
|
{
|
|
/* for a file extension, the progid is the default value */
|
|
hr = this->GetValue(this->hkeySource, NULL, (void**)&progId, NULL);
|
|
if (FAILED(hr))
|
|
return S_OK;
|
|
}
|
|
else /* if (*pszAssoc == '{') */
|
|
{
|
|
HKEY progIdKey;
|
|
/* for a clsid, the progid is the default value of the ProgID subkey */
|
|
ret = RegOpenKeyExW(this->hkeySource,
|
|
szProgID,
|
|
0,
|
|
KEY_READ,
|
|
&progIdKey);
|
|
if (ret != ERROR_SUCCESS)
|
|
return S_OK;
|
|
hr = this->GetValue(progIdKey, NULL, (void**)&progId, NULL);
|
|
if (FAILED(hr))
|
|
return S_OK;
|
|
RegCloseKey(progIdKey);
|
|
}
|
|
|
|
/* open the actual progid key, the one with the shell subkey */
|
|
ret = RegOpenKeyExW(HKEY_CLASSES_ROOT,
|
|
progId,
|
|
0,
|
|
KEY_READ,
|
|
&this->hkeyProgID);
|
|
HeapFree(GetProcessHeap(), 0, progId);
|
|
|
|
return S_OK;
|
|
}
|
|
else if (hkeyProgid != NULL)
|
|
{
|
|
/* reopen the key so we don't end up closing a key owned by the caller */
|
|
RegOpenKeyExW(hkeyProgid, NULL, 0, KEY_READ, &this->hkeyProgID);
|
|
this->hkeySource = this->hkeyProgID;
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* IQueryAssociations_GetString
|
|
*
|
|
* Get a file association string from the registry.
|
|
*
|
|
* PARAMS
|
|
* cfFlags [I] ASSOCF_ flags from "shlwapi.h"
|
|
* str [I] Type of string to get (ASSOCSTR enum from "shlwapi.h")
|
|
* pszExtra [I] Extra information about the string location
|
|
* pszOut [O] Destination for the association string
|
|
* pcchOut [I/O] Length of pszOut
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK. pszOut contains the string, pcchOut contains its length.
|
|
* Failure: An HRESULT error code indicating the error.
|
|
*/
|
|
HRESULT STDMETHODCALLTYPE CQueryAssociations::GetString(
|
|
ASSOCF flags,
|
|
ASSOCSTR str,
|
|
LPCWSTR pszExtra,
|
|
LPWSTR pszOut,
|
|
DWORD *pcchOut)
|
|
{
|
|
const ASSOCF unimplemented_flags = ~ASSOCF_NOTRUNCATE;
|
|
DWORD len = 0;
|
|
HRESULT hr;
|
|
WCHAR path[MAX_PATH];
|
|
|
|
TRACE("(%p)->(0x%08x, %u, %s, %p, %p)\n", this, flags, str, debugstr_w(pszExtra), pszOut, pcchOut);
|
|
if (flags & unimplemented_flags)
|
|
{
|
|
FIXME("%08x: unimplemented flags\n", flags & unimplemented_flags);
|
|
}
|
|
|
|
if (!pcchOut)
|
|
{
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
if (!this->hkeySource && !this->hkeyProgID)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
|
|
}
|
|
|
|
switch (str)
|
|
{
|
|
case ASSOCSTR_COMMAND:
|
|
{
|
|
WCHAR *command;
|
|
hr = this->GetCommand(pszExtra, &command);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = this->ReturnString(flags, pszOut, pcchOut, command, strlenW(command) + 1);
|
|
HeapFree(GetProcessHeap(), 0, command);
|
|
}
|
|
return hr;
|
|
}
|
|
case ASSOCSTR_EXECUTABLE:
|
|
{
|
|
hr = this->GetExecutable(pszExtra, path, MAX_PATH, &len);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
len++;
|
|
return this->ReturnString(flags, pszOut, pcchOut, path, len);
|
|
}
|
|
case ASSOCSTR_FRIENDLYDOCNAME:
|
|
{
|
|
WCHAR *pszFileType;
|
|
|
|
hr = this->GetValue(this->hkeySource, NULL, (void**)&pszFileType, NULL);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
DWORD size = 0;
|
|
DWORD ret = RegGetValueW(HKEY_CLASSES_ROOT, pszFileType, NULL, RRF_RT_REG_SZ, NULL, NULL, &size);
|
|
if (ret == ERROR_SUCCESS)
|
|
{
|
|
WCHAR *docName = static_cast<WCHAR *>(HeapAlloc(GetProcessHeap(), 0, size));
|
|
if (docName)
|
|
{
|
|
ret = RegGetValueW(HKEY_CLASSES_ROOT, pszFileType, NULL, RRF_RT_REG_SZ, NULL, docName, &size);
|
|
if (ret == ERROR_SUCCESS)
|
|
{
|
|
hr = this->ReturnString(flags, pszOut, pcchOut, docName, strlenW(docName) + 1);
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ret);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, docName);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ret);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, pszFileType);
|
|
return hr;
|
|
}
|
|
case ASSOCSTR_FRIENDLYAPPNAME:
|
|
{
|
|
PVOID verinfoW = NULL;
|
|
DWORD size, retval = 0;
|
|
UINT flen;
|
|
WCHAR *bufW;
|
|
static const WCHAR translationW[] = L"\\VarFileInfo\\Translation";
|
|
static const WCHAR fileDescFmtW[] = L"\\StringFileInfo\\%04x%04x\\FileDescription";
|
|
WCHAR fileDescW[41];
|
|
|
|
hr = this->GetExecutable(pszExtra, path, MAX_PATH, &len);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
retval = GetFileVersionInfoSizeW(path, &size);
|
|
if (!retval)
|
|
{
|
|
goto get_friendly_name_fail;
|
|
}
|
|
verinfoW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, retval);
|
|
if (!verinfoW)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
if (!GetFileVersionInfoW(path, 0, retval, verinfoW))
|
|
{
|
|
goto get_friendly_name_fail;
|
|
}
|
|
if (VerQueryValueW(verinfoW, translationW, (LPVOID *)&bufW, &flen))
|
|
{
|
|
UINT i;
|
|
DWORD *langCodeDesc = (DWORD *)bufW;
|
|
for (i = 0; i < flen / sizeof(DWORD); i++)
|
|
{
|
|
sprintfW(fileDescW, fileDescFmtW, LOWORD(langCodeDesc[i]), HIWORD(langCodeDesc[i]));
|
|
if (VerQueryValueW(verinfoW, fileDescW, (LPVOID *)&bufW, &flen))
|
|
{
|
|
/* Does strlenW(bufW) == 0 mean we use the filename? */
|
|
len = strlenW(bufW) + 1;
|
|
TRACE("found FileDescription: %s\n", debugstr_w(bufW));
|
|
hr = this->ReturnString(flags, pszOut, pcchOut, bufW, len);
|
|
HeapFree(GetProcessHeap(), 0, verinfoW);
|
|
return hr;
|
|
}
|
|
}
|
|
}
|
|
get_friendly_name_fail:
|
|
PathRemoveExtensionW(path);
|
|
PathStripPathW(path);
|
|
TRACE("using filename: %s\n", debugstr_w(path));
|
|
hr = this->ReturnString(flags, pszOut, pcchOut, path, strlenW(path) + 1);
|
|
HeapFree(GetProcessHeap(), 0, verinfoW);
|
|
return hr;
|
|
}
|
|
case ASSOCSTR_CONTENTTYPE:
|
|
{
|
|
static const WCHAR Content_TypeW[] = L"Content Type";
|
|
|
|
DWORD size = 0;
|
|
DWORD ret = RegGetValueW(this->hkeySource, NULL, Content_TypeW, RRF_RT_REG_SZ, NULL, NULL, &size);
|
|
if (ret != ERROR_SUCCESS)
|
|
{
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
WCHAR *contentType = static_cast<WCHAR *>(HeapAlloc(GetProcessHeap(), 0, size));
|
|
if (contentType != NULL)
|
|
{
|
|
ret = RegGetValueW(this->hkeySource, NULL, Content_TypeW, RRF_RT_REG_SZ, NULL, contentType, &size);
|
|
if (ret == ERROR_SUCCESS)
|
|
{
|
|
hr = this->ReturnString(flags, pszOut, pcchOut, contentType, strlenW(contentType) + 1);
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ret);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, contentType);
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
return hr;
|
|
}
|
|
case ASSOCSTR_DEFAULTICON:
|
|
{
|
|
static const WCHAR DefaultIconW[] = L"DefaultIcon";
|
|
DWORD ret;
|
|
DWORD size = 0;
|
|
ret = RegGetValueW(this->hkeyProgID, DefaultIconW, NULL, RRF_RT_REG_SZ, NULL, NULL, &size);
|
|
if (ret == ERROR_SUCCESS)
|
|
{
|
|
WCHAR *icon = static_cast<WCHAR *>(HeapAlloc(GetProcessHeap(), 0, size));
|
|
if (icon)
|
|
{
|
|
ret = RegGetValueW(this->hkeyProgID, DefaultIconW, NULL, RRF_RT_REG_SZ, NULL, icon, &size);
|
|
if (ret == ERROR_SUCCESS)
|
|
{
|
|
hr = this->ReturnString(flags, pszOut, pcchOut, icon, strlenW(icon) + 1);
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ret);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, icon);
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ret);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ret);
|
|
}
|
|
return hr;
|
|
}
|
|
case ASSOCSTR_SHELLEXTENSION:
|
|
{
|
|
static const WCHAR shellexW[] = L"ShellEx\\";
|
|
WCHAR keypath[sizeof(shellexW) / sizeof(shellexW[0]) + 39], guid[39];
|
|
CLSID clsid;
|
|
HKEY hkey;
|
|
|
|
hr = CLSIDFromString(pszExtra, &clsid);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
strcpyW(keypath, shellexW);
|
|
strcatW(keypath, pszExtra);
|
|
LONG ret = RegOpenKeyExW(this->hkeySource, keypath, 0, KEY_READ, &hkey);
|
|
if (ret)
|
|
{
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
DWORD size = sizeof(guid);
|
|
ret = RegGetValueW(hkey, NULL, NULL, RRF_RT_REG_SZ, NULL, guid, &size);
|
|
RegCloseKey(hkey);
|
|
if (ret)
|
|
{
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
return this->ReturnString(flags, pszOut, pcchOut, guid, size / sizeof(WCHAR));
|
|
}
|
|
|
|
default:
|
|
{
|
|
FIXME("assocstr %d unimplemented!\n", str);
|
|
return E_NOTIMPL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**************************************************************************
|
|
* IQueryAssociations_GetKey
|
|
*
|
|
* Get a file association key from the registry.
|
|
*
|
|
* PARAMS
|
|
* cfFlags [I] ASSOCF_ flags from "shlwapi.h"
|
|
* assockey [I] Type of key to get (ASSOCKEY enum from "shlwapi.h")
|
|
* pszExtra [I] Extra information about the key location
|
|
* phkeyOut [O] Destination for the association key
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK. phkeyOut contains a handle to the key.
|
|
* Failure: An HRESULT error code indicating the error.
|
|
*/
|
|
HRESULT STDMETHODCALLTYPE CQueryAssociations::GetKey(
|
|
ASSOCF cfFlags,
|
|
ASSOCKEY assockey,
|
|
LPCWSTR pszExtra,
|
|
HKEY *phkeyOut)
|
|
{
|
|
FIXME("(%p,0x%8x,0x%8x,%s,%p)-stub!\n", this, cfFlags, assockey,
|
|
debugstr_w(pszExtra), phkeyOut);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* IQueryAssociations_GetData
|
|
*
|
|
* Get the data for a file association key from the registry.
|
|
*
|
|
* PARAMS
|
|
* cfFlags [I] ASSOCF_ flags from "shlwapi.h"
|
|
* assocdata [I] Type of data to get (ASSOCDATA enum from "shlwapi.h")
|
|
* pszExtra [I] Extra information about the data location
|
|
* pvOut [O] Destination for the association key
|
|
* pcbOut [I/O] Size of pvOut
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK. pszOut contains the data, pcbOut contains its length.
|
|
* Failure: An HRESULT error code indicating the error.
|
|
*/
|
|
HRESULT STDMETHODCALLTYPE CQueryAssociations::GetData(ASSOCF cfFlags, ASSOCDATA assocdata, LPCWSTR pszExtra, LPVOID pvOut, DWORD *pcbOut)
|
|
{
|
|
static const WCHAR edit_flags[] = L"EditFlags";
|
|
|
|
TRACE("(%p,0x%8x,0x%8x,%s,%p,%p)\n", this, cfFlags, assocdata,
|
|
debugstr_w(pszExtra), pvOut, pcbOut);
|
|
|
|
if(cfFlags)
|
|
{
|
|
FIXME("Unsupported flags: %x\n", cfFlags);
|
|
}
|
|
|
|
switch(assocdata)
|
|
{
|
|
case ASSOCDATA_EDITFLAGS:
|
|
{
|
|
if(!this->hkeyProgID)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
|
|
}
|
|
|
|
void *data;
|
|
DWORD size;
|
|
HRESULT hres = this->GetValue(this->hkeyProgID, edit_flags, &data, &size);
|
|
if(FAILED(hres))
|
|
{
|
|
return hres;
|
|
}
|
|
|
|
if (!pcbOut)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, data);
|
|
return hres;
|
|
}
|
|
|
|
hres = this->ReturnData(pvOut, pcbOut, data, size);
|
|
HeapFree(GetProcessHeap(), 0, data);
|
|
return hres;
|
|
}
|
|
default:
|
|
{
|
|
FIXME("Unsupported ASSOCDATA value: %d\n", assocdata);
|
|
return E_NOTIMPL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**************************************************************************
|
|
* IQueryAssociations_GetEnum
|
|
*
|
|
* Not yet implemented in native Win32.
|
|
*
|
|
* PARAMS
|
|
* cfFlags [I] ASSOCF_ flags from "shlwapi.h"
|
|
* assocenum [I] Type of enum to get (ASSOCENUM enum from "shlwapi.h")
|
|
* pszExtra [I] Extra information about the enum location
|
|
* riid [I] REFIID to look for
|
|
* ppvOut [O] Destination for the interface.
|
|
*
|
|
* RETURNS
|
|
* Success: S_OK.
|
|
* Failure: An HRESULT error code indicating the error.
|
|
*
|
|
* NOTES
|
|
* Presumably this function returns an enumerator object.
|
|
*/
|
|
HRESULT STDMETHODCALLTYPE CQueryAssociations::GetEnum(
|
|
ASSOCF cfFlags,
|
|
ASSOCENUM assocenum,
|
|
LPCWSTR pszExtra,
|
|
REFIID riid,
|
|
LPVOID *ppvOut)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
HRESULT CQueryAssociations::GetValue(HKEY hkey, const WCHAR *name, void **data, DWORD *data_size)
|
|
{
|
|
DWORD size;
|
|
LONG ret;
|
|
|
|
ret = RegQueryValueExW(hkey, name, 0, NULL, NULL, &size);
|
|
if (ret != ERROR_SUCCESS)
|
|
{
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
if (!size)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
*data = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!*data)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
ret = RegQueryValueExW(hkey, name, 0, NULL, (LPBYTE)*data, &size);
|
|
if (ret != ERROR_SUCCESS)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, *data);
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
if(data_size)
|
|
{
|
|
*data_size = size;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CQueryAssociations::GetCommand(const WCHAR *extra, WCHAR **command)
|
|
{
|
|
HKEY hkeyCommand;
|
|
HKEY hkeyShell;
|
|
HKEY hkeyVerb;
|
|
HRESULT hr;
|
|
LONG ret;
|
|
WCHAR *extra_from_reg = NULL;
|
|
WCHAR *filetype;
|
|
static const WCHAR commandW[] = L"command";
|
|
static const WCHAR shellW[] = L"shell";
|
|
|
|
/* When looking for file extension it's possible to have a default value
|
|
that points to another key that contains 'shell/<verb>/command' subtree. */
|
|
hr = this->GetValue(this->hkeySource, NULL, (void**)&filetype, NULL);
|
|
if (hr == S_OK)
|
|
{
|
|
HKEY hkeyFile;
|
|
|
|
ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, filetype, 0, KEY_READ, &hkeyFile);
|
|
HeapFree(GetProcessHeap(), 0, filetype);
|
|
|
|
if (ret == ERROR_SUCCESS)
|
|
{
|
|
ret = RegOpenKeyExW(hkeyFile, shellW, 0, KEY_READ, &hkeyShell);
|
|
RegCloseKey(hkeyFile);
|
|
}
|
|
else
|
|
{
|
|
ret = RegOpenKeyExW(this->hkeySource, shellW, 0, KEY_READ, &hkeyShell);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret = RegOpenKeyExW(this->hkeySource, shellW, 0, KEY_READ, &hkeyShell);
|
|
}
|
|
|
|
if (ret)
|
|
{
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
|
|
if (!extra)
|
|
{
|
|
/* check for default verb */
|
|
hr = this->GetValue(hkeyShell, NULL, (void**)&extra_from_reg, NULL);
|
|
if (FAILED(hr))
|
|
{
|
|
/* no default verb, try first subkey */
|
|
DWORD max_subkey_len;
|
|
|
|
ret = RegQueryInfoKeyW(hkeyShell, NULL, NULL, NULL, NULL, &max_subkey_len, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
if (ret)
|
|
{
|
|
RegCloseKey(hkeyShell);
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
|
|
max_subkey_len++;
|
|
extra_from_reg = static_cast<WCHAR*>(HeapAlloc(GetProcessHeap(), 0, max_subkey_len * sizeof(WCHAR)));
|
|
if (!extra_from_reg)
|
|
{
|
|
RegCloseKey(hkeyShell);
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
ret = RegEnumKeyExW(hkeyShell, 0, extra_from_reg, &max_subkey_len, NULL, NULL, NULL, NULL);
|
|
if (ret)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, extra_from_reg);
|
|
RegCloseKey(hkeyShell);
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
}
|
|
extra = extra_from_reg;
|
|
}
|
|
|
|
/* open verb subkey */
|
|
ret = RegOpenKeyExW(hkeyShell, extra, 0, KEY_READ, &hkeyVerb);
|
|
HeapFree(GetProcessHeap(), 0, extra_from_reg);
|
|
RegCloseKey(hkeyShell);
|
|
if (ret)
|
|
{
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
/* open command subkey */
|
|
ret = RegOpenKeyExW(hkeyVerb, commandW, 0, KEY_READ, &hkeyCommand);
|
|
RegCloseKey(hkeyVerb);
|
|
if (ret)
|
|
{
|
|
return HRESULT_FROM_WIN32(ret);
|
|
}
|
|
hr = this->GetValue(hkeyCommand, NULL, (void**)command, NULL);
|
|
RegCloseKey(hkeyCommand);
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CQueryAssociations::GetExecutable(LPCWSTR pszExtra, LPWSTR path, DWORD pathlen, DWORD *len)
|
|
{
|
|
WCHAR *pszCommand;
|
|
WCHAR *pszStart;
|
|
WCHAR *pszEnd;
|
|
|
|
HRESULT hr = this->GetCommand(pszExtra, &pszCommand);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
DWORD expLen = ExpandEnvironmentStringsW(pszCommand, NULL, 0);
|
|
if (expLen > 0)
|
|
{
|
|
expLen++;
|
|
WCHAR *buf = static_cast<WCHAR *>(HeapAlloc(GetProcessHeap(), 0, expLen * sizeof(WCHAR)));
|
|
ExpandEnvironmentStringsW(pszCommand, buf, expLen);
|
|
HeapFree(GetProcessHeap(), 0, pszCommand);
|
|
pszCommand = buf;
|
|
}
|
|
|
|
/* cleanup pszCommand */
|
|
if (pszCommand[0] == '"')
|
|
{
|
|
pszStart = pszCommand + 1;
|
|
pszEnd = strchrW(pszStart, '"');
|
|
if (pszEnd)
|
|
{
|
|
*pszEnd = 0;
|
|
}
|
|
*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
|
|
}
|
|
else
|
|
{
|
|
pszStart = pszCommand;
|
|
for (pszEnd = pszStart; (pszEnd = strchrW(pszEnd, ' ')); pszEnd++)
|
|
{
|
|
WCHAR c = *pszEnd;
|
|
*pszEnd = 0;
|
|
if ((*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL)))
|
|
{
|
|
break;
|
|
}
|
|
*pszEnd = c;
|
|
}
|
|
if (!pszEnd)
|
|
{
|
|
*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
|
|
}
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, pszCommand);
|
|
if (!*len)
|
|
{
|
|
return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CQueryAssociations::ReturnData(void *out, DWORD *outlen, const void *data, DWORD datalen)
|
|
{
|
|
if (out)
|
|
{
|
|
if (*outlen < datalen)
|
|
{
|
|
*outlen = datalen;
|
|
return E_POINTER;
|
|
}
|
|
*outlen = datalen;
|
|
memcpy(out, data, datalen);
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
*outlen = datalen;
|
|
return S_FALSE;
|
|
}
|
|
}
|
|
|
|
HRESULT CQueryAssociations::ReturnString(ASSOCF flags, LPWSTR out, DWORD *outlen, LPCWSTR data, DWORD datalen)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD len;
|
|
|
|
TRACE("flags=0x%08x, data=%s\n", flags, debugstr_w(data));
|
|
|
|
if (!out)
|
|
{
|
|
*outlen = datalen;
|
|
return S_FALSE;
|
|
}
|
|
|
|
if (*outlen < datalen)
|
|
{
|
|
if (flags & ASSOCF_NOTRUNCATE)
|
|
{
|
|
len = 0;
|
|
if (*outlen > 0) out[0] = 0;
|
|
hr = E_POINTER;
|
|
}
|
|
else
|
|
{
|
|
len = min(*outlen, datalen);
|
|
hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
|
|
}
|
|
*outlen = datalen;
|
|
}
|
|
else
|
|
{
|
|
len = datalen;
|
|
}
|
|
|
|
if (len)
|
|
{
|
|
memcpy(out, data, len*sizeof(WCHAR));
|
|
}
|
|
|
|
return hr;
|
|
} |