mshtml: Remove some stray #undef.
[wine] / dlls / shlwapi / regstream.c
1 /*
2  * SHLWAPI Registry Stream functions
3  *
4  * Copyright 1999 Juergen Schmied
5  * Copyright 2002 Jon Griffiths
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include <stdarg.h>
23 #include <string.h>
24
25 #define COBJMACROS
26
27 #include "winerror.h"
28 #include "windef.h"
29 #include "winbase.h"
30 #include "objbase.h"
31 #include "winreg.h"
32 #include "shlwapi.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(shell);
37
38 typedef struct
39 {
40         IStream IStream_iface;
41         LONG   ref;
42         HKEY   hKey;
43         LPBYTE pbBuffer;
44         DWORD  dwLength;
45         DWORD  dwPos;
46         DWORD  dwMode;
47         union {
48             LPSTR keyNameA;
49             LPWSTR keyNameW;
50         }u;
51         BOOL   bUnicode;
52 } ISHRegStream;
53
54 static inline ISHRegStream *impl_from_IStream(IStream *iface)
55 {
56         return CONTAINING_RECORD(iface, ISHRegStream, IStream_iface);
57 }
58
59 /**************************************************************************
60 *  IStream_fnQueryInterface
61 */
62 static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj)
63 {
64         ISHRegStream *This = impl_from_IStream(iface);
65
66         TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
67
68         *ppvObj = NULL;
69
70         if(IsEqualIID(riid, &IID_IUnknown))     /*IUnknown*/
71           *ppvObj = This;
72         else if(IsEqualIID(riid, &IID_IStream)) /*IStream*/
73           *ppvObj = This;
74
75         if(*ppvObj)
76         {
77           IStream_AddRef((IStream*)*ppvObj);
78           TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
79           return S_OK;
80         }
81         TRACE("-- Interface: E_NOINTERFACE\n");
82         return E_NOINTERFACE;
83 }
84
85 /**************************************************************************
86 *  IStream_fnAddRef
87 */
88 static ULONG WINAPI IStream_fnAddRef(IStream *iface)
89 {
90         ISHRegStream *This = impl_from_IStream(iface);
91         ULONG refCount = InterlockedIncrement(&This->ref);
92         
93         TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
94
95         return refCount;
96 }
97
98 /**************************************************************************
99 *  IStream_fnRelease
100 */
101 static ULONG WINAPI IStream_fnRelease(IStream *iface)
102 {
103         ISHRegStream *This = impl_from_IStream(iface);
104         ULONG refCount = InterlockedDecrement(&This->ref);
105
106         TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
107
108         if (!refCount)
109         {
110           TRACE(" destroying SHReg IStream (%p)\n",This);
111
112           if (This->hKey)
113           {
114             /* write back data in REG_BINARY */
115             if (This->dwMode == STGM_READWRITE || This->dwMode == STGM_WRITE)
116             {
117               if (This->dwLength)
118               {
119                 if (This->bUnicode)
120                   RegSetValueExW(This->hKey, This->u.keyNameW, 0, REG_BINARY,
121                                  (const BYTE *) This->pbBuffer, This->dwLength);
122                 else
123                   RegSetValueExA(This->hKey, This->u.keyNameA, 0, REG_BINARY,
124                                 (const BYTE *) This->pbBuffer, This->dwLength);
125               }
126               else
127               {
128                 if (This->bUnicode)
129                   RegDeleteValueW(This->hKey, This->u.keyNameW);
130                 else
131                   RegDeleteValueA(This->hKey, This->u.keyNameA);
132               }
133             }
134
135             RegCloseKey(This->hKey);
136           }
137
138           HeapFree(GetProcessHeap(),0,This->u.keyNameA);
139           HeapFree(GetProcessHeap(),0,This->pbBuffer);
140           HeapFree(GetProcessHeap(),0,This);
141           return 0;
142         }
143
144         return refCount;
145 }
146
147 /**************************************************************************
148  * IStream_fnRead
149  */
150 static HRESULT WINAPI IStream_fnRead (IStream * iface, void* pv, ULONG cb, ULONG* pcbRead)
151 {
152         ISHRegStream *This = impl_from_IStream(iface);
153         DWORD dwBytesToRead;
154
155         TRACE("(%p)->(%p,0x%08x,%p)\n",This, pv, cb, pcbRead);
156
157         if (This->dwPos >= This->dwLength)
158           dwBytesToRead = 0;
159         else
160           dwBytesToRead = This->dwLength - This->dwPos;
161
162         dwBytesToRead = (cb > dwBytesToRead) ? dwBytesToRead : cb;
163         if (dwBytesToRead != 0) /* not at end of buffer and we want to read something */
164         {
165           memmove(pv, This->pbBuffer + This->dwPos, dwBytesToRead);
166           This->dwPos += dwBytesToRead; /* adjust pointer */
167         }
168
169         if (pcbRead)
170           *pcbRead = dwBytesToRead;
171
172         return S_OK;
173 }
174
175 /**************************************************************************
176  * IStream_fnWrite
177  */
178 static HRESULT WINAPI IStream_fnWrite (IStream * iface, const void* pv, ULONG cb, ULONG* pcbWritten)
179 {
180         ISHRegStream *This = impl_from_IStream(iface);
181         DWORD newLen = This->dwPos + cb;
182
183         TRACE("(%p, %p, %d, %p)\n",This, pv, cb, pcbWritten);
184
185         if (newLen < This->dwPos) /* overflow */
186           return STG_E_INSUFFICIENTMEMORY;
187
188         if (newLen > This->dwLength)
189         {
190           LPBYTE newBuf = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pbBuffer, newLen);
191           if (!newBuf)
192             return STG_E_INSUFFICIENTMEMORY;
193
194           This->dwLength = newLen;
195           This->pbBuffer = newBuf;
196         }
197         memmove(This->pbBuffer + This->dwPos, pv, cb);
198         This->dwPos += cb; /* adjust pointer */
199
200         if (pcbWritten)
201           *pcbWritten = cb;
202
203         return S_OK;
204 }
205
206 /**************************************************************************
207  *  IStream_fnSeek
208  */
209 static HRESULT WINAPI IStream_fnSeek (IStream * iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
210 {
211         ISHRegStream *This = impl_from_IStream(iface);
212         LARGE_INTEGER tmp;
213         TRACE("(%p, %s, %d %p)\n", This,
214               wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
215
216         if (dwOrigin == STREAM_SEEK_SET)
217           tmp = dlibMove;
218         else if (dwOrigin == STREAM_SEEK_CUR)
219           tmp.QuadPart = This->dwPos + dlibMove.QuadPart;
220         else if (dwOrigin == STREAM_SEEK_END)
221           tmp.QuadPart = This->dwLength + dlibMove.QuadPart;
222         else
223           return STG_E_INVALIDPARAMETER;
224
225         if (tmp.QuadPart < 0)
226           return STG_E_INVALIDFUNCTION;
227
228         /* we cut off the high part here */
229         This->dwPos = tmp.u.LowPart;
230
231         if (plibNewPosition)
232           plibNewPosition->QuadPart = This->dwPos;
233         return S_OK;
234 }
235
236 /**************************************************************************
237  * IStream_fnSetSize
238  */
239 static HRESULT WINAPI IStream_fnSetSize (IStream * iface, ULARGE_INTEGER libNewSize)
240 {
241         ISHRegStream *This = impl_from_IStream(iface);
242         DWORD newLen;
243         LPBYTE newBuf;
244
245         TRACE("(%p, %s)\n", This, wine_dbgstr_longlong(libNewSize.QuadPart));
246
247         /* we cut off the high part here */
248         newLen = libNewSize.u.LowPart;
249         newBuf = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pbBuffer, newLen);
250         if (!newBuf)
251           return STG_E_INSUFFICIENTMEMORY;
252
253         This->pbBuffer = newBuf;
254         This->dwLength = newLen;
255
256         return S_OK;
257 }
258
259 /**************************************************************************
260  * IStream_fnCopyTo
261  */
262 static HRESULT WINAPI IStream_fnCopyTo (IStream * iface, IStream* pstm, ULARGE_INTEGER cb, ULARGE_INTEGER* pcbRead, ULARGE_INTEGER* pcbWritten)
263 {
264         ISHRegStream *This = impl_from_IStream(iface);
265
266         TRACE("(%p)\n",This);
267         if (pcbRead)
268           pcbRead->QuadPart = 0;
269         if (pcbWritten)
270           pcbWritten->QuadPart = 0;
271
272         /* TODO implement */
273         return E_NOTIMPL;
274 }
275
276 /**************************************************************************
277  * IStream_fnCommit
278  */
279 static HRESULT WINAPI IStream_fnCommit (IStream * iface, DWORD grfCommitFlags)
280 {
281         ISHRegStream *This = impl_from_IStream(iface);
282
283         TRACE("(%p)\n",This);
284
285         /* commit not supported by this stream */
286         return E_NOTIMPL;
287 }
288
289 /**************************************************************************
290  * IStream_fnRevert
291  */
292 static HRESULT WINAPI IStream_fnRevert (IStream * iface)
293 {
294         ISHRegStream *This = impl_from_IStream(iface);
295
296         TRACE("(%p)\n",This);
297
298         /* revert not supported by this stream */
299         return E_NOTIMPL;
300 }
301
302 /**************************************************************************
303  * IStream_fnLockUnlockRegion
304  */
305 static HRESULT WINAPI IStream_fnLockUnlockRegion (IStream * iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
306 {
307         ISHRegStream *This = impl_from_IStream(iface);
308
309         TRACE("(%p)\n",This);
310
311         /* lock/unlock not supported by this stream */
312         return E_NOTIMPL;
313 }
314
315 /*************************************************************************
316  * IStream_fnStat
317  */
318 static HRESULT WINAPI IStream_fnStat (IStream * iface, STATSTG* pstatstg, DWORD grfStatFlag)
319 {
320         ISHRegStream *This = impl_from_IStream(iface);
321
322         TRACE("(%p, %p, %d)\n",This,pstatstg,grfStatFlag);
323
324         pstatstg->pwcsName = NULL;
325         pstatstg->type = STGTY_STREAM;
326         pstatstg->cbSize.QuadPart = This->dwLength;
327         pstatstg->mtime.dwHighDateTime = 0;
328         pstatstg->mtime.dwLowDateTime = 0;
329         pstatstg->ctime.dwHighDateTime = 0;
330         pstatstg->ctime.dwLowDateTime = 0;
331         pstatstg->atime.dwHighDateTime = 0;
332         pstatstg->atime.dwLowDateTime = 0;
333         pstatstg->grfMode = This->dwMode;
334         pstatstg->grfLocksSupported = 0;
335         pstatstg->clsid = CLSID_NULL;
336         pstatstg->grfStateBits = 0;
337         pstatstg->reserved = 0;
338
339         return S_OK;
340 }
341
342 /*************************************************************************
343  * IStream_fnClone
344  */
345 static HRESULT WINAPI IStream_fnClone (IStream * iface, IStream** ppstm)
346 {
347         ISHRegStream *This = impl_from_IStream(iface);
348
349         TRACE("(%p)\n",This);
350         *ppstm = NULL;
351
352         /* clone not supported by this stream */
353         return E_NOTIMPL;
354 }
355
356 static const IStreamVtbl rstvt =
357 {
358         IStream_fnQueryInterface,
359         IStream_fnAddRef,
360         IStream_fnRelease,
361         IStream_fnRead,
362         IStream_fnWrite,
363         IStream_fnSeek,
364         IStream_fnSetSize,
365         IStream_fnCopyTo,
366         IStream_fnCommit,
367         IStream_fnRevert,
368         IStream_fnLockUnlockRegion,
369         IStream_fnLockUnlockRegion,
370         IStream_fnStat,
371         IStream_fnClone
372 };
373
374 /* Methods overridden by the dummy stream */
375
376 /**************************************************************************
377  *  IStream_fnAddRefDummy
378  */
379 static ULONG WINAPI IStream_fnAddRefDummy(IStream *iface)
380 {
381         ISHRegStream *This = impl_from_IStream(iface);
382         TRACE("(%p)\n", This);
383         return 2;
384 }
385
386 /**************************************************************************
387  *  IStream_fnReleaseDummy
388  */
389 static ULONG WINAPI IStream_fnReleaseDummy(IStream *iface)
390 {
391         ISHRegStream *This = impl_from_IStream(iface);
392         TRACE("(%p)\n", This);
393         return 1;
394 }
395
396 /**************************************************************************
397  * IStream_fnReadDummy
398  */
399 static HRESULT WINAPI IStream_fnReadDummy(IStream *iface, LPVOID pv, ULONG cb, ULONG* pcbRead)
400 {
401   if (pcbRead)
402     *pcbRead = 0;
403   return E_NOTIMPL;
404 }
405
406 static const IStreamVtbl DummyRegStreamVTable =
407 {
408   IStream_fnQueryInterface,
409   IStream_fnAddRefDummy,  /* Overridden */
410   IStream_fnReleaseDummy, /* Overridden */
411   IStream_fnReadDummy,    /* Overridden */
412   IStream_fnWrite,
413   IStream_fnSeek,
414   IStream_fnSetSize,
415   IStream_fnCopyTo,
416   IStream_fnCommit,
417   IStream_fnRevert,
418   IStream_fnLockUnlockRegion,
419   IStream_fnLockUnlockRegion,
420   IStream_fnStat,
421   IStream_fnClone
422 };
423
424 /* Dummy registry stream object */
425 static ISHRegStream rsDummyRegStream =
426 {
427  { &DummyRegStreamVTable },
428  1,
429  NULL,
430  NULL,
431  0,
432  0,
433  STGM_READWRITE,
434  {NULL},
435  FALSE
436 };
437
438 /**************************************************************************
439  * IStream_Create
440  *
441  * Internal helper: Create and initialise a new registry stream object.
442  */
443 static ISHRegStream *IStream_Create(HKEY hKey, LPBYTE pbBuffer, DWORD dwLength)
444 {
445  ISHRegStream* regStream;
446
447  regStream = HeapAlloc(GetProcessHeap(), 0, sizeof(ISHRegStream));
448
449  if (regStream)
450  {
451    regStream->IStream_iface.lpVtbl = &rstvt;
452    regStream->ref = 1;
453    regStream->hKey = hKey;
454    regStream->pbBuffer = pbBuffer;
455    regStream->dwLength = dwLength;
456    regStream->dwPos = 0;
457    regStream->dwMode = STGM_READWRITE;
458    regStream->u.keyNameA = NULL;
459    regStream->bUnicode = FALSE;
460  }
461  TRACE ("Returning %p\n", regStream);
462  return regStream;
463 }
464
465 /*************************************************************************
466  * SHOpenRegStream2A    [SHLWAPI.@]
467  *
468  * Create a stream to read binary registry data.
469  *
470  * PARAMS
471  * hKey      [I] Registry handle
472  * pszSubkey [I] The sub key name
473  * pszValue  [I] The value name under the sub key
474  * dwMode    [I] Unused
475  *
476  * RETURNS
477  * Success: An IStream interface referring to the registry data
478  * Failure: NULL, if the registry key could not be opened or is not binary.
479  */
480 IStream * WINAPI SHOpenRegStream2A(HKEY hKey, LPCSTR pszSubkey,
481                                    LPCSTR pszValue,DWORD dwMode)
482 {
483   ISHRegStream *tmp;
484   HKEY hStrKey = NULL;
485   LPBYTE lpBuff = NULL;
486   DWORD dwLength = 0;
487   LONG ret;
488
489   TRACE("(%p,%s,%s,0x%08x)\n", hKey, pszSubkey, pszValue, dwMode);
490
491   if (dwMode == STGM_READ)
492     ret = RegOpenKeyExA(hKey, pszSubkey, 0, KEY_READ, &hStrKey);
493   else /* in write mode we make sure the subkey exits */
494     ret = RegCreateKeyExA(hKey, pszSubkey, 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &hStrKey, NULL);
495
496   if (ret == ERROR_SUCCESS)
497   {
498     if (dwMode == STGM_READ || dwMode == STGM_READWRITE)
499     {
500       /* read initial data */
501       ret = RegQueryValueExA(hStrKey, pszValue, 0, 0, 0, &dwLength);
502       if (ret == ERROR_SUCCESS && dwLength)
503       {
504         lpBuff = HeapAlloc(GetProcessHeap(), 0, dwLength);
505         RegQueryValueExA(hStrKey, pszValue, 0, 0, lpBuff, &dwLength);
506       }
507     }
508
509     if (!dwLength)
510       lpBuff = HeapAlloc(GetProcessHeap(), 0, dwLength);
511
512     tmp = IStream_Create(hStrKey, lpBuff, dwLength);
513     if(tmp)
514     {
515       if(pszValue)
516       {
517         int len = lstrlenA(pszValue) + 1;
518         tmp->u.keyNameA = HeapAlloc(GetProcessHeap(), 0, len);
519         memcpy(tmp->u.keyNameA, pszValue, len);
520       }
521
522       tmp->dwMode = dwMode;
523       tmp->bUnicode = FALSE;
524       return &tmp->IStream_iface;
525     }
526   }
527
528   HeapFree(GetProcessHeap(), 0, lpBuff);
529   if (hStrKey)
530     RegCloseKey(hStrKey);
531   return NULL;
532 }
533
534 /*************************************************************************
535  * SHOpenRegStream2W    [SHLWAPI.@]
536  *
537  * See SHOpenRegStream2A.
538  */
539 IStream * WINAPI SHOpenRegStream2W(HKEY hKey, LPCWSTR pszSubkey,
540                                    LPCWSTR pszValue, DWORD dwMode)
541 {
542   ISHRegStream *tmp;
543   HKEY hStrKey = NULL;
544   LPBYTE lpBuff = NULL;
545   DWORD dwLength = 0;
546   LONG ret;
547
548   TRACE("(%p,%s,%s,0x%08x)\n", hKey, debugstr_w(pszSubkey),
549         debugstr_w(pszValue), dwMode);
550
551   if (dwMode == STGM_READ)
552     ret = RegOpenKeyExW(hKey, pszSubkey, 0, KEY_READ, &hStrKey);
553   else /* in write mode we make sure the subkey exits */
554     ret = RegCreateKeyExW(hKey, pszSubkey, 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &hStrKey, NULL);
555
556   if (ret == ERROR_SUCCESS)
557   {
558     if (dwMode == STGM_READ || dwMode == STGM_READWRITE)
559     {
560       /* read initial data */
561       ret = RegQueryValueExW(hStrKey, pszValue, 0, 0, 0, &dwLength);
562       if (ret == ERROR_SUCCESS && dwLength)
563       {
564         lpBuff = HeapAlloc(GetProcessHeap(), 0, dwLength);
565         RegQueryValueExW(hStrKey, pszValue, 0, 0, lpBuff, &dwLength);
566       }
567     }
568
569     if (!dwLength)
570       lpBuff = HeapAlloc(GetProcessHeap(), 0, dwLength);
571
572     tmp = IStream_Create(hStrKey, lpBuff, dwLength);
573     if(tmp)
574     {
575       if(pszValue)
576       {
577         int len = lstrlenW(pszValue) + 1;
578         tmp->u.keyNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
579         memcpy(tmp->u.keyNameW, pszValue, len * sizeof(WCHAR));
580       }
581
582       tmp->dwMode = dwMode;
583       tmp->bUnicode = TRUE;
584       return &tmp->IStream_iface;
585     }
586   }
587
588   HeapFree(GetProcessHeap(), 0, lpBuff);
589   if (hStrKey)
590     RegCloseKey(hStrKey);
591   return NULL;
592 }
593
594 /*************************************************************************
595  * SHOpenRegStreamA     [SHLWAPI.@]
596  *
597  * Create a stream to read binary registry data.
598  *
599  * PARAMS
600  * hKey      [I] Registry handle
601  * pszSubkey [I] The sub key name
602  * pszValue  [I] The value name under the sub key
603  * dwMode    [I] STGM mode for opening the file
604  *
605  * RETURNS
606  * Success: An IStream interface referring to the registry data
607  * Failure: If the registry key could not be opened or is not binary,
608  *          A dummy (empty) IStream object is returned.
609  */
610 IStream * WINAPI SHOpenRegStreamA(HKEY hkey, LPCSTR pszSubkey,
611                                   LPCSTR pszValue, DWORD dwMode)
612 {
613   IStream *iStream;
614
615   TRACE("(%p,%s,%s,0x%08x)\n", hkey, pszSubkey, pszValue, dwMode);
616
617   iStream = SHOpenRegStream2A(hkey, pszSubkey, pszValue, dwMode);
618   return iStream ? iStream : &rsDummyRegStream.IStream_iface;
619 }
620
621 /*************************************************************************
622  * SHOpenRegStreamW     [SHLWAPI.@]
623  *
624  * See SHOpenRegStreamA.
625  */
626 IStream * WINAPI SHOpenRegStreamW(HKEY hkey, LPCWSTR pszSubkey,
627                                   LPCWSTR pszValue, DWORD dwMode)
628 {
629   IStream *iStream;
630
631   TRACE("(%p,%s,%s,0x%08x)\n", hkey, debugstr_w(pszSubkey),
632         debugstr_w(pszValue), dwMode);
633   iStream = SHOpenRegStream2W(hkey, pszSubkey, pszValue, dwMode);
634   return iStream ? iStream : &rsDummyRegStream.IStream_iface;
635 }
636
637 /*************************************************************************
638  * @   [SHLWAPI.12]
639  *
640  * Create an IStream object on a block of memory.
641  *
642  * PARAMS
643  * lpbData   [I] Memory block to create the IStream object on
644  * dwDataLen [I] Length of data block
645  *
646  * RETURNS
647  * Success: A pointer to the IStream object.
648  * Failure: NULL, if any parameters are invalid or an error occurs.
649  *
650  * NOTES
651  *  A copy of the memory pointed to by lpbData is made, and is freed
652  *  when the stream is released.
653  */
654 IStream * WINAPI SHCreateMemStream(const BYTE *lpbData, UINT dwDataLen)
655 {
656   ISHRegStream *strm = NULL;
657   LPBYTE lpbDup;
658
659   TRACE("(%p,%d)\n", lpbData, dwDataLen);
660
661   if (!lpbData)
662     dwDataLen = 0;
663
664   lpbDup = HeapAlloc(GetProcessHeap(), 0, dwDataLen);
665
666   if (lpbDup)
667   {
668     memcpy(lpbDup, lpbData, dwDataLen);
669     strm = IStream_Create(NULL, lpbDup, dwDataLen);
670
671     if (!strm)
672       HeapFree(GetProcessHeap(), 0, lpbDup);
673   }
674   return &strm->IStream_iface;
675 }
676
677 /*************************************************************************
678  * SHCreateStreamWrapper   [SHLWAPI.@]
679  *
680  * Create an IStream object on a block of memory.
681  *
682  * PARAMS
683  * lpbData    [I] Memory block to create the IStream object on
684  * dwDataLen  [I] Length of data block
685  * dwReserved [I] Reserved, Must be 0.
686  * lppStream  [O] Destination for IStream object
687  *
688  * RETURNS
689  * Success: S_OK. lppStream contains the new IStream object.
690  * Failure: E_INVALIDARG, if any parameters are invalid,
691  *          E_OUTOFMEMORY if memory allocation fails.
692  *
693  * NOTES
694  *  The stream assumes ownership of the memory passed to it.
695  */
696 HRESULT WINAPI SHCreateStreamWrapper(LPBYTE lpbData, DWORD dwDataLen,
697                                      DWORD dwReserved, IStream **lppStream)
698 {
699   ISHRegStream *strm;
700
701   if (lppStream)
702     *lppStream = NULL;
703
704   if(dwReserved || !lppStream)
705     return E_INVALIDARG;
706
707   strm = IStream_Create(NULL, lpbData, dwDataLen);
708
709   if(!strm)
710     return E_OUTOFMEMORY;
711
712   IStream_QueryInterface(&strm->IStream_iface, &IID_IStream, (void**)lppStream);
713   IStream_Release(&strm->IStream_iface);
714   return S_OK;
715 }