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