windows-server-2003/inetcore/urlmon/trans/transdat.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1995.
//
//  File:       transdata.cxx
//
//  Contents:   Contains the module which provide data passed on in OnDataAvailable
//
//  Classes:
//
//  Functions:
//
//  History:    12-07-95   JohannP (Johann Posch)   Created
//
//----------------------------------------------------------------------------
#include <trans.h>
#ifndef unix
#include "..\stg\rostmdir.hxx"
#include "..\stg\rostmfil.hxx"
#else
#include "../stg/rostmdir.hxx"
#include "../stg/rostmfil.hxx"
#endif /* unix */

PerfDbgTag(tagCTransData,    "Urlmon", "Log CTransData",        DEB_DATA);
    DbgTag(tagCTransDataErr, "Urlmon", "Log CTransData Errors", DEB_DATA|DEB_ERROR);

HRESULT FindMediaType(LPCSTR pszType, CLIPFORMAT *cfType);
HRESULT FindMediaTypeW(LPCWSTR pwzType, CLIPFORMAT *cfType);

static LPSTR g_szCF_NULL = "*/*";

char  szContent[]           = "Content Type";
char  szClassID[]           = "CLSID";
char  szFlags[]             = "Flags";
char  szExtension[]         = "Extension";
char  szMimeKey[]           = "MIME\\Database\\Content Type\\";
const ULONG ulMimeKeyLen    = ((sizeof(szMimeKey)/sizeof(char))-1);

// The byte combination that identifies that a file is a storage of
// some kind
const BYTE SIGSTG[] = {0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1};
const BYTE CBSIGSTG = sizeof(SIGSTG);


#define CBSNIFFDATA_MAX 256

#ifdef DBG
char *szDataSinkName[] =
{
     "Unknown"
    ,"StreamNoCopyData"
    ,"File"
    ,"Storage"
    ,"StreamOnFile"
    ,"StreamBindToObject"
    ,"GenericStream"
};

#define GetDataSinkName(ds) szDataSinkName[ds]

#else

#define GetDataSinkName(ds) ""

#endif


//+---------------------------------------------------------------------------
//
//  Method:     CTransData::CTransData
//
//  Synopsis:
//
//  Arguments:  [pTrans] --
//              [DWORD] --
//              [dwSizeBuffer] --
//              [fBindToObject] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
CTransData::CTransData(CTransaction *pTrans, LPBYTE pByte,DWORD dwSizeBuffer, BOOL fBindToObject) : _CRefs()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                None,
                "CTransData::CTransData",
                "this=%#x, %#x, %#x, %#x, %B",
                this, pTrans, pByte, dwSizeBuffer, fBindToObject
                ));
                
    _TransDataState = TransData_Initialized;
    _wzMime[0] = '\0';
    _wzFileName[0]= 0;
    _pwzUrl = 0;
    _pwzRedirectUrl = 0;
    _pStgMed = 0;
    _lpBuffer = pByte;
    _cbBufferSize = dwSizeBuffer;
    _cbDataSize = 0;
    _cbTotalBytesRead = 0;
    _cbReadReturn = 0;
    _cbBufferFilled = 0;
    _cbDataSniffMin = DATASNIFSIZE_MIN;
    _pEnumFE = 0;
    _pStgMed = NULL;
    _pProt = NULL;

    _fBindToObject = fBindToObject; //Flag changes on attachment.. Use sparingly.
    _fMimeTypeVerified = TRUE;
    _fDocFile = FALSE;
    _fInitialized = FALSE;
    _fRemoteReady = FALSE;
    _fCache = FALSE;
    _fLocked = FALSE;
    _fFileAsStmOnFile = FALSE;
    _fEOFOnSwitchSink = FALSE; 

    _hFile = NULL;
    _cbBytesReported = 0;
    _dwAttached = 0;
    _grfBindF  = 0;
    _grfBSC = 0;

    DEBUG_LEAVE(0);
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::~CTransData
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
CTransData::~CTransData()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                None,
                "CTransData::~CTransData",
                "this=%#x",
                this
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::~CTransData");

    if (_pwzUrl)
    {
        delete [] _pwzUrl;
    }

    if (_pwzRedirectUrl)
    {
        delete [] _pwzRedirectUrl;
    }
    
    if (_pProt)
    {
        if (_fLocked)
        {
            _pProt->UnlockRequest();
        }
        _pProt->Release();
        _pProt = NULL;
    }

    if (_pBndCtx)
    {
        _pBndCtx->Release();
    }

    if (_pStgMed)
    {
        TransAssert((   (_pStgMed->pUnkForRelease == NULL)
                     || (_pStgMed->pUnkForRelease == this)));

        if (_pStgMed->tymed == TYMED_ISTREAM)
        {
            _pStgMed->pstm->Release();
        }
        else if (_pStgMed->tymed == TYMED_FILE)
        {
            if (_pStgMed->lpszFileName)
            {
                delete _pStgMed->lpszFileName;
            }
        }
        else if (_pStgMed->tymed == TYMED_ISTORAGE)
        {
            _pStgMed->pstg->Release();
        }

        DbgLog1(tagCTransData, this, "=== CTransData::~CTransData: (pStgMed:%lx)", _pStgMed);
        delete _pStgMed;
        _pStgMed = NULL;
    }

    if (_hFile)
    {
        DbgLog1(tagCTransData, this, "=== CTransData::~CTransData (CloseHandle(%lx)", _hFile);
        CloseHandle(_hFile);
        _hFile = NULL;
    }

    if (_lpBuffer)
    {
        delete _lpBuffer;
    }

    PerfDbgLog(tagCTransData, this, "-CTransData::~CTransData");
    
    DEBUG_LEAVE(0);
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::QueryInterface
//
//  Synopsis:
//
//  Arguments:  [riid] --
//              [ppvObj] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::QueryInterface(REFIID riid, void **ppvObj)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::IUnknown::QueryInterface",
                "this=%#x, %#x, %#x",
                this, &riid, ppvObj
                ));
                
    VDATEPTROUT(ppvObj, void *);
    VDATETHIS(this);
    HRESULT hr = NOERROR;

    PerfDbgLog(tagCTransData, this, "+CTransData::QueryInterface");

    *ppvObj = NULL;
    if ((riid == IID_IUnknown) || (riid == IID_ITransactionData))
    {
        *ppvObj = this;
        AddRef();
    }
    else
    {
        hr = E_NOINTERFACE;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::QueryInterface (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Function:   CTransData::AddRef
//
//  Synopsis:
//
//  Arguments:  [ULONG] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CTransData::AddRef(void)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Dword,
                "CTransData::IUnknown::AddRef",
                "this=%#x",
                this
                ));
                
    LONG lRet = ++_CRefs;
    PerfDbgLog1(tagCTransData, this, "CTransData::AddRef (cRefs:%ld)", lRet);

    DEBUG_LEAVE(lRet);
    return lRet;
}

//+---------------------------------------------------------------------------
//
//  Function:   CTransData::Release
//
//  Synopsis:
//
//  Arguments:  [ULONG] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CTransData::Release(void)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Dword,
                "CTransData::IUnknown::Release",
                "this=%#x",
                this
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::Release");

    LONG lRet = --_CRefs;

    if (_CRefs == 0)
    {
        delete this;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::Release (cRefs:%ld)", lRet);

    DEBUG_LEAVE(lRet);
    return lRet;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::GetTransactionData
//
//  Synopsis:
//
//  Arguments:  [pwzUrl] --
//              [ppwzFilename] --
//              [ppwzMime] --
//              [pdwSizeTotal] --
//              [pdwSizeAvailable] --
//              [dwReserved] --
//
//  Returns:
//
//  History:    9-09-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::GetTransactionData(LPCWSTR pwzUrl, LPOLESTR *ppwzFilename, LPOLESTR *ppwzMime,
                                            DWORD *pdwSizeTotal, DWORD *pdwSizeAvailable, DWORD  dwReserved)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::GetTransactionData",
                "this=%#x, %.80wq, %#x, %#x, %#x, %#x, %#x",
                this, pwzUrl, ppwzFilename, ppwzMime, pdwSizeTotal, pdwSizeAvailable, dwReserved
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::GetTransactionData");
    HRESULT hr = NOERROR;
    TransAssert((pwzUrl && ppwzFilename && ppwzMime && pdwSizeTotal && pdwSizeAvailable ));
    TransAssert((_wzFileName[0] != 0));


    if  (ppwzFilename && ppwzMime && pdwSizeTotal && pdwSizeAvailable)
    {
        LPWSTR pwzUrlLocal = GetUrl();
        TransAssert((pwzUrlLocal));

        DbgLog2(tagCTransData, this, "=== CTransData::GetTransactionData (pwzUrlLocal:%ws, pwzUrl:%ws)", pwzUrlLocal, pwzUrl);

        if (!wcscmp(pwzUrl, _pwzUrl) || (_pwzRedirectUrl && !wcscmp(pwzUrl, _pwzRedirectUrl)))
        {
            *ppwzFilename = OLESTRDuplicate(_wzFileName);

            *ppwzMime = OLESTRDuplicate(_wzMime);

            if (_cbDataSize)
            {
                *pdwSizeTotal  = _cbDataSize;
            }
            else
            {
                *pdwSizeTotal  = _cbTotalBytesRead;
            }
            *pdwSizeAvailable = _cbTotalBytesRead;

        }
        else
        {
            *ppwzFilename = 0;
            *ppwzMime = NULL;
            *pdwSizeTotal = 0;
            *pdwSizeAvailable = 0;
            hr = E_INVALIDARG;
        }
    }
    else
    {
        hr = E_INVALIDARG;
    }

    PerfDbgLog5(tagCTransData, this, "-CTransData::GetTransactionData (hr:%lx, Filename:%ws, Mime:%ws, _cbDataSize:%ld, _cbTotalBytesRead:%ld)",
        hr, XDBG(*ppwzFilename,L""), XDBG(*ppwzMime,L""), _cbDataSize, _cbTotalBytesRead);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::Create
//
//  Synopsis:   Set up the transaction data object.
//
//  Arguments:  [pTrans] -- pointer to transaction
//              [riid] --   riid the users passed in
//              [ppCTD] --  the transdata object passed back
//
//  Returns:
//
//  History:    1-18-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::Create(LPCWSTR pwUrl, DWORD grfBindF, REFIID riid, IBindCtx *pBndCtx,
                                BOOL fBindToObject, CTransData **ppCTD)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::Create",
                "%.80wq, %#x, %#x, %#x, %B, %#x",
                pwUrl, grfBindF, &riid, pBndCtx, fBindToObject, ppCTD
                ));
                
    HRESULT hr = NOERROR;
    PerfDbgLog1(tagCTransData, NULL, "+CTransData::Create(fBindToObject:%d)", fBindToObject);
    CTransData *pCTData;

    LPBYTE   lpBuffer;
    ULONG    cbBufferSize;
    cbBufferSize = DNLD_BUFFER_SIZE;

    TransAssert((DATASNIFSIZEDOCFILE_MIN <= cbBufferSize));
    lpBuffer = (LPBYTE) new BYTE[cbBufferSize];
    pCTData = new CTransData(NULL,lpBuffer,cbBufferSize, fBindToObject);

    if (lpBuffer && pCTData)
    {
        *ppCTD = pCTData;
        pCTData->Initialize(pwUrl, grfBindF, riid, pBndCtx);

        // Try to get an IEnumFORMATETC pointer from the bind context
        //hr = GetObjectParam(pbc, REG_ENUMFORMATETC, IID_IEnumFORMATETC, (IUnknown**)&_pEnumFE);
    }
    else
    {
        if (pCTData)
        {
            delete pCTData;
        }
        else if (lpBuffer)
        {
            delete lpBuffer;
        }

        hr = E_OUTOFMEMORY;
        *ppCTD = 0;
    }

    PerfDbgLog2(tagCTransData, NULL, "-CTransData::Create (out:%lx,hr:%lx)", *ppCTD, hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::Initialize
//
//  Synopsis:
//
//  Arguments:  [riid] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::Initialize(LPCWSTR pwzUrl, DWORD grfBindF, REFIID riid, IBindCtx *pBndCtx, BOOL fBindToObject)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::Initialize",
                "this=%#x, %.80wq, %#x, %#x, %#x, %B",
                this, pwzUrl, grfBindF, &riid, pBndCtx, fBindToObject
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::Initialize");
    HRESULT hr = NOERROR;

    if (_fInitialized == FALSE)
    {
        _ds = DataSink_Unknown;
        _formatetc.tymed = TYMED_NULL;
        _grfBindF = grfBindF;
        _pBndCtx = pBndCtx;
        _pBndCtx->AddRef();
        
        _pwzUrl = OLESTRDuplicate((LPWSTR)pwzUrl);
        if (!_pwzUrl) 
        {
            hr = E_OUTOFMEMORY;
        }

        if (SUCCEEDED(hr))
        {
            if (_fBindToObject)
            {
                _formatetc.tymed = TYMED_ISTREAM;
                _ds = DataSink_Unknown;
            }
            else if (riid == IID_IUnknown)
            {
                // this is the BindToStorage
                _formatetc.tymed = TYMED_FILE;
                _ds = DataSink_File;
            }
            else if (riid == IID_IStream)
            {
                // We do not know yet which kind of stream
                // SetDataSink will determine this.

                _formatetc.tymed = TYMED_ISTREAM;
                _ds = DataSink_StreamOnFile;
            }
            else if (riid == IID_IStorage)
            {
                BIND_OPTS bindopts;
                bindopts.cbStruct = sizeof(BIND_OPTS);
                hr = pBndCtx->GetBindOptions(&bindopts);
                _grfMode = bindopts.grfMode;

                _formatetc.tymed = TYMED_ISTORAGE;
                _ds = DataSink_Storage;

            }
            else
            {
                // this call should fail
                hr = E_INVALIDARG;
                TransAssert((FALSE && "Unknown data sink for this request!"));
            }
        }
        
        if (SUCCEEDED(hr))
        {
            HRESULT hr1;
            ITransactionData *pCTransData = NULL;
            LPWSTR pwzFilename = NULL;
            LPWSTR pwzMime = NULL;

            hr1 = GetObjectParam(pBndCtx, SZ_TRANSACTIONDATA, IID_ITransactionData, (IUnknown **)&pCTransData);
            DbgLog2(tagCTransData, this, "=== CTransData::Initialize GetObjectParam: pbndctx:%lx, hr:%lx)", pBndCtx, hr1);

            if (SUCCEEDED(hr1))
            {
                TransAssert((pCTransData));
                hr1 = pCTransData->GetTransactionData(_pwzUrl,&pwzFilename, &pwzMime, &_cbDataSize, &_cbTotalBytesRead, 0);
                DbgLog5(tagCTransData, this, "=== CTransData::Initialize GetTransactionData (hr:%lx, Filename:%ws, Mime:%ws, _cbDataSize:%ld, _cbTotalBytesRead:%ld)", hr1, pwzFilename, pwzMime, _cbDataSize, _cbTotalBytesRead);
                pCTransData->Release();
            }


            if (SUCCEEDED(hr1) )
            {
                // set the url filename
                SetFileName(pwzFilename);
                if (pwzMime)
                {
                    SetMimeType(pwzMime);
                    _fMimeTypeVerified = TRUE;
                }
                _fRemoteReady = TRUE;

                if (pwzMime)
                {
                    delete pwzMime;
                }
                if (pwzFilename)
                {
                    delete pwzFilename;
                }
            }
        }
        _fInitialized = TRUE;
    }
    else
    {
        _dwAttached++;
        
        if (_pBndCtx)
        {
            _pBndCtx->Release();
        }

        _pBndCtx = pBndCtx;

        if (_pBndCtx)
        {
            _pBndCtx->AddRef();
        }

        // no set up the righte datasink
        if (fBindToObject)
        {
            _fBindToObject = TRUE;
            SwitchDataSink(DataSink_StreamBindToObject);
        }
        else if (riid == IID_IUnknown)
        {
            SwitchDataSink(DataSink_File);
        }
        else if (   (riid == IID_IStream)
                 && (grfBindF & BINDF_NEEDFILE))
        {
            SwitchDataSink(DataSink_StreamOnFile);
        }

    }

    PerfDbgLog3(tagCTransData, this, "-CTransData::Initialize (_formatetc.tymed:%ld, _ds:%lx, hr:%lx)", _formatetc.tymed,_ds, hr);

    DEBUG_LEAVE(hr);
    return hr;
}


//+---------------------------------------------------------------------------
//
//  Method:     CTransData::PrepareThreadTransfer
//
//  Synopsis:
//
//  Arguments:
//
//  Returns:
//
//  History:    10-09-1996   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::PrepareThreadTransfer()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::PrepareThreadTransfer",
                "this=%#x",
                this
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::PrepareThreadTransfer");
    HRESULT hr = NOERROR;

    if (_pBndCtx)
    {
        _pBndCtx->Release();
        _pBndCtx = NULL;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::PrepareThreadTransfer (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}


//+---------------------------------------------------------------------------
//
//  Method:     CTransData::GetDataSink
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    2-22-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DataSink CTransData::GetDataSink()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Pointer,
                "CTransData::GetDataSink",
                "this=%#x",
                this
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::GetDataSink");
    DataSink dsRet = DataSink_Unknown;

    if (_ds == DataSink_Unknown)
    {
        DWORD dwBindF = GetBindFlags();

        if (   (dwBindF & BINDF_ASYNCSTORAGE)
            && (dwBindF & BINDF_PULLDATA)
            && (_formatetc.tymed == TYMED_ISTREAM))
        {
            dsRet = _ds = DataSink_StreamNoCopyData;
        }
    }
    else
    {
        dsRet = _ds;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::GetDataSink (dsRet:%lx)", dsRet);

    DEBUG_LEAVE(dsRet);
    return dsRet;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::SetDataSink
//
//  Synopsis:
//
//  Arguments:  [dwBindF] --
//
//  Returns:
//
//  History:    2-25-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DataSink CTransData::SetDataSink(DWORD dwBindF)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Pointer,
                "CTransData::SetDataSink",
                "this=%#x, %#x",
                this, dwBindF
                ));
                
    PerfDbgLog1(tagCTransData, this, "+CTransData::SetDataSink (_ds:%lx)", _ds);

    TransAssert((_formatetc.tymed != TYMED_NULL));
    _grfBindF = dwBindF;

    switch (_ds)
    {
    case DataSink_Unknown:
    {
        if (_fBindToObject)
        {
            TransAssert((_formatetc.tymed == TYMED_ISTREAM));
            _ds = DataSink_StreamBindToObject;
        }
    }
    break;
    case DataSink_File:
    {
        TransAssert((_formatetc.tymed == TYMED_FILE));

    }
    break;
    case DataSink_StreamOnFile:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
        if ((dwBindF & BINDF_ASYNCSTORAGE) && (dwBindF & BINDF_PULLDATA))  
        {
            _ds = DataSink_StreamNoCopyData;
        }
    }
    break;

    case DataSink_StreamBindToObject:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
        TransAssert((_fBindToObject == TRUE));

        if (IsObjectReady() == NOERROR)
        {
            // 
            // change it to file - stream on file will be opened
            //
            _ds = DataSink_StreamOnFile;
        }
        else if ((dwBindF & BINDF_ASYNCSTORAGE) && (dwBindF & BINDF_PULLDATA))
        {
            _ds = DataSink_StreamNoCopyData;
        }

    }
    break;

    case DataSink_Storage:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTORAGE));
    }
    break;

    case DataSink_GenericStream:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
    }
    break;

    default:
        TransAssert((FALSE && "CTransData::SetDataSink -- Invalid data location"));
    break;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::SetDataSink (_ds:%lx)", _ds);

    DEBUG_LEAVE(_ds);
    return _ds;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::SwitchDataSink
//
//  Synopsis:
//
//  Arguments:  [dwBindF] --
//
//  Returns:
//
//  History:    2-25-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DataSink CTransData::SwitchDataSink(DataSink dsNew)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Pointer,
                "CTransData::SwitchDataSink",
                "this=%#x, %#x",
                this, dsNew
                ));
                
    PerfDbgLog2(tagCTransData, this, "+CTransData::SwitchDataSink (_ds:%lx, dsNew:%lx)", _ds, dsNew);

    TransAssert((_ds != DataSink_Unknown));
    TransAssert((_formatetc.tymed != TYMED_NULL));
    HRESULT hr = NOERROR;

    switch (_ds)
    {
    case DataSink_File:
    {
        TransAssert((_formatetc.tymed == TYMED_FILE));
    }
    break;
    case DataSink_StreamOnFile:
    {
         TransAssert((_wzFileName[0] != 0));
         _formatetc.tymed = TYMED_ISTREAM;
    }
    break;

    case DataSink_GenericStream:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
    }
    break;

    case DataSink_StreamNoCopyData:
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
        if (   dsNew == DataSink_StreamOnFile
            || dsNew == DataSink_GenericStream
            || dsNew == DataSink_StreamBindToObject)
        {
            _ds = dsNew;
            DWORD dwNew = 0;
            hr = OnDataReceived(_grfBSC, 0, 0, &dwNew);
            if( hr == S_FALSE)
            {
                _fEOFOnSwitchSink = TRUE;
            }
        }

    break;

    case DataSink_StreamBindToObject:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
        TransAssert((_fBindToObject == TRUE));
        _ds = dsNew;
        if (_ds == DataSink_File)
        {
            _formatetc.tymed = TYMED_FILE;
            DWORD dwNew = 0;
            hr = OnDataReceived(_grfBSC, 0, 0, &dwNew);
            if( hr == S_FALSE)
            {
                _fEOFOnSwitchSink = TRUE;
            }
        }

    }
    break;

    case DataSink_Storage:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTORAGE));
    }
    break;

    default:
        TransAssert((FALSE && "CTransData::SwitchDataSink -- Invalid data location"));
    break;
    }

    PerfDbgLog2(tagCTransData, this, "-CTransData::SwitchDataSink (_ds:%lx, dsNew:%lx)", _ds, dsNew);

    DEBUG_LEAVE(_ds);
    return _ds;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::IsFileRequired()
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    2-22-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
BOOL CTransData::IsFileRequired()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Bool,
                "CTransData::IsFileRequired",
                "this=%#x",
                this
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::IsFileRequired()");
    BOOL fRet = FALSE;
    TransAssert((_ds != DataSink_Unknown));

    switch (_ds)
    {
    case DataSink_File:
    case DataSink_StreamOnFile:
        fRet = TRUE;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::IsFileRequired() (fRet:%d)", fRet);

    DEBUG_LEAVE(fRet);
    return fRet;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::GetData
//
//  Synopsis:
//
//  Arguments:  [ppformatetc] --
//              [ppStgMed] --
//              [grfBSCF] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::GetData(FORMATETC **ppformatetc, STGMEDIUM **ppStgMed, DWORD grfBSCF)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::GetData",
                "this=%#x, %#x, %#x, %#x",
                this, ppformatetc, ppStgMed, grfBSCF
                ));
                
    PerfDbgLog1(tagCTransData, this, "+CTransData::GetData (_ds:%ld)", _ds);
    HRESULT hr = INET_E_DATA_NOT_AVAILABLE;
    BOOL fNewStgMed = FALSE;
    DataSink ds;

    *ppStgMed = 0;
    *ppformatetc = 0;


    if (_pStgMed == NULL)
    {
        // first find the formatETC based on
        // clipformat and the EnumFormatETC
        FindFormatETC();

        _pStgMed = new STGMEDIUM;
        if (_pStgMed == NULL)
        {
            hr = E_OUTOFMEMORY;
            goto End;
        }

        *ppformatetc = &_formatetc;

        _pStgMed->tymed = TYMED_NULL;
        _pStgMed->hGlobal = NULL;
        _pStgMed->pUnkForRelease = 0;
        _pStgMed->pstm = NULL;
        fNewStgMed = TRUE;

    }

    ds = _ds;
    if( _fFileAsStmOnFile && _ds == DataSink_File )
    {
        ds = DataSink_StreamOnFile;
    } 
    
    switch (ds)
    {
    case DataSink_File:
    {
        //TransAssert((   (grfBSCF & ~BSCF_LASTDATANOTIFICATION)
        //             || ((grfBSCF & BSCF_LASTDATANOTIFICATION) && (_formatetc.tymed == TYMED_FILE)) ));

        if (_wzFileName[0] != 0)
        {
            TransAssert((_wzFileName[0] != 0));
            if (_pStgMed->tymed == TYMED_FILE)
            {
                if (_pStgMed->lpszFileName == NULL)
                {
                    _pStgMed->lpszFileName = (LPWSTR) new WCHAR [wcslen(_wzFileName)+2];
                    if (_pStgMed->lpszFileName)
                    {
                        wcscpy(_pStgMed->lpszFileName, _wzFileName);
                    }
                    else
                    {
                        hr = E_OUTOFMEMORY;
                        goto End;
                    }
                }
            }
            else
            {
                ASSERT(_pStgMed->tymed == TYMED_NULL);
                
                _pStgMed->tymed = TYMED_FILE;
                _pStgMed->lpszFileName = (LPWSTR) new WCHAR [wcslen(_wzFileName)+2];
                if (_pStgMed->lpszFileName)
                {
                    wcscpy(_pStgMed->lpszFileName, _wzFileName);
                }
                else
                {
                    hr = E_OUTOFMEMORY;
                    goto End;
                }
                
            }

            if (_pStgMed->pUnkForRelease == NULL)
            {
                _pStgMed->pUnkForRelease = this;
            }

            hr = NOERROR;
            DbgLog1(tagCTransData, this, "+CTransData::GetData -> TYMED_FILE: %ws", _wzFileName);
        }
        else
        {
            // filename is not available yet
            hr = INET_E_DATA_NOT_AVAILABLE;
        }
    }
    break;

    case DataSink_GenericStream:
    case DataSink_StreamBindToObject:
    case DataSink_StreamNoCopyData:
    {
        DbgLog1(tagCTransData, this, "=== CTransData::GetData (_ds:%lx)", _ds);
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));

        if (_pStgMed->tymed == TYMED_NULL)
        {
            CReadOnlyStreamDirect *pCRoStm = new CReadOnlyStreamDirect( this, _grfBindF);

            if (pCRoStm)
            {
                _pStgMed->tymed = TYMED_ISTREAM;
                _pStgMed->pstm = pCRoStm;
                _pStgMed->pUnkForRelease = this;
                hr = NOERROR;
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }

            DbgLog1(tagCTransData, this, "+CTransData::GetData -> TYMED_ISTREAM: %lx", pCRoStm);
        }
        else
        {
            hr = NOERROR;
        }

        DbgLog2(tagCTransData, this, "=== CTransData::GetData (_ds:%lx,pstm:%lx)", _ds,_pStgMed->pstm);
        DbgLog2(tagCTransData, this, "=== (_cbBufferFilled:%ld, _cbBufferSize:%ld)", _cbBufferFilled,_cbBufferSize);

    }
    break;

    case DataSink_StreamOnFile:
    {
        DbgLog1(tagCTransData, this, "=== CTransData::GetData (_ds:%lx)", _ds);
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));

        if (_wzFileName[0] != 0)
        {
            if (_pStgMed->tymed == TYMED_NULL)
            {
                if( _pStgMed->pstm )
                {
                    //BUG-BUG : relying on undocumented behavior of ReleaseStgMedium..
                    // may or may not zero this out in future.
                    _pStgMed->tymed = TYMED_ISTREAM;
                    _pStgMed->pUnkForRelease = this;

                    // When pStm gets created, the ctor set the ref count
                    // to 1, so no need any additional AddRef.
                    //
                    // Here we are not create a new pStm, we need to do an
                    // AddRef on the pStm because 
                    // CBinding::OnDataNotification (the only caller of this)
                    // will call ReleaseStgMedia() which will call 
                    // _pStgMeg->pstm->Release()

                    _pStgMed->pstm->AddRef();

                    hr = NOERROR;
                }
                else
                {
                    char szTempFile[MAX_PATH];
                    CReadOnlyStreamFile *pCRoStm = NULL;
                    W2A(_wzFileName, szTempFile, MAX_PATH);

                    hr = CReadOnlyStreamFile::Create(szTempFile, &pCRoStm, _pwzUrl);

                    if (pCRoStm)
                    {
                        _pStgMed->tymed = TYMED_ISTREAM;
                        _pStgMed->pstm = pCRoStm;
                        _pStgMed->pUnkForRelease = this;
                        hr = NOERROR;
                    }
                    else
                    {
                        // filename is not available yet
                        hr = INET_E_DATA_NOT_AVAILABLE;
                    }

                    DbgLog2(tagCTransData, this, "+CTransData::GetData -> TYMED_ISTREAM: %lx (hr:%lx)", pCRoStm,hr);
                }

            }
            else
            {
                TransAssert((_pStgMed->tymed == TYMED_ISTREAM));
                hr = NOERROR;
            }
        }
        else
        {
            DbgLog(tagCTransDataErr, this, "+CTransData::GetData ->StreamOnFile: no filename!");

            // filename is not available yet
            hr = INET_E_DATA_NOT_AVAILABLE;
        }

    }
    break;

    case DataSink_Storage:
    {
        DbgLog2(tagCTransData, this, "=== CTransData::GetData (_ds:%lx, _wzFileName:%ws)", _ds, _wzFileName);
        TransAssert((_formatetc.tymed == TYMED_ISTORAGE));

        TransAssert((_wzFileName != NULL));

        if (_wzFileName[0] != 0)
        {
            if (_pStgMed->tymed == TYMED_NULL)
            {
                IStorage *pStg = NULL;

                hr = StgOpenStorage(_wzFileName, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &pStg );
                DbgLog1(tagCTransData, this, "+CTransData::GetData -> TYMED_ISTORAGE: %ws", _wzFileName);

                if (pStg)
                {
                    _pStgMed->tymed = TYMED_ISTORAGE;
                    _pStgMed->pstg = pStg;
                    _pStgMed->pUnkForRelease = this;
                    hr = NOERROR;
                }

                DbgLog2(tagCTransData, this, "+CTransData::GetData -> TYMED_ISTORAGE: %lx (hr:%lx)", pStg,hr);
            }
            else
            {
                TransAssert((_pStgMed->tymed == TYMED_ISTORAGE));
                hr = NOERROR;
            }
        }
        // else return default error
    }
    break;

    default:
        // this needs to be implemented
        TransAssert((FALSE && "CTransData::GetData -- Invalid data location"));
    break;
    }

    if (SUCCEEDED(hr) && _pStgMed)
    {
        // this object was addref on punkforrelease
        *ppStgMed = _pStgMed;
        *ppformatetc = &_formatetc;

        // Use ourselves as the unknown for release, so that the temp file
        // doesn't get removed when ReleaseStgMedium() is called.  We need
        // to AddRef ourselves to balance the Release that will occur.

        if (_pStgMed->pUnkForRelease)
        {
            AddRef();
            if (   _pProt 
                && fNewStgMed
                && SUCCEEDED(_pProt->LockRequest(0)) )
            {
                    _fLocked = TRUE;
            }
        }

        hr = NOERROR;

        TransAssert((_pStgMed->pUnkForRelease != NULL));
    }

End:
    PerfDbgLog1(tagCTransData, this, "-CTransData::GetData (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::ReadHere
//
//  Synopsis:
//
//  Arguments:  [pBuffer] --
//              [cbBuffer] --
//              [pdwRead] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::ReadHere(LPBYTE pBuffer, DWORD cbBuffer, DWORD *pdwRead)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::ReadHere",
                "this=%#x, %#x, %#x, %#x",
                this, pBuffer, cbBuffer, pdwRead
                ));
                
    PerfDbgLog2(tagCTransData, this, "+CTransData::ReadHere (_ds:%lx,cbBuffer:%ld)", _ds,cbBuffer);
    HRESULT hr = NOERROR;

    switch (_ds)
    {
    case DataSink_StreamNoCopyData:
    case DataSink_StreamBindToObject:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
        BOOL fRead = TRUE;
        DWORD dwCopy = 0;
        DWORD dwCopyNew = 0;

        if (_cbBufferFilled)
        {
            fRead = FALSE;

            // copy data form the local buffer to the provide buffer
            if (cbBuffer < _cbBufferFilled)
            {
                dwCopy = cbBuffer;
                memcpy(pBuffer, _lpBuffer, cbBuffer);
                // move the memory to the front
                memcpy(_lpBuffer, _lpBuffer + cbBuffer, _cbBufferFilled - cbBuffer);
                _cbBufferFilled -= cbBuffer;
                hr = S_OK;
            }
            else if (cbBuffer == _cbBufferFilled)
            {
                dwCopy = _cbBufferFilled;
                memcpy(pBuffer, _lpBuffer, _cbBufferFilled);
                _cbBufferFilled = 0;
                hr = S_OK;
            }
            else
            {
                //
                // user buffer is greater than what is available in
                //
                dwCopy = _cbBufferFilled;
                memcpy(pBuffer, _lpBuffer, _cbBufferFilled);
                _cbBufferFilled = 0;
                fRead = TRUE;
                hr = E_PENDING;
            }
        }

        // now read from the wire
        if ((_cbBufferFilled == 0) && (fRead == TRUE))
        {
            // read data from our buffer
            if (_TransDataState == TransData_ProtoTerminated)
            {
                // download completed
                hr = (dwCopy) ? S_OK : S_FALSE;
            }
            else if (pBuffer && cbBuffer)
            {
                hr = _pProt->Read(pBuffer + dwCopy, cbBuffer - dwCopy, &dwCopyNew);
                _cbTotalBytesRead += dwCopyNew;
            }
            else
            {
                hr = E_INVALIDARG;
            }
        }

        if (pdwRead)
        {
            *pdwRead = dwCopy + dwCopyNew;

            if (*pdwRead && (hr != E_PENDING))
            // some data in buffer
            {
                hr = S_OK;
            }
        }
    }
    break;

    case DataSink_StreamOnFile:
    {
        DbgLog(tagCTransData, this, "=== CTransData::ReadHere (_ds:DataSink_StreamNoCopyData)");
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
        TransAssert((pdwRead != NULL));

        // read data from our buffer
        if (_TransDataState == TransData_ProtoTerminated)
        {
            // download completed
            hr = S_FALSE;
        }
        else if (pBuffer && cbBuffer)
        {
            hr = _pProt->Read(pBuffer, cbBuffer, pdwRead);
        }
        else
        {
            hr = E_INVALIDARG;
        }
    }
    break;

    case DataSink_File:
    {
        TransAssert((_formatetc.tymed == TYMED_FILE));

    }
    break;

    default:
        // this needs to be implemented
        hr = E_FAIL;
        TransAssert((FALSE && "CTransData::ReadHere -- Invalid data location"));
    break;
    }

    TransAssert((   (   (hr == S_FALSE && *pdwRead == 0)
                     || (hr == S_OK && *pdwRead != 0)
                     || (hr == E_PENDING)
                     || (hr == E_INVALIDARG)
                     || (hr == INET_E_DATA_NOT_AVAILABLE)
                     || (hr == INET_E_DOWNLOAD_FAILURE)
                    )
                 && "CTransData::ReadHere -- Invalid return code"));


    PerfDbgLog3(tagCTransData, this, "-CTransData::ReadHere (hr:%lx,cbBuffer:%ld,pdwRead:%ld)", hr,cbBuffer,*pdwRead);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::Seek
//
//  Synopsis:
//
//  Arguments:  [DWORD] --
//              [ULARGE_INTEGER] --
//              [plibNewPosition] --
//
//  Returns:
//
//  History:    10-30-1996   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::Seek(LARGE_INTEGER dlibMove,DWORD dwOrigin,ULARGE_INTEGER *plibNewPosition)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::Seek",
                "this=%#x, %#x, %#x, %#x",
                this, dlibMove, dwOrigin, plibNewPosition
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::Seek");
    HRESULT hr;

    hr = _pProt->Seek(dlibMove, dwOrigin,plibNewPosition);

    PerfDbgLog1(tagCTransData, this, "-CTransData::Seek (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::GetReadBuffer
//
//  Synopsis:
//
//  Arguments:  [ppBuffer] --
//              [pcbBytes] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::GetReadBuffer(BYTE **ppBuffer, DWORD *pcbBytes)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::GetReadBuffer",
                "this=%#x, %#x, %#x",
                this, ppBuffer, pcbBytes
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::GetReadBuffer");
    HRESULT hr;

    TransAssert((_cbBufferSize >= _cbBufferFilled));

    *ppBuffer = _lpBuffer + _cbBufferFilled;
    *pcbBytes = _cbBufferSize - _cbBufferFilled;

    hr = ((_cbBufferSize - _cbBufferFilled) > 0) ? NOERROR : E_FAIL;

    PerfDbgLog3(tagCTransData, this, "-CTransData::GetReadBuffer (pBuffer:%lx,size:%ld,hr:%lx)",
        *ppBuffer, *pcbBytes, hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::OnDataInBuffer
//
//  Synopsis:
//
//  Arguments:  [pBuffer] --
//              [cbBytesAvailable] --
//              [dwBytesTotal] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::OnDataInBuffer(BYTE *pBuffer, DWORD cbBytesRead, DWORD dwBytesTotal)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::OnDataInBuffer",
                "this=%#x, %#x, %#x, %#x",
                this, pBuffer, cbBytesRead, dwBytesTotal
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::OnDataInBuffer");
    HRESULT hr = NOERROR;

    _cbTotalBytesRead += cbBytesRead;
    _cbBufferFilled += cbBytesRead;

    PerfDbgLog1(tagCTransData, this, "-CTransData::OnDataInBuffer (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::OnDataReceived
//
//  Synopsis:
//
//  Arguments:  [cbBytesAvailable] --
//              [dwBytesTotalRead] --
//              [dwTotalSize] --
//
//  Returns:
//
//  History:    2-23-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::OnDataReceived(DWORD grfBSC, DWORD cbBytesAvailable, DWORD dwTotalSize, DWORD *pcbNewAvailable)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::OnDataReceived",
                "this=%#x, %#x, %#x, %#x, %#x",
                this, grfBSC, cbBytesAvailable, dwTotalSize, pcbNewAvailable
                ));
                
    PerfDbgLog4(tagCTransData, this, "+CTransData::OnDataReceived (_ds:%s, grfBSC:%lx,  cbBytesAvailable:%ld, _cbTotalBytesRead:%ld)",
        GetDataSinkName(_ds), grfBSC, cbBytesAvailable, _cbTotalBytesRead);
    HRESULT hr = NOERROR;

    *pcbNewAvailable = cbBytesAvailable;
    _grfBSC |= grfBSC;

    switch (_ds)
    {
    case DataSink_StreamNoCopyData:
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));

    case DataSink_StreamBindToObject:
    {
        DWORD dwNewData = 0;
        TransAssert((_pProt && _cbDataSniffMin));

        // _cbTotalBytesRead = # of bytes read so far
        if (_cbTotalBytesRead < _cbDataSniffMin)
        {
            // no bytes read so far
            TransAssert((_cbTotalBytesRead < _cbDataSniffMin));
            // read data into buffer and report progess
            hr = _pProt->Read(_lpBuffer + _cbBufferFilled, _cbBufferSize - _cbBufferFilled, &dwNewData);
            _cbTotalBytesRead += dwNewData;
            _cbBufferFilled += dwNewData;

            // now check if this is docfile
            // if so download at least 2k
            if (!_fDocFile && _cbBufferFilled && (IsDocFile(_lpBuffer, _cbBufferFilled) == S_OK))
            {
                _fDocFile = TRUE;
                _cbDataSniffMin =  (dwTotalSize && dwTotalSize < DATASNIFSIZEDOCFILE_MIN) ? dwTotalSize : DATASNIFSIZEDOCFILE_MIN;
            }

            if ((hr == E_PENDING) && (_cbTotalBytesRead < _cbDataSniffMin))
            {
                // do not report anything - wait until we get more data
                // a request is pending at this time
                // need more data to sniff properly
                hr  = S_NEEDMOREDATA;
            }
            else if (hr == NOERROR || hr == E_PENDING)
            {
                TransAssert((_cbTotalBytesRead != 0));

                // report the data we have in the buffer or
                // the available #
                DWORD cbBytesReport =  (cbBytesAvailable > _cbTotalBytesRead) ? cbBytesAvailable : _cbTotalBytesRead + 1;

                if (dwTotalSize && ((cbBytesReport > dwTotalSize)))
                {
                    cbBytesReport =  dwTotalSize;
                }

               *pcbNewAvailable = cbBytesReport;
            }
        }
    }

    break;


    case DataSink_File:
    case DataSink_Storage:
    case DataSink_StreamOnFile:
    {
        DWORD dwNewData = 0;

        TransAssert((_pProt));

        if (_cbTotalBytesRead < _cbDataSniffMin)
        {
            _cbDataSniffMin =  (dwTotalSize && dwTotalSize < DATASNIFSIZEDOCFILE_MIN) ? dwTotalSize : DATASNIFSIZEDOCFILE_MIN;

            // read data into buffer and report progess
            hr = _pProt->Read(_lpBuffer + _cbBufferFilled, _cbBufferSize - _cbBufferFilled, &dwNewData);

            _cbTotalBytesRead += dwNewData;
            _cbBufferFilled += dwNewData;

            if ((hr == E_PENDING) && (_cbTotalBytesRead < _cbDataSniffMin))
            {
                // do not report anything - wait until we get more data
                // a request is pending at this time
                // need more data to sniff properly
                hr  = S_NEEDMOREDATA;
            }
            else if (hr == NOERROR || hr == E_PENDING)
            {
                TransAssert((_cbTotalBytesRead != 0));
            }
            *pcbNewAvailable = _cbTotalBytesRead;
        }

        // Note: read until pending or eof and report progress
        //       this is important to keep the download going
        if (hr == NOERROR)
        {
            // reset the buffer - don't overwrite sniffing data
            _cbBufferFilled = (_fMimeTypeVerified) ? 0 : _cbDataSniffMin;
            
            // bugbug: need special flag which indicates not to read if fully available
            //if (!(grfBSC & BSCF_DATAFULLYAVAILABLE))
            
            if (1)
            {
                //read as much data until S_OK or E_PENDING or error
                do
                {
                    hr = _pProt->Read(_lpBuffer + _cbBufferFilled, _cbBufferSize - _cbBufferFilled, &dwNewData);
                    _cbTotalBytesRead += dwNewData;

                } while (hr == NOERROR);

                // report available data
                if (hr == NOERROR || hr == E_PENDING)
                {
                    TransAssert((_cbTotalBytesRead != 0));
                }
                *pcbNewAvailable = (cbBytesAvailable > _cbTotalBytesRead) ? _cbTotalBytesRead : _cbTotalBytesRead;
            }
            else
            {
                TransAssert((dwTotalSize == cbBytesAvailable));
                *pcbNewAvailable = dwTotalSize;
            }

        }
    }
    break;

    default:
        TransAssert((FALSE && "CTransData::OnDataReceived -- Invalid data location"));
    break;
    }

    // cbBytesAvailable might be off be 1
    //TransAssert((cbBytesAvailable <= *pcbNewAvailable));

    PerfDbgLog1(tagCTransData, this, "-CTransData::OnDataReceived (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}


//+---------------------------------------------------------------------------
//
//  Method:     CTransData::OnStart
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    2-23-96   JohannP (Johann Posch)   Created
//
//  Notes:      TransData does not keep CINet alive
//              and will NOT call delete on it!
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::OnStart(IOInetProtocol *pCINet)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::OnStart",
                "this=%#x, %#x",
                this, pCINet
                ));
                
    HRESULT hr = NOERROR;
    PerfDbgLog(tagCTransData, this, "+CTransData::OnStart");
    TransAssert((pCINet != NULL));

    if (_pProt)
    {
        _pProt->Release();
        _pProt = NULL;
    }

    switch (_ds)
    {
    case DataSink_StreamBindToObject:
    case DataSink_StreamNoCopyData:
    case DataSink_StreamOnFile:
    case DataSink_GenericStream:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
        // this point is not addref by CTransData
        TransAssert((_pProt == NULL));
        _pProt = pCINet;
    }
    break;

    case DataSink_Storage:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTORAGE));
        // this point is not addref by CTransData
        TransAssert((_pProt == NULL));
        _pProt = pCINet;
    }
    break;


    case DataSink_File:
    {
        TransAssert((_formatetc.tymed == TYMED_FILE));
        // this point is not addref by CTransData
        TransAssert((_pProt == NULL));
        _pProt = pCINet;
    }
    break;

    default:
        TransAssert((FALSE && "Invalid data location"));
    break;
    }

    if (_pProt)
    {
        _pProt->AddRef();
    }
    else
    {
        TransAssert((FALSE));
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::OnStart (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}


//+---------------------------------------------------------------------------
//
//  Method:     CTransData::OnTerminate
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::OnTerminate()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::OnTerminate",
                "this=%#x",
                this
                ));
                
    HRESULT hr = NOERROR;
    PerfDbgLog(tagCTransData, this, "+CTransData::OnTerminate");

    TransAssert((_TransDataState < TransData_ProtoTerminated));

    switch (_ds)
    {

    case DataSink_Storage:
    case DataSink_File:
    {
        TransAssert((_formatetc.tymed == TYMED_FILE) || (_formatetc.tymed == TYMED_ISTORAGE));
        DbgLog2(tagCTransData, this, ">>> CTransData::OnTerminate (hr:%lx, _wzTempFile:%ws)", hr, _wzFileName);
    }
    break;

    case DataSink_StreamBindToObject:
    case DataSink_StreamNoCopyData:
    case DataSink_StreamOnFile:
    case DataSink_GenericStream:
    {
        TransAssert((_formatetc.tymed == TYMED_ISTREAM));
        TransAssert((_pProt != NULL));
    }
    break;
    default:
        TransAssert((FALSE && "Invalid data location"));
    break;
    }

    if (_pBndCtx)
    {
        _pBndCtx->Release();
        _pBndCtx = NULL;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::OnTerminate (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::FindFormatETC
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::FindFormatETC()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::FindFormatETC",
                "this=%#x",
                this
                ));
                
    HRESULT hr = NOERROR;
    PerfDbgLog1(tagCTransData, this, "+CTransData::FindFormatETC (_cbBufferFilled:%ld)", _cbBufferFilled);

    _formatetc.ptd = NULL;
    _formatetc.dwAspect = DVASPECT_CONTENT;
    _formatetc.lindex = -1;

    _formatetc.cfFormat = 0;
    TransAssert((   _formatetc.tymed == TYMED_ISTREAM
                 || _formatetc.tymed == TYMED_FILE
                 || _formatetc.tymed == TYMED_ISTORAGE ));

    LPCWSTR pwzStrOrg = GetMimeType();
    LPCWSTR pwzStr = pwzStrOrg;

    // If not already done so, attempt to
    // verify mime type by examining data.
    if (!_fMimeTypeVerified)
    {
        DWORD dwFlags = 0;
        DWORD dwSniffFlags = 0;
        DWORD cbLen = sizeof(dwFlags);
        LPWSTR pwzFileName = GetFileName();
        LPWSTR pwzStrOut = 0;



        // the buffer should contain data if the no mime
        TransAssert((    (_cbBufferFilled == 0 && (pwzStr || pwzFileName))
                     ||  ( _cbBufferFilled != 0) ));

        FindMimeFromData(NULL, pwzFileName,_lpBuffer, _cbBufferFilled, pwzStrOrg, dwSniffFlags,  &pwzStrOut, 0);

        if (pwzStrOut)
        {
            SetMimeType(pwzStrOut);
            pwzStr = GetMimeType();
        }
        
        delete [] pwzStrOut;
        _fMimeTypeVerified = TRUE;
    }

    // the new mime should never be NULL if we had a proposed mime
    TransAssert((   (pwzStrOrg && pwzStr)
                 || (pwzStrOrg == NULL)     ));

    if (pwzStr)
    {
        char szMime[SZMIMESIZE_MAX];
        W2A(pwzStr, szMime, SZMIMESIZE_MAX);

        CLIPFORMAT cfType;
        if (FindMediaTypeW(pwzStr,&cfType) != NOERROR)
        {
            _formatetc.cfFormat = (CLIPFORMAT) RegisterClipboardFormat(szMime);
        }
        else
        {
            _formatetc.cfFormat = cfType;
        }
    }
    else
    {
        _formatetc.cfFormat = CF_NULL;
    }

    // Check if the format that we got is one of the format that
    // is requested, and if so, use it
#ifdef UNUSED
    if (_pEnumFE)
    {
        FORMATETC FmtetcT;
        BOOL fDone = FALSE;

        _pEnumFE->Reset();

        while (!fDone && ((hr = _pEnumFE->Next(1, &FmtetcT,NULL)) == NOERROR))
        {
            TransAssert((SUCCEEDED(hr)));

            if (FmtetcT.cfFormat == _cfFormat)
            {
                _formatetc.cfFormat = _cfFormat;
            }
        }
    }
#endif //UNUSED

    PerfDbgLog3(tagCTransData, this, "-CTransData::FindFormatETC (hr:%lx, szStr:%ws, _formatetc.cfFormat:%lx)", hr, pwzStr?pwzStr:L"", _formatetc.cfFormat);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::GetAcceptStr
//
//  Synopsis:
//
//  Arguments:  [ppwzStr] --
//              [pcElements] --
//
//  Returns:
//
//  History:    3-29-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::GetAcceptStr(LPWSTR *ppwzStr, ULONG *pcElements)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::GetAcceptStr",
                "this=%#x, %#x, %#x",
                this, ppwzStr, pcElements
                ));
                
    HRESULT hr = NOERROR;
    PerfDbgLog(tagCTransData, this, "+CTransData::GetAcceptStr");
    IEnumFORMATETC *pIEnumFE = NULL;

    TransAssert((ppwzStr));
    TransAssert((*pcElements > 0));

    CHAR pszUnknownName[MAX_PATH];
    ULONG cMimes = 0;
    
    *ppwzStr = 0;
    hr = GetObjectParam(_pBndCtx, REG_ENUMFORMATETC, IID_IEnumFORMATETC, (IUnknown**)&pIEnumFE);

    if (hr == NOERROR)
    {
        BOOL fCF_NULL = FALSE;
        #define ELEMENTS 10
        ULONG cElementsIn = ELEMENTS;
        ULONG cElements = 0;
        FORMATETC rgFormatEtc[ELEMENTS];


        pIEnumFE->Reset();
        // find # of elements
        do
        {
            ULONG cEl = 0;
            hr = pIEnumFE->Next(cElementsIn, rgFormatEtc ,&cEl);
            cElements += cEl;
        } while (hr == S_OK);

        UrlMkAssert((cElements > 0));

        if  (   (cElements > 0)
             && (hr == S_OK || hr == S_FALSE))
        {

            {
                ULONG cElementsOut = 0;
                pIEnumFE->Reset();
                do
                {
                    ULONG cEl = 0;
                    FORMATETC *pFmtEtc = rgFormatEtc;

                    hr = pIEnumFE->Next(cElementsIn, rgFormatEtc ,&cEl);                    
                    cElementsOut += cEl;
                    // (hr==S_FALSE) => (cElementsOut==cEl)
                    UrlMkAssert((!(hr==S_FALSE) || (cElementsOut == cElements)));

                    // On the last call to ->Next() enumerator, we get back an S_FALSE
                    // if the # of elements received (cEl) < asked for (cElementsIn)
                    if ((cElementsOut == cElements) && (hr == S_FALSE))
                        hr = S_OK;

                    for (ULONG i = 0; i < cEl; i++)
                    {
                        if( cMimes >=  (*pcElements - 1)  )
                        {
                            // exceeding the income array size, stop
                            break;
                        }


                        LPSTR szFormat = NULL;
                        CLIPFORMAT  cfFormat = (pFmtEtc + i)->cfFormat;
                        if (cfFormat == CF_NULL)
                        {
                            fCF_NULL = TRUE;
                        }
                        else
                        {
                            hr = FindMediaString(cfFormat, &szFormat);
                            if (hr != NOERROR || !szFormat)
                            {
                                // unknown cfFormat
                                if( GetClipboardFormatName(cfFormat, pszUnknownName, MAX_PATH))
                                {
                                    hr = NOERROR;
                                    szFormat = pszUnknownName;
                                } 
                                else
                                {
                                    // word97 will send out cfFormat=1
                                    // which associated to "" string
                                    hr = NOERROR;
                                }
                            }
                            if( szFormat )
                            {

                                *(ppwzStr + cMimes)= NULL; 
                                *(ppwzStr + cMimes) = DupA2W(szFormat);
                                if( *(ppwzStr + cMimes) )
                                {
                                    cMimes++;
                                } 
                                else
                                {
                                    hr = E_OUTOFMEMORY;
                                    break;
                                }
                            }
                        }
                    }

                } while ( (cElementsOut < cElements) && (hr == NOERROR) );

                // append the cf_null (*/*)
                if( hr == NOERROR && (fCF_NULL || (cMimes == 0)) )
                {
                    *(ppwzStr + cMimes) = DupA2W(g_szCF_NULL);
                    if( !*(ppwzStr + cMimes) )
                    {
                        hr = E_OUTOFMEMORY;
                    } 
                    else
                    { 
                        cMimes++;
                        hr = NOERROR;
                    }
                }

                if( hr == NOERROR )
                {
                    *(ppwzStr + cMimes) = NULL;
                }
            }
        }

        pIEnumFE->Release();
    }
    else
    {
        {
            *ppwzStr = DupA2W(g_szCF_NULL);
            if( *ppwzStr )
            {
                cMimes = 1;
                *(ppwzStr + 1) = NULL;
                hr = NOERROR;
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }
    }

    if( hr == NOERROR )
    {
        *pcElements = cMimes;
    }
    else
    {
        *pcElements = 0;
        if( cMimes >= 1 )
        {
            for( ULONG i = 0; i < cMimes; i ++)
            {
                delete [] *(ppwzStr + i);
            }
        }
        *ppwzStr = NULL;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::GetAcceptStr (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::GetAcceptMimes
//
//  Synopsis:
//
//  Arguments:  [ppStr] --
//
//  Returns:
//
//  History:    3-29-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::GetAcceptMimes(LPWSTR *ppwzStr, ULONG cel, ULONG *pcElements)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::GetAcceptMimes",
                "this=%#x, %#x, %#x, %#x",
                this, ppwzStr, cel, pcElements
                ));
                
    HRESULT hr = NOERROR;
    PerfDbgLog(tagCTransData, this, "+CTransData::GetAcceptMimes");

    TransAssert((ppwzStr && pcElements && *pcElements));

    if (ppwzStr && pcElements)
    {
        if( *pcElements > 1 )
        {
            hr = GetAcceptStr( ppwzStr, pcElements );
        }
        else if( *pcElements == 1)
        {
            // zero terminated 
            *ppwzStr = NULL;
        }
        else
        {
            hr =  E_INVALIDARG;
        }
    }
    else
    {
        hr =  E_INVALIDARG;
    }
    PerfDbgLog1(tagCTransData, this, "-CTransData::GetAcceptMimes (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}


//+---------------------------------------------------------------------------
//
//  Method:     CTransData::SetClipFormat
//
//  Synopsis:
//
//  Arguments:  [cfFormat] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::SetClipFormat(CLIPFORMAT  cfFormat)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::SetClipFormat",
                "this=%#x, %#x",
                this, cfFormat
                ));
                
    HRESULT hr = NOERROR;
    PerfDbgLog(tagCTransData, this, "+CTransData::SetClipFormat");

    _cfFormat = cfFormat;

    PerfDbgLog1(tagCTransData, this, "-CTransData::SetClipFormat (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::IsObjectReady
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::IsObjectReady(  )
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::IsObjectReady",
                "this=%#x",
                this
                ));
                
    HRESULT hr = E_FAIL;
    PerfDbgLog(tagCTransData, this, "+CTransData::IsObjectReady");

    // check size and
    if ((_cbDataSize != 0) && (_cbDataSize == _cbTotalBytesRead))
    {
        hr = NOERROR;
    }

    PerfDbgLog3(tagCTransData, this, "-CTransData::IsObjectReady (hr:%lx, _cbDataSize:%ld, _cbTotalBytesRead:%ld)", hr, _cbDataSize, _cbTotalBytesRead);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::InProgress
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::InProgress()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::InProgress",
                "this=%#x",
                this
                ));
                
    HRESULT hr = S_FALSE;
    PerfDbgLog(tagCTransData, this, "+CTransData::InProgress");

    if (_grfBSC & (BSCF_LASTDATANOTIFICATION | BSCF_FIRSTDATANOTIFICATION))
    {
        hr = S_FALSE;
    }
    else if (_cbTotalBytesRead == 0)
    {
        // check if some bits already in the buffer

        hr = S_OK;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::InProgress (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::GetFileName
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
LPWSTR CTransData::GetFileName()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Pointer,
                "CTransData::GetFileName",
                "this=%#x",
                this
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::GetFileName");
    LPWSTR pwzFileName = NULL;

    //TransAssert((_wzFileName[0] != 0));

    if (_wzFileName[0] != 0)
    {
        pwzFileName = _wzFileName;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::GetFileName (szFile:%ws)", pwzFileName?pwzFileName:L"");

    DEBUG_LEAVE(pwzFileName);
    return pwzFileName;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::GetClassID
//
//  Synopsis:
//
//  Arguments:  [pclsid] --
//              [fReOpen] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::GetClassID(CLSID clsidIn, CLSID *pclsid)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::GetClassID",
                "this=%#x, %#x, %#x",
                this, clsidIn, pclsid
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::GetClassID");
    WCHAR wzMime[SZMIMESIZE_MAX];
    HRESULT hr;
    LPWSTR pwzTempFile = NULL;

    DWORD fIgnoreMimeClsid = GetBindFlags() & BINDF_IGNOREMIMECLSID;
    LPCWSTR pwzMime = GetMimeType();

    pwzTempFile = GetFileName();

    if (   (_cbBufferFilled != 0)
             && (_cbTotalBytesRead <= _cbBufferSize)
             && (IsDocFile(_lpBuffer, _cbBufferFilled) == S_OK))
    {
        _fDocFile = TRUE;
        _fMimeTypeVerified = TRUE;

        // Storage file (docfile) case
        // GetClassFileOrMime takes care of class mapping
        hr = GetClassFileOrMime2(_pBndCtx, pwzTempFile, _lpBuffer, _cbBufferFilled, pwzMime, 0, pclsid, fIgnoreMimeClsid);
        if (hr != NOERROR)
        {
            // S_FALSE means keep downloading
            hr = S_FALSE;
        }
    }
    else
    {
        if (!_fMimeTypeVerified)
        {
            DWORD dwFlags = 0;
            DWORD dwSniffFlags = 0;
            DWORD cbLen = sizeof(dwFlags);

            LPWSTR  pwzStr = 0;
            FindMimeFromData(NULL, pwzTempFile, _lpBuffer, _cbBufferFilled, pwzMime, dwSniffFlags,  &pwzStr, 0);
            if (pwzStr)
            {
                SetMimeType(pwzStr);
            }
            _fMimeTypeVerified = TRUE;
            delete [] pwzStr;
        }

        hr = GetClassFileOrMime2(_pBndCtx, pwzTempFile, NULL, 0, pwzMime, 0, pclsid, fIgnoreMimeClsid);
    }

    #if DBG==1
    if (hr == NOERROR)
    {
        LPOLESTR pszStr;
        StringFromCLSID(*pclsid, &pszStr);
        DbgLog2(tagCTransData, this, "CTransData::GetClassID (file:%ws)(class:%ws)",
            pwzTempFile, pszStr);
        delete pszStr;
    }
    #endif

    PerfDbgLog1(tagCTransData, this, "-CTransData::GetClassID (hr:%lx)", hr);

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::SetMimeType
//
//  Synopsis:
//
//  Arguments:  [pszMime] --
//
//  Returns:
//
//  History:    2-07-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::SetMimeType(LPCWSTR pwzMime)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::SetMimeType",
                "this=%#x, %.80wq",
                this, pwzMime
                ));
                
    PerfDbgLog2(tagCTransData, this, "+CTransData::SetMimeType (OldMime:%ws; MimeStr:%ws)", _wzMime?_wzMime:L"", pwzMime?pwzMime:L"");
    HRESULT hr = NOERROR;

    if (pwzMime)
    {

        #if DBG_XXX
        if (pwzMime)
        {
            if (   !wcscmp(_wzMime, CFWSTR_MIME_HTML)
                || !wcscmp(_wzMime, CFWSTR_MIME_TEXT))
            {
                if (   !wcscmp(pwzMime, CFWSTR_MIME_RAWDATA)
                    || !wcscmp(pwzMime,L"application/octet-stream"))
                {
                    DbgLog2(tagCTransDataErr, "=== SetMimeType: OldMime:%ws, NewMime:%ws",
                        _wzMime, pwzMime);
                    //TransAssert((FALSE));
                }
            }
        }

        if (_wzMime[0] != 0 && strcmp(_wzMime,pwzMime))
        {
            DbgLog2(tagTransDataErr, "=== SetMimeType: OldMime:%s, NewMime:%s",
                _wzMime, pwzMime);
        }

        #endif //DBG


        DWORD cLen = wcslen((LPWSTR)pwzMime);

        if (cLen >= SZMIMESIZE_MAX)
        {
            cLen = SZMIMESIZE_MAX - 1;
            wcsncpy(_wzMime, (LPWSTR)pwzMime, cLen);
            _wzMime[cLen] = 0;
        }
        else
        {
            wcscpy(_wzMime, (LPWSTR)pwzMime);
        }
    }
    else
    {
        DbgLog(tagCTransDataErr, this, "CTransData::SetMimeType ->invalid mime");
    }

    PerfDbgLog2(tagCTransData, this, "-CTransData::SetMimeType (hr:%lx, Mime:%ws)", hr,_wzMime?_wzMime:L"");

    DEBUG_LEAVE(hr);
    return hr;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::SetFileName
//
//  Synopsis:
//
//  Arguments:  [szFile] --
//
//  Returns:
//
//  History:    1-27-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP CTransData::SetFileName(LPWSTR pwzFile)
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Hresult,
                "CTransData::SetFileName",
                "this=%#x, %.80wq",
                this, pwzFile
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::SetFileName");

    TransAssert((pwzFile));
    if(pwzFile)
    {
        wcscpy(_wzFileName, pwzFile);
    }

    PerfDbgLog2(tagCTransData, this, "-CTransData::SetFileName (_wzFileName:%ws, hr:%lx)", _wzFileName?_wzFileName:L"", NOERROR);

    DEBUG_LEAVE(NOERROR);
    return NOERROR;
}

//+---------------------------------------------------------------------------
//
//  Method:     CTransData::GetMimeType
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    4-24-96   JohannP (Johann Posch)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
LPCWSTR CTransData::GetMimeType()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                Pointer,
                "CTransData::GetMimeType",
                "this=%#x",
                this
                ));
                
    PerfDbgLog(tagCTransData, this, "+CTransData::GetMimeType");
    LPWSTR pwzStr = NULL;

    if (_wzMime[0] != 0)
    {
        pwzStr = _wzMime;
    }

    PerfDbgLog1(tagCTransData, this, "-CTransData::GetMimeType (pStr:%ws)", pwzStr?pwzStr:L"");

    DEBUG_LEAVE(pwzStr);
    return pwzStr;
}


//+---------------------------------------------------------------------------
//
//  Method:     CTransData::OnEndofData()
//
//  Synopsis:
//
//  Arguments:  (none)
//
//  Returns:
//
//  History:    7-30-97   DanpoZ(Danpo Zhang)   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
void CTransData::OnEndofData()
{
    DEBUG_ENTER((DBG_TRANSDAT,
                None,
                "CTransData::OnEndofData",
                "this=%#x",
                this
                ));
                
    PerfDbgLog1(tagCTransData, this, "+CTransData::OnEndofData(_ds:%ld)", _ds);
    BOOL fNewStgMed = FALSE;

    if (_pStgMed  && _ds == DataSink_StreamOnFile && _pStgMed->pstm )
    {
        ((CReadOnlyStreamFile*)(_pStgMed->pstm))->SetDataFullyAvailable();
    }

    PerfDbgLog(tagCTransData, this, "-CTransData::OnEndofData");

    DEBUG_LEAVE(0);
}