dlls/shcore/main.c

   1 /*
   2  * Copyright 2002 Jon Griffiths
   3  * Copyright 2016 Sebastian Lackner
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "initguid.h"
  29 #include "ocidl.h"
  30 #include "featurestagingapi.h"
  31 #include "shellscalingapi.h"
  32 #include "shlwapi.h"
  33
  34 #include "wine/debug.h"
  35 #include "wine/heap.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(shcore);
  38
  39 static DWORD shcore_tls;
  40 static IUnknown *process_ref;
  41
  42 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
  43 {
  44     TRACE("%p, %lu, %p.\n", instance, reason, reserved);
  45
  46     switch (reason)
  47     {
  48         case DLL_PROCESS_ATTACH:
  49             DisableThreadLibraryCalls(instance);
  50             shcore_tls = TlsAlloc();
  51             break;
  52         case DLL_PROCESS_DETACH:
  53             if (reserved) break;
  54             if (shcore_tls != TLS_OUT_OF_INDEXES)
  55                 TlsFree(shcore_tls);
  56             break;
  57     }
  58
  59     return TRUE;
  60 }
  61
  62 HRESULT WINAPI GetProcessDpiAwareness(HANDLE process, PROCESS_DPI_AWARENESS *value)
  63 {
  64     if (GetProcessDpiAwarenessInternal( process, (DPI_AWARENESS *)value )) return S_OK;
  65     return HRESULT_FROM_WIN32( GetLastError() );
  66 }
  67
  68 HRESULT WINAPI SetProcessDpiAwareness(PROCESS_DPI_AWARENESS value)
  69 {
  70     if (SetProcessDpiAwarenessInternal( value )) return S_OK;
  71     return HRESULT_FROM_WIN32( GetLastError() );
  72 }
  73
  74 HRESULT WINAPI GetDpiForMonitor(HMONITOR monitor, MONITOR_DPI_TYPE type, UINT *x, UINT *y)
  75 {
  76     if (GetDpiForMonitorInternal( monitor, type, x, y )) return S_OK;
  77     return HRESULT_FROM_WIN32( GetLastError() );
  78 }
  79
  80 HRESULT WINAPI GetScaleFactorForMonitor(HMONITOR monitor, DEVICE_SCALE_FACTOR *scale)
  81 {
  82     FIXME("(%p %p): stub\n", monitor, scale);
  83
  84     *scale = SCALE_100_PERCENT;
  85     return S_OK;
  86 }
  87
  88 DEVICE_SCALE_FACTOR WINAPI GetScaleFactorForDevice(DISPLAY_DEVICE_TYPE device_type)
  89 {
  90     FIXME("%d\n", device_type);
  91
  92     return SCALE_100_PERCENT;
  93 }
  94
  95 HRESULT WINAPI _IStream_Read(IStream *stream, void *dest, ULONG size)
  96 {
  97     ULONG read;
  98     HRESULT hr;
  99
 100     TRACE("%p, %p, %lu.\n", stream, dest, size);
 101
 102     hr = IStream_Read(stream, dest, size, &read);
 103     if (SUCCEEDED(hr) && read != size)
 104         hr = E_FAIL;
 105     return hr;
 106 }
 107
 108 HRESULT WINAPI IStream_Reset(IStream *stream)
 109 {
 110     static const LARGE_INTEGER zero;
 111
 112     TRACE("(%p)\n", stream);
 113
 114     return IStream_Seek(stream, zero, 0, NULL);
 115 }
 116
 117 HRESULT WINAPI IStream_Size(IStream *stream, ULARGE_INTEGER *size)
 118 {
 119     STATSTG statstg;
 120     HRESULT hr;
 121
 122     TRACE("(%p, %p)\n", stream, size);
 123
 124     memset(&statstg, 0, sizeof(statstg));
 125
 126     hr = IStream_Stat(stream, &statstg, STATFLAG_NONAME);
 127
 128     if (SUCCEEDED(hr) && size)
 129         *size = statstg.cbSize;
 130     return hr;
 131 }
 132
 133 HRESULT WINAPI _IStream_Write(IStream *stream, const void *src, ULONG size)
 134 {
 135     ULONG written;
 136     HRESULT hr;
 137
 138     TRACE("%p, %p, %lu.\n", stream, src, size);
 139
 140     hr = IStream_Write(stream, src, size, &written);
 141     if (SUCCEEDED(hr) && written != size)
 142         hr = E_FAIL;
 143
 144     return hr;
 145 }
 146
 147 void WINAPI IUnknown_AtomicRelease(IUnknown **obj)
 148 {
 149     TRACE("(%p)\n", obj);
 150
 151     if (!obj || !*obj)
 152         return;
 153
 154     IUnknown_Release(*obj);
 155     *obj = NULL;
 156 }
 157
 158 HRESULT WINAPI IUnknown_GetSite(IUnknown *unk, REFIID iid, void **site)
 159 {
 160     IObjectWithSite *obj = NULL;
 161     HRESULT hr = E_INVALIDARG;
 162
 163     TRACE("(%p, %s, %p)\n", unk, debugstr_guid(iid), site);
 164
 165     if (unk && iid && site)
 166     {
 167         hr = IUnknown_QueryInterface(unk, &IID_IObjectWithSite, (void **)&obj);
 168         if (SUCCEEDED(hr) && obj)
 169         {
 170             hr = IObjectWithSite_GetSite(obj, iid, site);
 171             IObjectWithSite_Release(obj);
 172         }
 173     }
 174
 175     return hr;
 176 }
 177
 178 HRESULT WINAPI IUnknown_QueryService(IUnknown *obj, REFGUID sid, REFIID iid, void **out)
 179 {
 180     IServiceProvider *provider = NULL;
 181     HRESULT hr;
 182
 183     if (!out)
 184         return E_FAIL;
 185
 186     *out = NULL;
 187
 188     if (!obj)
 189         return E_FAIL;
 190
 191     hr = IUnknown_QueryInterface(obj, &IID_IServiceProvider, (void **)&provider);
 192     if (hr == S_OK && provider)
 193     {
 194         TRACE("Using provider %p.\n", provider);
 195
 196         hr = IServiceProvider_QueryService(provider, sid, iid, out);
 197
 198         TRACE("Provider %p returned %p.\n", provider, *out);
 199
 200         IServiceProvider_Release(provider);
 201     }
 202
 203     return hr;
 204 }
 205
 206 void WINAPI IUnknown_Set(IUnknown **dest, IUnknown *src)
 207 {
 208     TRACE("(%p, %p)\n", dest, src);
 209
 210     IUnknown_AtomicRelease(dest);
 211
 212     if (src)
 213     {
 214         IUnknown_AddRef(src);
 215         *dest = src;
 216     }
 217 }
 218
 219 HRESULT WINAPI IUnknown_SetSite(IUnknown *obj, IUnknown *site)
 220 {
 221     IInternetSecurityManager *sec_manager;
 222     IObjectWithSite *objwithsite;
 223     HRESULT hr;
 224
 225     if (!obj)
 226         return E_FAIL;
 227
 228     hr = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (void **)&objwithsite);
 229     TRACE("ObjectWithSite %p, hr %#lx.\n", objwithsite, hr);
 230     if (SUCCEEDED(hr))
 231     {
 232         hr = IObjectWithSite_SetSite(objwithsite, site);
 233         TRACE("SetSite() hr %#lx.\n", hr);
 234         IObjectWithSite_Release(objwithsite);
 235     }
 236     else
 237     {
 238         hr = IUnknown_QueryInterface(obj, &IID_IInternetSecurityManager, (void **)&sec_manager);
 239         TRACE("InternetSecurityManager %p, hr %#lx.\n", sec_manager, hr);
 240         if (FAILED(hr))
 241             return hr;
 242
 243         hr = IInternetSecurityManager_SetSecuritySite(sec_manager, (IInternetSecurityMgrSite *)site);
 244         TRACE("SetSecuritySite() hr %#lx.\n", hr);
 245         IInternetSecurityManager_Release(sec_manager);
 246     }
 247
 248     return hr;
 249 }
 250
 251 HRESULT WINAPI SetCurrentProcessExplicitAppUserModelID(const WCHAR *appid)
 252 {
 253     FIXME("%s: stub\n", debugstr_w(appid));
 254     return S_OK;
 255 }
 256
 257 HRESULT WINAPI GetCurrentProcessExplicitAppUserModelID(const WCHAR **appid)
 258 {
 259     FIXME("%p: stub\n", appid);
 260     *appid = NULL;
 261     return E_NOTIMPL;
 262 }
 263
 264 /*************************************************************************
 265  * CommandLineToArgvW            [SHCORE.@]
 266  *
 267  * We must interpret the quotes in the command line to rebuild the argv
 268  * array correctly:
 269  * - arguments are separated by spaces or tabs
 270  * - quotes serve as optional argument delimiters
 271  *   '"a b"'   -> 'a b'
 272  * - escaped quotes must be converted back to '"'
 273  *   '\"'      -> '"'
 274  * - consecutive backslashes preceding a quote see their number halved with
 275  *   the remainder escaping the quote:
 276  *   2n   backslashes + quote -> n backslashes + quote as an argument delimiter
 277  *   2n+1 backslashes + quote -> n backslashes + literal quote
 278  * - backslashes that are not followed by a quote are copied literally:
 279  *   'a\b'     -> 'a\b'
 280  *   'a\\b'    -> 'a\\b'
 281  * - in quoted strings, consecutive quotes see their number divided by three
 282  *   with the remainder modulo 3 deciding whether to close the string or not.
 283  *   Note that the opening quote must be counted in the consecutive quotes,
 284  *   that's the (1+) below:
 285  *   (1+) 3n   quotes -> n quotes
 286  *   (1+) 3n+1 quotes -> n quotes plus closes the quoted string
 287  *   (1+) 3n+2 quotes -> n+1 quotes plus closes the quoted string
 288  * - in unquoted strings, the first quote opens the quoted string and the
 289  *   remaining consecutive quotes follow the above rule.
 290  */
 291 WCHAR** WINAPI CommandLineToArgvW(const WCHAR *cmdline, int *numargs)
 292 {
 293     int qcount, bcount;
 294     const WCHAR *s;
 295     WCHAR **argv;
 296     DWORD argc;
 297     WCHAR *d;
 298
 299     if (!numargs)
 300     {
 301         SetLastError(ERROR_INVALID_PARAMETER);
 302         return NULL;
 303     }
 304
 305     if (*cmdline == 0)
 306     {
 307         /* Return the path to the executable */
 308         DWORD len, deslen = MAX_PATH, size;
 309
 310         size = sizeof(WCHAR *) * 2 + deslen * sizeof(WCHAR);
 311         for (;;)
 312         {
 313             if (!(argv = LocalAlloc(LMEM_FIXED, size))) return NULL;
 314             len = GetModuleFileNameW(0, (WCHAR *)(argv + 2), deslen);
 315             if (!len)
 316             {
 317                 LocalFree(argv);
 318                 return NULL;
 319             }
 320             if (len < deslen) break;
 321             deslen *= 2;
 322             size = sizeof(WCHAR *) * 2 + deslen * sizeof(WCHAR);
 323             LocalFree(argv);
 324         }
 325         argv[0] = (WCHAR *)(argv + 2);
 326         argv[1] = NULL;
 327         *numargs = 1;
 328
 329         return argv;
 330     }
 331
 332     /* --- First count the arguments */
 333     argc = 1;
 334     s = cmdline;
 335     /* The first argument, the executable path, follows special rules */
 336     if (*s == '"')
 337     {
 338         /* The executable path ends at the next quote, no matter what */
 339         s++;
 340         while (*s)
 341             if (*s++ == '"')
 342                 break;
 343     }
 344     else
 345     {
 346         /* The executable path ends at the next space, no matter what */
 347         while (*s && *s != ' ' && *s != '\t')
 348             s++;
 349     }
 350     /* skip to the first argument, if any */
 351     while (*s == ' ' || *s == '\t')
 352         s++;
 353     if (*s)
 354         argc++;
 355
 356     /* Analyze the remaining arguments */
 357     qcount = bcount = 0;
 358     while (*s)
 359     {
 360         if ((*s == ' ' || *s == '\t') && qcount == 0)
 361         {
 362             /* skip to the next argument and count it if any */
 363             while (*s == ' ' || *s == '\t')
 364                 s++;
 365             if (*s)
 366                 argc++;
 367             bcount = 0;
 368         }
 369         else if (*s == '\\')
 370         {
 371             /* '\', count them */
 372             bcount++;
 373             s++;
 374         }
 375         else if (*s == '"')
 376         {
 377             /* '"' */
 378             if ((bcount & 1) == 0)
 379                 qcount++; /* unescaped '"' */
 380             s++;
 381             bcount = 0;
 382             /* consecutive quotes, see comment in copying code below */
 383             while (*s == '"')
 384             {
 385                 qcount++;
 386                 s++;
 387             }
 388             qcount = qcount % 3;
 389             if (qcount == 2)
 390                 qcount = 0;
 391         }
 392         else
 393         {
 394             /* a regular character */
 395             bcount = 0;
 396             s++;
 397         }
 398     }
 399
 400     /* Allocate in a single lump, the string array, and the strings that go
 401      * with it. This way the caller can make a single LocalFree() call to free
 402      * both, as per MSDN.
 403      */
 404     argv = LocalAlloc(LMEM_FIXED, (argc + 1) * sizeof(WCHAR *) + (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
 405     if (!argv)
 406         return NULL;
 407
 408     /* --- Then split and copy the arguments */
 409     argv[0] = d = lstrcpyW((WCHAR *)(argv + argc + 1), cmdline);
 410     argc = 1;
 411     /* The first argument, the executable path, follows special rules */
 412     if (*d == '"')
 413     {
 414         /* The executable path ends at the next quote, no matter what */
 415         s = d + 1;
 416         while (*s)
 417         {
 418             if (*s == '"')
 419             {
 420                 s++;
 421                 break;
 422             }
 423             *d++ = *s++;
 424         }
 425     }
 426     else
 427     {
 428         /* The executable path ends at the next space, no matter what */
 429         while (*d && *d != ' ' && *d != '\t')
 430             d++;
 431         s = d;
 432         if (*s)
 433             s++;
 434     }
 435     /* close the executable path */
 436     *d++ = 0;
 437     /* skip to the first argument and initialize it if any */
 438     while (*s == ' ' || *s == '\t')
 439         s++;
 440     if (!*s)
 441     {
 442         /* There are no parameters so we are all done */
 443         argv[argc] = NULL;
 444         *numargs = argc;
 445         return argv;
 446     }
 447
 448     /* Split and copy the remaining arguments */
 449     argv[argc++] = d;
 450     qcount = bcount = 0;
 451     while (*s)
 452     {
 453         if ((*s == ' ' || *s == '\t') && qcount == 0)
 454         {
 455             /* close the argument */
 456             *d++ = 0;
 457             bcount = 0;
 458
 459             /* skip to the next one and initialize it if any */
 460             do {
 461                 s++;
 462             } while (*s == ' ' || *s == '\t');
 463             if (*s)
 464                 argv[argc++] = d;
 465         }
 466         else if (*s=='\\')
 467         {
 468             *d++ = *s++;
 469             bcount++;
 470         }
 471         else if (*s == '"')
 472         {
 473             if ((bcount & 1) == 0)
 474             {
 475                 /* Preceded by an even number of '\', this is half that
 476                  * number of '\', plus a quote which we erase.
 477                  */
 478                 d -= bcount / 2;
 479                 qcount++;
 480             }
 481             else
 482             {
 483                 /* Preceded by an odd number of '\', this is half that
 484                  * number of '\' followed by a '"'
 485                  */
 486                 d = d - bcount / 2 - 1;
 487                 *d++ = '"';
 488             }
 489             s++;
 490             bcount = 0;
 491             /* Now count the number of consecutive quotes. Note that qcount
 492              * already takes into account the opening quote if any, as well as
 493              * the quote that lead us here.
 494              */
 495             while (*s == '"')
 496             {
 497                 if (++qcount == 3)
 498                 {
 499                     *d++ = '"';
 500                     qcount = 0;
 501                 }
 502                 s++;
 503             }
 504             if (qcount == 2)
 505                 qcount = 0;
 506         }
 507         else
 508         {
 509             /* a regular character */
 510             *d++ = *s++;
 511             bcount = 0;
 512         }
 513     }
 514     *d = '\0';
 515     argv[argc] = NULL;
 516     *numargs = argc;
 517
 518     return argv;
 519 }
 520
 521 struct shstream
 522 {
 523     IStream IStream_iface;
 524     LONG refcount;
 525
 526     union
 527     {
 528         struct
 529         {
 530             BYTE *buffer;
 531             DWORD length;
 532             DWORD position;
 533
 534             HKEY hkey;
 535             WCHAR *valuename;
 536         } mem;
 537         struct
 538         {
 539             HANDLE handle;
 540             DWORD mode;
 541             WCHAR *path;
 542         } file;
 543     } u;
 544 };
 545
 546 static inline struct shstream *impl_from_IStream(IStream *iface)
 547 {
 548     return CONTAINING_RECORD(iface, struct shstream, IStream_iface);
 549 }
 550
 551 static HRESULT WINAPI shstream_QueryInterface(IStream *iface, REFIID riid, void **out)
 552 {
 553     struct shstream *stream = impl_from_IStream(iface);
 554
 555     TRACE("(%p)->(%s, %p)\n", stream, debugstr_guid(riid), out);
 556
 557     if (IsEqualIID(riid, &IID_IUnknown) ||
 558         IsEqualIID(riid, &IID_IStream) ||
 559         IsEqualIID(riid, &IID_ISequentialStream))
 560     {
 561         *out = iface;
 562         IStream_AddRef(iface);
 563         return S_OK;
 564     }
 565
 566     *out = NULL;
 567     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 568     return E_NOINTERFACE;
 569 }
 570
 571 static ULONG WINAPI shstream_AddRef(IStream *iface)
 572 {
 573     struct shstream *stream = impl_from_IStream(iface);
 574     ULONG refcount = InterlockedIncrement(&stream->refcount);
 575
 576     TRACE("%p, refcount %lu.\n", iface, refcount);
 577
 578     return refcount;
 579 }
 580
 581 static ULONG WINAPI memstream_Release(IStream *iface)
 582 {
 583     struct shstream *stream = impl_from_IStream(iface);
 584     ULONG refcount = InterlockedDecrement(&stream->refcount);
 585
 586     TRACE("%p, refcount %lu.\n", iface, refcount);
 587
 588     if (!refcount)
 589     {
 590         heap_free(stream->u.mem.buffer);
 591         heap_free(stream);
 592     }
 593
 594     return refcount;
 595 }
 596
 597 static HRESULT WINAPI memstream_Read(IStream *iface, void *buff, ULONG buff_size, ULONG *read_len)
 598 {
 599     struct shstream *stream = impl_from_IStream(iface);
 600     DWORD length;
 601
 602     TRACE("%p, %p, %lu, %p.\n", iface, buff, buff_size, read_len);
 603
 604     if (stream->u.mem.position >= stream->u.mem.length)
 605     {
 606         if (read_len)
 607             *read_len = 0;
 608         return S_FALSE;
 609     }
 610
 611     length = stream->u.mem.length - stream->u.mem.position;
 612     if (buff_size < length)
 613         length = buff_size;
 614
 615     memmove(buff, stream->u.mem.buffer + stream->u.mem.position, length);
 616     stream->u.mem.position += length;
 617
 618     if (read_len)
 619         *read_len = length;
 620
 621     return S_OK;
 622 }
 623
 624 static HRESULT WINAPI memstream_Write(IStream *iface, const void *buff, ULONG buff_size, ULONG *written)
 625 {
 626     struct shstream *stream = impl_from_IStream(iface);
 627     DWORD length = stream->u.mem.position + buff_size;
 628
 629     TRACE("%p, %p, %lu, %p.\n", iface, buff, buff_size, written);
 630
 631     if (length < stream->u.mem.position) /* overflow */
 632         return STG_E_INSUFFICIENTMEMORY;
 633
 634     if (length > stream->u.mem.length)
 635     {
 636         BYTE *buffer = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, stream->u.mem.buffer, length);
 637         if (!buffer)
 638             return STG_E_INSUFFICIENTMEMORY;
 639
 640         stream->u.mem.length = length;
 641         stream->u.mem.buffer = buffer;
 642     }
 643     memmove(stream->u.mem.buffer + stream->u.mem.position, buff, buff_size);
 644     stream->u.mem.position += buff_size; /* adjust pointer */
 645
 646     if (written)
 647         *written = buff_size;
 648
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI memstream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER*new_pos)
 653 {
 654     struct shstream *stream = impl_from_IStream(iface);
 655     LARGE_INTEGER tmp;
 656
 657     TRACE("%p, %s, %ld, %p.\n", iface, wine_dbgstr_longlong(move.QuadPart), origin, new_pos);
 658
 659     if (origin == STREAM_SEEK_SET)
 660         tmp = move;
 661     else if (origin == STREAM_SEEK_CUR)
 662         tmp.QuadPart = stream->u.mem.position + move.QuadPart;
 663     else if (origin == STREAM_SEEK_END)
 664         tmp.QuadPart = stream->u.mem.length + move.QuadPart;
 665     else
 666         return STG_E_INVALIDPARAMETER;
 667
 668     if (tmp.QuadPart < 0)
 669         return STG_E_INVALIDFUNCTION;
 670
 671     /* we cut off the high part here */
 672     stream->u.mem.position = tmp.u.LowPart;
 673
 674     if (new_pos)
 675         new_pos->QuadPart = stream->u.mem.position;
 676     return S_OK;
 677 }
 678
 679 static HRESULT WINAPI memstream_SetSize(IStream *iface, ULARGE_INTEGER new_size)
 680 {
 681     struct shstream *stream = impl_from_IStream(iface);
 682     DWORD length;
 683     BYTE *buffer;
 684
 685     TRACE("(%p, %s)\n", stream, wine_dbgstr_longlong(new_size.QuadPart));
 686
 687     /* we cut off the high part here */
 688     length = new_size.u.LowPart;
 689     buffer = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, stream->u.mem.buffer, length);
 690     if (!buffer)
 691         return STG_E_INSUFFICIENTMEMORY;
 692
 693     stream->u.mem.buffer = buffer;
 694     stream->u.mem.length = length;
 695
 696     return S_OK;
 697 }
 698
 699 static HRESULT WINAPI shstream_CopyTo(IStream *iface, IStream *dest, ULARGE_INTEGER size,
 700         ULARGE_INTEGER *read_len, ULARGE_INTEGER *written)
 701 {
 702     struct shstream *stream = impl_from_IStream(iface);
 703     ULARGE_INTEGER total_read, total_written;
 704     HRESULT hr = S_OK;
 705     BYTE buffer[0x400];
 706
 707     TRACE("(%p, %p, %s, %p, %p)\n", stream, dest, wine_dbgstr_longlong(size.QuadPart), read_len, written);
 708
 709     if (!dest)
 710         return E_POINTER;
 711
 712     total_read.QuadPart = 0;
 713     total_written.QuadPart = 0;
 714
 715     while (size.QuadPart > 0)
 716     {
 717         ULONG chunk_size = size.QuadPart >= sizeof(buffer) ? sizeof(buffer) : size.u.LowPart;
 718         ULONG chunk_read, chunk_written;
 719
 720         hr = IStream_Read(iface, buffer, chunk_size, &chunk_read);
 721         if (FAILED(hr))
 722             break;
 723
 724         total_read.QuadPart += chunk_read;
 725
 726         if (chunk_read)
 727         {
 728             hr = IStream_Write(dest, buffer, chunk_read, &chunk_written);
 729             if (FAILED(hr))
 730                 break;
 731
 732             total_written.QuadPart += chunk_written;
 733         }
 734
 735         if (chunk_read != chunk_size)
 736             size.QuadPart = 0;
 737         else
 738             size.QuadPart -= chunk_read;
 739     }
 740
 741     if (read_len)
 742         read_len->QuadPart = total_read.QuadPart;
 743     if (written)
 744         written->QuadPart = total_written.QuadPart;
 745
 746     return hr;
 747 }
 748
 749 static HRESULT WINAPI shstream_Commit(IStream *iface, DWORD flags)
 750 {
 751     TRACE("%p, %#lx.\n", iface, flags);
 752
 753     /* Commit is not supported by this stream */
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT WINAPI shstream_Revert(IStream *iface)
 758 {
 759     struct shstream *stream = impl_from_IStream(iface);
 760
 761     TRACE("(%p)\n", stream);
 762
 763     /* revert not supported by this stream */
 764     return E_NOTIMPL;
 765 }
 766
 767 static HRESULT WINAPI shstream_LockRegion(IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER size, DWORD lock_type)
 768 {
 769     struct shstream *stream = impl_from_IStream(iface);
 770
 771     TRACE("(%p)\n", stream);
 772
 773     /* lock/unlock not supported by this stream */
 774     return E_NOTIMPL;
 775 }
 776
 777 static HRESULT WINAPI shstream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER size, DWORD lock_type)
 778 {
 779     struct shstream *stream = impl_from_IStream(iface);
 780
 781     TRACE("(%p)\n", stream);
 782
 783     /* lock/unlock not supported by this stream */
 784     return E_NOTIMPL;
 785 }
 786
 787 static HRESULT WINAPI memstream_Stat(IStream *iface, STATSTG *statstg, DWORD flags)
 788 {
 789     struct shstream *stream = impl_from_IStream(iface);
 790
 791     TRACE("%p, %p, %#lx.\n", iface, statstg, flags);
 792
 793     memset(statstg, 0, sizeof(*statstg));
 794     statstg->type = STGTY_STREAM;
 795     statstg->cbSize.QuadPart = stream->u.mem.length;
 796     statstg->grfMode = STGM_READWRITE;
 797
 798     return S_OK;
 799 }
 800
 801 static HRESULT WINAPI shstream_Clone(IStream *iface, IStream **dest)
 802 {
 803     struct shstream *stream = impl_from_IStream(iface);
 804
 805     TRACE("(%p, %p)\n", stream, dest);
 806
 807     *dest = NULL;
 808
 809     /* clone not supported by this stream */
 810     return E_NOTIMPL;
 811 }
 812
 813 static const IStreamVtbl memstreamvtbl =
 814 {
 815     shstream_QueryInterface,
 816     shstream_AddRef,
 817     memstream_Release,
 818     memstream_Read,
 819     memstream_Write,
 820     memstream_Seek,
 821     memstream_SetSize,
 822     shstream_CopyTo,
 823     shstream_Commit,
 824     shstream_Revert,
 825     shstream_LockRegion,
 826     shstream_UnlockRegion,
 827     memstream_Stat,
 828     shstream_Clone,
 829 };
 830
 831 static struct shstream *shstream_create(const IStreamVtbl *vtbl, const BYTE *data, UINT data_len)
 832 {
 833     struct shstream *stream;
 834
 835     if (!data)
 836         data_len = 0;
 837
 838     stream = heap_alloc(sizeof(*stream));
 839     stream->IStream_iface.lpVtbl = vtbl;
 840     stream->refcount = 1;
 841     stream->u.mem.buffer = heap_alloc(data_len);
 842     if (!stream->u.mem.buffer)
 843     {
 844         heap_free(stream);
 845         return NULL;
 846     }
 847     memcpy(stream->u.mem.buffer, data, data_len);
 848     stream->u.mem.length = data_len;
 849     stream->u.mem.position = 0;
 850
 851     return stream;
 852 }
 853
 854 /*************************************************************************
 855  * SHCreateMemStream   [SHCORE.@]
 856  *
 857  * Create an IStream object on a block of memory.
 858  *
 859  * PARAMS
 860  * data     [I] Memory block to create the IStream object on
 861  * data_len [I] Length of data block
 862  *
 863  * RETURNS
 864  * Success: A pointer to the IStream object.
 865  * Failure: NULL, if any parameters are invalid or an error occurs.
 866  *
 867  * NOTES
 868  *  A copy of the memory block is made, it's freed when the stream is released.
 869  */
 870 IStream * WINAPI SHCreateMemStream(const BYTE *data, UINT data_len)
 871 {
 872     struct shstream *stream;
 873
 874     TRACE("(%p, %u)\n", data, data_len);
 875
 876     stream = shstream_create(&memstreamvtbl, data, data_len);
 877     return stream ? &stream->IStream_iface : NULL;
 878 }
 879
 880 static ULONG WINAPI filestream_Release(IStream *iface)
 881 {
 882     struct shstream *stream = impl_from_IStream(iface);
 883     ULONG refcount = InterlockedDecrement(&stream->refcount);
 884
 885     TRACE("%p, refcount %lu.\n", iface, refcount);
 886
 887     if (!refcount)
 888     {
 889         CloseHandle(stream->u.file.handle);
 890         heap_free(stream->u.file.path);
 891         heap_free(stream);
 892     }
 893
 894     return refcount;
 895 }
 896
 897 static HRESULT WINAPI filestream_Read(IStream *iface, void *buff, ULONG size, ULONG *read_len)
 898 {
 899     struct shstream *stream = impl_from_IStream(iface);
 900     DWORD read = 0;
 901
 902     TRACE("%p, %p, %lu, %p.\n", iface, buff, size, read_len);
 903
 904     if (!ReadFile(stream->u.file.handle, buff, size, &read, NULL))
 905     {
 906         WARN("error %ld reading file\n", GetLastError());
 907         return S_FALSE;
 908     }
 909
 910     if (read_len)
 911         *read_len = read;
 912
 913     return read == size ? S_OK : S_FALSE;
 914 }
 915
 916 static HRESULT WINAPI filestream_Write(IStream *iface, const void *buff, ULONG size, ULONG *written)
 917 {
 918     struct shstream *stream = impl_from_IStream(iface);
 919     DWORD written_len = 0;
 920
 921     TRACE("%p, %p, %lu, %p.\n", iface, buff, size, written);
 922
 923     switch (stream->u.file.mode & 0xf)
 924     {
 925         case STGM_WRITE:
 926         case STGM_READWRITE:
 927             break;
 928         default:
 929             return STG_E_ACCESSDENIED;
 930     }
 931
 932     if (!WriteFile(stream->u.file.handle, buff, size, &written_len, NULL))
 933         return HRESULT_FROM_WIN32(GetLastError());
 934
 935     if (written)
 936         *written = written_len;
 937
 938     return S_OK;
 939 }
 940
 941 static HRESULT WINAPI filestream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
 942 {
 943     struct shstream *stream = impl_from_IStream(iface);
 944     DWORD position;
 945
 946     TRACE("%p, %s, %ld, %p.\n", iface, wine_dbgstr_longlong(move.QuadPart), origin, new_pos);
 947
 948     position = SetFilePointer(stream->u.file.handle, move.u.LowPart, NULL, origin);
 949     if (position == INVALID_SET_FILE_POINTER)
 950         return HRESULT_FROM_WIN32(GetLastError());
 951
 952     if (new_pos)
 953     {
 954         new_pos->u.HighPart = 0;
 955         new_pos->u.LowPart = position;
 956     }
 957
 958     return S_OK;
 959 }
 960
 961 static HRESULT WINAPI filestream_SetSize(IStream *iface, ULARGE_INTEGER size)
 962 {
 963     struct shstream *stream = impl_from_IStream(iface);
 964     LARGE_INTEGER origin, move;
 965
 966     TRACE("(%p, %s)\n", stream, wine_dbgstr_longlong(size.QuadPart));
 967
 968     move.QuadPart = 0;
 969     if (!SetFilePointerEx(stream->u.file.handle, move, &origin, FILE_CURRENT))
 970         return E_FAIL;
 971
 972     move.QuadPart = size.QuadPart;
 973     if (!SetFilePointerEx(stream->u.file.handle, move, NULL, FILE_BEGIN))
 974         return E_FAIL;
 975
 976     if (stream->u.file.mode != STGM_READ)
 977     {
 978         if (!SetEndOfFile(stream->u.file.handle))
 979             return E_FAIL;
 980         if (!SetFilePointerEx(stream->u.file.handle, origin, NULL, FILE_BEGIN))
 981             return E_FAIL;
 982     }
 983
 984     return S_OK;
 985 }
 986
 987 static HRESULT WINAPI filestream_CopyTo(IStream *iface, IStream *dest, ULARGE_INTEGER size,
 988         ULARGE_INTEGER *read_len, ULARGE_INTEGER *written)
 989 {
 990     struct shstream *stream = impl_from_IStream(iface);
 991     HRESULT hr = S_OK;
 992     char buff[1024];
 993
 994     TRACE("(%p, %p, %s, %p, %p)\n", stream, dest, wine_dbgstr_longlong(size.QuadPart), read_len, written);
 995
 996     if (read_len)
 997         read_len->QuadPart = 0;
 998     if (written)
 999         written->QuadPart = 0;
1000
1001     if (!dest)
1002         return S_OK;
1003
1004     while (size.QuadPart)
1005     {
1006         ULONG left, read_chunk, written_chunk;
1007
1008         left = size.QuadPart > sizeof(buff) ? sizeof(buff) : size.QuadPart;
1009
1010         /* Read */
1011         hr = IStream_Read(iface, buff, left, &read_chunk);
1012         if (FAILED(hr) || read_chunk == 0)
1013             break;
1014         if (read_len)
1015             read_len->QuadPart += read_chunk;
1016
1017         /* Write */
1018         hr = IStream_Write(dest, buff, read_chunk, &written_chunk);
1019         if (written_chunk)
1020             written->QuadPart += written_chunk;
1021         if (FAILED(hr) || written_chunk != left)
1022             break;
1023
1024         size.QuadPart -= left;
1025     }
1026
1027     return hr;
1028 }
1029
1030 static HRESULT WINAPI filestream_Commit(IStream *iface, DWORD flags)
1031 {
1032     TRACE("%p, %#lx.\n", iface, flags);
1033
1034     return S_OK;
1035 }
1036
1037 static HRESULT WINAPI filestream_Stat(IStream *iface, STATSTG *statstg, DWORD flags)
1038 {
1039     struct shstream *stream = impl_from_IStream(iface);
1040     BY_HANDLE_FILE_INFORMATION fi;
1041
1042     TRACE("%p, %p, %#lx.\n", iface, statstg, flags);
1043
1044     if (!statstg)
1045         return STG_E_INVALIDPOINTER;
1046
1047     memset(&fi, 0, sizeof(fi));
1048     GetFileInformationByHandle(stream->u.file.handle, &fi);
1049
1050     if (flags & STATFLAG_NONAME)
1051         statstg->pwcsName = NULL;
1052     else
1053     {
1054         int len = lstrlenW(stream->u.file.path);
1055         if ((statstg->pwcsName = CoTaskMemAlloc((len + 1) * sizeof(WCHAR))))
1056             memcpy(statstg->pwcsName, stream->u.file.path, (len + 1) * sizeof(WCHAR));
1057     }
1058     statstg->type = 0;
1059     statstg->cbSize.u.LowPart = fi.nFileSizeLow;
1060     statstg->cbSize.u.HighPart = fi.nFileSizeHigh;
1061     statstg->mtime = fi.ftLastWriteTime;
1062     statstg->ctime = fi.ftCreationTime;
1063     statstg->atime = fi.ftLastAccessTime;
1064     statstg->grfMode = stream->u.file.mode;
1065     statstg->grfLocksSupported = 0;
1066     memcpy(&statstg->clsid, &IID_IStream, sizeof(CLSID));
1067     statstg->grfStateBits = 0;
1068     statstg->reserved = 0;
1069
1070     return S_OK;
1071 }
1072
1073 static const IStreamVtbl filestreamvtbl =
1074 {
1075     shstream_QueryInterface,
1076     shstream_AddRef,
1077     filestream_Release,
1078     filestream_Read,
1079     filestream_Write,
1080     filestream_Seek,
1081     filestream_SetSize,
1082     filestream_CopyTo,
1083     filestream_Commit,
1084     shstream_Revert,
1085     shstream_LockRegion,
1086     shstream_UnlockRegion,
1087     filestream_Stat,
1088     shstream_Clone,
1089 };
1090
1091 /*************************************************************************
1092  * SHCreateStreamOnFileEx   [SHCORE.@]
1093  */
1094 HRESULT WINAPI SHCreateStreamOnFileEx(const WCHAR *path, DWORD mode, DWORD attributes,
1095     BOOL create, IStream *template, IStream **ret)
1096 {
1097     DWORD access, share, creation_disposition, len;
1098     struct shstream *stream;
1099     HANDLE hFile;
1100
1101     TRACE("%s, %ld, %#lx, %d, %p, %p)\n", debugstr_w(path), mode, attributes,
1102         create, template, ret);
1103
1104     if (!path || !ret || template)
1105         return E_INVALIDARG;
1106
1107     *ret = NULL;
1108
1109     /* Access */
1110     switch (mode & 0xf)
1111     {
1112         case STGM_WRITE:
1113         case STGM_READWRITE:
1114             access = GENERIC_READ | GENERIC_WRITE;
1115             break;
1116         case STGM_READ:
1117             access = GENERIC_READ;
1118             break;
1119         default:
1120             return E_INVALIDARG;
1121     }
1122
1123     /* Sharing */
1124     switch (mode & 0xf0)
1125     {
1126         case 0:
1127         case STGM_SHARE_DENY_NONE:
1128             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
1129             break;
1130         case STGM_SHARE_DENY_READ:
1131             share = FILE_SHARE_WRITE;
1132             break;
1133         case STGM_SHARE_DENY_WRITE:
1134             share = FILE_SHARE_READ;
1135             break;
1136         case STGM_SHARE_EXCLUSIVE:
1137             share = 0;
1138             break;
1139         default:
1140             return E_INVALIDARG;
1141     }
1142
1143     switch (mode & 0xf000)
1144     {
1145         case STGM_FAILIFTHERE:
1146             creation_disposition = create ? CREATE_NEW : OPEN_EXISTING;
1147             break;
1148         case STGM_CREATE:
1149             creation_disposition = CREATE_ALWAYS;
1150             break;
1151         default:
1152             return E_INVALIDARG;
1153     }
1154
1155     hFile = CreateFileW(path, access, share, NULL, creation_disposition, attributes, 0);
1156     if (hFile == INVALID_HANDLE_VALUE)
1157         return HRESULT_FROM_WIN32(GetLastError());
1158
1159     stream = heap_alloc(sizeof(*stream));
1160     stream->IStream_iface.lpVtbl = &filestreamvtbl;
1161     stream->refcount = 1;
1162     stream->u.file.handle = hFile;
1163     stream->u.file.mode = mode;
1164
1165     len = lstrlenW(path);
1166     stream->u.file.path = heap_alloc((len + 1) * sizeof(WCHAR));
1167     memcpy(stream->u.file.path, path, (len + 1) * sizeof(WCHAR));
1168
1169     *ret = &stream->IStream_iface;
1170
1171     return S_OK;
1172 }
1173
1174 /*************************************************************************
1175  * SHCreateStreamOnFileW   [SHCORE.@]
1176  */
1177 HRESULT WINAPI SHCreateStreamOnFileW(const WCHAR *path, DWORD mode, IStream **stream)
1178 {
1179     TRACE("%s, %#lx, %p.\n", debugstr_w(path), mode, stream);
1180
1181     if (!path || !stream)
1182         return E_INVALIDARG;
1183
1184     if ((mode & (STGM_CONVERT | STGM_DELETEONRELEASE | STGM_TRANSACTED)) != 0)
1185         return E_INVALIDARG;
1186
1187     return SHCreateStreamOnFileEx(path, mode, 0, FALSE, NULL, stream);
1188 }
1189
1190 /*************************************************************************
1191  * SHCreateStreamOnFileA   [SHCORE.@]
1192  */
1193 HRESULT WINAPI SHCreateStreamOnFileA(const char *path, DWORD mode, IStream **stream)
1194 {
1195     WCHAR *pathW;
1196     HRESULT hr;
1197     DWORD len;
1198
1199     TRACE("%s, %#lx, %p.\n", debugstr_a(path), mode, stream);
1200
1201     if (!path)
1202         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
1203
1204     len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
1205     pathW = heap_alloc(len * sizeof(WCHAR));
1206     if (!pathW)
1207         return E_OUTOFMEMORY;
1208
1209     MultiByteToWideChar(CP_ACP, 0, path, -1, pathW, len);
1210     hr = SHCreateStreamOnFileW(pathW, mode, stream);
1211     heap_free(pathW);
1212
1213     return hr;
1214 }
1215
1216 static ULONG WINAPI regstream_Release(IStream *iface)
1217 {
1218     struct shstream *stream = impl_from_IStream(iface);
1219     ULONG refcount = InterlockedDecrement(&stream->refcount);
1220
1221     TRACE("%p, refcount %lu.\n", iface, refcount);
1222
1223     if (!refcount)
1224     {
1225         if (stream->u.mem.hkey)
1226         {
1227             if (stream->u.mem.length)
1228                 RegSetValueExW(stream->u.mem.hkey, stream->u.mem.valuename, 0, REG_BINARY,
1229                         (const BYTE *)stream->u.mem.buffer, stream->u.mem.length);
1230             else
1231                 RegDeleteValueW(stream->u.mem.hkey, stream->u.mem.valuename);
1232             RegCloseKey(stream->u.mem.hkey);
1233         }
1234         CoTaskMemFree(stream->u.mem.valuename);
1235         heap_free(stream->u.mem.buffer);
1236         heap_free(stream);
1237     }
1238
1239     return refcount;
1240 }
1241
1242 static const IStreamVtbl regstreamvtbl =
1243 {
1244     shstream_QueryInterface,
1245     shstream_AddRef,
1246     regstream_Release,
1247     memstream_Read,
1248     memstream_Write,
1249     memstream_Seek,
1250     memstream_SetSize,
1251     shstream_CopyTo,
1252     shstream_Commit,
1253     shstream_Revert,
1254     shstream_LockRegion,
1255     shstream_UnlockRegion,
1256     memstream_Stat,
1257     shstream_Clone,
1258 };
1259
1260 /*************************************************************************
1261  * SHOpenRegStream2W        [SHCORE.@]
1262  */
1263 IStream * WINAPI SHOpenRegStream2W(HKEY hKey, const WCHAR *subkey, const WCHAR *value, DWORD mode)
1264 {
1265     struct shstream *stream;
1266     HKEY hStrKey = NULL;
1267     BYTE *buff = NULL;
1268     DWORD length = 0;
1269     LONG ret;
1270
1271     TRACE("%p, %s, %s, %#lx.\n", hKey, debugstr_w(subkey), debugstr_w(value), mode);
1272
1273     if (mode == STGM_READ)
1274         ret = RegOpenKeyExW(hKey, subkey, 0, KEY_READ, &hStrKey);
1275     else /* in write mode we make sure the subkey exits */
1276         ret = RegCreateKeyExW(hKey, subkey, 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &hStrKey, NULL);
1277
1278     if (ret == ERROR_SUCCESS)
1279     {
1280         if (mode == STGM_READ || mode == STGM_READWRITE)
1281         {
1282             /* read initial data */
1283             ret = RegQueryValueExW(hStrKey, value, 0, 0, 0, &length);
1284             if (ret == ERROR_SUCCESS && length)
1285             {
1286                 buff = heap_alloc(length);
1287                 RegQueryValueExW(hStrKey, value, 0, 0, buff, &length);
1288             }
1289         }
1290
1291         if (!length)
1292             buff = heap_alloc(length);
1293
1294         stream = shstream_create(&regstreamvtbl, buff, length);
1295         heap_free(buff);
1296         if (stream)
1297         {
1298             stream->u.mem.hkey = hStrKey;
1299             SHStrDupW(value, &stream->u.mem.valuename);
1300             return &stream->IStream_iface;
1301         }
1302     }
1303
1304     if (hStrKey)
1305         RegCloseKey(hStrKey);
1306
1307     return NULL;
1308 }
1309
1310 /*************************************************************************
1311  * SHOpenRegStream2A        [SHCORE.@]
1312  */
1313 IStream * WINAPI SHOpenRegStream2A(HKEY hKey, const char *subkey, const char *value, DWORD mode)
1314 {
1315     WCHAR *subkeyW = NULL, *valueW = NULL;
1316     IStream *stream;
1317
1318     TRACE("%p, %s, %s, %#lx.\n", hKey, debugstr_a(subkey), debugstr_a(value), mode);
1319
1320     if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
1321         return NULL;
1322     if (value && FAILED(SHStrDupA(value, &valueW)))
1323     {
1324         CoTaskMemFree(subkeyW);
1325         return NULL;
1326     }
1327
1328     stream = SHOpenRegStream2W(hKey, subkeyW, valueW, mode);
1329     CoTaskMemFree(subkeyW);
1330     CoTaskMemFree(valueW);
1331     return stream;
1332 }
1333
1334 /*************************************************************************
1335  * SHOpenRegStreamA        [SHCORE.@]
1336  */
1337 IStream * WINAPI SHOpenRegStreamA(HKEY hkey, const char *subkey, const char *value, DWORD mode)
1338 {
1339     WCHAR *subkeyW = NULL, *valueW = NULL;
1340     IStream *stream;
1341
1342     TRACE("%p, %s, %s, %#lx.\n", hkey, debugstr_a(subkey), debugstr_a(value), mode);
1343
1344     if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
1345         return NULL;
1346     if (value && FAILED(SHStrDupA(value, &valueW)))
1347     {
1348         CoTaskMemFree(subkeyW);
1349         return NULL;
1350     }
1351
1352     stream = SHOpenRegStreamW(hkey, subkeyW, valueW, mode);
1353     CoTaskMemFree(subkeyW);
1354     CoTaskMemFree(valueW);
1355     return stream;
1356 }
1357
1358 static ULONG WINAPI dummystream_AddRef(IStream *iface)
1359 {
1360     TRACE("()\n");
1361     return 2;
1362 }
1363
1364 static ULONG WINAPI dummystream_Release(IStream *iface)
1365 {
1366     TRACE("()\n");
1367     return 1;
1368 }
1369
1370 static HRESULT WINAPI dummystream_Read(IStream *iface, void *buff, ULONG buff_size, ULONG *read_len)
1371 {
1372     if (read_len)
1373         *read_len = 0;
1374
1375     return E_NOTIMPL;
1376 }
1377
1378 static const IStreamVtbl dummystreamvtbl =
1379 {
1380     shstream_QueryInterface,
1381     dummystream_AddRef,
1382     dummystream_Release,
1383     dummystream_Read,
1384     memstream_Write,
1385     memstream_Seek,
1386     memstream_SetSize,
1387     shstream_CopyTo,
1388     shstream_Commit,
1389     shstream_Revert,
1390     shstream_LockRegion,
1391     shstream_UnlockRegion,
1392     memstream_Stat,
1393     shstream_Clone,
1394 };
1395
1396 static struct shstream dummyregstream = { { &dummystreamvtbl } };
1397
1398 /*************************************************************************
1399  * SHOpenRegStreamW        [SHCORE.@]
1400  */
1401 IStream * WINAPI SHOpenRegStreamW(HKEY hkey, const WCHAR *subkey, const WCHAR *value, DWORD mode)
1402 {
1403     IStream *stream;
1404
1405     TRACE("%p, %s, %s, %#lx.\n", hkey, debugstr_w(subkey), debugstr_w(value), mode);
1406     stream = SHOpenRegStream2W(hkey, subkey, value, mode);
1407     return stream ? stream : &dummyregstream.IStream_iface;
1408 }
1409
1410 struct threadref
1411 {
1412     IUnknown IUnknown_iface;
1413     LONG *refcount;
1414 };
1415
1416 static inline struct threadref *threadref_impl_from_IUnknown(IUnknown *iface)
1417 {
1418     return CONTAINING_RECORD(iface, struct threadref, IUnknown_iface);
1419 }
1420
1421 static HRESULT WINAPI threadref_QueryInterface(IUnknown *iface, REFIID riid, void **out)
1422 {
1423     struct threadref *threadref = threadref_impl_from_IUnknown(iface);
1424
1425     TRACE("(%p, %s, %p)\n", threadref, debugstr_guid(riid), out);
1426
1427     if (out == NULL)
1428         return E_POINTER;
1429
1430     if (IsEqualGUID(&IID_IUnknown, riid))
1431     {
1432         *out = iface;
1433         IUnknown_AddRef(iface);
1434         return S_OK;
1435     }
1436
1437     *out = NULL;
1438     WARN("Interface %s not supported.\n", debugstr_guid(riid));
1439     return E_NOINTERFACE;
1440 }
1441
1442 static ULONG WINAPI threadref_AddRef(IUnknown *iface)
1443 {
1444     struct threadref *threadref = threadref_impl_from_IUnknown(iface);
1445     LONG refcount = InterlockedIncrement(threadref->refcount);
1446
1447     TRACE("%p, refcount %ld.\n", threadref, refcount);
1448
1449     return refcount;
1450 }
1451
1452 static ULONG WINAPI threadref_Release(IUnknown *iface)
1453 {
1454     struct threadref *threadref = threadref_impl_from_IUnknown(iface);
1455     LONG refcount = InterlockedDecrement(threadref->refcount);
1456
1457     TRACE("%p, refcount %ld.\n", threadref, refcount);
1458
1459     if (!refcount)
1460         heap_free(threadref);
1461
1462     return refcount;
1463 }
1464
1465 static const IUnknownVtbl threadrefvtbl =
1466 {
1467     threadref_QueryInterface,
1468     threadref_AddRef,
1469     threadref_Release,
1470 };
1471
1472 /*************************************************************************
1473  * SHCreateThreadRef        [SHCORE.@]
1474  */
1475 HRESULT WINAPI SHCreateThreadRef(LONG *refcount, IUnknown **out)
1476 {
1477     struct threadref *threadref;
1478
1479     TRACE("(%p, %p)\n", refcount, out);
1480
1481     if (!refcount || !out)
1482         return E_INVALIDARG;
1483
1484     *out = NULL;
1485
1486     threadref = heap_alloc(sizeof(*threadref));
1487     if (!threadref)
1488         return E_OUTOFMEMORY;
1489     threadref->IUnknown_iface.lpVtbl = &threadrefvtbl;
1490     threadref->refcount = refcount;
1491
1492     *refcount = 1;
1493     *out = &threadref->IUnknown_iface;
1494
1495     TRACE("Created %p.\n", threadref);
1496     return S_OK;
1497 }
1498
1499 /*************************************************************************
1500  * SHGetThreadRef        [SHCORE.@]
1501  */
1502 HRESULT WINAPI SHGetThreadRef(IUnknown **out)
1503 {
1504     TRACE("(%p)\n", out);
1505
1506     if (shcore_tls == TLS_OUT_OF_INDEXES)
1507         return E_NOINTERFACE;
1508
1509     *out = TlsGetValue(shcore_tls);
1510     if (!*out)
1511         return E_NOINTERFACE;
1512
1513     IUnknown_AddRef(*out);
1514     return S_OK;
1515 }
1516
1517 /*************************************************************************
1518  * SHSetThreadRef        [SHCORE.@]
1519  */
1520 HRESULT WINAPI SHSetThreadRef(IUnknown *obj)
1521 {
1522     TRACE("(%p)\n", obj);
1523
1524     if (shcore_tls == TLS_OUT_OF_INDEXES)
1525         return E_NOINTERFACE;
1526
1527     TlsSetValue(shcore_tls, obj);
1528     return S_OK;
1529 }
1530
1531 /*************************************************************************
1532  * SHReleaseThreadRef        [SHCORE.@]
1533  */
1534 HRESULT WINAPI SHReleaseThreadRef(void)
1535 {
1536     FIXME("() - stub!\n");
1537     return S_OK;
1538 }
1539
1540 /*************************************************************************
1541  * GetProcessReference        [SHCORE.@]
1542  */
1543 HRESULT WINAPI GetProcessReference(IUnknown **obj)
1544 {
1545     TRACE("(%p)\n", obj);
1546
1547     *obj = process_ref;
1548
1549     if (!process_ref)
1550         return E_FAIL;
1551
1552     if (*obj)
1553         IUnknown_AddRef(*obj);
1554
1555     return S_OK;
1556 }
1557
1558 /*************************************************************************
1559  * SetProcessReference        [SHCORE.@]
1560  */
1561 void WINAPI SetProcessReference(IUnknown *obj)
1562 {
1563     TRACE("(%p)\n", obj);
1564
1565     process_ref = obj;
1566 }
1567
1568 struct thread_data
1569 {
1570     LPTHREAD_START_ROUTINE thread_proc;
1571     LPTHREAD_START_ROUTINE callback;
1572     void *data;
1573     DWORD flags;
1574     HANDLE hEvent;
1575     IUnknown *thread_ref;
1576     IUnknown *process_ref;
1577 };
1578
1579 static DWORD WINAPI shcore_thread_wrapper(void *data)
1580 {
1581     struct thread_data thread_data;
1582     HRESULT hr = E_FAIL;
1583     DWORD retval;
1584
1585     TRACE("(%p)\n", data);
1586
1587     /* We are now executing in the context of the newly created thread.
1588      * So we copy the data passed to us (it is on the stack of the function
1589      * that called us, which is waiting for us to signal an event before
1590      * returning). */
1591     thread_data = *(struct thread_data *)data;
1592
1593     if (thread_data.flags & CTF_COINIT)
1594     {
1595         hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
1596         if (FAILED(hr))
1597             hr = CoInitializeEx(NULL, COINIT_DISABLE_OLE1DDE);
1598     }
1599
1600     if (thread_data.callback)
1601         thread_data.callback(thread_data.data);
1602
1603     /* Signal the thread that created us; it can return now. */
1604     SetEvent(thread_data.hEvent);
1605
1606     /* Execute the callers start code. */
1607     retval = thread_data.thread_proc(thread_data.data);
1608
1609     /* Release thread and process references. */
1610     if (thread_data.thread_ref)
1611         IUnknown_Release(thread_data.thread_ref);
1612
1613     if (thread_data.process_ref)
1614         IUnknown_Release(thread_data.process_ref);
1615
1616     if (SUCCEEDED(hr))
1617         CoUninitialize();
1618
1619     return retval;
1620 }
1621
1622 /*************************************************************************
1623  *      SHCreateThread        [SHCORE.@]
1624  */
1625 BOOL WINAPI SHCreateThread(LPTHREAD_START_ROUTINE thread_proc, void *data, DWORD flags, LPTHREAD_START_ROUTINE callback)
1626 {
1627     struct thread_data thread_data;
1628     BOOL called = FALSE;
1629
1630     TRACE("%p, %p, %#lx, %p.\n", thread_proc, data, flags, callback);
1631
1632     thread_data.thread_proc = thread_proc;
1633     thread_data.callback = callback;
1634     thread_data.data = data;
1635     thread_data.flags = flags;
1636     thread_data.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1637
1638     if (flags & CTF_THREAD_REF)
1639         SHGetThreadRef(&thread_data.thread_ref);
1640     else
1641         thread_data.thread_ref = NULL;
1642
1643     if (flags & CTF_PROCESS_REF)
1644         GetProcessReference(&thread_data.process_ref);
1645     else
1646         thread_data.process_ref = NULL;
1647
1648     /* Create the thread */
1649     if (thread_data.hEvent)
1650     {
1651         HANDLE hThread;
1652         DWORD retval;
1653
1654         hThread = CreateThread(NULL, 0, shcore_thread_wrapper, &thread_data, 0, &retval);
1655         if (hThread)
1656         {
1657             /* Wait for the thread to signal us to continue */
1658             WaitForSingleObject(thread_data.hEvent, INFINITE);
1659             CloseHandle(hThread);
1660             called = TRUE;
1661         }
1662         CloseHandle(thread_data.hEvent);
1663     }
1664
1665     if (!called)
1666     {
1667         if (!thread_data.callback && flags & CTF_INSIST)
1668         {
1669             /* Couldn't call, call synchronously */
1670             thread_data.thread_proc(data);
1671             called = TRUE;
1672         }
1673         else
1674         {
1675             if (thread_data.thread_ref)
1676                 IUnknown_Release(thread_data.thread_ref);
1677
1678             if (thread_data.process_ref)
1679                 IUnknown_Release(thread_data.process_ref);
1680         }
1681     }
1682
1683     return called;
1684 }
1685
1686 /*************************************************************************
1687  * SHStrDupW    [SHCORE.@]
1688  */
1689 HRESULT WINAPI SHStrDupW(const WCHAR *src, WCHAR **dest)
1690 {
1691     size_t len;
1692
1693     TRACE("(%s, %p)\n", debugstr_w(src), dest);
1694
1695     *dest = NULL;
1696
1697     if (!src)
1698         return E_INVALIDARG;
1699
1700     len = (lstrlenW(src) + 1) * sizeof(WCHAR);
1701     *dest = CoTaskMemAlloc(len);
1702     if (!*dest)
1703         return E_OUTOFMEMORY;
1704
1705     memcpy(*dest, src, len);
1706
1707     return S_OK;
1708 }
1709
1710 /*************************************************************************
1711  * SHStrDupA    [SHCORE.@]
1712  */
1713 HRESULT WINAPI SHStrDupA(const char *src, WCHAR **dest)
1714 {
1715     DWORD len;
1716
1717     *dest = NULL;
1718
1719     if (!src)
1720         return E_INVALIDARG;
1721
1722     len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
1723     *dest = CoTaskMemAlloc(len * sizeof(WCHAR));
1724     if (!*dest)
1725         return E_OUTOFMEMORY;
1726
1727     MultiByteToWideChar(CP_ACP, 0, src, -1, *dest, len);
1728
1729     return S_OK;
1730 }
1731
1732 /*************************************************************************
1733  * SHAnsiToAnsi        [SHCORE.@]
1734  */
1735 DWORD WINAPI SHAnsiToAnsi(const char *src, char *dest, int dest_len)
1736 {
1737     DWORD ret;
1738
1739     TRACE("(%s, %p, %d)\n", debugstr_a(src), dest, dest_len);
1740
1741     if (!src || !dest || dest_len <= 0)
1742         return 0;
1743
1744     lstrcpynA(dest, src, dest_len);
1745     ret = strlen(dest);
1746
1747     return src[ret] ? 0 : ret + 1;
1748 }
1749
1750 /*************************************************************************
1751  * SHUnicodeToAnsi        [SHCORE.@]
1752  */
1753 DWORD WINAPI SHUnicodeToAnsi(const WCHAR *src, char *dest, int dest_len)
1754 {
1755     int ret = 1;
1756
1757     TRACE("(%s, %p, %d)\n", debugstr_w(src), dest, dest_len);
1758
1759     if (!dest || !dest_len)
1760         return 0;
1761
1762     if (src)
1763     {
1764         ret = WideCharToMultiByte(CP_ACP, 0, src, -1, dest, dest_len, NULL, NULL);
1765         if (!ret)
1766         {
1767             dest[dest_len - 1] = 0;
1768             ret = dest_len;
1769         }
1770     }
1771     else
1772         dest[0] = 0;
1773
1774     return ret;
1775 }
1776
1777 /*************************************************************************
1778  * SHUnicodeToUnicode        [SHCORE.@]
1779  */
1780 DWORD WINAPI SHUnicodeToUnicode(const WCHAR *src, WCHAR *dest, int dest_len)
1781 {
1782     DWORD ret;
1783
1784     TRACE("(%s, %p, %d)\n", debugstr_w(src), dest, dest_len);
1785
1786     if (!src || !dest || dest_len <= 0)
1787         return 0;
1788
1789     lstrcpynW(dest, src, dest_len);
1790     ret = lstrlenW(dest);
1791
1792     return src[ret] ? 0 : ret + 1;
1793 }
1794
1795 /*************************************************************************
1796  * SHAnsiToUnicode        [SHCORE.@]
1797  */
1798 DWORD WINAPI SHAnsiToUnicode(const char *src, WCHAR *dest, int dest_len)
1799 {
1800     int ret = 1;
1801
1802     TRACE("(%s, %p, %d)\n", debugstr_a(src), dest, dest_len);
1803
1804     if (!dest || !dest_len)
1805         return 0;
1806
1807     if (src)
1808     {
1809         ret = MultiByteToWideChar(CP_ACP, 0, src, -1, dest, dest_len);
1810         if (!ret)
1811         {
1812             dest[dest_len - 1] = 0;
1813             ret = dest_len;
1814         }
1815     }
1816     else
1817         dest[0] = 0;
1818
1819     return ret;
1820 }
1821
1822 /*************************************************************************
1823  * SHRegDuplicateHKey        [SHCORE.@]
1824  */
1825 HKEY WINAPI SHRegDuplicateHKey(HKEY hKey)
1826 {
1827     HKEY newKey = 0;
1828
1829     RegOpenKeyExW(hKey, 0, 0, MAXIMUM_ALLOWED, &newKey);
1830     TRACE("new key is %p\n", newKey);
1831     return newKey;
1832 }
1833
1834 /*************************************************************************
1835  * SHDeleteEmptyKeyW        [SHCORE.@]
1836  */
1837 DWORD WINAPI SHDeleteEmptyKeyW(HKEY hkey, const WCHAR *subkey)
1838 {
1839     DWORD ret, count = 0;
1840     HKEY hsubkey = 0;
1841
1842     TRACE("(%p, %s)\n", hkey, debugstr_w(subkey));
1843
1844     ret = RegOpenKeyExW(hkey, subkey, 0, KEY_READ, &hsubkey);
1845     if (!ret)
1846     {
1847         ret = RegQueryInfoKeyW(hsubkey, NULL, NULL, NULL, &count,
1848                              NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1849         RegCloseKey(hsubkey);
1850         if (!ret)
1851         {
1852             if (count)
1853                 ret = ERROR_KEY_HAS_CHILDREN;
1854             else
1855                 ret = RegDeleteKeyW(hkey, subkey);
1856         }
1857     }
1858
1859     return ret;
1860 }
1861
1862 /*************************************************************************
1863  * SHDeleteEmptyKeyA        [SHCORE.@]
1864  */
1865 DWORD WINAPI SHDeleteEmptyKeyA(HKEY hkey, const char *subkey)
1866 {
1867     WCHAR *subkeyW = NULL;
1868     DWORD ret;
1869
1870     TRACE("(%p, %s)\n", hkey, debugstr_a(subkey));
1871
1872     if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
1873         return ERROR_OUTOFMEMORY;
1874
1875     ret = SHDeleteEmptyKeyW(hkey, subkeyW);
1876     CoTaskMemFree(subkeyW);
1877     return ret;
1878 }
1879
1880 /*************************************************************************
1881  * SHDeleteKeyW        [SHCORE.@]
1882  */
1883 DWORD WINAPI SHDeleteKeyW(HKEY hkey, const WCHAR *subkey)
1884 {
1885     TRACE("(%p, %s)\n", hkey, debugstr_w(subkey));
1886
1887     return RegDeleteTreeW(hkey, subkey);
1888 }
1889
1890 /*************************************************************************
1891  * SHDeleteKeyA        [SHCORE.@]
1892  */
1893 DWORD WINAPI SHDeleteKeyA(HKEY hkey, const char *subkey)
1894 {
1895     TRACE("(%p, %s)\n", hkey, debugstr_a(subkey));
1896
1897     return RegDeleteTreeA(hkey, subkey);
1898 }
1899
1900 /*************************************************************************
1901  * SHDeleteValueW        [SHCORE.@]
1902  */
1903 DWORD WINAPI SHDeleteValueW(HKEY hkey, const WCHAR *subkey, const WCHAR *value)
1904 {
1905     HKEY hsubkey;
1906     DWORD ret;
1907
1908     TRACE("(%p, %s, %s)\n", hkey, debugstr_w(subkey), debugstr_w(value));
1909
1910     ret = RegOpenKeyExW(hkey, subkey, 0, KEY_SET_VALUE, &hsubkey);
1911     if (!ret)
1912     {
1913         ret = RegDeleteValueW(hsubkey, value);
1914         RegCloseKey(hsubkey);
1915     }
1916
1917     return ret;
1918 }
1919
1920 /*************************************************************************
1921  * SHDeleteValueA        [SHCORE.@]
1922  */
1923 DWORD WINAPI SHDeleteValueA(HKEY hkey, const char *subkey, const char *value)
1924 {
1925     WCHAR *subkeyW = NULL, *valueW = NULL;
1926     DWORD ret;
1927
1928     TRACE("(%p, %s, %s)\n", hkey, debugstr_a(subkey), debugstr_a(value));
1929
1930     if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
1931         return ERROR_OUTOFMEMORY;
1932     if (value && FAILED(SHStrDupA(value, &valueW)))
1933     {
1934         CoTaskMemFree(subkeyW);
1935         return ERROR_OUTOFMEMORY;
1936     }
1937
1938     ret = SHDeleteValueW(hkey, subkeyW, valueW);
1939     CoTaskMemFree(subkeyW);
1940     CoTaskMemFree(valueW);
1941     return ret;
1942 }
1943
1944 /*************************************************************************
1945  * SHCopyKeyA        [SHCORE.@]
1946  */
1947 DWORD WINAPI SHCopyKeyA(HKEY hkey_src, const char *subkey, HKEY hkey_dst, DWORD reserved)
1948 {
1949     WCHAR *subkeyW = NULL;
1950     DWORD ret;
1951
1952     TRACE("%p, %s, %p, %ld.\n", hkey_src, debugstr_a(subkey), hkey_dst, reserved);
1953
1954     if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
1955         return 0;
1956
1957     ret = SHCopyKeyW(hkey_src, subkeyW, hkey_dst, reserved);
1958     CoTaskMemFree(subkeyW);
1959     return ret;
1960 }
1961
1962 /*************************************************************************
1963  * SHCopyKeyW        [SHCORE.@]
1964  */
1965 DWORD WINAPI SHCopyKeyW(HKEY hkey_src, const WCHAR *subkey, HKEY hkey_dst, DWORD reserved)
1966 {
1967     DWORD key_count = 0, value_count = 0, max_key_len = 0;
1968     WCHAR name[MAX_PATH], *ptr_name = name;
1969     BYTE buff[1024], *ptr = buff;
1970     DWORD max_data_len = 0, i;
1971     DWORD ret = 0;
1972
1973     TRACE("%p, %s, %p, %ld.\n", hkey_src, debugstr_w(subkey), hkey_dst, reserved);
1974
1975     if (!hkey_dst || !hkey_src)
1976         return ERROR_INVALID_PARAMETER;
1977
1978     if (subkey)
1979         ret = RegOpenKeyExW(hkey_src, subkey, 0, KEY_ALL_ACCESS, &hkey_src);
1980
1981     if (ret)
1982         hkey_src = NULL; /* Don't close this key since we didn't open it */
1983     else
1984     {
1985         DWORD max_value_len;
1986
1987         ret = RegQueryInfoKeyW(hkey_src, NULL, NULL, NULL, &key_count, &max_key_len,
1988                 NULL, &value_count, &max_value_len, &max_data_len, NULL, NULL);
1989         if (!ret)
1990         {
1991             /* Get max size for key/value names */
1992             max_key_len = max(max_key_len, max_value_len);
1993
1994             if (max_key_len++ > MAX_PATH - 1)
1995                 ptr_name = heap_alloc(max_key_len * sizeof(WCHAR));
1996
1997             if (max_data_len > sizeof(buff))
1998                 ptr = heap_alloc(max_data_len);
1999
2000             if (!ptr_name || !ptr)
2001                 ret = ERROR_NOT_ENOUGH_MEMORY;
2002         }
2003     }
2004
2005     for (i = 0; i < key_count && !ret; i++)
2006     {
2007         HKEY hsubkey_src, hsubkey_dst;
2008         DWORD length = max_key_len;
2009
2010         ret = RegEnumKeyExW(hkey_src, i, ptr_name, &length, NULL, NULL, NULL, NULL);
2011         if (!ret)
2012         {
2013             ret = RegOpenKeyExW(hkey_src, ptr_name, 0, KEY_READ, &hsubkey_src);
2014             if (!ret)
2015             {
2016                 /* Create destination sub key */
2017                 ret = RegCreateKeyW(hkey_dst, ptr_name, &hsubkey_dst);
2018                 if (!ret)
2019                 {
2020                     /* Recursively copy keys and values from the sub key */
2021                     ret = SHCopyKeyW(hsubkey_src, NULL, hsubkey_dst, 0);
2022                     RegCloseKey(hsubkey_dst);
2023                 }
2024             }
2025             RegCloseKey(hsubkey_src);
2026         }
2027     }
2028
2029     /* Copy all the values in this key */
2030     for (i = 0; i < value_count && !ret; i++)
2031     {
2032         DWORD length = max_key_len, type, data_len = max_data_len;
2033
2034         ret = RegEnumValueW(hkey_src, i, ptr_name, &length, NULL, &type, ptr, &data_len);
2035         if (!ret) {
2036             ret = SHSetValueW(hkey_dst, NULL, ptr_name, type, ptr, data_len);
2037         }
2038     }
2039
2040     /* Free buffers if allocated */
2041     if (ptr_name != name)
2042         heap_free(ptr_name);
2043     if (ptr != buff)
2044         heap_free(ptr);
2045
2046     if (subkey && hkey_src)
2047         RegCloseKey(hkey_src);
2048
2049     return ret;
2050 }
2051
2052
2053 /*************************************************************************
2054  * SHEnumKeyExA        [SHCORE.@]
2055  */
2056 LONG WINAPI SHEnumKeyExA(HKEY hkey, DWORD index, char *subkey, DWORD *length)
2057 {
2058     TRACE("%p, %ld, %s, %p.\n", hkey, index, debugstr_a(subkey), length);
2059
2060     return RegEnumKeyExA(hkey, index, subkey, length, NULL, NULL, NULL, NULL);
2061 }
2062
2063 /*************************************************************************
2064  * SHEnumKeyExW        [SHCORE.@]
2065  */
2066 LONG WINAPI SHEnumKeyExW(HKEY hkey, DWORD index, WCHAR *subkey, DWORD *length)
2067 {
2068     TRACE("%p, %ld, %s, %p.\n", hkey, index, debugstr_w(subkey), length);
2069
2070     return RegEnumKeyExW(hkey, index, subkey, length, NULL, NULL, NULL, NULL);
2071 }
2072
2073 /*************************************************************************
2074  * SHEnumValueA        [SHCORE.@]
2075  */
2076 LONG WINAPI SHEnumValueA(HKEY hkey, DWORD index, char *value, DWORD *length, DWORD *type,
2077         void *data, DWORD *data_len)
2078 {
2079     TRACE("%p, %ld, %s, %p, %p, %p, %p.\n", hkey, index, debugstr_a(value), length, type, data, data_len);
2080
2081     return RegEnumValueA(hkey, index, value, length, NULL, type, data, data_len);
2082 }
2083
2084 /*************************************************************************
2085  * SHEnumValueW        [SHCORE.@]
2086  */
2087 LONG WINAPI SHEnumValueW(HKEY hkey, DWORD index, WCHAR *value, DWORD *length, DWORD *type,
2088         void *data, DWORD *data_len)
2089 {
2090     TRACE("%p, %ld, %s, %p, %p, %p, %p.\n", hkey, index, debugstr_w(value), length, type, data, data_len);
2091
2092     return RegEnumValueW(hkey, index, value, length, NULL, type, data, data_len);
2093 }
2094
2095 /*************************************************************************
2096  * SHQueryValueExW    [SHCORE.@]
2097  */
2098 DWORD WINAPI SHQueryValueExW(HKEY hkey, const WCHAR *name, DWORD *reserved, DWORD *type,
2099         void *buff, DWORD *buff_len)
2100 {
2101     DWORD ret, value_type, data_len = 0;
2102
2103     TRACE("(%p, %s, %p, %p, %p, %p)\n", hkey, debugstr_w(name), reserved, type, buff, buff_len);
2104
2105     if (buff_len)
2106         data_len = *buff_len;
2107
2108     ret = RegQueryValueExW(hkey, name, reserved, &value_type, buff, &data_len);
2109     if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)
2110         return ret;
2111
2112     if (buff_len && value_type == REG_EXPAND_SZ)
2113     {
2114         DWORD length;
2115         WCHAR *value;
2116
2117         if (!buff || ret == ERROR_MORE_DATA)
2118         {
2119             length = data_len;
2120             value = heap_alloc(length);
2121             RegQueryValueExW(hkey, name, reserved, NULL, (BYTE *)value, &length);
2122             length = ExpandEnvironmentStringsW(value, NULL, 0);
2123         }
2124         else
2125         {
2126             length = (lstrlenW(buff) + 1) * sizeof(WCHAR);
2127             value = heap_alloc(length);
2128             memcpy(value, buff, length);
2129             length = ExpandEnvironmentStringsW(value, buff, *buff_len / sizeof(WCHAR));
2130             if (length > *buff_len) ret = ERROR_MORE_DATA;
2131         }
2132         data_len = max(data_len, length);
2133         heap_free(value);
2134     }
2135
2136     if (type)
2137         *type = value_type == REG_EXPAND_SZ ? REG_SZ : value_type;
2138     if (buff_len)
2139         *buff_len = data_len;
2140     return ret;
2141 }
2142
2143 /*************************************************************************
2144  * SHQueryValueExA    [SHCORE.@]
2145  */
2146 DWORD WINAPI SHQueryValueExA(HKEY hkey, const char *name, DWORD *reserved, DWORD *type,
2147         void *buff, DWORD *buff_len)
2148 {
2149     DWORD ret, value_type, data_len = 0;
2150
2151     TRACE("(%p, %s, %p, %p, %p, %p)\n", hkey, debugstr_a(name), reserved, type, buff, buff_len);
2152
2153     if (buff_len)
2154         data_len = *buff_len;
2155
2156     ret = RegQueryValueExA(hkey, name, reserved, &value_type, buff, &data_len);
2157     if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)
2158         return ret;
2159
2160     if (buff_len && value_type == REG_EXPAND_SZ)
2161     {
2162         DWORD length;
2163         char *value;
2164
2165         if (!buff || ret == ERROR_MORE_DATA)
2166         {
2167             length = data_len;
2168             value = heap_alloc(length);
2169             RegQueryValueExA(hkey, name, reserved, NULL, (BYTE *)value, &length);
2170             length = ExpandEnvironmentStringsA(value, NULL, 0);
2171         }
2172         else
2173         {
2174             length = strlen(buff) + 1;
2175             value = heap_alloc(length);
2176             memcpy(value, buff, length);
2177             length = ExpandEnvironmentStringsA(value, buff, *buff_len);
2178             if (length > *buff_len) ret = ERROR_MORE_DATA;
2179         }
2180         data_len = max(data_len, length);
2181         heap_free(value);
2182     }
2183
2184     if (type)
2185         *type = value_type == REG_EXPAND_SZ ? REG_SZ : value_type;
2186     if (buff_len)
2187         *buff_len = data_len;
2188     return ret;
2189 }
2190
2191 /*************************************************************************
2192  * SHGetValueA        [SHCORE.@]
2193  */
2194 DWORD WINAPI SHGetValueA(HKEY hkey, const char *subkey, const char *value,
2195        DWORD *type, void *data, DWORD *data_len)
2196 {
2197     HKEY hsubkey = 0;
2198     DWORD ret = 0;
2199
2200     TRACE("(%p, %s, %s, %p, %p, %p)\n", hkey, debugstr_a(subkey), debugstr_a(value),
2201             type, data, data_len);
2202
2203     if (subkey)
2204         ret = RegOpenKeyExA(hkey, subkey, 0, KEY_QUERY_VALUE, &hsubkey);
2205
2206     if (!ret)
2207     {
2208         ret = SHQueryValueExA(hsubkey ? hsubkey : hkey, value, 0, type, data, data_len);
2209         if (subkey)
2210             RegCloseKey(hsubkey);
2211     }
2212
2213     return ret;
2214 }
2215
2216 /*************************************************************************
2217  * SHGetValueW        [SHCORE.@]
2218  */
2219 DWORD WINAPI SHGetValueW(HKEY hkey, const WCHAR *subkey, const WCHAR *value,
2220         DWORD *type, void *data, DWORD *data_len)
2221 {
2222     HKEY hsubkey = 0;
2223     DWORD ret = 0;
2224
2225     TRACE("(%p, %s, %s, %p, %p, %p)\n", hkey, debugstr_w(subkey), debugstr_w(value),
2226             type, data, data_len);
2227
2228     if (subkey)
2229         ret = RegOpenKeyExW(hkey, subkey, 0, KEY_QUERY_VALUE, &hsubkey);
2230
2231     if (!ret)
2232     {
2233         ret = SHQueryValueExW(hsubkey ? hsubkey : hkey, value, 0, type, data, data_len);
2234         if (subkey)
2235             RegCloseKey(hsubkey);
2236     }
2237
2238     return ret;
2239 }
2240
2241 /*************************************************************************
2242  * SHRegGetIntW        [SHCORE.280]
2243  */
2244 int WINAPI SHRegGetIntW(HKEY hkey, const WCHAR *value, int default_value)
2245 {
2246     WCHAR buff[32];
2247     DWORD buff_len;
2248
2249     TRACE("(%p, %s, %d)\n", hkey, debugstr_w(value), default_value);
2250
2251     buff[0] = 0;
2252     buff_len = sizeof(buff);
2253     if (SHQueryValueExW(hkey, value, 0, 0, buff, &buff_len))
2254         return default_value;
2255
2256     if (*buff >= '0' && *buff <= '9')
2257         return wcstol(buff, NULL, 10);
2258
2259     return default_value;
2260 }
2261
2262 /*************************************************************************
2263  * SHRegGetPathA        [SHCORE.@]
2264  */
2265 DWORD WINAPI SHRegGetPathA(HKEY hkey, const char *subkey, const char *value, char *path, DWORD flags)
2266 {
2267     DWORD length = MAX_PATH;
2268
2269     TRACE("%p, %s, %s, %p, %#lx.\n", hkey, debugstr_a(subkey), debugstr_a(value), path, flags);
2270
2271     return SHGetValueA(hkey, subkey, value, 0, path, &length);
2272 }
2273
2274 /*************************************************************************
2275  * SHRegGetPathW        [SHCORE.@]
2276  */
2277 DWORD WINAPI SHRegGetPathW(HKEY hkey, const WCHAR *subkey, const WCHAR *value, WCHAR *path, DWORD flags)
2278 {
2279     DWORD length = MAX_PATH;
2280
2281     TRACE("%p, %s, %s, %p, %#lx.\n", hkey, debugstr_w(subkey), debugstr_w(value), path, flags);
2282
2283     return SHGetValueW(hkey, subkey, value, 0, path, &length);
2284 }
2285
2286 /*************************************************************************
2287  * SHSetValueW       [SHCORE.@]
2288  */
2289 DWORD WINAPI SHSetValueW(HKEY hkey, const WCHAR *subkey, const WCHAR *value, DWORD type,
2290         const void *data, DWORD data_len)
2291 {
2292     DWORD ret = ERROR_SUCCESS, dummy;
2293     HKEY hsubkey;
2294
2295     TRACE("%p, %s, %s, %ld, %p, %ld.\n", hkey, debugstr_w(subkey), debugstr_w(value),
2296             type, data, data_len);
2297
2298     if (subkey && *subkey)
2299         ret = RegCreateKeyExW(hkey, subkey, 0, NULL, 0, KEY_SET_VALUE, NULL, &hsubkey, &dummy);
2300     else
2301         hsubkey = hkey;
2302
2303     if (!ret)
2304     {
2305         ret = RegSetValueExW(hsubkey, value, 0, type, data, data_len);
2306         if (hsubkey != hkey)
2307             RegCloseKey(hsubkey);
2308     }
2309
2310     return ret;
2311 }
2312
2313 /*************************************************************************
2314  * SHSetValueA        [SHCORE.@]
2315  */
2316 DWORD WINAPI SHSetValueA(HKEY hkey, const char *subkey, const char *value,
2317         DWORD type, const void *data, DWORD data_len)
2318 {
2319     DWORD ret = ERROR_SUCCESS, dummy;
2320     HKEY hsubkey;
2321
2322     TRACE("%p, %s, %s, %ld, %p, %ld.\n", hkey, debugstr_a(subkey), debugstr_a(value),
2323             type, data, data_len);
2324
2325     if (subkey && *subkey)
2326         ret = RegCreateKeyExA(hkey, subkey, 0, NULL, 0, KEY_SET_VALUE, NULL, &hsubkey, &dummy);
2327     else
2328         hsubkey = hkey;
2329
2330     if (!ret)
2331     {
2332         ret = RegSetValueExA(hsubkey, value, 0, type, data, data_len);
2333         if (hsubkey != hkey)
2334             RegCloseKey(hsubkey);
2335     }
2336
2337     return ret;
2338 }
2339
2340 /*************************************************************************
2341  * SHRegSetPathA       [SHCORE.@]
2342  */
2343 DWORD WINAPI SHRegSetPathA(HKEY hkey, const char *subkey, const char *value, const char *path, DWORD flags)
2344 {
2345     FIXME("%p, %s, %s, %s, %#lx - semi-stub\n", hkey, debugstr_a(subkey),
2346             debugstr_a(value), debugstr_a(path), flags);
2347
2348     /* FIXME: PathUnExpandEnvStringsA() */
2349
2350     return SHSetValueA(hkey, subkey, value, REG_SZ, path, lstrlenA(path));
2351 }
2352
2353 /*************************************************************************
2354  * SHRegSetPathW       [SHCORE.@]
2355  */
2356 DWORD WINAPI SHRegSetPathW(HKEY hkey, const WCHAR *subkey, const WCHAR *value, const WCHAR *path, DWORD flags)
2357 {
2358     FIXME("%p, %s, %s, %s, %#lx semi-stub\n", hkey, debugstr_w(subkey),
2359             debugstr_w(value), debugstr_w(path), flags);
2360
2361     /* FIXME: PathUnExpandEnvStringsW(); */
2362
2363     return SHSetValueW(hkey, subkey, value, REG_SZ, path, lstrlenW(path));
2364 }
2365
2366 /*************************************************************************
2367  * SHQueryInfoKeyA       [SHCORE.@]
2368  */
2369 LONG WINAPI SHQueryInfoKeyA(HKEY hkey, DWORD *subkeys, DWORD *subkey_max, DWORD *values, DWORD *value_max)
2370 {
2371     TRACE("(%p, %p, %p, %p, %p)\n", hkey, subkeys, subkey_max, values, value_max);
2372
2373     return RegQueryInfoKeyA(hkey, NULL, NULL, NULL, subkeys, subkey_max, NULL, values, value_max, NULL, NULL, NULL);
2374 }
2375
2376 /*************************************************************************
2377  * SHQueryInfoKeyW       [SHCORE.@]
2378  */
2379 LONG WINAPI SHQueryInfoKeyW(HKEY hkey, DWORD *subkeys, DWORD *subkey_max, DWORD *values, DWORD *value_max)
2380 {
2381     TRACE("(%p, %p, %p, %p, %p)\n", hkey, subkeys, subkey_max, values, value_max);
2382
2383     return RegQueryInfoKeyW(hkey, NULL, NULL, NULL, subkeys, subkey_max, NULL, values, value_max, NULL, NULL, NULL);
2384 }
2385
2386 /*************************************************************************
2387  * IsOS        [SHCORE.@]
2388  */
2389 BOOL WINAPI IsOS(DWORD feature)
2390 {
2391     DWORD platform, majorv, minorv;
2392     OSVERSIONINFOA osvi;
2393
2394     osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
2395     if (!GetVersionExA(&osvi))
2396         return FALSE;
2397
2398     majorv = osvi.dwMajorVersion;
2399     minorv = osvi.dwMinorVersion;
2400     platform = osvi.dwPlatformId;
2401
2402 #define ISOS_RETURN(x) \
2403     TRACE("(%#lx) ret %d\n",feature,(x)); \
2404     return (x)
2405
2406     switch(feature)  {
2407     case OS_WIN32SORGREATER:
2408         ISOS_RETURN(platform == VER_PLATFORM_WIN32s
2409                  || platform == VER_PLATFORM_WIN32_WINDOWS);
2410     case OS_NT:
2411         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
2412     case OS_WIN95ORGREATER:
2413         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS);
2414     case OS_NT4ORGREATER:
2415         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 4);
2416     case OS_WIN2000ORGREATER_ALT:
2417     case OS_WIN2000ORGREATER:
2418         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5);
2419     case OS_WIN98ORGREATER:
2420         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 10);
2421     case OS_WIN98_GOLD:
2422         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 10);
2423     case OS_WIN2000PRO:
2424         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5);
2425     case OS_WIN2000SERVER:
2426         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1));
2427     case OS_WIN2000ADVSERVER:
2428         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1));
2429     case OS_WIN2000DATACENTER:
2430         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1));
2431     case OS_WIN2000TERMINAL:
2432         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1));
2433     case OS_EMBEDDED:
2434         FIXME("(OS_EMBEDDED) What should we return here?\n");
2435         return FALSE;
2436     case OS_TERMINALCLIENT:
2437         FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
2438         return FALSE;
2439     case OS_TERMINALREMOTEADMIN:
2440         FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
2441         return FALSE;
2442     case OS_WIN95_GOLD:
2443         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 0);
2444     case OS_MEORGREATER:
2445         ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 90);
2446     case OS_XPORGREATER:
2447         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1);
2448     case OS_HOME:
2449         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1);
2450     case OS_PROFESSIONAL:
2451         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
2452     case OS_DATACENTER:
2453         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
2454     case OS_ADVSERVER:
2455         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5);
2456     case OS_SERVER:
2457         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
2458     case OS_TERMINALSERVER:
2459         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
2460     case OS_PERSONALTERMINALSERVER:
2461         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && minorv >= 1 && majorv >= 5);
2462     case OS_FASTUSERSWITCHING:
2463         FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
2464         return TRUE;
2465     case OS_WELCOMELOGONUI:
2466         FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
2467         return FALSE;
2468     case OS_DOMAINMEMBER:
2469         FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
2470         return TRUE;
2471     case OS_ANYSERVER:
2472         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
2473     case OS_WOW6432:
2474         {
2475             BOOL is_wow64;
2476             IsWow64Process(GetCurrentProcess(), &is_wow64);
2477             return is_wow64;
2478         }
2479     case OS_WEBSERVER:
2480         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
2481     case OS_SMALLBUSINESSSERVER:
2482         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
2483     case OS_TABLETPC:
2484         FIXME("(OS_TABLETPC) What should we return here?\n");
2485         return FALSE;
2486     case OS_SERVERADMINUI:
2487         FIXME("(OS_SERVERADMINUI) What should we return here?\n");
2488         return FALSE;
2489     case OS_MEDIACENTER:
2490         FIXME("(OS_MEDIACENTER) What should we return here?\n");
2491         return FALSE;
2492     case OS_APPLIANCE:
2493         FIXME("(OS_APPLIANCE) What should we return here?\n");
2494         return FALSE;
2495     case 0x25: /*OS_VISTAORGREATER*/
2496         ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 6);
2497     }
2498
2499 #undef ISOS_RETURN
2500
2501     WARN("(%#lx) unknown parameter\n", feature);
2502
2503     return FALSE;
2504 }
2505
2506 /*************************************************************************
2507  * SubscribeFeatureStateChangeNotification        [SHCORE.@]
2508  */
2509 void WINAPI SubscribeFeatureStateChangeNotification(FEATURE_STATE_CHANGE_SUBSCRIPTION *subscription,
2510                                                     FEATURE_STATE_CHANGE_CALLBACK *callback, void *context)
2511 {
2512     FIXME("(%p, %p, %p) stub\n", subscription, callback, context);
2513 }
2514
2515 /*************************************************************************
2516  * GetFeatureEnabledState        [SHCORE.@]
2517  */
2518 FEATURE_ENABLED_STATE WINAPI GetFeatureEnabledState(UINT32 feature, FEATURE_CHANGE_TIME change_time)
2519 {
2520     FIXME("(%u, %u) stub\n", feature, change_time);
2521     return FEATURE_ENABLED_STATE_DEFAULT;
2522 }