ReactOS 0.4.15-dev-7674-gc0b4db1
istream.c
Go to the documentation of this file.
1/*
2 * SHLWAPI IStream functions
3 *
4 * Copyright 2002 Jon Griffiths
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20#include <stdarg.h>
21#include <string.h>
22
23#define COBJMACROS
24#define NONAMELESSUNION
25
26#include "windef.h"
27#include "winbase.h"
28#include "winerror.h"
29#include "winnls.h"
30#define NO_SHLWAPI_REG
31#define NO_SHLWAPI_PATH
32#include "shlwapi.h"
33#include "wine/debug.h"
34
36
37#define STGM_ACCESS_MODE(stgm) ((stgm)&0x0000f)
38#define STGM_SHARE_MODE(stgm) ((stgm)&0x000f0)
39#define STGM_CREATE_MODE(stgm) ((stgm)&0x0f000)
40
41/* Layout of ISHFileStream object */
42typedef struct
43{
52
54{
55 return CONTAINING_RECORD(iface, ISHFileStream, IStream_iface);
56}
57
59
60
61/**************************************************************************
62* IStream_fnQueryInterface
63*/
65{
67
68 TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppvObj);
69
70 *ppvObj = NULL;
71
73 IsEqualIID(riid, &IID_IStream))
74 {
75 IStream_AddRef(iface);
76 *ppvObj = iface;
77 return S_OK;
78 }
79 return E_NOINTERFACE;
80}
81
82/**************************************************************************
83* IStream_fnAddRef
84*/
86{
88 ULONG refCount = InterlockedIncrement(&This->ref);
89
90 TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
91
92 return refCount;
93}
94
95/**************************************************************************
96* IStream_fnRelease
97*/
99{
101 ULONG refCount = InterlockedDecrement(&This->ref);
102
103 TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
104
105 if (!refCount)
106 {
107 IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
108 LocalFree(This->lpszPath);
109 CloseHandle(This->hFile);
111 }
112
113 return refCount;
114}
115
116/**************************************************************************
117 * IStream_fnRead
118 */
119static HRESULT WINAPI IStream_fnRead(IStream *iface, void* pv, ULONG cb, ULONG* pcbRead)
120{
122 DWORD dwRead = 0;
123
124 TRACE("(%p,%p,0x%08x,%p)\n", This, pv, cb, pcbRead);
125
126 if (!ReadFile(This->hFile, pv, cb, &dwRead, NULL))
127 {
128 WARN("error %d reading file\n", GetLastError());
129 return S_FALSE;
130 }
131 if (pcbRead)
132 *pcbRead = dwRead;
133 return dwRead == cb ? S_OK : S_FALSE;
134}
135
136/**************************************************************************
137 * IStream_fnWrite
138 */
139static HRESULT WINAPI IStream_fnWrite(IStream *iface, const void* pv, ULONG cb, ULONG* pcbWritten)
140{
142 DWORD dwWritten = 0;
143
144 TRACE("(%p,%p,0x%08x,%p)\n", This, pv, cb, pcbWritten);
145
146 switch (STGM_ACCESS_MODE(This->dwMode))
147 {
148 case STGM_WRITE:
149 case STGM_READWRITE:
150 break;
151 default:
152 return STG_E_ACCESSDENIED;
153 }
154
155 if (!WriteFile(This->hFile, pv, cb, &dwWritten, NULL))
157
158 if (pcbWritten)
159 *pcbWritten = dwWritten;
160 return S_OK;
161}
162
163/**************************************************************************
164 * IStream_fnSeek
165 */
167 DWORD dwOrigin, ULARGE_INTEGER* pNewPos)
168{
170 DWORD dwPos;
171
172 TRACE("(%p,%d,%d,%p)\n", This, dlibMove.u.LowPart, dwOrigin, pNewPos);
173
174 IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
175 dwPos = SetFilePointer(This->hFile, dlibMove.u.LowPart, NULL, dwOrigin);
176 if( dwPos == INVALID_SET_FILE_POINTER )
178
179 if (pNewPos)
180 {
181 pNewPos->u.HighPart = 0;
182 pNewPos->u.LowPart = dwPos;
183 }
184 return S_OK;
185}
186
187/**************************************************************************
188 * IStream_fnSetSize
189 */
191{
193
194 TRACE("(%p,%d)\n", This, libNewSize.u.LowPart);
195
196 IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
197 if( ! SetFilePointer( This->hFile, libNewSize.QuadPart, NULL, FILE_BEGIN ) )
198 return E_FAIL;
199
200 if( ! SetEndOfFile( This->hFile ) )
201 return E_FAIL;
202
203 return S_OK;
204}
205
206/**************************************************************************
207 * IStream_fnCopyTo
208 */
210 ULARGE_INTEGER* pcbRead, ULARGE_INTEGER* pcbWritten)
211{
213 char copyBuff[1024];
214 ULONGLONG ulSize;
215 HRESULT hRet = S_OK;
216
217 TRACE("(%p,%p,%d,%p,%p)\n", This, pstm, cb.u.LowPart, pcbRead, pcbWritten);
218
219 if (pcbRead)
220 pcbRead->QuadPart = 0;
221 if (pcbWritten)
222 pcbWritten->QuadPart = 0;
223
224 if (!pstm)
225 return S_OK;
226
227 IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
228
229 /* Copy data */
230 ulSize = cb.QuadPart;
231 while (ulSize)
232 {
233 ULONG ulLeft, ulRead, ulWritten;
234
235 ulLeft = ulSize > sizeof(copyBuff) ? sizeof(copyBuff) : ulSize;
236
237 /* Read */
238 hRet = IStream_fnRead(iface, copyBuff, ulLeft, &ulRead);
239 if (FAILED(hRet) || ulRead == 0)
240 break;
241 if (pcbRead)
242 pcbRead->QuadPart += ulRead;
243
244 /* Write */
245 hRet = IStream_fnWrite(pstm, copyBuff, ulRead, &ulWritten);
246 if (pcbWritten)
247 pcbWritten->QuadPart += ulWritten;
248 if (FAILED(hRet) || ulWritten != ulLeft)
249 break;
250
251 ulSize -= ulLeft;
252 }
253 return hRet;
254}
255
256/**************************************************************************
257 * IStream_fnCommit
258 */
259static HRESULT WINAPI IStream_fnCommit(IStream *iface, DWORD grfCommitFlags)
260{
262
263 TRACE("(%p,%d)\n", This, grfCommitFlags);
264 /* Currently unbuffered: This function is not needed */
265 return S_OK;
266}
267
268/**************************************************************************
269 * IStream_fnRevert
270 */
272{
274
275 TRACE("(%p)\n", This);
276 return E_NOTIMPL;
277}
278
279/**************************************************************************
280 * IStream_fnLockUnlockRegion
281 */
283 ULARGE_INTEGER cb, DWORD dwLockType)
284{
286 TRACE("(%p,%d,%d,%d)\n", This, libOffset.u.LowPart, cb.u.LowPart, dwLockType);
287 return E_NOTIMPL;
288}
289
290/*************************************************************************
291 * IStream_fnStat
292 */
293static HRESULT WINAPI IStream_fnStat(IStream *iface, STATSTG* lpStat,
294 DWORD grfStatFlag)
295{
298
299 TRACE("(%p,%p,%d)\n", This, lpStat, grfStatFlag);
300
301 if (!lpStat)
303
304 memset(&fi, 0, sizeof(fi));
305 GetFileInformationByHandle(This->hFile, &fi);
306
307 if (grfStatFlag & STATFLAG_NONAME)
308 lpStat->pwcsName = NULL;
309 else
310 lpStat->pwcsName = StrDupW(This->lpszPath);
311 lpStat->type = This->type;
312 lpStat->cbSize.u.LowPart = fi.nFileSizeLow;
313 lpStat->cbSize.u.HighPart = fi.nFileSizeHigh;
314 lpStat->mtime = fi.ftLastWriteTime;
315 lpStat->ctime = fi.ftCreationTime;
316 lpStat->atime = fi.ftLastAccessTime;
317 lpStat->grfMode = This->dwMode;
318 lpStat->grfLocksSupported = 0;
319 memcpy(&lpStat->clsid, &IID_IStream, sizeof(CLSID));
320 lpStat->grfStateBits = This->grfStateBits;
321 lpStat->reserved = 0;
322
323 return S_OK;
324}
325
326/*************************************************************************
327 * IStream_fnClone
328 */
330{
332
333 TRACE("(%p)\n",This);
334 if (ppstm)
335 *ppstm = NULL;
336 return E_NOTIMPL;
337}
338
339static const IStreamVtbl SHLWAPI_fsVTable =
340{
355};
356
357/**************************************************************************
358 * IStream_Create
359 *
360 * Internal helper: Create and initialise a new file stream object.
361 */
362static IStream *IStream_Create(LPCWSTR lpszPath, HANDLE hFile, DWORD dwMode)
363{
364 ISHFileStream *fileStream;
365
366 fileStream = HeapAlloc(GetProcessHeap(), 0, sizeof(ISHFileStream));
367 if (!fileStream) return NULL;
368
369 fileStream->IStream_iface.lpVtbl = &SHLWAPI_fsVTable;
370 fileStream->ref = 1;
371 fileStream->hFile = hFile;
372 fileStream->dwMode = dwMode;
373 fileStream->lpszPath = StrDupW(lpszPath);
374 fileStream->type = 0; /* FIXME */
375 fileStream->grfStateBits = 0; /* FIXME */
376
377 TRACE ("Returning %p\n", fileStream);
378 return &fileStream->IStream_iface;
379}
380
381/*************************************************************************
382 * SHCreateStreamOnFileEx [SHLWAPI.@]
383 *
384 * Create a stream on a file.
385 *
386 * PARAMS
387 * lpszPath [I] Path of file to create stream on
388 * dwMode [I] Mode to create stream in
389 * dwAttributes [I] Attributes of the file
390 * bCreate [I] Whether to create the file if it doesn't exist
391 * lpTemplate [I] Reserved, must be NULL
392 * lppStream [O] Destination for created stream
393 *
394 * RETURNS
395 * Success: S_OK. lppStream contains the new stream object
396 * Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
397 *
398 * NOTES
399 * This function is available in Unicode only.
400 */
403 IStream *lpTemplate, IStream **lppStream)
404{
405 DWORD dwAccess, dwShare, dwCreate;
407
408 TRACE("(%s,%d,0x%08X,%d,%p,%p)\n", debugstr_w(lpszPath), dwMode,
409 dwAttributes, bCreate, lpTemplate, lppStream);
410
411 if (!lpszPath || !lppStream || lpTemplate)
412 return E_INVALIDARG;
413
414 *lppStream = NULL;
415
416 /* Access */
417 switch (STGM_ACCESS_MODE(dwMode))
418 {
419 case STGM_WRITE:
420 case STGM_READWRITE:
421 dwAccess = GENERIC_READ|GENERIC_WRITE;
422 break;
423 case STGM_READ:
424 dwAccess = GENERIC_READ;
425 break;
426 default:
427 return E_INVALIDARG;
428 }
429
430 /* Sharing */
431 switch (STGM_SHARE_MODE(dwMode))
432 {
433 case 0:
436 break;
438 dwShare = FILE_SHARE_WRITE;
439 break;
441 dwShare = FILE_SHARE_READ;
442 break;
444 dwShare = 0;
445 break;
446 default:
447 return E_INVALIDARG;
448 }
449
450 switch(STGM_CREATE_MODE(dwMode))
451 {
452 case STGM_FAILIFTHERE:
453 dwCreate = bCreate ? CREATE_NEW : OPEN_EXISTING;
454 break;
455 case STGM_CREATE:
456 dwCreate = CREATE_ALWAYS;
457 break;
458 default:
459 return E_INVALIDARG;
460 }
461
462 /* Open HANDLE to file */
463 hFile = CreateFileW(lpszPath, dwAccess, dwShare, NULL, dwCreate,
464 dwAttributes, 0);
465
468
469 *lppStream = IStream_Create(lpszPath, hFile, dwMode);
470
471 if(!*lppStream)
472 {
474 return E_OUTOFMEMORY;
475 }
476 return S_OK;
477}
478
479/*************************************************************************
480 * SHCreateStreamOnFileW [SHLWAPI.@]
481 *
482 * See SHCreateStreamOnFileA.
483 */
485 IStream **lppStream)
486{
487 TRACE("(%s,%d,%p)\n", debugstr_w(lpszPath), dwMode, lppStream);
488
489 if (!lpszPath || !lppStream)
490 return E_INVALIDARG;
491
493 return E_INVALIDARG;
494
495 return SHCreateStreamOnFileEx(lpszPath, dwMode, 0, FALSE, NULL, lppStream);
496}
497
498/*************************************************************************
499 * SHCreateStreamOnFileA [SHLWAPI.@]
500 *
501 * Create a stream on a file.
502 *
503 * PARAMS
504 * lpszPath [I] Path of file to create stream on
505 * dwMode [I] Mode to create stream in
506 * lppStream [O] Destination for created IStream object
507 *
508 * RETURNS
509 * Success: S_OK. lppStream contains the new IStream object
510 * Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
511 */
513 IStream **lppStream)
514{
516
517 TRACE("(%s,%d,%p)\n", debugstr_a(lpszPath), dwMode, lppStream);
518
519 if (!lpszPath)
521
522 MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, szPath, MAX_PATH);
523 return SHCreateStreamOnFileW(szPath, dwMode, lppStream);
524}
525
526/*************************************************************************
527 * @ [SHLWAPI.184]
528 *
529 * Call IStream_Read() on a stream.
530 *
531 * PARAMS
532 * lpStream [I] IStream object
533 * lpvDest [O] Destination for data read
534 * ulSize [I] Size of data to read
535 *
536 * RETURNS
537 * Success: S_OK. ulSize bytes have been read from the stream into lpvDest.
538 * Failure: An HRESULT error code, or E_FAIL if the read succeeded but the
539 * number of bytes read does not match.
540 */
541HRESULT WINAPI SHIStream_Read(IStream *lpStream, LPVOID lpvDest, ULONG ulSize)
542{
543 ULONG ulRead;
544 HRESULT hRet;
545
546 TRACE("(%p,%p,%d)\n", lpStream, lpvDest, ulSize);
547
548 hRet = IStream_Read(lpStream, lpvDest, ulSize, &ulRead);
549
550 if (SUCCEEDED(hRet) && ulRead != ulSize)
551 hRet = E_FAIL;
552 return hRet;
553}
554
555/*************************************************************************
556 * @ [SHLWAPI.166]
557 *
558 * Determine if a stream has 0 length.
559 *
560 * PARAMS
561 * lpStream [I] IStream object
562 *
563 * RETURNS
564 * TRUE: If the stream has 0 length
565 * FALSE: Otherwise.
566 */
568{
569 STATSTG statstg;
570 BOOL bRet = TRUE;
571
572 TRACE("(%p)\n", lpStream);
573
574 memset(&statstg, 0, sizeof(statstg));
575
576 if(SUCCEEDED(IStream_Stat(lpStream, &statstg, 1)))
577 {
578 if(statstg.cbSize.QuadPart)
579 bRet = FALSE; /* Non-Zero */
580 }
581 else
582 {
583 DWORD dwDummy;
584
585 /* Try to read from the stream */
586 if(SUCCEEDED(SHIStream_Read(lpStream, &dwDummy, sizeof(dwDummy))))
587 {
589 zero.QuadPart = 0;
590
591 IStream_Seek(lpStream, zero, 0, NULL);
592 bRet = FALSE; /* Non-Zero */
593 }
594 }
595 return bRet;
596}
597
598/*************************************************************************
599 * @ [SHLWAPI.212]
600 *
601 * Call IStream_Write() on a stream.
602 *
603 * PARAMS
604 * lpStream [I] IStream object
605 * lpvSrc [I] Source for data to write
606 * ulSize [I] Size of data
607 *
608 * RETURNS
609 * Success: S_OK. ulSize bytes have been written to the stream from lpvSrc.
610 * Failure: An HRESULT error code, or E_FAIL if the write succeeded but the
611 * number of bytes written does not match.
612 */
614{
615 ULONG ulWritten;
616 HRESULT hRet;
617
618 TRACE("(%p,%p,%d)\n", lpStream, lpvSrc, ulSize);
619
620 hRet = IStream_Write(lpStream, lpvSrc, ulSize, &ulWritten);
621
622 if (SUCCEEDED(hRet) && ulWritten != ulSize)
623 hRet = E_FAIL;
624
625 return hRet;
626}
627
628/*************************************************************************
629 * @ [SHLWAPI.213]
630 *
631 * Seek to the start of a stream.
632 *
633 * PARAMS
634 * lpStream [I] IStream object
635 *
636 * RETURNS
637 * Success: S_OK. The current position within the stream is updated
638 * Failure: An HRESULT error code.
639 */
641{
643 TRACE("(%p)\n", lpStream);
644 zero.QuadPart = 0;
645 return IStream_Seek(lpStream, zero, 0, NULL);
646}
647
648/*************************************************************************
649 * @ [SHLWAPI.214]
650 *
651 * Get the size of a stream.
652 *
653 * PARAMS
654 * lpStream [I] IStream object
655 * lpulSize [O] Destination for size
656 *
657 * RETURNS
658 * Success: S_OK. lpulSize contains the size of the stream.
659 * Failure: An HRESULT error code.
660 */
662{
663 STATSTG statstg;
664 HRESULT hRet;
665
666 TRACE("(%p,%p)\n", lpStream, lpulSize);
667
668 memset(&statstg, 0, sizeof(statstg));
669
670 hRet = IStream_Stat(lpStream, &statstg, 1);
671
672 if (SUCCEEDED(hRet) && lpulSize)
673 *lpulSize = statstg.cbSize;
674 return hRet;
675}
#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 WARN(fmt,...)
Definition: debug.h:112
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define FILE_BEGIN
Definition: compat.h:761
#define INVALID_SET_FILE_POINTER
Definition: compat.h:732
#define CP_ACP
Definition: compat.h:109
#define OPEN_EXISTING
Definition: compat.h:775
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
#define SetFilePointer
Definition: compat.h:743
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define HeapAlloc
Definition: compat.h:733
#define GENERIC_READ
Definition: compat.h:135
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CreateFileW
Definition: compat.h:741
#define MultiByteToWideChar
Definition: compat.h:110
#define FILE_SHARE_READ
Definition: compat.h:136
BOOL WINAPI GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation)
Definition: fileinfo.c:458
BOOL WINAPI SetEndOfFile(HANDLE hFile)
Definition: fileinfo.c:1004
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
static HRESULT WINAPI IStream_fnSetSize(IStream *iface, ULARGE_INTEGER libNewSize)
Definition: istream.c:190
HRESULT WINAPI IStream_Size(IStream *lpStream, ULARGE_INTEGER *lpulSize)
Definition: istream.c:661
static const IStreamVtbl SHLWAPI_fsVTable
Definition: istream.c:339
static IStream * IStream_Create(LPCWSTR lpszPath, HANDLE hFile, DWORD dwMode)
Definition: istream.c:362
static HRESULT WINAPI IStream_fnCopyTo(IStream *iface, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
Definition: istream.c:209
#define STGM_CREATE_MODE(stgm)
Definition: istream.c:39
static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj)
Definition: istream.c:64
static HRESULT WINAPI IStream_fnStat(IStream *iface, STATSTG *lpStat, DWORD grfStatFlag)
Definition: istream.c:293
HRESULT WINAPI IStream_Reset(IStream *lpStream)
Definition: istream.c:640
static HRESULT WINAPI IStream_fnWrite(IStream *iface, const void *pv, ULONG cb, ULONG *pcbWritten)
Definition: istream.c:139
HRESULT WINAPI SHCreateStreamOnFileA(LPCSTR lpszPath, DWORD dwMode, IStream **lppStream)
Definition: istream.c:512
static ULONG WINAPI IStream_fnRelease(IStream *iface)
Definition: istream.c:98
BOOL WINAPI SHIsEmptyStream(IStream *lpStream)
Definition: istream.c:567
static HRESULT WINAPI IStream_fnCommit(IStream *, DWORD)
Definition: istream.c:259
#define STGM_SHARE_MODE(stgm)
Definition: istream.c:38
static HRESULT WINAPI IStream_fnRevert(IStream *iface)
Definition: istream.c:271
static HRESULT WINAPI IStream_fnSeek(IStream *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *pNewPos)
Definition: istream.c:166
static HRESULT WINAPI IStream_fnLockUnlockRegion(IStream *iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
Definition: istream.c:282
HRESULT WINAPI SHCreateStreamOnFileEx(LPCWSTR lpszPath, DWORD dwMode, DWORD dwAttributes, BOOL bCreate, IStream *lpTemplate, IStream **lppStream)
Definition: istream.c:401
#define STGM_ACCESS_MODE(stgm)
Definition: istream.c:37
HRESULT WINAPI SHCreateStreamOnFileW(LPCWSTR lpszPath, DWORD dwMode, IStream **lppStream)
Definition: istream.c:484
HRESULT WINAPI SHIStream_Write(IStream *lpStream, LPCVOID lpvSrc, ULONG ulSize)
Definition: istream.c:613
static HRESULT WINAPI IStream_fnRead(IStream *iface, void *pv, ULONG cb, ULONG *pcbRead)
Definition: istream.c:119
HRESULT WINAPI SHIStream_Read(IStream *lpStream, LPVOID lpvDest, ULONG ulSize)
Definition: istream.c:541
static HRESULT WINAPI IStream_fnClone(IStream *iface, IStream **ppstm)
Definition: istream.c:329
static ISHFileStream * impl_from_IStream(IStream *iface)
Definition: istream.c:53
static ULONG WINAPI IStream_fnAddRef(IStream *iface)
Definition: istream.c:85
LPWSTR WINAPI StrDupW(LPCWSTR lpszStr)
Definition: string.c:1089
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
REFIID riid
Definition: atlbase.h:39
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define CREATE_ALWAYS
Definition: disk.h:72
#define CREATE_NEW
Definition: disk.h:69
LPCWSTR szPath
Definition: env.c:37
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
static LPOLESTR
Definition: stg_prop.c:27
_In_ HANDLE hFile
Definition: mswsock.h:90
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define GENERIC_WRITE
Definition: nt_native.h:90
#define STGM_CREATE
Definition: objbase.h:926
#define STGM_SHARE_DENY_NONE
Definition: objbase.h:920
#define STGM_CONVERT
Definition: objbase.h:927
#define STGM_READWRITE
Definition: objbase.h:919
#define STGM_TRANSACTED
Definition: objbase.h:915
#define STGM_SHARE_EXCLUSIVE
Definition: objbase.h:923
#define STGM_FAILIFTHERE
Definition: objbase.h:928
#define STGM_DELETEONRELEASE
Definition: objbase.h:925
#define STGM_SHARE_DENY_WRITE
Definition: objbase.h:922
#define STGM_WRITE
Definition: objbase.h:918
#define STGM_READ
Definition: objbase.h:917
#define STGM_SHARE_DENY_READ
Definition: objbase.h:921
long LONG
Definition: pedump.c:60
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define REFIID
Definition: guiddef.h:118
#define memset(x, y, z)
Definition: compat.h:39
int zero
Definition: sehframes.cpp:29
_In_ int _In_ BOOL bCreate
Definition: shlobj.h:1511
#define TRACE(s)
Definition: solgame.cpp:4
DWORD type
Definition: istream.c:49
DWORD grfStateBits
Definition: istream.c:50
HANDLE hFile
Definition: istream.c:46
LPOLESTR lpszPath
Definition: istream.c:48
LONG ref
Definition: istream.c:45
DWORD dwMode
Definition: istream.c:47
IStream IStream_iface
Definition: istream.c:44
struct _ULARGE_INTEGER::@4136 u
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
struct _LARGE_INTEGER::@2291 u
DWORD dwAttributes
Definition: vdmdbg.h:34
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
CONST void * LPCVOID
Definition: windef.h:191
#define WINAPI
Definition: msvc.h:6
#define STG_E_INVALIDPOINTER
Definition: winerror.h:2571
#define S_FALSE
Definition: winerror.h:2357
#define E_NOINTERFACE
Definition: winerror.h:2364
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
#define STG_E_ACCESSDENIED
Definition: winerror.h:2568
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
const char * LPCSTR
Definition: xmlstorage.h:183
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185