able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/security/gina/snapins/gptext/policy.h

1157 lines
44 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//
// Current ADM version
//
// Version 1 -> Windows 95
// Version 2 -> Windows NT v4.0
// Version 3 -> Windows 2000
// Version 4 -> Windows Whistler
//
#define CURRENT_ADM_VERSION 4
//
// Add/Remove template entry
//
typedef struct tagTEMPLATEENTRY {
LPTSTR lpFileName;
DWORD dwSize;
FILETIME ftTime;
} TEMPLATEENTRY, *LPTEMPLATEENTRY;
//
// Supported On strings
//
typedef struct tagSUPPORTEDENTRY {
LPTSTR lpString;
BOOL bEnabled;
BOOL bNull;
struct tagSUPPORTEDENTRY * pNext;
} SUPPORTEDENTRY, *LPSUPPORTEDENTRY;
//
// RSOP link list data structures
//
typedef struct tagRSOPREGITEM {
LPTSTR lpKeyName;
LPTSTR lpValueName;
LPTSTR lpGPOName;
DWORD dwType;
DWORD dwSize;
LPBYTE lpData;
BOOL bFoundInADM;
UINT uiPrecedence;
BOOL bDeleted;
struct tagRSOPREGITEM * pNext;
} RSOPREGITEM, *LPRSOPREGITEM;
typedef struct tagRSOPADMFILE {
TCHAR szFileName[100];
TCHAR szFullFileName[MAX_PATH];
FILETIME FileTime;
DWORD dwError;
struct tagRSOPADMFILE * pNext;
} RSOPADMFILE, *LPRSOPADMFILE;
//
// From admincfg.h
//
#define REGBUFLEN 255
#define MAXSTRLEN 1024
#define SMALLBUF 48
#define ERROR_ALREADY_DISPLAYED 0xFFFF
#define GETNAMEPTR(x) (x->uOffsetName ? ((TCHAR *)((BYTE *) x + x->uOffsetName)) : NULL)
#define GETKEYNAMEPTR(x) (x->uOffsetKeyName ? ((TCHAR *)((BYTE *) x + x->uOffsetKeyName)) : NULL)
#define GETVALUENAMEPTR(x) (x->uOffsetValueName ? ((TCHAR *)((BYTE *) x + x->uOffsetValueName)) : NULL)
#define GETOBJECTDATAPTR(x) (x->uOffsetObjectData ? ((BYTE *) x + x->uOffsetObjectData) : NULL)
#define GETVALUESTRPTR(x) (x->uOffsetValueStr ? ((TCHAR *)((BYTE *) x + x->uOffsetValueStr)) : NULL)
#define GETSUPPORTEDPTR(x) (x->uOffsetSupported ? ((TCHAR *)((BYTE *) x + x->uOffsetSupported)) : NULL)
//
// From memory.h
//
#define DEFAULT_ENUM_BUF_SIZE 256
// Entry type ID's
#define ETYPE_CATEGORY 0x0001
#define ETYPE_POLICY 0x0002
#define ETYPE_SETTING 0x0004
#define ETYPE_ROOT 0x0008
#define ETYPE_REGITEM 0x0010
#define ETYPE_MASK 0x001F
// Setting type ID's
#define STYPE_TEXT 0x0010
#define STYPE_CHECKBOX 0x0020
#define STYPE_ENUM 0x0040
#define STYPE_EDITTEXT 0x0080
#define STYPE_NUMERIC 0x0100
#define STYPE_COMBOBOX 0x0200
#define STYPE_DROPDOWNLIST 0x0400
#define STYPE_LISTBOX 0x0800
#define STYPE_MASK 0xFFF0
// Flags
#define DF_REQUIRED 0x0001 // text or numeric field required to have entry
#define DF_USEDEFAULT 0x0002 // use specified text or numeric value
#define DF_DEFCHECKED 0x0004 // initialize checkbox or radio button as checked
#define DF_TXTCONVERT 0x0008 // save numeric values as text rather than binary
#define DF_ADDITIVE 0x0010 // listbox is additive, rather than destructive
#define DF_EXPLICITVALNAME 0x0020 // listbox value names need to be specified for each entry
#define DF_NOSORT 0x0040 // listbox is not sorted alphabetically. Uses order in ADM.
#define DF_EXPANDABLETEXT 0x0080 // write REG_EXPAND_SZ text value
#define VF_ISNUMERIC 0x0100 // value is numeric (rather than text)
#define VF_DELETE 0x0200 // value should be deleted
#define VF_SOFT 0x0400 // value is soft (only propagated if doesn't exist on destination)
// generic table entry
typedef struct tagTABLEENTRY {
DWORD dwSize;
DWORD dwType;
struct tagTABLEENTRY * pNext; // ptr to next sibling in node
struct tagTABLEENTRY * pPrev; // ptr to previous sibling in node
struct tagTABLEENTRY * pChild; // ptr to child node
UINT uOffsetName; // offset from beginning of struct to name
UINT uOffsetKeyName; // offset from beginning of struct to key name
// table entry information here
} TABLEENTRY;
typedef struct tagACTION {
DWORD dwFlags; // can be VF_ISNUMERIC, VF_DELETE, VF_SOFT
UINT uOffsetKeyName;
UINT uOffsetValueName;
union {
UINT uOffsetValue; // offset to value, if text
DWORD dwValue; // value, if numeric
};
UINT uOffsetNextAction;
// key name, value name, value stored here
} ACTION;
typedef struct tagACTIONLIST {
UINT nActionItems;
ACTION Action[1];
} ACTIONLIST;
typedef struct tagSTATEVALUE {
DWORD dwFlags; // can be VF_ISNUMERIC, VF_DELETE, VF_SOFT
union {
TCHAR szValue[1]; // value, if text
DWORD dwValue; // value, if numeric
};
} STATEVALUE;
// specialized nodes -- CATEGORY, POLICY, SETTING and REGITEM can all be cast to TABLEENTRY
typedef struct tagCATEGORY {
DWORD dwSize; // size of this struct (including variable-length name)
DWORD dwType;
struct tagTABLEENTRY * pNext; // ptr to next sibling in node
struct tagTABLEENTRY * pPrev; // ptr to previous sibling in node
struct tagTABLEENTRY * pChild; // ptr to child node
UINT uOffsetName; // offset from beginning of struct to name
UINT uOffsetKeyName; // offset from beginning of struct to key name
UINT uOffsetHelp; // offset from beginning of struct to help text
// category name stored here
// category registry key name stored here
} CATEGORY;
typedef struct tagPOLICY {
DWORD dwSize; // size of this struct (including variable-length name)
DWORD dwType;
struct tagTABLEENTRY * pNext; // ptr to next sibling in node
struct tagTABLEENTRY * pPrev; // ptr to previous sibling in node
struct tagTABLEENTRY * pChild; // ptr to child node
UINT uOffsetName; // offset from beginning of struct to name
UINT uOffsetKeyName; // offset from beginning of struct to key name
UINT uOffsetValueName; // offset from beginning of struct to value name
UINT uDataIndex; // index into user's data buffer for this setting
UINT uOffsetValue_On; // offset to STATEVALUE for ON state
UINT uOffsetValue_Off; // offset to STATEVALUE for OFF state
UINT uOffsetActionList_On; // offset to ACTIONLIST for ON state
UINT uOffsetActionList_Off; // offset to ACTIONLIST for OFF state
UINT uOffsetHelp; // offset from beginning of struct to help text
UINT uOffsetClientExt; // offset from beginning of struct to clientext text
BOOL bTruePolicy; // something located under the Policies key
UINT uOffsetSupported; // list of supported products
// name stored here
// policy registry key name stored here
} POLICY;
typedef struct tagSETTINGS {
DWORD dwSize; // size of this struct (including variable-length data)
DWORD dwType;
struct tagTABLEENTRY * pNext; // ptr to next sibling in node
struct tagTABLEENTRY * pPrev; // ptr to previous sibling in node
struct tagTABLEENTRY * pChild; // ptr to child node
UINT uOffsetName; // offset from beginning of struct to name
UINT uOffsetKeyName; // offset from beginning of struct to key name
UINT uOffsetValueName; // offset from beginning of struct to value name
UINT uDataIndex; // index into user's data buffer for this setting
UINT uOffsetObjectData; // offset to object data
UINT uOffsetClientExt; // offset from beginning of struct to clientext text
DWORD dwFlags; // can be DF_REQUIRED, DF_USEDEFAULT, DF_DEFCHECKED,
// VF_SOFT, DF_NO_SORT
// settings registry value name stored here
// object-dependent data stored here (a CHECKBOXINFO,
// RADIOBTNINFO, EDITTEXTINFO, or NUMERICINFO struct)
} SETTINGS;
typedef struct tagREGITEM {
DWORD dwSize;
DWORD dwType;
struct tagTABLEENTRY * pNext; // ptr to next sibling in node
struct tagTABLEENTRY * pPrev; // ptr to previous sibling in node
struct tagTABLEENTRY * pChild; // ptr to child node
UINT uOffsetName; // offset from beginning of struct to name
UINT uOffsetKeyName; // offset from beginning of struct to key name
UINT uOffsetValueStr; // offset from beginning of struct to the value in string format
BOOL bTruePolicy; // something located under the Policies key
LPRSOPREGITEM lpItem; // Pointer to a rsop registry item
// Name and keyname information here
} REGITEM;
typedef struct tagCHECKBOXINFO {
UINT uOffsetValue_On; // offset to STATEVALUE for ON state
UINT uOffsetValue_Off; // offset to STATEVALUE for OFF state
UINT uOffsetActionList_On; // offset to ACTIONLIST for ON state
UINT uOffsetActionList_Off; // offset to ACTIONLIST for OFF state
} CHECKBOXINFO;
typedef struct tagEDITTEXTINFO {
UINT uOffsetDefText;
UINT nMaxLen; // max len of edit field
} EDITTEXTINFO;
typedef struct tagPOLICYCOMBOBOXINFO {
UINT uOffsetDefText;
UINT nMaxLen; // max len of edit field
UINT uOffsetSuggestions;
} POLICYCOMBOBOXINFO;
typedef struct tagNUMERICINFO {
UINT uDefValue; // default value
UINT uMaxValue; // minimum value
UINT uMinValue; // maximum value
UINT uSpinIncrement; // if 0, spin box is not displayed.
} NUMERICINFO;
typedef struct tagCLASSLIST {
TABLEENTRY * pMachineCategoryList; // per-machine category list
UINT nMachineDataItems;
TABLEENTRY * pUserCategoryList; // per-user category table
UINT nUserDataItems;
} CLASSLIST;
typedef struct tagDROPDOWNINFO {
UINT uOffsetItemName;
UINT uDefaultItemIndex; // only used in 1st DROPDOWNINFO struct in list
DWORD dwFlags;
union {
UINT uOffsetValue;
DWORD dwValue;
};
UINT uOffsetActionList;
UINT uOffsetNextDropdowninfo;
} DROPDOWNINFO;
typedef struct tagLISTBOXINFO {
UINT uOffsetPrefix; // offset to prefix to use for value names (e.g
// "stuff" -> "stuff1", "stuff2", etc
UINT uOffsetValue; // offset to STATEVALUE to use for value data for each entry
// (can't have both a data value and a prefix)
} LISTBOXINFO;
//
// From policy.h
//
#define NO_DATA_INDEX (UINT) -1
#define DEF_CONTROLS 10
typedef struct tagPOLICYCTRLINFO {
HWND hwnd;
DWORD dwType;
UINT uDataIndex; // index into user's data buffer
SETTINGS * pSetting;
} POLICYCTRLINFO;
typedef struct tagSTRDATA {
DWORD dwSize; // size of structure incl. variable-len data
TCHAR szData[1]; // variable-length data
} STRDATA;
typedef struct tagPOLICYDLGINFO {
TABLEENTRY * pEntryRoot; // root template
SETTINGS * pCurrentSettings; // template for current settings
HWND hwndSettings;
HWND hwndApp;
BOOL fActive;
POLICYCTRLINFO * pControlTable;
DWORD dwControlTableSize;
UINT nControls;
} POLICYDLGINFO;
//
// From settings.h
//
#define WT_CLIP 1
#define WT_SETTINGS 2
#define SSTYLE_STATIC WS_CHILD | WS_VISIBLE
#define SSTYLE_CHECKBOX WS_CHILD | WS_VISIBLE | BS_CHECKBOX
#define SSTYLE_EDITTEXT WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | WS_BORDER
#define SSTYLE_UPDOWN WS_CHILD | WS_VISIBLE | UDS_NOTHOUSANDS
#define SSTYLE_COMBOBOX WS_CHILD | WS_VISIBLE | CBS_AUTOHSCROLL | CBS_DROPDOWN \
| WS_BORDER | CBS_SORT | WS_VSCROLL
#define SSTYLE_DROPDOWNLIST WS_CHILD | WS_VISIBLE | CBS_AUTOHSCROLL | CBS_DROPDOWNLIST \
| WS_BORDER | CBS_SORT | WS_VSCROLL
#define SSTYLE_LISTVIEW WS_CHILD | WS_VISIBLE | WS_BORDER
#define SSTYLE_LBBUTTON WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON
#define LISTBOX_BTN_WIDTH 100
#define LISTBOX_BTN_HEIGHT 20
#define SC_XSPACING 5
#define SC_YSPACING 5
#define SC_YPAD 8
#define SC_EDITWIDTH 220
#define SC_UPDOWNWIDTH 60
#define SC_UPDOWNWIDTH2 30
#define SC_XLEADING 5
#define SC_XINDENT 5
#define SC_YTEXTDROP 3
#define SC_YCONTROLWRAP 1
//
// From parse.h
//
#define KYWD_ID_KEYNAME 1
#define KYWD_ID_VALUENAME 2
#define KYWD_ID_CATEGORY 3
#define KYWD_ID_POLICY 4
#define KYWD_ID_PART 5
#define KYWD_ID_CHECKBOX 6
#define KYWD_ID_TEXT 7
#define KYWD_ID_EDITTEXT 8
#define KYWD_ID_NUMERIC 9
#define KYWD_ID_DEFCHECKED 10
#define KYWD_ID_MAXLENGTH 11
#define KYWD_ID_MIN 12
#define KYWD_ID_MAX 13
#define KYWD_ID_SPIN 14
#define KYWD_ID_REQUIRED 15
#define KYWD_ID_EDITTEXT_DEFAULT 16
#define KYWD_ID_COMBOBOX_DEFAULT 17
#define KYWD_ID_NUMERIC_DEFAULT 18
#define KYWD_ID_OEMCONVERT 19
#define KYWD_ID_CLASS 20
#define KYWD_ID_USER 21
#define KYWD_ID_MACHINE 22
#define KYWD_ID_TXTCONVERT 23
#define KYWD_ID_VALUE 24
#define KYWD_ID_VALUEON 25
#define KYWD_ID_VALUEOFF 26
#define KYWD_ID_ACTIONLIST 27
#define KYWD_ID_ACTIONLISTON 28
#define KYWD_ID_ACTIONLISTOFF 29
#define KYWD_ID_DELETE 30
#define KYWD_ID_COMBOBOX 31
#define KYWD_ID_SUGGESTIONS 32
#define KYWD_ID_DROPDOWNLIST 33
#define KYWD_ID_NAME 34
#define KYWD_ID_ITEMLIST 35
#define KYWD_ID_DEFAULT 36
#define KYWD_ID_SOFT 37
#define KYWD_ID_STRINGSSECT 38
#define KYWD_ID_LISTBOX 39
#define KYWD_ID_VALUEPREFIX 40
#define KYWD_ID_ADDITIVE 41
#define KYWD_ID_EXPLICITVALUE 42
#define KYWD_ID_VERSION 43
#define KYWD_ID_GT 44
#define KYWD_ID_GTE 45
#define KYWD_ID_LT 46
#define KYWD_ID_LTE 47
#define KYWD_ID_EQ 48
#define KYWD_ID_NE 49
#define KYWD_ID_END 50
#define KYWD_ID_NOSORT 51
#define KYWD_ID_EXPANDABLETEXT 52
#define KYWD_ID_HELP 53
#define KYWD_ID_CLIENTEXT 54
#define KYWD_ID_SUPPORTED 55
#define KYWD_DONE 100
#define DEFAULT_TMP_BUF_SIZE 512
#define STRINGS_BUF_SIZE 8096
#define WORDBUFSIZE 255
#define FILEBUFSIZE 8192
#define HELPBUFSIZE 4096
typedef struct tagKEYWORDINFO {
LPCTSTR pWord;
UINT nID;
} KEYWORDINFO;
typedef struct tagENTRYDATA {
BOOL fHasKey;
BOOL fHasValue;
BOOL fParentHasKey;
} ENTRYDATA;
typedef struct tagPARSEPROCSTRUCT {
HGLOBAL hTable; // handle of current table
TABLEENTRY *pTableEntry; // pointer to struct for current entry
DWORD *pdwBufSize; // size of buffer of pTableEntry
ENTRYDATA *pData; // used to maintain state between calls to parseproc
KEYWORDINFO *pEntryCmpList;
} PARSEPROCSTRUCT;
typedef UINT (* PARSEPROC) (CPolicyComponentData *, UINT,PARSEPROCSTRUCT *,BOOL *,BOOL *, LPTSTR);
typedef struct tagPARSEENTRYSTRUCT {
TABLEENTRY * pParent;
DWORD dwEntryType;
KEYWORDINFO *pEntryCmpList;
KEYWORDINFO *pTypeCmpList;
PARSEPROC pParseProc;
DWORD dwStructSize;
BOOL fHasSubtable;
BOOL fParentHasKey;
} PARSEENTRYSTRUCT;
//
// From load.c
//
// flags for detected settings
#define FS_PRESENT 0x0001
#define FS_DELETED 0x0002
#define FS_DISABLED 0x0004
#define WM_MYCHANGENOTIFY (WM_USER + 123)
#define WM_MOVEFOCUS (WM_USER + 124)
#define WM_UPDATEITEM (WM_USER + 125)
#define WM_SETPREVNEXT (WM_USER + 126)
#define WM_MYREFRESH (WM_USER + 127)
//
// GPE root node ids
//
// {8FC0B739-A0E1-11d1-A7D3-0000F87571E3}
DEFINE_GUID(NODEID_MachineRoot, 0x8fc0b739, 0xa0e1, 0x11d1, 0xa7, 0xd3, 0x0, 0x0, 0xf8, 0x75, 0x71, 0xe3);
// {8FC0B73B-A0E1-11d1-A7D3-0000F87571E3}
DEFINE_GUID(NODEID_UserRoot, 0x8fc0b73b, 0xa0e1, 0x11d1, 0xa7, 0xd3, 0x0, 0x0, 0xf8, 0x75, 0x71, 0xe3);
//
// RSOP root node ids
//
// {e753a11a-66cc-4816-8dd8-3cbe46717fd3}
DEFINE_GUID(NODEID_RSOPMachineRoot, 0xe753a11a, 0x66cc, 0x4816, 0x8d, 0xd8, 0x3c, 0xbe, 0x46, 0x71, 0x7f, 0xd3);
//
// {99d5b872-1ad0-4d87-acf1-82125d317653}
DEFINE_GUID(NODEID_RSOPUserRoot, 0x99d5b872, 0x1ad0, 0x4d87, 0xac, 0xf1, 0x82, 0x12, 0x5d, 0x31, 0x76, 0x53);
//
// GPE Policy SnapIn extension GUIDs
//
// {0F6B957D-509E-11d1-A7CC-0000F87571E3}
DEFINE_GUID(CLSID_PolicySnapInMachine,0xf6b957d, 0x509e, 0x11d1, 0xa7, 0xcc, 0x0, 0x0, 0xf8, 0x75, 0x71, 0xe3);
// {0F6B957E-509E-11d1-A7CC-0000F87571E3}
DEFINE_GUID(CLSID_PolicySnapInUser,0xf6b957e, 0x509e, 0x11d1, 0xa7, 0xcc, 0x0, 0x0, 0xf8, 0x75, 0x71, 0xe3);
//
// RSOP SnapIn extension GUIDs
//
// {B6F9C8AE-EF3A-41c8-A911-37370C331DD4}
DEFINE_GUID(CLSID_RSOPolicySnapInMachine,0xb6f9c8ae, 0xef3a, 0x41c8, 0xa9, 0x11, 0x37, 0x37, 0xc, 0x33, 0x1d, 0xd4);
// {B6F9C8AF-EF3A-41c8-A911-37370C331DD4}
DEFINE_GUID(CLSID_RSOPolicySnapInUser,0xb6f9c8af, 0xef3a, 0x41c8, 0xa9, 0x11, 0x37, 0x37, 0xc, 0x33, 0x1d, 0xd4);
//
// GPE Policy node ids
//
// {0F6B957F-509E-11d1-A7CC-0000F87571E3}
DEFINE_GUID(NODEID_PolicyRootMachine,0xf6b957f, 0x509e, 0x11d1, 0xa7, 0xcc, 0x0, 0x0, 0xf8, 0x75, 0x71, 0xe3);
// {0F6B9580-509E-11d1-A7CC-0000F87571E3}
DEFINE_GUID(NODEID_PolicyRootUser,0xf6b9580, 0x509e, 0x11d1, 0xa7, 0xcc, 0x0, 0x0, 0xf8, 0x75, 0x71, 0xe3);
//
// RSOP node ids
//
// {B6F9C8B0-EF3A-41c8-A911-37370C331DD4}
DEFINE_GUID(NODEID_RSOPolicyRootMachine,0xb6f9c8b0, 0xef3a, 0x41c8, 0xa9, 0x11, 0x37, 0x37, 0xc, 0x33, 0x1d, 0xd4);
// {B6F9C8B1-EF3A-41c8-A911-37370C331DD4}
DEFINE_GUID(NODEID_RSOPolicyRootUser,0xb6f9c8b1, 0xef3a, 0x41c8, 0xa9, 0x11, 0x37, 0x37, 0xc, 0x33, 0x1d, 0xd4);
#define ROOT_NAME_SIZE 50
//
// CPolicyComponentData class
//
class CPolicyComponentData:
public IComponentData,
public IExtendContextMenu,
public IPersistStreamInit,
public ISnapinHelp
{
friend class CPolicyDataObject;
friend class CPolicySnapIn;
protected:
ULONG m_cRef;
HWND m_hwndFrame;
LPCONSOLENAMESPACE2 m_pScope;
LPCONSOLE m_pConsole;
HSCOPEITEM m_hRoot;
HSCOPEITEM m_hSWPolicies;
LPGPEINFORMATION m_pGPTInformation;
LPRSOPINFORMATION m_pRSOPInformation;
LPRSOPREGITEM m_pRSOPRegistryData;
LPOLESTR m_pszNamespace;
DWORD m_bTemplatesColumn;
BOOL m_bUserScope;
BOOL m_bRSOP;
TCHAR m_szRootName[ROOT_NAME_SIZE];
HANDLE m_ADMEvent;
HANDLE m_hTemplateThread;
INT m_iSWPoliciesLen;
INT m_iWinPoliciesLen;
BOOL m_bShowConfigPoliciesOnly;
BOOL m_bUseSupportedOnFilter;
CPolicySnapIn * m_pSnapin;
REGITEM * m_pExtraSettingsRoot;
BOOL m_bExtraSettingsInitialized;
//
// Parsing globals (review)
//
UINT m_nFileLine;
TABLEENTRY *m_pMachineCategoryList; // per-machine category list
UINT m_nMachineDataItems;
TABLEENTRY *m_pUserCategoryList; // per-user category table
UINT m_nUserDataItems;
LPSUPPORTEDENTRY m_pSupportedStrings;
TABLEENTRY *m_pListCurrent; // Current category list (either user or machine)
UINT *m_pnDataItemCount;
BOOL m_bRetrieveString;
LPTSTR m_pszParseFileName; // Template currently being parsed or NULL
// buffer to read .INF file into
TCHAR *m_pFilePtr;
TCHAR *m_pFileEnd;
TCHAR *m_pDefaultStrings;
TCHAR *m_pLanguageStrings;
TCHAR *m_pLocaleStrings;
BOOL m_fInComment;
public:
CPolicyComponentData(BOOL bUser, BOOL bRSOP);
~CPolicyComponentData();
// IUnknown methods
STDMETHODIMP QueryInterface(REFIID, LPVOID FAR *);
STDMETHODIMP_(ULONG) AddRef();
STDMETHODIMP_(ULONG) Release();
//
// Implemented IComponentData methods
//
STDMETHODIMP Initialize(LPUNKNOWN pUnknown);
STDMETHODIMP CreateComponent(LPCOMPONENT* ppComponent);
STDMETHODIMP QueryDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type, LPDATAOBJECT* ppDataObject);
STDMETHODIMP Destroy(void);
STDMETHODIMP Notify(LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param);
STDMETHODIMP GetDisplayInfo(LPSCOPEDATAITEM pItem);
STDMETHODIMP CompareObjects(LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB);
//
// Implemented IExtendContextMenu methods
//
STDMETHODIMP AddMenuItems(LPDATAOBJECT piDataObject, LPCONTEXTMENUCALLBACK pCallback,
LONG *pInsertionAllowed);
STDMETHODIMP Command(LONG lCommandID, LPDATAOBJECT piDataObject);
//
// Implemented IPersistStreamInit interface members
//
STDMETHODIMP GetClassID(CLSID *pClassID);
STDMETHODIMP IsDirty(VOID);
STDMETHODIMP Load(IStream *pStm);
STDMETHODIMP Save(IStream *pStm, BOOL fClearDirty);
STDMETHODIMP GetSizeMax(ULARGE_INTEGER *pcbSize);
STDMETHODIMP InitNew(VOID);
//
// Implemented ISnapinHelp interface members
//
STDMETHODIMP GetHelpTopic(LPOLESTR *lpCompiledHelpFile);
private:
HRESULT EnumerateScopePane(LPDATAOBJECT lpDataObject, HSCOPEITEM hParent);
BOOL CheckForChildCategories (TABLEENTRY *pParent);
#if DBG
VOID DumpEntry (TABLEENTRY * pEntry, UINT uIndent);
VOID DumpCurrentTable (void);
#endif
VOID FreeTemplates (void);
static DWORD LoadTemplatesThread (CPolicyComponentData * pCD);
void AddTemplates(LPTSTR lpDest, LPCTSTR lpValueName, UINT idRes);
void AddDefaultTemplates(LPTSTR lpDest);
void AddNewADMsToExistingGPO (LPTSTR lpDest);
void UpdateExistingTemplates(LPTSTR lpDest);
HRESULT LoadGPOTemplates (void);
BOOL IsSlowLink (LPTSTR lpFileName);
HRESULT AddADMFile (LPTSTR lpFileName, LPTSTR lpFullFileName,
FILETIME *pFileTime, DWORD dwErr, LPRSOPADMFILE *lpHead);
HRESULT LoadRSOPTemplates (void);
HRESULT LoadTemplates (void);
BOOL ParseTemplate (LPTSTR lpFileName);
UINT ParseClass(BOOL *pfMore);
TABLEENTRY * FindCategory(TABLEENTRY *pParent, LPTSTR lpName);
UINT ParseEntry(PARSEENTRYSTRUCT *ppes,BOOL *pfMore, LPTSTR pKeyName);
UINT ParseCategory(TABLEENTRY * pParent, BOOL fParentHasKey,BOOL *pfMore,LPTSTR pKeyName);
static UINT CategoryParseProc(CPolicyComponentData *, UINT nMsg,PARSEPROCSTRUCT * ppps,
BOOL * pfMore,BOOL * pfFoundEnd,LPTSTR pKeyName);
UINT ParsePolicy(TABLEENTRY * pParent,
BOOL fParentHasKey,BOOL *pfMore,LPTSTR pKeyName);
static UINT PolicyParseProc(CPolicyComponentData *, UINT nMsg,PARSEPROCSTRUCT * ppps,
BOOL * pfMore,BOOL * pfFoundEnd,LPTSTR pKeyName);
UINT ParseSettings(TABLEENTRY * pParent,
BOOL fParentHasKey,BOOL *pfMore,LPTSTR pKeyName);
static UINT SettingsParseProc(CPolicyComponentData *pCD, UINT nMsg,PARSEPROCSTRUCT * ppps,
BOOL * pfMore,BOOL * pfFoundEnd,LPTSTR pKeyName);
UINT InitSettingsParse(PARSEPROCSTRUCT *ppps,DWORD dwType,DWORD dwSize,
KEYWORDINFO * pKeyList,SETTINGS ** ppSettings,BYTE **ppObjectData);
UINT ParseValue_W(PARSEPROCSTRUCT * ppps,TCHAR * pszWordBuf,
DWORD cbWordBuf,DWORD * pdwValue,DWORD * pdwFlags,
BOOL * pfMore);
UINT ParseValue(PARSEPROCSTRUCT * ppps,UINT * puOffsetData,
TABLEENTRY ** ppTableEntryNew,BOOL * pfMore);
UINT ParseSuggestions(PARSEPROCSTRUCT * ppps,UINT * puOffsetData,
TABLEENTRY ** ppTableEntryNew,BOOL * pfMore);
UINT ParseActionList(PARSEPROCSTRUCT * ppps,UINT * puOffsetData,
TABLEENTRY ** ppTableEntryNew,
LPCTSTR pszKeyword,BOOL * pfMore);
UINT ParseItemList(PARSEPROCSTRUCT * ppps,UINT * puOffsetData,
BOOL * pfMore);
BOOL AddActionListString(TCHAR * pszData,DWORD cbData,BYTE ** ppBase,UINT * puOffset,
DWORD * pdwAlloc,DWORD *pdwUsed);
BYTE * AddDataToEntry(TABLEENTRY * pTableEntry, BYTE * pData,UINT cbData,
UINT * puOffsetData,DWORD * pdwBufSize);
BOOL CompareKeyword(TCHAR * szWord,KEYWORDINFO *pKeywordList, UINT * pnListIndex);
TCHAR * GetNextWord(TCHAR * szBuf,UINT cbBuf,BOOL * pfMore,
UINT * puErr);
TCHAR * GetNextSectionWord(TCHAR * szBuf,UINT cbBuf,
KEYWORDINFO * pKeywordList, UINT *pnListIndex,
BOOL * pfMore,UINT * puErr);
UINT GetNextSectionNumericWord(UINT * pnVal);
TCHAR * GetNextChar(BOOL * pfMore,UINT * puErr);
BOOL GetString (LPTSTR pStringSection, LPTSTR lpStringName,
LPTSTR lpResult, DWORD dwSize);
BOOL IsComment(TCHAR * pBuf);
BOOL IsQuote(TCHAR * pBuf);
BOOL IsEndOfLine(TCHAR * pBuf);
BOOL IsWhitespace(TCHAR * pBuf);
BOOL IsLocalizedString(TCHAR * pBuf);
VOID DisplayKeywordError(UINT uErrorID,TCHAR * szFound,KEYWORDINFO * pExpectedList);
int MsgBox(HWND hWnd,UINT nResource,UINT uIcon,UINT uButtons);
int MsgBoxSz(HWND hWnd,LPTSTR szText,UINT uIcon,UINT uButtons);
int MsgBoxParam(HWND hWnd,UINT nResource,TCHAR * szReplaceText,UINT uIcon,UINT uButtons);
LPTSTR LoadSz(UINT idString,LPTSTR lpszBuf,UINT cbBuf);
UINT FindMatchingDirective(BOOL *pfMore,BOOL fElseOK);
UINT ProcessIfdefs(TCHAR * pBuf,UINT cbBuf,BOOL * pfMore);
BOOL FreeTable(TABLEENTRY * pTableEntry);
LPTSTR GetStringSection (LPCTSTR lpSection, LPCTSTR lpFileName);
static INT TemplatesSortCallback (LPARAM lParam1, LPARAM lParam2, LPARAM lColumn);
BOOL FillADMFiles (HWND hDlg);
BOOL InitializeTemplatesDlg (HWND hDlg);
BOOL AddTemplates(HWND hDlg);
BOOL RemoveTemplates(HWND hDlg);
static INT_PTR CALLBACK TemplatesDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
BOOL AddRSOPRegistryDataNode(LPTSTR lpKeyName, LPTSTR lpValueName, DWORD dwType,
DWORD dwDataSize, LPBYTE lpData, UINT uiPrecedence,
LPTSTR lpGPOName, BOOL bDeleted);
VOID FreeRSOPRegistryData(VOID);
HRESULT InitializeRSOPRegistryData(VOID);
HRESULT GetGPOFriendlyName(IWbemServices *pIWbemServices,
LPTSTR lpGPOID, BSTR pLanguage,
LPTSTR *pGPOName);
UINT ReadRSOPRegistryValue(HKEY uiPrecedence, TCHAR * pszKeyName,TCHAR * pszValueName,
LPBYTE pData, DWORD dwMaxSize, DWORD *dwType,
LPTSTR *lpGPOName, LPRSOPREGITEM lpItem);
UINT EnumRSOPRegistryValues(HKEY uiPrecedence, TCHAR * pszKeyName,
TCHAR * pszValueName, DWORD dwMaxSize,
LPRSOPREGITEM *lpEnum);
UINT FindRSOPRegistryEntry(HKEY uiPrecedence, TCHAR * pszKeyName,
TCHAR * pszValueName, LPRSOPREGITEM *lpEnum);
VOID DumpRSOPRegistryData (VOID);
VOID InitializeExtraSettings (VOID);
BOOL FindEntryInActionList(POLICY * pPolicy, ACTIONLIST *pActionList, LPTSTR lpKeyName, LPTSTR lpValueName);
BOOL FindEntryInTable(TABLEENTRY * pTable, LPTSTR lpKeyName, LPTSTR lpValueName);
VOID AddEntryToList (TABLEENTRY *pItem);
BOOL DoesNodeExist (LPSUPPORTEDENTRY *pList, LPTSTR lpString);
BOOL CheckSupportedFilter (POLICY *pPolicy);
BOOL IsAnyPolicyAllowedPastFilter(TABLEENTRY * pCategory);
VOID AddSupportedNode (LPSUPPORTEDENTRY *pList, LPTSTR lpString, BOOL bNull);
VOID FreeSupportedData(LPSUPPORTEDENTRY lpList);
VOID InitializeSupportInfo(TABLEENTRY * pTable, LPSUPPORTEDENTRY *pList);
};
//
// ComponentData class factory
//
class CPolicyComponentDataCF : public IClassFactory
{
protected:
ULONG m_cRef;
BOOL m_bUser;
BOOL m_bRSOP;
public:
CPolicyComponentDataCF(BOOL bUser, BOOL bRSOP);
~CPolicyComponentDataCF();
// IUnknown methods
STDMETHODIMP QueryInterface(REFIID, LPVOID FAR *);
STDMETHODIMP_(ULONG) AddRef();
STDMETHODIMP_(ULONG) Release();
// IClassFactory methods
STDMETHODIMP CreateInstance(LPUNKNOWN, REFIID, LPVOID FAR *);
STDMETHODIMP LockServer(BOOL);
};
//
// SnapIn class
//
class CPolicySnapIn:
public IComponent,
public IExtendContextMenu,
public IExtendPropertySheet
{
protected:
ULONG m_cRef;
LPCONSOLE m_pConsole; // Console's IFrame interface
CPolicyComponentData *m_pcd;
LPRESULTDATA m_pResult; // Result pane's interface
LPHEADERCTRL m_pHeader; // Result pane's header control interface
LPCONSOLEVERB m_pConsoleVerb; // pointer the console verb
LPDISPLAYHELP m_pDisplayHelp; // IDisplayHelp interface
WCHAR m_pName[40]; // Name text
WCHAR m_pState[40]; // State text
WCHAR m_pSetting[40]; // Setting text
WCHAR m_pGPOName[40]; // GPO Name text
WCHAR m_pMultipleGPOs[75]; // Multiple GPOs text
INT m_nColumn1Size; // Size of column 1
INT m_nColumn2Size; // Size of column 2
INT m_nColumn3Size; // Size of column 3
LONG m_lViewMode; // View mode
WCHAR m_pEnabled[30]; // Enabled text
WCHAR m_pDisabled[30]; // Disabled text
WCHAR m_pNotConfigured[30]; // Not configured text
BOOL m_bPolicyOnly; // Show policies only
DWORD m_dwPolicyOnlyPolicy; // Policy for enforcing Show Policies Only
HWND m_hMsgWindow; // Hidden message window
POLICY *m_pCurrentPolicy; // Currently selected policy
HWND m_hPropDlg; // Properties dialog
HICON m_hPolicyIcon; // Policy icon
HICON m_hPreferenceIcon; // Preference icon
BOOL m_bDirty; // Has something changed in the policy UI
HHOOK m_hKbdHook; // Keyboard hook handle
static unsigned int m_cfNodeType;
public:
UINT m_uiRefreshMsg; // Reload the adm namespace
CPolicySnapIn(CPolicyComponentData *pComponent);
~CPolicySnapIn();
//
// IUnknown methods
//
STDMETHODIMP QueryInterface(REFIID, LPVOID FAR *);
STDMETHODIMP_(ULONG) AddRef();
STDMETHODIMP_(ULONG) Release();
//
// Implemented IComponent methods
//
STDMETHODIMP Initialize(LPCONSOLE);
STDMETHODIMP Destroy(MMC_COOKIE);
STDMETHODIMP Notify(LPDATAOBJECT, MMC_NOTIFY_TYPE, LPARAM, LPARAM);
STDMETHODIMP QueryDataObject(MMC_COOKIE, DATA_OBJECT_TYPES, LPDATAOBJECT *);
STDMETHODIMP GetDisplayInfo(LPRESULTDATAITEM);
STDMETHODIMP GetResultViewType(MMC_COOKIE, LPOLESTR*, long*);
STDMETHODIMP CompareObjects(LPDATAOBJECT, LPDATAOBJECT);
//
// Implemented IExtendContextMenu methods
//
STDMETHODIMP AddMenuItems(LPDATAOBJECT piDataObject, LPCONTEXTMENUCALLBACK pCallback,
LONG *pInsertionAllowed);
STDMETHODIMP Command(LONG lCommandID, LPDATAOBJECT piDataObject);
//
// Implemented IExtendPropertySheet methods
//
STDMETHODIMP CreatePropertyPages(LPPROPERTYSHEETCALLBACK lpProvider,
LONG_PTR handle, LPDATAOBJECT lpDataObject);
STDMETHODIMP QueryPagesFor(LPDATAOBJECT lpDataObject);
BOOL IsAnyPolicyEnabled(TABLEENTRY * pCategory);
private:
VOID RefreshSettingsControls(HWND hDlg);
HRESULT UpdateItemWorker (VOID);
HRESULT MoveFocusWorker (BOOL bPrevious);
HRESULT MoveFocus (HWND hDlg, BOOL bPrevious);
HRESULT SetPrevNextButtonState (HWND hDlg);
HRESULT SetPrevNextButtonStateWorker (HWND hDlg);
static INT_PTR CALLBACK PolicyDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
static INT_PTR CALLBACK PolicyHelpDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
static INT_PTR CALLBACK PolicyPrecedenceDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
static LRESULT CALLBACK KeyboardHookProc(int nCode, WPARAM wParam,LPARAM lParam);
VOID SetKeyboardHook(HWND hDlg);
VOID RemoveKeyboardHook(VOID);
INT GetPolicyState (TABLEENTRY *pTableEntry, UINT uiPrecedence, LPTSTR *lpGPOName);
BOOL CheckActionList (POLICY * pPolicy, HKEY hKeyRoot, BOOL bActionListOn, LPTSTR *lpGPOName);
UINT LoadSettings(TABLEENTRY * pTableEntry,HKEY hkeyRoot,
DWORD * pdwFound, LPTSTR *lpGPOName);
UINT LoadListboxData(TABLEENTRY * pTableEntry,HKEY hkeyRoot,
TCHAR * pszCurrentKeyName,DWORD * pdwFound, HGLOBAL * phGlobal, LPTSTR *lpGPOName);
BOOL ReadCustomValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
TCHAR * pszValue,UINT cbValue,DWORD * pdwValue,DWORD * pdwFlags,LPTSTR *lpGPOName);
BOOL CompareCustomValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
STATEVALUE * pStateValue,DWORD * pdwFound, LPTSTR *lpGPOName);
BOOL ReadStandardValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
TABLEENTRY * pTableEntry,DWORD * pdwData,DWORD * pdwFound, LPTSTR *lpGPOName);
VOID PrependValueName(TCHAR * pszValueName,DWORD dwFlags,TCHAR * pszNewValueName,
UINT cbNewValueName);
UINT WriteRegistryDWordValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName, DWORD dwValue);
UINT ReadRegistryDWordValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
DWORD * pdwValue, LPTSTR *lpGPOName);
UINT WriteRegistryStringValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
TCHAR * pszValue, BOOL bExpandable);
UINT ReadRegistryStringValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
TCHAR * pszValue,UINT cbValue, LPTSTR *lpGPOName);
UINT DeleteRegistryValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName);
UINT WriteCustomValue_W(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
TCHAR * pszValue,DWORD dwValue,DWORD dwFlags,BOOL fErase);
UINT WriteCustomValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
STATEVALUE * pStateValue,BOOL fErase);
UINT WriteStandardValue(HKEY hkeyRoot,TCHAR * pszKeyName,TCHAR * pszValueName,
TABLEENTRY * pTableEntry,DWORD dwData,BOOL fErase,
BOOL fWriteZero);
TCHAR * ResizeBuffer(TCHAR *pBuf,HGLOBAL hBuf,DWORD dwNeeded,DWORD * pdwCurSize);
static LRESULT CALLBACK MessageWndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam);
static LRESULT CALLBACK ClipWndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam);
VOID ProcessCommand(HWND hWnd,WPARAM wParam,HWND hwndCtrl, POLICYDLGINFO * pdi);
VOID EnsureSettingControlVisible(HWND hDlg,HWND hwndCtrl);
VOID ProcessScrollBar(HWND hWnd,WPARAM wParam,BOOL bVert);
VOID FreeSettingsControls(HWND hDlg);
VOID InsertComboboxItems(HWND hwndControl,TCHAR * pSuggestionList);
BOOL CreateSettingsControls(HWND hDlg,SETTINGS * pSetting,BOOL fEnable);
HWND CreateSetting(POLICYDLGINFO * pdi,TCHAR * pszClassName,TCHAR * pszWindowName,
DWORD dwExStyle,DWORD dwStyle,int x,int y,int cx,int cy,DWORD dwType,UINT uIndex,
SETTINGS * pSetting, HFONT hFontDlg);
BOOL SetWindowData(POLICYDLGINFO * pdi,HWND hwndControl,DWORD dwType,
UINT uDataIndex,SETTINGS * pSetting);
int AddControlHwnd(POLICYDLGINFO * pdi,POLICYCTRLINFO * pPolicyCtrlInfo);
BOOL AdjustWindowToText(HWND hWnd,TCHAR * szText,UINT xStart,UINT yStart,
UINT yPad,UINT * pnWidth,UINT * pnHeight, HFONT hFontDlg);
BOOL GetTextSize(HWND hWnd,TCHAR * szText,SIZE * pSize, HFONT hFontDlg);
HRESULT SaveSettings(HWND hDlg);
VOID DeleteOldListboxData(SETTINGS * pSetting,HKEY hkeyRoot, TCHAR * pszCurrentKeyName);
UINT SaveListboxData(HGLOBAL hData,SETTINGS * pSetting,HKEY hkeyRoot,
TCHAR * pszCurrentKeyName,BOOL fErase,BOOL fMarkDeleted, BOOL bEnabled, BOOL *bFoundNone);
UINT ProcessCheckboxActionLists(HKEY hkeyRoot,TABLEENTRY * pTableEntry,
TCHAR * pszCurrentKeyName,DWORD dwData,
BOOL fErase, BOOL fMarkAsDeleted,BOOL bPolicy);
UINT WriteActionList(HKEY hkeyRoot,ACTIONLIST * pActionList,
LPTSTR pszCurrentKeyName,BOOL fErase, BOOL fMarkAsDeleted);
int FindComboboxItemData(HWND hwndControl,UINT nData);
HRESULT InitializeSettingsControls(HWND hDlg, BOOL fEnable);
VOID ShowListbox(HWND hParent,SETTINGS * pSettings);
static INT_PTR CALLBACK ShowListboxDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam);
BOOL InitShowlistboxDlg(HWND hDlg);
BOOL ProcessShowlistboxDlg(HWND hDlg);
VOID EnableShowListboxButtons(HWND hDlg);
VOID ListboxRemove(HWND hDlg,HWND hwndListbox);
VOID ListboxAdd(HWND hwndListbox, BOOL fExplicitValName,BOOL fValuePrefix);
static INT_PTR CALLBACK ListboxAddDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
void InitializeFilterDialog (HWND hDlg);
static INT_PTR CALLBACK FilterDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
LRESULT CallNextHook(int nCode, WPARAM wParam, LPARAM lParam);
};
//
// Structure passed to Settings / Properties dialog
//
typedef struct tagSETTINGSINFO {
CPolicySnapIn * pCS;
POLICYDLGINFO * pdi;
HFONT hFontDlg;
} SETTINGSINFO, *LPSETTINGSINFO;
//
// From listbox.c
//
typedef struct tagLISTBOXDLGINFO {
CPolicySnapIn * pCS;
SETTINGS * pSettings;
HGLOBAL hData;
} LISTBOXDLGINFO;
typedef struct tagADDITEMINFO {
CPolicySnapIn * pCS;
BOOL fExplicitValName;
BOOL fValPrefix;
HWND hwndListbox;
TCHAR szValueName[MAX_PATH+1]; // only used if fExplicitValName is set
TCHAR szValueData[MAX_PATH+1];
} ADDITEMINFO;
//
// IPolicyDataObject interface id
//
// {0F6B9580-509E-11d1-A7CC-0000F87571E3}
DEFINE_GUID(IID_IPolicyDataObject,0xf6b9580, 0x509e, 0x11d1, 0xa7, 0xcc, 0x0, 0x0, 0xf8, 0x75, 0x71, 0xe3);
//
// This is a private dataobject interface for GPTs.
// When the GPT snapin receives a dataobject and needs to determine
// if it came from the GPT snapin or a different component, it can QI for
// this interface.
//
#undef INTERFACE
#define INTERFACE IPolicyDataObject
DECLARE_INTERFACE_(IPolicyDataObject, IUnknown)
{
// *** IUnknown methods ***
STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID * ppvObj) PURE;
STDMETHOD_(ULONG,AddRef) (THIS) PURE;
STDMETHOD_(ULONG,Release) (THIS) PURE;
// *** IPolicyDataObject methods ***
STDMETHOD(SetType) (THIS_ DATA_OBJECT_TYPES type) PURE;
STDMETHOD(GetType) (THIS_ DATA_OBJECT_TYPES *type) PURE;
STDMETHOD(SetCookie) (THIS_ MMC_COOKIE cookie) PURE;
STDMETHOD(GetCookie) (THIS_ MMC_COOKIE *cookie) PURE;
};
typedef IPolicyDataObject *LPPOLICYDATAOBJECT;
//
// CPolicyDataObject class
//
class CPolicyDataObject : public IDataObject,
public IPolicyDataObject
{
friend class CPolicySnapIn;
protected:
ULONG m_cRef;
CPolicyComponentData *m_pcd;
DATA_OBJECT_TYPES m_type;
MMC_COOKIE m_cookie;
//
// Clipboard formats that are required by the console
//
static unsigned int m_cfNodeType;
static unsigned int m_cfNodeTypeString;
static unsigned int m_cfDisplayName;
static unsigned int m_cfCoClass;
static unsigned int m_cfDescription;
static unsigned int m_cfHTMLDetails;
public:
CPolicyDataObject(CPolicyComponentData *pComponent);
~CPolicyDataObject();
//
// IUnknown methods
//
STDMETHODIMP QueryInterface(REFIID, LPVOID FAR *);
STDMETHODIMP_(ULONG) AddRef();
STDMETHODIMP_(ULONG) Release();
//
// Implemented IDataObject methods
//
STDMETHOD(GetDataHere)(LPFORMATETC lpFormatetc, LPSTGMEDIUM lpMedium);
//
// Unimplemented IDataObject methods
//
STDMETHOD(GetData)(LPFORMATETC lpFormatetcIn, LPSTGMEDIUM lpMedium)
{ return E_NOTIMPL; };
STDMETHOD(EnumFormatEtc)(DWORD dwDirection, LPENUMFORMATETC* ppEnumFormatEtc)
{ return E_NOTIMPL; };
STDMETHOD(QueryGetData)(LPFORMATETC lpFormatetc)
{ return E_NOTIMPL; };
STDMETHOD(GetCanonicalFormatEtc)(LPFORMATETC lpFormatetcIn, LPFORMATETC lpFormatetcOut)
{ return E_NOTIMPL; };
STDMETHOD(SetData)(LPFORMATETC lpFormatetc, LPSTGMEDIUM lpMedium, BOOL bRelease)
{ return E_NOTIMPL; };
STDMETHOD(DAdvise)(LPFORMATETC lpFormatetc, DWORD advf,
LPADVISESINK pAdvSink, LPDWORD pdwConnection)
{ return E_NOTIMPL; };
STDMETHOD(DUnadvise)(DWORD dwConnection)
{ return E_NOTIMPL; };
STDMETHOD(EnumDAdvise)(LPENUMSTATDATA* ppEnumAdvise)
{ return E_NOTIMPL; };
//
// Implemented IPolicyDataObject methods
//
STDMETHOD(SetType) (DATA_OBJECT_TYPES type)
{ m_type = type; return S_OK; };
STDMETHOD(GetType) (DATA_OBJECT_TYPES *type)
{ *type = m_type; return S_OK; };
STDMETHOD(SetCookie) (MMC_COOKIE cookie)
{ m_cookie = cookie; return S_OK; };
STDMETHOD(GetCookie) (MMC_COOKIE *cookie)
{ *cookie = m_cookie; return S_OK; };
private:
HRESULT CreateNodeTypeData(LPSTGMEDIUM lpMedium);
HRESULT CreateNodeTypeStringData(LPSTGMEDIUM lpMedium);
HRESULT CreateDisplayName(LPSTGMEDIUM lpMedium);
HRESULT CreateCoClassID(LPSTGMEDIUM lpMedium);
HRESULT Create(LPVOID pBuffer, INT len, LPSTGMEDIUM lpMedium);
};
VOID LoadMessage (DWORD dwID, LPTSTR lpBuffer, DWORD dwSize);
BOOL ReportAdmError (HWND hParent, DWORD dwError, UINT idMsg, ...);
Reference in a new issue Copy permalink