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