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.
2802 lines
85 KiB
2802 lines
85 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 2000 - 2001.
|
|
//
|
|
// File: headers.h
|
|
//
|
|
// Contents:
|
|
//
|
|
// History: 07-26-2001 Hiteshr Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#include "headers.h"
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:IsValidStoreType
|
|
// Synopsis:Vaildates the store type
|
|
//-----------------------------------------------------------------------------
|
|
BOOL IsValidStoreType(ULONG lStoreType)
|
|
{
|
|
if((lStoreType == AZ_ADMIN_STORE_XML) ||
|
|
(lStoreType == AZ_ADMIN_STORE_AD))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: AddColumnToListView
|
|
// Synopsis: Add Columns to Listview and set column width according to
|
|
// percentage specified in the COL_FOR_LV
|
|
// Arguments:IN pListCtrl: ListCtrl pointer
|
|
// IN pColForLV: Column Infomration Array
|
|
//
|
|
// Returns:
|
|
//-----------------------------------------------------------------------------
|
|
VOID
|
|
AddColumnToListView(IN CListCtrl* pListCtrl,
|
|
IN COL_FOR_LV* pColForLV)
|
|
{
|
|
if(!pListCtrl || !pColForLV)
|
|
{
|
|
ASSERT(pListCtrl);
|
|
ASSERT(pColForLV);
|
|
}
|
|
|
|
UINT iTotal = 0;
|
|
RECT rc;
|
|
|
|
pListCtrl->GetClientRect(&rc);
|
|
|
|
for( UINT iCol = 0; pColForLV[iCol].idText != LAST_COL_ENTRY_IDTEXT; ++iCol)
|
|
{
|
|
CString strHeader;
|
|
VERIFY(strHeader.LoadString(pColForLV[iCol].idText));
|
|
LV_COLUMN col;
|
|
col.mask = LVCF_FMT | LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH;
|
|
col.fmt = LVCFMT_LEFT;
|
|
col.pszText = (LPWSTR)(LPCTSTR)strHeader;
|
|
col.iSubItem = iCol;
|
|
|
|
col.cx = (rc.right * pColForLV[iCol].iPercent) / 100;
|
|
|
|
pListCtrl->InsertColumn(iCol,&col);
|
|
iTotal += col.cx;
|
|
}
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: BaseAzInListCtrl
|
|
// Synopsis: Checks if Object of type eObjectTypeAz named strName is
|
|
// in the Listview. If its present, returns
|
|
// its index else returns -1.
|
|
// Arguments:IN pListCtrl: ListCtrl pointer
|
|
// IN strName: string to search for
|
|
// IN eObjectTypeAz Compare the object of this type only
|
|
//
|
|
// Returns: If its present, returns its index else returns -1
|
|
//-----------------------------------------------------------------------------
|
|
int
|
|
BaseAzInListCtrl(IN CListCtrl* pListCtrl,
|
|
IN const CString& strName,
|
|
IN OBJECT_TYPE_AZ eObjectTypeAz)
|
|
{
|
|
if(!pListCtrl)
|
|
{
|
|
ASSERT(pListCtrl);
|
|
return -1;
|
|
}
|
|
|
|
int iCount = pListCtrl->GetItemCount();
|
|
for( int i = 0; i < iCount; ++i)
|
|
{
|
|
CBaseAz* pBaseAz = (CBaseAz*)pListCtrl->GetItemData(i);
|
|
if(pBaseAz)
|
|
{
|
|
if((pBaseAz->GetObjectType() == eObjectTypeAz) &&
|
|
(pBaseAz->GetName() == strName))
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: AddBaseAzFromListToListCtrl
|
|
// Synopsis: Take the items from List and Add them to ListCtrl. Doesn't
|
|
// add the items which are already in ListCtrl
|
|
// Arguments:listBaseAz: List of items
|
|
// pListCtrl: ListControl Pointer
|
|
// uiFlags : Column Info
|
|
// bCheckDuplicate: Check for duplicate items
|
|
// Returns: The index of the new item if it is successful; otherwise, -1
|
|
// NOTE: Function assume the Order of column is Name, Type and Description
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
AddBaseAzFromListToListCtrl(IN CList<CBaseAz*, CBaseAz*>& listBaseAz,
|
|
IN CListCtrl* pListCtrl,
|
|
IN UINT uiFlags,
|
|
IN BOOL bCheckDuplicate)
|
|
{
|
|
//Remember index of selected item
|
|
int iFirstSelectedItem = pListCtrl->GetNextItem(-1, LVIS_SELECTED);
|
|
|
|
POSITION pos = listBaseAz.GetHeadPosition();
|
|
|
|
for (int i = 0; i < listBaseAz.GetCount(); i++)
|
|
{
|
|
CBaseAz* pBaseAz = listBaseAz.GetNext(pos);
|
|
|
|
//Check if item is in ListControl
|
|
if(!bCheckDuplicate ||
|
|
BaseAzInListCtrl(pListCtrl,
|
|
pBaseAz->GetName(),
|
|
pBaseAz->GetObjectType()) == -1)
|
|
{
|
|
VERIFY( AddBaseAzToListCtrl(pListCtrl,
|
|
pListCtrl->GetItemCount(),
|
|
pBaseAz,
|
|
uiFlags) != -1);
|
|
|
|
}
|
|
}
|
|
|
|
//Restore Selection
|
|
if(pListCtrl->GetItemCount() <= iFirstSelectedItem)
|
|
--iFirstSelectedItem;
|
|
|
|
SelectListCtrlItem(pListCtrl, iFirstSelectedItem);
|
|
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: AddActionItemFromListToListCtrl
|
|
// Synopsis: Take the Actions items from List and Add them to ListCtrl.
|
|
// Arguments:listBaseAz: List of items
|
|
// pListCtrl: ListControl Pointer
|
|
// uiFlags : Column Info
|
|
// bCheckDuplicate: Check for duplicate items
|
|
// Returns: The index of the new item if it is successful; otherwise, -1
|
|
// NOTE: Function assume the Order of column is Name, Type and Description
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
AddActionItemFromListToListCtrl(IN CList<ActionItem*, ActionItem*>& listActionItem,
|
|
IN CListCtrl* pListCtrl,
|
|
IN UINT uiFlags,
|
|
IN BOOL bCheckDuplicate)
|
|
{
|
|
//Remember index of selected item
|
|
int iFirstSelectedItem = pListCtrl->GetNextItem(-1, LVIS_SELECTED);
|
|
|
|
POSITION pos = listActionItem.GetHeadPosition();
|
|
for (int i = 0; i < listActionItem.GetCount(); i++)
|
|
{
|
|
ActionItem* pActionItem = listActionItem.GetNext(pos);
|
|
|
|
if(pActionItem->action == ACTION_REMOVE ||
|
|
pActionItem->action == ACTION_REMOVED)
|
|
continue;
|
|
|
|
//Check if item is in ListControl
|
|
if(!bCheckDuplicate ||
|
|
BaseAzInListCtrl(pListCtrl,
|
|
(pActionItem->m_pMemberAz)->GetName(),
|
|
(pActionItem->m_pMemberAz)->GetObjectType()) == -1)
|
|
{
|
|
VERIFY( AddActionItemToListCtrl(pListCtrl,
|
|
pListCtrl->GetItemCount(),
|
|
pActionItem,
|
|
uiFlags) != -1);
|
|
|
|
}
|
|
}
|
|
|
|
//Restore Selection
|
|
if(pListCtrl->GetItemCount() <= iFirstSelectedItem)
|
|
--iFirstSelectedItem;
|
|
|
|
SelectListCtrlItem(pListCtrl, iFirstSelectedItem);
|
|
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: AddActionItemFromMapToListCtrl
|
|
// Synopsis: Take the Actions items from Map and Add them to ListCtrl.
|
|
// Arguments:listBaseAz: List of items
|
|
// pListCtrl: ListControl Pointer
|
|
// uiFlags : Column Info
|
|
// bCheckDuplicate: Check for duplicate items
|
|
// Returns: The index of the new item if it is successful; otherwise, -1
|
|
// NOTE: Function assume the Order of column is Name, Type and Description
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
AddActionItemFromMapToListCtrl(IN ActionMap& mapActionItem,
|
|
IN CListCtrl* pListCtrl,
|
|
IN UINT uiFlags,
|
|
IN BOOL bCheckDuplicate)
|
|
{
|
|
//Remember index of selected item
|
|
int iFirstSelectedItem = pListCtrl->GetNextItem(-1, LVIS_SELECTED);
|
|
|
|
for (ActionMap::iterator it = mapActionItem.begin();
|
|
it != mapActionItem.end();
|
|
++it)
|
|
{
|
|
ActionItem* pActionItem = (*it).second;
|
|
|
|
if(pActionItem->action == ACTION_REMOVE ||
|
|
pActionItem->action == ACTION_REMOVED)
|
|
continue;
|
|
|
|
//Check if item is in ListControl
|
|
if(!bCheckDuplicate ||
|
|
BaseAzInListCtrl(pListCtrl,
|
|
(pActionItem->m_pMemberAz)->GetName(),
|
|
(pActionItem->m_pMemberAz)->GetObjectType()) == -1)
|
|
{
|
|
VERIFY( AddActionItemToListCtrl(pListCtrl,
|
|
pListCtrl->GetItemCount(),
|
|
pActionItem,
|
|
uiFlags) != -1);
|
|
|
|
}
|
|
}
|
|
|
|
//Restore Selection
|
|
if(pListCtrl->GetItemCount() <= iFirstSelectedItem)
|
|
--iFirstSelectedItem;
|
|
|
|
SelectListCtrlItem(pListCtrl, iFirstSelectedItem);
|
|
}
|
|
//+----------------------------------------------------------------------------
|
|
// Function: AddBaseAzToListCtrl
|
|
// Synopsis: Adds a new item to ListCtrl.
|
|
// Arguments:pListCtrl: ListControl Pointer
|
|
// iIndex: Index at which to Add
|
|
// pBaseAz: Item to add
|
|
// uiFlags: column info
|
|
// Returns: The index of the new item if it is successful; otherwise, -1
|
|
//-----------------------------------------------------------------------------
|
|
int
|
|
AddBaseAzToListCtrl(IN CListCtrl* pListCtrl,
|
|
IN int iIndex,
|
|
IN CBaseAz* pBaseAz,
|
|
IN UINT uiFlags)
|
|
{
|
|
if(!pListCtrl || !pBaseAz)
|
|
{
|
|
ASSERT(pListCtrl);
|
|
ASSERT(pBaseAz);
|
|
return -1;
|
|
}
|
|
|
|
//Add Name and Item Data
|
|
CString strName = pBaseAz->GetName();
|
|
int iNewIndex = pListCtrl->InsertItem(LVIF_TEXT|LVIF_STATE|LVIF_PARAM|LVIF_IMAGE,
|
|
iIndex,strName,0,0,
|
|
pBaseAz->GetImageIndex(),
|
|
(LPARAM)pBaseAz);
|
|
|
|
if(iNewIndex == -1)
|
|
return iNewIndex;
|
|
|
|
int iCol = 1;
|
|
|
|
if(uiFlags & COL_TYPE )
|
|
{
|
|
CString strType = pBaseAz->GetType();
|
|
pListCtrl->SetItemText(iNewIndex,
|
|
iCol,
|
|
(LPWSTR)(LPCTSTR)strType);
|
|
iCol++;
|
|
}
|
|
|
|
if(uiFlags & COL_PARENT_TYPE)
|
|
{
|
|
CString strParentType = pBaseAz->GetParentType();
|
|
pListCtrl->SetItemText(iNewIndex,
|
|
iCol,
|
|
(LPWSTR)(LPCTSTR)strParentType);
|
|
iCol++;
|
|
}
|
|
|
|
if(uiFlags & COL_DESCRIPTION)
|
|
{
|
|
//Add Description
|
|
CString strDesc = pBaseAz->GetDescription();
|
|
pListCtrl->SetItemText(iNewIndex,
|
|
iCol,
|
|
(LPWSTR)(LPCTSTR)strDesc);
|
|
}
|
|
|
|
return iNewIndex;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: AddActionItemToListCtrl
|
|
// Synopsis: Adds a new item to ListCtrl.
|
|
// Arguments:pListCtrl: ListControl Pointer
|
|
// iIndex: Index at which to Add
|
|
// pActionItem: Item to add
|
|
// uiFlags: column info
|
|
// Returns: The index of the new item if it is successful; otherwise, -1
|
|
//-----------------------------------------------------------------------------
|
|
int
|
|
AddActionItemToListCtrl(IN CListCtrl* pListCtrl,
|
|
IN int iIndex,
|
|
IN ActionItem* pActionItem,
|
|
IN UINT uiFlags)
|
|
{
|
|
if(!pListCtrl || !pActionItem)
|
|
{
|
|
ASSERT(pListCtrl);
|
|
ASSERT(pActionItem);
|
|
return -1;
|
|
}
|
|
|
|
CBaseAz* pBaseAz = pActionItem->m_pMemberAz;
|
|
|
|
//Add Name and Item Data
|
|
CString strName = pBaseAz->GetName();
|
|
int iNewIndex = pListCtrl->InsertItem(LVIF_TEXT|LVIF_STATE|LVIF_PARAM|LVIF_IMAGE,
|
|
iIndex,
|
|
strName,
|
|
0,0,
|
|
pBaseAz->GetImageIndex(),
|
|
(LPARAM)pActionItem);
|
|
|
|
if(iNewIndex == -1)
|
|
return iNewIndex;
|
|
|
|
int iCol = 1;
|
|
|
|
if(uiFlags & COL_TYPE )
|
|
{
|
|
CString strType = pBaseAz->GetType();
|
|
pListCtrl->SetItemText(iNewIndex,
|
|
iCol,
|
|
(LPWSTR)(LPCTSTR)strType);
|
|
iCol++;
|
|
}
|
|
|
|
if(uiFlags & COL_PARENT_TYPE)
|
|
{
|
|
CString strParentType = pBaseAz->GetParentType();
|
|
pListCtrl->SetItemText(iNewIndex,
|
|
iCol,
|
|
(LPWSTR)(LPCTSTR)strParentType);
|
|
iCol++;
|
|
|
|
}
|
|
|
|
if(uiFlags & COL_DESCRIPTION)
|
|
{
|
|
//Add Description
|
|
CString strDesc = pBaseAz->GetDescription();
|
|
pListCtrl->SetItemText(iNewIndex,
|
|
iCol,
|
|
(LPWSTR)(LPCTSTR)strDesc);
|
|
}
|
|
|
|
return iNewIndex;
|
|
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: EnableButtonIfSelectedInListCtrl
|
|
// Synopsis: Enables the button if something is selected in Listctrl
|
|
// Arguments:
|
|
// Returns: TRUE if Enabled the button, FALSE if didn't.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
EnableButtonIfSelectedInListCtrl(IN CListCtrl * pListCtrl,
|
|
IN CButton* pButton)
|
|
{
|
|
if(!pListCtrl || !pButton)
|
|
{
|
|
ASSERT(pListCtrl);
|
|
ASSERT(pButton);
|
|
return FALSE;
|
|
}
|
|
|
|
int nSelectedItem = pListCtrl->GetNextItem(-1, LVIS_SELECTED);
|
|
|
|
if (nSelectedItem != -1)
|
|
{
|
|
pButton->EnableWindow(TRUE);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
if(pButton->GetFocus() == pButton)
|
|
pListCtrl->SetFocus();
|
|
pButton->EnableWindow(FALSE);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: DeleteSelectedRows
|
|
// Synopsis: Deletes the selected rows
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
DeleteSelectedRows(IN CListCtrl* pListCtrl)
|
|
{
|
|
//Remember the Position of first selected entry.
|
|
//In the end set the position back to it
|
|
int iFirstSelectedItem = pListCtrl->GetNextItem(-1, LVIS_SELECTED);
|
|
|
|
int iSelectedItem = -1;
|
|
while( (iSelectedItem = pListCtrl->GetNextItem(-1, LVIS_SELECTED)) != -1)
|
|
{
|
|
pListCtrl->DeleteItem(iSelectedItem);
|
|
}
|
|
|
|
if(pListCtrl->GetItemCount() <= iFirstSelectedItem)
|
|
--iFirstSelectedItem;
|
|
|
|
SelectListCtrlItem(pListCtrl, iFirstSelectedItem);
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: SelectListCtrlItem
|
|
// Synopsis: Select the item in List Ctrl and mark it visible
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
SelectListCtrlItem(IN CListCtrl* pListCtrl,
|
|
IN int iSelected)
|
|
{
|
|
if(iSelected == -1)
|
|
iSelected = 0;
|
|
pListCtrl->SetItemState(iSelected,
|
|
LVIS_SELECTED| LVIS_FOCUSED,
|
|
LVIS_SELECTED| LVIS_FOCUSED);
|
|
pListCtrl->EnsureVisible(iSelected,FALSE);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: AddBaseAzItemsFromListCtrlToList
|
|
// Synopsis: Add items from ListCtrl to List
|
|
//-----------------------------------------------------------------------------
|
|
VOID
|
|
AddBaseAzItemsFromListCtrlToList(IN CListCtrl* pListCtrl,
|
|
OUT CList<CBaseAz*,CBaseAz*>& listBaseAz)
|
|
{
|
|
if(!pListCtrl)
|
|
{
|
|
ASSERT(pListCtrl);
|
|
return;
|
|
}
|
|
|
|
int iCount = pListCtrl->GetItemCount();
|
|
for( int i = 0; i < iCount; ++i)
|
|
{
|
|
CBaseAz* pBaseAz = (CBaseAz*)pListCtrl->GetItemData(i);
|
|
listBaseAz.AddTail(pBaseAz);
|
|
}
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Synopsis: Gets long value from Edit box
|
|
// Returns: FALSE if edit box is empty. Assumes only numeric can be entered
|
|
// in edit box
|
|
//-----------------------------------------------------------------------------
|
|
GetLongValue(CEdit& refEdit, LONG& reflValue, HWND hWnd)
|
|
{
|
|
CString strValue;
|
|
refEdit.GetWindowText(strValue);
|
|
if(strValue.IsEmpty())
|
|
{
|
|
reflValue = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
return ConvertStringToLong(strValue, reflValue, hWnd);
|
|
}
|
|
//+----------------------------------------------------------------------------
|
|
// Synopsis: Sets long value in Edit box
|
|
//-----------------------------------------------------------------------------
|
|
VOID SetLongValue(CEdit* pEdit, LONG lValue)
|
|
{
|
|
//Maximum required size for _itow is 33.
|
|
//When radix is 2, 32 char for 32bits + NULL terminator
|
|
|
|
WCHAR buffer[33];
|
|
_ltow(lValue,buffer,10);
|
|
pEdit->SetWindowText(buffer);
|
|
return;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Synopsis: Converts a sid in binary format to a sid in string format
|
|
//-----------------------------------------------------------------------------
|
|
BOOL ConvertSidToStringSid(IN PSID pSid, OUT CString* pstrSid)
|
|
{
|
|
if(!pSid || !pstrSid)
|
|
{
|
|
ASSERT(pSid);
|
|
ASSERT(pstrSid);
|
|
return FALSE;
|
|
}
|
|
|
|
LPWSTR pszSid = NULL;
|
|
if(ConvertSidToStringSid(pSid, &pszSid))
|
|
{
|
|
ASSERT(pszSid);
|
|
*pstrSid = pszSid;
|
|
LocalFree(pszSid);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Synopsis: Converts a sid in string format to sid in binary format
|
|
//-----------------------------------------------------------------------------
|
|
BOOL ConvertStringSidToSid(IN const CString& strSid, OUT PSID *ppSid)
|
|
{
|
|
if(!ppSid)
|
|
{
|
|
ASSERT(ppSid);
|
|
return FALSE;
|
|
}
|
|
return ::ConvertStringSidToSid((LPCTSTR)strSid,ppSid);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:GetStringSidFromSidCachecAz
|
|
// Synopsis:Gets the string sid from CSidCacheAz object
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
GetStringSidFromSidCachecAz(CBaseAz* pBaseAz,
|
|
CString* pstrStringSid)
|
|
{
|
|
if(!pBaseAz || !pstrStringSid)
|
|
{
|
|
ASSERT(pBaseAz);
|
|
ASSERT(pstrStringSid);
|
|
return FALSE;
|
|
}
|
|
|
|
CSidCacheAz *pSidCacheAz = dynamic_cast<CSidCacheAz*>(pBaseAz);
|
|
if(!pSidCacheAz)
|
|
{
|
|
ASSERT(pSidCacheAz);
|
|
return FALSE;
|
|
}
|
|
|
|
return ConvertSidToStringSid(pSidCacheAz->GetSid(), pstrStringSid);
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: AddAzObjectNodesToList
|
|
// Synopsis: Adds the nodes for object of type eObjectType to the Container
|
|
// node.
|
|
// Arguments:IN eObjectType: Type of object
|
|
// IN listAzChildObject: List of objects to be added
|
|
// IN pContainerNode: Container in snapin to which new nodes will
|
|
// be added.
|
|
// Returns:
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT
|
|
AddAzObjectNodesToList(IN OBJECT_TYPE_AZ eObjectType,
|
|
IN CList<CBaseAz*, CBaseAz*>& listAzChildObject,
|
|
IN CBaseContainerNode* pContainerNode)
|
|
{
|
|
if(!pContainerNode)
|
|
{
|
|
ASSERT(pContainerNode);
|
|
return E_POINTER;
|
|
}
|
|
switch (eObjectType)
|
|
{
|
|
|
|
case APPLICATION_AZ:
|
|
return ADD_APPLICATION_FUNCTION::DoEnum(listAzChildObject,pContainerNode);
|
|
case SCOPE_AZ:
|
|
return ADD_SCOPE_FUNCTION::DoEnum(listAzChildObject,pContainerNode);
|
|
case GROUP_AZ:
|
|
return ADD_GROUP_FUNCTION::DoEnum(listAzChildObject,pContainerNode);
|
|
case TASK_AZ:
|
|
return ADD_TASK_FUNCTION::DoEnum(listAzChildObject,pContainerNode);
|
|
case ROLE_AZ:
|
|
return ADD_ROLE_FUNCTION::DoEnum(listAzChildObject,pContainerNode);
|
|
case OPERATION_AZ:
|
|
return ADD_OPERATION_FUNCTION::DoEnum(listAzChildObject,pContainerNode);
|
|
}
|
|
|
|
ASSERT(FALSE);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
//Error Handling and Message Display Routines
|
|
//
|
|
VOID
|
|
vFormatString(CString &strOutput, UINT nIDPrompt, va_list *pargs)
|
|
{
|
|
CString strFormat;
|
|
if(!strFormat.LoadString(nIDPrompt))
|
|
return;
|
|
|
|
LPWSTR pszResult = NULL;
|
|
|
|
if(FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
|
|
strFormat,
|
|
0,
|
|
0,
|
|
(LPTSTR)&pszResult,
|
|
1,
|
|
pargs) && pszResult)
|
|
{
|
|
strOutput = pszResult;
|
|
LocalFree(pszResult);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
FormatString(CString &strOutput, UINT nIDPrompt, ...)
|
|
{
|
|
CString strFormat;
|
|
if(!strFormat.LoadString(nIDPrompt))
|
|
return;
|
|
|
|
va_list args;
|
|
va_start(args, nIDPrompt);
|
|
|
|
LPWSTR pszResult = NULL;
|
|
|
|
if(FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
|
|
strFormat,
|
|
0,
|
|
0,
|
|
(LPTSTR)&pszResult,
|
|
1,
|
|
&args))
|
|
{
|
|
strOutput = pszResult;
|
|
LocalFree(pszResult);
|
|
}
|
|
|
|
va_end(args);
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
GetSystemError(CString &strOutput, DWORD dwErr)
|
|
{
|
|
|
|
LPWSTR pszErrorMsg = NULL;
|
|
|
|
if( FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL,
|
|
dwErr,
|
|
MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
(LPWSTR) &pszErrorMsg,
|
|
0,
|
|
NULL) && pszErrorMsg)
|
|
{
|
|
strOutput = pszErrorMsg;
|
|
LocalFree(pszErrorMsg);
|
|
}
|
|
else
|
|
{
|
|
strOutput.Format(L"<0x%08x>",dwErr);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
int DisplayMessageBox(HWND hWnd,
|
|
const CString& strMessage,
|
|
UINT uStyle)
|
|
{
|
|
CThemeContextActivator activator;
|
|
|
|
CString strTitle;
|
|
strTitle.LoadString(IDS_SNAPIN_NAME);
|
|
|
|
return ::MessageBox(hWnd, strMessage, strTitle, uStyle|MB_TASKMODAL);
|
|
}
|
|
|
|
int FormatAndDisplayMessageBox(HWND hWnd,
|
|
UINT uStyle,
|
|
UINT nIDPrompt,
|
|
va_list &args)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
CThemeContextActivator activator;
|
|
|
|
CString strMessage;
|
|
vFormatString(strMessage,nIDPrompt,&args);
|
|
int iReturn = 0;
|
|
if(!strMessage.IsEmpty())
|
|
iReturn = DisplayMessageBox(hWnd, strMessage,uStyle);
|
|
|
|
va_end(args);
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
void
|
|
DisplayError(HWND hWnd, UINT nIDPrompt, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, nIDPrompt);
|
|
FormatAndDisplayMessageBox(hWnd, MB_OK | MB_ICONERROR,nIDPrompt,args);
|
|
va_end(args);
|
|
}
|
|
|
|
void
|
|
DisplayInformation(HWND hWnd, UINT nIDPrompt, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, nIDPrompt);
|
|
FormatAndDisplayMessageBox(hWnd, MB_OK | MB_ICONINFORMATION,nIDPrompt,args);
|
|
va_end(args);
|
|
}
|
|
|
|
void
|
|
DisplayWarning(HWND hWnd, UINT nIDPrompt, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, nIDPrompt);
|
|
FormatAndDisplayMessageBox(hWnd, MB_OK | MB_ICONWARNING, nIDPrompt,args);
|
|
va_end(args);
|
|
}
|
|
|
|
|
|
int
|
|
DisplayConfirmation(HWND hwnd, UINT nIDPrompt,...)
|
|
{
|
|
va_list args;
|
|
va_start(args, nIDPrompt);
|
|
int iReturn = FormatAndDisplayMessageBox(hwnd, MB_YESNO | MB_ICONEXCLAMATION,nIDPrompt,args);
|
|
va_end(args);
|
|
return iReturn;
|
|
}
|
|
|
|
BOOL
|
|
IsDeleteConfirmed(HWND hwndOwner,
|
|
CBaseAz& refBaseAz)
|
|
{
|
|
CString strType = refBaseAz.GetType();
|
|
strType.MakeLower();
|
|
return IDYES == DisplayConfirmation(hwndOwner,
|
|
IDS_DELETE_CONFIRMATION,
|
|
(LPCTSTR)strType,
|
|
(LPCTSTR)refBaseAz.GetName());
|
|
}
|
|
|
|
//
|
|
//Error Map for object types containing some common error info for
|
|
//each object type
|
|
//
|
|
ErrorMap ERROR_MAP[] =
|
|
{
|
|
{ ADMIN_MANAGER_AZ,
|
|
IDS_TYPE_ADMIN_MANAGER,
|
|
IDS_ADMIN_MANAGER_NAME_EXIST,
|
|
IDS_ADMIN_MANAGER_NAME_INVAILD,
|
|
L"\\ / : * ? \" < > | [tab]",
|
|
},
|
|
{ APPLICATION_AZ,
|
|
IDS_TYPE_APPLICATION,
|
|
IDS_APPLICATION_NAME_EXIST,
|
|
IDS_APPLICATION_NAME_INVAILD,
|
|
L"\\ / : * ? \" < > | [tab]",
|
|
},
|
|
{ SCOPE_AZ,
|
|
IDS_TYPE_SCOPE,
|
|
IDS_SCOPE_NAME_EXIST,
|
|
IDS_SCOPE_NAME_INVAILD,
|
|
L"",
|
|
},
|
|
{ GROUP_AZ,
|
|
IDS_TYPE_GROUP,
|
|
IDS_GROUP_NAME_EXIST,
|
|
IDS_GROUP_NAME_INVAILD,
|
|
L"\\ / : * ? \" < > | [tab]",
|
|
},
|
|
{ TASK_AZ,
|
|
IDS_TYPE_TASK,
|
|
IDS_TASK_OP_ALREADY_EXIST,
|
|
IDS_TASK_NAME_INVAILD,
|
|
L"\\ / : * ? \" < > | [tab]",
|
|
},
|
|
{ ROLE_AZ,
|
|
IDS_TYPE_ROLE,
|
|
IDS_ROLE_NAME_EXIST,
|
|
IDS_ROLE_NAME_INVAILD,
|
|
L"\\ / : * ? \" < > | [tab]",
|
|
},
|
|
{ OPERATION_AZ,
|
|
IDS_TYPE_OPERATION,
|
|
IDS_TASK_OP_ALREADY_EXIST,
|
|
IDS_OPERATION_NAME_INVAILD,
|
|
L"\\ / : * ? \" < > | [tab]",
|
|
},
|
|
};
|
|
|
|
ErrorMap *GetErrorMap(OBJECT_TYPE_AZ eObjectType)
|
|
{
|
|
for(int i = 0; i < ARRAYLEN(ERROR_MAP); ++i)
|
|
{
|
|
if(ERROR_MAP[i].eObjectType == eObjectType)
|
|
return ERROR_MAP + i;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: GetLSAConnection
|
|
// Synopsis: Wrapper for LsaOpenPolicy
|
|
//-----------------------------------------------------------------------------
|
|
LSA_HANDLE
|
|
GetLSAConnection(IN const CString& strServer,
|
|
IN DWORD dwAccessDesired)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,GetLSAConnection)
|
|
|
|
LSA_OBJECT_ATTRIBUTES oa;
|
|
SECURITY_QUALITY_OF_SERVICE sqos;
|
|
|
|
sqos.Length = sizeof(SECURITY_QUALITY_OF_SERVICE);
|
|
sqos.ImpersonationLevel = SecurityImpersonation;
|
|
sqos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
|
|
sqos.EffectiveOnly = FALSE;
|
|
|
|
InitializeObjectAttributes(&oa, NULL, 0, NULL, NULL);
|
|
oa.SecurityQualityOfService = &sqos;
|
|
|
|
LSA_UNICODE_STRING uszServer = {0};
|
|
LSA_UNICODE_STRING *puszServer = NULL;
|
|
|
|
if (!strServer.IsEmpty() &&
|
|
RtlCreateUnicodeString(&uszServer, (LPCTSTR)strServer))
|
|
{
|
|
puszServer = &uszServer;
|
|
}
|
|
|
|
LSA_HANDLE hPolicy = NULL;
|
|
LsaOpenPolicy(puszServer, &oa, dwAccessDesired, &hPolicy);
|
|
|
|
if (puszServer)
|
|
RtlFreeUnicodeString(puszServer);
|
|
|
|
return hPolicy;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:GetFileName
|
|
// Synopsis:Displays FileOpen dialog box and return file selected by user
|
|
// Arguments:hwndOwner : owner window
|
|
// bOpen: File must exist
|
|
// nIDTitle : title of open dialog box
|
|
// pszFilter : filter
|
|
// strFileName : gets selected file name
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
GetFileName(IN HWND hwndOwner,
|
|
IN BOOL bOpen,
|
|
IN INT nIDTitle,
|
|
IN const CString& strInitFolderPath,
|
|
IN LPCTSTR pszFilter,
|
|
IN OUT CString& strFileName)
|
|
{
|
|
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,GetFileName)
|
|
|
|
OPENFILENAME of;
|
|
ZeroMemory(&of,sizeof(OPENFILENAME));
|
|
|
|
WCHAR szFilePathBuffer[MAX_PATH];
|
|
ZeroMemory(szFilePathBuffer,sizeof(szFilePathBuffer));
|
|
|
|
of.lStructSize = sizeof(OPENFILENAME);
|
|
of.hwndOwner = hwndOwner;
|
|
of.lpstrFilter = pszFilter;
|
|
of.nFilterIndex = 1;
|
|
of.lpstrFile = szFilePathBuffer;
|
|
of.nMaxFile = MAX_PATH;
|
|
of.lpstrInitialDir = (LPCWSTR)strInitFolderPath;
|
|
if(nIDTitle)
|
|
{
|
|
CString strTitle;
|
|
if(strTitle.LoadString(nIDTitle))
|
|
of.lpstrTitle = (LPWSTR)(LPCTSTR)strTitle;
|
|
}
|
|
|
|
of.Flags = OFN_HIDEREADONLY;
|
|
if(bOpen)
|
|
of.Flags |= (OFN_FILEMUSTEXIST |OFN_PATHMUSTEXIST);
|
|
|
|
if(GetOpenFileName(&of))
|
|
{
|
|
strFileName = of.lpstrFile;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int ServerBrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM /*lParam*/, LPARAM lpData)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case BFFM_INITIALIZED:
|
|
SendMessage(hwnd, BFFM_SETEXPANDED, TRUE, lpData);
|
|
SendMessage(hwnd, BFFM_SETSELECTION, TRUE, lpData);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:GetFolderName
|
|
// Synopsis:Displays Folder selection dialog box and return folder selected
|
|
// by user
|
|
// Arguments:hwndOwner : owner window
|
|
// nIDTitle : title of dialog box
|
|
// strInitBrowseRoot : location of the root folder from which to
|
|
// start browsing
|
|
// strFolderName : gets selected file name
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
GetFolderName(IN HWND hwndOwner,
|
|
IN INT nIDTitle,
|
|
IN const CString& strInitBrowseRoot,
|
|
IN OUT CString& strFolderName)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,GetFolderName)
|
|
|
|
BROWSEINFO bi;
|
|
ZeroMemory(&bi,sizeof(bi));
|
|
|
|
WCHAR szBuffer[MAX_PATH];
|
|
szBuffer[0] = 0;
|
|
|
|
CString strTitle;
|
|
VERIFY(strTitle.LoadString(nIDTitle));
|
|
|
|
bi.hwndOwner = hwndOwner;
|
|
bi.pszDisplayName = szBuffer;
|
|
bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_USENEWUI;
|
|
bi.lpszTitle = strTitle;
|
|
bi.lpfn = ServerBrowseCallbackProc;
|
|
bi.lParam = (LPARAM)(LPCWSTR)strInitBrowseRoot;
|
|
|
|
LPITEMIDLIST pidl = SHBrowseForFolder(&bi);
|
|
if(pidl)
|
|
{
|
|
WCHAR szFolderPath[MAX_PATH];
|
|
if(SHGetPathFromIDList(pidl,szFolderPath))
|
|
{
|
|
PathAddBackslash(szFolderPath);
|
|
strFolderName = szFolderPath;
|
|
}
|
|
}
|
|
|
|
return !strFolderName.IsEmpty();
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:GetADContainerPath
|
|
// Synopsis:Displays a dialog box to allow for selecting a AD container
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
GetADContainerPath(HWND hWndOwner,
|
|
ULONG nIDCaption,
|
|
ULONG nIDTitle,
|
|
CString& strPath,
|
|
CADInfo& refAdInfo)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,GetADContainerPath)
|
|
|
|
HRESULT hr = refAdInfo.GetRootDSE();
|
|
CHECK_HRESULT(hr);
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
DisplayError(hWndOwner,IDS_CANNOT_ACCESS_AD);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
CString strRootDomainPath;
|
|
if(!refAdInfo.GetRootDomainDn().IsEmpty())
|
|
{
|
|
if(!refAdInfo.GetRootDomainDCName().IsEmpty())
|
|
{
|
|
strRootDomainPath = L"LDAP://" +
|
|
refAdInfo.GetRootDomainDCName() +
|
|
L"/" +
|
|
refAdInfo.GetRootDomainDn();
|
|
}
|
|
else
|
|
{
|
|
strRootDomainPath = L"LDAP://" + refAdInfo.GetRootDomainDn();
|
|
}
|
|
}
|
|
|
|
|
|
DSBROWSEINFOW dsbrowse;
|
|
ZeroMemory(&dsbrowse,sizeof(dsbrowse));
|
|
dsbrowse.cbStruct = sizeof(dsbrowse);
|
|
|
|
//Set Root of search to forest root
|
|
if(!strRootDomainPath.IsEmpty())
|
|
dsbrowse.pszRoot = (LPCTSTR)strRootDomainPath;
|
|
|
|
//Construct the path to which tree will expand on opening of
|
|
//dialog box
|
|
CString strInitialPath;
|
|
GetDefaultADContainerPath(refAdInfo,TRUE,TRUE,strInitialPath);
|
|
|
|
WCHAR szPath[MAX_PATH];
|
|
ZeroMemory(szPath,sizeof(szPath));
|
|
|
|
if(!strInitialPath.IsEmpty() && MAX_PATH > strInitialPath.GetLength())
|
|
{
|
|
wcscpy(szPath,(LPCTSTR)strInitialPath);
|
|
}
|
|
|
|
dsbrowse.hwndOwner = hWndOwner;
|
|
CString strCaption;
|
|
if(nIDCaption)
|
|
{
|
|
strCaption.LoadString(nIDCaption);
|
|
dsbrowse.pszCaption = strCaption;
|
|
}
|
|
|
|
CString strTitle;
|
|
if(nIDTitle)
|
|
{
|
|
strTitle.LoadString(nIDTitle);
|
|
dsbrowse.pszTitle = strTitle;
|
|
}
|
|
|
|
dsbrowse.pszPath = szPath;
|
|
dsbrowse.cchPath = MAX_PATH;
|
|
dsbrowse.dwFlags = DSBI_ENTIREDIRECTORY|DSBI_RETURN_FORMAT|DSBI_INCLUDEHIDDEN|DSBI_EXPANDONOPEN;
|
|
dsbrowse.dwReturnFormat = ADS_FORMAT_X500_NO_SERVER;
|
|
|
|
BOOL bRet = FALSE;
|
|
BOOL iRet = 0;
|
|
iRet = DsBrowseForContainer(&dsbrowse);
|
|
if(IDOK == iRet)
|
|
{
|
|
//Path contains LDAP:// string which we don't want
|
|
size_t nLen = wcslen(g_szLDAP);
|
|
if(_wcsnicmp(dsbrowse.pszPath,g_szLDAP,nLen) == 0 )
|
|
strPath = (dsbrowse.pszPath + nLen);
|
|
else
|
|
strPath = dsbrowse.pszPath;
|
|
bRet = TRUE;
|
|
}
|
|
else if (-1 == iRet)
|
|
{
|
|
Dbg(DEB_SNAPIN, "DsBrowseForContainer Failed\n");
|
|
DisplayError(hWndOwner,IDS_CANNOT_ACCESS_AD);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:CompareBaseAzObjects
|
|
// Synopsis:Compares two baseaz objects for equivalance. If two pAzA and pAzB
|
|
// are two different instances of same coreaz object, they are equal
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
CompareBaseAzObjects(CBaseAz* pAzA, CBaseAz* pAzB)
|
|
{
|
|
if(pAzA == pAzB)
|
|
return TRUE;
|
|
|
|
if(!pAzA || !pAzB)
|
|
return FALSE;
|
|
|
|
|
|
if(!(pAzA->GetObjectType() == pAzB->GetObjectType() &&
|
|
pAzA->GetName() == pAzB->GetName()))
|
|
|
|
return FALSE;
|
|
|
|
//If object if of type AdminManager, it must be same node
|
|
if(pAzA->GetObjectType() == ADMIN_MANAGER_AZ)
|
|
return (pAzA == pAzB);
|
|
|
|
|
|
//Two objects with same name and object type can exist under different
|
|
//parent-> Check if their parents are same->
|
|
|
|
if(pAzA->GetParentAz()->GetName() == pAzB->GetParentAz()->GetName())
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
//Below Code maps dialog box id to Help Map
|
|
//Ported from DNS Manager
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
#include "HelpMap.H"
|
|
#define BEGIN_HELP_MAP(map) static DWORD_PTR map[] = {
|
|
#define HELP_MAP_ENTRY(x) x, (DWORD_PTR)&g_aHelpIDs_##x ,
|
|
#define END_HELP_MAP 0, 0 };
|
|
|
|
|
|
#define NEXT_HELP_MAP_ENTRY(p) ((p)+2)
|
|
#define MAP_ENTRY_DLG_ID(p) (*p)
|
|
#define MAP_ENTRY_TABLE(p) ((DWORD*)(*(p+1)))
|
|
#define IS_LAST_MAP_ENTRY(p) (MAP_ENTRY_DLG_ID(p) == 0)
|
|
|
|
|
|
|
|
BEGIN_HELP_MAP(AuthManContextHelpMap)
|
|
HELP_MAP_ENTRY(IDD_ADD_GROUP)
|
|
HELP_MAP_ENTRY(IDD_ADD_OPERATION)
|
|
HELP_MAP_ENTRY(IDD_ADD_ROLE_DEFINITION)
|
|
HELP_MAP_ENTRY(IDD_ADD_TASK)
|
|
HELP_MAP_ENTRY(IDD_ADMIN_MANAGER_ADVANCED_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_ADMIN_MANAGER_GENERAL_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_APPLICATION_GENERAL_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_AUDIT)
|
|
HELP_MAP_ENTRY(IDD_GROUP_GENERAL_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_GROUP_LDAP_QUERY)
|
|
HELP_MAP_ENTRY(IDD_GROUP_MEMBER)
|
|
HELP_MAP_ENTRY(IDD_GROUP_NON_MEMBER)
|
|
HELP_MAP_ENTRY(IDD_NEW_APPLICATION)
|
|
HELP_MAP_ENTRY(IDD_NEW_AUTHORIZATION_STORE)
|
|
HELP_MAP_ENTRY(IDD_NEW_GROUP)
|
|
HELP_MAP_ENTRY(IDD_NEW_OPERATION)
|
|
HELP_MAP_ENTRY(IDD_NEW_ROLE_DEFINITION)
|
|
HELP_MAP_ENTRY(IDD_NEW_SCOPE)
|
|
HELP_MAP_ENTRY(IDD_NEW_TASK)
|
|
HELP_MAP_ENTRY(IDD_OPEN_AUTHORIZATION_STORE)
|
|
HELP_MAP_ENTRY(IDD_OPERATION_GENERAL_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_ROLE_DEFINITION_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_SCOPE_GENERAL_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_ROLE_DEFINITION_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_SECURITY)
|
|
HELP_MAP_ENTRY(IDD_TASK_DEFINITION_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_TASK_GENERAL_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_ROLE_DEFINITION_GENERAL_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_ROLE_GENERAL_PROPERTY)
|
|
HELP_MAP_ENTRY(IDD_ROLE_DEF_DIALOG)
|
|
HELP_MAP_ENTRY(IDD_BROWSE_AD_STORE)
|
|
HELP_MAP_ENTRY(IDD_SCRIPT)
|
|
HELP_MAP_ENTRY(IDD_ADD_ROLE_DEFINITION_1)
|
|
END_HELP_MAP
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:FindDialogContextTopic
|
|
// Synopsis:Finds the helpmap for a given dialog id
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
FindDialogContextTopic(IN UINT nDialogID,
|
|
OUT DWORD_PTR* pMap)
|
|
{
|
|
if(!pMap)
|
|
{
|
|
ASSERT(pMap);
|
|
return FALSE;
|
|
}
|
|
|
|
const DWORD_PTR* pMapEntry = AuthManContextHelpMap;
|
|
while (!IS_LAST_MAP_ENTRY(pMapEntry))
|
|
{
|
|
if (nDialogID == MAP_ENTRY_DLG_ID(pMapEntry))
|
|
{
|
|
DWORD_PTR pTable = (DWORD_PTR)MAP_ENTRY_TABLE(pMapEntry);
|
|
ASSERT(pTable);
|
|
*pMap = pTable;
|
|
return TRUE;
|
|
}
|
|
pMapEntry = NEXT_HELP_MAP_ENTRY(pMapEntry);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:CanReadOneProperty
|
|
// Synopsis:Function tries to read IsWriteable property. If that fails displays
|
|
// an error message. This is used before adding property pages.
|
|
// if we cannot read IsWritable property,thereisn't much hope.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CanReadOneProperty(LPCWSTR pszName,
|
|
CBaseAz* pBaseAz)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,CanReadOneProperty)
|
|
|
|
if(!pBaseAz)
|
|
{
|
|
ASSERT(pBaseAz);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL bWrite;
|
|
HRESULT hr = pBaseAz->IsWritable(bWrite);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
if(hr == HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE))
|
|
{
|
|
DisplayError(NULL,
|
|
IDS_PROP_ERROR_OBJECT_DELETED,
|
|
pszName);
|
|
|
|
}
|
|
else
|
|
{
|
|
//Display Generic Error
|
|
CString strError;
|
|
GetSystemError(strError, hr);
|
|
DisplayError(NULL,
|
|
IDS_GENERIC_PROP_DISPLAY_ERROR,
|
|
(LPCWSTR)strError,
|
|
pszName);
|
|
|
|
}
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: ListCompareProc
|
|
// Synopsis: Comparison function used by list control
|
|
//-----------------------------------------------------------------------------
|
|
int CALLBACK
|
|
ListCompareProc(LPARAM lParam1,
|
|
LPARAM lParam2,
|
|
LPARAM lParamSort)
|
|
{
|
|
int iResult = CSTR_EQUAL;
|
|
|
|
if(!lParam1 || !lParam2 || !lParamSort)
|
|
{
|
|
ASSERT(lParam1);
|
|
ASSERT(lParam2);
|
|
ASSERT(lParamSort);
|
|
return iResult;
|
|
}
|
|
|
|
CompareInfo *pCompareInfo = (CompareInfo*)lParamSort;
|
|
|
|
CBaseAz* pBaseAz1 = NULL;
|
|
CBaseAz* pBaseAz2 = NULL;
|
|
|
|
if(pCompareInfo->bActionItem)
|
|
{
|
|
pBaseAz1 = ((ActionItem*)lParam1)->m_pMemberAz;
|
|
pBaseAz2 = ((ActionItem*)lParam2)->m_pMemberAz;
|
|
}
|
|
else
|
|
{
|
|
pBaseAz1 = (CBaseAz*)lParam1;
|
|
pBaseAz2 = (CBaseAz*)lParam2;
|
|
}
|
|
|
|
|
|
CString str1;
|
|
CString str2;
|
|
|
|
int iColType = -1;
|
|
int iColParentType = -1;
|
|
int iColDescription = -1;
|
|
|
|
int iCol = 1;
|
|
if(pCompareInfo->uiFlags & COL_TYPE )
|
|
{
|
|
iColType = iCol++;
|
|
}
|
|
if(pCompareInfo->uiFlags & COL_PARENT_TYPE)
|
|
{
|
|
iColParentType = iCol++;
|
|
}
|
|
if(pCompareInfo->uiFlags & COL_DESCRIPTION)
|
|
{
|
|
iColDescription = iCol++;
|
|
}
|
|
|
|
if (pBaseAz1 && pBaseAz2)
|
|
{
|
|
if(pCompareInfo->iColumn == 0)
|
|
{
|
|
str1 = pBaseAz1->GetName();
|
|
str2 = pBaseAz2->GetName();
|
|
}
|
|
else if(pCompareInfo->iColumn == iColType)
|
|
{
|
|
str1 = pBaseAz1->GetType();
|
|
str2 = pBaseAz2->GetType();
|
|
}
|
|
else if(pCompareInfo->iColumn == iColDescription)
|
|
{
|
|
str1 = pBaseAz1->GetDescription();
|
|
str2 = pBaseAz2->GetDescription();
|
|
}
|
|
else if(pCompareInfo->iColumn == iColParentType)
|
|
{
|
|
str1 = pBaseAz1->GetParentType();
|
|
str2 = pBaseAz2->GetParentType();
|
|
}
|
|
|
|
iResult = CompareString(LOCALE_USER_DEFAULT, 0, str1, -1, str2, -1) - 2;
|
|
iResult *= pCompareInfo->iSortDirection;
|
|
}
|
|
|
|
return iResult;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:SortListControl
|
|
// Synopsis:Sorts a list control
|
|
// Arguments:pListCtrl: List control to sort
|
|
// iColumnClicked: column clicked
|
|
// iSortDirection: direction in which to sort
|
|
// uiFlags: column info
|
|
// bActionItem: if item in list is actionitem
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
SortListControl(CListCtrl* pListCtrl,
|
|
int iColumnClicked,
|
|
int iSortDirection,
|
|
UINT uiFlags,
|
|
BOOL bActionItem)
|
|
{
|
|
if(!pListCtrl)
|
|
{
|
|
ASSERT(pListCtrl);
|
|
return;
|
|
}
|
|
|
|
CompareInfo compareInfo;
|
|
compareInfo.bActionItem = bActionItem;
|
|
compareInfo.iColumn = iColumnClicked;
|
|
compareInfo.iSortDirection = iSortDirection;
|
|
compareInfo.uiFlags = uiFlags;
|
|
pListCtrl->SortItems(ListCompareProc,
|
|
(DWORD_PTR)&compareInfo);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Synopsis: Ensures that selection in listview control is visible
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
EnsureListViewSelectionIsVisible(CListCtrl *pListCtrl)
|
|
{
|
|
ASSERT(pListCtrl);
|
|
|
|
int iSelected = pListCtrl->GetNextItem(-1, LVNI_SELECTED);
|
|
if (-1 != iSelected)
|
|
pListCtrl->EnsureVisible(iSelected, FALSE);
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Synopsis:Convert input number in string format to long. if number is out
|
|
// of range displays a message.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
ConvertStringToLong(LPCWSTR pszInput,
|
|
long &reflongOutput,
|
|
HWND hWnd)
|
|
{
|
|
if(!pszInput)
|
|
{
|
|
ASSERT(pszInput);
|
|
return FALSE;
|
|
}
|
|
//
|
|
//Get the Max len of long
|
|
long lMaxLong = LONG_MAX;
|
|
WCHAR szMaxLongBuffer[34];
|
|
_ltow(lMaxLong,szMaxLongBuffer,10);
|
|
size_t nMaxLen = wcslen(szMaxLongBuffer);
|
|
|
|
//
|
|
//Get the length of input
|
|
LPCWSTR pszTempInput = pszInput;
|
|
if(pszInput[0] == L'-')
|
|
{
|
|
pszTempInput++;
|
|
}
|
|
|
|
//
|
|
//Length of input greater than length of Max Long, than
|
|
//input is out of range.
|
|
size_t nInputLen = wcslen(pszTempInput);
|
|
if(nInputLen > nMaxLen)
|
|
{
|
|
if(hWnd)
|
|
{
|
|
DisplayError(hWnd,IDS_GREATER_THAN_MAX_LONG,pszTempInput,szMaxLongBuffer);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
//Convert input to int64 and check its less that max integer
|
|
//
|
|
__int64 i64Input = _wtoi64(pszTempInput);
|
|
if(i64Input > (__int64)lMaxLong)
|
|
{
|
|
if(hWnd)
|
|
{
|
|
DisplayError(hWnd,IDS_GREATER_THAN_MAX_LONG,pszTempInput,szMaxLongBuffer);
|
|
}
|
|
return FALSE;
|
|
}
|
|
//
|
|
//Value is good
|
|
//
|
|
reflongOutput = _wtol(pszInput);
|
|
return TRUE;
|
|
}
|
|
|
|
VOID
|
|
SetSel(CEdit& refEdit)
|
|
{
|
|
refEdit.SetFocus();
|
|
refEdit.SetSel(0,-1);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: ValidateStoreTypeAndName
|
|
// Synopsis: Validates the user entered AD Store Name
|
|
// Arguments: strName: User entered store name to verify
|
|
// Returns: TRUE if name is valid else false
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
ValidateStoreTypeAndName(HWND hWnd,
|
|
LONG ulStoreType,
|
|
const CString& strName)
|
|
{
|
|
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,ValidateStoreTypeAndName)
|
|
|
|
//Store Name is not entered in the valid format. We should come here only
|
|
//when store name is entered at the command line.
|
|
if((AZ_ADMIN_STORE_INVALID == ulStoreType) ||
|
|
strName.IsEmpty())
|
|
{
|
|
DisplayError(hWnd,IDS_INVALIDSTORE_ON_COMMANDLINE);
|
|
return FALSE;
|
|
}
|
|
|
|
//No validation is required for XML Store
|
|
if(ulStoreType == AZ_ADMIN_STORE_XML)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
ASSERT(ulStoreType == AZ_ADMIN_STORE_AD);
|
|
BOOL bRet = FALSE;
|
|
PDS_NAME_RESULT pResult = NULL;
|
|
do
|
|
{
|
|
//Get the store name with LDAP:// prefix
|
|
CString strFormalName;
|
|
NameToStoreName(AZ_ADMIN_STORE_AD,
|
|
strName,
|
|
TRUE,
|
|
strFormalName);
|
|
|
|
Dbg(DEB_SNAPIN, "AD store name entered is: %ws\n", CHECK_NULL(strFormalName));
|
|
|
|
CComPtr<IADsPathname> spPathName;
|
|
HRESULT hr = spPathName.CoCreateInstance(CLSID_Pathname,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER);
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
|
|
hr = spPathName->Set(CComBSTR(strFormalName),
|
|
ADS_SETTYPE_FULL);
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
|
|
//Get the DN entered by user
|
|
CComBSTR bstrDN;
|
|
hr = spPathName->Retrieve(ADS_FORMAT_X500_DN,&bstrDN);
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
|
|
if(bstrDN.Length() == 0)
|
|
{
|
|
Dbg(DEB_SNAPIN, "spPathName->Retrieve returned 0 len DN\n");
|
|
break;
|
|
}
|
|
|
|
//Do a syntactical crack for the DN to see if its a valid DN
|
|
LPCWSTR pszName = bstrDN;
|
|
|
|
if( DsCrackNames(NULL,
|
|
DS_NAME_FLAG_SYNTACTICAL_ONLY,
|
|
DS_FQDN_1779_NAME,
|
|
DS_CANONICAL_NAME,
|
|
1,
|
|
&pszName,
|
|
&pResult) != DS_NAME_NO_ERROR)
|
|
{
|
|
Dbg(DEB_SNAPIN, "DsCrackName failed to crack the name");
|
|
break;
|
|
}
|
|
|
|
ASSERT(pResult);
|
|
|
|
if(pResult->rItems->status == DS_NAME_NO_ERROR)
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
}while(0);
|
|
|
|
if(pResult)
|
|
DsFreeNameResult(pResult);
|
|
|
|
if(!bRet)
|
|
{
|
|
DisplayError(hWnd,IDS_INVALID_AD_STORE_NAME);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: NameToFormatStoreName
|
|
// Synopsis: Converts user entered name to format which core understands
|
|
// Arguments: ulStoreType: Type of store
|
|
// strName: User entered store name
|
|
// bUseLDAP:use LDAP string to format AD name instead msldap
|
|
// strFormalName: gets the output ldap name
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
NameToStoreName(IN LONG lStoreType,
|
|
IN const CString& strName,
|
|
IN BOOL bUseLDAP,
|
|
OUT CString& strFormalName)
|
|
{
|
|
strFormalName.Empty();
|
|
|
|
if(lStoreType == AZ_ADMIN_STORE_XML)
|
|
{
|
|
if(_wcsnicmp(strName,g_szMSXML,wcslen(g_szMSXML)) == 0 )
|
|
{
|
|
strFormalName = strName;
|
|
}
|
|
else
|
|
{
|
|
strFormalName = g_szMSXML + strName;
|
|
}
|
|
return;
|
|
}
|
|
else if(lStoreType == AZ_ADMIN_STORE_AD)
|
|
{
|
|
LPCWSTR lpcszPrefix = bUseLDAP ? g_szLDAP : g_szMSLDAP;
|
|
LPCWSTR lpcszOtherPrefix = bUseLDAP ? g_szMSLDAP : g_szLDAP;
|
|
|
|
if(_wcsnicmp(strName,lpcszPrefix,wcslen(lpcszPrefix)) == 0 )
|
|
{
|
|
strFormalName = strName;
|
|
}
|
|
else
|
|
{
|
|
size_t nlen = wcslen(lpcszOtherPrefix);
|
|
//Check if user has put other prefix in the name
|
|
if(_wcsnicmp(strName,lpcszOtherPrefix,nlen) == 0 )
|
|
{
|
|
strFormalName = lpcszPrefix + strName.Right(strName.GetLength() - (int)nlen);
|
|
}
|
|
else
|
|
{
|
|
strFormalName = lpcszPrefix + strName;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
|
|
void
|
|
TrimWhiteSpace(CString& str)
|
|
{
|
|
str.TrimLeft(L"\t ");
|
|
str.TrimRight(L"\t ");
|
|
}
|
|
|
|
BOOL
|
|
TranslateNameFromDnToDns(const CString& strInputDN,
|
|
CString& strOutputDNS)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,TranslateNameFromDnToDns)
|
|
|
|
if(strInputDN.IsEmpty())
|
|
return FALSE;
|
|
|
|
strOutputDNS.Empty();
|
|
|
|
Dbg(DEB_SNAPIN, "DN of Forest is %ws\n", (LPCWSTR)strInputDN);
|
|
|
|
LPCWSTR pstrName = strInputDN;
|
|
PDS_NAME_RESULT pResult;
|
|
if( DS_NAME_NO_ERROR
|
|
== DsCrackNames(NULL,
|
|
DS_NAME_FLAG_SYNTACTICAL_ONLY,
|
|
DS_FQDN_1779_NAME,
|
|
DS_CANONICAL_NAME,
|
|
1,
|
|
(LPWSTR*)(&pstrName),
|
|
&pResult))
|
|
{
|
|
if(pResult &&
|
|
pResult->cItems == 1 &&
|
|
pResult->rItems[0].status == DS_NAME_NO_ERROR &&
|
|
pResult->rItems[0].pDomain)
|
|
{
|
|
strOutputDNS = pResult->rItems[0].pDomain;
|
|
Dbg(DEB_SNAPIN, "DNS of Forest is %ws\n", (LPCWSTR)strOutputDNS);
|
|
}
|
|
|
|
if(pResult)
|
|
{
|
|
DsFreeNameResult(pResult);
|
|
}
|
|
}
|
|
return !strOutputDNS.IsEmpty();
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:GetSearchObject
|
|
// Synopsis:Get IDirectorySearch object to search at forest
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT
|
|
GetSearchObject(IN CADInfo& refAdInfo,
|
|
OUT CComPtr<IDirectorySearch>& refspSearchObject)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,GetSearchObject)
|
|
|
|
HRESULT hr = S_OK;
|
|
do
|
|
{
|
|
//
|
|
hr = refAdInfo.GetRootDSE();
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
const CString& strForestDNS = refAdInfo.GetRootDomainDnsName();
|
|
|
|
CString strGCPath = L"GC://";
|
|
strGCPath += strForestDNS;
|
|
|
|
|
|
//
|
|
//Get IDirectorySearch Object
|
|
//
|
|
hr = AzRoleAdsOpenObject((LPWSTR)(LPCWSTR)strGCPath,
|
|
NULL,
|
|
NULL,
|
|
IID_IDirectorySearch,
|
|
(void**)&refspSearchObject);
|
|
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
}while(0);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// Attributes that we want the Object Picker to retrieve
|
|
//
|
|
static const LPCTSTR g_aszOPAttributes[] =
|
|
{
|
|
TEXT("distinguishedName"),
|
|
};
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:GetListOfAuthorizationStore
|
|
// Synopsis:Search at GC for AD policy stores and returns list.
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT
|
|
GetListOfAuthorizationStore(IN CADInfo& refAdInfo,
|
|
OUT CList<CString,CString> &strList)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//If List is not empty, empty it
|
|
while(!strList.IsEmpty())
|
|
strList.RemoveHead();
|
|
|
|
do
|
|
{
|
|
TIMER("Time to search GC for AD Stores");
|
|
|
|
CComPtr<IDirectorySearch> spSearchObject;
|
|
CString str;
|
|
hr = GetSearchObject(refAdInfo,
|
|
spSearchObject);
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
CDSSearch searchObject(spSearchObject);
|
|
searchObject.SetFilterString((LPWSTR)g_pszAuthorizationStoreQueryFilter);
|
|
searchObject.SetAttributeList((LPWSTR*)g_aszOPAttributes,1);
|
|
|
|
hr = searchObject.DoQuery();
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
int iIndex = 0;
|
|
while(TRUE)
|
|
{
|
|
hr = searchObject.GetNextRow();
|
|
|
|
//We are done
|
|
if(hr == S_ADS_NOMORE_ROWS)
|
|
{
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
ADS_SEARCH_COLUMN ColumnData;
|
|
hr = searchObject.GetColumn((LPWSTR)g_aszOPAttributes[0], &ColumnData);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
ASSERT(ADSTYPE_DN_STRING == ColumnData.dwADsType);
|
|
strList.AddTail(ColumnData.pADsValues->DNString);
|
|
searchObject.FreeColumn(&ColumnData);
|
|
}
|
|
}//End of while loop
|
|
}while(0);
|
|
|
|
if(!strList.IsEmpty())
|
|
return S_OK;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Class: CBaseAddDialog
|
|
Purpose:Displays a dialog box with list of AD Policy stores
|
|
******************************************************************************/
|
|
class CBrowseADStoreDlg : public CHelpEnabledDialog
|
|
{
|
|
public:
|
|
CBrowseADStoreDlg(CList<CString,CString>&strList,
|
|
CString& strSelectedADStorePath)
|
|
:CHelpEnabledDialog(IDD_BROWSE_AD_STORE),
|
|
m_strList(strList),
|
|
m_strSelectedADStorePath(strSelectedADStorePath)
|
|
{
|
|
}
|
|
|
|
virtual BOOL
|
|
OnInitDialog();
|
|
|
|
virtual void
|
|
OnOK();
|
|
private:
|
|
CList<CString,CString> &m_strList;
|
|
CString& m_strSelectedADStorePath;
|
|
};
|
|
|
|
BOOL
|
|
CBrowseADStoreDlg::
|
|
OnInitDialog()
|
|
{
|
|
CListCtrl* pListCtrl = (CListCtrl*)GetDlgItem(IDC_LIST);
|
|
ASSERT(pListCtrl);
|
|
//
|
|
//Initialize the list control
|
|
//
|
|
ListView_SetImageList(pListCtrl->GetSafeHwnd(),
|
|
LoadImageList(::AfxGetInstanceHandle (),
|
|
MAKEINTRESOURCE(IDB_ICONS)),
|
|
LVSIL_SMALL);
|
|
|
|
|
|
//Add ListBox Extended Style
|
|
pListCtrl->SetExtendedStyle(LVS_EX_FULLROWSELECT |
|
|
LVS_EX_INFOTIP);
|
|
|
|
//Add List box Columns
|
|
AddColumnToListView(pListCtrl,Col_For_Browse_ADStore_Page);
|
|
|
|
POSITION pos = m_strList.GetHeadPosition();
|
|
for (int i=0;i < m_strList.GetCount();i++)
|
|
{
|
|
pListCtrl->InsertItem(LVIF_TEXT|LVIF_STATE|LVIF_IMAGE,
|
|
i,
|
|
m_strList.GetNext(pos),
|
|
0,
|
|
0,
|
|
iIconStore,
|
|
NULL);
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
CBrowseADStoreDlg::
|
|
OnOK()
|
|
{
|
|
TRACE_METHOD_EX(DEB_SNAPIN,CBrowseADStoreDlg,OnOK)
|
|
CListCtrl* pListCtrl = (CListCtrl*)GetDlgItem(IDC_LIST);
|
|
int iSelected = -1;
|
|
if((iSelected = pListCtrl->GetNextItem(-1, LVIS_SELECTED)) != -1)
|
|
{
|
|
m_strSelectedADStorePath = pListCtrl->GetItemText(iSelected,0);
|
|
}
|
|
CHelpEnabledDialog::OnOK();
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:BrowseAdStores
|
|
// Synopsis:Displays a dialog box with list of AD stores available.
|
|
// Arguments:strDN: Gets the selected ad store name
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
BrowseAdStores(IN HWND hwndOwner,
|
|
OUT CString& strDN,
|
|
IN CADInfo& refAdInfo)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,BrowseAdStores)
|
|
|
|
CList<CString,CString> strList;
|
|
if(SUCCEEDED(GetListOfAuthorizationStore(refAdInfo,
|
|
strList)))
|
|
{
|
|
if(!strList.IsEmpty())
|
|
{
|
|
CBrowseADStoreDlg dlg(strList,strDN);
|
|
dlg.DoModal();
|
|
}
|
|
else
|
|
{
|
|
DisplayInformation(hwndOwner,
|
|
IDS_NO_AD_STORE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Display Error
|
|
DisplayError(hwndOwner,
|
|
IDS_CANNOT_ACCESS_AD);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:LoadIcons
|
|
// Synopsis:Adds icons to imagelist
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT
|
|
LoadIcons(LPIMAGELIST pImageList)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,LoadIcons)
|
|
if(!pImageList)
|
|
{
|
|
ASSERT(pImageList);
|
|
return E_POINTER;
|
|
}
|
|
|
|
struct RESID2IICON
|
|
{
|
|
UINT uIconId; // Icon resource ID
|
|
int iIcon; // Index of the icon in the image list
|
|
};
|
|
const static RESID2IICON rgzLoadIconList[] =
|
|
{
|
|
{IDI_UNKNOWN_SID, iIconUnknownSid},
|
|
{IDI_COMPUTER, iIconComputerSid},
|
|
{IDI_GROUP, iIconGroup},
|
|
//iIconLocalGroup, //This is not used, but since its in the imagelist
|
|
// //i added an entry here
|
|
{IDI_USER, iIconUser,},
|
|
{ IDI_BASIC_GROUP, iIconBasicGroup},
|
|
{ IDI_LDAP_GROUP, iIconLdapGroup},
|
|
{ IDI_OPERATION, iIconOperation},
|
|
{ IDI_TASK, iIconTask},
|
|
{ IDI_ROLE_DEFINITION, iIconRoleDefinition},
|
|
{ IDI_STORE, iIconStore},
|
|
{ IDI_APP, iIconApplication},
|
|
{ IDI_ROLE, iIconRole},
|
|
{ IDI_ROLE_SNAPIN, iIconRoleSnapin},
|
|
{ IDI_SCOPE, iIconScope},
|
|
{ IDI_CONTAINER, iIconContainer},
|
|
{ 0, 0} // Must be last
|
|
};
|
|
|
|
|
|
for (int i = 0; rgzLoadIconList[i].uIconId != 0; i++)
|
|
{
|
|
HICON hIcon =
|
|
::LoadIcon (AfxGetInstanceHandle (),
|
|
MAKEINTRESOURCE (rgzLoadIconList[i].uIconId));
|
|
ASSERT (hIcon && "Icon ID not found in resources");
|
|
|
|
pImageList->ImageListSetIcon ((PLONG_PTR) hIcon,
|
|
rgzLoadIconList[i].iIcon);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: LoadImageList
|
|
// Synopsis: Loads image list
|
|
//-----------------------------------------------------------------------------
|
|
HIMAGELIST
|
|
LoadImageList(HINSTANCE hInstance, LPCTSTR pszBitmapID)
|
|
{
|
|
HIMAGELIST himl = NULL;
|
|
HBITMAP hbm = LoadBitmap(hInstance, pszBitmapID);
|
|
|
|
if (hbm != NULL)
|
|
{
|
|
BITMAP bm;
|
|
GetObject(hbm, sizeof(BITMAP), &bm);
|
|
|
|
himl = ImageList_Create(bm.bmHeight, // height == width
|
|
bm.bmHeight,
|
|
ILC_COLOR | ILC_MASK,
|
|
bm.bmWidth / bm.bmHeight,
|
|
0); // don't need to grow
|
|
if (himl != NULL)
|
|
ImageList_AddMasked(himl, hbm, CLR_DEFAULT);
|
|
|
|
DeleteObject(hbm);
|
|
}
|
|
|
|
return himl;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: AddExtensionToFileName
|
|
// Synopsis: Functions adds .xml extension to name of file if no extension
|
|
// is present.
|
|
// Arguments:
|
|
// Returns:
|
|
//-----------------------------------------------------------------------------
|
|
VOID
|
|
AddExtensionToFileName(IN OUT CString& strFileName)
|
|
{
|
|
if(strFileName.IsEmpty())
|
|
return;
|
|
|
|
//if the last char is "\" don't do anything
|
|
if((strFileName.ReverseFind(L'\\') + 1) == strFileName.GetLength())
|
|
return;
|
|
|
|
int iLastDot = strFileName.ReverseFind(L'.');
|
|
if(iLastDot != -1)
|
|
{
|
|
//if there are three chars after last dot,
|
|
//file has extension. Index returned is zero based
|
|
if(strFileName.GetLength() == (iLastDot + 3 + 1))
|
|
return;
|
|
}
|
|
|
|
//File doesn't have extension. Add extension to the file.
|
|
strFileName += g_pszFileStoreExtension;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: GetFileExtension
|
|
// Synopsis: Get the extension of the file.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
GetFileExtension(IN const CString& strFileName,
|
|
OUT CString& strExtension)
|
|
{
|
|
if(strFileName.IsEmpty())
|
|
return FALSE;
|
|
|
|
|
|
//Find the position of last dot
|
|
int iLastDot = strFileName.ReverseFind(L'.');
|
|
if(iLastDot != -1)
|
|
{
|
|
strExtension = strFileName.Right(strFileName.GetLength() - (iLastDot+1));
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function:GetCurrentWorkingDirectory
|
|
// Synopsis:Gets the current working directory
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
GetCurrentWorkingDirectory(IN OUT CString& strCWD)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,GetCurrentWorkingDirectory)
|
|
|
|
strCWD.Empty();
|
|
LPWSTR pszBuffer = NULL;
|
|
|
|
do
|
|
{
|
|
int nLen = 0;
|
|
WCHAR szBuffer[MAX_PATH];
|
|
|
|
if((nLen = GetCurrentDirectory(MAX_PATH,szBuffer)) != 0)
|
|
{
|
|
//If the return value is less than MAX_PATH, function
|
|
//was successful. If its greater, buffer is not big enough,
|
|
//dynamically allocate it below.
|
|
if(nLen < MAX_PATH)
|
|
{
|
|
strCWD = szBuffer;
|
|
break;
|
|
}
|
|
|
|
//Bigger buffer is required
|
|
pszBuffer = new WCHAR[nLen];
|
|
if(pszBuffer)
|
|
{
|
|
if((nLen = GetCurrentDirectory(nLen,pszBuffer)) != 0)
|
|
{
|
|
strCWD = pszBuffer;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}while(0);//FALSE LOOP
|
|
|
|
if(pszBuffer)
|
|
delete [] pszBuffer;
|
|
|
|
//Add \ at the end of string
|
|
if(!strCWD.IsEmpty() &&
|
|
((strCWD.ReverseFind(L'\\') + 1) != strCWD.GetLength()))
|
|
{
|
|
strCWD += L'\\';
|
|
}
|
|
|
|
|
|
return !strCWD.IsEmpty();
|
|
}
|
|
|
|
VOID
|
|
RemoveItemsFromActionMap(ActionMap& mapActionItem)
|
|
{
|
|
for (ActionMap::iterator it = mapActionItem.begin();
|
|
it != mapActionItem.end();
|
|
++it)
|
|
{
|
|
delete (*it).second;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
Class: CADInfo
|
|
Purpose:Keeps a cache of Active Directory info avoiding multiple binds
|
|
******************************************************************************/
|
|
|
|
HRESULT
|
|
CADInfo::
|
|
GetRootDSE()
|
|
{
|
|
TRACE_METHOD_EX(DEB_SNAPIN,CADInfo,GetRootDSE)
|
|
HRESULT hr = S_OK;
|
|
if(m_spRootDSE == NULL)
|
|
{
|
|
//
|
|
//Bind to RootDSE
|
|
//
|
|
hr = AzRoleAdsOpenObject(L"LDAP://RootDSE",
|
|
NULL,
|
|
NULL,
|
|
IID_IADs,
|
|
(void**)&m_spRootDSE);
|
|
CHECK_HRESULT(hr);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
const CString&
|
|
CADInfo::GetDomainDnsName()
|
|
{
|
|
TRACE_METHOD_EX(DEB_SNAPIN,CADInfo,GetDomainDnsName)
|
|
if(m_strDomainDnsName.IsEmpty())
|
|
{
|
|
if(m_strDomainDn.IsEmpty())
|
|
GetDomainDn();
|
|
|
|
if(!m_strDomainDn.IsEmpty())
|
|
{
|
|
TranslateNameFromDnToDns(m_strDomainDn,m_strDomainDnsName);
|
|
Dbg(DEB_SNAPIN, "Domain Dns is: %ws\n", CHECK_NULL((LPCTSTR)m_strDomainDnsName));
|
|
}
|
|
}
|
|
return m_strDomainDnsName;
|
|
}
|
|
|
|
const CString&
|
|
CADInfo::GetDomainDn()
|
|
{
|
|
TRACE_METHOD_EX(DEB_SNAPIN,CADInfo,GetDomainDn)
|
|
|
|
if((m_spRootDSE != NULL) && m_strDomainDn.IsEmpty())
|
|
{
|
|
// Get the default name
|
|
VARIANT Default;
|
|
VariantInit(&Default);
|
|
HRESULT hr = m_spRootDSE->Get (CComBSTR(L"defaultNamingContext"), &Default);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
ASSERT(VT_BSTR == Default.vt);
|
|
if(VT_BSTR == Default.vt)
|
|
{
|
|
m_strDomainDn = Default.bstrVal;
|
|
::VariantClear(&Default);
|
|
|
|
Dbg(DEB_SNAPIN, "Domain Dn is: %ws\n", CHECK_NULL((LPCTSTR)m_strDomainDn));
|
|
}
|
|
}
|
|
}
|
|
return m_strDomainDn;
|
|
}
|
|
|
|
|
|
const CString&
|
|
CADInfo::GetRootDomainDnsName()
|
|
{
|
|
TRACE_METHOD_EX(DEB_SNAPIN,CADInfo,GetRootDomainDnsName)
|
|
if(m_strRootDomainDnsName.IsEmpty())
|
|
{
|
|
if(m_strRootDomainDn.IsEmpty())
|
|
GetRootDomainDn();
|
|
|
|
if(!m_strRootDomainDn.IsEmpty())
|
|
{
|
|
TranslateNameFromDnToDns(m_strRootDomainDn,m_strRootDomainDnsName);
|
|
Dbg(DEB_SNAPIN, "Root Domain Dns is: %ws\n", CHECK_NULL((LPCTSTR)m_strRootDomainDnsName));
|
|
}
|
|
}
|
|
return m_strRootDomainDnsName;
|
|
}
|
|
|
|
const CString&
|
|
CADInfo::GetRootDomainDn()
|
|
{
|
|
TRACE_METHOD_EX(DEB_SNAPIN,CADInfo,GetRootDomainDn)
|
|
if((m_spRootDSE != NULL) && m_strRootDomainDn.IsEmpty())
|
|
{
|
|
// Get the default name
|
|
VARIANT Default;
|
|
VariantInit(&Default);
|
|
HRESULT hr = m_spRootDSE->Get(CComBSTR(L"rootDomainNamingContext"), &Default);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
//Convert DN to DNS name
|
|
m_strRootDomainDn = Default.bstrVal;
|
|
::VariantClear(&Default);
|
|
|
|
Dbg(DEB_SNAPIN, "Root Domain DN is: %ws\n", CHECK_NULL((LPCTSTR)m_strRootDomainDn));
|
|
}
|
|
}
|
|
|
|
return m_strRootDomainDn;
|
|
}
|
|
|
|
BOOL GetDcNameForDomain(IN const CString& strDomainName,
|
|
OUT CString& strDCName)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,GetDcNameForDomain)
|
|
if(strDomainName.IsEmpty())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
strDCName.Empty();
|
|
|
|
PDOMAIN_CONTROLLER_INFO pDomainInfo = NULL;
|
|
//Get the DC Name
|
|
DWORD dwErr = DsGetDcName(NULL,
|
|
(LPCWSTR)strDomainName,
|
|
NULL,
|
|
NULL,
|
|
DS_IS_DNS_NAME|DS_DIRECTORY_SERVICE_REQUIRED,
|
|
&pDomainInfo);
|
|
if((ERROR_SUCCESS == dwErr) && pDomainInfo)
|
|
{
|
|
LPWSTR pszDCName = pDomainInfo->DomainControllerName;
|
|
|
|
//The returned computer name is prefixed with \\
|
|
//Remove backslashes
|
|
if(pszDCName[0] == L'\\' && pszDCName[1] == L'\\')
|
|
pszDCName += 2;
|
|
|
|
//If a DNS-style name is returned, it is terminated with a period,
|
|
//indicating that the returned name is an absolute (non-relative)
|
|
//DNS name.
|
|
//We don't need period, remove it
|
|
|
|
//DomainControllerName is in DNS format.
|
|
if(pDomainInfo->Flags & DS_DNS_CONTROLLER_FLAG)
|
|
{
|
|
size_t dwLen = wcslen(pszDCName);
|
|
if(dwLen && (L'.' == pszDCName[dwLen -1]))
|
|
{
|
|
pszDCName[dwLen -1] = L'\0';
|
|
}
|
|
}
|
|
Dbg(DEB_SNAPIN, "DC is %ws\n", pszDCName);
|
|
strDCName = pszDCName;
|
|
NetApiBufferFree(pDomainInfo);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
const CString&
|
|
CADInfo::
|
|
GetRootDomainDCName()
|
|
{
|
|
TRACE_METHOD_EX(DEB_SNAPIN,CADInfo,GetRootDomainDCName)
|
|
|
|
if((m_spRootDSE != NULL) && m_strRootDomainDcName.IsEmpty())
|
|
{
|
|
GetDcNameForDomain(GetRootDomainDnsName(),m_strRootDomainDcName);
|
|
}
|
|
|
|
return m_strRootDomainDcName;
|
|
}
|
|
|
|
const CString&
|
|
CADInfo::
|
|
GetDomainDCName()
|
|
{
|
|
TRACE_METHOD_EX(DEB_SNAPIN,CADInfo,GetDomainDCName)
|
|
|
|
if((m_spRootDSE != NULL) && m_strDomainDcName.IsEmpty())
|
|
{
|
|
|
|
GetDcNameForDomain(GetDomainDnsName(),m_strDomainDcName);
|
|
}
|
|
|
|
return m_strDomainDcName;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// Function: AzRoleAdsOpenObject
|
|
// Synopsis: A thin wrapper around ADsOpenObject
|
|
//+--------------------------------------------------------------------------
|
|
HRESULT AzRoleAdsOpenObject(LPWSTR lpszPathName,
|
|
LPWSTR lpszUserName,
|
|
LPWSTR lpszPassword,
|
|
REFIID riid,
|
|
VOID** ppObject,
|
|
BOOL bBindToServer)
|
|
{
|
|
static DWORD additionalFlags = GetADsOpenObjectFlags();
|
|
DWORD dwFlags = ADS_SECURE_AUTHENTICATION | additionalFlags;
|
|
|
|
if (bBindToServer)
|
|
{
|
|
//
|
|
// If we know we are connecting to a specific server and not domain in general
|
|
// then pass the ADS_SERVER_BIND flag to save ADSI the trouble of figuring it out
|
|
//
|
|
dwFlags |= ADS_SERVER_BIND;
|
|
}
|
|
|
|
|
|
//
|
|
//Get IDirectorySearch Object
|
|
//
|
|
return ADsOpenObject(lpszPathName,
|
|
lpszUserName,
|
|
lpszPassword,
|
|
additionalFlags,
|
|
riid,
|
|
ppObject);
|
|
}
|
|
|
|
VOID
|
|
GetDefaultADContainerPath(IN CADInfo& refAdInfo,
|
|
IN BOOL bAddServer,
|
|
IN BOOL bAddLdap,
|
|
OUT CString& strPath)
|
|
{
|
|
strPath.Empty();
|
|
if(!refAdInfo.GetDomainDn().IsEmpty())
|
|
{
|
|
if(!refAdInfo.GetDomainDCName().IsEmpty())
|
|
{
|
|
if(bAddLdap)
|
|
{
|
|
strPath += L"LDAP://";
|
|
}
|
|
if(bAddServer)
|
|
{
|
|
strPath += refAdInfo.GetDomainDCName();
|
|
strPath += L"/";
|
|
}
|
|
strPath += g_pszProgramDataPrefix;
|
|
strPath += refAdInfo.GetDomainDn();
|
|
}
|
|
else
|
|
{
|
|
if(bAddLdap)
|
|
{
|
|
strPath = L"LDAP://";
|
|
}
|
|
strPath += g_pszProgramDataPrefix;
|
|
strPath += refAdInfo.GetDomainDn();
|
|
}
|
|
}
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// Function: IsBizRuleWritable
|
|
// Synopsis: Checks if bizrules are writable for this object
|
|
//+--------------------------------------------------------------------------
|
|
BOOL
|
|
IsBizRuleWritable(HWND hWnd, CContainerAz& refBaseAz)
|
|
{
|
|
CScopeAz* pScopeAz = dynamic_cast<CScopeAz*>(&refBaseAz);
|
|
//Bizrules are always writable for at
|
|
//application level
|
|
if(!pScopeAz)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL bBizRuleWritable = TRUE;
|
|
HRESULT hr = pScopeAz->BizRulesWritable(bBizRuleWritable);
|
|
if(SUCCEEDED(hr) && !bBizRuleWritable)
|
|
{
|
|
DisplayInformation(hWnd,
|
|
IDS_BIZRULE_NOT_ALLOWED,
|
|
pScopeAz->GetName());
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
// Function: ParseStoreURL
|
|
// Synopsis: Extracts the store name and type from a store url
|
|
// store url are in format msldap://DN or msxml://filepath
|
|
//+--------------------------------------------------------------------------
|
|
void
|
|
ParseStoreURL(IN const CString& strStoreURL,
|
|
OUT CString& refstrStoreName,
|
|
OUT LONG& reflStoreType)
|
|
{
|
|
if(_wcsnicmp(strStoreURL,g_szMSXML,wcslen(g_szMSXML)) == 0 )
|
|
{
|
|
reflStoreType = AZ_ADMIN_STORE_XML;
|
|
refstrStoreName = strStoreURL.Mid((int)wcslen(g_szMSXML));
|
|
}
|
|
else if(_wcsnicmp(strStoreURL,g_szMSLDAP,wcslen(g_szMSLDAP)) == 0 )
|
|
{
|
|
reflStoreType = AZ_ADMIN_STORE_AD;
|
|
refstrStoreName = strStoreURL.Mid((int)wcslen(g_szMSLDAP));
|
|
}
|
|
else
|
|
{
|
|
reflStoreType = AZ_ADMIN_STORE_INVALID;
|
|
refstrStoreName = strStoreURL;
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Class: CCommandLineOptions
|
|
Purpose:class for reading the command line options for console file
|
|
******************************************************************************/
|
|
void
|
|
CCommandLineOptions::
|
|
Initialize()
|
|
{
|
|
TRACE_METHOD_EX(DEB_SNAPIN,CCommandLineOptions,Initialize)
|
|
|
|
//This should be called only once
|
|
if(m_bInit)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_bInit = TRUE;
|
|
|
|
// see if we have command line arguments
|
|
|
|
// Count of arguments
|
|
int cArgs = 0;
|
|
// Array of pointers to string
|
|
LPCWSTR * lpServiceArgVectors = (LPCWSTR *)CommandLineToArgvW(GetCommandLineW(),
|
|
&cArgs);
|
|
if (lpServiceArgVectors == NULL || cArgs <= 2)
|
|
{
|
|
// none, just return
|
|
return;
|
|
}
|
|
|
|
m_bCommandLineSpecified = TRUE;
|
|
CString strStoreURL = lpServiceArgVectors[2];
|
|
ParseStoreURL(strStoreURL,
|
|
m_strStoreName,
|
|
m_lStoreType);
|
|
|
|
Dbg(DEB_SNAPIN, "Store URL Name entered at commandline is %ws\n", CHECK_NULL(strStoreURL));
|
|
Dbg(DEB_SNAPIN, "Store Name entered at commandline is %ws\n", CHECK_NULL(m_strStoreName));
|
|
Dbg(DEB_SNAPIN, "AD store type entered is: %u\n", m_lStoreType);
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: OpenAdminManager
|
|
// Synopsis: Open an existing Authorization Store adds
|
|
// corresponding adminManager object to snapin
|
|
// Arguments:IN hWnd: Handle of window for dialog box
|
|
// IN bOpenFromSavedConsole: True if open is in response to a console
|
|
// file.
|
|
// IN lStoreType: XML or AD
|
|
// IN strName: Name of store
|
|
// IN strScriptDir : Script directory
|
|
// IN pRootData: Snapin Rootdata
|
|
// IN pComponentData: ComponentData
|
|
// Returns:
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT OpenAdminManager(IN HWND hWnd,
|
|
IN BOOL bOpenFromSavedConsole,
|
|
IN ULONG lStoreType,
|
|
IN const CString& strStoreName,
|
|
IN const CString& strScriptDir,
|
|
IN CRootData* pRootData,
|
|
IN CComponentDataObject* pComponentData)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,OpenAdminManager)
|
|
if(!pRootData || !pComponentData)
|
|
{
|
|
ASSERT(pRootData);
|
|
ASSERT(pComponentData);
|
|
return E_POINTER;
|
|
}
|
|
|
|
//NTRAID#NTBUG9-706617-2002/07/17-hiteshr Our validation code cannot validate
|
|
//ADAM dn. Do not do any validation.
|
|
|
|
////Vaidate the store name
|
|
//if(!ValidateStoreTypeAndName(hWnd,
|
|
// lStoreType,
|
|
// strStoreName))
|
|
//{
|
|
// return E_INVALIDARG;
|
|
//}
|
|
|
|
|
|
HRESULT hr = OpenCreateAdminManager(FALSE,
|
|
bOpenFromSavedConsole,
|
|
lStoreType,
|
|
strStoreName,
|
|
L"",
|
|
strScriptDir,
|
|
pRootData,
|
|
pComponentData);
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
//Display Error
|
|
if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
|
|
{
|
|
if(!bOpenFromSavedConsole)
|
|
{
|
|
::DisplayError(hWnd,
|
|
IDS_ADMIN_MANAGER_NOT_FOUND,
|
|
(LPCTSTR)strStoreName);
|
|
}
|
|
else
|
|
{
|
|
::DisplayError(hWnd,
|
|
IDS_CANNOT_FIND_AUTHORIZATION_STORE,
|
|
(LPCTSTR)strStoreName);
|
|
|
|
}
|
|
}
|
|
else if(hr == HRESULT_FROM_WIN32(ERROR_INVALID_NAME))
|
|
{
|
|
ErrorMap * pErrorMap = GetErrorMap(ADMIN_MANAGER_AZ);
|
|
::DisplayError(hWnd,
|
|
pErrorMap->idInvalidName,
|
|
pErrorMap->pszInvalidChars);
|
|
}
|
|
else
|
|
{
|
|
//Display Generic Error
|
|
CString strError;
|
|
GetSystemError(strError, hr);
|
|
::DisplayError(hWnd,
|
|
IDS_OPEN_ADMIN_MANAGER_GENERIC_ERROR,
|
|
(LPCTSTR)strError);
|
|
|
|
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: GetDisplayNameFromStoreURL
|
|
// Synopsis: Get the display name for the store.
|
|
// Arguments: strPolicyURL: This is store url in msxml://filepath or
|
|
// msldap://dn format.
|
|
// strDisplayName: This gets the display name. For xml, display
|
|
// name is name of file, for AD its name of leaf element
|
|
// Returns:
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
GetDisplayNameFromStoreURL(IN const CString& strPolicyURL,
|
|
OUT CString& strDisplayName)
|
|
{
|
|
//Store URL format has msxml:// or msldap:// prefix
|
|
//Get the store name without any prefix
|
|
CString strStorePath;
|
|
LONG lStoreType;
|
|
ParseStoreURL(strPolicyURL,
|
|
strStorePath,
|
|
lStoreType);
|
|
|
|
//Default Display Name of store is path without prefix.
|
|
strDisplayName = strStorePath;
|
|
|
|
if(AZ_ADMIN_STORE_INVALID == lStoreType)
|
|
{
|
|
ASSERT(FALSE);
|
|
return;
|
|
}
|
|
|
|
//For XML store, display name is name of the file
|
|
if(AZ_ADMIN_STORE_XML == lStoreType)
|
|
{
|
|
strDisplayName = PathFindFileName(strStorePath);
|
|
}
|
|
//For AD store, display name is name of the leaf element
|
|
else
|
|
{
|
|
do
|
|
{
|
|
CComPtr<IADsPathname> spPathName;
|
|
HRESULT hr = spPathName.CoCreateInstance(CLSID_Pathname,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER);
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
//The path which we have right now can be dn or server/dn.
|
|
//append LDAP:// to it.
|
|
CString strLDAPStorePath = g_szLDAP + strStorePath;
|
|
|
|
hr = spPathName->Set(CComBSTR(strLDAPStorePath),
|
|
ADS_SETTYPE_FULL);
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
//Get the leaf element. This will return leaf element in the
|
|
//format cn=foo. We only want "foo".
|
|
CComBSTR bstrLeaf;
|
|
hr = spPathName->Retrieve(ADS_FORMAT_LEAF ,&bstrLeaf);
|
|
BREAK_ON_FAIL_HRESULT(hr);
|
|
|
|
if(bstrLeaf.Length())
|
|
{
|
|
strDisplayName = bstrLeaf;
|
|
strDisplayName.Delete(0,strDisplayName.Find(L'=') + 1);
|
|
}
|
|
}while(0);
|
|
}
|
|
}
|
|
|
|
void
|
|
SetXMLStoreDirectory(IN CRoleRootData& roleRootData,
|
|
IN const CString& strXMLStorePath)
|
|
{
|
|
CString strXMLStoreDirectory = GetDirectoryFromPath(strXMLStorePath);
|
|
roleRootData.SetXMLStorePath(strXMLStoreDirectory);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: GetDirectoryFromPath
|
|
// Synopsis: Removes the file name from the input file path and return
|
|
// the folder path. For Ex: Input is C:\temp\foo.xml. Return
|
|
// value will be C:\temp\
|
|
//-----------------------------------------------------------------------------
|
|
CString
|
|
GetDirectoryFromPath(IN const CString& strPath)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,GetDirectoryFromPath)
|
|
Dbg(DEB_SNAPIN, "Input path", CHECK_NULL(strPath));
|
|
|
|
CString strDir;
|
|
if(strPath.GetLength() < MAX_PATH)
|
|
{
|
|
WCHAR szPath[MAX_PATH];
|
|
HRESULT hr = StringCchCopy(szPath,MAX_PATH,(LPCWSTR)strPath);
|
|
if(FAILED(hr))
|
|
return strDir;
|
|
|
|
if(!PathRemoveFileSpec(szPath))
|
|
return strDir;
|
|
|
|
PathAddBackslash(szPath);
|
|
|
|
strDir = szPath;
|
|
}
|
|
Dbg(DEB_SNAPIN, "Output Dir", CHECK_NULL(strDir));
|
|
return strDir;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
// Function: ConvertToExpandedAndAbsolutePath
|
|
// Synopsis: Expands the environment variables in the input path and also
|
|
// makes it absolute if necessary.
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
ConvertToExpandedAndAbsolutePath(IN OUT CString& strPath)
|
|
{
|
|
TRACE_FUNCTION_EX(DEB_SNAPIN,ConvertToExpandedAndAbsolutePath)
|
|
Dbg(DEB_SNAPIN, "Input name", CHECK_NULL(strPath));
|
|
do
|
|
{
|
|
//
|
|
//Expand evironment variables in the path
|
|
//
|
|
|
|
WCHAR szExpandedPath[MAX_PATH];
|
|
DWORD dwSize = ExpandEnvironmentStrings(strPath,
|
|
szExpandedPath,
|
|
MAX_PATH);
|
|
|
|
//Buffer is small, allocate required buffer and try again
|
|
if(dwSize > MAX_PATH)
|
|
{
|
|
LPWSTR pszExpandedPath = (LPWSTR)LocalAlloc(LPTR,dwSize*sizeof(WCHAR));
|
|
if(pszExpandedPath)
|
|
{
|
|
dwSize = ExpandEnvironmentStrings(strPath,
|
|
pszExpandedPath,
|
|
dwSize);
|
|
if(dwSize)
|
|
{
|
|
strPath = pszExpandedPath;
|
|
}
|
|
|
|
LocalFree(pszExpandedPath);
|
|
pszExpandedPath = NULL;
|
|
|
|
if(!dwSize)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if(dwSize)
|
|
{
|
|
strPath = szExpandedPath;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
//Make absolute path
|
|
WCHAR szAbsolutePath[MAX_PATH];
|
|
dwSize = GetFullPathName(strPath,
|
|
MAX_PATH,
|
|
szAbsolutePath,
|
|
NULL);
|
|
//Buffer is small
|
|
if(dwSize > MAX_PATH)
|
|
{
|
|
LPWSTR pszAbsolutePath = (LPWSTR)LocalAlloc(LPTR,dwSize*sizeof(WCHAR));
|
|
if(pszAbsolutePath)
|
|
{
|
|
dwSize = GetFullPathName(strPath,
|
|
MAX_PATH,
|
|
pszAbsolutePath,
|
|
NULL);
|
|
if(dwSize)
|
|
{
|
|
strPath = pszAbsolutePath;
|
|
}
|
|
|
|
LocalFree(pszAbsolutePath);
|
|
pszAbsolutePath = NULL;
|
|
}
|
|
}
|
|
else if(dwSize)
|
|
{
|
|
strPath = szAbsolutePath;
|
|
}
|
|
}while(0);
|
|
Dbg(DEB_SNAPIN, "Output name", CHECK_NULL(strPath));
|
|
}
|
|
//+----------------------------------------------------------------------------
|
|
// Function: PreprocessScript
|
|
// Synopsis: Script is read from XML file and displayed multi line edit control.
|
|
// End of line in the XML is indicated by LF instead of CRLF sequence,
|
|
// however Edit Control requires CRLF sequence to format correctly and
|
|
// with only LF it displays everything in a single line with a box for
|
|
// LF char. This function checks if script uses LF for line termination
|
|
// and changes it with CRLF sequence.
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
PreprocessScript(CString& strScript)
|
|
{
|
|
|
|
WCHAR chLF = 0x0a;
|
|
WCHAR szCRLF[3] = {0x0D, 0x0A, 0};
|
|
|
|
if(strScript.Find(chLF) != -1 && strScript.Find(szCRLF) == -1)
|
|
{
|
|
CString strProcessedScript;
|
|
|
|
int len = strScript.GetLength();
|
|
for( int i = 0; i < len; ++i)
|
|
{
|
|
WCHAR ch = strScript.GetAt(i);
|
|
if(ch == chLF)
|
|
{
|
|
strProcessedScript += szCRLF;
|
|
}
|
|
else
|
|
{
|
|
strProcessedScript += ch;
|
|
}
|
|
}
|
|
strScript = strProcessedScript;
|
|
}
|
|
}
|