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