Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

740 lines
19 KiB

//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1995.
//
// File: CCodeFt.cxx
//
// Contents:
//
// Classes:
//
// Functions:
//
// History: 04-29-97 DanpoZ (Danpo Zhang) Created
//
//----------------------------------------------------------------------------
#include <eapp.h>
PerfDbgTag(tagDft, "Pluggable MF", "Log CDataFt", DEB_PROT)
DbgTag(tagDftErr, "Pluggable MF", "Log CDataFtErrors", DEB_PROT|DEB_ERROR)
#define SZDFILTERROOT "PROTOCOLS\\Filter\\Data Filter\\"
//+---------------------------------------------------------------------------
//
// Method: CStdZFilter::QueryInterface
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 06-26-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CStdZFilter::QueryInterface(REFIID riid, void **ppvObj)
{
PerfDbgLog(tagDft, this, "+CStdFilter::QueryInterface");
VDATEPTROUT(ppvObj, void*);
VDATETHIS(this);
HRESULT hr = NOERROR;
if( riid == IID_IUnknown ||
riid == IID_IDataFilter )
{
*ppvObj = this;
AddRef();
}
else
hr = E_NOINTERFACE;
PerfDbgLog1(
tagDft, this, "-CStdZFilter::QueryInterface(hr:%1x)", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CStdZFilter::AddRef
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 06-26-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG)
CStdZFilter::AddRef()
{
PerfDbgLog(tagDft, this, "+CStdZFilter::AddRef");
LONG lRet = ++_CRefs;
DllAddRef();
PerfDbgLog1(tagDft, this, "-CStdZFilter::AddRef(cRef:%1d)", lRet);
return lRet;
}
//+---------------------------------------------------------------------------
//
// Method: CStdZFilter::Release
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 06-26-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG)
CStdZFilter::Release()
{
PerfDbgLog(tagDft, this, "+CStdZFilter::Release");
LONG lRet = --_CRefs;
if(!lRet)
delete this;
DllRelease();
PerfDbgLog1(tagDft, this, "-CStdZFilter::Release(cRef:%1d)", lRet);
return lRet;
}
//+---------------------------------------------------------------------------
//
// Method: CStdZFilter::DoEncode
//
// Synopsis:
//
// Arguments: [dwFlags] - flags
// [lInBufferSize] - Input Buffer Size
// [pbInBuffer] - Input Buffer
// [lOutBufferSize] - Output Buffer Size
// [pbOutBuffer] - Output Buffer
// [lInBytesAvailable] - Data available in Input Buffer
// [plInBytesRead] - Total data read from input buffer
// [plOutBytesWritten] - Total data written to output buffer
// [dwReserved] - currently not used
//
// Returns: NOERROR or E_FAIL
//
// History: 06-27-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CStdZFilter::DoEncode(
DWORD dwFlags,
LONG lInBufferSize,
BYTE* pbInBuffer,
LONG lOutBufferSize,
BYTE* pbOutBuffer,
LONG lInBytesAvailable,
LONG* plInBytesRead,
LONG* plOutBytesWritten,
DWORD dwReserved
)
{
PerfDbgLog(tagDft, this, "+CStdZFilter::DoEncode");
HRESULT hr = NOERROR;
if( !_pEncodeCtx )
hr = CreateCompression(&_pEncodeCtx, _ulSchema);
if( _pEncodeCtx && !FAILED(hr) )
{
PProtAssert( pbInBuffer && pbOutBuffer &&
plInBytesRead && plOutBytesWritten);
hr = Compress(
_pEncodeCtx,
pbInBuffer,
lInBytesAvailable,
pbOutBuffer,
lOutBufferSize,
plInBytesRead,
plOutBytesWritten,
_cEncLevel
);
}
PerfDbgLog1(tagDft, this, "-CStdZFilter::DoEncode(hr:%1x)", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CStdZFilter::DoDecode
//
// Synopsis:
//
// Arguments: [dwFlags] - flags
// [lInBufferSize] - Input Buffer Size
// [pbInBuffer] - Input Buffer
// [lOutBufferSize] - Output Buffer Size
// [pbOutBuffer] - Output Buffer
// [lInBytesAvailable] - Data available in Input Buffer
// [plInBytesRead] - Total data read from input buffer
// [plOutBytesWritten] - Total data written to output buffer
// [dwReserved] - reserved
//
// Returns: NOERROR or E_FAIL
//
// History: 06-27-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CStdZFilter::DoDecode(
DWORD dwFlags,
LONG lInBufferSize,
BYTE* pbInBuffer,
LONG lOutBufferSize,
BYTE* pbOutBuffer,
LONG lInBytesAvailable,
LONG* plInBytesRead,
LONG* plOutBytesWritten,
DWORD dwReserved
)
{
PerfDbgLog(tagDft, this, "+CStdZFilter::DoDecode");
HRESULT hr = NOERROR;
if( !_pDecodeCtx )
hr = CreateDecompression(&_pDecodeCtx, _ulSchema);
if( _pDecodeCtx && !FAILED(hr) )
{
PProtAssert( pbInBuffer && pbOutBuffer &&
plInBytesRead && plOutBytesWritten);
hr = Decompress(
_pDecodeCtx,
pbInBuffer,
lInBytesAvailable,
pbOutBuffer,
lOutBufferSize,
plInBytesRead,
plOutBytesWritten
);
}
PerfDbgLog1(tagDft, this, "-CStdZFilter::DoDecode(hr:%1x)", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CStdZFilter::SetEncodingLevel
//
// Synopsis:
//
// Arguments: [cEncLevel] - encoding level (between 1-100)
//
// Returns: NOERROR or E_FAIL
//
// History: 06-27-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CStdZFilter::SetEncodingLevel(DWORD dwEncLevel)
{
PerfDbgLog(tagDft, this, "+CStdZFilter::SetEncodingLevel");
HRESULT hr = NOERROR;
if( dwEncLevel >= 1 && dwEncLevel <= 100 )
{
// input value should be between 1 - 100]
// our formula is _cEncLevel = dwEncLevel * 10 / 100
_cEncLevel = (dwEncLevel * 10) / 100;
if( !_cEncLevel )
++_cEncLevel;
}
else
hr = E_INVALIDARG;
PerfDbgLog1(
tagDft, this, "-CStdZFilter::SetEncodingLevel(hr:%1x)", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CStdZFilter::InitFilter
//
// Synopsis:
//
// Arguments:
//
// Returns: NOERROR or E_FAIL (dll init failed)
//
// History: 06-27-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
HRESULT
CStdZFilter::InitFilter()
{
PerfDbgLog(tagDft, this, "+CStdZFilter::InitFilter");
HRESULT hr = NOERROR;
// init the compressor
if (FAILED(InitCompression()))
hr = E_FAIL;
// init the decompressor
if (FAILED(InitDecompression()))
hr = E_FAIL;
PerfDbgLog(tagDft, this, "-CStdZFilter::InitFilter");
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CStdZFilter::CStdZFilter
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 06-26-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
CStdZFilter::CStdZFilter(ULONG ulSchema)
: _CRefs()
{
PerfDbgLog(tagDft, this, "+CStdZFilter::CStdZFilter");
_pEncodeCtx = NULL;
_pDecodeCtx = NULL;
// accepts the number between 1[fastest] - 10[most compres]
// the formula is _cEncLevel/10 = 50/100
_cEncLevel= 5;
_ulSchema = ulSchema;
PerfDbgLog(tagDft, this, "-CStdZFilter::CStdZFilter");
}
//+---------------------------------------------------------------------------
//
// Method: CStdZFilter::~CStdZFilter
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 06-26-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
CStdZFilter::~CStdZFilter()
{
PerfDbgLog(tagDft, this, "+CStdZFilter::~CStdZFilter");
if( _pEncodeCtx )
DestroyCompression(_pEncodeCtx);
if( _pDecodeCtx )
DestroyDecompression(_pDecodeCtx);
PerfDbgLog(tagDft, this, "-CStdZFilter::~CStdZFilter");
}
//+---------------------------------------------------------------------------
//
// Method: CEncodingFilterFactory::QueryInterface
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 04-29-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CEncodingFilterFactory::QueryInterface(REFIID riid, void **ppvObj)
{
PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::QueryInterface");
VDATEPTROUT(ppvObj, void*);
VDATETHIS(this);
HRESULT hr = NOERROR;
if( riid == IID_IUnknown ||
riid == IID_IEncodingFilterFactory )
{
*ppvObj = this;
AddRef();
}
else
hr = E_NOINTERFACE;
PerfDbgLog1(
tagDft, this, "-CEncodingFilterFactory::QueryInterface(hr:%1x)", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CEncodingFilterFactory::AddRef
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 04-29-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG)
CEncodingFilterFactory::AddRef()
{
PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::AddRef");
LONG lRet = ++_CRefs;
PerfDbgLog1(
tagDft, this, "-CEncodingFilterFactory::AddRef(cRef:%1d)", lRet);
return lRet;
}
//+---------------------------------------------------------------------------
//
// Method: CEncodingFilterFactory::Release
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 04-29-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG)
CEncodingFilterFactory::Release()
{
PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::Release");
LONG lRet = --_CRefs;
if(!lRet)
delete this;
PerfDbgLog1(
tagDft, this, "-CEncodingFilterFactory::Release(cRef:%1d)", lRet);
return lRet;
}
//+---------------------------------------------------------------------------
//
// Method: CEncodingFilterFactory::FindBestFilter
//
// Synopsis:
//
// Arguments: [grfETYPEIn] - input encoding type
// [grfETYPEOut] - output encoding type
// [info] - DATAINFO (what the data looks like)
// [ppDF] - output DataFilter pointer
//
// Returns:
//
// History: 04-29-97 DanpoZ (Danpo Zhang) Created
//
// Notes: currently it calls FindDefaultFilter()
//
//----------------------------------------------------------------------------
STDMETHODIMP
CEncodingFilterFactory::FindBestFilter(
LPCWSTR pwzCodeIn,
LPCWSTR pwzCodeOut,
DATAINFO info,
IDataFilter** ppDF
)
{
PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::FindBestFilter");
HRESULT hr = NOERROR;
hr = GetDefaultFilter(pwzCodeIn, pwzCodeOut, ppDF);
PerfDbgLog1(
tagDft, this, "-CEncodingFilterFactory::FindBestFilter(hr:%1x)", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CEncodingFilterFactory::GetDefaultFilter
//
// Synopsis:
//
// Arguments: [tIn] - input encoding type
// [tOut] - output encoding type
// [ppDF] - output DataFilter pointer
//
// Returns:
//
// History: 04-29-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CEncodingFilterFactory::GetDefaultFilter(
LPCWSTR pwzCodeIn,
LPCWSTR pwzCodeOut,
IDataFilter** ppDF
)
{
PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::GetDefaultFilter");
VDATEPTROUT(ppDF, void*);
*ppDF = NULL;
HRESULT hr = E_FAIL;
BOOL fBuiltIn = FALSE;
if( (!_wcsicmp(pwzCodeIn, L"gzip") && !_wcsicmp(pwzCodeOut, L"text")) ||
(!_wcsicmp(pwzCodeIn, L"text") && !_wcsicmp(pwzCodeOut, L"gzip") ) )
{
// GZIP
*ppDF = new CStdZFilter(COMPRESSION_FLAG_GZIP);
fBuiltIn = TRUE;
if( !(*ppDF) )
{
hr = E_OUTOFMEMORY;
}
}
else
if((!_wcsicmp(pwzCodeIn, L"deflate") && !_wcsicmp(pwzCodeOut, L"text"))|| (!_wcsicmp(pwzCodeIn, L"text") && !_wcsicmp(pwzCodeOut, L"deflate")) )
{
// deflate
*ppDF = new CStdZFilter(COMPRESSION_FLAG_DEFLATE);
fBuiltIn = TRUE;
if( !(*ppDF) )
{
hr = E_OUTOFMEMORY;
}
}
else
{
// lookup reg to find out the class
CLSID clsid = CLSID_NULL;
hr = LookupClsIDFromReg(pwzCodeIn, pwzCodeOut, &clsid, 0);
if( hr == NOERROR )
{ // Get Clsid
IClassFactory* pCF = NULL;
hr = CoGetClassObject(
clsid, CLSCTX_INPROC_SERVER, NULL,
IID_IClassFactory, (void**)&pCF );
if( hr == NOERROR )
{ // Get Class Fac
IUnknown* pUnk = NULL;
hr = pCF->CreateInstance(NULL, IID_IUnknown, (void**)&pUnk);
if( hr == NOERROR )
{ // Created Instance
hr = pUnk->QueryInterface(IID_IDataFilter, (void**)ppDF);
pUnk->Release();
} // Created Instance
pCF->Release();
} // Get Class Fac
} // Get Clsid
} // lookup reg to find out the class
// only do this for built-in filter (this is not universal)
if( (*ppDF) && fBuiltIn )
{
hr = ((CStdZFilter*)(*ppDF))->InitFilter();
}
PerfDbgLog1(
tagDft, this, "-CEncodingFilterFactory::GetDefaultFilter(hr:%1x)",hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CEncodingFilterFactory::LookupClsIDFromReg
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 08-20-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP
CEncodingFilterFactory::LookupClsIDFromReg(
LPCWSTR pwzCodeIn,
LPCWSTR pwzCodeOut,
CLSID* pclsid,
DWORD dwFlags
)
{
HRESULT hr = E_FAIL;
CHAR szCodeIn[ULPROTOCOLLEN];
CHAR szCodeOut[ULPROTOCOLLEN];
CHAR szCodeKey[2*ULPROTOCOLLEN+1];
DWORD dwLen = 256;
CHAR szDFilterKey[MAX_PATH];
BOOL fFoundKey = FALSE;
HKEY hDFKey = NULL;
DWORD dwType;
W2A(pwzCodeIn, szCodeIn, ULPROTOCOLLEN);
W2A(pwzCodeOut, szCodeOut, ULPROTOCOLLEN);
// check buffer overrun
if( (strlen(szCodeIn) + strlen(szCodeOut) + 2)
<= MAX_PATH )
{
// try key#1
strcpy(szDFilterKey, SZDFILTERROOT);
strcat(szDFilterKey, szCodeIn);
strcat(szDFilterKey, "#");
strcat(szDFilterKey, szCodeOut);
if( RegOpenKeyEx(
HKEY_CLASSES_ROOT, szDFilterKey, 0,
KEY_QUERY_VALUE, &hDFKey ) == ERROR_SUCCESS)
{
if( RegQueryValueEx(
hDFKey, SZCLASS, NULL, &dwType, (LPBYTE)szDFilterKey, &dwLen
) == ERROR_SUCCESS
)
{
hr = CLSIDFromStringA(szDFilterKey, pclsid);
fFoundKey = TRUE;
}
RegCloseKey(hDFKey);
}
// try key#2
if( !fFoundKey )
{
strcpy(szDFilterKey, SZDFILTERROOT);
strcat(szDFilterKey, szCodeOut);
strcat(szDFilterKey, "#");
strcat(szDFilterKey, szCodeIn);
if( RegOpenKeyEx(
HKEY_CLASSES_ROOT, szDFilterKey, 0,
KEY_QUERY_VALUE, &hDFKey ) == ERROR_SUCCESS )
{
if( RegQueryValueEx(
hDFKey, SZCLASS, NULL, &dwType,
(LPBYTE)szDFilterKey, &dwLen
) == ERROR_SUCCESS
)
{
hr = CLSIDFromStringA(szDFilterKey, pclsid);
}
RegCloseKey(hDFKey);
}
}
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: CEncodingFilterFactory::CEncodingFilterFactory
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 04-29-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
CEncodingFilterFactory::CEncodingFilterFactory()
: _CRefs()
{
PerfDbgLog(
tagDft, this, "+CEncodingFilterFactory::CEncodingFilterFactory");
PerfDbgLog(
tagDft, this, "-CEncodingFilterFactory::CEncodingFilterFactory");
}
//+---------------------------------------------------------------------------
//
// Method: CEncodingFilterFactory::~CEncodingFilterFactory
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// History: 04-29-97 DanpoZ (Danpo Zhang) Created
//
// Notes:
//
//----------------------------------------------------------------------------
CEncodingFilterFactory::~CEncodingFilterFactory()
{
PerfDbgLog(
tagDft, this, "+CEncodingFilterFactory::~CEncodingFilterFactory");
PerfDbgLog(
tagDft, this, "-CEncodingFilterFactory::~CEncodingFilterFactory");
}