winex11: Consider zero-size windows mapped even when they are positioned at 0,0.
[wine/multimedia.git] / dlls / shlwapi / istream.c
blob3395209c856aa682d2b3825c786e02b147c1f317
1 /*
2 * SHLWAPI IStream functions
4 * Copyright 2002 Jon Griffiths
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.
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.
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
20 #include <stdarg.h>
21 #include <string.h>
23 #define COBJMACROS
24 #define NONAMELESSUNION
25 #define NONAMELESSSTRUCT
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winerror.h"
30 #include "winnls.h"
31 #define NO_SHLWAPI_REG
32 #define NO_SHLWAPI_PATH
33 #include "shlwapi.h"
34 #include "wine/debug.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(shell);
38 #define STGM_ACCESS_MODE(stgm) ((stgm)&0x0000f)
39 #define STGM_SHARE_MODE(stgm) ((stgm)&0x000f0)
40 #define STGM_CREATE_MODE(stgm) ((stgm)&0x0f000)
42 /* Layout of ISHFileStream object */
43 typedef struct
45 IStream IStream_iface;
46 LONG ref;
47 HANDLE hFile;
48 DWORD dwMode;
49 LPOLESTR lpszPath;
50 DWORD type;
51 DWORD grfStateBits;
52 } ISHFileStream;
54 static inline ISHFileStream *impl_from_IStream(IStream *iface)
56 return CONTAINING_RECORD(iface, ISHFileStream, IStream_iface);
59 static HRESULT WINAPI IStream_fnCommit(IStream*,DWORD);
62 /**************************************************************************
63 * IStream_fnQueryInterface
65 static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj)
67 ISHFileStream *This = impl_from_IStream(iface);
69 TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppvObj);
71 *ppvObj = NULL;
73 if(IsEqualIID(riid, &IID_IUnknown) ||
74 IsEqualIID(riid, &IID_IStream))
76 *ppvObj = This;
77 IStream_AddRef(iface);
78 return S_OK;
80 return E_NOINTERFACE;
83 /**************************************************************************
84 * IStream_fnAddRef
86 static ULONG WINAPI IStream_fnAddRef(IStream *iface)
88 ISHFileStream *This = impl_from_IStream(iface);
89 ULONG refCount = InterlockedIncrement(&This->ref);
91 TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
93 return refCount;
96 /**************************************************************************
97 * IStream_fnRelease
99 static ULONG WINAPI IStream_fnRelease(IStream *iface)
101 ISHFileStream *This = impl_from_IStream(iface);
102 ULONG refCount = InterlockedDecrement(&This->ref);
104 TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
106 if (!refCount)
108 IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
109 LocalFree(This->lpszPath);
110 CloseHandle(This->hFile);
111 HeapFree(GetProcessHeap(), 0, This);
114 return refCount;
117 /**************************************************************************
118 * IStream_fnRead
120 static HRESULT WINAPI IStream_fnRead(IStream *iface, void* pv, ULONG cb, ULONG* pcbRead)
122 ISHFileStream *This = impl_from_IStream(iface);
123 DWORD dwRead = 0;
125 TRACE("(%p,%p,0x%08x,%p)\n", This, pv, cb, pcbRead);
127 if (!ReadFile(This->hFile, pv, cb, &dwRead, NULL))
129 WARN("error %d reading file\n", GetLastError());
130 return S_FALSE;
132 if (pcbRead)
133 *pcbRead = dwRead;
134 return S_OK;
137 /**************************************************************************
138 * IStream_fnWrite
140 static HRESULT WINAPI IStream_fnWrite(IStream *iface, const void* pv, ULONG cb, ULONG* pcbWritten)
142 ISHFileStream *This = impl_from_IStream(iface);
143 DWORD dwWritten = 0;
145 TRACE("(%p,%p,0x%08x,%p)\n", This, pv, cb, pcbWritten);
147 switch (STGM_ACCESS_MODE(This->dwMode))
149 case STGM_WRITE:
150 case STGM_READWRITE:
151 break;
152 default:
153 return STG_E_ACCESSDENIED;
156 if (!WriteFile(This->hFile, pv, cb, &dwWritten, NULL))
157 return HRESULT_FROM_WIN32(GetLastError());
159 if (pcbWritten)
160 *pcbWritten = dwWritten;
161 return S_OK;
164 /**************************************************************************
165 * IStream_fnSeek
167 static HRESULT WINAPI IStream_fnSeek(IStream *iface, LARGE_INTEGER dlibMove,
168 DWORD dwOrigin, ULARGE_INTEGER* pNewPos)
170 ISHFileStream *This = impl_from_IStream(iface);
171 DWORD dwPos;
173 TRACE("(%p,%d,%d,%p)\n", This, dlibMove.u.LowPart, dwOrigin, pNewPos);
175 IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
176 dwPos = SetFilePointer(This->hFile, dlibMove.u.LowPart, NULL, dwOrigin);
177 if( dwPos == INVALID_SET_FILE_POINTER )
178 return HRESULT_FROM_WIN32(GetLastError());
180 if (pNewPos)
182 pNewPos->u.HighPart = 0;
183 pNewPos->u.LowPart = dwPos;
185 return S_OK;
188 /**************************************************************************
189 * IStream_fnSetSize
191 static HRESULT WINAPI IStream_fnSetSize(IStream *iface, ULARGE_INTEGER libNewSize)
193 ISHFileStream *This = impl_from_IStream(iface);
195 TRACE("(%p,%d)\n", This, libNewSize.u.LowPart);
197 IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
198 if( ! SetFilePointer( This->hFile, libNewSize.QuadPart, NULL, FILE_BEGIN ) )
199 return E_FAIL;
201 if( ! SetEndOfFile( This->hFile ) )
202 return E_FAIL;
204 return S_OK;
207 /**************************************************************************
208 * IStream_fnCopyTo
210 static HRESULT WINAPI IStream_fnCopyTo(IStream *iface, IStream* pstm, ULARGE_INTEGER cb,
211 ULARGE_INTEGER* pcbRead, ULARGE_INTEGER* pcbWritten)
213 ISHFileStream *This = impl_from_IStream(iface);
214 char copyBuff[1024];
215 ULONGLONG ulSize;
216 HRESULT hRet = S_OK;
218 TRACE("(%p,%p,%d,%p,%p)\n", This, pstm, cb.u.LowPart, pcbRead, pcbWritten);
220 if (pcbRead)
221 pcbRead->QuadPart = 0;
222 if (pcbWritten)
223 pcbWritten->QuadPart = 0;
225 if (!pstm)
226 return S_OK;
228 IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
230 /* Copy data */
231 ulSize = cb.QuadPart;
232 while (ulSize)
234 ULONG ulLeft, ulAmt;
236 ulLeft = ulSize > sizeof(copyBuff) ? sizeof(copyBuff) : ulSize;
238 /* Read */
239 hRet = IStream_fnRead(iface, copyBuff, ulLeft, &ulAmt);
240 if (pcbRead)
241 pcbRead->QuadPart += ulAmt;
242 if (FAILED(hRet) || ulAmt != ulLeft)
243 break;
245 /* Write */
246 hRet = IStream_fnWrite(pstm, copyBuff, ulLeft, &ulAmt);
247 if (pcbWritten)
248 pcbWritten->QuadPart += ulAmt;
249 if (FAILED(hRet) || ulAmt != ulLeft)
250 break;
252 ulSize -= ulLeft;
254 return hRet;
257 /**************************************************************************
258 * IStream_fnCommit
260 static HRESULT WINAPI IStream_fnCommit(IStream *iface, DWORD grfCommitFlags)
262 ISHFileStream *This = impl_from_IStream(iface);
264 TRACE("(%p,%d)\n", This, grfCommitFlags);
265 /* Currently unbuffered: This function is not needed */
266 return S_OK;
269 /**************************************************************************
270 * IStream_fnRevert
272 static HRESULT WINAPI IStream_fnRevert(IStream *iface)
274 ISHFileStream *This = impl_from_IStream(iface);
276 TRACE("(%p)\n", This);
277 return E_NOTIMPL;
280 /**************************************************************************
281 * IStream_fnLockUnlockRegion
283 static HRESULT WINAPI IStream_fnLockUnlockRegion(IStream *iface, ULARGE_INTEGER libOffset,
284 ULARGE_INTEGER cb, DWORD dwLockType)
286 ISHFileStream *This = impl_from_IStream(iface);
287 TRACE("(%p,%d,%d,%d)\n", This, libOffset.u.LowPart, cb.u.LowPart, dwLockType);
288 return E_NOTIMPL;
291 /*************************************************************************
292 * IStream_fnStat
294 static HRESULT WINAPI IStream_fnStat(IStream *iface, STATSTG* lpStat,
295 DWORD grfStatFlag)
297 ISHFileStream *This = impl_from_IStream(iface);
298 BY_HANDLE_FILE_INFORMATION fi;
299 HRESULT hRet = S_OK;
301 TRACE("(%p,%p,%d)\n", This, lpStat, grfStatFlag);
303 if (!grfStatFlag)
304 hRet = STG_E_INVALIDPOINTER;
305 else
307 memset(&fi, 0, sizeof(fi));
308 GetFileInformationByHandle(This->hFile, &fi);
310 if (grfStatFlag & STATFLAG_NONAME)
311 lpStat->pwcsName = NULL;
312 else
313 lpStat->pwcsName = StrDupW(This->lpszPath);
314 lpStat->type = This->type;
315 lpStat->cbSize.u.LowPart = fi.nFileSizeLow;
316 lpStat->cbSize.u.HighPart = fi.nFileSizeHigh;
317 lpStat->mtime = fi.ftLastWriteTime;
318 lpStat->ctime = fi.ftCreationTime;
319 lpStat->atime = fi.ftLastAccessTime;
320 lpStat->grfMode = This->dwMode;
321 lpStat->grfLocksSupported = 0;
322 memcpy(&lpStat->clsid, &IID_IStream, sizeof(CLSID));
323 lpStat->grfStateBits = This->grfStateBits;
324 lpStat->reserved = 0;
326 return hRet;
329 /*************************************************************************
330 * IStream_fnClone
332 static HRESULT WINAPI IStream_fnClone(IStream *iface, IStream** ppstm)
334 ISHFileStream *This = impl_from_IStream(iface);
336 TRACE("(%p)\n",This);
337 if (ppstm)
338 *ppstm = NULL;
339 return E_NOTIMPL;
342 static const IStreamVtbl SHLWAPI_fsVTable =
344 IStream_fnQueryInterface,
345 IStream_fnAddRef,
346 IStream_fnRelease,
347 IStream_fnRead,
348 IStream_fnWrite,
349 IStream_fnSeek,
350 IStream_fnSetSize,
351 IStream_fnCopyTo,
352 IStream_fnCommit,
353 IStream_fnRevert,
354 IStream_fnLockUnlockRegion,
355 IStream_fnLockUnlockRegion,
356 IStream_fnStat,
357 IStream_fnClone
360 /**************************************************************************
361 * IStream_Create
363 * Internal helper: Create and initialise a new file stream object.
365 static IStream *IStream_Create(LPCWSTR lpszPath, HANDLE hFile, DWORD dwMode)
367 ISHFileStream* fileStream;
369 fileStream = HeapAlloc(GetProcessHeap(), 0, sizeof(ISHFileStream));
371 if (fileStream)
373 fileStream->IStream_iface.lpVtbl = &SHLWAPI_fsVTable;
374 fileStream->ref = 1;
375 fileStream->hFile = hFile;
376 fileStream->dwMode = dwMode;
377 fileStream->lpszPath = StrDupW(lpszPath);
378 fileStream->type = 0; /* FIXME */
379 fileStream->grfStateBits = 0; /* FIXME */
381 TRACE ("Returning %p\n", fileStream);
382 return &fileStream->IStream_iface;
385 /*************************************************************************
386 * SHCreateStreamOnFileEx [SHLWAPI.@]
388 * Create a stream on a file.
390 * PARAMS
391 * lpszPath [I] Path of file to create stream on
392 * dwMode [I] Mode to create stream in
393 * dwAttributes [I] Attributes of the file
394 * bCreate [I] Whether to create the file if it doesn't exist
395 * lpTemplate [I] Reserved, must be NULL
396 * lppStream [O] Destination for created stream
398 * RETURNS
399 * Success: S_OK. lppStream contains the new stream object
400 * Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
402 * NOTES
403 * This function is available in Unicode only.
405 HRESULT WINAPI SHCreateStreamOnFileEx(LPCWSTR lpszPath, DWORD dwMode,
406 DWORD dwAttributes, BOOL bCreate,
407 IStream *lpTemplate, IStream **lppStream)
409 DWORD dwAccess, dwShare, dwCreate;
410 HANDLE hFile;
412 TRACE("(%s,%d,0x%08X,%d,%p,%p)\n", debugstr_w(lpszPath), dwMode,
413 dwAttributes, bCreate, lpTemplate, lppStream);
415 if (!lpszPath || !lppStream || lpTemplate)
416 return E_INVALIDARG;
418 *lppStream = NULL;
420 /* Access */
421 switch (STGM_ACCESS_MODE(dwMode))
423 case STGM_READWRITE:
424 dwAccess = GENERIC_READ|GENERIC_WRITE;
425 break;
426 case STGM_WRITE:
427 dwAccess = GENERIC_WRITE;
428 break;
429 case STGM_READ:
430 dwAccess = GENERIC_READ;
431 break;
432 default:
433 return E_INVALIDARG;
436 /* Sharing */
437 switch (STGM_SHARE_MODE(dwMode))
439 case 0:
440 dwShare = FILE_SHARE_READ|FILE_SHARE_WRITE;
441 break;
442 case STGM_SHARE_DENY_READ:
443 dwShare = FILE_SHARE_WRITE;
444 break;
445 case STGM_SHARE_DENY_WRITE:
446 dwShare = FILE_SHARE_READ;
447 break;
448 case STGM_SHARE_EXCLUSIVE:
449 dwShare = 0;
450 break;
451 case STGM_SHARE_DENY_NONE:
452 dwShare = FILE_SHARE_READ|FILE_SHARE_WRITE;
453 break;
454 default:
455 return E_INVALIDARG;
458 switch(STGM_CREATE_MODE(dwMode))
460 case STGM_FAILIFTHERE:
461 dwCreate = bCreate ? CREATE_NEW : OPEN_EXISTING;
462 break;
463 case STGM_CREATE:
464 dwCreate = CREATE_ALWAYS;
465 break;
466 default:
467 return E_INVALIDARG;
470 /* Open HANDLE to file */
471 hFile = CreateFileW(lpszPath, dwAccess, dwShare, NULL, dwCreate,
472 dwAttributes, 0);
474 if(hFile == INVALID_HANDLE_VALUE)
475 return HRESULT_FROM_WIN32(GetLastError());
477 *lppStream = IStream_Create(lpszPath, hFile, dwMode);
479 if(!*lppStream)
481 CloseHandle(hFile);
482 return E_OUTOFMEMORY;
484 return S_OK;
487 /*************************************************************************
488 * SHCreateStreamOnFileW [SHLWAPI.@]
490 * See SHCreateStreamOnFileA.
492 HRESULT WINAPI SHCreateStreamOnFileW(LPCWSTR lpszPath, DWORD dwMode,
493 IStream **lppStream)
495 TRACE("(%s,%d,%p)\n", debugstr_w(lpszPath), dwMode, lppStream);
497 if (!lpszPath || !lppStream)
498 return E_INVALIDARG;
500 if ((dwMode & (STGM_CONVERT|STGM_DELETEONRELEASE|STGM_TRANSACTED)) != 0)
501 return E_INVALIDARG;
503 return SHCreateStreamOnFileEx(lpszPath, dwMode, 0, FALSE, NULL, lppStream);
506 /*************************************************************************
507 * SHCreateStreamOnFileA [SHLWAPI.@]
509 * Create a stream on a file.
511 * PARAMS
512 * lpszPath [I] Path of file to create stream on
513 * dwMode [I] Mode to create stream in
514 * lppStream [O] Destination for created IStream object
516 * RETURNS
517 * Success: S_OK. lppStream contains the new IStream object
518 * Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
520 HRESULT WINAPI SHCreateStreamOnFileA(LPCSTR lpszPath, DWORD dwMode,
521 IStream **lppStream)
523 WCHAR szPath[MAX_PATH];
525 TRACE("(%s,%d,%p)\n", debugstr_a(lpszPath), dwMode, lppStream);
527 if (!lpszPath)
528 return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
530 MultiByteToWideChar(0, 0, lpszPath, -1, szPath, MAX_PATH);
531 return SHCreateStreamOnFileW(szPath, dwMode, lppStream);
534 /*************************************************************************
535 * @ [SHLWAPI.184]
537 * Call IStream_Read() on a stream.
539 * PARAMS
540 * lpStream [I] IStream object
541 * lpvDest [O] Destination for data read
542 * ulSize [I] Size of data to read
544 * RETURNS
545 * Success: S_OK. ulSize bytes have been read from the stream into lpvDest.
546 * Failure: An HRESULT error code, or E_FAIL if the read succeeded but the
547 * number of bytes read does not match.
549 HRESULT WINAPI SHIStream_Read(IStream *lpStream, LPVOID lpvDest, ULONG ulSize)
551 ULONG ulRead;
552 HRESULT hRet;
554 TRACE("(%p,%p,%d)\n", lpStream, lpvDest, ulSize);
556 hRet = IStream_Read(lpStream, lpvDest, ulSize, &ulRead);
558 if (SUCCEEDED(hRet) && ulRead != ulSize)
559 hRet = E_FAIL;
560 return hRet;
563 /*************************************************************************
564 * @ [SHLWAPI.166]
566 * Determine if a stream has 0 length.
568 * PARAMS
569 * lpStream [I] IStream object
571 * RETURNS
572 * TRUE: If the stream has 0 length
573 * FALSE: Otherwise.
575 BOOL WINAPI SHIsEmptyStream(IStream *lpStream)
577 STATSTG statstg;
578 BOOL bRet = TRUE;
580 TRACE("(%p)\n", lpStream);
582 memset(&statstg, 0, sizeof(statstg));
584 if(SUCCEEDED(IStream_Stat(lpStream, &statstg, 1)))
586 if(statstg.cbSize.QuadPart)
587 bRet = FALSE; /* Non-Zero */
589 else
591 DWORD dwDummy;
593 /* Try to read from the stream */
594 if(SUCCEEDED(SHIStream_Read(lpStream, &dwDummy, sizeof(dwDummy))))
596 LARGE_INTEGER zero;
597 zero.QuadPart = 0;
599 IStream_Seek(lpStream, zero, 0, NULL);
600 bRet = FALSE; /* Non-Zero */
603 return bRet;
606 /*************************************************************************
607 * @ [SHLWAPI.212]
609 * Call IStream_Write() on a stream.
611 * PARAMS
612 * lpStream [I] IStream object
613 * lpvSrc [I] Source for data to write
614 * ulSize [I] Size of data
616 * RETURNS
617 * Success: S_OK. ulSize bytes have been written to the stream from lpvSrc.
618 * Failure: An HRESULT error code, or E_FAIL if the write succeeded but the
619 * number of bytes written does not match.
621 HRESULT WINAPI SHIStream_Write(IStream *lpStream, LPCVOID lpvSrc, ULONG ulSize)
623 ULONG ulWritten;
624 HRESULT hRet;
626 TRACE("(%p,%p,%d)\n", lpStream, lpvSrc, ulSize);
628 hRet = IStream_Write(lpStream, lpvSrc, ulSize, &ulWritten);
630 if (SUCCEEDED(hRet) && ulWritten != ulSize)
631 hRet = E_FAIL;
633 return hRet;
636 /*************************************************************************
637 * @ [SHLWAPI.213]
639 * Seek to the start of a stream.
641 * PARAMS
642 * lpStream [I] IStream object
644 * RETURNS
645 * Success: S_OK. The current position within the stream is updated
646 * Failure: An HRESULT error code.
648 HRESULT WINAPI IStream_Reset(IStream *lpStream)
650 LARGE_INTEGER zero;
651 TRACE("(%p)\n", lpStream);
652 zero.QuadPart = 0;
653 return IStream_Seek(lpStream, zero, 0, NULL);
656 /*************************************************************************
657 * @ [SHLWAPI.214]
659 * Get the size of a stream.
661 * PARAMS
662 * lpStream [I] IStream object
663 * lpulSize [O] Destination for size
665 * RETURNS
666 * Success: S_OK. lpulSize contains the size of the stream.
667 * Failure: An HRESULT error code.
669 HRESULT WINAPI IStream_Size(IStream *lpStream, ULARGE_INTEGER* lpulSize)
671 STATSTG statstg;
672 HRESULT hRet;
674 TRACE("(%p,%p)\n", lpStream, lpulSize);
676 memset(&statstg, 0, sizeof(statstg));
678 hRet = IStream_Stat(lpStream, &statstg, 1);
680 if (SUCCEEDED(hRet) && lpulSize)
681 *lpulSize = statstg.cbSize;
682 return hRet;