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