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