ReactOS  0.4.13-dev-259-g5ca9c9c
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 
38 typedef struct
39 {
47  union {
50  }u;
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 */
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  */
148 static 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  */
176 static 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  */
207 static 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
221  return STG_E_INVALIDPARAMETER;
222 
223  if (tmp.QuadPart < 0)
224  return STG_E_INVALIDFUNCTION;
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  */
277 static 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  */
316 static 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  */
343 static HRESULT WINAPI IStream_fnClone (IStream * iface, IStream** ppstm)
344 {
346 
347  TRACE("(%p)\n",This);
348  *ppstm = NULL;
349 
350  /* clone not supported by this stream */
351  return E_NOTIMPL;
352 }
353 
354 static 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 
404 static 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  */
652 IStream * 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  return &strm->IStream_iface;
673 }
674 
675 /*************************************************************************
676  * SHCreateStreamWrapper [SHLWAPI.@]
677  *
678  * Create an IStream object on a block of memory.
679  *
680  * PARAMS
681  * lpbData [I] Memory block to create the IStream object on
682  * dwDataLen [I] Length of data block
683  * dwReserved [I] Reserved, Must be 0.
684  * lppStream [O] Destination for IStream object
685  *
686  * RETURNS
687  * Success: S_OK. lppStream contains the new IStream object.
688  * Failure: E_INVALIDARG, if any parameters are invalid,
689  * E_OUTOFMEMORY if memory allocation fails.
690  *
691  * NOTES
692  * The stream assumes ownership of the memory passed to it.
693  */
695  DWORD dwReserved, IStream **lppStream)
696 {
697  ISHRegStream *strm;
698 
699  if (lppStream)
700  *lppStream = NULL;
701 
702  if(dwReserved || !lppStream)
703  return E_INVALIDARG;
704 
705  strm = IStream_Create(NULL, lpbData, dwDataLen);
706 
707  if(!strm)
708  return E_OUTOFMEMORY;
709 
710  IStream_QueryInterface(&strm->IStream_iface, &IID_IStream, (void**)lppStream);
711  IStream_Release(&strm->IStream_iface);
712  return S_OK;
713 }
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
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:4041
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
IStream *WINAPI SHOpenRegStream2A(HKEY hKey, LPCSTR pszSubkey, LPCSTR pszValue, DWORD dwMode)
Definition: regstream.c:478
#define REFIID
Definition: guiddef.h:113
#define TRUE
Definition: types.h:120
LPSTR keyNameA
Definition: regstream.c:48
#define E_NOINTERFACE
Definition: winerror.h:2364
#define ERROR_SUCCESS
Definition: deptool.c:10
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
static HRESULT WINAPI IStream_fnStat(IStream *iface, STATSTG *pstatstg, DWORD grfStatFlag)
Definition: regstream.c:316
static ISHRegStream rsDummyRegStream
Definition: regstream.c:423
IStream *WINAPI SHOpenRegStreamA(HKEY hkey, LPCSTR pszSubkey, LPCSTR pszValue, DWORD dwMode)
Definition: regstream.c:608
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_READ
Definition: nt_native.h:1023
REFIID riid
Definition: precomp.h:44
static HRESULT WINAPI IStream_fnLockUnlockRegion(IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: regstream.c:303
static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj)
Definition: regstream.c:62
DWORD dwLength
Definition: regstream.c:44
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3346
#define STG_E_INSUFFICIENTMEMORY
Definition: winerror.h:2570
IStream *WINAPI SHOpenRegStream2W(HKEY hKey, LPCWSTR pszSubkey, LPCWSTR pszValue, DWORD dwMode)
Definition: regstream.c:537
char * LPSTR
Definition: xmlstorage.h:182
#define lstrlenW
Definition: compat.h:407
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:1094
union ISHRegStream::@524 u
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:52
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:90
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
#define debugstr_w
Definition: kernel32.h:32
#define E_INVALIDARG
Definition: ddrawi.h:101
smooth NULL
Definition: ftsmooth.c:416
#define STGM_WRITE
Definition: objbase.h:917
LPBYTE pbBuffer
Definition: regstream.c:43
static HRESULT WINAPI IStream_fnCommit(IStream *iface, DWORD grfCommitFlags)
Definition: regstream.c:277
const char * LPCSTR
Definition: xmlstorage.h:183
#define STG_E_INVALIDFUNCTION
Definition: winerror.h:2564
static HRESULT WINAPI IStream_fnRead(IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
Definition: regstream.c:148
#define debugstr_guid
Definition: kernel32.h:35
WINE_DEFAULT_DEBUG_CHANNEL(shell)
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
static HRESULT WINAPI IStream_fnClone(IStream *iface, IStream **ppstm)
Definition: regstream.c:343
#define STGM_READ
Definition: objbase.h:916
#define KEY_WRITE
Definition: nt_native.h:1031
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:4917
struct _ULARGE_INTEGER::@3737 u
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
__wchar_t WCHAR
Definition: xmlstorage.h:180
static DWORD DWORD * dwLength
Definition: fusion.c:83
#define CLSID_NULL
Definition: guiddef.h:94
LONG HRESULT
Definition: typedefs.h:77
const GUID IID_IUnknown
static HRESULT WINAPI IStream_fnSeek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
Definition: regstream.c:207
BOOL bUnicode
Definition: regstream.c:51
IStream *WINAPI SHCreateMemStream(const BYTE *lpbData, UINT dwDataLen)
Definition: regstream.c:652
#define WINAPI
Definition: msvc.h:8
static const IStreamVtbl DummyRegStreamVTable
Definition: regstream.c:404
unsigned long DWORD
Definition: ntddk_ex.h:95
IStream IStream_iface
Definition: regstream.c:40
#define STG_E_INVALIDPARAMETER
Definition: winerror.h:2580
static DWORD cb
Definition: integrity.c:41
IStream *WINAPI SHOpenRegStreamW(HKEY hkey, LPCWSTR pszSubkey, LPCWSTR pszValue, DWORD dwMode)
Definition: regstream.c:624
LPWSTR keyNameW
Definition: regstream.c:49
int ret
#define InterlockedDecrement
Definition: armddk.h:52
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
unsigned char BYTE
Definition: mem.h:68
DWORD dwPos
Definition: regstream.c:45
HRESULT WINAPI SHCreateStreamWrapper(LPBYTE lpbData, DWORD dwDataLen, DWORD dwReserved, IStream **lppStream)
Definition: regstream.c:694
#define STGM_READWRITE
Definition: objbase.h:918
#define S_OK
Definition: intsafe.h:59
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define InterlockedIncrement
Definition: armddk.h:53
LONG WINAPI RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName)
Definition: reg.c:2368
static HRESULT WINAPI IStream_fnWrite(IStream *iface, const void *pv, ULONG cb, ULONG *pcbWritten)
Definition: regstream.c:176
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
static ULONG WINAPI IStream_fnReleaseDummy(IStream *iface)
Definition: regstream.c:387
static ISHRegStream * impl_from_IStream(IStream *iface)
Definition: regstream.c:54
#define HeapReAlloc
Definition: compat.h:393
#define E_NOTIMPL
Definition: ddrawi.h:99
LONG WINAPI RegDeleteValueA(HKEY hKey, LPCSTR lpValueName)
Definition: reg.c:2331
unsigned int UINT
Definition: ndis.h:50
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
static HRESULT WINAPI IStream_fnRevert(IStream *iface)
Definition: regstream.c:290
static ISHRegStream * IStream_Create(HKEY hKey, LPBYTE pbBuffer, DWORD dwLength)
Definition: regstream.c:441
static HRESULT WINAPI IStream_fnReadDummy(IStream *iface, LPVOID pv, ULONG cb, ULONG *pcbRead)
Definition: regstream.c:397
static ULONG WINAPI IStream_fnAddRefDummy(IStream *iface)
Definition: regstream.c:377
struct _LARGE_INTEGER::@2192 u
static HRESULT WINAPI IStream_fnSetSize(IStream *iface, ULARGE_INTEGER libNewSize)
Definition: regstream.c:237
static HRESULT WINAPI IStream_fnCopyTo(IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
Definition: regstream.c:260
unsigned int ULONG
Definition: retypes.h:1
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:41
DWORD dwMode
Definition: regstream.c:46
LONG WINAPI RegSetValueExA(HKEY hKey, LPCSTR lpValueName, DWORD Reserved, DWORD dwType, CONST BYTE *lpData, DWORD cbData)
Definition: reg.c:4831
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:1032
WCHAR * LPWSTR
Definition: xmlstorage.h:184
static ULONG WINAPI IStream_fnAddRef(IStream *iface)
Definition: regstream.c:86
static const IStreamVtbl rstvt
Definition: regstream.c:354
#define HeapFree(x, y, z)
Definition: compat.h:394
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:90
static ULONG WINAPI IStream_fnRelease(IStream *iface)
Definition: regstream.c:99
LONGLONG QuadPart
Definition: typedefs.h:112