able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/query/sdk/htmlprop/htmlprop.cxx

1021 lines
28 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright 1998 - 1999 Microsoft Corporation. All Rights Reserved.
//
// PROGRAM: htmlprop.cxx
//
// PURPOSE: Sits on the Indexing Service HTML filter to translate string
// meta properties into specified data types.
//
// PLATFORM: Windows 2000
//
//--------------------------------------------------------------------------
#define UNICODE
#include <stdio.h>
#include <wchar.h>
#include <windows.h>
#include <oledb.h>
#include <cmdtree.h>
#include <filterr.h>
#include <filter.h>
#include "htmlprop.hxx"
#include "filtreg.hxx"
// The typid of the html filter
CLSID TYPID_HtmlPropIFilter =
{
0xc8e2ab80, 0xa1db, 0x11d1,
{ 0xa8, 0xfb, 0x00, 0xe0, 0x98, 0x00, 0x6e, 0xd3 }
};
// The CLSID for the html property filter
CLSID CLSID_HtmlPropIFilter =
{
0xf4309e80, 0xa1db, 0x11d1,
{ 0xa8, 0xfb, 0x00, 0xe0, 0x98, 0x00, 0x6e, 0xd3 }
};
// Class of the html property filter
CLSID CLSID_HtmlPropClass =
{
0x4cbd1020, 0xa1db, 0x11d1,
{ 0xa8, 0xfb, 0x00, 0xe0, 0x98, 0x00, 0x6e, 0xd3 }
};
// The built-in html filter
CLSID CLSID_HtmlIFilter =
{
0xe0ca5340, 0x4534, 0x11cf,
{ 0xb9, 0x52, 0x00, 0xaa, 0x00, 0x51, 0xfe, 0x20 }
};
// The guid for html meta properties
CLSID CLSID_MetaProperty =
{
0xd1b5d3f0, 0xc0b3, 0x11cf,
{ 0x9a, 0x92, 0x00, 0xa0, 0xc9, 0x08, 0xdb, 0xf1 }
};
// The guid for html meta properties in string form
const WCHAR * pwcMetaProperty = L"d1b5d3f0-c0b3-11cf-9a92-00a0c908dbf1";
struct SPropertyEntry
{
WCHAR awcName[cwcMaxName]; // name of the meta property
DBTYPE dbType; // data type of property
};
const SPropertyEntry aTypeEntries[] =
{
{ L"DBTYPE_I1", DBTYPE_I1 }, // 0: signed char
{ L"DBTYPE_UI1", DBTYPE_UI1 }, // 1: unsigned char
{ L"DBTYPE_I2", DBTYPE_I2 }, // 2: 2 byte signed int
{ L"DBTYPE_UI2", DBTYPE_UI2 }, // 3: 2 byte unsigned int
{ L"DBTYPE_I4", DBTYPE_I4 }, // 4: 4 byte signed int
{ L"DBTYPE_UI4", DBTYPE_UI4 }, // 5: 4 byte unsigned int
{ L"DBTYPE_I8", DBTYPE_I8 }, // 6: 8 byte signed int
{ L"DBTYPE_UI8", DBTYPE_UI8 }, // 7: 8 byte unsigned int
{ L"DBTYPE_R4", DBTYPE_R4 }, // 8: 4 byte float
{ L"DBTYPE_R8", DBTYPE_R8 }, // 9: 8 byte float
{ L"DBTYPE_BOOL", DBTYPE_BOOL }, // 12: BOOL (true=-1, false=0)
{ L"DBTYPE_WSTR", DBTYPE_WSTR }, // 14: wide null terminated string
{ L"VT_FILETIME", VT_FILETIME } // 19: I8 filetime
};
const ULONG cTypeEntries = sizeof aTypeEntries / sizeof aTypeEntries[0];
const WCHAR * pwcHTMLPropertyFile = L"htmlprop.ini";
const ULONG maxEntries = 500;
SPropertyEntry g_aEntries[ maxEntries ];
ULONG g_cEntries = 0; // count of entries in g_aEntries
long g_cInstances = 0;
HMODULE g_hHtmlDll = 0; // module handle for nlhtml.dll
// htmlfilt.dll for IS 1.x and nlhtml.dll for IS 2.x
const WCHAR * pwcHTMLFilter = L"nlhtml.dll";
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::HtmlPropIFilter
//
// Synopsis: Constructor
//
//--------------------------------------------------------------------------
HtmlPropIFilter::HtmlPropIFilter() :
_pHtmlFilter( 0 ),
_pPersistFile( 0 ),
_lRefs( 1 )
{
InterlockedIncrement( &g_cInstances );
} //HtmlPropIFilter
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::~HtmlPropIFilter
//
// Synopsis: Destructor
//
//--------------------------------------------------------------------------
HtmlPropIFilter::~HtmlPropIFilter()
{
InterlockedDecrement( &g_cInstances );
if ( _pHtmlFilter )
_pHtmlFilter->Release();
if ( _pPersistFile )
_pPersistFile->Release();
} //~HtmlPropIFilter
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::QueryInterface
//
// Synopsis: Rebind to other interface
//
// Arguments: [riid] -- IID of new interface
// [ppvObject] -- New interface * returned here
//
// Returns: S_OK if bind succeeded, E_NOINTERFACE if bind failed
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::QueryInterface(
REFIID riid,
void ** ppvObject)
{
if ( IID_IFilter == riid )
*ppvObject = (IFilter *)this;
else if ( IID_IPersist == riid )
*ppvObject = (IPersist *)(IPersistFile *)this;
else if ( IID_IPersistFile == riid )
*ppvObject = (IPersistFile *)this;
else if ( IID_IUnknown == riid )
*ppvObject = (IUnknown *)(IPersist *)(IPersistFile *)this;
else
{
*ppvObject = 0;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
} //QueryInterface
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::AddRef
//
// Synopsis: Increments refcount
//
//--------------------------------------------------------------------------
ULONG STDMETHODCALLTYPE HtmlPropIFilter::AddRef()
{
return InterlockedIncrement( &_lRefs );
} //AddRef
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::Release
//
// Synopsis: Decrement refcount. Delete if necessary.
//
//--------------------------------------------------------------------------
ULONG STDMETHODCALLTYPE HtmlPropIFilter::Release()
{
long lTmp = InterlockedDecrement( &_lRefs );
if ( 0 == lTmp )
delete this;
return lTmp;
} //Release
//+-------------------------------------------------------------------------
//
// Member: HtmlPropIFilter::Init, public
//
// Synopsis: Initializes instance of property filter
//
// Arguments: [grfFlags] -- flags for filter behavior
// [cAttributes] -- number of attributes in array aAttributes
// [aAttributes] -- array of attributes
// [pFlags] -- flags
//
//----------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::Init(
ULONG grfFlags,
ULONG cAttributes,
FULLPROPSPEC const * aAttributes,
ULONG * pFlags )
{
return _pHtmlFilter->Init( grfFlags, cAttributes, aAttributes, pFlags );
} //Init
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::GetChunk
//
// Synopsis: Gets the next chunk
//
// Arguments: [pStat] -- Chunk info
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::GetChunk(
STAT_CHUNK * pStat )
{
SCODE sc = _pHtmlFilter->GetChunk( pStat );
// If we got a chunk, it's a value chunk, and it's a meta property with
// a string identifier, store away the name so it's available when the
// value is retrieved.
if ( ( SUCCEEDED( sc ) ) &&
( 0 != ( pStat->flags & CHUNK_VALUE ) ) &&
( PRSPEC_LPWSTR == pStat->attribute.psProperty.ulKind ) &&
( CLSID_MetaProperty == pStat->attribute.guidPropSet ) &&
( 0 != pStat->attribute.psProperty.lpwstr ) &&
( wcslen( pStat->attribute.psProperty.lpwstr ) < cwcMaxName ) )
{
_fMetaProperty = TRUE;
wcscpy( _awcName, pStat->attribute.psProperty.lpwstr );
}
else
{
_fMetaProperty = FALSE;
}
return sc;
} //GetChunk
//+-------------------------------------------------------------------------
//
// Function: ParseDateTime
//
// Synopsis: Parse the string and return a date/time
// n.b. If the date is ill-formed and this function returns
// an error code, the file will be unfiltered, and can be
// found by using the unfiltered admin query.
// The date parsing is very strict.
// Times are in any time zone you like, but .htx will interpret
// all dates as GMT. You can always use .asp script to munge
// dates as you like.
//
// Arguments: [pwcDate] -- String form of the date/time
// [ft] -- Returns the date/time
//
//--------------------------------------------------------------------------
SCODE ParseDateTime(
WCHAR * pwcDate,
FILETIME & ft )
{
SYSTEMTIME stValue = { 0, 0, 0, 0, 0, 0, 0, 0 };
// Some day add more flexible date formats!
int cItems = swscanf( pwcDate,
L"%4hd/%2hd/%2hd %2hd:%2hd:%2hd:%3hd",
&stValue.wYear,
&stValue.wMonth,
&stValue.wDay,
&stValue.wHour,
&stValue.wMinute,
&stValue.wSecond,
&stValue.wMilliseconds );
if ( 1 == cItems )
cItems = swscanf( pwcDate,
L"%4hd-%2hd-%2hd %2hd:%2hd:%2hd:%3hd",
&stValue.wYear,
&stValue.wMonth,
&stValue.wDay,
&stValue.wHour,
&stValue.wMinute,
&stValue.wSecond,
&stValue.wMilliseconds );
if( cItems != 3 && cItems != 6 && cItems != 7)
return E_INVALIDARG;
// Make a sensible split for Year 2000
if (stValue.wYear < 30)
stValue.wYear += 2000;
else if (stValue.wYear < 100)
stValue.wYear += 1900;
if( !SystemTimeToFileTime( &stValue, &ft ) )
return HRESULT_FROM_WIN32( GetLastError() );
return S_OK;
} //ParseDateTime
//+-------------------------------------------------------------------------
//
// Function: Translate
//
// Synopsis: Translates the string property value to the given type
//
// Arguments: [v] -- The variant to translate
// [dbType] -- The resulting data type
//
//--------------------------------------------------------------------------
SCODE Translate(
PROPVARIANT & v,
DBTYPE dbType )
{
PROPVARIANT varCopy = v;
BOOL fChange = TRUE;
SCODE sc = S_OK;
WCHAR *p = v.pwszVal;
// The source must be a string variant
if ( 0 == p || VT_LPWSTR != v.vt )
return S_OK;
v.vt = dbType;
// Eat leading white space
while ( ' ' == *p )
p++;
int base = 10;
// Is this a hex number?
if ( '0' == *p && ( 'x' == *(p+1) || 'X' == *(p+1) ) )
{
p += 2;
base = 16;
}
WCHAR * pwc;
// DBTYPE_I1 isn't an official OLE property type, so it isn't supported.
//
// Note: range checking could be added and a failure code could be
// returned if the check failed. That would put the file in the
// unfiltered list.
switch ( dbType )
{
case DBTYPE_UI1 :
v.bVal = (BYTE) wcstoul( v.pwszVal, &pwc, base );
break;
case DBTYPE_I2 :
v.iVal = (SHORT) wcstol( v.pwszVal, &pwc, base );
break;
case DBTYPE_UI2 :
v.uiVal = (USHORT) wcstoul( v.pwszVal, &pwc, base );
break;
case DBTYPE_I4 :
v.lVal = (LONG) wcstol( v.pwszVal, &pwc, base );
break;
case DBTYPE_UI4 :
v.ulVal = (ULONG) wcstoul( v.pwszVal, &pwc, base );
break;
case DBTYPE_I8 :
swscanf( v.pwszVal, L"%I64d", &v.fltVal );
break;
case DBTYPE_UI8 :
swscanf( v.pwszVal, L"%I64u", &v.fltVal );
break;
case DBTYPE_R4 :
swscanf( v.pwszVal, L"%f", &v.fltVal );
break;
case DBTYPE_R8 :
swscanf( v.pwszVal, L"%lf", &v.dblVal );
break;
case DBTYPE_BOOL :
// If the first character is t or 1, assume VARIANT_TRUE
if ( 't' == *v.pwszVal ||
'T' == *v.pwszVal ||
'1' == *v.pwszVal )
v.boolVal = VARIANT_TRUE;
else
v.boolVal = VARIANT_FALSE;
break;
case VT_FILETIME :
sc = ParseDateTime( p, v.filetime );
break;
default :
// leave the property as it was
fChange = FALSE;
v.vt = varCopy.vt;
break;
}
// Free the memory for the (now converted) string value
if ( fChange )
PropVariantClear( &varCopy );
return sc;
} //Translate
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::GetValue
//
// Synopsis: Retrieves the current value
//
// Arguments: [ppPropValue] -- Where the value is stored
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::GetValue(
PROPVARIANT ** ppPropValue )
{
SCODE sc = _pHtmlFilter->GetValue( ppPropValue );
// Is this a value that must be translated?
if ( SUCCEEDED( sc ) && _fMetaProperty && 0 != *ppPropValue )
{
// lookup the datatype of the translation based on property name
for ( ULONG i = 0; i < g_cEntries; i++ )
{
if ( !_wcsicmp( g_aEntries[i].awcName, _awcName ) )
{
// found it, so translate it
sc = Translate( **ppPropValue,
g_aEntries[i].dbType );
break;
}
}
}
return sc;
} //GetValue
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::GetText
//
// Synopsis: Gets text from the filter
//
// Arguments: [pcwcBuffer] -- Returns the # of WCHARs returned
// [awcBuffer] -- Where text is written
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::GetText(
ULONG * pcwcBuffer,
WCHAR * awcBuffer )
{
return _pHtmlFilter->GetText( pcwcBuffer, awcBuffer );
} //GetText
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::BindRegion
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::BindRegion(
FILTERREGION origPos,
REFIID riid,
void ** ppunk )
{
return _pHtmlFilter->BindRegion( origPos, riid, ppunk );
} //BindRegion
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::GetClassID
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::GetClassID( CLSID * pClassID )
{
*pClassID = CLSID_HtmlPropIFilter;
return S_OK;
} //GetClassID
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::IsDirty
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::IsDirty()
{
return S_FALSE;
} //IsDirty
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::Load
//
// Synopsis: Loads the file for the filter
//
// Arguments: [pszFileName] -- Name of the file
// [dwMode] -- Mode of the load
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::Load(
LPCWSTR pszFileName,
DWORD dwMode)
{
//
// Get html filter class object and class factory
//
IClassFactory * pcf;
SCODE sc = E_FAIL;
if ( 0 != g_hHtmlDll )
{
LPFNGETCLASSOBJECT pfn = (LPFNGETCLASSOBJECT)GetProcAddress(
g_hHtmlDll,
"DllGetClassObject" );
if ( 0 != pfn )
sc = (pfn)( CLSID_HtmlIFilter, IID_IClassFactory, (void **)&pcf );
}
if ( SUCCEEDED(sc) )
{
// Get an html filter
sc = pcf->CreateInstance( 0, IID_IFilter, (void **)&_pHtmlFilter );
pcf->Release();
if ( SUCCEEDED(sc) )
{
// Load the file
sc = _pHtmlFilter->QueryInterface( IID_IPersistFile,
(void **) &_pPersistFile );
if ( SUCCEEDED(sc) )
{
sc = _pPersistFile->Load( pszFileName, dwMode );
}
else
{
_pHtmlFilter->Release();
_pHtmlFilter = 0;
}
}
}
return sc;
} //Load
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::Save
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::Save(
LPCWSTR pszFileName,
BOOL fRemember )
{
return E_FAIL;
} //Save
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::SaveCompleted
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::SaveCompleted(
LPCWSTR pszFileName )
{
return E_FAIL;
} //SaveCompleted
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilter::GetcurFile
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilter::GetCurFile(
LPWSTR * ppszFileName )
{
return _pPersistFile->GetCurFile( ppszFileName );
} //GetCurFile
//+-------------------------------------------------------------------------
//
// Function: ParsePropertyFile
//
// Synopsis: Parses a property file and stores datatypes for html meta
// properties. Property files are in .idq format, with a
// [Names] section.
//
//--------------------------------------------------------------------------
void ParsePropertyFile()
{
// already parsed the file?
if ( g_cEntries > 0 )
return;
// open the property file in the system32 directory
WCHAR awcFile[ MAX_PATH ];
GetSystemDirectory( awcFile, sizeof awcFile / sizeof WCHAR );
wcscat( awcFile, L"\\" );
wcscat( awcFile, pwcHTMLPropertyFile );
FILE *file = _wfopen( awcFile, L"r" );
if ( 0 != file )
{
WCHAR awc[ 500 ];
BOOL fNames = FALSE;
// for each line of the file
while ( fgetws( awc, sizeof awc, file ) )
{
int cwc = wcslen( awc );
if ( 0 == cwc )
continue;
// trim off trailing newline
if ( awc[ cwc - 1 ] == '\n' )
{
cwc--;
awc[cwc] = 0;
}
// is this a section line?
if ( '[' == awc[0] )
{
fNames = !_wcsicmp( L"[names]", awc );
}
else if ( ( '#' != awc[0] ) && fNames )
{
// parse the data type
WCHAR *pwcType = wcschr( awc, L'(' );
if ( 0 != pwcType )
{
pwcType++;
while ( ' ' == *pwcType )
pwcType++;
WCHAR *pwcX = wcstok( pwcType, L", )" );
if ( 0 != pwcType )
{
// lookup the type in the list of types
for ( ULONG i = 0; i < cTypeEntries; i++ )
{
if ( !_wcsicmp( aTypeEntries[i].awcName,
pwcType ) )
break;
}
// got the type, so find the guid
if ( i < cTypeEntries )
{
// find the property guid
pwcType += 1 + wcslen( pwcType );
WCHAR *pwcName = wcschr( pwcType, '=' );
if ( pwcName )
{
pwcName++;
while ( ' ' == *pwcName )
pwcName++;
// is this the html guid?
if ( !_wcsnicmp( pwcName,
pwcMetaProperty,
wcslen( pwcMetaProperty ) ) )
{
// find the property name
pwcName = wcschr( pwcName, ' ' );
if ( pwcName )
{
// skip white space
while ( ' ' == *pwcName )
pwcName++;
// got it -- save it away if it fits
if ( ( wcslen( pwcName ) < cwcMaxName ) &&
( g_cEntries < maxEntries ) )
{
wcscpy( g_aEntries[g_cEntries].awcName,
pwcName );
g_aEntries[g_cEntries++].dbType =
aTypeEntries[i].dbType;
}
}
}
}
}
}
}
}
}
fclose( file );
}
} //ParsePropertyFile
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilterCF::HtmlPropIFilterCF
//
// Synopsis: HTML Property IFilter class factory constructor
//
//--------------------------------------------------------------------------
HtmlPropIFilterCF::HtmlPropIFilterCF()
{
_lRefs = 1;
long c = InterlockedIncrement( &g_cInstances );
if ( 0 == g_hHtmlDll && 1 == c )
{
// load the html filter dll
g_hHtmlDll = LoadLibrary( pwcHTMLFilter );
// load the property information
ParsePropertyFile();
}
} //HtmlPropIFilterCF
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilterCF::~HtmlPropIFilterCF
//
// Synopsis: HTML IFilter class factory constructor
//
//--------------------------------------------------------------------------
HtmlPropIFilterCF::~HtmlPropIFilterCF()
{
long c = InterlockedDecrement( &g_cInstances );
if ( 0 != g_hHtmlDll && 0 == c )
{
FreeLibrary( g_hHtmlDll );
g_hHtmlDll = 0;
}
} //~HtmlPropIFilterCF
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilterCF::QueryInterface
//
// Synopsis: Rebind to other interface
//
// Arguments: [riid] -- IID of new interface
// [ppvObject] -- New interface * returned here
//
// Returns: S_OK if bind succeeded, E_NOINTERFACE if bind failed
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilterCF::QueryInterface(
REFIID riid,
void ** ppvObject )
{
if ( IID_IClassFactory == riid )
*ppvObject = (IUnknown *) (IClassFactory *) this;
else if ( IID_IUnknown == riid )
*ppvObject = (IUnknown *) (IPersist *) this;
else
{
*ppvObject = 0;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
} //QueryInterface
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilterCF::AddRef
//
// Synopsis: Increments refcount
//
//--------------------------------------------------------------------------
ULONG STDMETHODCALLTYPE HtmlPropIFilterCF::AddRef()
{
return InterlockedIncrement( &_lRefs );
} //AddRef
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilterCF::Release
//
// Synopsis: Decrement refcount. Delete if necessary.
//
//--------------------------------------------------------------------------
ULONG STDMETHODCALLTYPE HtmlPropIFilterCF::Release()
{
long lTmp = InterlockedDecrement( &_lRefs );
if ( 0 == lTmp )
delete this;
return lTmp;
} //Release
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilterCF::CreateInstance
//
// Synopsis: Creates new HtmlPropIFilter object
//
// Arguments: [pUnkOuter] -- 'Outer' IUnknown
// [riid] -- Interface to bind
// [ppvObject] -- Interface returned here
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilterCF::CreateInstance(
IUnknown * pUnkOuter,
REFIID riid,
void * * ppvObject )
{
*ppvObject = 0;
HtmlPropIFilter * pFilter = new HtmlPropIFilter;
if ( 0 == pFilter )
return E_OUTOFMEMORY;
SCODE sc = pFilter->QueryInterface( riid , ppvObject );
pFilter->Release();
return sc;
} //CreateInstance
//+-------------------------------------------------------------------------
//
// Method: HtmlPropIFilterCF::LockServer
//
// Synopsis: Force class factory to remain loaded
//
// Arguments: [fLock] -- TRUE if locking, FALSE if unlocking
//
// Returns: S_OK
//
//--------------------------------------------------------------------------
SCODE STDMETHODCALLTYPE HtmlPropIFilterCF::LockServer(BOOL fLock)
{
if(fLock)
InterlockedIncrement( &g_cInstances );
else
InterlockedDecrement( &g_cInstances );
return S_OK;
} //LockServer
//+-------------------------------------------------------------------------
//
// Function: DllGetClassObject
//
// Synopsis: Ole DLL load class routine
//
// Arguments: [cid] -- Class to load
// [iid] -- Interface to bind to on class object
// [ppvObj] -- Interface pointer returned here
//
// Returns: HTML Property filter class factory
//
//--------------------------------------------------------------------------
extern "C" SCODE STDMETHODCALLTYPE DllGetClassObject(
REFCLSID cid,
REFIID iid,
void ** ppvObj )
{
IUnknown * pUnk = 0;
if ( CLSID_HtmlPropIFilter == cid ||
CLSID_HtmlPropClass == cid )
{
pUnk = new HtmlPropIFilterCF;
if ( 0 == pUnk )
return E_OUTOFMEMORY;
}
else
{
*ppvObj = 0;
return E_NOINTERFACE;
}
SCODE sc = pUnk->QueryInterface( iid, ppvObj );
pUnk->Release();
return sc;
} //DllGetClassObject
//+-------------------------------------------------------------------------
//
// Method: DllCanUnloadNow
//
// Synopsis: Notifies DLL to unload (cleanup global resources)
//
// Returns: S_OK if it is acceptable for caller to unload DLL.
//
//--------------------------------------------------------------------------
extern "C" SCODE STDMETHODCALLTYPE DllCanUnloadNow( void )
{
if ( 0 == g_cInstances )
return S_OK;
else
return S_FALSE;
} //DllCanUnloadNow
SClassEntry const aHtmlPropClasses[] =
{
{ L".hhc", L"hhcfile", L"HHC file", L"{7f73b8f6-c19c-11d0-aa66-00c04fc2eddc}", L"HHC file" },
{ L".htm", L"htmlfile", L"HTML file", L"{25336920-03f9-11cf-8fd0-00aa00686f13}", L"HTML file" },
{ L".html", L"htmlfile", L"HTML file", L"{25336920-03f9-11cf-8fd0-00aa00686f13}", L"HTML file" },
{ L".htx", L"htmlfile", L"HTML file", L"{25336920-03f9-11cf-8fd0-00aa00686f13}", L"HTML file" },
{ L".stm", L"htmlfile", L"HTML file", L"{25336920-03f9-11cf-8fd0-00aa00686f13}", L"HTML file" },
{ L".htw", L"htmlfile", L"HTML file", L"{25336920-03f9-11cf-8fd0-00aa00686f13}", L"HTML file" },
{ L".asp", L"asp_auto_file", L"ASP auto file", L"{bd70c020-2d24-11d0-9110-00004c752752}", L"ASP auto file" },
};
SHandlerEntry const HtmlPropHandler =
{
L"{c694d910-a439-11d1-a903-00e098006ed3}",
L"html property persistent handler",
L"{f4309e80-a1db-11d1-a8fb-00e098006ed3}",
};
SFilterEntry const HtmlPropFilter =
{
L"{f4309e80-a1db-11d1-a8fb-00e098006ed3}",
L"html property filter",
L"HtmlProp.dll",
L"Both"
};
DEFINE_DLLREGISTERFILTER( HtmlPropHandler, HtmlPropFilter, aHtmlPropClasses )
Reference in a new issue Copy permalink