845 lines
24 KiB
C++
845 lines
24 KiB
C++
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1995.
|
|
//
|
|
// File: mimehndl.cxx
|
|
//
|
|
// Contents: Class that performs the download of a particular request.
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 12-04-95 JohannP (Johann Posch) Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#include <eapp.h>
|
|
|
|
|
|
PerfDbgTag(tagCTransaction, "Urlmon", "Log CTransaction", DEB_TRANS)
|
|
DbgTag(tagCTransactionErr, "Urlmon", "Log CTransaction Errors", DEB_TRANS|DEB_ERROR)
|
|
|
|
typedef struct _tagPROTOCOLFILTERDATA
|
|
{
|
|
DWORD cbSize;
|
|
IOInetProtocolSink *pProtocolSink; // out parameter
|
|
IOInetProtocol *pProtocol; // in parameter
|
|
IUnknown *pUnk;
|
|
DWORD dwFilterFlags;
|
|
} PROTOCOLFILTERDATA;
|
|
|
|
|
|
CMimeHandlerTest1::CMimeHandlerTest1(REFCLSID rclsid, IUnknown *pUnkOuter, IUnknown **ppUnkInner) : CBaseProtocol(rclsid, pUnkOuter, ppUnkInner)
|
|
{
|
|
_pUnk = 0;
|
|
_pProt = 0;
|
|
_pProtSnk = 0;
|
|
_dwMode = 0;
|
|
_dwOInetBdgFlags = 0;
|
|
_pBuffer = 0; // DNLD_BUFFER_SIZE size buffer
|
|
_cbBufferSize = 0;
|
|
_cbTotalBytesRead = 0;
|
|
_cbBufferFilled = 0; //how much of the buffer is in use
|
|
_cbDataSniffMin = 0;
|
|
_cbBytesReported = 0;
|
|
_fDocFile = 0;
|
|
_fMimeVerified = 0;
|
|
_pwzFileName = 0;
|
|
_pwzMimeSuggested = 0;
|
|
_fDelete = 0;
|
|
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::QueryInterface
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [riid] --
|
|
// [ppvObj] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
VDATEPTROUT(ppvObj, void *);
|
|
VDATETHIS(this);
|
|
HRESULT hr = NOERROR;
|
|
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::QueryInterface");
|
|
|
|
*ppvObj = NULL;
|
|
|
|
{
|
|
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, "-CMimeHandlerTest1::QueryInterface (hr:%lx)", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CMimeHandlerTest1::AddRef
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [ULONG] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CMimeHandlerTest1::AddRef(void)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::AddRef");
|
|
|
|
LONG lRet;
|
|
|
|
{
|
|
lRet = ++_CRefs;
|
|
}
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::AddRef (cRefs:%ld)", lRet);
|
|
return lRet;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CMimeHandlerTest1::Release
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [ULONG] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CMimeHandlerTest1::Release(void)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Release");
|
|
|
|
LONG lRet;
|
|
{
|
|
lRet = --_CRefs;
|
|
if (_CRefs == 0 && _fDelete)
|
|
{
|
|
delete this;
|
|
}
|
|
}
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::Release (cRefs:%ld)", lRet);
|
|
return lRet;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::Start
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pwzUrl] --
|
|
// [pTrans] --
|
|
// [pOIBindInfo] --
|
|
// [grfSTI] --
|
|
// [dwReserved] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::Start(LPCWSTR pwzUrl, IOInetProtocolSink *pOInetProtSnk, IOInetBindInfo *pOIBindInfo,
|
|
DWORD grfSTI, DWORD dwReserved)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Start\n");
|
|
HRESULT hr = NOERROR;
|
|
PROTOCOLFILTERDATA *pFilterData = 0;
|
|
|
|
TransAssert((pOIBindInfo && pOInetProtSnk));
|
|
if (dwReserved)
|
|
{
|
|
pFilterData = (PROTOCOLFILTERDATA *)dwReserved;
|
|
}
|
|
if (pFilterData && pOInetProtSnk)
|
|
{
|
|
TransAssert((pOIBindInfo && pOInetProtSnk));
|
|
_pProt = pFilterData->pProtocol;
|
|
if (_pProt)
|
|
{
|
|
_pProt->AddRef();
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
_pProtSnk = pOInetProtSnk;
|
|
_pProtSnk->AddRef();
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "+CMimeHandlerTest1::Start (hr:%lx)\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::Continue
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pStateInfoIn] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::Continue(PROTOCOLDATA *pStateInfoIn)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Continue\n");
|
|
|
|
HRESULT hr = _pProt->Continue(pStateInfoIn);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::Continue (hr:%lx)\n",hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::Abort
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [hrReason] --
|
|
// [dwOptions] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-09-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::Abort(HRESULT hrReason, DWORD dwOptions)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Abort\n");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProt->Abort(hrReason, dwOptions);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::Abort (hr:%lx)\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::Terminate
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [dwOptions] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::Terminate(DWORD dwOptions)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Terminate\n");
|
|
HRESULT hr = NOERROR;
|
|
|
|
TransAssert((_pProt));
|
|
//IOInetProtocol *pProt = _pProt;
|
|
|
|
hr = _pProt->Terminate(dwOptions);
|
|
//pProt->Release();
|
|
//_pProt = 0;
|
|
|
|
_pProtSnk->Release();
|
|
_pProtSnk = 0;
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::Terminate (hr:%lx)\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::Suspend
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::Suspend()
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Suspend\n");
|
|
|
|
HRESULT hr = _pProt->Suspend();
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::Suspend (hr:%lx)\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::Resume
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::Resume()
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Resume\n");
|
|
|
|
HRESULT hr = _pProt->Resume();
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::Resume (hr:%lx)\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::Read
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [ULONG] --
|
|
// [ULONG] --
|
|
// [pcbRead] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::Read(void *pBuffer, ULONG cbBuffer,ULONG *pcbRead)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Read\n");
|
|
HRESULT hr = E_FAIL;
|
|
|
|
BOOL fRead = TRUE;
|
|
DWORD dwCopy = 0;
|
|
DWORD dwCopyNew = 0;
|
|
|
|
if ( (_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP))
|
|
&& (_cbBufferFilled))
|
|
{
|
|
fRead = FALSE;
|
|
|
|
// copy data form the local buffer to the provide buffer
|
|
if (cbBuffer < _cbBufferFilled)
|
|
{
|
|
dwCopy = cbBuffer;
|
|
memcpy(pBuffer, _pBuffer, cbBuffer);
|
|
// move the memory to the front
|
|
memcpy(_pBuffer, _pBuffer + cbBuffer, _cbBufferFilled - cbBuffer);
|
|
_cbBufferFilled -= cbBuffer;
|
|
hr = S_OK;
|
|
}
|
|
else if (cbBuffer == _cbBufferFilled)
|
|
{
|
|
dwCopy = _cbBufferFilled;
|
|
memcpy(pBuffer, _pBuffer, _cbBufferFilled);
|
|
_cbBufferFilled = 0;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// user buffer is greater than what is available in
|
|
//
|
|
dwCopy = _cbBufferFilled;
|
|
memcpy(pBuffer, _pBuffer, _cbBufferFilled);
|
|
_cbBufferFilled = 0;
|
|
fRead = TRUE;
|
|
hr = E_PENDING;
|
|
}
|
|
}
|
|
|
|
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, "-CMimeHandlerTest1::Read (hr:%lx)\n",hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::Seek
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [DWORD] --
|
|
// [ULARGE_INTEGER] --
|
|
// [plibNewPosition] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::Seek(LARGE_INTEGER dlibMove,DWORD dwOrigin,ULARGE_INTEGER *plibNewPosition)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Seek\n");
|
|
|
|
HRESULT hr = _pProt->Seek(dlibMove, dwOrigin, plibNewPosition);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::Seek (hr:%lx)\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::LockRequest
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [dwOptions] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::LockRequest(DWORD dwOptions)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::LockRequest\n");
|
|
|
|
HRESULT hr = hr = _pProt->LockRequest(dwOptions);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::LockRequest (hr:%lx)\n",hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::UnlockRequest
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 10-29-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::UnlockRequest()
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::UnlockRequest\n");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProt->UnlockRequest();
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::UnlockRequest (hr:%lx)\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CTransaction::OnDataReceived
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [grfBSC] --
|
|
// [cbBytesAvailable] --
|
|
// [dwTotalSize] --
|
|
// [pcbNewAvailable] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 4-15-1997 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#if 0
|
|
STDMETHODIMP CMimeHandlerTest1::OnDataReceived(DWORD *pgrfBSC, DWORD *pcbBytesAvailable, DWORD *pdwTotalSize) //, DWORD *pcbNewAvailable)
|
|
{
|
|
PerfDbgLog3(tagCTransaction, this, "+CMimeHandlerTest1::OnDataReceived (grfBSC:%lx, cbBytesAvailable:%ld, _cbTotalBytesRead:%ld)",
|
|
*pgrfBSC, *pcbBytesAvailable, _cbTotalBytesRead);
|
|
HRESULT hr = NOERROR;
|
|
DWORD grfBSC = *pgrfBSC;
|
|
DWORD cbBytesAvailable = *pcbBytesAvailable;
|
|
DWORD dwTotalSize = *pdwTotalSize;
|
|
DWORD *pcbNewAvailable = &cbBytesAvailable;
|
|
|
|
*pcbNewAvailable = cbBytesAvailable;
|
|
|
|
if (_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP))
|
|
{
|
|
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
|
|
do
|
|
{
|
|
hr = _pProt->Read(_pBuffer + _cbBufferFilled, _cbBufferSize - _cbBufferFilled, &dwNewData);
|
|
_cbTotalBytesRead += dwNewData;
|
|
_cbBufferFilled += dwNewData;
|
|
} while ((hr == S_OK) && (_cbTotalBytesRead < _cbDataSniffMin));
|
|
|
|
// now check if this is docfile
|
|
// if so download at least 2k
|
|
if (!_fDocFile && _cbBufferFilled && (IsDocFile(_pBuffer, _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;
|
|
}
|
|
else if (hr == S_FALSE)
|
|
{
|
|
// end of stream
|
|
*pgrfBSC |= (BSCF_LASTDATANOTIFICATION & BSCF_DATAFULLYAVAILABLE);
|
|
*pcbBytesAvailable = *pdwTotalSize = _cbTotalBytesRead;
|
|
}
|
|
|
|
if ( (!_fMimeVerified)
|
|
&& ( (*pcbNewAvailable >= _cbDataSniffMin)
|
|
|| (hr == S_FALSE)) )
|
|
{
|
|
// enough data or end of stream
|
|
_fMimeVerified = TRUE;
|
|
LPCWSTR pwzStr = FindMimeFromDataIntern(_pwzFileName,_pBuffer, _cbBufferFilled, _pwzMimeSuggested, 0);
|
|
_pProtSnk->ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE, pwzStr);
|
|
|
|
if (_pwzMimeSuggested != pwzStr)
|
|
{
|
|
if (_pwzMimeSuggested)
|
|
{
|
|
delete [] _pwzMimeSuggested;
|
|
}
|
|
if (pwzStr)
|
|
{
|
|
_pwzMimeSuggested = OLESTRDuplicate((LPWSTR)pwzStr);
|
|
}
|
|
}
|
|
|
|
if ( _fDocFile
|
|
&& (_dwOInetBdgFlags & PI_DOCFILECLSIDLOOKUP))
|
|
{
|
|
// find the class id and send it on
|
|
CLSID clsid;
|
|
|
|
HRESULT hr1 = GetClassDocFileBuffer(_pBuffer, _cbBufferFilled, &clsid);
|
|
if (hr1 == NOERROR)
|
|
{
|
|
LPOLESTR pwzStrClsId;
|
|
StringFromCLSID(clsid, &pwzStrClsId);
|
|
_pProtSnk->ReportProgress(BINDSTATUS_CLASSIDAVAILABLE, pwzStrClsId);
|
|
|
|
delete [] pwzStrClsId;
|
|
}
|
|
}
|
|
}
|
|
hr = NOERROR;
|
|
}
|
|
//TransAssert((cbBytesAvailable <= *pcbNewAvailable));
|
|
if (cbBytesAvailable > *pcbNewAvailable)
|
|
{
|
|
*pcbNewAvailable = cbBytesAvailable;
|
|
}
|
|
if (dwTotalSize && (dwTotalSize < *pcbNewAvailable))
|
|
{
|
|
*pcbNewAvailable = dwTotalSize;
|
|
}
|
|
}
|
|
|
|
{
|
|
CLock lck(_mxs);
|
|
_cbBytesReported = *pcbNewAvailable;
|
|
*pdwTotalSize = dwTotalSize;
|
|
}
|
|
|
|
|
|
PerfDbgLog2(tagCTransaction, this, "-CMimeHandlerTest1::OnDataReceived (hr:%lx, _cbBufferFilled:%lx)", hr, _cbBufferFilled);
|
|
return hr;
|
|
}
|
|
#endif // 0
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::Switch
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pStateInfo] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::Switch(PROTOCOLDATA *pStateInfo)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::Switch");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProtSnk->Switch(pStateInfo);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::Switch (hr:%lx)", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::ReportProgress
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [NotMsg] --
|
|
// [szStatusText] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::ReportProgress(ULONG NotMsg, LPCWSTR pwzStatusText)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::ReportProgress");
|
|
HRESULT hr = NOERROR;
|
|
|
|
switch (NotMsg)
|
|
{
|
|
case BINDSTATUS_MIMETYPEAVAILABLE:
|
|
if (_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP))
|
|
{
|
|
// report the mime later after sniffing data
|
|
_pwzMimeSuggested = OLESTRDuplicate(pwzStatusText);
|
|
}
|
|
else
|
|
{
|
|
hr = _pProtSnk->ReportProgress(NotMsg, pwzStatusText);
|
|
}
|
|
|
|
break;
|
|
|
|
case BINDSTATUS_CACHEFILENAMEAVAILABLE :
|
|
_pwzFileName = OLESTRDuplicate(pwzStatusText);
|
|
|
|
default:
|
|
{
|
|
hr = _pProtSnk->ReportProgress(NotMsg, pwzStatusText);
|
|
|
|
}
|
|
|
|
} // end switch
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::ReportProgress (hr:%lx)", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::ReportData
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [grfBSCF] --
|
|
// [ULONG] --
|
|
// [ulProgressMax] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::ReportData(DWORD grfBSCF, ULONG ulProgress,ULONG ulProgressMax)
|
|
{
|
|
PerfDbgLog3(tagCTransaction, this, "+CMimeHandlerTest1::ReportData(grfBSCF:%lx, ulProgress:%ld, ulProgressMax:%ld)",
|
|
grfBSCF, ulProgress, ulProgressMax);
|
|
HRESULT hr = NOERROR;
|
|
/*
|
|
if ( (_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP)
|
|
&& (OnDataReceived(&grfBSCF, &ulProgress, &ulProgressMax) == NOERROR)) )
|
|
{
|
|
hr = _pProtSnk->ReportData( grfBSCF, ulProgress, ulProgressMax);
|
|
}
|
|
else
|
|
*/
|
|
{
|
|
hr = _pProtSnk->ReportData( grfBSCF, ulProgress, ulProgressMax);
|
|
}
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::ReportData (hr:%lx)", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CMimeHandlerTest1::ReportResult
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [DWORD] --
|
|
// [dwError] --
|
|
// [wzResult] --
|
|
//
|
|
// Returns:
|
|
//
|
|
// History: 11-07-1996 JohannP (Johann Posch) Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CMimeHandlerTest1::ReportResult(HRESULT hrResult, DWORD dwError, LPCWSTR wzResult)
|
|
{
|
|
PerfDbgLog(tagCTransaction, this, "+CMimeHandlerTest1::ReportResult");
|
|
HRESULT hr = NOERROR;
|
|
|
|
hr = _pProtSnk->ReportResult(hrResult, dwError, wzResult);
|
|
|
|
PerfDbgLog1(tagCTransaction, this, "-CMimeHandlerTest1::ReportResult (hr:%lx)", hr);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CMimeHandlerTest1::Initialize(DWORD dwMode, DWORD dwOptions, IUnknown *pUnk, IOInetProtocol *pProt, IOInetProtocolSink *pProtSnk)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
_dwMode = dwMode;
|
|
_pUnk = pUnk;
|
|
_pProt = pProt;
|
|
_pProtSnk = pProtSnk;
|
|
if (_pProtSnk)
|
|
{
|
|
_pProtSnk->AddRef();
|
|
}
|
|
if (_pUnk)
|
|
{
|
|
_pUnk->AddRef();
|
|
}
|
|
|
|
_dwOInetBdgFlags = dwOptions;
|
|
if (_dwOInetBdgFlags & (PI_MIMEVERIFICATION | PI_DOCFILECLSIDLOOKUP))
|
|
{
|
|
_cbBufferSize = DATASNIFSIZEDOCFILE_MIN;
|
|
_pBuffer = (LPBYTE) new BYTE[_cbBufferSize];
|
|
|
|
if (!_pBuffer)
|
|
{
|
|
_cbBufferSize = 0;
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
_cbDataSniffMin = _cbBufferSize;
|
|
}
|
|
TransAssert((_pUnk && _pProt && _pProtSnk));
|
|
return hr;
|
|
}
|
|
|