oledb32: Implement conversion from DBTYPE_GUID to DBTYPE_STR/DBTYPE_WSTR/DBTYPE_BSTR.
[wine] / dlls / shlwapi / istream.c
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 #define NONAMELESSSTRUCT
26
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"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(shell);
37
38 #define STGM_ACCESS_MODE(stgm)   ((stgm)&0x0000f)
39 #define STGM_SHARE_MODE(stgm)    ((stgm)&0x000f0)
40 #define STGM_CREATE_MODE(stgm)   ((stgm)&0x0f000)
41
42 /* Layout of ISHFileStream object */
43 typedef struct
44 {
45   const IStreamVtbl *lpVtbl;
46   LONG     ref;
47   HANDLE   hFile;
48   DWORD    dwMode;
49   LPOLESTR lpszPath;
50   DWORD    type;
51   DWORD    grfStateBits;
52 } ISHFileStream;
53
54 static HRESULT WINAPI IStream_fnCommit(IStream*,DWORD);
55
56
57 /**************************************************************************
58 *  IStream_fnQueryInterface
59 */
60 static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj)
61 {
62   ISHFileStream *This = (ISHFileStream *)iface;
63
64   TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppvObj);
65
66   *ppvObj = NULL;
67
68   if(IsEqualIID(riid, &IID_IUnknown) ||
69      IsEqualIID(riid, &IID_IStream))
70   {
71     *ppvObj = This;
72     IStream_AddRef(iface);
73     return S_OK;
74   }
75   return E_NOINTERFACE;
76 }
77
78 /**************************************************************************
79 *  IStream_fnAddRef
80 */
81 static ULONG WINAPI IStream_fnAddRef(IStream *iface)
82 {
83   ISHFileStream *This = (ISHFileStream *)iface;
84   ULONG refCount = InterlockedIncrement(&This->ref);
85   
86   TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
87
88   return refCount;
89 }
90
91 /**************************************************************************
92 *  IStream_fnRelease
93 */
94 static ULONG WINAPI IStream_fnRelease(IStream *iface)
95 {
96   ISHFileStream *This = (ISHFileStream *)iface;
97   ULONG refCount = InterlockedDecrement(&This->ref); 
98
99   TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
100   
101   if (!refCount)
102   {
103     IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
104     LocalFree(This->lpszPath);
105     CloseHandle(This->hFile);
106     HeapFree(GetProcessHeap(), 0, This);
107   }
108   
109   return refCount;
110 }
111
112 /**************************************************************************
113  * IStream_fnRead
114  */
115 static HRESULT WINAPI IStream_fnRead(IStream *iface, void* pv, ULONG cb, ULONG* pcbRead)
116 {
117   ISHFileStream *This = (ISHFileStream *)iface;
118   DWORD dwRead = 0;
119
120   TRACE("(%p,%p,0x%08x,%p)\n", This, pv, cb, pcbRead);
121
122   if (!ReadFile(This->hFile, pv, cb, &dwRead, NULL))
123   {
124     WARN("error %d reading file\n", GetLastError());
125     return S_FALSE;
126   }
127   if (pcbRead)
128     *pcbRead = dwRead;
129   return S_OK;
130 }
131
132 /**************************************************************************
133  * IStream_fnWrite
134  */
135 static HRESULT WINAPI IStream_fnWrite(IStream *iface, const void* pv, ULONG cb, ULONG* pcbWritten)
136 {
137   ISHFileStream *This = (ISHFileStream *)iface;
138   DWORD dwWritten = 0;
139
140   TRACE("(%p,%p,0x%08x,%p)\n", This, pv, cb, pcbWritten);
141
142   switch (STGM_ACCESS_MODE(This->dwMode))
143   {
144   case STGM_WRITE:
145   case STGM_READWRITE:
146     break;
147   default:
148     return STG_E_ACCESSDENIED;
149   }
150
151   if (!WriteFile(This->hFile, pv, cb, &dwWritten, NULL))
152     return HRESULT_FROM_WIN32(GetLastError());
153
154   if (pcbWritten)
155     *pcbWritten = dwWritten;
156   return S_OK;
157 }
158
159 /**************************************************************************
160  *  IStream_fnSeek
161  */
162 static HRESULT WINAPI IStream_fnSeek(IStream *iface, LARGE_INTEGER dlibMove,
163                                      DWORD dwOrigin, ULARGE_INTEGER* pNewPos)
164 {
165   ISHFileStream *This = (ISHFileStream *)iface;
166   DWORD dwPos;
167
168   TRACE("(%p,%d,%d,%p)\n", This, dlibMove.u.LowPart, dwOrigin, pNewPos);
169
170   IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
171   dwPos = SetFilePointer(This->hFile, dlibMove.u.LowPart, NULL, dwOrigin);
172   if( dwPos == INVALID_SET_FILE_POINTER )
173      return HRESULT_FROM_WIN32(GetLastError());
174
175   if (pNewPos)
176   {
177     pNewPos->u.HighPart = 0;
178     pNewPos->u.LowPart = dwPos;
179   }
180   return S_OK;
181 }
182
183 /**************************************************************************
184  * IStream_fnSetSize
185  */
186 static HRESULT WINAPI IStream_fnSetSize(IStream *iface, ULARGE_INTEGER libNewSize)
187 {
188   ISHFileStream *This = (ISHFileStream *)iface;
189
190   TRACE("(%p,%d)\n", This, libNewSize.u.LowPart);
191
192   IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
193   if( ! SetFilePointer( This->hFile, libNewSize.QuadPart, NULL, FILE_BEGIN ) )
194     return E_FAIL;
195
196   if( ! SetEndOfFile( This->hFile ) )
197     return E_FAIL;
198
199   return S_OK;
200 }
201
202 /**************************************************************************
203  * IStream_fnCopyTo
204  */
205 static HRESULT WINAPI IStream_fnCopyTo(IStream *iface, IStream* pstm, ULARGE_INTEGER cb,
206                                        ULARGE_INTEGER* pcbRead, ULARGE_INTEGER* pcbWritten)
207 {
208   ISHFileStream *This = (ISHFileStream *)iface;
209   char copyBuff[1024];
210   ULONGLONG ulSize;
211   HRESULT hRet = S_OK;
212
213   TRACE("(%p,%p,%d,%p,%p)\n", This, pstm, cb.u.LowPart, pcbRead, pcbWritten);
214
215   if (pcbRead)
216     pcbRead->QuadPart = 0;
217   if (pcbWritten)
218     pcbWritten->QuadPart = 0;
219
220   if (!pstm)
221     return S_OK;
222
223   IStream_fnCommit(iface, 0); /* If ever buffered, this will be needed */
224
225   /* Copy data */
226   ulSize = cb.QuadPart;
227   while (ulSize)
228   {
229     ULONG ulLeft, ulAmt;
230
231     ulLeft = ulSize > sizeof(copyBuff) ? sizeof(copyBuff) : ulSize;
232
233     /* Read */
234     hRet = IStream_fnRead(iface, copyBuff, ulLeft, &ulAmt);
235     if (pcbRead)
236       pcbRead->QuadPart += ulAmt;
237     if (FAILED(hRet) || ulAmt != ulLeft)
238       break;
239
240     /* Write */
241     hRet = IStream_fnWrite(pstm, copyBuff, ulLeft, &ulAmt);
242     if (pcbWritten)
243       pcbWritten->QuadPart += ulAmt;
244     if (FAILED(hRet) || ulAmt != ulLeft)
245       break;
246
247     ulSize -= ulLeft;
248   }
249   return hRet;
250 }
251
252 /**************************************************************************
253  * IStream_fnCommit
254  */
255 static HRESULT WINAPI IStream_fnCommit(IStream *iface, DWORD grfCommitFlags)
256 {
257   ISHFileStream *This = (ISHFileStream *)iface;
258
259   TRACE("(%p,%d)\n", This, grfCommitFlags);
260   /* Currently unbuffered: This function is not needed */
261   return S_OK;
262 }
263
264 /**************************************************************************
265  * IStream_fnRevert
266  */
267 static HRESULT WINAPI IStream_fnRevert(IStream *iface)
268 {
269   ISHFileStream *This = (ISHFileStream *)iface;
270
271   TRACE("(%p)\n", This);
272   return E_NOTIMPL;
273 }
274
275 /**************************************************************************
276  * IStream_fnLockUnlockRegion
277  */
278 static HRESULT WINAPI IStream_fnLockUnlockRegion(IStream *iface, ULARGE_INTEGER libOffset,
279                                                  ULARGE_INTEGER cb, DWORD dwLockType)
280 {
281   ISHFileStream *This = (ISHFileStream *)iface;
282   TRACE("(%p,%d,%d,%d)\n", This, libOffset.u.LowPart, cb.u.LowPart, dwLockType);
283   return E_NOTIMPL;
284 }
285
286 /*************************************************************************
287  * IStream_fnStat
288  */
289 static HRESULT WINAPI IStream_fnStat(IStream *iface, STATSTG* lpStat,
290                                      DWORD grfStatFlag)
291 {
292   ISHFileStream *This = (ISHFileStream *)iface;
293   BY_HANDLE_FILE_INFORMATION fi;
294   HRESULT hRet = S_OK;
295
296   TRACE("(%p,%p,%d)\n", This, lpStat, grfStatFlag);
297
298   if (!grfStatFlag)
299     hRet = STG_E_INVALIDPOINTER;
300   else
301   {
302     memset(&fi, 0, sizeof(fi));
303     GetFileInformationByHandle(This->hFile, &fi);
304
305     if (grfStatFlag & STATFLAG_NONAME)
306       lpStat->pwcsName = NULL;
307     else
308       lpStat->pwcsName = StrDupW(This->lpszPath);
309     lpStat->type = This->type;
310     lpStat->cbSize.u.LowPart = fi.nFileSizeLow;
311     lpStat->cbSize.u.HighPart = fi.nFileSizeHigh;
312     lpStat->mtime = fi.ftLastWriteTime;
313     lpStat->ctime = fi.ftCreationTime;
314     lpStat->atime = fi.ftLastAccessTime;
315     lpStat->grfMode = This->dwMode;
316     lpStat->grfLocksSupported = 0;
317     memcpy(&lpStat->clsid, &IID_IStream, sizeof(CLSID));
318     lpStat->grfStateBits = This->grfStateBits;
319     lpStat->reserved = 0;
320   }
321   return hRet;
322 }
323
324 /*************************************************************************
325  * IStream_fnClone
326  */
327 static HRESULT WINAPI IStream_fnClone(IStream *iface, IStream** ppstm)
328 {
329   ISHFileStream *This = (ISHFileStream *)iface;
330
331   TRACE("(%p)\n",This);
332   if (ppstm)
333     *ppstm = NULL;
334   return E_NOTIMPL;
335 }
336
337 static const IStreamVtbl SHLWAPI_fsVTable =
338 {
339   IStream_fnQueryInterface,
340   IStream_fnAddRef,
341   IStream_fnRelease,
342   IStream_fnRead,
343   IStream_fnWrite,
344   IStream_fnSeek,
345   IStream_fnSetSize,
346   IStream_fnCopyTo,
347   IStream_fnCommit,
348   IStream_fnRevert,
349   IStream_fnLockUnlockRegion,
350   IStream_fnLockUnlockRegion,
351   IStream_fnStat,
352   IStream_fnClone
353 };
354
355 /**************************************************************************
356  * IStream_Create
357  *
358  * Internal helper: Create and initialise a new file stream object.
359  */
360 static IStream *IStream_Create(LPCWSTR lpszPath, HANDLE hFile, DWORD dwMode)
361 {
362  ISHFileStream* fileStream;
363
364  fileStream = HeapAlloc(GetProcessHeap(), 0, sizeof(ISHFileStream));
365
366  if (fileStream)
367  {
368    fileStream->lpVtbl = &SHLWAPI_fsVTable;
369    fileStream->ref = 1;
370    fileStream->hFile = hFile;
371    fileStream->dwMode = dwMode;
372    fileStream->lpszPath = StrDupW(lpszPath);
373    fileStream->type = 0; /* FIXME */
374    fileStream->grfStateBits = 0; /* FIXME */
375  }
376  TRACE ("Returning %p\n", fileStream);
377  return (IStream *)fileStream;
378 }
379
380 /*************************************************************************
381  * SHCreateStreamOnFileEx   [SHLWAPI.@]
382  *
383  * Create a stream on a file.
384  *
385  * PARAMS
386  *  lpszPath     [I] Path of file to create stream on
387  *  dwMode       [I] Mode to create stream in
388  *  dwAttributes [I] Attributes of the file
389  *  bCreate      [I] Whether to create the file if it doesn't exist
390  *  lpTemplate   [I] Reserved, must be NULL
391  *  lppStream    [O] Destination for created stream
392  *
393  * RETURNS
394  * Success: S_OK. lppStream contains the new stream object
395  * Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
396  *
397  * NOTES
398  *  This function is available in Unicode only.
399  */
400 HRESULT WINAPI SHCreateStreamOnFileEx(LPCWSTR lpszPath, DWORD dwMode,
401                                       DWORD dwAttributes, BOOL bCreate,
402                                       IStream *lpTemplate, IStream **lppStream)
403 {
404   DWORD dwAccess, dwShare, dwCreate;
405   HANDLE hFile;
406
407   TRACE("(%s,%d,0x%08X,%d,%p,%p)\n", debugstr_w(lpszPath), dwMode,
408         dwAttributes, bCreate, lpTemplate, lppStream);
409
410   if (!lpszPath || !lppStream || lpTemplate)
411     return E_INVALIDARG;
412
413   *lppStream = NULL;
414
415   /* Access */
416   switch (STGM_ACCESS_MODE(dwMode))
417   {
418   case STGM_READWRITE:
419     dwAccess = GENERIC_READ|GENERIC_WRITE;
420     break;
421   case STGM_WRITE:
422     dwAccess = GENERIC_WRITE;
423     break;
424   case STGM_READ:
425     dwAccess = GENERIC_READ;
426     break;
427   default:
428     return E_INVALIDARG;
429   }
430
431   /* Sharing */
432   switch (STGM_SHARE_MODE(dwMode))
433   {
434   case 0:
435     dwShare = FILE_SHARE_READ|FILE_SHARE_WRITE;
436     break;
437   case STGM_SHARE_DENY_READ:
438     dwShare = FILE_SHARE_WRITE;
439     break;
440   case STGM_SHARE_DENY_WRITE:
441     dwShare = FILE_SHARE_READ;
442     break;
443   case STGM_SHARE_EXCLUSIVE:
444     dwShare = 0;
445     break;
446   case STGM_SHARE_DENY_NONE:
447     dwShare = FILE_SHARE_READ|FILE_SHARE_WRITE;
448     break;
449   default:
450     return E_INVALIDARG;
451   }
452
453   switch(STGM_CREATE_MODE(dwMode))
454   {
455   case STGM_FAILIFTHERE:
456     dwCreate = bCreate ? CREATE_NEW : OPEN_EXISTING;
457     break;
458   case STGM_CREATE:
459     dwCreate = CREATE_ALWAYS;
460     break;
461   default:
462     return E_INVALIDARG;
463   }
464
465   /* Open HANDLE to file */
466   hFile = CreateFileW(lpszPath, dwAccess, dwShare, NULL, dwCreate,
467                       dwAttributes, 0);
468
469   if(hFile == INVALID_HANDLE_VALUE)
470     return HRESULT_FROM_WIN32(GetLastError());
471
472   *lppStream = IStream_Create(lpszPath, hFile, dwMode);
473
474   if(!*lppStream)
475   {
476     CloseHandle(hFile);
477     return E_OUTOFMEMORY;
478   }
479   return S_OK;
480 }
481
482 /*************************************************************************
483  * SHCreateStreamOnFileW   [SHLWAPI.@]
484  *
485  * See SHCreateStreamOnFileA.
486  */
487 HRESULT WINAPI SHCreateStreamOnFileW(LPCWSTR lpszPath, DWORD dwMode,
488                                    IStream **lppStream)
489 {
490   TRACE("(%s,%d,%p)\n", debugstr_w(lpszPath), dwMode, lppStream);
491
492   if (!lpszPath || !lppStream)
493     return E_INVALIDARG;
494
495   if ((dwMode & (STGM_CONVERT|STGM_DELETEONRELEASE|STGM_TRANSACTED)) != 0)
496     return E_INVALIDARG;
497
498   return SHCreateStreamOnFileEx(lpszPath, dwMode, 0, FALSE, NULL, lppStream);
499 }
500
501 /*************************************************************************
502  * SHCreateStreamOnFileA   [SHLWAPI.@]
503  *
504  * Create a stream on a file.
505  *
506  * PARAMS
507  *  lpszPath  [I] Path of file to create stream on
508  *  dwMode    [I] Mode to create stream in
509  *  lppStream [O] Destination for created IStream object
510  *
511  * RETURNS
512  * Success: S_OK. lppStream contains the new IStream object
513  * Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
514  */
515 HRESULT WINAPI SHCreateStreamOnFileA(LPCSTR lpszPath, DWORD dwMode,
516                                      IStream **lppStream)
517 {
518   WCHAR szPath[MAX_PATH];
519
520   TRACE("(%s,%d,%p)\n", debugstr_a(lpszPath), dwMode, lppStream);
521
522   if (!lpszPath)
523     return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
524
525   MultiByteToWideChar(0, 0, lpszPath, -1, szPath, MAX_PATH);
526   return SHCreateStreamOnFileW(szPath, dwMode, lppStream);
527 }
528
529 /*************************************************************************
530  * @       [SHLWAPI.184]
531  *
532  * Call IStream_Read() on a stream.
533  *
534  * PARAMS
535  *  lpStream [I] IStream object
536  *  lpvDest  [O] Destination for data read
537  *  ulSize   [I] Size of data to read
538  *
539  * RETURNS
540  *  Success: S_OK. ulSize bytes have been read from the stream into lpvDest.
541  *  Failure: An HRESULT error code, or E_FAIL if the read succeeded but the
542  *           number of bytes read does not match.
543  */
544 HRESULT WINAPI SHIStream_Read(IStream *lpStream, LPVOID lpvDest, ULONG ulSize)
545 {
546   ULONG ulRead;
547   HRESULT hRet;
548
549   TRACE("(%p,%p,%d)\n", lpStream, lpvDest, ulSize);
550
551   hRet = IStream_Read(lpStream, lpvDest, ulSize, &ulRead);
552
553   if (SUCCEEDED(hRet) && ulRead != ulSize)
554     hRet = E_FAIL;
555   return hRet;
556 }
557
558 /*************************************************************************
559  * @       [SHLWAPI.166]
560  *
561  * Determine if a stream has 0 length.
562  *
563  * PARAMS
564  *  lpStream [I] IStream object
565  *
566  * RETURNS
567  *  TRUE:  If the stream has 0 length
568  *  FALSE: Otherwise.
569  */
570 BOOL WINAPI SHIsEmptyStream(IStream *lpStream)
571 {
572   STATSTG statstg;
573   BOOL bRet = TRUE;
574
575   TRACE("(%p)\n", lpStream);
576
577   memset(&statstg, 0, sizeof(statstg));
578
579   if(SUCCEEDED(IStream_Stat(lpStream, &statstg, 1)))
580   {
581     if(statstg.cbSize.QuadPart)
582       bRet = FALSE; /* Non-Zero */
583   }
584   else
585   {
586     DWORD dwDummy;
587
588     /* Try to read from the stream */
589     if(SUCCEEDED(SHIStream_Read(lpStream, &dwDummy, sizeof(dwDummy))))
590     {
591       LARGE_INTEGER zero;
592       zero.QuadPart = 0;
593
594       IStream_Seek(lpStream, zero, 0, NULL);
595       bRet = FALSE; /* Non-Zero */
596     }
597   }
598   return bRet;
599 }
600
601 /*************************************************************************
602  * @       [SHLWAPI.212]
603  *
604  * Call IStream_Write() on a stream.
605  *
606  * PARAMS
607  *  lpStream [I] IStream object
608  *  lpvSrc   [I] Source for data to write
609  *  ulSize   [I] Size of data
610  *
611  * RETURNS
612  *  Success: S_OK. ulSize bytes have been written to the stream from lpvSrc.
613  *  Failure: An HRESULT error code, or E_FAIL if the write succeeded but the
614  *           number of bytes written does not match.
615  */
616 HRESULT WINAPI SHIStream_Write(IStream *lpStream, LPCVOID lpvSrc, ULONG ulSize)
617 {
618   ULONG ulWritten;
619   HRESULT hRet;
620
621   TRACE("(%p,%p,%d)\n", lpStream, lpvSrc, ulSize);
622
623   hRet = IStream_Write(lpStream, lpvSrc, ulSize, &ulWritten);
624
625   if (SUCCEEDED(hRet) && ulWritten != ulSize)
626     hRet = E_FAIL;
627
628   return hRet;
629 }
630
631 /*************************************************************************
632  * @       [SHLWAPI.213]
633  *
634  * Seek to the start of a stream.
635  *
636  * PARAMS
637  *  lpStream [I] IStream object
638  *
639  * RETURNS
640  *  Success: S_OK. The current position within the stream is updated
641  *  Failure: An HRESULT error code.
642  */
643 HRESULT WINAPI IStream_Reset(IStream *lpStream)
644 {
645   LARGE_INTEGER zero;
646   TRACE("(%p)\n", lpStream);
647   zero.QuadPart = 0;
648   return IStream_Seek(lpStream, zero, 0, NULL);
649 }
650
651 /*************************************************************************
652  * @       [SHLWAPI.214]
653  *
654  * Get the size of a stream.
655  *
656  * PARAMS
657  *  lpStream [I] IStream object
658  *  lpulSize [O] Destination for size
659  *
660  * RETURNS
661  *  Success: S_OK. lpulSize contains the size of the stream.
662  *  Failure: An HRESULT error code.
663  */
664 HRESULT WINAPI IStream_Size(IStream *lpStream, ULARGE_INTEGER* lpulSize)
665 {
666   STATSTG statstg;
667   HRESULT hRet;
668
669   TRACE("(%p,%p)\n", lpStream, lpulSize);
670
671   memset(&statstg, 0, sizeof(statstg));
672
673   hRet = IStream_Stat(lpStream, &statstg, 1);
674
675   if (SUCCEEDED(hRet) && lpulSize)
676     *lpulSize = statstg.cbSize;
677   return hRet;
678 }