1635 lines
46 KiB
C++
1635 lines
46 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1995.
|
|
//
|
|
// File: transact.cxx
|
|
//
|
|
// Contents: Class that performs the download of a particular request.
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 12-04-95 JohannP (Johann Posch) Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#include <trans.h>
|
|
#include <shlwapi.h>
|
|
|
|
#include "oinet.hxx"
|
|
|
|
PerfDbgTag(tagCTransaction, "Urlmon", "Log CTransaction", DEB_TRANS);
|
|
DbgTag(tagCTransactionErr, "Urlmon", "Log CTransaction Errors", DEB_TRANS|DEB_ERROR);
|
|
|
|
HRESULT GetClassDocFileBuffer(LPVOID pbuffer, DWORD dwSize, CLSID *pclsid);
|
|
HRESULT GetCodeBaseFromDocFile(LPBYTE pBuffer, ULONG ulSize, LPWSTR *pwzClassStr,
|
|
LPWSTR pwzBaseUrl, DWORD *lpdwVersionMS, DWORD *lpdwVersionLS);
|
|
HRESULT IsHandlerAvailable(LPWSTR pwzUrl, LPWSTR pwzMime, CLSID *pclsid,
|
|
LPBYTE pBuffer, ULONG cbSize);
|
|
|
|
#if 0
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProtSnk::QueryInterface
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [riid] --
|
|
// [ppvObj] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProtSnk::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
VDATEPTROUT(ppvObj, void *);
|
|
VDATETHIS(this);
|
|
HRESULT hr = NOERROR;
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProtSnk::QueryInterface");
|
|
|
|
*ppvObj = NULL;
|
|
if (_pUnk)
|
|
{
|
|
hr = _pUnk->QueryInterface(riid, ppvObj);
|
|
}
|
|
else
|
|
{
|
|
if ( (riid == IID_IUnknown)
|
|
|| (riid == IID_IOInetProtocol))
|
|
{
|
|
*ppvObj = (IOInetProtocol *) this;
|
|
AddRef();
|
|
}
|
|
else if (riid == IID_IOInetProtocolSink)
|
|
{
|
|
*ppvObj = (IOInetProtocolSink *) this;
|
|
AddRef();
|
|
}
|
|
else
|
|
{
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
}
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProtSnk::QueryInterface (hr:%lx)", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: COInetProtSnk::AddRef
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [ULONG] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) COInetProtSnk::AddRef(void)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProtSnk::AddRef");
|
|
|
|
LONG lRet = _pProtSnk->AddRef();
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProtSnk::AddRef (cRefs:%ld)", lRet);
|
|
return lRet;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: COInetProtSnk::Release
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [ULONG] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) COInetProtSnk::Release(void)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProtSnk::Release");
|
|
|
|
LONG lRet = _pProtSnk->Release();
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProtSnk::Release (cRefs:%ld)", lRet);
|
|
return lRet;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProtSnk::Switch
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pStateInfo] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProtSnk::Switch(PROTOCOLDATA *pStateInfo)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProtSnk::Switch");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProtSnk->Switch(pStateInfo);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProtSnk::Switch (hr:%lx)", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProtSnk::ReportProgress
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [NotMsg] --
|
|
// [szStatusText] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProtSnk::ReportProgress(ULONG NotMsg, LPCWSTR pwzStatusText)
|
|
{
|
|
PerfDbgLog1(tagCTransaction, this, "+COInetProtSnk::ReportProgress pwzStatusText:%ws", pwzStatusText);
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProtSnk->ReportProgress(NotMsg, pwzStatusText);
|
|
|
|
PerfDbgLog2(tagCTransaction, this, "-COInetProtSnk::ReportProgress (pwzStatusText:%ws, hr:%lx)", pwzStatusText, hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProtSnk::ReportData
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [grfBSCF] --
|
|
// [ULONG] --
|
|
// [ulProgressMax] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProtSnk::ReportData(DWORD grfBSCF, ULONG ulProgress,ULONG ulProgressMax)
|
|
{
|
|
PerfDbgLog3(tagCTransaction, this, "+COInetProtSnk::ReportData(grfBSCF:%lx, ulProgress:%ld, ulProgressMax:%ld)",
|
|
grfBSCF, ulProgress, ulProgressMax);
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProtSnk->ReportData( grfBSCF, ulProgress, ulProgressMax);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProtSnk::ReportData (hr:%lx)", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProtSnk::ReportResult
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [DWORD] --
|
|
// [dwError] --
|
|
// [wzResult] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProtSnk::ReportResult(HRESULT hrResult, DWORD dwError, LPCWSTR wzResult)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProtSnk::ReportResult");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProtSnk->ReportResult(hrResult, dwError, wzResult);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProtSnk::ReportResult (hr:%lx)", hr);
|
|
return hr;
|
|
}
|
|
#endif // 0
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::QueryInterface
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [riid] --
|
|
// [ppvObj] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IUnknown::QueryInterface",
|
|
"this=%#x, %#x, %#x",
|
|
this, &riid, ppvObj
|
|
));
|
|
|
|
VDATEPTROUT(ppvObj, void *);
|
|
VDATETHIS(this);
|
|
HRESULT hr = NOERROR;
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::QueryInterface");
|
|
|
|
*ppvObj = NULL;
|
|
|
|
if (_pUnk)
|
|
{
|
|
hr = _pUnk->QueryInterface(riid, ppvObj);
|
|
}
|
|
else
|
|
{
|
|
if ( (riid == IID_IUnknown)
|
|
|| (riid == IID_IOInetProtocol))
|
|
{
|
|
*ppvObj = (IOInetProtocol *) this;
|
|
AddRef();
|
|
}
|
|
else if (riid == IID_IOInetProtocolSink)
|
|
{
|
|
*ppvObj = (IOInetProtocolSink *) this;
|
|
AddRef();
|
|
}
|
|
else if (riid == IID_IServiceProvider)
|
|
{
|
|
*ppvObj = (IServiceProvider *) this;
|
|
AddRef();
|
|
}
|
|
else if (riid == IID_IOInetPriority)
|
|
{
|
|
*ppvObj = (IOInetPriority *) this;
|
|
AddRef();
|
|
}
|
|
else
|
|
{
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
}
|
|
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::QueryInterface (hr:%lx)", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: COInetProt::AddRef
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [ULONG] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) COInetProt::AddRef(void)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Dword,
|
|
"COInetProt::IUnknown::AddRef",
|
|
"this=%#x",
|
|
this
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::AddRef");
|
|
|
|
LONG lRet;
|
|
|
|
if (_pUnk)
|
|
{
|
|
lRet = _pUnk->AddRef();
|
|
}
|
|
else
|
|
{
|
|
lRet = ++_CRefs;
|
|
}
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::AddRef (cRefs:%ld)", lRet);
|
|
|
|
DEBUG_LEAVE(lRet);
|
|
return lRet;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: COInetProt::Release
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [ULONG] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) COInetProt::Release(void)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Dword,
|
|
"COInetProt::IUnknown::Release",
|
|
"this=%#x",
|
|
this
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Release");
|
|
|
|
LONG lRet;
|
|
if (_pUnk)
|
|
{
|
|
lRet = _pUnk->Release();
|
|
}
|
|
else
|
|
{
|
|
lRet = --_CRefs;
|
|
if (_CRefs == 0)
|
|
{
|
|
//
|
|
// release all objects
|
|
if (_pProtSnk)
|
|
{
|
|
_pProtSnk->Release();
|
|
}
|
|
if (_pProt)
|
|
{
|
|
_pProt->Release();
|
|
}
|
|
|
|
if (_dwMode & PP_DELETE)
|
|
{
|
|
delete this;
|
|
}
|
|
}
|
|
}
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Release (cRefs:%ld)", lRet);
|
|
|
|
DEBUG_LEAVE(lRet);
|
|
return lRet;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Start
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pwzUrl] --
|
|
// [pTrans] --
|
|
// [pOIBindInfo] --
|
|
// [grfSTI] --
|
|
// [dwReserved] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Start(LPCWSTR pwzUrl, IOInetProtocolSink *pOInetProtSnk, IOInetBindInfo *pOIBindInfo,
|
|
DWORD grfSTI, DWORD_PTR dwReserved)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolRoot::Start",
|
|
"this=%#x, %.80wq, %#x, %#x, %#x, %#x",
|
|
this, pwzUrl, pOInetProtSnk, pOIBindInfo, grfSTI, dwReserved
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Start\n");
|
|
HRESULT hr = NOERROR;
|
|
|
|
TransAssert((pOIBindInfo && pOInetProtSnk && pwzUrl));
|
|
|
|
// Just before starting the transaction give it the priority.
|
|
|
|
IOInetPriority * pOInetPriority = NULL;
|
|
if (_pProt->QueryInterface(IID_IOInetPriority, (void **) &pOInetPriority) == S_OK)
|
|
{
|
|
pOInetPriority->SetPriority(_nPriority);
|
|
pOInetPriority->Release();
|
|
}
|
|
|
|
delete [] _pwzUrl;
|
|
_pwzUrl = OLESTRDuplicate(pwzUrl);
|
|
|
|
hr = _pProt->Start(pwzUrl, pOInetProtSnk, pOIBindInfo, grfSTI, dwReserved);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Start (hr:%lx)\n", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Continue
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pStateInfoIn] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Continue(PROTOCOLDATA *pStateInfoIn)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolRoot::Continue",
|
|
"this=%#x, %#x",
|
|
this, pStateInfoIn
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Continue\n");
|
|
|
|
HRESULT hr = _pProt->Continue(pStateInfoIn);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Continue (hr:%lx)\n",hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Abort
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [hrReason] --
|
|
// [dwOptions] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-09-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Abort(HRESULT hrReason, DWORD dwOptions)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolRoot::Abort",
|
|
"this=%#x, %#x, %#x",
|
|
this, hrReason, dwOptions
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Abort\n");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProt->Abort(hrReason, dwOptions);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Abort (hr:%lx)\n", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Terminate
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [dwOptions] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Terminate(DWORD dwOptions)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolRoot::Terminate",
|
|
"this=%#x, %#x",
|
|
this, dwOptions
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Terminate\n");
|
|
HRESULT hr = NOERROR;
|
|
|
|
TransAssert((_pProt));
|
|
|
|
hr = _pProt->Terminate(dwOptions);
|
|
SetProtocolSink(0);
|
|
SetServiceProvider(0);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Terminate (hr:%lx)\n", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Suspend
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Suspend()
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolRoot::Suspend",
|
|
"this=%#x",
|
|
this
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Suspend\n");
|
|
|
|
HRESULT hr = _pProt->Suspend();
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Suspend (hr:%lx)\n", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Resume
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Resume()
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolRoot::Resume",
|
|
"this=%#x",
|
|
this
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Resume\n");
|
|
|
|
HRESULT hr = _pProt->Resume();
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Resume (hr:%lx)\n", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Read
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [ULONG] --
|
|
// [ULONG] --
|
|
// [pcbRead] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Read(void *pBuffer, ULONG cbBuffer,ULONG *pcbRead)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocol::Read",
|
|
"this=%#x, %#x, %#x, %#x",
|
|
this, pBuffer, cbBuffer, pcbRead
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Read\n");
|
|
HRESULT hr = E_FAIL;
|
|
|
|
BOOL fRead = TRUE;
|
|
DWORD dwCopy = 0;
|
|
DWORD dwCopyNew = 0;
|
|
|
|
if ((_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP))
|
|
&& _cbBufferUnread)
|
|
{
|
|
fRead = FALSE;
|
|
|
|
// copy data form the local buffer to the provide buffer
|
|
if (cbBuffer <= _cbBufferUnread)
|
|
{
|
|
dwCopy = cbBuffer;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
dwCopy = _cbBufferUnread;
|
|
fRead = TRUE;
|
|
}
|
|
memcpy(pBuffer, _pBuffer+(_cbBufferFilled-_cbBufferUnread), dwCopy);
|
|
_cbBufferUnread -= dwCopy;
|
|
}
|
|
|
|
if (fRead)
|
|
{
|
|
if (_pProt)
|
|
{
|
|
hr = _pProt->Read( ((LPBYTE)pBuffer) + dwCopy, cbBuffer - dwCopy, &dwCopyNew);
|
|
_cbTotalBytesRead += dwCopyNew;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
|
|
if (pcbRead)
|
|
{
|
|
*pcbRead = dwCopy + dwCopyNew;
|
|
}
|
|
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Read (hr:%lx)\n",hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Seek
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [DWORD] --
|
|
// [ULARGE_INTEGER] --
|
|
// [plibNewPosition] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Seek(LARGE_INTEGER dlibMove,DWORD dwOrigin,ULARGE_INTEGER *plibNewPosition)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocol::Seek",
|
|
"this=%#x, %#x, %#x, %#x",
|
|
this, dlibMove, dwOrigin, plibNewPosition
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Seek\n");
|
|
|
|
HRESULT hr = _pProt->Seek(dlibMove, dwOrigin, plibNewPosition);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Seek (hr:%lx)\n", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::LockRequest
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [dwOptions] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::LockRequest(DWORD dwOptions)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocol::LockRequest",
|
|
"this=%#x, %#x",
|
|
this, dwOptions
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::LockRequest\n");
|
|
|
|
HRESULT hr = hr = _pProt->LockRequest(dwOptions);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::LockRequest (hr:%lx)\n",hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::UnlockRequest
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::UnlockRequest()
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocol::UnlockRequest",
|
|
"this=%#x",
|
|
this
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::UnlockRequest\n");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProt->UnlockRequest();
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::UnlockRequest (hr:%lx)\n", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CTransaction::OnDataReceived
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [grfBSC] --
|
|
// [cbBytesAvailable] --
|
|
// [dwTotalSize] --
|
|
// [pcbNewAvailable] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 4-15-1997 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::OnDataReceived(DWORD *pgrfBSC, DWORD *pcbBytesAvailable, DWORD *pdwTotalSize)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::OnDataReceived",
|
|
"this=%#x, %#x, %#x, %#x",
|
|
this, pgrfBSC, pcbBytesAvailable, pdwTotalSize
|
|
));
|
|
|
|
PerfDbgLog3(tagCTransaction, this, "+COInetProt::OnDataReceived (grfBSC:%lx, *pcbBytesAvailable:%ld, _cbTotalBytesRead:%ld)",
|
|
*pgrfBSC, *pcbBytesAvailable, _cbTotalBytesRead);
|
|
HRESULT hr = NOERROR;
|
|
DWORD grfBSC = *pgrfBSC;
|
|
BOOL fEndOfData = FALSE;
|
|
|
|
if (_fWaitOnHandler)
|
|
{
|
|
hr = S_NEEDMOREDATA;
|
|
}
|
|
else if (
|
|
((_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP | PI_CLASSINSTALL))
|
|
&& (!_fMimeVerified || _fNeedMoreData))
|
|
||
|
|
((_dwOInetBdgFlags & PI_CLASSINSTALL) && !_fClassInstallChecked)
|
|
)
|
|
{
|
|
DWORD dwNewData = 0;
|
|
TransAssert((_pProt && _cbDataSniffMin));
|
|
|
|
//TransAssert((pcbBytesAvailable && *pcbBytesAvailable));
|
|
//TransAssert((pdwTotalSize));
|
|
|
|
// _cbTotalBytesRead = # of bytes read so far
|
|
if (_cbBufferFilled < _cbDataSniffMin)
|
|
{
|
|
// no bytes read so far
|
|
TransAssert((_cbTotalBytesRead < _cbDataSniffMin));
|
|
// read data into buffer and report progess
|
|
do
|
|
{
|
|
PProtAssert((_pBuffer && (_pBuffer + _cbBufferFilled) ));
|
|
hr = _pProt->Read(_pBuffer + _cbBufferFilled, _cbBufferSize - _cbBufferFilled, &dwNewData);
|
|
_cbTotalBytesRead += dwNewData;
|
|
_cbBufferFilled += dwNewData;
|
|
_cbBufferUnread += dwNewData;
|
|
} while ((hr == S_OK) && (_cbBufferFilled < _cbDataSniffMin));
|
|
|
|
// now check if this is docfile
|
|
// if so download at least 2k
|
|
if (!_fDocFile && _cbBufferFilled && (IsDocFile(_pBuffer, _cbBufferFilled) == S_OK))
|
|
{
|
|
_fDocFile = TRUE;
|
|
|
|
// we may need to sniff to maximum to find handler
|
|
|
|
if (_cbBufferSize < DATASNIFSIZEDOCFILE_MAX)
|
|
{
|
|
LPBYTE pBufferTemp;
|
|
|
|
pBufferTemp = (LPBYTE) new BYTE[DATASNIFSIZEDOCFILE_MAX];
|
|
if (pBufferTemp)
|
|
{
|
|
memcpy(pBufferTemp, _pBuffer, _cbBufferFilled);
|
|
delete [] _pBuffer;
|
|
_pBuffer = pBufferTemp;
|
|
_cbBufferSize = DATASNIFSIZEDOCFILE_MAX;
|
|
|
|
if (hr == NOERROR)
|
|
{
|
|
//since we increased the buffersize and we want to drain DATASNIFSIZEDOCFILE_MAX bytes.
|
|
do
|
|
{
|
|
PProtAssert((_pBuffer && (_pBuffer + _cbBufferFilled) ));
|
|
hr = _pProt->Read(_pBuffer + _cbBufferFilled, _cbBufferSize - _cbBufferFilled, &dwNewData);
|
|
_cbTotalBytesRead += dwNewData;
|
|
_cbBufferFilled += dwNewData;
|
|
_cbBufferUnread += dwNewData;
|
|
} while ((hr == S_OK) && (_cbBufferFilled < _cbBufferSize));
|
|
}
|
|
}
|
|
}
|
|
|
|
_cbDataSniffMin = (*pdwTotalSize && *pdwTotalSize < _cbBufferSize) ? *pdwTotalSize : _cbBufferSize;
|
|
}
|
|
|
|
if ((hr == E_PENDING) && (_cbBufferFilled < _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 = (*pcbBytesAvailable > _cbTotalBytesRead) ? *pcbBytesAvailable : _cbTotalBytesRead + 1;
|
|
|
|
if (*pdwTotalSize && ((cbBytesReport > *pdwTotalSize)))
|
|
{
|
|
cbBytesReport = *pdwTotalSize;
|
|
}
|
|
*pcbBytesAvailable = cbBytesReport;
|
|
}
|
|
else if (hr == S_FALSE)
|
|
{
|
|
// end of stream
|
|
*pgrfBSC |= (BSCF_LASTDATANOTIFICATION & BSCF_DATAFULLYAVAILABLE);
|
|
*pcbBytesAvailable = *pdwTotalSize = _cbTotalBytesRead;
|
|
fEndOfData = TRUE;
|
|
}
|
|
|
|
if ( (!_fMimeVerified)
|
|
&& ( (*pcbBytesAvailable >= _cbDataSniffMin)
|
|
|| (hr == S_FALSE)) )
|
|
{
|
|
// enough data or end of stream
|
|
_fMimeVerified = TRUE;
|
|
LPWSTR pwzStr = 0;
|
|
DWORD dwMimeFlags = FMFD_DEFAULT;
|
|
if( !_pwzFileName )
|
|
{
|
|
dwMimeFlags = FMFD_URLASFILENAME;
|
|
}
|
|
hr = FindMimeFromData(NULL, (_pwzFileName) ? _pwzFileName : _pwzUrl, _pBuffer, _cbBufferFilled, _pwzMimeSuggested, dwMimeFlags, &pwzStr, 0);
|
|
|
|
TransAssert(pwzStr);
|
|
|
|
// note: _pwzUrl & _pwzFileName may be used later for composing URL
|
|
// in code base attribute of active document (deleted in destructor)
|
|
|
|
if (pwzStr)
|
|
{
|
|
_fMimeReported = 1;
|
|
_pProtSnk->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, pwzStr);
|
|
}
|
|
else
|
|
{
|
|
TransAssert((!_pwzMimeSuggested));
|
|
}
|
|
|
|
if (pwzStr)
|
|
{
|
|
delete [] _pwzMimeSuggested;
|
|
_pwzMimeSuggested = pwzStr;
|
|
pwzStr = 0;
|
|
}
|
|
|
|
if ( _fDocFile
|
|
&& (_dwOInetBdgFlags & PI_DOCFILECLSIDLOOKUP))
|
|
{
|
|
// find the class id and send it on
|
|
CLSID clsid;
|
|
|
|
HRESULT hr1 = GetClassDocFileBuffer(_pBuffer, _cbBufferFilled, &clsid);
|
|
if (hr1 == NOERROR)
|
|
{
|
|
if (_pwzStrClsId)
|
|
{
|
|
delete [] _pwzStrClsId;
|
|
_pwzStrClsId = NULL;
|
|
}
|
|
StringFromCLSID(clsid, &_pwzStrClsId);
|
|
if (_pwzStrClsId)
|
|
{
|
|
_fReportedClassId = TRUE;
|
|
_pProtSnk->ReportProgress(BINDSTATUS_CLASSIDAVAILABLE, _pwzStrClsId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//On a BTS->BTO scenario, we should get into this loop with the lesser of DATASNIFSIZEDOCFILE_MIN or TOTAL_SIZE.
|
|
//On a BTO scenario, the situation is the same as before, except hr=S_NEEDMOREDATA if size<DATASNIF_MIN.
|
|
//On a BTS scenario, this block will not be entered.
|
|
if ( (_dwOInetBdgFlags & PI_CLASSINSTALL)
|
|
&& !_fGotHandler )
|
|
{
|
|
_fClassInstallChecked = TRUE;
|
|
|
|
BOOL fIgnoreMimeClsid = FALSE;
|
|
DWORD dwVersionMS = 0, dwVersionLS = 0;
|
|
LPWSTR pwzCodeBase = 0, pwzVerInfo = 0;
|
|
CLSID clsid;
|
|
HRESULT hr1;
|
|
|
|
if (!_fReportedClassId && _pwzStrClsId && _pProtSnk)
|
|
{
|
|
_fReportedClassId = TRUE;
|
|
_pProtSnk->ReportProgress(BINDSTATUS_CLASSIDAVAILABLE, _pwzStrClsId);
|
|
}
|
|
|
|
if (IsHandlerAvailable((_pwzFileName) ? _pwzFileName : _pwzUrl, _pwzMimeSuggested, &clsid, _pBuffer, _cbBufferFilled) == S_OK)
|
|
{
|
|
_fGotHandler = TRUE;
|
|
}
|
|
else if (_fDocFile)
|
|
{
|
|
// try get code base + version information
|
|
// even if handler is installed, a newer version may be required for this doc file
|
|
|
|
hr1 = GetCodeBaseFromDocFile(_pBuffer, _cbBufferFilled, &pwzCodeBase, _pwzUrl, &dwVersionMS, &dwVersionLS);
|
|
|
|
// convert version info. to string
|
|
if (SUCCEEDED(hr1) && (dwVersionMS || dwVersionLS))
|
|
{
|
|
CHAR szVerInfo[MAX_PATH];
|
|
|
|
wsprintfA(szVerInfo,"%ld,%ld", dwVersionMS, dwVersionLS);
|
|
pwzVerInfo = DupA2W(szVerInfo);
|
|
}
|
|
|
|
// if failed to get codebase, keep sniffing
|
|
// if we are at end of bits then go with out a code base
|
|
|
|
_fNeedMoreData = FAILED(hr1) && (_cbBufferFilled < _cbDataSniffMin) && (!fEndOfData);
|
|
}
|
|
|
|
//BUGBUG #51944: This currently requires a DocFile and CodeBase property
|
|
|
|
if (!_fNeedMoreData && !_fGotHandler && _fDocFile && pwzCodeBase)
|
|
{
|
|
LPOLESTR pwzClsId = 0;
|
|
|
|
if (!IsEqualCLSID(clsid, CLSID_NULL))
|
|
{
|
|
StringFromCLSID(clsid, &pwzClsId);
|
|
}
|
|
else if (_pwzMimeSuggested)
|
|
{
|
|
// this is an optimization, if no CLSID and only this as mime type
|
|
// then we won't find anything in ObjectStore
|
|
if (!StrCmpNIW(_pwzMimeSuggested, L"application/octet-stream", 24))
|
|
{
|
|
_fGotHandler = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!_fGotHandler && (pwzClsId || _pwzMimeSuggested))
|
|
{
|
|
LPWSTR pwzClassStr = 0;
|
|
int cbClassStr;
|
|
|
|
cbClassStr = (pwzCodeBase ? lstrlenW(pwzCodeBase) : 0)
|
|
+ (pwzClsId ? lstrlenW(pwzClsId) : 0)
|
|
+ (_pwzMimeSuggested ? lstrlenW(_pwzMimeSuggested) : 0)
|
|
+ (pwzVerInfo ? (lstrlenW(pwzVerInfo) + 1) : 0)
|
|
+ 3;
|
|
|
|
pwzClassStr = new WCHAR[cbClassStr];
|
|
|
|
if (pwzClassStr)
|
|
{
|
|
//BUGBUG: This is a bit of a hack, we have a collection of
|
|
//info to pass into filter, we concatenate it into one long
|
|
//string and send it in.
|
|
|
|
*pwzClassStr = '\0';
|
|
if (pwzCodeBase && *pwzCodeBase)
|
|
{
|
|
StrCpyW(pwzClassStr, pwzCodeBase);
|
|
}
|
|
|
|
StrCatW(pwzClassStr, L"?");
|
|
|
|
if (pwzClsId)
|
|
{
|
|
StrCatW(pwzClassStr, pwzClsId);
|
|
}
|
|
else if (_pwzMimeSuggested)
|
|
{
|
|
StrCatW(pwzClassStr, _pwzMimeSuggested);
|
|
}
|
|
|
|
if (pwzVerInfo)
|
|
{
|
|
StrCatW(pwzClassStr, L"?");
|
|
StrCatW(pwzClassStr, pwzVerInfo);
|
|
}
|
|
|
|
_pCTrans->ReportProgress(BINDSTATUS_CLASSINSTALLLOCATION,
|
|
pwzClassStr);
|
|
|
|
delete [] pwzClassStr;
|
|
|
|
// don't process this code branch again
|
|
_fGotHandler = TRUE;
|
|
|
|
// wait on more data now
|
|
hr = S_NEEDMOREDATA;
|
|
|
|
// wait on more data for future calls
|
|
_fWaitOnHandler = TRUE;
|
|
|
|
// wait for more data to sniff
|
|
_fNeedMoreData = TRUE;
|
|
|
|
}
|
|
|
|
delete [] pwzClsId;
|
|
|
|
} // pwzClsId || _pwzMimeSuggested
|
|
} // !_fNeedMoreData
|
|
|
|
if (pwzCodeBase)
|
|
{
|
|
CoTaskMemFree(pwzCodeBase);
|
|
}
|
|
|
|
if (pwzVerInfo)
|
|
{
|
|
delete [] pwzVerInfo;
|
|
}
|
|
|
|
// if we don't need to sniff any more, curb _cbDataSniffMin
|
|
if (_fDocFile && _fGotHandler)
|
|
{
|
|
_cbDataSniffMin = (*pdwTotalSize && *pdwTotalSize < DATASNIFSIZEDOCFILE_MIN) ? *pdwTotalSize : DATASNIFSIZEDOCFILE_MIN;
|
|
}
|
|
|
|
// once we have a handler we can release pwzUrl & pwzFilename
|
|
if (_fGotHandler)
|
|
{
|
|
delete [] _pwzUrl;
|
|
_pwzUrl = 0;
|
|
delete [] _pwzFileName;
|
|
_pwzFileName = 0;
|
|
}
|
|
|
|
// report the data we have in the buffer or
|
|
// the available #
|
|
*pcbBytesAvailable = (*pcbBytesAvailable > _cbTotalBytesRead) ? *pcbBytesAvailable : _cbTotalBytesRead + 1;
|
|
} // PI_CLASSINSTALL && !_fGotHandler
|
|
|
|
if (*pdwTotalSize && (*pdwTotalSize < *pcbBytesAvailable))
|
|
{
|
|
*pcbBytesAvailable = *pdwTotalSize;
|
|
}
|
|
|
|
if (hr == S_FALSE)
|
|
{
|
|
hr = NOERROR;
|
|
}
|
|
}
|
|
|
|
{
|
|
CLock lck(_mxs);
|
|
_cbBytesReported = *pcbBytesAvailable;
|
|
}
|
|
//TransAssert((pcbBytesAvailable && *pcbBytesAvailable));
|
|
//TransAssert((hr == NOERROR || hr == S_NEEDMOREDATA));
|
|
|
|
PerfDbgLog2(tagCTransaction, this, "-COInetProt::OnDataReceived (hr:%lx, _cbBufferFilled:%ld)", hr, _cbBufferFilled);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Switch
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pStateInfo] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Switch(PROTOCOLDATA *pStateInfo)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolSink::Switch",
|
|
"this=%#x, %#x",
|
|
this, pStateInfo
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::Switch");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProtSnk->Switch(pStateInfo);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::Switch (hr:%lx)", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::ReportProgress
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [NotMsg] --
|
|
// [szStatusText] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::ReportProgress(ULONG NotMsg, LPCWSTR pwzStatusText)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolSink::ReportProgress",
|
|
"this=%#x, %#x, %.80wq",
|
|
this, NotMsg, pwzStatusText
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::ReportProgress");
|
|
HRESULT hr = NOERROR;
|
|
|
|
switch (NotMsg)
|
|
{
|
|
case BINDSTATUS_FILTERREPORTMIMETYPE:
|
|
{
|
|
if( _pCTrans && pwzStatusText )
|
|
{
|
|
// mime filter sending signal to tell us the true mime type
|
|
_pCTrans->UpdateVerifiedMimeType(pwzStatusText);
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
|
|
case BINDSTATUS_MIMETYPEAVAILABLE:
|
|
if (_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP | PI_CLASSINSTALL))
|
|
{
|
|
// report the mime later after sniffing data
|
|
_pwzMimeSuggested = OLESTRDuplicate(pwzStatusText);
|
|
}
|
|
else
|
|
{
|
|
hr = _pProtSnk->ReportProgress(NotMsg, pwzStatusText);
|
|
}
|
|
|
|
break;
|
|
|
|
case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
|
|
{
|
|
// disable mime sniffing
|
|
_dwOInetBdgFlags &= (~PI_MIMEVERIFICATION &~PI_DOCFILECLSIDLOOKUP &~PI_CLASSINSTALL);
|
|
hr = _pProtSnk->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, pwzStatusText);
|
|
|
|
}
|
|
break;
|
|
|
|
case BINDSTATUS_CACHEFILENAMEAVAILABLE :
|
|
_pwzFileName = OLESTRDuplicate(pwzStatusText);
|
|
hr = _pProtSnk->ReportProgress(NotMsg, pwzStatusText);
|
|
break;
|
|
|
|
case BINDSTATUS_DIRECTBIND:
|
|
_fMimeVerified = TRUE;
|
|
break;
|
|
|
|
case BINDSTATUS_ENDDOWNLOADCOMPONENTS :
|
|
if (_fWaitOnHandler)
|
|
{
|
|
// don't stall ReportData any more
|
|
_fWaitOnHandler = FALSE;
|
|
|
|
// we're done with our stuff, skip sniffing
|
|
_fNeedMoreData = FALSE;
|
|
|
|
}
|
|
|
|
|
|
default:
|
|
{
|
|
hr = _pProtSnk->ReportProgress(NotMsg, pwzStatusText);
|
|
}
|
|
|
|
} // end switch
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::ReportProgress (hr:%lx)", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::ReportData
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [grfBSCF] --
|
|
// [ULONG] --
|
|
// [ulProgressMax] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::ReportData(DWORD grfBSCF, ULONG ulProgress,ULONG ulProgressMax)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolSink::ReportData",
|
|
"this=%#x, %#x, %#x, %#x",
|
|
this, grfBSCF, ulProgress, ulProgressMax
|
|
));
|
|
|
|
PerfDbgLog3(tagCTransaction, this, "+COInetProt::ReportData(grfBSCF:%lx, ulProgress:%ld, ulProgressMax:%ld)",
|
|
grfBSCF, ulProgress, ulProgressMax);
|
|
HRESULT hr = NOERROR, hr2;
|
|
|
|
TransAssert((ulProgress));
|
|
|
|
if ( ((_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP | PI_CLASSINSTALL))
|
|
&& (!_fMimeVerified || _fNeedMoreData))
|
|
||
|
|
((_dwOInetBdgFlags & PI_CLASSINSTALL) && !_fClassInstallChecked)
|
|
)
|
|
{
|
|
if ( (OnDataReceived(&grfBSCF, &ulProgress, &ulProgressMax) == NOERROR)
|
|
&& _pProtSnk
|
|
&& (ulProgress || (!ulProgress && !ulProgressMax)) )
|
|
{
|
|
// OnDataReceived sniffs data and calls Read - EOF with ReportResult might occure
|
|
//TransAssert((ulProgress));
|
|
TransAssert((_fMimeReported));
|
|
hr = _pProtSnk->ReportData( grfBSCF, ulProgress, ulProgressMax);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TransAssert((ulProgress));
|
|
hr = _pProtSnk->ReportData( grfBSCF, ulProgress, ulProgressMax);
|
|
}
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::ReportData (hr:%lx)", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::ReportResult
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [DWORD] --
|
|
// [dwError] --
|
|
// [wzResult] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::ReportResult(HRESULT hrResult, DWORD dwError, LPCWSTR wzResult)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetProtocolSink::ReportResult",
|
|
"this=%#x, %#x, %#x, %.80wq",
|
|
this, hrResult, dwError, wzResult
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::ReportResult");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProtSnk->ReportResult(hrResult, dwError, wzResult);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::ReportResult (hr:%lx)", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::Initialize
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pCTrans] --
|
|
// [dwMode] --
|
|
// [dwOptions] --
|
|
// [pUnk] --
|
|
// [pProt] --
|
|
// [pProtSnk] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP COInetProt::Initialize(CTransaction *pCTrans,IServiceProvider *pSrvPrv, DWORD dwMode, DWORD dwOptions,
|
|
IUnknown *pUnk, IOInetProtocol *pProt, IOInetProtocolSink *pProtSnk, LPWSTR pwzUrl)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::Initialize",
|
|
"this=%#x, %#x, %#x, %#x, %#x, %#x, %#x, %#x, %.80wq",
|
|
this, pCTrans, pSrvPrv, dwMode, dwOptions, pUnk, pProt, pProtSnk, pwzUrl
|
|
));
|
|
|
|
HRESULT hr = NOERROR;
|
|
_dwMode = dwMode;
|
|
_pUnk = pUnk;
|
|
//_pProt = pProt;
|
|
//_pProtSnk = pProtSnk;
|
|
_pCTrans = pCTrans;
|
|
_pSrvPrv = pSrvPrv;
|
|
if (_pSrvPrv)
|
|
{
|
|
_pSrvPrv->AddRef();
|
|
}
|
|
SetProtocolSink(pProtSnk);
|
|
SetProtocol(pProt);
|
|
|
|
_dwOInetBdgFlags = dwOptions;
|
|
if (_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP))
|
|
{
|
|
ULONG cbBufferSize;
|
|
|
|
TransAssert(( DATASNIFSIZE_MIN <= DATASNIFSIZEDOCFILE_MIN));
|
|
|
|
if (_dwOInetBdgFlags & PI_CLASSINSTALL)
|
|
{
|
|
cbBufferSize = DATASNIFSIZEDOCFILE_MAX;
|
|
}
|
|
else
|
|
{
|
|
cbBufferSize = DATASNIFSIZEDOCFILE_MIN; //DATASNIFSIZE_MIN;
|
|
}
|
|
|
|
if (cbBufferSize != _cbBufferSize)
|
|
{
|
|
_cbBufferSize = cbBufferSize;
|
|
delete [] _pBuffer;
|
|
_pBuffer = (LPBYTE) new BYTE[_cbBufferSize];
|
|
}
|
|
|
|
if (!_pBuffer)
|
|
{
|
|
_cbBufferSize = 0;
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
_cbDataSniffMin = DATASNIFSIZE_MIN;
|
|
}
|
|
|
|
if (pwzUrl)
|
|
{
|
|
delete [] _pwzUrl;
|
|
_pwzUrl = OLESTRDuplicate(pwzUrl);
|
|
}
|
|
|
|
}
|
|
TransAssert((_pProt && _pProtSnk));
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: COInetProt::QueryService
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [rsid] --
|
|
// [riid] --
|
|
// [ppvObj] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT IUnknown_QueryService(IUnknown* punk, REFGUID rsid, REFIID riid, void ** ppvObj);
|
|
|
|
HRESULT COInetProt::QueryService(REFGUID rsid, REFIID riid, void ** ppvObj)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IServiceProvider::QueryService",
|
|
"this=%#x, %#x, %#x, %#x",
|
|
this, &rsid, &riid, ppvObj
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::QueryService");
|
|
HRESULT hr = NOERROR;
|
|
VDATETHIS(this);
|
|
TransAssert((ppvObj));
|
|
|
|
if (_pSrvPrv)
|
|
{
|
|
hr = _pSrvPrv->QueryService(rsid,riid, ppvObj);
|
|
}
|
|
else
|
|
{
|
|
hr = IUnknown_QueryService(_pProtSnk, rsid, riid, ppvObj);
|
|
}
|
|
|
|
TransAssert(( ((hr == E_NOINTERFACE) && !*ppvObj) || ((hr == NOERROR) && *ppvObj) ));
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::QueryService (hr:%lx)", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP COInetProt::SetPriority(LONG nPriority)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetPriority::SetPriority",
|
|
"this=%#x, %#x",
|
|
this, nPriority
|
|
));
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "+COInetProt::SetPriority (%ld)", nPriority);
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
_nPriority = nPriority;
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::SetPriority (hr:%lx)", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP COInetProt::GetPriority(LONG * pnPriority)
|
|
{
|
|
DEBUG_ENTER((DBG_TRANS,
|
|
Hresult,
|
|
"COInetProt::IInternetPriority::GetPriority",
|
|
"this=%#x, %#x",
|
|
this, pnPriority
|
|
));
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+COInetProt::GetPriority");
|
|
|
|
HRESULT hr;
|
|
|
|
if (!pnPriority)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
*pnPriority = _nPriority;
|
|
hr = S_OK;
|
|
}
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-COInetProt::GetPriority (hr:%lx)", hr);
|
|
|
|
DEBUG_LEAVE(hr);
|
|
return hr;
|
|
}
|