windows-xp/Source/XPSP1/NT/com/ole32/stg/exp/docfile.cxx

//+--------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1991 - 1992.
//
//  File:       docfile.c
//
//  Contents:   DocFile root functions (Stg* functions)
//
//  History:    10-Dec-91       DrewB   Created
//
//---------------------------------------------------------------

#include <exphead.cxx>
#pragma hdrstop

#include <rpubdf.hxx>
#include <expdf.hxx>
#include <expst.hxx>
#include <dfentry.hxx>
#include <logfile.hxx>
#include <dirfunc.hxx>
#include <wdocfile.hxx>

#include <ole2sp.h>
#include <ole2com.h>
#include <hkole32.h>

#ifdef COORD
#include <resource.hxx>
#endif

#ifdef _MAC
#include <ole2sp.h>
#endif


HRESULT IsNffAppropriate(const LPCWSTR pwcsName);

//+--------------------------------------------------------------
//
//  Function:   DfFromLB, private
//
//  Synopsis:   Starts a root Docfile on an ILockBytes
//
//  Arguments:  [plst] - LStream to start on
//              [df] - Permissions
//              [dwStartFlags] - Startup flags
//              [snbExclude] - Partial instantiation list
//              [ppdfExp] - DocFile return
//              [pcid] - Class ID return for opens
//
//  Returns:    Appropriate status code
//
//  Modifies:   [ppdfExp]
//              [pcid]
//
//  History:    19-Mar-92       DrewB   Created
//              18-May-93       AlexT   Added pMalloc
//
//  Algorithm:  Create and initialize a root transaction level
//              Create and initialize a public docfile
//              Create and initialize an exposed docfile
//
//---------------------------------------------------------------


#ifdef COORD
SCODE DfFromLB(CPerContext *ppc,
               ILockBytes *plst,
               DFLAGS df,
               DWORD dwStartFlags,
               SNBW snbExclude,
               ITransaction *pTransaction,
               CExposedDocFile **ppdfExp,
               CLSID *pcid)
#else
SCODE DfFromLB(CPerContext *ppc,
               ILockBytes *plst,
               DFLAGS df,
               DWORD dwStartFlags,
               SNBW snbExclude,
               CExposedDocFile **ppdfExp,
               CLSID *pcid)
#endif //COORD
{
    SCODE sc, scConv;
    CRootPubDocFile *prpdf;

#ifdef COORD
    CPubDocFile *ppubdf;
    CPubDocFile *ppubReturn;
    CWrappedDocFile *pwdf;
    CDocfileResource *pdfr = NULL;
#endif

    CDFBasis *pdfb;
    ULONG ulOpenLock;
    IMalloc *pMalloc = ppc->GetMalloc();

    ppc->AddRef();

    olDebugOut((DEB_ITRACE, "In  DfFromLB(%p, %p, %X, %lX, %p, %p, %p)\n",
                pMalloc, plst, df, dwStartFlags, snbExclude, ppdfExp, pcid));

    //Take the mutex in the CPerContext, in case there is an IFillLockBytes
    //  trying to write data while we're trying to open.
    CSafeSem _ss(ppc);
    olChk(_ss.Take());

#ifdef CHECKCID
    ULONG cbRead;
    olChk(plst->ReadAt(CBCLSIDOFFSET, pcid, sizeof(CLSID), &cbRead));
    if (cbRead != sizeof(CLSID))
        olErr(EH_Err, STG_E_INVALIDHEADER);
    if (!REFCLSIDEQ(*pcid, DOCFILE_CLASSID))
        olErr(EH_Err, STG_E_INVALIDHEADER);
#endif

#ifdef COORD

    if (pTransaction != NULL)
    {
        //If we've passed in an ITransaction pointer, it indicates that we
        //   want to open or create this docfile as part of a coordinated
        //   transaction.  First, we need to find out if there's a docfile
        //   resource manager for that transaction currently existing in
        //   this process.
        //First, check if we're opening transacted.  If we aren't, then we're
        //   not going to allow this docfile to participate in the
        //   transaction.

        if (!P_TRANSACTED(df))
        {
            //Is this the right error?
            olErr(EH_Err, STG_E_INVALIDFUNCTION);
        }
        XACTTRANSINFO xti;
        olChk(pTransaction->GetTransactionInfo(&xti));

        EnterCriticalSection(&g_csResourceList);
        CDocfileResource *pdfrTemp = g_dfrHead.GetNext();

        while (pdfrTemp != NULL)
        {
            if (IsEqualBOID(pdfrTemp->GetUOW(), xti.uow))
            {
                //Direct hit.
                pdfr = pdfrTemp;
                break;
            }
            pdfrTemp = pdfrTemp->GetNext();
        }

        if (pdfr == NULL)
        {
            ITransactionCoordinator *ptc;
            //If there isn't, we need to create one.

            olChkTo(EH_cs, pTransaction->QueryInterface(
                IID_ITransactionCoordinator,
                (void **)&ptc));

            pdfr = new CDocfileResource;
            if (pdfr == NULL)
            {
                ptc->Release();
                olErr(EH_cs, STG_E_INSUFFICIENTMEMORY);
            }
            sc = pdfr->Enlist(ptc);
            ptc->Release();
            if (FAILED(sc))
            {
                pdfr->Release();;
                olErr(EH_cs, sc);
            }

            //Add to list.
            pdfr->SetNext(g_dfrHead.GetNext());
            if (g_dfrHead.GetNext() != NULL)
                g_dfrHead.GetNext()->SetPrev(pdfr);
            g_dfrHead.SetNext(pdfr);
            pdfr->SetPrev(&g_dfrHead);
        }
        else
        {
            //We'll release this reference below.
            pdfr->AddRef();
        }
        LeaveCriticalSection(&g_csResourceList);
    }
#endif

    // Make root
    olMem(prpdf = new (pMalloc) CRootPubDocFile(pMalloc));
    olChkTo(EH_prpdf, scConv = prpdf->InitRoot(plst, dwStartFlags, df,
                                               snbExclude, &pdfb,
                                               &ulOpenLock,
                                               ppc->GetGlobal()));

#ifdef COORD
    if (pTransaction != NULL)
    {
        //Set up a fake transaction level at the root.  A pointer to
        //  this will be held by the resource manager.  The storage pointer
        //  that is passed back to the caller will be a pointer to the
        //  transaction level (non-root) below it.  This will allow the
        //  client to write and commit as many times as desired without
        //  the changes ever actually hitting the file.

        CDfName dfnNull;  //  auto-initialized to 0
        WCHAR wcZero = 0;
        dfnNull.Set(2, (BYTE *)&wcZero);

        olMemTo(EH_prpdfInit, pwdf = new (pMalloc) CWrappedDocFile(
                &dfnNull,
                ROOT_LUID,
                (df & ~DF_INDEPENDENT),
                pdfb,
                NULL));

        olChkTo(EH_pwdf, pwdf->Init(prpdf->GetDF()));
        prpdf->GetDF()->AddRef();

        olMemTo(EH_pwdfInit, ppubdf = new (pMalloc) CPubDocFile(
            prpdf,
            pwdf,
            (df | DF_COORD) & ~DF_INDEPENDENT,
            ROOT_LUID,
            pdfb,
            &dfnNull,
            2,
            pdfb->GetBaseMultiStream()));

        olChkTo(EH_ppubdf, pwdf->InitPub(ppubdf));
        ppubdf->AddXSMember(NULL, pwdf, ROOT_LUID);

        ppubReturn = ppubdf;
    }
    else
    {
        ppubReturn = prpdf;
    }
#endif //COORD


    ppc->SetILBInfo(pdfb->GetBase(),
                    pdfb->GetDirty(),
                    pdfb->GetOriginal(),
                    ulOpenLock);
    ppc->SetLockInfo(ulOpenLock != 0, df);
    // Make exposed

#ifdef COORD
    //We don't need to AddRef ppc since it starts with a refcount of 1.
    olMemTo(EH_ppcInit,
            *ppdfExp = new (pMalloc) CExposedDocFile(
                ppubReturn,
                pdfb,
                ppc));

    if (pTransaction != NULL)
    {
        CExposedDocFile *pexpdf;

        olMemTo(EH_ppcInit, pexpdf = new (pMalloc) CExposedDocFile(
            prpdf,
            pdfb,
            ppc));
        ppc->AddRef();

        sc = pdfr->Join(pexpdf);
        if (FAILED(sc))
        {
            pexpdf->Release();
            olErr(EH_ppcInit, sc);
        }
        pdfr->Release();
    }
#else
    olMemTo(EH_ppcInit,
            *ppdfExp = new (pMalloc) CExposedDocFile(
                prpdf,
                pdfb,
                ppc));
#endif //COORD

    olDebugOut((DEB_ITRACE, "Out DfFromLB => %p\n", *ppdfExp));
    return scConv;

 EH_ppcInit:
    // The context will release this but we want to keep it around
    // so take a reference
    pdfb->GetOriginal()->AddRef();
    pdfb->GetBase()->AddRef();
    pdfb->GetDirty()->AddRef();
    if (ulOpenLock > 0 && ppc->GetGlobal() == NULL)
    {
        //  The global context doesn't exist, so we need to release
        //  the open lock explicitly.

        ReleaseOpen(pdfb->GetOriginal(), df, ulOpenLock);
    }

    //  The open lock has now been released (either explicitly or by ppc)
    ulOpenLock = 0;
#ifdef COORD
EH_ppubdf:
    if (pTransaction != NULL)
    {
        ppubdf->vRelease();
    }
EH_pwdfInit:
    if (pTransaction != NULL)
    {
        prpdf->GetDF()->Release();
    }
EH_pwdf:
    if (pTransaction != NULL)
    {
        pwdf->Release();
    }
 EH_prpdfInit:
#endif //COORD
    pdfb->GetDirty()->Release();
    pdfb->GetBase()->Release();
    if (ulOpenLock > 0)
        ReleaseOpen(pdfb->GetOriginal(), df, ulOpenLock);

    pdfb->SetDirty(NULL);
    pdfb->SetBase(NULL);

 EH_prpdf:
    prpdf->ReleaseLocks(plst);
    prpdf->vRelease();
#ifdef COORD
    if ((pTransaction != NULL) && (pdfr != NULL))
    {
        pdfr->Release();
    }
    goto EH_Err;
 EH_cs:
    LeaveCriticalSection(&g_csResourceList);
#endif

 EH_Err:
    ppc->Release();
    return sc;
}

//+--------------------------------------------------------------
//
//  Function:   DfFromName, private
//
//  Synopsis:   Starts a root DocFile from a base name
//
//  Arguments:  [pwcsName] - Name
//              [df] - Permissions
//              [dwStartFlags] - Startup flags
//              [snbExclude] - Partial instantiation list
//              [ppdfExp] - Docfile return
//              [pcid] - Class ID return for opens
//
//  Returns:    Appropriate status code
//
//  Modifies:   [ppdfExp]
//              [pcid]
//
//  History:    19-Mar-92       DrewB   Created
//              18-May-93       AlexT   Add per file allocator
//
//  Notes:      [pwcsName] is treated as unsafe memory
//
//---------------------------------------------------------------


// This set of root startup flags is handled by the multistream
// and doesn't need to be set for filestreams
#define RSF_MSF (RSF_CONVERT | RSF_TRUNCATE | RSF_ENCRYPTED)

#ifdef COORD
SCODE DfFromName(WCHAR const *pwcsName,
                 DFLAGS df,
                 DWORD dwStartFlags,
                 SNBW snbExclude,
                 ITransaction *pTransaction,
                 CExposedDocFile **ppdfExp,
                 ULONG *pulSectorSize,
                 CLSID *pcid)
#else
SCODE DfFromName(WCHAR const *pwcsName,
                 DFLAGS df,
                 DWORD dwStartFlags,
                 SNBW snbExclude,
                 CExposedDocFile **ppdfExp,
                 ULONG *pulSectorSize,
                 CLSID *pcid)
#endif
{
    IMalloc *pMalloc;
    CFileStream *plst;
    CPerContext *ppc;
    CFileStream *plst2 = NULL;
    SCODE sc;
    CMSFHeader *phdr = NULL;
    BOOL fCreated;

    olDebugOut((DEB_ITRACE, "In  DfFromName(%ws, %lX, %lX, %p, %p, %p)\n",
                pwcsName, df, dwStartFlags, snbExclude, ppdfExp, pcid));

    olHChk(DfCreateSharedAllocator(&pMalloc, df & DF_LARGE));

    // Start an ILockBytes from the named file
    olMemTo(EH_Malloc, plst = new (pMalloc) CFileStream(pMalloc));
    olChkTo(EH_plst, plst->InitGlobal(dwStartFlags & ~RSF_MSF, df));
    sc = plst->InitFile(pwcsName);
    fCreated = SUCCEEDED(sc) &&
        ((dwStartFlags & RSF_CREATE) || pwcsName == NULL);
    if (sc == STG_E_FILEALREADYEXISTS && (dwStartFlags & RSF_MSF))
    {
        plst->SetStartFlags(dwStartFlags & ~(RSF_MSF | RSF_CREATE));
        sc = plst->InitFile(pwcsName);
    }
    olChkTo(EH_plst, sc);

    if (!(dwStartFlags & RSF_CREATE))
    {
        ULONG cbDiskSector =  (dwStartFlags & RSF_NO_BUFFERING) ?
                               plst->GetSectorSize() : HEADERSIZE;
        olMemTo (EH_plstInit, phdr = (CMSFHeader*) TaskMemAlloc (cbDiskSector));
        ULARGE_INTEGER ulOffset = {0,0};
        ULONG ulRead;

        olChkTo (EH_plstInit, plst->ReadAt(ulOffset,phdr,cbDiskSector,&ulRead));
        if (ulRead < sizeof(CMSFHeaderData))
            olErr (EH_plstInit, STG_E_FILEALREADYEXISTS);
        sc = phdr->Validate();
        if (sc == STG_E_INVALIDHEADER)
            sc = STG_E_FILEALREADYEXISTS;
        olChkTo (EH_plstInit, sc);
        if (phdr->GetSectorShift() > SECTORSHIFT512)
        {
            IMalloc *pMalloc2 = NULL;
            CGlobalFileStream *pgfst = plst->GetGlobal();
#ifdef MULTIHEAP
            CSharedMemoryBlock *psmb;
            BYTE *pbBase;
            ULONG ulHeapName;
#endif

            df |= DF_LARGE;   // reallocate objects from task memory
            dwStartFlags |= (phdr->GetSectorShift() <<12) & RSF_SECTORSIZE_MASK;
            // create and initialize the task allocator
#ifdef MULTIHEAP
            g_smAllocator.GetState (&psmb, &pbBase, &ulHeapName);
#endif
            olChkTo(EH_taskmem, DfCreateSharedAllocator(&pMalloc2, TRUE));
            pMalloc->Release();
            pMalloc = pMalloc2;

            olMemTo(EH_taskmem, plst2 = new (pMalloc2) CFileStream(pMalloc2));
            olChkTo(EH_taskmem, plst2->InitGlobal(dwStartFlags & ~RSF_MSF, df));

            plst2->InitFromFileStream (plst);
            plst2->GetGlobal()->InitFromGlobalFileStream (pgfst);

#ifdef MULTIHEAP
            g_smAllocator.SetState (psmb, pbBase, ulHeapName, NULL, NULL);
            g_smAllocator.Uninit();  // unmap newly created heap
            g_smAllocator.SetState (NULL, NULL, 0, NULL, NULL);
#endif
            plst = plst2;  // CFileStream was destroyed by Uninit

        }
        TaskMemFree ((BYTE*)phdr);
        phdr = NULL;
    }

    //Create the per context
    olMemTo(EH_plstInit, ppc = new (pMalloc) CPerContext(pMalloc));
    olChkTo(EH_ppc, ppc->InitNewContext());

    {
#ifdef MULTIHEAP
        CSafeMultiHeap smh(ppc);
#endif

    // Start up the docfile
#ifdef COORD
        sc = DfFromLB(ppc, plst, df, dwStartFlags,
                      snbExclude, pTransaction,
                      ppdfExp, pcid);
#else
        sc = DfFromLB(ppc, plst, df, dwStartFlags,
                      snbExclude, ppdfExp, pcid);
#endif //COORD

    //Either DfFromLB has AddRef'ed the per context or it has failed.
    //Either way we want to release our reference here.
        LONG lRet;
        lRet = ppc->Release();
#ifdef MULTIHEAP
        olAssert((FAILED(sc)) || (lRet != 0));
#endif
        if (FAILED(sc))
        {
            if (fCreated || ((dwStartFlags & RSF_CREATE) && !P_TRANSACTED(df)))
                plst->Delete();
            plst->Release();
#ifdef MULTIHEAP
            if (lRet == 0)
            {
                g_smAllocator.Uninit();
            }
#endif
        }
        else if (pulSectorSize != NULL)
        {
            *pulSectorSize = (*ppdfExp)->GetPub()->GetBaseMS()->GetSectorSize();
        }
    }
    pMalloc->Release();

    olDebugOut((DEB_ITRACE, "Out DfFromName => %p\n", *ppdfExp));
    return sc;
EH_ppc:
    delete ppc;
EH_taskmem:
    if (plst2) plst2->Release();
EH_plstInit:
    if (fCreated || ((dwStartFlags & RSF_CREATE) && !P_TRANSACTED(df)))
        plst->Delete();
EH_plst:
    plst->Release();
EH_Malloc:
#ifdef MULTIHEAP
    g_smAllocator.Uninit();  // unmap newly created heap
#endif
    pMalloc->Release();
EH_Err:
    if (phdr != NULL)
        TaskMemFree ((BYTE*)phdr);
    return sc;
}


//+--------------------------------------------------------------
//
//  Function:   DfCreateDocfile, public
//
//  Synopsis:   Creates a root Docfile on a file
//
//  Arguments:  [pwcsName] - Filename
//              [grfMode] - Permissions
//              [reserved] - security attributes
//              [grfAttrs] - Win32 CreateFile attributes
//              [ppstgOpen] - Docfile return
//
//  Returns:    Appropriate status code
//
//  Modifies:   [ppstgOpen]
//
//  History:    14-Jan-92       DrewB   Created
//
//---------------------------------------------------------------


STDAPI DfCreateDocfile (WCHAR const *pwcsName,
#ifdef COORD
                        ITransaction *pTransaction,
#else
                        void *pTransaction,
#endif
                        DWORD grfMode,
#if WIN32 == 300
                        LPSECURITY_ATTRIBUTES reserved,
#else
                        LPSTGSECURITY reserved,
#endif
                        ULONG ulSectorSize,
                        DWORD grfAttrs,
                        IStorage **ppstgOpen)
{
    SafeCExposedDocFile pdfExp;
    SCODE sc;
    DFLAGS df;
    DWORD dwSectorFlag = 0;

    OLETRACEIN((API_StgCreateDocfile,
        PARAMFMT("pwcsName= %ws, grfMode= %x, reserved=%p, ppstgOpen= %p"),
                pwcsName, grfMode, reserved, ppstgOpen));

    olLog(("--------::In  StgCreateDocFile(%ws, %lX, %lu, %p)\n",
           pwcsName, grfMode, reserved, ppstgOpen));
    olDebugOut((DEB_TRACE, "In  StgCreateDocfile(%ws, %lX, %lu, %p)\n",
               pwcsName, grfMode, reserved, ppstgOpen));

    olAssert(sizeof(LPSTGSECURITY) == sizeof(DWORD));

    olChkTo(EH_BadPtr, ValidatePtrBuffer(ppstgOpen));
    *ppstgOpen = NULL;
    if (pwcsName)
        olChk(ValidateNameW(pwcsName, _MAX_PATH));

    if (reserved != 0)
        olErr(EH_Err, STG_E_INVALIDPARAMETER);

    if (grfMode & STGM_SIMPLE)
    {
        if (pTransaction != NULL)
        {
            olErr(EH_Err, STG_E_INVALIDFLAG);
        }
        if (ulSectorSize > 512)
            olErr (EH_Err, STG_E_INVALIDPARAMETER);

        sc = DfCreateSimpDocfile(pwcsName, grfMode, 0, ppstgOpen);
        goto EH_Err;
    }

    olChk(VerifyPerms(grfMode, TRUE));
    if ((grfMode & STGM_RDWR) == STGM_READ ||
        (grfMode & (STGM_DELETEONRELEASE | STGM_CONVERT)) ==
        (STGM_DELETEONRELEASE | STGM_CONVERT))
        olErr(EH_Err, STG_E_INVALIDFLAG);

    df = ModeToDFlags(grfMode);
    if ((grfMode & (STGM_TRANSACTED | STGM_CONVERT)) ==
        (STGM_TRANSACTED | STGM_CONVERT))
        df |= DF_INDEPENDENT;
    if (ulSectorSize > 512)
    {
        df |= DF_LARGE;
        switch (ulSectorSize)
        {
            case 4096 : dwSectorFlag = RSF_SECTORSIZE4K; break;
            case 8192 : dwSectorFlag = RSF_SECTORSIZE8K; break;
            case 16384 : dwSectorFlag = RSF_SECTORSIZE16K; break;
            case 32768 : dwSectorFlag = RSF_SECTORSIZE32K; break;
            default : olErr (EH_Err, STG_E_INVALIDPARAMETER);
        }
    }
    else if (ulSectorSize != 0 && ulSectorSize != 512)
             olErr (EH_Err, STG_E_INVALIDPARAMETER);

#if WIN32 != 200
    //
    // When we create over NFF files, delete them first.
    // except when we want to preserve encryption information
    //
    if( (STGM_CREATE & grfMode) && !(FILE_ATTRIBUTE_ENCRYPTED & grfAttrs))
    {
        if( SUCCEEDED( IsNffAppropriate( pwcsName ) ) )
        {
            if(FALSE == DeleteFileW( pwcsName ) )
            {
                DWORD dwErr = GetLastError();
                if( dwErr != ERROR_FILE_NOT_FOUND &&
                    dwErr != ERROR_PATH_NOT_FOUND )
                {
                    olErr( EH_Err, Win32ErrorToScode( dwErr ) );
                }
            }
        }
    }
#endif // _CHICAGO_

    DfInitSharedMemBase();
#ifdef COORD
    olChk(sc = DfFromName(pwcsName, df,
                          RSF_CREATE |
                          ((grfMode & STGM_CREATE) ? RSF_TRUNCATE : 0) |
                          ((grfMode & STGM_CONVERT) ? RSF_CONVERT : 0) |
                          ((grfMode & STGM_DELETEONRELEASE) ?
                           RSF_DELETEONRELEASE : 0) |
                          (dwSectorFlag) |
                          ((grfAttrs & FILE_FLAG_NO_BUFFERING) ?
                            RSF_NO_BUFFERING : 0) |
                          ((grfAttrs & FILE_ATTRIBUTE_ENCRYPTED) ?
                            RSF_ENCRYPTED : 0),
                          NULL, pTransaction, &pdfExp, NULL, NULL));
#else
    olChk(sc = DfFromName(pwcsName, df,
                          RSF_CREATE |
                          ((grfMode & STGM_CREATE) ? RSF_TRUNCATE : 0) |
                          ((grfMode & STGM_CONVERT) ? RSF_CONVERT : 0) |
                          ((grfMode & STGM_DELETEONRELEASE) ?
                           RSF_DELETEONRELEASE : 0) |
                          (dwSectorFlag) |
                          ((grfAttrs & FILE_FLAG_NO_BUFFERING) ?
                            RSF_NO_BUFFERING : 0) |
                          ((grfAttrs & FILE_ATTRIBUTE_ENCRYPTED) ?
                            RSF_ENCRYPTED : 0),
                          NULL, &pdfExp, NULL, NULL));
#endif //COORD

    TRANSFER_INTERFACE(pdfExp, IStorage, ppstgOpen);

EH_Err:
    olDebugOut((DEB_TRACE, "Out StgCreateDocfile => %p, ret == %lx\n",
         *ppstgOpen, sc));
    olLog(("--------::Out StgCreateDocFile().  *ppstgOpen == %p, ret == %lx\n",
           *ppstgOpen, sc));

    OLETRACEOUT(( API_StgCreateDocfile, _OLERETURN(sc)));

EH_BadPtr:
    FreeLogFile();
    return _OLERETURN(sc);
}

//+--------------------------------------------------------------
//
//  Function:   StgCreateDocfile, public
//
//  Synopsis:   Creates a root Docfile on a file
//
//  Arguments:  [pwcsName] - Filename
//              [grfMode] - Permissions
//              [reserved] - security attributes
//              [ppstgOpen] - Docfile return
//
//  Returns:    Appropriate status code
//
//  Modifies:   [ppstgOpen]
//
//  History:    14-Jan-92       DrewB   Created
//
//---------------------------------------------------------------

STDAPI StgCreateDocfile(WCHAR const *pwcsName,
                        DWORD grfMode,
                        LPSTGSECURITY reserved,
                        IStorage **ppstgOpen)
{
    return DfCreateDocfile(pwcsName, NULL, grfMode, reserved, 0, 0, ppstgOpen);
}

//+--------------------------------------------------------------
//
//  Function:   StgCreateDocfileOnILockBytes, public
//
//  Synopsis:   Creates a root Docfile on an lstream
//
//  Arguments:  [plkbyt] - LStream
//              [grfMode] - Permissions
//              [reserved] - Unused
//              [ppstgOpen] - Docfile return
//
//  Returns:    Appropriate status code
//
//  Modifies:   [ppstgOpen]
//
//  History:    14-Jan-92       DrewB   Created
//
//---------------------------------------------------------------


STDAPI StgCreateDocfileOnILockBytes(ILockBytes *plkbyt,
                                    DWORD grfMode,
                                    DWORD reserved,
                                    IStorage **ppstgOpen)
{
    IMalloc *pMalloc;
    CPerContext *ppc;
    SafeCExposedDocFile pdfExp;
    SCODE sc;
    DFLAGS df;
#ifdef MULTIHEAP
    CPerContext pcSharedMemory (NULL);
#endif

    OLETRACEIN((API_StgCreateDocfileOnILockBytes,
                PARAMFMT("plkbyt= %p, grfMode= %x, reserved= %ud, ppstgOpen= %p"),
                plkbyt, grfMode, reserved, ppstgOpen));

    olLog(("--------::In  StgCreateDocFileOnILockBytes(%p, %lX, %lu, %p)\n",
           plkbyt, grfMode, reserved, ppstgOpen));
    olDebugOut((DEB_TRACE, "In  StgCreateDocfileOnILockBytes("
                "%p, %lX, %lu, %p)\n",
                plkbyt, grfMode, reserved, ppstgOpen));

    olChk(ValidatePtrBuffer(ppstgOpen));
    *ppstgOpen = NULL;
    olChk(ValidateInterface(plkbyt, IID_ILockBytes));

    if (reserved != 0)
        olErr(EH_Err, STG_E_INVALIDPARAMETER);
    if ((grfMode & (STGM_CREATE | STGM_CONVERT)) == 0)
        olErr(EH_Err, STG_E_FILEALREADYEXISTS);
    olChk(VerifyPerms(grfMode, TRUE));
    if (grfMode & STGM_DELETEONRELEASE)
        olErr(EH_Err, STG_E_INVALIDFUNCTION);
    df = ModeToDFlags(grfMode);
    if ((grfMode & (STGM_TRANSACTED | STGM_CONVERT)) ==
        (STGM_TRANSACTED | STGM_CONVERT))
        df |= DF_INDEPENDENT;

    DfInitSharedMemBase();
    olHChk(DfCreateSharedAllocator(&pMalloc, TRUE));
#ifdef MULTIHEAP
    // Because a custom ILockbytes can call back into storage code,
    // possibly using another shared heap, we need a temporary
    // owner until the real CPerContext is allocated
    // new stack frame for CSafeMultiHeap constructor/destructor
    {
        pcSharedMemory.GetThreadAllocatorState();
        CSafeMultiHeap smh(&pcSharedMemory);
#endif

    //Create the per context
    olMem(ppc = new (pMalloc) CPerContext(pMalloc));
    olChkTo(EH_ppc, ppc->InitNewContext());

#ifdef COORD
    sc = DfFromLB(ppc, plkbyt, df,
                  RSF_CREATE |
                  ((grfMode & STGM_CREATE) ? RSF_TRUNCATE : 0) |
                  ((grfMode & STGM_CONVERT) ? RSF_CONVERT : 0),
                  NULL, NULL, &pdfExp, NULL);
#else
    sc = DfFromLB(ppc, plkbyt, df,
                  RSF_CREATE |
                  ((grfMode & STGM_CREATE) ? RSF_TRUNCATE : 0) |
                  ((grfMode & STGM_CONVERT) ? RSF_CONVERT : 0),
                  NULL, &pdfExp, NULL);
#endif //COORD

    pMalloc->Release();

    //Either DfFromLB has AddRef'ed the per context or it has failed.
    //Either way we want to release our reference here.
    ppc->Release();

    olChkTo(EH_Truncate, sc);

    TRANSFER_INTERFACE(pdfExp, IStorage, ppstgOpen);

    //  Success;  since we hold on to the ILockBytes interface,
    //  we must take a reference to it.
    plkbyt->AddRef();

    olDebugOut((DEB_TRACE, "Out StgCreateDocfileOnILockBytes => %p\n",
                *ppstgOpen));
#ifdef MULTIHEAP
    }
#endif
 EH_Err:
    OLETRACEOUT((API_StgCreateDocfileOnILockBytes, ResultFromScode(sc)));

    olLog(("--------::Out StgCreateDocFileOnILockBytes().  "
           "*ppstgOpen == %p, ret == %lx\n", *ppstgOpen, sc));
    FreeLogFile();
    return ResultFromScode(sc);

 EH_ppc:
    delete ppc;
    goto EH_Err;

 EH_Truncate:
    if ((grfMode & STGM_CREATE) && (grfMode & STGM_TRANSACTED) == 0)
    {
        ULARGE_INTEGER ulSize;

        ULISet32(ulSize, 0);
        olHVerSucc(plkbyt->SetSize(ulSize));
    }
    goto EH_Err;
}

//+--------------------------------------------------------------
//
//  Function:   DfOpenDocfile, public
//
//  Synopsis:   Instantiates a root Docfile from a file,
//              converting if necessary
//
//  Arguments:  [pwcsName] - Name
//              [pstgPriority] - Priority mode reopen IStorage
//              [grfMode] - Permissions
//              [snbExclude] - Exclusions for priority reopen
//              [reserved] - security attributes
//              [grfAttrs] - Win32 CreateFile attributes
//              [ppstgOpen] - Docfile return
//
//  Returns:    Appropriate status code
//
//  Modifies:   [ppstgOpen]
//
//  History:    14-Jan-92       DrewB   Created
//
//---------------------------------------------------------------

STDAPI DfOpenDocfile(OLECHAR const *pwcsName,
#ifdef COORD
                     ITransaction *pTransaction,
#else
                     void *pTransaction,
#endif
                     IStorage *pstgPriority,
                     DWORD grfMode,
                     SNB snbExclude,
                     LPSTGSECURITY reserved,
                     ULONG *pulSectorSize,
                     DWORD grfAttrs,
                     IStorage **ppstgOpen)
{
    SafeCExposedDocFile pdfExp;
    SCODE sc;
    WCHAR awcName[_MAX_PATH];
    CLSID cid;

    OLETRACEIN((API_StgOpenStorage,
         PARAMFMT("pstgPriority= %p, grfMode= %x, snbExclude= %p, reserved= %p, ppStgOpen= %p"),
         pstgPriority, grfMode,snbExclude, reserved, ppstgOpen));

    olLog(("--------::In  StgOpenStorage(%ws, %p, %lX, %p, %lu, %p)\n",
           pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstgOpen));
    olDebugOut((DEB_TRACE, "In  StgOpenStorage("
                "%ws, %p, %lX, %p, %lu, %p)\n", pwcsName, pstgPriority,
                grfMode, snbExclude, reserved, ppstgOpen));

    olAssert(sizeof(LPSTGSECURITY) == sizeof(DWORD));

    olChk(ValidatePtrBuffer(ppstgOpen));
    *ppstgOpen = NULL;
    if (pstgPriority == NULL)
    {
        olChk(ValidateNameW(pwcsName, _MAX_PATH));
        lstrcpyW(awcName, pwcsName);
    }
    if (pstgPriority)
    {
        STATSTG stat;

        olChk(ValidateInterface(pstgPriority, IID_IStorage));
        olHChk(pstgPriority->Stat(&stat, 0));
        if (lstrlenW (stat.pwcsName) > _MAX_PATH)
            olErr (EH_Err, STG_E_INVALIDNAME);
        lstrcpyW(awcName, stat.pwcsName);
        TaskMemFree(stat.pwcsName);
    }
#if WIN32 != 200
    if (grfMode & STGM_SIMPLE)
    {
        sc = DfOpenSimpDocfile(pwcsName, grfMode, 0, ppstgOpen);
        goto EH_Err;
    }
#endif
    olChk(VerifyPerms(grfMode, TRUE));
    if (grfMode & (STGM_CREATE | STGM_CONVERT))
        olErr(EH_Err, STG_E_INVALIDFLAG);
    if (snbExclude)
    {
        if ((grfMode & STGM_RDWR) != STGM_READWRITE)
            olErr(EH_Err, STG_E_ACCESSDENIED);
        olChk(ValidateSNB(snbExclude));
    }
    if (reserved != 0)
        olErr(EH_Err, STG_E_INVALIDPARAMETER);
    if (grfMode & STGM_DELETEONRELEASE)
        olErr(EH_Err, STG_E_INVALIDFUNCTION);

    //Otherwise, try it as a docfile
    if (pstgPriority)
        olChk(pstgPriority->Release());

    DfInitSharedMemBase();
#ifdef COORD
    olChk(DfFromName(awcName, ModeToDFlags(grfMode), RSF_OPEN |
                     ((grfMode & STGM_DELETEONRELEASE) ?
                      RSF_DELETEONRELEASE : 0) |
                     ((grfAttrs & FILE_FLAG_NO_BUFFERING) ?
                      RSF_NO_BUFFERING : 0),
                     snbExclude, pTransaction, &pdfExp, pulSectorSize, &cid));
#else
    olChk(DfFromName(awcName, ModeToDFlags(grfMode), RSF_OPEN |
                     ((grfMode & STGM_DELETEONRELEASE) ?
                      RSF_DELETEONRELEASE : 0) |
                     ((grfAttrs & FILE_FLAG_NO_BUFFERING) ?
                      RSF_NO_BUFFERING : 0),
                     snbExclude, &pdfExp, pulSectorSize, &cid));
#endif //COORD

    TRANSFER_INTERFACE(pdfExp, IStorage, ppstgOpen);

    olDebugOut((DEB_TRACE, "Out StgOpenStorage => %p\n", *ppstgOpen));
EH_Err:
    olLog(("--------::Out StgOpenStorage().  *ppstgOpen == %p, ret == %lx\n",
           *ppstgOpen, sc));
    FreeLogFile();
    OLETRACEOUT((API_StgOpenStorage, sc));

    return sc;
}

//+--------------------------------------------------------------
//
//  Function:   StgOpenStorageOnILockBytes, public
//
//  Synopsis:   Instantiates a root Docfile from an LStream,
//              converting if necessary
//
//  Arguments:  [plkbyt] - Source LStream
//              [pstgPriority] - For priority reopens
//              [grfMode] - Permissions
//              [snbExclude] - For priority reopens
//              [reserved]
//              [ppstgOpen] - Docfile return
//
//  Returns:    Appropriate status code
//
//  Modifies:   [ppstgOpen]
//
//  History:    14-Jan-92       DrewB   Created
//
//---------------------------------------------------------------

STDAPI StgOpenStorageOnILockBytes(ILockBytes *plkbyt,
                                  IStorage *pstgPriority,
                                  DWORD grfMode,
                                  SNB snbExclude,
                                  DWORD reserved,
                                  IStorage **ppstgOpen)
{
    IMalloc *pMalloc;
    CPerContext *ppc;
    SCODE sc;
    SafeCExposedDocFile pdfExp;
#ifdef MULTIHEAP
    CPerContext pcSharedMemory(NULL);
#endif
    CLSID cid;

    OLETRACEIN((API_StgOpenStorageOnILockBytes,
         PARAMFMT("pstgPriority= %p, grfMode= %x, snbExclude= %p, reserved= %ud, ppstgOpen= %p"),
         pstgPriority, grfMode, snbExclude, reserved, ppstgOpen));

    olLog(("--------::In  StgOpenStorageOnILockBytes("
           "%p, %p, %lX, %p, %lu, %p)\n",
           plkbyt, pstgPriority, grfMode, snbExclude, reserved, ppstgOpen));
    olDebugOut((DEB_TRACE, "In  StgOpenStorageOnILockBytes("
                "%p, %p, %lX, %p, %lu, %p)\n", plkbyt, pstgPriority,
                grfMode, snbExclude, reserved, ppstgOpen));

    olChk(ValidatePtrBuffer(ppstgOpen));
    *ppstgOpen = NULL;
    olChk(ValidateInterface(plkbyt, IID_ILockBytes));
    if (pstgPriority)
        olChk(ValidateInterface(pstgPriority, IID_IStorage));
    olChk(VerifyPerms(grfMode, TRUE));
    if (grfMode & (STGM_CREATE | STGM_CONVERT))
        olErr(EH_Err, STG_E_INVALIDFLAG);
    if (grfMode & STGM_DELETEONRELEASE)
        olErr(EH_Err, STG_E_INVALIDFUNCTION);
    if (snbExclude)
    {
        if ((grfMode & STGM_RDWR) != STGM_READWRITE)
            olErr(EH_Err, STG_E_ACCESSDENIED);
        olChk(ValidateSNB(snbExclude));
    }
    if (reserved != 0)
        olErr(EH_Err, STG_E_INVALIDPARAMETER);
    if (pstgPriority)
        olChk(pstgPriority->Release());

    IFileLockBytes *pfl;
    if (SUCCEEDED(plkbyt->QueryInterface(IID_IFileLockBytes,
                                         (void **)&pfl)) &&
        ((CFileStream *)plkbyt)->GetContextPointer() != NULL)
    {
        //Someone passed us the ILockBytes we gave them from
        //StgGetIFillLockBytesOnFile.  It already contains a
        //context pointer, so reuse that rather than creating
        //a whole new shared heap.
        pfl->Release();
        CFileStream *pfst = (CFileStream *)plkbyt;
        CPerContext *ppc = pfst->GetContextPointer();
#ifdef MULTIHEAP
        CSafeMultiHeap smh(ppc);
#endif
#ifdef COORD
        olChk(DfFromLB(ppc,
                         pfst,
                         ModeToDFlags(grfMode),
                         pfst->GetStartFlags(),
                         NULL,
                         NULL,
                         &pdfExp,
                         NULL));
#else
        olChk(DfFromLB(ppc,
                         pfst,
                         ModeToDFlags(grfMode),
                         pfst->GetStartFlags(),
                         NULL,
                         &pdfExp,
                         NULL));
#endif
    }
    else
    {
        DfInitSharedMemBase();
        olHChk(DfCreateSharedAllocator(&pMalloc, TRUE));
#ifdef MULTIHEAP
    // Because a custom ILockbytes can call back into storage code,
    // possibly using another shared heap, we need a temporary
    // owner until the real CPerContext is allocated
    // new stack frame for CSafeMultiHeap constructor/destructor
        {
            pcSharedMemory.GetThreadAllocatorState();
            CSafeMultiHeap smh(&pcSharedMemory);
#endif

            //Create the per context
            olMem(ppc = new (pMalloc) CPerContext(pMalloc));
            sc = ppc->InitNewContext();
            if (FAILED(sc))
            {
                delete ppc;
                olErr(EH_Err, sc);
            }

#ifdef COORD
            sc = DfFromLB(ppc,
                          plkbyt, ModeToDFlags(grfMode), RSF_OPEN, snbExclude,
                          NULL, &pdfExp, &cid);
#else
            sc = DfFromLB(ppc,
                          plkbyt, ModeToDFlags(grfMode), RSF_OPEN, snbExclude,
                          &pdfExp, &cid);
#endif //COORD

            pMalloc->Release();

            //Either DfFromLB has AddRef'ed the per context or it has failed.
            //Either way we want to release our reference here.
            ppc->Release();
            olChk(sc);
#ifdef MULTIHEAP
        }
#endif
    }

    TRANSFER_INTERFACE(pdfExp, IStorage, ppstgOpen);

    //  Success;  since we hold on to the ILockBytes interface,
    //  we must take a reference to it.
    plkbyt->AddRef();

    olDebugOut((DEB_TRACE, "Out StgOpenStorageOnILockBytes => %p\n",
                *ppstgOpen));

EH_Err:
    olLog(("--------::Out StgOpenStorageOnILockBytes().  "
           "*ppstgOpen == %p, ret == %lx\n", *ppstgOpen, sc));
    FreeLogFile();
    OLETRACEOUT((API_StgOpenStorageOnILockBytes, sc));

    return sc;
}

//+---------------------------------------------------------------------------
//
//  Function:   DfGetClass, public
//
//  Synopsis:   Retrieves the class ID of the root entry of a docfile
//
//  Arguments:  [hFile] - Docfile file handle
//              [pclsid] - Class ID return
//
//  Returns:    Appropriate status code
//
//  Modifies:   [pclsid]
//
//  History:    09-Feb-94       DrewB   Created
//
//----------------------------------------------------------------------------

STDAPI DfGetClass(HANDLE hFile,
                  CLSID *pclsid)
{
    SCODE sc;
    DWORD dwCb;
    IMalloc *pMalloc;
    CFileStream *pfst;
    ULARGE_INTEGER uliOffset;
    ULONG ulOpenLock, ulAccessLock;
    BYTE bBuffer[sizeof(CMSFHeader)];
    CMSFHeader *pmsh;
    CDirEntry *pde;

    olDebugOut((DEB_ITRACE, "In  DfGetClass(%p, %p)\n", hFile, pclsid));

    olAssert(sizeof(bBuffer) >= sizeof(CMSFHeader));
    pmsh = (CMSFHeader *)bBuffer;

    olAssert(sizeof(bBuffer) >= sizeof(CDirEntry));
    pde = (CDirEntry *)bBuffer;

    if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) != 0)
    {
        olErr(EH_Err, LAST_STG_SCODE);
    }
    if (!ReadFile(hFile, pmsh->GetData(), sizeof(CMSFHeaderData), &dwCb, NULL))
    {
        olErr(EH_Err, LAST_STG_SCODE);
    }
    if (dwCb != sizeof(CMSFHeaderData))
    {
        olErr(EH_Err, STG_E_INVALIDHEADER);
    }
    sc = pmsh->Validate();
    olChk(sc);

    // Now we know it's a docfile

    DfInitSharedMemBase();
    olHChk(DfCreateSharedAllocator(&pMalloc, FALSE));
    olMemTo(EH_pMalloc, pfst = new (pMalloc) CFileStream(pMalloc));
    olChkTo(EH_pfst, pfst->InitGlobal(0, 0));
    olChkTo(EH_pfst, pfst->InitFromHandle(hFile));

    // Take open and access locks to ensure that we're cooperating
    // with real opens

    olChkTo(EH_pfst, GetOpen(pfst, DF_READ, TRUE, &ulOpenLock));
    olChkTo(EH_open, GetAccess(pfst, DF_READ, &ulAccessLock));

    uliOffset.HighPart = 0;
    uliOffset.LowPart = (pmsh->GetDirStart() << pmsh->GetSectorShift())+
        HEADERSIZE;

    // The root directory entry is always the first directory entry
    // in the first directory sector

    // Ideally, we could read just the class ID directly into
    // pclsid.  In practice, all the important things are declared
    // private or protected so it's easier to read the whole entry

    olChkTo(EH_access, GetScode(pfst->ReadAt(uliOffset, pde,
                                             sizeof(CDirEntry), &dwCb)));
    if (dwCb != sizeof(CDirEntry))
    {
        sc = STG_E_READFAULT;
    }
    else
    {
        sc = S_OK;
    }

    *pclsid = pde->GetClassId();

    olDebugOut((DEB_ITRACE, "Out DfGetClass\n"));
 EH_access:
    ReleaseAccess(pfst, DF_READ, ulAccessLock);
 EH_open:
    ReleaseOpen(pfst, DF_READ, ulOpenLock);
 EH_pfst:
    pfst->Release();
 EH_pMalloc:
    pMalloc->Release();
 EH_Err:
    return ResultFromScode(sc);
}