dlls/itss/storage.c

   1 /*
   2  *    ITSS Storage implementation
   3  *
   4  * Copyright 2004 Mike McCormack
   5  *
   6  *  see http://bonedaddy.net/pabs3/hhm/#chmspec
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "winnls.h"
  32 #include "winreg.h"
  33 #include "ole2.h"
  34
  35 #include "uuids.h"
  36
  37 #include "itss.h"
  38 #include "chm_lib.h"
  39
  40 #include "wine/unicode.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(itss);
  44
  45 /************************************************************************/
  46
  47 typedef struct _ITSS_IStorageImpl
  48 {
  49     IStorageVtbl *vtbl_IStorage;
  50     DWORD ref;
  51     struct chmFile *chmfile;
  52     WCHAR dir[1];
  53 } ITSS_IStorageImpl;
  54
  55 struct enum_info
  56 {
  57     struct enum_info *next, *prev;
  58     struct chmUnitInfo ui;
  59 };
  60
  61 typedef struct _IEnumSTATSTG_Impl
  62 {
  63     IEnumSTATSTGVtbl *vtbl_IEnumSTATSTG;
  64     DWORD ref;
  65     struct enum_info *first, *last, *current;
  66 } IEnumSTATSTG_Impl;
  67
  68 typedef struct _IStream_Impl
  69 {
  70     IStreamVtbl *vtbl_IStream;
  71     DWORD ref;
  72     ITSS_IStorageImpl *stg;
  73     ULONGLONG addr;
  74     struct chmUnitInfo ui;
  75 } IStream_Impl;
  76
  77 static HRESULT ITSS_create_chm_storage(
  78            struct chmFile *chmfile, const WCHAR *dir, IStorage** ppstgOpen );
  79 static IStream_Impl* ITSS_create_stream(
  80            ITSS_IStorageImpl *stg, struct chmUnitInfo *ui );
  81
  82 /************************************************************************/
  83
  84 static HRESULT WINAPI ITSS_IEnumSTATSTG_QueryInterface(
  85     IEnumSTATSTG* iface,
  86     REFIID riid,
  87     void** ppvObject)
  88 {
  89     ICOM_THIS(IEnumSTATSTG_Impl,iface);
  90
  91     if (IsEqualGUID(riid, &IID_IUnknown)
  92         || IsEqualGUID(riid, &IID_IEnumSTATSTG))
  93     {
  94         IEnumSTATSTG_AddRef(iface);
  95         *ppvObject = This;
  96         return S_OK;
  97     }
  98
  99     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
 100     return E_NOINTERFACE;
 101 }
 102
 103 static ULONG WINAPI ITSS_IEnumSTATSTG_AddRef(
 104     IEnumSTATSTG* iface)
 105 {
 106     ICOM_THIS(IEnumSTATSTG_Impl,iface);
 107     return ++(This->ref);
 108 }
 109
 110 static ULONG WINAPI ITSS_IEnumSTATSTG_Release(
 111     IEnumSTATSTG* iface)
 112 {
 113     ICOM_THIS(IEnumSTATSTG_Impl,iface);
 114
 115     ULONG ref = --This->ref;
 116
 117     if (ref == 0)
 118     {
 119         while( This->first )
 120         {
 121             struct enum_info *t = This->first->next;
 122             HeapFree( GetProcessHeap(), 0, This->first );
 123             This->first = t;
 124         }
 125         HeapFree(GetProcessHeap(), 0, This);
 126     }
 127
 128     return ref;
 129 }
 130
 131 static HRESULT WINAPI ITSS_IEnumSTATSTG_Next(
 132         IEnumSTATSTG* iface,
 133         ULONG celt,
 134         STATSTG* rgelt,
 135         ULONG* pceltFetched)
 136 {
 137     ICOM_THIS(IEnumSTATSTG_Impl,iface);
 138     DWORD len, n;
 139     struct enum_info *cur;
 140
 141     TRACE("%p %lu %p %p\n", This, celt, rgelt, pceltFetched );
 142
 143     cur = This->current;
 144     n = 0;
 145     while( (n<celt) && cur)
 146     {
 147         WCHAR *str;
 148
 149         memset( rgelt, 0, sizeof *rgelt );
 150
 151         /* copy the name */
 152         str = cur->ui.path;
 153         if( *str == '/' )
 154             str++;
 155         len = strlenW( str ) + 1;
 156         rgelt->pwcsName = CoTaskMemAlloc( len*sizeof(WCHAR) );
 157         strcpyW( rgelt->pwcsName, str );
 158
 159         /* determine the type */
 160         if( rgelt->pwcsName[len-2] == '/' )
 161         {
 162             rgelt->pwcsName[len-2] = 0;
 163             rgelt->type = STGTY_STORAGE;
 164         }
 165         else
 166             rgelt->type = STGTY_STREAM;
 167
 168         /* copy the size */
 169         rgelt->cbSize.QuadPart = cur->ui.length;
 170
 171         /* advance to the next item if it exists */
 172         n++;
 173         cur = cur->next;
 174     }
 175
 176     This->current = cur;
 177     *pceltFetched = n;
 178
 179     if( n < celt )
 180         return S_FALSE;
 181
 182     return S_OK;
 183 }
 184
 185 static HRESULT WINAPI ITSS_IEnumSTATSTG_Skip(
 186         IEnumSTATSTG* iface,
 187         ULONG celt)
 188 {
 189     ICOM_THIS(IEnumSTATSTG_Impl,iface);
 190     DWORD n;
 191     struct enum_info *cur;
 192
 193     TRACE("%p %lu\n", This, celt );
 194
 195     cur = This->current;
 196     n = 0;
 197     while( (n<celt) && cur)
 198     {
 199         n++;
 200         cur = cur->next;
 201     }
 202     This->current = cur;
 203
 204     if( n < celt )
 205         return S_FALSE;
 206
 207     return S_OK;
 208 }
 209
 210 static HRESULT WINAPI ITSS_IEnumSTATSTG_Reset(
 211         IEnumSTATSTG* iface)
 212 {
 213     ICOM_THIS(IEnumSTATSTG_Impl,iface);
 214
 215     TRACE("%p\n", This );
 216
 217     This->current = This->first;
 218
 219     return S_OK;
 220 }
 221
 222 static HRESULT WINAPI ITSS_IEnumSTATSTG_Clone(
 223         IEnumSTATSTG* iface,
 224         IEnumSTATSTG** ppenum)
 225 {
 226     FIXME("\n");
 227     return E_NOTIMPL;
 228 }
 229
 230 struct IEnumSTATSTGVtbl IEnumSTATSTG_vtbl =
 231 {
 232     ITSS_IEnumSTATSTG_QueryInterface,
 233     ITSS_IEnumSTATSTG_AddRef,
 234     ITSS_IEnumSTATSTG_Release,
 235     ITSS_IEnumSTATSTG_Next,
 236     ITSS_IEnumSTATSTG_Skip,
 237     ITSS_IEnumSTATSTG_Reset,
 238     ITSS_IEnumSTATSTG_Clone
 239 };
 240
 241 static IEnumSTATSTG_Impl *ITSS_create_enum( void )
 242 {
 243     IEnumSTATSTG_Impl *stgenum;
 244
 245     stgenum = HeapAlloc( GetProcessHeap(), 0, sizeof (IEnumSTATSTG_Impl) );
 246     stgenum->vtbl_IEnumSTATSTG = &IEnumSTATSTG_vtbl;
 247     stgenum->ref = 1;
 248     stgenum->first = NULL;
 249     stgenum->last = NULL;
 250     stgenum->current = NULL;
 251
 252     TRACE(" -> %p\n", stgenum );
 253
 254     return stgenum;
 255 }
 256
 257 /************************************************************************/
 258
 259 HRESULT WINAPI ITSS_IStorageImpl_QueryInterface(
 260     IStorage* iface,
 261     REFIID riid,
 262     void** ppvObject)
 263 {
 264     ICOM_THIS(ITSS_IStorageImpl,iface);
 265
 266     if (IsEqualGUID(riid, &IID_IUnknown)
 267         || IsEqualGUID(riid, &IID_IStorage))
 268     {
 269         IStorage_AddRef(iface);
 270         *ppvObject = This;
 271         return S_OK;
 272     }
 273
 274     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
 275     return E_NOINTERFACE;
 276 }
 277
 278 ULONG WINAPI ITSS_IStorageImpl_AddRef(
 279     IStorage* iface)
 280 {
 281     ICOM_THIS(ITSS_IStorageImpl,iface);
 282     return ++(This->ref);
 283 }
 284
 285 ULONG WINAPI ITSS_IStorageImpl_Release(
 286     IStorage* iface)
 287 {
 288     ICOM_THIS(ITSS_IStorageImpl,iface);
 289
 290     ULONG ref = --This->ref;
 291
 292     if (ref == 0)
 293     {
 294         HeapFree(GetProcessHeap(), 0, This);
 295     }
 296
 297     return ref;
 298 }
 299
 300 HRESULT WINAPI ITSS_IStorageImpl_CreateStream(
 301     IStorage* iface,
 302     LPCOLESTR pwcsName,
 303     DWORD grfMode,
 304     DWORD reserved1,
 305     DWORD reserved2,
 306     IStream** ppstm)
 307 {
 308     FIXME("\n");
 309     return E_NOTIMPL;
 310 }
 311
 312 HRESULT WINAPI ITSS_IStorageImpl_OpenStream(
 313     IStorage* iface,
 314     LPCOLESTR pwcsName,
 315     void* reserved1,
 316     DWORD grfMode,
 317     DWORD reserved2,
 318     IStream** ppstm)
 319 {
 320     ICOM_THIS(ITSS_IStorageImpl,iface);
 321     IStream_Impl *stm;
 322     DWORD len;
 323     struct chmUnitInfo ui;
 324     int r;
 325     WCHAR *path;
 326
 327     TRACE("%p %s %p %lu %lu %p\n", This, debugstr_w(pwcsName),
 328           reserved1, grfMode, reserved2, ppstm );
 329
 330     len = strlenW( This->dir ) + strlenW( pwcsName ) + 1;
 331     path = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 332     strcpyW( path, This->dir );
 333     strcatW( path, pwcsName );
 334
 335     r = chm_resolve_object(This->chmfile, path, &ui);
 336     HeapFree( GetProcessHeap(), 0, path );
 337
 338     if( r != CHM_RESOLVE_SUCCESS )
 339         return STG_E_FILENOTFOUND;
 340
 341     stm = ITSS_create_stream( This, &ui );
 342     if( !stm )
 343         return E_FAIL;
 344
 345     *ppstm = (IStream*) stm;
 346
 347     return S_OK;
 348 }
 349
 350 HRESULT WINAPI ITSS_IStorageImpl_CreateStorage(
 351     IStorage* iface,
 352     LPCOLESTR pwcsName,
 353     DWORD grfMode,
 354     DWORD dwStgFmt,
 355     DWORD reserved2,
 356     IStorage** ppstg)
 357 {
 358     FIXME("\n");
 359     return E_NOTIMPL;
 360 }
 361
 362 HRESULT WINAPI ITSS_IStorageImpl_OpenStorage(
 363     IStorage* iface,
 364     LPCOLESTR pwcsName,
 365     IStorage* pstgPriority,
 366     DWORD grfMode,
 367     SNB snbExclude,
 368     DWORD reserved,
 369     IStorage** ppstg)
 370 {
 371     FIXME("\n");
 372     return E_NOTIMPL;
 373 }
 374
 375 HRESULT WINAPI ITSS_IStorageImpl_CopyTo(
 376     IStorage* iface,
 377     DWORD ciidExclude,
 378     const IID* rgiidExclude,
 379     SNB snbExclude,
 380     IStorage* pstgDest)
 381 {
 382     FIXME("\n");
 383     return E_NOTIMPL;
 384 }
 385
 386 HRESULT WINAPI ITSS_IStorageImpl_MoveElementTo(
 387     IStorage* iface,
 388     LPCOLESTR pwcsName,
 389     IStorage* pstgDest,
 390     LPCOLESTR pwcsNewName,
 391     DWORD grfFlags)
 392 {
 393     FIXME("\n");
 394     return E_NOTIMPL;
 395 }
 396
 397 HRESULT WINAPI ITSS_IStorageImpl_Commit(
 398     IStorage* iface,
 399     DWORD grfCommitFlags)
 400 {
 401     FIXME("\n");
 402     return E_NOTIMPL;
 403 }
 404
 405 HRESULT WINAPI ITSS_IStorageImpl_Revert(
 406     IStorage* iface)
 407 {
 408     FIXME("\n");
 409     return E_NOTIMPL;
 410 }
 411
 412 static int ITSS_chm_enumerator(
 413     struct chmFile *h,
 414     struct chmUnitInfo *ui,
 415     void *context)
 416 {
 417     struct enum_info *info;
 418     IEnumSTATSTG_Impl* stgenum = context;
 419
 420     TRACE("adding %s to enumeration\n", debugstr_w(ui->path) );
 421
 422     info = HeapAlloc( GetProcessHeap(), 0, sizeof (struct enum_info) );
 423     memcpy( &info->ui, ui, sizeof info->ui );
 424
 425     info->next = NULL;
 426     info->prev = stgenum->last;
 427     if( stgenum->last )
 428         stgenum->last->next = info;
 429     else
 430         stgenum->first = info;
 431     stgenum->last = info;
 432
 433     return CHM_ENUMERATOR_CONTINUE;
 434 }
 435
 436 HRESULT WINAPI ITSS_IStorageImpl_EnumElements(
 437     IStorage* iface,
 438     DWORD reserved1,
 439     void* reserved2,
 440     DWORD reserved3,
 441     IEnumSTATSTG** ppenum)
 442 {
 443     ICOM_THIS(ITSS_IStorageImpl,iface);
 444     IEnumSTATSTG_Impl* stgenum;
 445
 446     TRACE("%p %ld %p %ld %p\n", This, reserved1, reserved2, reserved3, ppenum );
 447
 448     stgenum = ITSS_create_enum();
 449     if( !stgenum )
 450         return E_FAIL;
 451
 452     chm_enumerate_dir(This->chmfile,
 453                   This->dir,
 454                   CHM_ENUMERATE_ALL,
 455                   ITSS_chm_enumerator,
 456                   stgenum );
 457
 458     stgenum->current = stgenum->first;
 459
 460     *ppenum = (IEnumSTATSTG*) stgenum;
 461
 462     return S_OK;
 463 }
 464
 465 HRESULT WINAPI ITSS_IStorageImpl_DestroyElement(
 466     IStorage* iface,
 467     LPCOLESTR pwcsName)
 468 {
 469     FIXME("\n");
 470     return E_NOTIMPL;
 471 }
 472
 473 HRESULT WINAPI ITSS_IStorageImpl_RenameElement(
 474     IStorage* iface,
 475     LPCOLESTR pwcsOldName,
 476     LPCOLESTR pwcsNewName)
 477 {
 478     FIXME("\n");
 479     return E_NOTIMPL;
 480 }
 481
 482 HRESULT WINAPI ITSS_IStorageImpl_SetElementTimes(
 483     IStorage* iface,
 484     LPCOLESTR pwcsName,
 485     const FILETIME* pctime,
 486     const FILETIME* patime,
 487     const FILETIME* pmtime)
 488 {
 489     FIXME("\n");
 490     return E_NOTIMPL;
 491 }
 492
 493 HRESULT WINAPI ITSS_IStorageImpl_SetClass(
 494     IStorage* iface,
 495     REFCLSID clsid)
 496 {
 497     FIXME("\n");
 498     return E_NOTIMPL;
 499 }
 500
 501 HRESULT WINAPI ITSS_IStorageImpl_SetStateBits(
 502     IStorage* iface,
 503     DWORD grfStateBits,
 504     DWORD grfMask)
 505 {
 506     FIXME("\n");
 507     return E_NOTIMPL;
 508 }
 509
 510 HRESULT WINAPI ITSS_IStorageImpl_Stat(
 511     IStorage* iface,
 512     STATSTG* pstatstg,
 513     DWORD grfStatFlag)
 514 {
 515     FIXME("\n");
 516     return E_NOTIMPL;
 517 }
 518
 519 static IStorageVtbl ITSS_IStorageImpl_Vtbl =
 520 {
 521     ITSS_IStorageImpl_QueryInterface,
 522     ITSS_IStorageImpl_AddRef,
 523     ITSS_IStorageImpl_Release,
 524     ITSS_IStorageImpl_CreateStream,
 525     ITSS_IStorageImpl_OpenStream,
 526     ITSS_IStorageImpl_CreateStorage,
 527     ITSS_IStorageImpl_OpenStorage,
 528     ITSS_IStorageImpl_CopyTo,
 529     ITSS_IStorageImpl_MoveElementTo,
 530     ITSS_IStorageImpl_Commit,
 531     ITSS_IStorageImpl_Revert,
 532     ITSS_IStorageImpl_EnumElements,
 533     ITSS_IStorageImpl_DestroyElement,
 534     ITSS_IStorageImpl_RenameElement,
 535     ITSS_IStorageImpl_SetElementTimes,
 536     ITSS_IStorageImpl_SetClass,
 537     ITSS_IStorageImpl_SetStateBits,
 538     ITSS_IStorageImpl_Stat,
 539 };
 540
 541 static HRESULT ITSS_create_chm_storage(
 542       struct chmFile *chmfile, const WCHAR *dir, IStorage** ppstgOpen )
 543 {
 544     ITSS_IStorageImpl *stg;
 545     DWORD len;
 546
 547     TRACE("%p %s\n", chmfile, debugstr_w( dir ) );
 548
 549     len = strlenW( dir ) + 1;
 550     stg = HeapAlloc( GetProcessHeap(), 0,
 551                      sizeof (ITSS_IStorageImpl) + len*sizeof(WCHAR) );
 552     stg->vtbl_IStorage = &ITSS_IStorageImpl_Vtbl;
 553     stg->ref = 1;
 554     stg->chmfile = chmfile;
 555     strcpyW( stg->dir, dir );
 556
 557     *ppstgOpen = (IStorage*) stg;
 558
 559     return S_OK;
 560 }
 561
 562 HRESULT ITSS_StgOpenStorage(
 563     const WCHAR* pwcsName,
 564     IStorage* pstgPriority,
 565     DWORD grfMode,
 566     SNB snbExclude,
 567     DWORD reserved,
 568     IStorage** ppstgOpen)
 569 {
 570     struct chmFile *chmfile;
 571     static const WCHAR szRoot[] = { '/', 0 };
 572
 573     TRACE("%s\n", debugstr_w(pwcsName) );
 574
 575     chmfile = chm_openW( pwcsName );
 576     if( !chmfile )
 577         return E_FAIL;
 578
 579     return ITSS_create_chm_storage( chmfile, szRoot, ppstgOpen );
 580 }
 581
 582 /************************************************************************/
 583
 584 static HRESULT WINAPI ITSS_IStream_QueryInterface(
 585     IStream* iface,
 586     REFIID riid,
 587     void** ppvObject)
 588 {
 589     ICOM_THIS(IStream_Impl,iface);
 590
 591     if (IsEqualGUID(riid, &IID_IUnknown)
 592         || IsEqualGUID(riid, &IID_ISequentialStream)
 593         || IsEqualGUID(riid, &IID_IStream))
 594     {
 595         IStream_AddRef(iface);
 596         *ppvObject = This;
 597         return S_OK;
 598     }
 599
 600     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
 601     return E_NOINTERFACE;
 602 }
 603
 604 static ULONG WINAPI ITSS_IStream_AddRef(
 605     IStream* iface)
 606 {
 607     ICOM_THIS(IStream_Impl,iface);
 608     return ++(This->ref);
 609 }
 610
 611 static ULONG WINAPI ITSS_IStream_Release(
 612     IStream* iface)
 613 {
 614     ICOM_THIS(IStream_Impl,iface);
 615
 616     ULONG ref = --This->ref;
 617
 618     if (ref == 0)
 619     {
 620         IStorage_Release( (IStorage*) This->stg );
 621         HeapFree(GetProcessHeap(), 0, This);
 622     }
 623
 624     return ref;
 625 }
 626
 627 static HRESULT WINAPI ITSS_IStream_Read(
 628         IStream* iface,
 629         void* pv,
 630         ULONG cb,
 631         ULONG* pcbRead)
 632 {
 633     ICOM_THIS(IStream_Impl,iface);
 634     ULONG count;
 635
 636     TRACE("%p %p %lu %p\n", This, pv, cb, pcbRead);
 637
 638     count = chm_retrieve_object(This->stg->chmfile,
 639                           &This->ui, pv, This->addr, cb);
 640     This->addr += count;
 641     if( pcbRead )
 642         *pcbRead = count;
 643
 644     return S_OK;
 645 }
 646
 647 static HRESULT WINAPI ITSS_IStream_Write(
 648         IStream* iface,
 649         const void* pv,
 650         ULONG cb,
 651         ULONG* pcbWritten)
 652 {
 653     FIXME("\n");
 654     return E_NOTIMPL;
 655 }
 656
 657 static HRESULT WINAPI ITSS_IStream_Seek(
 658         IStream* iface,
 659         LARGE_INTEGER dlibMove,
 660         DWORD dwOrigin,
 661         ULARGE_INTEGER* plibNewPosition)
 662 {
 663     ICOM_THIS(IStream_Impl,iface);
 664     LONGLONG newpos;
 665
 666     TRACE("%p %s %lu %p\n", This,
 667           wine_dbgstr_longlong( dlibMove.QuadPart ), dwOrigin, plibNewPosition );
 668
 669     newpos = This->addr;
 670     switch( dwOrigin )
 671     {
 672     case STREAM_SEEK_CUR:
 673         newpos = This->addr + dlibMove.QuadPart;
 674         break;
 675     case STREAM_SEEK_SET:
 676         newpos = dlibMove.QuadPart;
 677         break;
 678     case STREAM_SEEK_END:
 679         newpos = This->ui.length + dlibMove.QuadPart;
 680         break;
 681     }
 682
 683     if( ( newpos < 0 ) || ( newpos > This->ui.length ) )
 684         return STG_E_INVALIDPOINTER;
 685
 686     This->addr = newpos;
 687     if( plibNewPosition )
 688         plibNewPosition->QuadPart = This->addr;
 689
 690     return S_OK;
 691 }
 692
 693 static HRESULT WINAPI ITSS_IStream_SetSize(
 694         IStream* iface,
 695         ULARGE_INTEGER libNewSize)
 696 {
 697     FIXME("\n");
 698     return E_NOTIMPL;
 699 }
 700
 701 static HRESULT WINAPI ITSS_IStream_CopyTo(
 702         IStream* iface,
 703         IStream* pstm,
 704         ULARGE_INTEGER cb,
 705         ULARGE_INTEGER* pcbRead,
 706         ULARGE_INTEGER* pcbWritten)
 707 {
 708     FIXME("\n");
 709     return E_NOTIMPL;
 710 }
 711
 712 static HRESULT WINAPI ITSS_IStream_Commit(
 713         IStream* iface,
 714         DWORD grfCommitFlags)
 715 {
 716     FIXME("\n");
 717     return E_NOTIMPL;
 718 }
 719
 720 static HRESULT WINAPI ITSS_IStream_Revert(
 721         IStream* iface)
 722 {
 723     FIXME("\n");
 724     return E_NOTIMPL;
 725 }
 726
 727 static HRESULT WINAPI ITSS_IStream_LockRegion(
 728         IStream* iface,
 729         ULARGE_INTEGER libOffset,
 730         ULARGE_INTEGER cb,
 731         DWORD dwLockType)
 732 {
 733     FIXME("\n");
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI ITSS_IStream_UnlockRegion(
 738         IStream* iface,
 739         ULARGE_INTEGER libOffset,
 740         ULARGE_INTEGER cb,
 741         DWORD dwLockType)
 742 {
 743     FIXME("\n");
 744     return E_NOTIMPL;
 745 }
 746
 747 static HRESULT WINAPI ITSS_IStream_Stat(
 748         IStream* iface,
 749         STATSTG* pstatstg,
 750         DWORD grfStatFlag)
 751 {
 752     FIXME("\n");
 753     return E_NOTIMPL;
 754 }
 755
 756 static HRESULT WINAPI ITSS_IStream_Clone(
 757         IStream* iface,
 758         IStream** ppstm)
 759 {
 760     FIXME("\n");
 761     return E_NOTIMPL;
 762 }
 763
 764 struct IStreamVtbl ITSS_IStream_vtbl =
 765 {
 766     ITSS_IStream_QueryInterface,
 767     ITSS_IStream_AddRef,
 768     ITSS_IStream_Release,
 769     ITSS_IStream_Read,
 770     ITSS_IStream_Write,
 771     ITSS_IStream_Seek,
 772     ITSS_IStream_SetSize,
 773     ITSS_IStream_CopyTo,
 774     ITSS_IStream_Commit,
 775     ITSS_IStream_Revert,
 776     ITSS_IStream_LockRegion,
 777     ITSS_IStream_UnlockRegion,
 778     ITSS_IStream_Stat,
 779     ITSS_IStream_Clone,
 780 };
 781
 782 static IStream_Impl *ITSS_create_stream(
 783            ITSS_IStorageImpl *stg, struct chmUnitInfo *ui )
 784 {
 785     IStream_Impl *stm;
 786
 787     stm = HeapAlloc( GetProcessHeap(), 0, sizeof (IStream_Impl) );
 788     stm->vtbl_IStream = &ITSS_IStream_vtbl;
 789     stm->ref = 1;
 790     stm->addr = 0;
 791     memcpy( &stm->ui, ui, sizeof stm->ui );
 792     stm->stg = stg;
 793     IStorage_AddRef( (IStorage*) stg );
 794
 795     TRACE(" -> %p\n", stm );
 796
 797     return stm;
 798 }