git.oblomov.eu Git - wine/blob - dlls/shlwapi/assoc.c

   1 /*
   2  * IQueryAssociations object and helper functions
   3  *
   4  * Copyright 2002 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #include <stdarg.h>
  21 #include <assert.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winnls.h"
  26 #include "winreg.h"
  27 #include "objbase.h"
  28 #include "shlguid.h"
  29 #include "shlwapi.h"
  30 #include "wine/unicode.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  34
  35 /**************************************************************************
  36  *  IQueryAssociations {SHLWAPI}
  37  *
  38  * DESCRIPTION
  39  *  This object provides a layer of abstraction over the system registry in
  40  *  order to simplify the process of parsing associations between files.
  41  *  Associations in this context means the registry entries that link (for
  42  *  example) the extension of a file with its description, list of
  43  *  applications to open the file with, and actions that can be performed on it
  44  *  (the shell displays such information in the context menu of explorer
  45  *  when you right-click on a file).
  46  *
  47  * HELPERS
  48  * You can use this object transparently by calling the helper functions
  49  * AssocQueryKeyA(), AssocQueryStringA() and AssocQueryStringByKeyA(). These
  50  * create an IQueryAssociations object, perform the requested actions
  51  * and then dispose of the object. Alternatively, you can create an instance
  52  * of the object using AssocCreate() and call the following methods on it:
  53  *
  54  * METHODS
  55  */
  56
  57 /* Default IQueryAssociations::Init() flags */
  58 #define SHLWAPI_DEF_ASSOCF (ASSOCF_INIT_BYEXENAME|ASSOCF_INIT_DEFAULTTOSTAR| \
  59                             ASSOCF_INIT_DEFAULTTOFOLDER)
  60
  61 typedef struct
  62 {
  63   const IQueryAssociationsVtbl *lpVtbl;
  64   LONG ref;
  65   HKEY hkeySource;
  66   HKEY hkeyProgID;
  67 } IQueryAssociationsImpl;
  68
  69 static const IQueryAssociationsVtbl IQueryAssociations_vtbl;
  70
  71 /**************************************************************************
  72  *  IQueryAssociations_Constructor [internal]
  73  *
  74  * Construct a new IQueryAssociations object.
  75  */
  76 static IQueryAssociations* IQueryAssociations_Constructor(void)
  77 {
  78   IQueryAssociationsImpl* iface;
  79
  80   iface = HeapAlloc(GetProcessHeap(),0,sizeof(IQueryAssociationsImpl));
  81   iface->lpVtbl = &IQueryAssociations_vtbl;
  82   iface->ref = 1;
  83   iface->hkeySource = NULL;
  84   iface->hkeyProgID = NULL;
  85
  86   TRACE("Returning IQueryAssociations* %p\n", iface);
  87   return (IQueryAssociations*)iface;
  88 }
  89
  90 /*************************************************************************
  91  * SHLWAPI_ParamAToW
  92  *
  93  * Internal helper function: Convert ASCII parameter to Unicode.
  94  */
  95 static BOOL SHLWAPI_ParamAToW(LPCSTR lpszParam, LPWSTR lpszBuff, DWORD dwLen,
  96                               LPWSTR* lpszOut)
  97 {
  98   if (lpszParam)
  99   {
 100     DWORD dwStrLen = MultiByteToWideChar(CP_ACP, 0, lpszParam, -1, NULL, 0);
 101
 102     if (dwStrLen < dwLen)
 103     {
 104       *lpszOut = lpszBuff; /* Use Buffer, it is big enough */
 105     }
 106     else
 107     {
 108       /* Create a new buffer big enough for the string */
 109       *lpszOut = HeapAlloc(GetProcessHeap(), 0,
 110                                    dwStrLen * sizeof(WCHAR));
 111       if (!*lpszOut)
 112         return FALSE;
 113     }
 114     MultiByteToWideChar(CP_ACP, 0, lpszParam, -1, *lpszOut, dwStrLen);
 115   }
 116   else
 117     *lpszOut = NULL;
 118   return TRUE;
 119 }
 120
 121 /*************************************************************************
 122  * AssocCreate  [SHLWAPI.@]
 123  *
 124  * Create a new IQueryAssociations object.
 125  *
 126  * PARAMS
 127  *  clsid       [I] CLSID of object
 128  *  refiid      [I] REFIID of interface
 129  *  lpInterface [O] Destination for the created IQueryAssociations object
 130  *
 131  * RETURNS
 132  *  Success: S_OK. lpInterface contains the new object.
 133  *  Failure: An HRESULT error code indicating the error.
 134  *
 135  * NOTES
 136  *  refiid must be equal to IID_IQueryAssociations, or this function will fail.
 137  */
 138 HRESULT WINAPI AssocCreate(CLSID clsid, REFIID refiid, void **lpInterface)
 139 {
 140   HRESULT hRet;
 141   IQueryAssociations* lpAssoc;
 142
 143   TRACE("(%s,%s,%p)\n", debugstr_guid(&clsid), debugstr_guid(refiid),
 144         lpInterface);
 145
 146   if (!lpInterface)
 147     return E_INVALIDARG;
 148
 149   *(DWORD*)lpInterface = 0;
 150
 151   if (!IsEqualGUID(&clsid, &IID_IQueryAssociations))
 152     return E_NOTIMPL;
 153
 154   lpAssoc = IQueryAssociations_Constructor();
 155
 156   if (!lpAssoc)
 157     return E_OUTOFMEMORY;
 158
 159   hRet = IQueryAssociations_QueryInterface(lpAssoc, refiid, lpInterface);
 160   IQueryAssociations_Release(lpAssoc);
 161   return hRet;
 162 }
 163
 164 /*************************************************************************
 165  * AssocQueryKeyW  [SHLWAPI.@]
 166  *
 167  * See AssocQueryKeyA.
 168  */
 169 HRESULT WINAPI AssocQueryKeyW(ASSOCF cfFlags, ASSOCKEY assockey, LPCWSTR pszAssoc,
 170                               LPCWSTR pszExtra, HKEY *phkeyOut)
 171 {
 172   HRESULT hRet;
 173   IQueryAssociations* lpAssoc;
 174
 175   TRACE("(0x%8x,0x%8x,%s,%s,%p)\n", cfFlags, assockey, debugstr_w(pszAssoc),
 176         debugstr_w(pszExtra), phkeyOut);
 177
 178   lpAssoc = IQueryAssociations_Constructor();
 179
 180   if (!lpAssoc)
 181     return E_OUTOFMEMORY;
 182
 183   cfFlags &= SHLWAPI_DEF_ASSOCF;
 184   hRet = IQueryAssociations_Init(lpAssoc, cfFlags, pszAssoc, NULL, NULL);
 185
 186   if (SUCCEEDED(hRet))
 187     hRet = IQueryAssociations_GetKey(lpAssoc, cfFlags, assockey, pszExtra, phkeyOut);
 188
 189   IQueryAssociations_Release(lpAssoc);
 190   return hRet;
 191 }
 192
 193 /*************************************************************************
 194  * AssocQueryKeyA  [SHLWAPI.@]
 195  *
 196  * Get a file association key from the registry.
 197  *
 198  * PARAMS
 199  *  cfFlags  [I] ASSOCF_ flags from "shlwapi.h"
 200  *  assockey [I] Type of key to get
 201  *  pszAssoc [I] Key name to search below
 202  *  pszExtra [I] Extra information about the key location
 203  *  phkeyOut [O] Destination for the association key
 204  *
 205  * RETURNS
 206  *  Success: S_OK. phkeyOut contains the key.
 207  *  Failure: An HRESULT error code indicating the error.
 208  */
 209 HRESULT WINAPI AssocQueryKeyA(ASSOCF cfFlags, ASSOCKEY assockey, LPCSTR pszAssoc,
 210                               LPCSTR pszExtra, HKEY *phkeyOut)
 211 {
 212   WCHAR szAssocW[MAX_PATH], *lpszAssocW = NULL;
 213   WCHAR szExtraW[MAX_PATH], *lpszExtraW = NULL;
 214   HRESULT hRet = E_OUTOFMEMORY;
 215
 216   TRACE("(0x%8x,0x%8x,%s,%s,%p)\n", cfFlags, assockey, debugstr_a(pszAssoc),
 217         debugstr_a(pszExtra), phkeyOut);
 218
 219   if (SHLWAPI_ParamAToW(pszAssoc, szAssocW, MAX_PATH, &lpszAssocW) &&
 220       SHLWAPI_ParamAToW(pszExtra, szExtraW, MAX_PATH, &lpszExtraW))
 221   {
 222     hRet = AssocQueryKeyW(cfFlags, assockey, lpszAssocW, lpszExtraW, phkeyOut);
 223   }
 224
 225   if (lpszAssocW != szAssocW)
 226     HeapFree(GetProcessHeap(), 0, lpszAssocW);
 227
 228   if (lpszExtraW != szExtraW)
 229     HeapFree(GetProcessHeap(), 0, lpszExtraW);
 230
 231   return hRet;
 232 }
 233
 234 /*************************************************************************
 235  * AssocQueryStringW  [SHLWAPI.@]
 236  *
 237  * See AssocQueryStringA.
 238  */
 239 HRESULT WINAPI AssocQueryStringW(ASSOCF cfFlags, ASSOCSTR str, LPCWSTR pszAssoc,
 240                                  LPCWSTR pszExtra, LPWSTR pszOut, DWORD *pcchOut)
 241 {
 242   HRESULT hRet;
 243   IQueryAssociations* lpAssoc;
 244
 245   TRACE("(0x%8x,0x%8x,%s,%s,%p,%p)\n", cfFlags, str, debugstr_w(pszAssoc),
 246         debugstr_w(pszExtra), pszOut, pcchOut);
 247
 248   if (!pcchOut)
 249     return E_UNEXPECTED;
 250
 251   lpAssoc = IQueryAssociations_Constructor();
 252
 253   if (!lpAssoc)
 254     return E_OUTOFMEMORY;
 255
 256   hRet = IQueryAssociations_Init(lpAssoc, cfFlags & SHLWAPI_DEF_ASSOCF,
 257                                  pszAssoc, NULL, NULL);
 258
 259   if (SUCCEEDED(hRet))
 260     hRet = IQueryAssociations_GetString(lpAssoc, cfFlags, str, pszExtra,
 261                                         pszOut, pcchOut);
 262
 263   IQueryAssociations_Release(lpAssoc);
 264   return hRet;
 265 }
 266
 267 /*************************************************************************
 268  * AssocQueryStringA  [SHLWAPI.@]
 269  *
 270  * Get a file association string from the registry.
 271  *
 272  * PARAMS
 273  *  cfFlags  [I] ASSOCF_ flags from "shlwapi.h"
 274  *  str      [I] Type of string to get (ASSOCSTR enum from "shlwapi.h")
 275  *  pszAssoc [I] Key name to search below
 276  *  pszExtra [I] Extra information about the string location
 277  *  pszOut   [O] Destination for the association string
 278  *  pcchOut  [O] Length of pszOut
 279  *
 280  * RETURNS
 281  *  Success: S_OK. pszOut contains the string, pcchOut contains its length.
 282  *  Failure: An HRESULT error code indicating the error.
 283  */
 284 HRESULT WINAPI AssocQueryStringA(ASSOCF cfFlags, ASSOCSTR str, LPCSTR pszAssoc,
 285                                  LPCSTR pszExtra, LPSTR pszOut, DWORD *pcchOut)
 286 {
 287   WCHAR szAssocW[MAX_PATH], *lpszAssocW = NULL;
 288   WCHAR szExtraW[MAX_PATH], *lpszExtraW = NULL;
 289   HRESULT hRet = E_OUTOFMEMORY;
 290
 291   TRACE("(0x%8x,0x%8x,%s,%s,%p,%p)\n", cfFlags, str, debugstr_a(pszAssoc),
 292         debugstr_a(pszExtra), pszOut, pcchOut);
 293
 294   if (!pcchOut)
 295     hRet = E_UNEXPECTED;
 296   else if (SHLWAPI_ParamAToW(pszAssoc, szAssocW, MAX_PATH, &lpszAssocW) &&
 297            SHLWAPI_ParamAToW(pszExtra, szExtraW, MAX_PATH, &lpszExtraW))
 298   {
 299     WCHAR szReturnW[MAX_PATH], *lpszReturnW = szReturnW;
 300     DWORD dwLenOut = *pcchOut;
 301
 302     if (dwLenOut >= MAX_PATH)
 303       lpszReturnW = HeapAlloc(GetProcessHeap(), 0,
 304                                       (dwLenOut + 1) * sizeof(WCHAR));
 305
 306     if (!lpszReturnW)
 307       hRet = E_OUTOFMEMORY;
 308     else
 309     {
 310       hRet = AssocQueryStringW(cfFlags, str, lpszAssocW, lpszExtraW,
 311                                lpszReturnW, &dwLenOut);
 312
 313       if (SUCCEEDED(hRet))
 314         WideCharToMultiByte(CP_ACP,0,szReturnW,-1,pszOut,dwLenOut,0,0);
 315       *pcchOut = dwLenOut;
 316
 317       if (lpszReturnW != szReturnW)
 318         HeapFree(GetProcessHeap(), 0, lpszReturnW);
 319     }
 320   }
 321
 322   if (lpszAssocW != szAssocW)
 323     HeapFree(GetProcessHeap(), 0, lpszAssocW);
 324   if (lpszExtraW != szExtraW)
 325     HeapFree(GetProcessHeap(), 0, lpszExtraW);
 326   return hRet;
 327 }
 328
 329 /*************************************************************************
 330  * AssocQueryStringByKeyW  [SHLWAPI.@]
 331  *
 332  * See AssocQueryStringByKeyA.
 333  */
 334 HRESULT WINAPI AssocQueryStringByKeyW(ASSOCF cfFlags, ASSOCSTR str, HKEY hkAssoc,
 335                                       LPCWSTR pszExtra, LPWSTR pszOut,
 336                                       DWORD *pcchOut)
 337 {
 338   HRESULT hRet;
 339   IQueryAssociations* lpAssoc;
 340
 341   TRACE("(0x%8x,0x%8x,%p,%s,%p,%p)\n", cfFlags, str, hkAssoc,
 342         debugstr_w(pszExtra), pszOut, pcchOut);
 343
 344   lpAssoc = IQueryAssociations_Constructor();
 345
 346   if (!lpAssoc)
 347     return E_OUTOFMEMORY;
 348
 349   cfFlags &= SHLWAPI_DEF_ASSOCF;
 350   hRet = IQueryAssociations_Init(lpAssoc, cfFlags, 0, hkAssoc, NULL);
 351
 352   if (SUCCEEDED(hRet))
 353     hRet = IQueryAssociations_GetString(lpAssoc, cfFlags, str, pszExtra,
 354                                         pszOut, pcchOut);
 355
 356   IQueryAssociations_Release(lpAssoc);
 357   return hRet;
 358 }
 359
 360 /*************************************************************************
 361  * AssocQueryStringByKeyA  [SHLWAPI.@]
 362  *
 363  * Get a file association string from the registry, given a starting key.
 364  *
 365  * PARAMS
 366  *  cfFlags  [I] ASSOCF_ flags from "shlwapi.h"
 367  *  str      [I] Type of string to get
 368  *  hkAssoc  [I] Key to search below
 369  *  pszExtra [I] Extra information about the string location
 370  *  pszOut   [O] Destination for the association string
 371  *  pcchOut  [O] Length of pszOut
 372  *
 373  * RETURNS
 374  *  Success: S_OK. pszOut contains the string, pcchOut contains its length.
 375  *  Failure: An HRESULT error code indicating the error.
 376  */
 377 HRESULT WINAPI AssocQueryStringByKeyA(ASSOCF cfFlags, ASSOCSTR str, HKEY hkAssoc,
 378                                       LPCSTR pszExtra, LPSTR pszOut,
 379                                       DWORD *pcchOut)
 380 {
 381   WCHAR szExtraW[MAX_PATH], *lpszExtraW = szExtraW;
 382   WCHAR szReturnW[MAX_PATH], *lpszReturnW = szReturnW;
 383   HRESULT hRet = E_OUTOFMEMORY;
 384
 385   TRACE("(0x%8x,0x%8x,%p,%s,%p,%p)\n", cfFlags, str, hkAssoc,
 386         debugstr_a(pszExtra), pszOut, pcchOut);
 387
 388   if (!pcchOut)
 389     hRet = E_INVALIDARG;
 390   else if (SHLWAPI_ParamAToW(pszExtra, szExtraW, MAX_PATH, &lpszExtraW))
 391   {
 392     DWORD dwLenOut = *pcchOut;
 393     if (dwLenOut >= MAX_PATH)
 394       lpszReturnW = HeapAlloc(GetProcessHeap(), 0,
 395                                       (dwLenOut + 1) * sizeof(WCHAR));
 396
 397     if (lpszReturnW)
 398     {
 399       hRet = AssocQueryStringByKeyW(cfFlags, str, hkAssoc, lpszExtraW,
 400                                     lpszReturnW, &dwLenOut);
 401
 402       if (SUCCEEDED(hRet))
 403         WideCharToMultiByte(CP_ACP,0,szReturnW,-1,pszOut,dwLenOut,0,0);
 404       *pcchOut = dwLenOut;
 405
 406       if (lpszReturnW != szReturnW)
 407         HeapFree(GetProcessHeap(), 0, lpszReturnW);
 408     }
 409   }
 410
 411   if (lpszExtraW != szExtraW)
 412     HeapFree(GetProcessHeap(), 0, lpszExtraW);
 413   return hRet;
 414 }
 415
 416
 417 /**************************************************************************
 418  *  AssocIsDangerous  (SHLWAPI.@)
 419  *
 420  * Determine if a file association is dangerous (potentially malware).
 421  *
 422  * PARAMS
 423  *  lpszAssoc [I] Name of file or file extension to check.
 424  *
 425  * RETURNS
 426  *  TRUE, if lpszAssoc may potentially be malware (executable),
 427  *  FALSE, Otherwise.
 428  */
 429 BOOL WINAPI AssocIsDangerous(LPCWSTR lpszAssoc)
 430 {
 431     FIXME("%s\n", debugstr_w(lpszAssoc));
 432     return FALSE;
 433 }
 434
 435 /**************************************************************************
 436  *  IQueryAssociations_QueryInterface {SHLWAPI}
 437  *
 438  * See IUnknown_QueryInterface.
 439  */
 440 static HRESULT WINAPI IQueryAssociations_fnQueryInterface(
 441   IQueryAssociations* iface,
 442   REFIID riid,
 443   LPVOID *ppvObj)
 444 {
 445   IQueryAssociationsImpl *This = (IQueryAssociationsImpl *)iface;
 446
 447   TRACE("(%p,%s,%p)\n",This, debugstr_guid(riid), ppvObj);
 448
 449   *ppvObj = NULL;
 450
 451   if (IsEqualIID(riid, &IID_IUnknown) ||
 452       IsEqualIID(riid, &IID_IQueryAssociations))
 453   {
 454     *ppvObj = (IQueryAssociations*)This;
 455
 456     IQueryAssociations_AddRef((IQueryAssociations*)*ppvObj);
 457     TRACE("Returning IQueryAssociations (%p)\n", *ppvObj);
 458     return S_OK;
 459   }
 460   TRACE("Returning E_NOINTERFACE\n");
 461   return E_NOINTERFACE;
 462 }
 463
 464 /**************************************************************************
 465  *  IQueryAssociations_AddRef {SHLWAPI}
 466  *
 467  * See IUnknown_AddRef.
 468  */
 469 static ULONG WINAPI IQueryAssociations_fnAddRef(IQueryAssociations *iface)
 470 {
 471   IQueryAssociationsImpl *This = (IQueryAssociationsImpl *)iface;
 472   ULONG refCount = InterlockedIncrement(&This->ref);
 473
 474   TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
 475
 476   return refCount;
 477 }
 478
 479 /**************************************************************************
 480  *  IQueryAssociations_Release {SHLWAPI}
 481  *
 482  * See IUnknown_Release.
 483  */
 484 static ULONG WINAPI IQueryAssociations_fnRelease(IQueryAssociations *iface)
 485 {
 486   IQueryAssociationsImpl *This = (IQueryAssociationsImpl *)iface;
 487   ULONG refCount = InterlockedDecrement(&This->ref);
 488
 489   TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
 490
 491   if (!refCount)
 492   {
 493     TRACE("Destroying IQueryAssociations (%p)\n", This);
 494     RegCloseKey(This->hkeySource);
 495     RegCloseKey(This->hkeyProgID);
 496     HeapFree(GetProcessHeap(), 0, This);
 497   }
 498
 499   return refCount;
 500 }
 501
 502 /**************************************************************************
 503  *  IQueryAssociations_Init {SHLWAPI}
 504  *
 505  * Initialise an IQueryAssociations object.
 506  *
 507  * PARAMS
 508  *  iface      [I] IQueryAssociations interface to initialise
 509  *  cfFlags    [I] ASSOCF_ flags from "shlwapi.h"
 510  *  pszAssoc   [I] String for the root key name, or NULL if hkeyProgid is given
 511  *  hkeyProgid [I] Handle for the root key, or NULL if pszAssoc is given
 512  *  hWnd       [I] Reserved, must be NULL.
 513  *
 514  * RETURNS
 515  *  Success: S_OK. iface is initialised with the parameters given.
 516  *  Failure: An HRESULT error code indicating the error.
 517  */
 518 static HRESULT WINAPI IQueryAssociations_fnInit(
 519   IQueryAssociations *iface,
 520   ASSOCF cfFlags,
 521   LPCWSTR pszAssoc,
 522   HKEY hkeyProgid,
 523   HWND hWnd)
 524 {
 525     static const WCHAR szProgID[] = {'P','r','o','g','I','D',0};
 526     IQueryAssociationsImpl *This = (IQueryAssociationsImpl *)iface;
 527     LONG ret;
 528
 529     TRACE("(%p)->(%d,%s,%p,%p)\n", iface,
 530                                     cfFlags,
 531                                     debugstr_w(pszAssoc),
 532                                     hkeyProgid,
 533                                     hWnd);
 534     if (hWnd != NULL)
 535         FIXME("hwnd != NULL not supported\n");
 536     if (cfFlags != 0)
 537         FIXME("unsupported flags: %x\n", cfFlags);
 538     if (pszAssoc != NULL)
 539     {
 540         ret = RegOpenKeyExW(HKEY_CLASSES_ROOT,
 541                             pszAssoc,
 542                             0,
 543                             KEY_READ,
 544                             &This->hkeySource);
 545         if (ret != ERROR_SUCCESS)
 546             return E_FAIL;
 547         /* if this is not a prog id */
 548         if ((*pszAssoc == '.') || (*pszAssoc == '{'))
 549         {
 550             RegOpenKeyExW(This->hkeySource,
 551                           szProgID,
 552                           0,
 553                           KEY_READ,
 554                           &This->hkeyProgID);
 555         }
 556         else
 557             This->hkeyProgID = This->hkeySource;
 558         return S_OK;
 559     }
 560     else if (hkeyProgid != NULL)
 561     {
 562         This->hkeyProgID = hkeyProgid;
 563         return S_OK;
 564     }
 565     else
 566         return E_INVALIDARG;
 567 }
 568
 569 static HRESULT ASSOC_GetValue(HKEY hkey, WCHAR ** pszText)
 570 {
 571   DWORD len;
 572   LONG ret;
 573
 574   assert(pszText);
 575   ret = RegQueryValueExW(hkey, NULL, 0, NULL, NULL, &len);
 576   if (ret != ERROR_SUCCESS)
 577     return HRESULT_FROM_WIN32(ret);
 578   if (!len)
 579     return E_FAIL;
 580   *pszText = HeapAlloc(GetProcessHeap(), 0, len);
 581   if (!*pszText)
 582     return E_OUTOFMEMORY;
 583   ret = RegQueryValueExW(hkey, NULL, 0, NULL, (LPBYTE)*pszText,
 584                          &len);
 585   if (ret != ERROR_SUCCESS)
 586   {
 587     HeapFree(GetProcessHeap(), 0, *pszText);
 588     return HRESULT_FROM_WIN32(ret);
 589   }
 590   return S_OK;
 591 }
 592
 593 static HRESULT ASSOC_GetExecutable(IQueryAssociationsImpl *This,
 594                                    LPCWSTR pszExtra, LPWSTR path,
 595                                    DWORD pathlen, DWORD *len)
 596 {
 597   HKEY hkeyCommand;
 598   HKEY hkeyFile;
 599   HKEY hkeyShell;
 600   HKEY hkeyVerb;
 601   HRESULT hr;
 602   LONG ret;
 603   WCHAR * pszCommand;
 604   WCHAR * pszEnd;
 605   WCHAR * pszExtraFromReg;
 606   WCHAR * pszFileType;
 607   WCHAR * pszStart;
 608   static const WCHAR commandW[] = { 'c','o','m','m','a','n','d',0 };
 609   static const WCHAR shellW[] = { 's','h','e','l','l',0 };
 610
 611   assert(len);
 612
 613   hr = ASSOC_GetValue(This->hkeySource, &pszFileType);
 614   if (FAILED(hr))
 615     return hr;
 616   ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, pszFileType, 0, KEY_READ, &hkeyFile);
 617   HeapFree(GetProcessHeap(), 0, pszFileType);
 618   if (ret != ERROR_SUCCESS)
 619     return HRESULT_FROM_WIN32(ret);
 620
 621   ret = RegOpenKeyExW(hkeyFile, shellW, 0, KEY_READ, &hkeyShell);
 622   RegCloseKey(hkeyFile);
 623   if (ret != ERROR_SUCCESS)
 624     return HRESULT_FROM_WIN32(ret);
 625
 626   if (!pszExtra)
 627   {
 628     hr = ASSOC_GetValue(hkeyShell, &pszExtraFromReg);
 629     if (FAILED(hr))
 630     {
 631       RegCloseKey(hkeyShell);
 632       return hr;
 633     }
 634   }
 635
 636   ret = RegOpenKeyExW(hkeyShell, pszExtra ? pszExtra : pszExtraFromReg, 0,
 637                       KEY_READ, &hkeyVerb);
 638   HeapFree(GetProcessHeap(), 0, pszExtraFromReg);
 639   RegCloseKey(hkeyShell);
 640   if (ret != ERROR_SUCCESS)
 641     return HRESULT_FROM_WIN32(ret);
 642
 643   ret = RegOpenKeyExW(hkeyVerb, commandW, 0, KEY_READ, &hkeyCommand);
 644   RegCloseKey(hkeyVerb);
 645   if (ret != ERROR_SUCCESS)
 646     return HRESULT_FROM_WIN32(ret);
 647   hr = ASSOC_GetValue(hkeyCommand, &pszCommand);
 648   RegCloseKey(hkeyCommand);
 649   if (FAILED(hr))
 650     return hr;
 651
 652   /* cleanup pszCommand */
 653   if (pszCommand[0] == '"')
 654   {
 655     pszStart = pszCommand + 1;
 656     pszEnd = strchrW(pszStart, '"');
 657   }
 658   else
 659   {
 660     pszStart = pszCommand;
 661     pszEnd = strchrW(pszStart, ' ');
 662   }
 663   if (pszEnd)
 664     *pszEnd = 0;
 665
 666   *len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
 667   HeapFree(GetProcessHeap(), 0, pszCommand);
 668   if (!*len)
 669     return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 670   return S_OK;
 671 }
 672
 673 static HRESULT ASSOC_ReturnData(LPWSTR out, DWORD *outlen, LPCWSTR data,
 674                                 DWORD datalen)
 675 {
 676   assert(outlen);
 677
 678   if (out)
 679   {
 680     if (*outlen < datalen)
 681     {
 682       *outlen = datalen;
 683       return E_POINTER;
 684     }
 685     *outlen = datalen;
 686     lstrcpynW(out, data, datalen);
 687     return S_OK;
 688   }
 689   else
 690   {
 691     *outlen = datalen;
 692     return S_FALSE;
 693   }
 694 }
 695
 696 /**************************************************************************
 697  *  IQueryAssociations_GetString {SHLWAPI}
 698  *
 699  * Get a file association string from the registry.
 700  *
 701  * PARAMS
 702  *  iface    [I]   IQueryAssociations interface to query
 703  *  cfFlags  [I]   ASSOCF_ flags from "shlwapi.h"
 704  *  str      [I]   Type of string to get (ASSOCSTR enum from "shlwapi.h")
 705  *  pszExtra [I]   Extra information about the string location
 706  *  pszOut   [O]   Destination for the association string
 707  *  pcchOut  [I/O] Length of pszOut
 708  *
 709  * RETURNS
 710  *  Success: S_OK. pszOut contains the string, pcchOut contains its length.
 711  *  Failure: An HRESULT error code indicating the error.
 712  */
 713 static HRESULT WINAPI IQueryAssociations_fnGetString(
 714   IQueryAssociations *iface,
 715   ASSOCF cfFlags,
 716   ASSOCSTR str,
 717   LPCWSTR pszExtra,
 718   LPWSTR pszOut,
 719   DWORD *pcchOut)
 720 {
 721   IQueryAssociationsImpl *This = (IQueryAssociationsImpl *)iface;
 722   const ASSOCF cfUnimplemented = ~(0);
 723   DWORD len = 0;
 724   HRESULT hr;
 725   WCHAR path[MAX_PATH];
 726
 727   TRACE("(%p,0x%8x,0x%8x,%s,%p,%p)\n", This, cfFlags, str,
 728         debugstr_w(pszExtra), pszOut, pcchOut);
 729
 730   if (cfFlags & cfUnimplemented)
 731     FIXME("%08x: unimplemented flags!\n", cfFlags & cfUnimplemented);
 732
 733   if (!pcchOut)
 734     return E_UNEXPECTED;
 735
 736   switch (str)
 737   {
 738     case ASSOCSTR_EXECUTABLE:
 739     {
 740       hr = ASSOC_GetExecutable(This, pszExtra, path, MAX_PATH, &len);
 741       if (FAILED(hr))
 742         return hr;
 743       len++;
 744       return ASSOC_ReturnData(pszOut, pcchOut, path, len);
 745       break;
 746     }
 747
 748     default:
 749       FIXME("assocstr %d unimplemented!\n", str);
 750       return E_NOTIMPL;
 751   }
 752 }
 753
 754 /**************************************************************************
 755  *  IQueryAssociations_GetKey {SHLWAPI}
 756  *
 757  * Get a file association key from the registry.
 758  *
 759  * PARAMS
 760  *  iface    [I] IQueryAssociations interface to query
 761  *  cfFlags  [I] ASSOCF_ flags from "shlwapi.h"
 762  *  assockey [I] Type of key to get (ASSOCKEY enum from "shlwapi.h")
 763  *  pszExtra [I] Extra information about the key location
 764  *  phkeyOut [O] Destination for the association key
 765  *
 766  * RETURNS
 767  *  Success: S_OK. phkeyOut contains a handle to the key.
 768  *  Failure: An HRESULT error code indicating the error.
 769  */
 770 static HRESULT WINAPI IQueryAssociations_fnGetKey(
 771   IQueryAssociations *iface,
 772   ASSOCF cfFlags,
 773   ASSOCKEY assockey,
 774   LPCWSTR pszExtra,
 775   HKEY *phkeyOut)
 776 {
 777   IQueryAssociationsImpl *This = (IQueryAssociationsImpl *)iface;
 778
 779   FIXME("(%p,0x%8x,0x%8x,%s,%p)-stub!\n", This, cfFlags, assockey,
 780         debugstr_w(pszExtra), phkeyOut);
 781   return E_NOTIMPL;
 782 }
 783
 784 /**************************************************************************
 785  *  IQueryAssociations_GetData {SHLWAPI}
 786  *
 787  * Get the data for a file association key from the registry.
 788  *
 789  * PARAMS
 790  *  iface     [I]   IQueryAssociations interface to query
 791  *  cfFlags   [I]   ASSOCF_ flags from "shlwapi.h"
 792  *  assocdata [I]   Type of data to get (ASSOCDATA enum from "shlwapi.h")
 793  *  pszExtra  [I]   Extra information about the data location
 794  *  pvOut     [O]   Destination for the association key
 795  *  pcbOut    [I/O] Size of pvOut
 796  *
 797  * RETURNS
 798  *  Success: S_OK. pszOut contains the data, pcbOut contains its length.
 799  *  Failure: An HRESULT error code indicating the error.
 800  */
 801 static HRESULT WINAPI IQueryAssociations_fnGetData(
 802   IQueryAssociations *iface,
 803   ASSOCF cfFlags,
 804   ASSOCDATA assocdata,
 805   LPCWSTR pszExtra,
 806   LPVOID pvOut,
 807   DWORD *pcbOut)
 808 {
 809   IQueryAssociationsImpl *This = (IQueryAssociationsImpl *)iface;
 810
 811   FIXME("(%p,0x%8x,0x%8x,%s,%p,%p)-stub!\n", This, cfFlags, assocdata,
 812         debugstr_w(pszExtra), pvOut, pcbOut);
 813   return E_NOTIMPL;
 814 }
 815
 816 /**************************************************************************
 817  *  IQueryAssociations_GetEnum {SHLWAPI}
 818  *
 819  * Not yet implemented in native Win32.
 820  *
 821  * PARAMS
 822  *  iface     [I] IQueryAssociations interface to query
 823  *  cfFlags   [I] ASSOCF_ flags from "shlwapi.h"
 824  *  assocenum [I] Type of enum to get (ASSOCENUM enum from "shlwapi.h")
 825  *  pszExtra  [I] Extra information about the enum location
 826  *  riid      [I] REFIID to look for
 827  *  ppvOut    [O] Destination for the interface.
 828  *
 829  * RETURNS
 830  *  Success: S_OK.
 831  *  Failure: An HRESULT error code indicating the error.
 832  *
 833  * NOTES
 834  *  Presumably this function returns an enumerator object.
 835  */
 836 static HRESULT WINAPI IQueryAssociations_fnGetEnum(
 837   IQueryAssociations *iface,
 838   ASSOCF cfFlags,
 839   ASSOCENUM assocenum,
 840   LPCWSTR pszExtra,
 841   REFIID riid,
 842   LPVOID *ppvOut)
 843 {
 844   IQueryAssociationsImpl *This = (IQueryAssociationsImpl *)iface;
 845
 846   FIXME("(%p,0x%8x,0x%8x,%s,%s,%p)-stub!\n", This, cfFlags, assocenum,
 847         debugstr_w(pszExtra), debugstr_guid(riid), ppvOut);
 848   return E_NOTIMPL;
 849 }
 850
 851 static const IQueryAssociationsVtbl IQueryAssociations_vtbl =
 852 {
 853   IQueryAssociations_fnQueryInterface,
 854   IQueryAssociations_fnAddRef,
 855   IQueryAssociations_fnRelease,
 856   IQueryAssociations_fnInit,
 857   IQueryAssociations_fnGetString,
 858   IQueryAssociations_fnGetKey,
 859   IQueryAssociations_fnGetData,
 860   IQueryAssociations_fnGetEnum
 861 };