ReactOS 0.4.15-dev-8408-g466a198
regstream.c
Go to the documentation of this file.
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
37
38typedef struct
39{
47 union {
50 }u;
53
55{
56 return CONTAINING_RECORD(iface, ISHRegStream, IStream_iface);
57}
58
59/**************************************************************************
60* IStream_fnQueryInterface
61*/
63{
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) || IsEqualIID(riid, &IID_IStream))
71 *ppvObj = &This->IStream_iface;
72
73 if(*ppvObj)
74 {
75 IStream_AddRef((IStream*)*ppvObj);
76 TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
77 return S_OK;
78 }
79 TRACE("-- Interface: E_NOINTERFACE\n");
80 return E_NOINTERFACE;
81}
82
83/**************************************************************************
84* IStream_fnAddRef
85*/
87{
89 ULONG refCount = InterlockedIncrement(&This->ref);
90
91 TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
92
93 return refCount;
94}
95
96/**************************************************************************
97* IStream_fnRelease
98*/
100{
102 ULONG refCount = InterlockedDecrement(&This->ref);
103
104 TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
105
106 if (!refCount)
107 {
108 TRACE(" destroying SHReg IStream (%p)\n",This);
109
110 if (This->hKey)
111 {
112 /* write back data in REG_BINARY */
113 if (This->dwMode == STGM_READWRITE || This->dwMode == STGM_WRITE)
114 {
115 if (This->dwLength)
116 {
117 if (This->bUnicode)
118 RegSetValueExW(This->hKey, This->u.keyNameW, 0, REG_BINARY,
119 (const BYTE *) This->pbBuffer, This->dwLength);
120 else
121 RegSetValueExA(This->hKey, This->u.keyNameA, 0, REG_BINARY,
122 (const BYTE *) This->pbBuffer, This->dwLength);
123 }
124 else
125 {
126 if (This->bUnicode)
127 RegDeleteValueW(This->hKey, This->u.keyNameW);
128 else
129 RegDeleteValueA(This->hKey, This->u.keyNameA);
130 }
131 }
132
133 RegCloseKey(This->hKey);
134 }
135
136 HeapFree(GetProcessHeap(),0,This->u.keyNameA);
137 HeapFree(GetProcessHeap(),0,This->pbBuffer);
139 return 0;
140 }
141
142 return refCount;
143}
144
145/**************************************************************************
146 * IStream_fnRead
147 */
148static HRESULT WINAPI IStream_fnRead (IStream * iface, void* pv, ULONG cb, ULONG* pcbRead)
149{
151 DWORD dwBytesToRead;
152
153 TRACE("(%p)->(%p,0x%08x,%p)\n",This, pv, cb, pcbRead);
154
155 if (This->dwPos >= This->dwLength)
156 dwBytesToRead = 0;
157 else
158 dwBytesToRead = This->dwLength - This->dwPos;
159
160 dwBytesToRead = (cb > dwBytesToRead) ? dwBytesToRead : cb;
161 if (dwBytesToRead != 0) /* not at end of buffer and we want to read something */
162 {
163 memmove(pv, This->pbBuffer + This->dwPos, dwBytesToRead);
164 This->dwPos += dwBytesToRead; /* adjust pointer */
165 }
166
167 if (pcbRead)
168 *pcbRead = dwBytesToRead;
169
170 return S_OK;
171}
172
173/**************************************************************************
174 * IStream_fnWrite
175 */
176static HRESULT WINAPI IStream_fnWrite (IStream * iface, const void* pv, ULONG cb, ULONG* pcbWritten)
177{
179 DWORD newLen = This->dwPos + cb;
180
181 TRACE("(%p, %p, %d, %p)\n",This, pv, cb, pcbWritten);
182
183 if (newLen < This->dwPos) /* overflow */
185
186 if (newLen > This->dwLength)
187 {
188 LPBYTE newBuf = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pbBuffer, newLen);
189 if (!newBuf)
191
192 This->dwLength = newLen;
193 This->pbBuffer = newBuf;
194 }
195 memmove(This->pbBuffer + This->dwPos, pv, cb);
196 This->dwPos += cb; /* adjust pointer */
197
198 if (pcbWritten)
199 *pcbWritten = cb;
200
201 return S_OK;
202}
203
204/**************************************************************************
205 * IStream_fnSeek
206 */
207static HRESULT WINAPI IStream_fnSeek (IStream * iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
208{
210 LARGE_INTEGER tmp;
211 TRACE("(%p, %s, %d %p)\n", This,
212 wine_dbgstr_longlong(dlibMove.QuadPart), dwOrigin, plibNewPosition);
213
214 if (dwOrigin == STREAM_SEEK_SET)
215 tmp = dlibMove;
216 else if (dwOrigin == STREAM_SEEK_CUR)
217 tmp.QuadPart = This->dwPos + dlibMove.QuadPart;
218 else if (dwOrigin == STREAM_SEEK_END)
219 tmp.QuadPart = This->dwLength + dlibMove.QuadPart;
220 else
222
223 if (tmp.QuadPart < 0)
225
226 /* we cut off the high part here */
227 This->dwPos = tmp.u.LowPart;
228
229 if (plibNewPosition)
230 plibNewPosition->QuadPart = This->dwPos;
231 return S_OK;
232}
233
234/**************************************************************************
235 * IStream_fnSetSize
236 */
238{
240 DWORD newLen;
241 LPBYTE newBuf;
242
243 TRACE("(%p, %s)\n", This, wine_dbgstr_longlong(libNewSize.QuadPart));
244
245 /* we cut off the high part here */
246 newLen = libNewSize.u.LowPart;
247 newBuf = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->pbBuffer, newLen);
248 if (!newBuf)
250
251 This->pbBuffer = newBuf;
252 This->dwLength = newLen;
253
254 return S_OK;
255}
256
257/**************************************************************************
258 * IStream_fnCopyTo
259 */
261{
263
264 TRACE("(%p)\n",This);
265 if (pcbRead)
266 pcbRead->QuadPart = 0;
267 if (pcbWritten)
268 pcbWritten->QuadPart = 0;
269
270 /* TODO implement */
271 return E_NOTIMPL;
272}
273
274/**************************************************************************
275 * IStream_fnCommit
276 */
277static HRESULT WINAPI IStream_fnCommit (IStream * iface, DWORD grfCommitFlags)
278{
280
281 TRACE("(%p)\n",This);
282
283 /* commit not supported by this stream */
284 return E_NOTIMPL;
285}
286
287/**************************************************************************
288 * IStream_fnRevert
289 */
291{
293
294 TRACE("(%p)\n",This);
295
296 /* revert not supported by this stream */
297 return E_NOTIMPL;
298}
299
300/**************************************************************************
301 * IStream_fnLockUnlockRegion
302 */
304{
306
307 TRACE("(%p)\n",This);
308
309 /* lock/unlock not supported by this stream */
310 return E_NOTIMPL;
311}
312
313/*************************************************************************
314 * IStream_fnStat
315 */
316static HRESULT WINAPI IStream_fnStat (IStream * iface, STATSTG* pstatstg, DWORD grfStatFlag)
317{
319
320 TRACE("(%p, %p, %d)\n",This,pstatstg,grfStatFlag);
321
322 pstatstg->pwcsName = NULL;
323 pstatstg->type = STGTY_STREAM;
324 pstatstg->cbSize.QuadPart = This->dwLength;
325 pstatstg->mtime.dwHighDateTime = 0;
326 pstatstg->mtime.dwLowDateTime = 0;
327 pstatstg->ctime.dwHighDateTime = 0;
328 pstatstg->ctime.dwLowDateTime = 0;
329 pstatstg->atime.dwHighDateTime = 0;
330 pstatstg->atime.dwLowDateTime = 0;
331 pstatstg->grfMode = This->dwMode;
332 pstatstg->grfLocksSupported = 0;
333 pstatstg->clsid = CLSID_NULL;
334 pstatstg->grfStateBits = 0;
335 pstatstg->reserved = 0;
336
337 return S_OK;
338}
339
340/*************************************************************************
341 * IStream_fnClone
342 */
344{
346
347 TRACE("(%p)\n",This);
348 *ppstm = NULL;
349
350 /* clone not supported by this stream */
351 return E_NOTIMPL;
352}
353
354static const IStreamVtbl rstvt =
355{
370};
371
372/* Methods overridden by the dummy stream */
373
374/**************************************************************************
375 * IStream_fnAddRefDummy
376 */
378{
380 TRACE("(%p)\n", This);
381 return 2;
382}
383
384/**************************************************************************
385 * IStream_fnReleaseDummy
386 */
388{
390 TRACE("(%p)\n", This);
391 return 1;
392}
393
394/**************************************************************************
395 * IStream_fnReadDummy
396 */
398{
399 if (pcbRead)
400 *pcbRead = 0;
401 return E_NOTIMPL;
402}
403
404static const IStreamVtbl DummyRegStreamVTable =
405{
407 IStream_fnAddRefDummy, /* Overridden */
408 IStream_fnReleaseDummy, /* Overridden */
409 IStream_fnReadDummy, /* Overridden */
420};
421
422/* Dummy registry stream object */
424{
426 1,
427 NULL,
428 NULL,
429 0,
430 0,
432 {NULL},
433 FALSE
434};
435
436/**************************************************************************
437 * IStream_Create
438 *
439 * Internal helper: Create and initialise a new registry stream object.
440 */
442{
443 ISHRegStream* regStream;
444
445 regStream = HeapAlloc(GetProcessHeap(), 0, sizeof(ISHRegStream));
446
447 if (regStream)
448 {
449 regStream->IStream_iface.lpVtbl = &rstvt;
450 regStream->ref = 1;
451 regStream->hKey = hKey;
452 regStream->pbBuffer = pbBuffer;
453 regStream->dwLength = dwLength;
454 regStream->dwPos = 0;
455 regStream->dwMode = STGM_READWRITE;
456 regStream->u.keyNameA = NULL;
457 regStream->bUnicode = FALSE;
458 }
459 TRACE ("Returning %p\n", regStream);
460 return regStream;
461}
462
463/*************************************************************************
464 * SHOpenRegStream2A [SHLWAPI.@]
465 *
466 * Create a stream to read binary registry data.
467 *
468 * PARAMS
469 * hKey [I] Registry handle
470 * pszSubkey [I] The sub key name
471 * pszValue [I] The value name under the sub key
472 * dwMode [I] Unused
473 *
474 * RETURNS
475 * Success: An IStream interface referring to the registry data
476 * Failure: NULL, if the registry key could not be opened or is not binary.
477 */
479 LPCSTR pszValue,DWORD dwMode)
480{
481 ISHRegStream *tmp;
482 HKEY hStrKey = NULL;
483 LPBYTE lpBuff = NULL;
484 DWORD dwLength = 0;
485 LONG ret;
486
487 TRACE("(%p,%s,%s,0x%08x)\n", hKey, pszSubkey, pszValue, dwMode);
488
489 if (dwMode == STGM_READ)
490 ret = RegOpenKeyExA(hKey, pszSubkey, 0, KEY_READ, &hStrKey);
491 else /* in write mode we make sure the subkey exits */
492 ret = RegCreateKeyExA(hKey, pszSubkey, 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &hStrKey, NULL);
493
494 if (ret == ERROR_SUCCESS)
495 {
496 if (dwMode == STGM_READ || dwMode == STGM_READWRITE)
497 {
498 /* read initial data */
499 ret = RegQueryValueExA(hStrKey, pszValue, 0, 0, 0, &dwLength);
500 if (ret == ERROR_SUCCESS && dwLength)
501 {
502 lpBuff = HeapAlloc(GetProcessHeap(), 0, dwLength);
503 RegQueryValueExA(hStrKey, pszValue, 0, 0, lpBuff, &dwLength);
504 }
505 }
506
507 if (!dwLength)
508 lpBuff = HeapAlloc(GetProcessHeap(), 0, dwLength);
509
510 tmp = IStream_Create(hStrKey, lpBuff, dwLength);
511 if(tmp)
512 {
513 if(pszValue)
514 {
515 int len = lstrlenA(pszValue) + 1;
516 tmp->u.keyNameA = HeapAlloc(GetProcessHeap(), 0, len);
517 memcpy(tmp->u.keyNameA, pszValue, len);
518 }
519
520 tmp->dwMode = dwMode;
521 tmp->bUnicode = FALSE;
522 return &tmp->IStream_iface;
523 }
524 }
525
526 HeapFree(GetProcessHeap(), 0, lpBuff);
527 if (hStrKey)
528 RegCloseKey(hStrKey);
529 return NULL;
530}
531
532/*************************************************************************
533 * SHOpenRegStream2W [SHLWAPI.@]
534 *
535 * See SHOpenRegStream2A.
536 */
538 LPCWSTR pszValue, DWORD dwMode)
539{
540 ISHRegStream *tmp;
541 HKEY hStrKey = NULL;
542 LPBYTE lpBuff = NULL;
543 DWORD dwLength = 0;
544 LONG ret;
545
546 TRACE("(%p,%s,%s,0x%08x)\n", hKey, debugstr_w(pszSubkey),
547 debugstr_w(pszValue), dwMode);
548
549 if (dwMode == STGM_READ)
550 ret = RegOpenKeyExW(hKey, pszSubkey, 0, KEY_READ, &hStrKey);
551 else /* in write mode we make sure the subkey exits */
552 ret = RegCreateKeyExW(hKey, pszSubkey, 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &hStrKey, NULL);
553
554 if (ret == ERROR_SUCCESS)
555 {
556 if (dwMode == STGM_READ || dwMode == STGM_READWRITE)
557 {
558 /* read initial data */
559 ret = RegQueryValueExW(hStrKey, pszValue, 0, 0, 0, &dwLength);
560 if (ret == ERROR_SUCCESS && dwLength)
561 {
562 lpBuff = HeapAlloc(GetProcessHeap(), 0, dwLength);
563 RegQueryValueExW(hStrKey, pszValue, 0, 0, lpBuff, &dwLength);
564 }
565 }
566
567 if (!dwLength)
568 lpBuff = HeapAlloc(GetProcessHeap(), 0, dwLength);
569
570 tmp = IStream_Create(hStrKey, lpBuff, dwLength);
571 if(tmp)
572 {
573 if(pszValue)
574 {
575 int len = lstrlenW(pszValue) + 1;
576 tmp->u.keyNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
577 memcpy(tmp->u.keyNameW, pszValue, len * sizeof(WCHAR));
578 }
579
580 tmp->dwMode = dwMode;
581 tmp->bUnicode = TRUE;
582 return &tmp->IStream_iface;
583 }
584 }
585
586 HeapFree(GetProcessHeap(), 0, lpBuff);
587 if (hStrKey)
588 RegCloseKey(hStrKey);
589 return NULL;
590}
591
592/*************************************************************************
593 * SHOpenRegStreamA [SHLWAPI.@]
594 *
595 * Create a stream to read binary registry data.
596 *
597 * PARAMS
598 * hKey [I] Registry handle
599 * pszSubkey [I] The sub key name
600 * pszValue [I] The value name under the sub key
601 * dwMode [I] STGM mode for opening the file
602 *
603 * RETURNS
604 * Success: An IStream interface referring to the registry data
605 * Failure: If the registry key could not be opened or is not binary,
606 * A dummy (empty) IStream object is returned.
607 */
609 LPCSTR pszValue, DWORD dwMode)
610{
611 IStream *iStream;
612
613 TRACE("(%p,%s,%s,0x%08x)\n", hkey, pszSubkey, pszValue, dwMode);
614
615 iStream = SHOpenRegStream2A(hkey, pszSubkey, pszValue, dwMode);
616 return iStream ? iStream : &rsDummyRegStream.IStream_iface;
617}
618
619/*************************************************************************
620 * SHOpenRegStreamW [SHLWAPI.@]
621 *
622 * See SHOpenRegStreamA.
623 */
625 LPCWSTR pszValue, DWORD dwMode)
626{
627 IStream *iStream;
628
629 TRACE("(%p,%s,%s,0x%08x)\n", hkey, debugstr_w(pszSubkey),
630 debugstr_w(pszValue), dwMode);
631 iStream = SHOpenRegStream2W(hkey, pszSubkey, pszValue, dwMode);
632 return iStream ? iStream : &rsDummyRegStream.IStream_iface;
633}
634
635/*************************************************************************
636 * @ [SHLWAPI.12]
637 *
638 * Create an IStream object on a block of memory.
639 *
640 * PARAMS
641 * lpbData [I] Memory block to create the IStream object on
642 * dwDataLen [I] Length of data block
643 *
644 * RETURNS
645 * Success: A pointer to the IStream object.
646 * Failure: NULL, if any parameters are invalid or an error occurs.
647 *
648 * NOTES
649 * A copy of the memory pointed to by lpbData is made, and is freed
650 * when the stream is released.
651 */
652IStream * WINAPI SHCreateMemStream(const BYTE *lpbData, UINT dwDataLen)
653{
654 ISHRegStream *strm = NULL;
655 LPBYTE lpbDup;
656
657 TRACE("(%p,%d)\n", lpbData, dwDataLen);
658
659 if (!lpbData)
660 dwDataLen = 0;
661
662 lpbDup = HeapAlloc(GetProcessHeap(), 0, dwDataLen);
663
664 if (lpbDup)
665 {
666 memcpy(lpbDup, lpbData, dwDataLen);
667 strm = IStream_Create(NULL, lpbDup, dwDataLen);
668
669 if (!strm)
670 HeapFree(GetProcessHeap(), 0, lpbDup);
671 }
672#ifdef __REACTOS__
673 if (!strm)
674 return NULL;
675#endif
676 return &strm->IStream_iface;
677}
678
679/*************************************************************************
680 * SHCreateStreamWrapper [SHLWAPI.@]
681 *
682 * Create an IStream object on a block of memory.
683 *
684 * PARAMS
685 * lpbData [I] Memory block to create the IStream object on
686 * dwDataLen [I] Length of data block
687 * dwReserved [I] Reserved, Must be 0.
688 * lppStream [O] Destination for IStream object
689 *
690 * RETURNS
691 * Success: S_OK. lppStream contains the new IStream object.
692 * Failure: E_INVALIDARG, if any parameters are invalid,
693 * E_OUTOFMEMORY if memory allocation fails.
694 *
695 * NOTES
696 * The stream assumes ownership of the memory passed to it.
697 */
699 DWORD dwReserved, IStream **lppStream)
700{
701 ISHRegStream *strm;
702
703 if (lppStream)
704 *lppStream = NULL;
705
706 if(dwReserved || !lppStream)
707 return E_INVALIDARG;
708
709 strm = IStream_Create(NULL, lpbData, dwDataLen);
710
711 if(!strm)
712 return E_OUTOFMEMORY;
713
714 IStream_QueryInterface(&strm->IStream_iface, &IID_IStream, (void**)lppStream);
715 IStream_Release(&strm->IStream_iface);
716 return S_OK;
717}
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
const GUID IID_IUnknown
#define RegCloseKey(hKey)
Definition: registry.h:49
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1096
LONG WINAPI RegSetValueExA(HKEY hKey, LPCSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE *lpData, DWORD cbData)
Definition: reg.c:4799
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3298
LONG WINAPI RegDeleteValueA(HKEY hKey, LPCSTR lpValueName)
Definition: reg.c:2287
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
LONG WINAPI RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName)
Definition: reg.c:2330
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4009
LONG WINAPI RegCreateKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD Reserved, _In_ LPSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_ LPDWORD lpdwDisposition)
Definition: reg.c:1034
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapReAlloc
Definition: compat.h:734
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
#define HeapFree(x, y, z)
Definition: compat.h:735
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define lstrlenW
Definition: compat.h:750
static DWORD DWORD * dwLength
Definition: fusion.c:86
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
FxAutoRegKey hKey
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
REFIID riid
Definition: atlbase.h:39
#define S_OK
Definition: intsafe.h:52
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_w
Definition: kernel32.h:32
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:95
unsigned int UINT
Definition: ndis.h:50
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_READ
Definition: nt_native.h:1023
#define KEY_WRITE
Definition: nt_native.h:1031
#define STGM_READWRITE
Definition: objbase.h:919
#define STGM_WRITE
Definition: objbase.h:918
#define STGM_READ
Definition: objbase.h:917
long LONG
Definition: pedump.c:60
#define CLSID_NULL
Definition: guiddef.h:99
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define REFIID
Definition: guiddef.h:118
static const IStreamVtbl rstvt
Definition: regstream.c:354
IStream *WINAPI SHOpenRegStreamW(HKEY hkey, LPCWSTR pszSubkey, LPCWSTR pszValue, DWORD dwMode)
Definition: regstream.c:624
static HRESULT WINAPI IStream_fnSeek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
Definition: regstream.c:207
static HRESULT WINAPI IStream_fnSetSize(IStream *iface, ULARGE_INTEGER libNewSize)
Definition: regstream.c:237
static ULONG WINAPI IStream_fnReleaseDummy(IStream *iface)
Definition: regstream.c:387
static ISHRegStream * impl_from_IStream(IStream *iface)
Definition: regstream.c:54
HRESULT WINAPI SHCreateStreamWrapper(LPBYTE lpbData, DWORD dwDataLen, DWORD dwReserved, IStream **lppStream)
Definition: regstream.c:698
static HRESULT WINAPI IStream_fnCopyTo(IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
Definition: regstream.c:260
IStream *WINAPI SHOpenRegStream2A(HKEY hKey, LPCSTR pszSubkey, LPCSTR pszValue, DWORD dwMode)
Definition: regstream.c:478
static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj)
Definition: regstream.c:62
static HRESULT WINAPI IStream_fnStat(IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
Definition: regstream.c:316
static HRESULT WINAPI IStream_fnWrite(IStream *iface, const void *pv, ULONG cb, ULONG *pcbWritten)
Definition: regstream.c:176
static ULONG WINAPI IStream_fnRelease(IStream *iface)
Definition: regstream.c:99
static HRESULT WINAPI IStream_fnRevert(IStream *iface)
Definition: regstream.c:290
static HRESULT WINAPI IStream_fnLockUnlockRegion(IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: regstream.c:303
IStream *WINAPI SHOpenRegStreamA(HKEY hkey, LPCSTR pszSubkey, LPCSTR pszValue, DWORD dwMode)
Definition: regstream.c:608
static ULONG WINAPI IStream_fnAddRefDummy(IStream *iface)
Definition: regstream.c:377
static ISHRegStream rsDummyRegStream
Definition: regstream.c:423
static HRESULT WINAPI IStream_fnCommit(IStream *iface, DWORD grfCommitFlags)
Definition: regstream.c:277
static HRESULT WINAPI IStream_fnReadDummy(IStream *iface, LPVOID pv, ULONG cb, ULONG *pcbRead)
Definition: regstream.c:397
IStream *WINAPI SHOpenRegStream2W(HKEY hKey, LPCWSTR pszSubkey, LPCWSTR pszValue, DWORD dwMode)
Definition: regstream.c:537
IStream *WINAPI SHCreateMemStream(const BYTE *lpbData, UINT dwDataLen)
Definition: regstream.c:652
static HRESULT WINAPI IStream_fnRead(IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
Definition: regstream.c:148
static const IStreamVtbl DummyRegStreamVTable
Definition: regstream.c:404
static HRESULT WINAPI IStream_fnClone(IStream *iface, IStream **ppstm)
Definition: regstream.c:343
static ULONG WINAPI IStream_fnAddRef(IStream *iface)
Definition: regstream.c:86
static ISHRegStream * IStream_Create(HKEY hKey, LPBYTE pbBuffer, DWORD dwLength)
Definition: regstream.c:441
#define TRACE(s)
Definition: solgame.cpp:4
LPWSTR keyNameW
Definition: regstream.c:49
LPSTR keyNameA
Definition: regstream.c:48
LPBYTE pbBuffer
Definition: regstream.c:43
union ISHRegStream::@557 u
BOOL bUnicode
Definition: regstream.c:51
DWORD dwLength
Definition: regstream.c:44
DWORD dwMode
Definition: regstream.c:46
DWORD dwPos
Definition: regstream.c:45
IStream IStream_iface
Definition: regstream.c:40
struct _ULARGE_INTEGER::@4136 u
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
unsigned char * LPBYTE
Definition: typedefs.h:53
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
LONGLONG QuadPart
Definition: typedefs.h:114
struct _LARGE_INTEGER::@2289 u
int ret
#define WINAPI
Definition: msvc.h:6
#define E_NOINTERFACE
Definition: winerror.h:2364
#define STG_E_INVALIDPARAMETER
Definition: winerror.h:2580
#define STG_E_INVALIDFUNCTION
Definition: winerror.h:2564
#define STG_E_INSUFFICIENTMEMORY
Definition: winerror.h:2570
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193