OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/inetcore/urlmon/trans/prothndl.cxx

1635 lines
46 KiB
C++
Raw Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
//+---------------------------------------------------------------------------
//
// 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;
}
Copy Permalink