windows-server-2003/admin/snapin/rolemgr/util.cpp

//+---------------------------------------------------------------------------
//
//  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;
    } 
}