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
  22 #define COBJMACROS
  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 "shobjidl.h"
  31 #include "shell32_main.h"
  32 #include "ver.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  36
  37 /**************************************************************************
  38  *  IQueryAssociations
  39  *
  40  * DESCRIPTION
  41  *  This object provides a layer of abstraction over the system registry in
  42  *  order to simplify the process of parsing associations between files.
  43  *  Associations in this context means the registry entries that link (for
  44  *  example) the extension of a file with its description, list of
  45  *  applications to open the file with, and actions that can be performed on it
  46  *  (the shell displays such information in the context menu of explorer
  47  *  when you right-click on a file).
  48  *
  49  * HELPERS
  50  * You can use this object transparently by calling the helper functions
  51  * AssocQueryKeyA(), AssocQueryStringA() and AssocQueryStringByKeyA(). These
  52  * create an IQueryAssociations object, perform the requested actions
  53  * and then dispose of the object. Alternatively, you can create an instance
  54  * of the object using AssocCreate() and call the following methods on it:
  55  *
  56  * METHODS
  57  */
  58
  59 typedef struct
  60 {
  61   IQueryAssociations IQueryAssociations_iface;
  62   LONG ref;
  63   HKEY hkeySource;
  64   HKEY hkeyProgID;
  65 } IQueryAssociationsImpl;
  66
  67 typedef struct
  68 {
  69   IApplicationAssociationRegistration IApplicationAssociationRegistration_iface;
  70   LONG ref;
  71 } IApplicationAssociationRegistrationImpl;
  72
  73
  74 static inline IQueryAssociationsImpl *impl_from_IQueryAssociations(IQueryAssociations *iface)
  75 {
  76   return CONTAINING_RECORD(iface, IQueryAssociationsImpl, IQueryAssociations_iface);
  77 }
  78
  79 struct enumassochandlers
  80 {
  81     IEnumAssocHandlers IEnumAssocHandlers_iface;
  82     LONG ref;
  83 };
  84
  85 static inline struct enumassochandlers *impl_from_IEnumAssocHandlers(IEnumAssocHandlers *iface)
  86 {
  87   return CONTAINING_RECORD(iface, struct enumassochandlers, IEnumAssocHandlers_iface);
  88 }
  89
  90 static HRESULT ASSOC_GetValue(HKEY hkey, const WCHAR *name, void **data, DWORD *data_size);
  91
  92 /**************************************************************************
  93  *  IQueryAssociations_QueryInterface
  94  *
  95  * See IUnknown_QueryInterface.
  96  */
  97 static HRESULT WINAPI IQueryAssociations_fnQueryInterface(
  98   IQueryAssociations* iface,
  99   REFIID riid,
 100   LPVOID *ppvObj)
 101 {
 102   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
 103
 104   TRACE("(%p,%s,%p)\n",This, debugstr_guid(riid), ppvObj);
 105
 106   if (ppvObj == NULL)
 107       return E_POINTER;
 108
 109   *ppvObj = NULL;
 110
 111   if (IsEqualIID(riid, &IID_IUnknown) ||
 112       IsEqualIID(riid, &IID_IQueryAssociations))
 113   {
 114     *ppvObj = &This->IQueryAssociations_iface;
 115
 116     IQueryAssociations_AddRef((IQueryAssociations*)*ppvObj);
 117     TRACE("Returning IQueryAssociations (%p)\n", *ppvObj);
 118     return S_OK;
 119   }
 120   TRACE("Returning E_NOINTERFACE\n");
 121   return E_NOINTERFACE;
 122 }
 123
 124 /**************************************************************************
 125  *  IQueryAssociations_AddRef
 126  *
 127  * See IUnknown_AddRef.
 128  */
 129 static ULONG WINAPI IQueryAssociations_fnAddRef(IQueryAssociations *iface)
 130 {
 131   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
 132   ULONG refCount = InterlockedIncrement(&This->ref);
 133
 134   TRACE("(%p)->(ref before=%lu)\n",This, refCount - 1);
 135
 136   return refCount;
 137 }
 138
 139 /**************************************************************************
 140  *  IQueryAssociations_Release
 141  *
 142  * See IUnknown_Release.
 143  */
 144 static ULONG WINAPI IQueryAssociations_fnRelease(IQueryAssociations *iface)
 145 {
 146   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
 147   ULONG refCount = InterlockedDecrement(&This->ref);
 148
 149   TRACE("(%p)->(ref before=%lu)\n",This, refCount + 1);
 150
 151   if (!refCount)
 152   {
 153     TRACE("Destroying IQueryAssociations (%p)\n", This);
 154     RegCloseKey(This->hkeySource);
 155     RegCloseKey(This->hkeyProgID);
 156     SHFree(This);
 157   }
 158
 159   return refCount;
 160 }
 161
 162 /**************************************************************************
 163  *  IQueryAssociations_Init
 164  *
 165  * Initialise an IQueryAssociations object.
 166  *
 167  * PARAMS
 168  *  iface      [I] IQueryAssociations interface to initialise
 169  *  cfFlags    [I] ASSOCF_ flags from "shlwapi.h"
 170  *  pszAssoc   [I] String for the root key name, or NULL if hkeyProgid is given
 171  *  hkeyProgid [I] Handle for the root key, or NULL if pszAssoc is given
 172  *  hWnd       [I] Reserved, must be NULL.
 173  *
 174  * RETURNS
 175  *  Success: S_OK. iface is initialised with the parameters given.
 176  *  Failure: An HRESULT error code indicating the error.
 177  */
 178 static HRESULT WINAPI IQueryAssociations_fnInit(
 179   IQueryAssociations *iface,
 180   ASSOCF cfFlags,
 181   LPCWSTR pszAssoc,
 182   HKEY hkeyProgid,
 183   HWND hWnd)
 184 {
 185     IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
 186     LONG ret;
 187
 188     TRACE("(%p)->(%ld,%s,%p,%p)\n", iface,
 189                                     cfFlags,
 190                                     debugstr_w(pszAssoc),
 191                                     hkeyProgid,
 192                                     hWnd);
 193     if (hWnd != NULL)
 194         FIXME("hwnd != NULL not supported\n");
 195     if (cfFlags != 0)
 196         FIXME("unsupported flags: %lx\n", cfFlags);
 197
 198     RegCloseKey(This->hkeySource);
 199     if (This->hkeySource != This->hkeyProgID)
 200         RegCloseKey(This->hkeyProgID);
 201     This->hkeySource = This->hkeyProgID = NULL;
 202
 203     /* If the process of initializing hkeyProgID fails, just return S_OK. That's what Windows does. */
 204     if (pszAssoc != NULL)
 205     {
 206         WCHAR *progId;
 207         HRESULT hr;
 208
 209         ret = RegOpenKeyExW(HKEY_CLASSES_ROOT,
 210                             pszAssoc,
 211                             0,
 212                             KEY_READ,
 213                             &This->hkeySource);
 214         if (ret)
 215             return S_OK;
 216         /* if this is a progid */
 217         if (*pszAssoc != '.' && *pszAssoc != '{')
 218         {
 219             This->hkeyProgID = This->hkeySource;
 220             return S_OK;
 221         }
 222
 223         /* if it's not a progid, it's a file extension or clsid */
 224         if (*pszAssoc == '.')
 225         {
 226             /* for a file extension, the progid is the default value */
 227             hr = ASSOC_GetValue(This->hkeySource, NULL, (void**)&progId, NULL);
 228             if (FAILED(hr))
 229                 return S_OK;
 230         }
 231         else /* if (*pszAssoc == '{') */
 232         {
 233             HKEY progIdKey;
 234             /* for a clsid, the progid is the default value of the ProgID subkey */
 235             ret = RegOpenKeyExW(This->hkeySource, L"ProgID", 0, KEY_READ, &progIdKey);
 236             if (ret != ERROR_SUCCESS)
 237                 return S_OK;
 238             hr = ASSOC_GetValue(progIdKey, NULL, (void**)&progId, NULL);
 239             if (FAILED(hr))
 240                 return S_OK;
 241             RegCloseKey(progIdKey);
 242         }
 243
 244         /* open the actual progid key, the one with the shell subkey */
 245         ret = RegOpenKeyExW(HKEY_CLASSES_ROOT,
 246                             progId,
 247                             0,
 248                             KEY_READ,
 249                             &This->hkeyProgID);
 250         heap_free(progId);
 251
 252         return S_OK;
 253     }
 254     else if (hkeyProgid != NULL)
 255     {
 256         /* reopen the key so we don't end up closing a key owned by the caller */
 257         RegOpenKeyExW(hkeyProgid, NULL, 0, KEY_READ, &This->hkeyProgID);
 258         This->hkeySource = This->hkeyProgID;
 259         return S_OK;
 260     }
 261     else
 262         return E_INVALIDARG;
 263 }
 264
 265 static HRESULT ASSOC_GetValue(HKEY hkey, const WCHAR *name, void **data, DWORD *data_size)
 266 {
 267   DWORD size;
 268   LONG ret;
 269
 270   ret = RegQueryValueExW(hkey, name, 0, NULL, NULL, &size);
 271   if (ret != ERROR_SUCCESS)
 272     return HRESULT_FROM_WIN32(ret);
 273   if (!size)
 274     return E_FAIL;
 275   *data = heap_alloc(size);
 276   if (!*data)
 277     return E_OUTOFMEMORY;
 278   ret = RegQueryValueExW(hkey, name, 0, NULL, (LPBYTE)*data, &size);
 279   if (ret != ERROR_SUCCESS)
 280   {
 281     heap_free(*data);
 282     return HRESULT_FROM_WIN32(ret);
 283   }
 284   if(data_size)
 285       *data_size = size;
 286   return S_OK;
 287 }
 288
 289 static HRESULT ASSOC_GetCommand(IQueryAssociationsImpl *This, const WCHAR *extra, WCHAR **command)
 290 {
 291   HKEY hkeyCommand;
 292   HKEY hkeyShell;
 293   HKEY hkeyVerb;
 294   HRESULT hr;
 295   LONG ret;
 296   WCHAR *extra_from_reg = NULL;
 297   WCHAR *filetype;
 298
 299   /* When looking for file extension it's possible to have a default value
 300      that points to another key that contains 'shell/<verb>/command' subtree. */
 301   hr = ASSOC_GetValue(This->hkeySource, NULL, (void**)&filetype, NULL);
 302   if (hr == S_OK)
 303   {
 304       HKEY hkeyFile;
 305
 306       ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, filetype, 0, KEY_READ, &hkeyFile);
 307       heap_free(filetype);
 308
 309       if (ret == ERROR_SUCCESS)
 310       {
 311           ret = RegOpenKeyExW(hkeyFile, L"shell", 0, KEY_READ, &hkeyShell);
 312           RegCloseKey(hkeyFile);
 313       }
 314       else
 315           ret = RegOpenKeyExW(This->hkeySource, L"shell", 0, KEY_READ, &hkeyShell);
 316   }
 317   else
 318       ret = RegOpenKeyExW(This->hkeySource, L"shell", 0, KEY_READ, &hkeyShell);
 319
 320   if (ret) return HRESULT_FROM_WIN32(ret);
 321
 322   if (!extra)
 323   {
 324       /* check for default verb */
 325       hr = ASSOC_GetValue(hkeyShell, NULL, (void**)&extra_from_reg, NULL);
 326       if (FAILED(hr))
 327       {
 328           /* no default verb, try first subkey */
 329           DWORD max_subkey_len;
 330
 331           ret = RegQueryInfoKeyW(hkeyShell, NULL, NULL, NULL, NULL, &max_subkey_len, NULL, NULL, NULL, NULL, NULL, NULL);
 332           if (ret)
 333           {
 334               RegCloseKey(hkeyShell);
 335               return HRESULT_FROM_WIN32(ret);
 336           }
 337
 338           max_subkey_len++;
 339           extra_from_reg = heap_alloc(max_subkey_len * sizeof(WCHAR));
 340           if (!extra_from_reg)
 341           {
 342               RegCloseKey(hkeyShell);
 343               return E_OUTOFMEMORY;
 344           }
 345
 346           ret = RegEnumKeyExW(hkeyShell, 0, extra_from_reg, &max_subkey_len, NULL, NULL, NULL, NULL);
 347           if (ret)
 348           {
 349               heap_free(extra_from_reg);
 350               RegCloseKey(hkeyShell);
 351               return HRESULT_FROM_WIN32(ret);
 352           }
 353       }
 354       extra = extra_from_reg;
 355   }
 356
 357   /* open verb subkey */
 358   ret = RegOpenKeyExW(hkeyShell, extra, 0, KEY_READ, &hkeyVerb);
 359   heap_free(extra_from_reg);
 360   RegCloseKey(hkeyShell);
 361   if (ret) return HRESULT_FROM_WIN32(ret);
 362
 363   /* open command subkey */
 364   ret = RegOpenKeyExW(hkeyVerb, L"command", 0, KEY_READ, &hkeyCommand);
 365   RegCloseKey(hkeyVerb);
 366   if (ret) return HRESULT_FROM_WIN32(ret);
 367
 368   hr = ASSOC_GetValue(hkeyCommand, NULL, (void**)command, NULL);
 369   RegCloseKey(hkeyCommand);
 370   return hr;
 371 }
 372
 373 static HRESULT ASSOC_GetExecutable(IQueryAssociationsImpl *This,
 374                                    LPCWSTR pszExtra, LPWSTR path,
 375                                    DWORD pathlen, DWORD *len)
 376 {
 377   WCHAR *pszCommand;
 378   WCHAR *pszStart;
 379   WCHAR *pszEnd;
 380   HRESULT hr;
 381
 382   hr = ASSOC_GetCommand(This, pszExtra, &pszCommand);
 383   if (FAILED(hr))
 384     return hr;
 385
 386   /* cleanup pszCommand */
 387   if (pszCommand[0] == '"')
 388   {
 389     pszStart = pszCommand + 1;
 390     pszEnd = wcschr(pszStart, '"');
 391     if (pszEnd)
 392       *pszEnd = 0;
 393     *len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
 394   }
 395   else
 396   {
 397     pszStart = pszCommand;
 398     for (pszEnd = pszStart; (pszEnd = wcschr(pszEnd, ' ')); pszEnd++)
 399     {
 400       WCHAR c = *pszEnd;
 401       *pszEnd = 0;
 402       if ((*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL)))
 403         break;
 404       *pszEnd = c;
 405     }
 406     if (!pszEnd)
 407       *len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
 408   }
 409
 410   heap_free(pszCommand);
 411   if (!*len)
 412     return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 413   return S_OK;
 414 }
 415
 416 static HRESULT ASSOC_ReturnData(void *out, DWORD *outlen, const void *data,
 417                                 DWORD datalen)
 418 {
 419   if (out)
 420   {
 421     if (*outlen < datalen)
 422     {
 423       *outlen = datalen;
 424       return E_POINTER;
 425     }
 426     *outlen = datalen;
 427     memcpy(out, data, datalen);
 428     return S_OK;
 429   }
 430   else
 431   {
 432     *outlen = datalen;
 433     return S_FALSE;
 434   }
 435 }
 436
 437 static HRESULT ASSOC_ReturnString(ASSOCF flags, LPWSTR out, DWORD *outlen, LPCWSTR data, DWORD datalen)
 438 {
 439     HRESULT hr = S_OK;
 440     DWORD len;
 441
 442     TRACE("flags=0x%08lx, data=%s\n", flags, debugstr_w(data));
 443
 444     if (!out)
 445     {
 446         *outlen = datalen;
 447         return S_FALSE;
 448     }
 449
 450     if (*outlen < datalen)
 451     {
 452         if (flags & ASSOCF_NOTRUNCATE)
 453         {
 454             len = 0;
 455             if (*outlen > 0) out[0] = 0;
 456             hr = E_POINTER;
 457         }
 458         else
 459         {
 460             len = min(*outlen, datalen);
 461             hr = E_NOT_SUFFICIENT_BUFFER;
 462         }
 463         *outlen = datalen;
 464     }
 465     else
 466         len = datalen;
 467
 468     if (len)
 469         memcpy(out, data, len*sizeof(WCHAR));
 470
 471     return hr;
 472 }
 473
 474 /**************************************************************************
 475  *  IQueryAssociations_GetString
 476  *
 477  * Get a file association string from the registry.
 478  *
 479  * PARAMS
 480  *  iface    [I]   IQueryAssociations interface to query
 481  *  cfFlags  [I]   ASSOCF_ flags from "shlwapi.h"
 482  *  str      [I]   Type of string to get (ASSOCSTR enum from "shlwapi.h")
 483  *  pszExtra [I]   Extra information about the string location
 484  *  pszOut   [O]   Destination for the association string
 485  *  pcchOut  [I/O] Length of pszOut
 486  *
 487  * RETURNS
 488  *  Success: S_OK. pszOut contains the string, pcchOut contains its length.
 489  *  Failure: An HRESULT error code indicating the error.
 490  */
 491 static HRESULT WINAPI IQueryAssociations_fnGetString(
 492   IQueryAssociations *iface,
 493   ASSOCF flags,
 494   ASSOCSTR str,
 495   LPCWSTR pszExtra,
 496   LPWSTR pszOut,
 497   DWORD *pcchOut)
 498 {
 499   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
 500   const ASSOCF unimplemented_flags = ~ASSOCF_NOTRUNCATE;
 501   DWORD len = 0;
 502   HRESULT hr;
 503   WCHAR path[MAX_PATH];
 504
 505   TRACE("(%p)->(0x%08lx, %u, %s, %p, %p)\n", This, flags, str, debugstr_w(pszExtra), pszOut, pcchOut);
 506
 507   if (flags & unimplemented_flags)
 508     FIXME("%08lx: unimplemented flags\n", flags & unimplemented_flags);
 509
 510   if (!pcchOut)
 511     return E_UNEXPECTED;
 512
 513   if (!This->hkeySource && !This->hkeyProgID)
 514     return HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
 515
 516   switch (str)
 517   {
 518     case ASSOCSTR_COMMAND:
 519     {
 520       WCHAR *command;
 521       hr = ASSOC_GetCommand(This, pszExtra, &command);
 522       if (SUCCEEDED(hr))
 523       {
 524         hr = ASSOC_ReturnString(flags, pszOut, pcchOut, command, lstrlenW(command) + 1);
 525         heap_free(command);
 526       }
 527       return hr;
 528     }
 529
 530     case ASSOCSTR_EXECUTABLE:
 531     {
 532       hr = ASSOC_GetExecutable(This, pszExtra, path, MAX_PATH, &len);
 533       if (FAILED(hr))
 534         return hr;
 535       len++;
 536       return ASSOC_ReturnString(flags, pszOut, pcchOut, path, len);
 537     }
 538
 539     case ASSOCSTR_FRIENDLYDOCNAME:
 540     {
 541       WCHAR *docName;
 542
 543       hr = ASSOC_GetValue(This->hkeyProgID, NULL, (void**)&docName, NULL);
 544       if (FAILED(hr)) {
 545           /* hKeyProgID is NULL or there is no default value, so fail */
 546           return HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
 547       }
 548       hr = ASSOC_ReturnString(flags, pszOut, pcchOut, docName, lstrlenW(docName) + 1);
 549       heap_free(docName);
 550       return hr;
 551     }
 552
 553     case ASSOCSTR_FRIENDLYAPPNAME:
 554     {
 555       PVOID verinfoW = NULL;
 556       DWORD size, retval = 0;
 557       UINT flen;
 558       WCHAR *bufW;
 559       WCHAR fileDescW[41];
 560
 561       hr = ASSOC_GetExecutable(This, pszExtra, path, MAX_PATH, &len);
 562       if (FAILED(hr))
 563         return hr;
 564
 565       retval = GetFileVersionInfoSizeW(path, &size);
 566       if (!retval)
 567         goto get_friendly_name_fail;
 568       verinfoW = heap_alloc_zero(retval);
 569       if (!verinfoW)
 570         return E_OUTOFMEMORY;
 571       if (!GetFileVersionInfoW(path, 0, retval, verinfoW))
 572         goto get_friendly_name_fail;
 573       if (VerQueryValueW(verinfoW, L"\\VarFileInfo\\Translation", (LPVOID *)&bufW, &flen))
 574       {
 575         UINT i;
 576         DWORD *langCodeDesc = (DWORD *)bufW;
 577         for (i = 0; i < flen / sizeof(DWORD); i++)
 578         {
 579           swprintf(fileDescW, ARRAY_SIZE(fileDescW), L"\\StringFileInfo\\%04x%04x\\FileDescription",
 580                    LOWORD(langCodeDesc[i]), HIWORD(langCodeDesc[i]));
 581           if (VerQueryValueW(verinfoW, fileDescW, (LPVOID *)&bufW, &flen))
 582           {
 583             /* Does lstrlenW(bufW) == 0 mean we use the filename? */
 584             len = lstrlenW(bufW) + 1;
 585             TRACE("found FileDescription: %s\n", debugstr_w(bufW));
 586             hr = ASSOC_ReturnString(flags, pszOut, pcchOut, bufW, len);
 587             heap_free(verinfoW);
 588             return hr;
 589           }
 590         }
 591       }
 592 get_friendly_name_fail:
 593       PathRemoveExtensionW(path);
 594       PathStripPathW(path);
 595       TRACE("using filename: %s\n", debugstr_w(path));
 596       hr = ASSOC_ReturnString(flags, pszOut, pcchOut, path, lstrlenW(path) + 1);
 597       heap_free(verinfoW);
 598       return hr;
 599     }
 600
 601     case ASSOCSTR_CONTENTTYPE:
 602     {
 603       WCHAR *contentType;
 604       DWORD ret;
 605       DWORD size;
 606
 607       size = 0;
 608       ret = RegGetValueW(This->hkeySource, NULL, L"Content Type", RRF_RT_REG_SZ, NULL, NULL, &size);
 609       if (ret != ERROR_SUCCESS)
 610         return HRESULT_FROM_WIN32(ret);
 611       contentType = heap_alloc(size);
 612       if (contentType != NULL)
 613       {
 614         ret = RegGetValueW(This->hkeySource, NULL, L"Content Type", RRF_RT_REG_SZ, NULL, contentType, &size);
 615         if (ret == ERROR_SUCCESS)
 616           hr = ASSOC_ReturnString(flags, pszOut, pcchOut, contentType, lstrlenW(contentType) + 1);
 617         else
 618           hr = HRESULT_FROM_WIN32(ret);
 619         heap_free(contentType);
 620       }
 621       else
 622         hr = E_OUTOFMEMORY;
 623       return hr;
 624     }
 625
 626     case ASSOCSTR_DEFAULTICON:
 627     {
 628       DWORD ret;
 629       DWORD size;
 630
 631       size = 0;
 632       ret = RegGetValueW(This->hkeyProgID, L"DefaultIcon", NULL, RRF_RT_REG_SZ, NULL, NULL, &size);
 633       if (ret == ERROR_SUCCESS)
 634       {
 635         WCHAR *icon = heap_alloc(size);
 636         if (icon)
 637         {
 638           ret = RegGetValueW(This->hkeyProgID, L"DefaultIcon", NULL, RRF_RT_REG_SZ, NULL, icon, &size);
 639           if (ret == ERROR_SUCCESS)
 640             hr = ASSOC_ReturnString(flags, pszOut, pcchOut, icon, lstrlenW(icon) + 1);
 641           else
 642             hr = HRESULT_FROM_WIN32(ret);
 643           heap_free(icon);
 644         }
 645         else
 646           hr = E_OUTOFMEMORY;
 647       } else {
 648           /* there is no DefaultIcon subkey or hkeyProgID is NULL, so return the default document icon */
 649           if (This->hkeyProgID == NULL)
 650               hr = ASSOC_ReturnString(flags, pszOut, pcchOut, L"shell32.dll,0", lstrlenW(L"shell32.dll,0") + 1);
 651           else
 652               return HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
 653       }
 654       return hr;
 655     }
 656     case ASSOCSTR_SHELLEXTENSION:
 657     {
 658         WCHAR keypath[ARRAY_SIZE(L"ShellEx\\") + 39], guid[39];
 659         CLSID clsid;
 660         HKEY hkey;
 661         DWORD size;
 662         LONG ret;
 663
 664         hr = CLSIDFromString(pszExtra, &clsid);
 665         if (FAILED(hr)) return hr;
 666
 667         lstrcpyW(keypath, L"ShellEx\\");
 668         lstrcatW(keypath, pszExtra);
 669         ret = RegOpenKeyExW(This->hkeySource, keypath, 0, KEY_READ, &hkey);
 670         if (ret) return HRESULT_FROM_WIN32(ret);
 671
 672         size = sizeof(guid);
 673         ret = RegGetValueW(hkey, NULL, NULL, RRF_RT_REG_SZ, NULL, guid, &size);
 674         RegCloseKey(hkey);
 675         if (ret) return HRESULT_FROM_WIN32(ret);
 676
 677         return ASSOC_ReturnString(flags, pszOut, pcchOut, guid, size / sizeof(WCHAR));
 678     }
 679
 680     default:
 681       FIXME("assocstr %d unimplemented!\n", str);
 682       return E_NOTIMPL;
 683   }
 684 }
 685
 686 /**************************************************************************
 687  *  IQueryAssociations_GetKey
 688  *
 689  * Get a file association key from the registry.
 690  *
 691  * PARAMS
 692  *  iface    [I] IQueryAssociations interface to query
 693  *  cfFlags  [I] ASSOCF_ flags from "shlwapi.h"
 694  *  assockey [I] Type of key to get (ASSOCKEY enum from "shlwapi.h")
 695  *  pszExtra [I] Extra information about the key location
 696  *  phkeyOut [O] Destination for the association key
 697  *
 698  * RETURNS
 699  *  Success: S_OK. phkeyOut contains a handle to the key.
 700  *  Failure: An HRESULT error code indicating the error.
 701  */
 702 static HRESULT WINAPI IQueryAssociations_fnGetKey(
 703   IQueryAssociations *iface,
 704   ASSOCF cfFlags,
 705   ASSOCKEY assockey,
 706   LPCWSTR pszExtra,
 707   HKEY *phkeyOut)
 708 {
 709   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
 710
 711   FIXME("(%p,0x%8lx,0x%8x,%s,%p)-stub!\n", This, cfFlags, assockey,
 712         debugstr_w(pszExtra), phkeyOut);
 713   return E_NOTIMPL;
 714 }
 715
 716 /**************************************************************************
 717  *  IQueryAssociations_GetData
 718  *
 719  * Get the data for a file association key from the registry.
 720  *
 721  * PARAMS
 722  *  iface     [I]   IQueryAssociations interface to query
 723  *  cfFlags   [I]   ASSOCF_ flags from "shlwapi.h"
 724  *  assocdata [I]   Type of data to get (ASSOCDATA enum from "shlwapi.h")
 725  *  pszExtra  [I]   Extra information about the data location
 726  *  pvOut     [O]   Destination for the association key
 727  *  pcbOut    [I/O] Size of pvOut
 728  *
 729  * RETURNS
 730  *  Success: S_OK. pszOut contains the data, pcbOut contains its length.
 731  *  Failure: An HRESULT error code indicating the error.
 732  */
 733 static HRESULT WINAPI IQueryAssociations_fnGetData(IQueryAssociations *iface,
 734         ASSOCF cfFlags, ASSOCDATA assocdata, LPCWSTR pszExtra, LPVOID pvOut,
 735         DWORD *pcbOut)
 736 {
 737     IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
 738     void *data = NULL;
 739     DWORD size;
 740     HRESULT hres;
 741
 742     TRACE("(%p,0x%8lx,0x%8x,%s,%p,%p)\n", This, cfFlags, assocdata,
 743             debugstr_w(pszExtra), pvOut, pcbOut);
 744
 745     if(cfFlags)
 746         FIXME("Unsupported flags: %lx\n", cfFlags);
 747
 748     switch(assocdata) {
 749     case ASSOCDATA_EDITFLAGS:
 750         if(!This->hkeyProgID)
 751             return HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
 752
 753         hres = ASSOC_GetValue(This->hkeyProgID, L"EditFlags", &data, &size);
 754         if(SUCCEEDED(hres) && pcbOut)
 755             hres = ASSOC_ReturnData(pvOut, pcbOut, data, size);
 756         heap_free(data);
 757         return hres;
 758     default:
 759         FIXME("Unsupported ASSOCDATA value: %d\n", assocdata);
 760         return E_NOTIMPL;
 761     }
 762 }
 763
 764 /**************************************************************************
 765  *  IQueryAssociations_GetEnum
 766  *
 767  * Not yet implemented in native Win32.
 768  *
 769  * PARAMS
 770  *  iface     [I] IQueryAssociations interface to query
 771  *  cfFlags   [I] ASSOCF_ flags from "shlwapi.h"
 772  *  assocenum [I] Type of enum to get (ASSOCENUM enum from "shlwapi.h")
 773  *  pszExtra  [I] Extra information about the enum location
 774  *  riid      [I] REFIID to look for
 775  *  ppvOut    [O] Destination for the interface.
 776  *
 777  * RETURNS
 778  *  Success: S_OK.
 779  *  Failure: An HRESULT error code indicating the error.
 780  *
 781  * NOTES
 782  *  Presumably this function returns an enumerator object.
 783  */
 784 static HRESULT WINAPI IQueryAssociations_fnGetEnum(
 785   IQueryAssociations *iface,
 786   ASSOCF cfFlags,
 787   ASSOCENUM assocenum,
 788   LPCWSTR pszExtra,
 789   REFIID riid,
 790   LPVOID *ppvOut)
 791 {
 792   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
 793
 794   FIXME("(%p,0x%8lx,0x%8x,%s,%s,%p)-stub!\n", This, cfFlags, assocenum,
 795         debugstr_w(pszExtra), debugstr_guid(riid), ppvOut);
 796   return E_NOTIMPL;
 797 }
 798
 799 static const IQueryAssociationsVtbl IQueryAssociations_vtbl =
 800 {
 801   IQueryAssociations_fnQueryInterface,
 802   IQueryAssociations_fnAddRef,
 803   IQueryAssociations_fnRelease,
 804   IQueryAssociations_fnInit,
 805   IQueryAssociations_fnGetString,
 806   IQueryAssociations_fnGetKey,
 807   IQueryAssociations_fnGetData,
 808   IQueryAssociations_fnGetEnum
 809 };
 810
 811 /**************************************************************************
 812  * IApplicationAssociationRegistration implementation
 813  */
 814 static inline IApplicationAssociationRegistrationImpl *impl_from_IApplicationAssociationRegistration(IApplicationAssociationRegistration *iface)
 815 {
 816   return CONTAINING_RECORD(iface, IApplicationAssociationRegistrationImpl, IApplicationAssociationRegistration_iface);
 817 }
 818
 819 static HRESULT WINAPI ApplicationAssociationRegistration_QueryInterface(
 820                         IApplicationAssociationRegistration* iface, REFIID riid, LPVOID *ppv)
 821 {
 822     IApplicationAssociationRegistrationImpl *This = impl_from_IApplicationAssociationRegistration(iface);
 823
 824     TRACE("(%p, %s, %p)\n",This, debugstr_guid(riid), ppv);
 825
 826     if (ppv == NULL)
 827         return E_POINTER;
 828
 829     if (IsEqualGUID(&IID_IUnknown, riid) ||
 830         IsEqualGUID(&IID_IApplicationAssociationRegistration, riid)) {
 831         *ppv = &This->IApplicationAssociationRegistration_iface;
 832         IUnknown_AddRef((IUnknown*)*ppv);
 833         TRACE("returning IApplicationAssociationRegistration: %p\n", *ppv);
 834         return S_OK;
 835     }
 836
 837     *ppv = NULL;
 838     FIXME("(%p)->(%s %p) interface not supported\n", This, debugstr_guid(riid), ppv);
 839     return E_NOINTERFACE;
 840 }
 841
 842 static ULONG WINAPI ApplicationAssociationRegistration_AddRef(IApplicationAssociationRegistration *iface)
 843 {
 844     IApplicationAssociationRegistrationImpl *This = impl_from_IApplicationAssociationRegistration(iface);
 845     ULONG ref = InterlockedIncrement(&This->ref);
 846
 847     TRACE("(%p) ref=%ld\n", This, ref);
 848     return ref;
 849 }
 850
 851 static ULONG WINAPI ApplicationAssociationRegistration_Release(IApplicationAssociationRegistration *iface)
 852 {
 853     IApplicationAssociationRegistrationImpl *This = impl_from_IApplicationAssociationRegistration(iface);
 854     ULONG ref = InterlockedDecrement(&This->ref);
 855
 856     TRACE("(%p) ref=%ld\n", This, ref);
 857
 858     if (!ref) {
 859         SHFree(This);
 860     }
 861     return ref;
 862 }
 863
 864 static HRESULT WINAPI ApplicationAssociationRegistration_QueryCurrentDefault(IApplicationAssociationRegistration *iface, LPCWSTR query,
 865                                                                              ASSOCIATIONTYPE type, ASSOCIATIONLEVEL level, LPWSTR *association)
 866 {
 867     IApplicationAssociationRegistrationImpl *This = impl_from_IApplicationAssociationRegistration(iface);
 868     WCHAR path[MAX_PATH];
 869     DWORD ret, keytype, size;
 870     HKEY hkey = NULL;
 871     HRESULT hr = HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
 872
 873     TRACE("(%p)->(%s, %d, %d, %p)\n", This, debugstr_w(query), type, level, association);
 874
 875     if(!association)
 876         return E_INVALIDARG;
 877
 878     *association = NULL;
 879
 880     if((type == AT_URLPROTOCOL || type == AT_FILEEXTENSION) && !query[0])
 881         return E_INVALIDARG;
 882     else if(type == AT_FILEEXTENSION && query[0] != '.')
 883         return E_INVALIDARG;
 884
 885     if(type == AT_FILEEXTENSION)
 886     {
 887         ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, query, 0, KEY_READ, &hkey);
 888         if(ret == ERROR_SUCCESS)
 889         {
 890             ret = RegGetValueW(hkey, NULL, NULL, RRF_RT_REG_SZ, &keytype, NULL, &size);
 891             if(ret == ERROR_SUCCESS)
 892             {
 893                 *association = CoTaskMemAlloc(size);
 894                 if(*association)
 895                 {
 896                     ret = RegGetValueW(hkey, NULL, NULL, RRF_RT_REG_SZ, &keytype, *association, &size);
 897                     if(ret == ERROR_SUCCESS)
 898                         hr = S_OK;
 899                     else
 900                     {
 901                         CoTaskMemFree(*association);
 902                         *association = NULL;
 903                     }
 904                 }
 905                 else
 906                     hr = E_OUTOFMEMORY;
 907             }
 908         }
 909     }
 910     else
 911     {
 912         ret = RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\Shell\\Associations", 0, KEY_READ, &hkey);
 913         if(ret == ERROR_SUCCESS)
 914         {
 915             if(type == AT_URLPROTOCOL)
 916                 swprintf( path, ARRAY_SIZE(path), L"UrlAssociations\\%s\\UserChoice", query );
 917             else if(type == AT_MIMETYPE)
 918                 swprintf( path, ARRAY_SIZE(path), L"MIMEAssociations\\%s\\UserChoice", query );
 919             else
 920             {
 921                 WARN("Unsupported type (%d).\n", type);
 922                 RegCloseKey(hkey);
 923                 return hr;
 924             }
 925
 926             ret = RegGetValueW(hkey, path, L"Progid", RRF_RT_REG_SZ, &keytype, NULL, &size);
 927             if(ret == ERROR_SUCCESS)
 928             {
 929                 *association = CoTaskMemAlloc(size);
 930                 if(*association)
 931                 {
 932                     ret = RegGetValueW(hkey, path, L"Progid", RRF_RT_REG_SZ, &keytype, *association, &size);
 933                     if(ret == ERROR_SUCCESS)
 934                         hr = S_OK;
 935                     else
 936                     {
 937                         CoTaskMemFree(*association);
 938                         *association = NULL;
 939                     }
 940                 }
 941                 else
 942                     hr = E_OUTOFMEMORY;
 943             }
 944         }
 945     }
 946
 947     RegCloseKey(hkey);
 948
 949     return hr;
 950 }
 951
 952 static HRESULT WINAPI ApplicationAssociationRegistration_QueryAppIsDefault(IApplicationAssociationRegistration* This, LPCWSTR query,
 953                                                                            ASSOCIATIONTYPE type, ASSOCIATIONLEVEL level, LPCWSTR appname, BOOL *is_default)
 954 {
 955     FIXME("(%p)->(%s, %d, %d, %s, %p)\n", This, debugstr_w(query), type, level, debugstr_w(appname), is_default);
 956     return E_NOTIMPL;
 957 }
 958
 959 static HRESULT WINAPI ApplicationAssociationRegistration_QueryAppIsDefaultAll(IApplicationAssociationRegistration* This, ASSOCIATIONLEVEL level,
 960                                                                               LPCWSTR appname, BOOL *is_default)
 961 {
 962     FIXME("(%p)->(%d, %s, %p)\n", This, level, debugstr_w(appname), is_default);
 963     return E_NOTIMPL;
 964 }
 965
 966 static HRESULT WINAPI ApplicationAssociationRegistration_SetAppAsDefault(IApplicationAssociationRegistration* This, LPCWSTR appname,
 967                                                                          LPCWSTR set, ASSOCIATIONTYPE set_type)
 968 {
 969     FIXME("(%p)->(%s, %s, %d)\n", This, debugstr_w(appname), debugstr_w(set), set_type);
 970     return E_NOTIMPL;
 971 }
 972
 973 static HRESULT WINAPI ApplicationAssociationRegistration_SetAppAsDefaultAll(IApplicationAssociationRegistration* This, LPCWSTR appname)
 974 {
 975     FIXME("(%p)->(%s)\n", This, debugstr_w(appname));
 976     return E_NOTIMPL;
 977 }
 978
 979
 980 static HRESULT WINAPI ApplicationAssociationRegistration_ClearUserAssociations(IApplicationAssociationRegistration* This)
 981 {
 982     FIXME("(%p)\n", This);
 983     return E_NOTIMPL;
 984 }
 985
 986
 987 static const IApplicationAssociationRegistrationVtbl IApplicationAssociationRegistration_vtbl =
 988 {
 989     ApplicationAssociationRegistration_QueryInterface,
 990     ApplicationAssociationRegistration_AddRef,
 991     ApplicationAssociationRegistration_Release,
 992     ApplicationAssociationRegistration_QueryCurrentDefault,
 993     ApplicationAssociationRegistration_QueryAppIsDefault,
 994     ApplicationAssociationRegistration_QueryAppIsDefaultAll,
 995     ApplicationAssociationRegistration_SetAppAsDefault,
 996     ApplicationAssociationRegistration_SetAppAsDefaultAll,
 997     ApplicationAssociationRegistration_ClearUserAssociations
 998 };
 999
1000 /**************************************************************************
1001  *  IQueryAssociations_Constructor [internal]
1002  *
1003  * Construct a new IQueryAssociations object.
1004  */
1005 HRESULT WINAPI QueryAssociations_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppOutput)
1006 {
1007     IQueryAssociationsImpl* this;
1008     HRESULT ret;
1009
1010     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
1011
1012     if (!(this = SHAlloc(sizeof(*this)))) return E_OUTOFMEMORY;
1013     this->IQueryAssociations_iface.lpVtbl = &IQueryAssociations_vtbl;
1014     this->ref = 0;
1015     this->hkeySource = 0;
1016     this->hkeyProgID = 0;
1017     if (FAILED(ret = IQueryAssociations_QueryInterface(&this->IQueryAssociations_iface, riid, ppOutput))) SHFree( this );
1018     TRACE("returning %p\n", *ppOutput);
1019     return ret;
1020 }
1021
1022 /**************************************************************************
1023  * ApplicationAssociationRegistration_Constructor [internal]
1024  *
1025  * Construct a IApplicationAssociationRegistration object.
1026  */
1027 HRESULT WINAPI ApplicationAssociationRegistration_Constructor(IUnknown *outer, REFIID riid, LPVOID *ppv)
1028 {
1029     IApplicationAssociationRegistrationImpl *This;
1030     HRESULT hr;
1031
1032     if (outer)
1033         return CLASS_E_NOAGGREGATION;
1034
1035     if (!(This = SHAlloc(sizeof(*This))))
1036         return E_OUTOFMEMORY;
1037
1038     This->IApplicationAssociationRegistration_iface.lpVtbl = &IApplicationAssociationRegistration_vtbl;
1039     This->ref = 0;
1040
1041     hr = IApplicationAssociationRegistration_QueryInterface(&This->IApplicationAssociationRegistration_iface, riid, ppv);
1042     if (FAILED(hr))
1043         SHFree(This);
1044
1045     TRACE("returning 0x%lx with %p\n", hr, *ppv);
1046     return hr;
1047 }
1048
1049 static HRESULT WINAPI enumassochandlers_QueryInterface(IEnumAssocHandlers *iface, REFIID riid, void **obj)
1050 {
1051     struct enumassochandlers *This = impl_from_IEnumAssocHandlers(iface);
1052
1053     TRACE("(%p %s %p)\n", This, debugstr_guid(riid), obj);
1054
1055     if (IsEqualIID(riid, &IID_IEnumAssocHandlers) ||
1056         IsEqualIID(riid, &IID_IUnknown))
1057     {
1058         *obj = iface;
1059         IEnumAssocHandlers_AddRef(iface);
1060         return S_OK;
1061     }
1062
1063     *obj = NULL;
1064     return E_NOINTERFACE;
1065 }
1066
1067 static ULONG WINAPI enumassochandlers_AddRef(IEnumAssocHandlers *iface)
1068 {
1069     struct enumassochandlers *This = impl_from_IEnumAssocHandlers(iface);
1070     ULONG ref = InterlockedIncrement(&This->ref);
1071
1072     TRACE("(%p)->(%lu)\n", This, ref);
1073     return ref;
1074 }
1075
1076 static ULONG WINAPI enumassochandlers_Release(IEnumAssocHandlers *iface)
1077 {
1078     struct enumassochandlers *This = impl_from_IEnumAssocHandlers(iface);
1079     ULONG ref = InterlockedDecrement(&This->ref);
1080
1081     TRACE("(%p)->(%lu)\n", This, ref);
1082
1083     if (!ref)
1084         SHFree(This);
1085
1086     return ref;
1087 }
1088
1089 static HRESULT WINAPI enumassochandlers_Next(IEnumAssocHandlers *iface, ULONG count, IAssocHandler **handlers,
1090     ULONG *fetched)
1091 {
1092     struct enumassochandlers *This = impl_from_IEnumAssocHandlers(iface);
1093
1094     FIXME("(%p)->(%lu %p %p): stub\n", This, count, handlers, fetched);
1095
1096     return E_NOTIMPL;
1097 }
1098
1099 static const IEnumAssocHandlersVtbl enumassochandlersvtbl = {
1100     enumassochandlers_QueryInterface,
1101     enumassochandlers_AddRef,
1102     enumassochandlers_Release,
1103     enumassochandlers_Next
1104 };
1105
1106 /**************************************************************************
1107  * SHCreateAssociationRegistration [SHELL32.@]
1108  */
1109 HRESULT WINAPI SHCreateAssociationRegistration(REFIID riid, LPVOID *ppv)
1110 {
1111     return ApplicationAssociationRegistration_Constructor(NULL, riid, ppv);
1112 }
1113
1114 /**************************************************************************
1115  * SHAssocEnumHandlers            [SHELL32.@]
1116  */
1117 HRESULT WINAPI SHAssocEnumHandlers(const WCHAR *extra, ASSOC_FILTER filter, IEnumAssocHandlers **enumhandlers)
1118 {
1119     struct enumassochandlers *enumassoc;
1120
1121     FIXME("(%s %d %p): stub\n", debugstr_w(extra), filter, enumhandlers);
1122
1123     *enumhandlers = NULL;
1124
1125     enumassoc = SHAlloc(sizeof(*enumassoc));
1126     if (!enumassoc)
1127         return E_OUTOFMEMORY;
1128
1129     enumassoc->IEnumAssocHandlers_iface.lpVtbl = &enumassochandlersvtbl;
1130     enumassoc->ref = 1;
1131
1132     *enumhandlers = &enumassoc->IEnumAssocHandlers_iface;
1133     return S_OK;
1134 }