windows-xp/Source/XPSP1/NT/admin/snapin/schmmgmt/schmutil.cpp

/****

SchmUtil.cpp

Various common utility routines for the Schema Editor Snap-In.

****/

#include "stdafx.h"

#include "macros.h"
USE_HANDLE_MACROS("SCHMMGMT(schmutil.cpp)")

#include "resource.h"
#include "cache.h"
#include "schmutil.h"
#include "compdata.h"

#include <wincrypt.h>  // CryptEncodeObject() and CryptDecodeObject()

//
// Removed from public headers by DS guys
// See bug 454342	XOM will not survive the transition to Win64
//
//#include <xom.h>

//
// Global strings for classes and attributes in the DS.
// These are NOT subject to localization.
//

LPWSTR g_DisplayName =          L"ldapDisplayName";
LPWSTR g_ClassFilter =          L"classSchema";
LPWSTR g_AttributeFilter =      L"attributeSchema";
LPWSTR g_Description =          L"adminDescription";
LPWSTR g_MayContain =           L"mayContain";
LPWSTR g_MustContain =          L"mustContain";
LPWSTR g_SystemMayContain =     L"systemMayContain";
LPWSTR g_SystemMustContain =    L"systemMustContain";
LPWSTR g_AuxiliaryClass =       L"auxiliaryClass";
LPWSTR g_SystemAuxiliaryClass = L"systemAuxiliaryClass";
LPWSTR g_SubclassOf =           L"subclassOf";
LPWSTR g_ObjectClassCategory =  L"objectClassCategory";
LPWSTR g_ObjectClass =			L"objectClass";
LPWSTR g_omObjectClass =        L"oMObjectClass";
LPWSTR g_CN =                   L"CN";
LPWSTR g_omSyntax =             L"oMSyntax";
LPWSTR g_AttributeSyntax =      L"attributeSyntax";
LPWSTR g_SystemOnly =           L"systemOnly";
LPWSTR g_Superiors =            L"possSuperiors";
LPWSTR g_SystemSuperiors =      L"systemPossSuperiors";
LPWSTR g_GlobalClassID =        L"governsID";
LPWSTR g_GlobalAttributeID =    L"attributeID";
LPWSTR g_RangeUpper =           L"rangeUpper";
LPWSTR g_RangeLower =           L"rangeLower";
LPWSTR g_IsSingleValued =       L"isSingleValued";
LPWSTR g_IndexFlag =            L"searchFlags";
LPWSTR g_ShowInAdvViewOnly =    L"showInAdvancedViewOnly";
LPWSTR g_UpdateSchema =         LDAP_OPATT_SCHEMA_UPDATE_NOW_W;
LPWSTR g_BecomeFsmo =           LDAP_OPATT_BECOME_SCHEMA_MASTER_W;
LPWSTR g_isDefunct =              L"isDefunct";
LPWSTR g_GCReplicated =         L"isMemberOfPartialAttributeSet";
LPWSTR g_DefaultAcl =           L"defaultSecurityDescriptor";
LPWSTR g_DefaultCategory =      L"defaultObjectCategory";
LPWSTR g_systemFlags =          L"systemFlags";
LPWSTR g_fsmoRoleOwner =        L"fsmoRoleOwner";

LPWSTR g_allowedChildClassesEffective = L"allowedChildClassesEffective";
LPWSTR g_allowedAttributesEffective =   L"allowedAttributesEffective";


LPWSTR g_ClassSearchRequest =   L"objectClass=classSchema";
LPWSTR g_AttribSearchRequest =  L"objectClass=attributeSchema";

//
// Syntax values.  Not subject to localization.
//

class CSyntaxDescriptor g_Syntax[] =
{
 /*SYNTAX_DISTNAME_TYPE                       */ CSyntaxDescriptor( IDS_SYNTAX_DN,          FALSE, FALSE, _T("2.5.5.1") , /*OM_S_OBJECT                    */  127, 9, (LPBYTE)"\x2B\x0C\x02\x87\x73\x1C\x00\x85\x4A" ),
 /*SYNTAX_OBJECT_ID_TYPE                      */ CSyntaxDescriptor( IDS_SYNTAX_OID,         FALSE, FALSE, _T("2.5.5.2") , /*OM_S_OBJECT_IDENTIFIER_STRING  */  6  , 0, NULL ),
 /*SYNTAX_NOCASE_STRING_TYPE                  */ CSyntaxDescriptor( IDS_SYNTAX_NOCASE_STR,  FALSE, TRUE,  _T("2.5.5.4") , /*OM_S_TELETEX_STRING            */  20 , 0, NULL ),
 /*SYNTAX_PRINT_CASE_STRING_TYPE              */ CSyntaxDescriptor( IDS_SYNTAX_PRCS_STR,    FALSE, TRUE,  _T("2.5.5.5") , /*OM_S_PRINTABLE_STRING          */  19 , 0, NULL ),
 /*SYNTAX_PRINT_CASE_STRING_TYPE              */ CSyntaxDescriptor( IDS_SYNTAX_I5_STR,      FALSE, TRUE,  _T("2.5.5.5") , /*OM_S_IA5_STRING                */  22 , 0, NULL ),
 /*SYNTAX_NUMERIC_STRING_TYPE                 */ CSyntaxDescriptor( IDS_SYNTAX_NUMSTR,      FALSE, FALSE, _T("2.5.5.6") , /*OM_S_NUMERIC_STRING            */  18 , 0, NULL ),
 /*SYNTAX_DISTNAME_BINARY_TYPE (OR-Name)      */ CSyntaxDescriptor( IDS_SYNTAX_OR_NAME,     FALSE, FALSE, _T("2.5.5.7") , /*OM_S_OBJECT                    */  127, 7, (LPBYTE)"\x56\x06\x01\x02\x05\x0B\x1D" ),
 /*SYNTAX_DISTNAME_BINARY_TYPE (DN-Binary)    */ CSyntaxDescriptor( IDS_SYNTAX_DN_BINARY,   FALSE, FALSE, _T("2.5.5.7") , /*OM_S_OBJECT                    */  127, 10,(LPBYTE)"\x2A\x86\x48\x86\xF7\x14\x01\x01\x01\x0B" ),
 /*SYNTAX_BOOLEAN_TYPE                        */ CSyntaxDescriptor( IDS_SYNTAX_BOOLEAN,     FALSE, FALSE, _T("2.5.5.8") , /*OM_S_BOOLEAN                   */  1  , 0, NULL ),
 /*SYNTAX_INTEGER_TYPE                        */ CSyntaxDescriptor( IDS_SYNTAX_INTEGER,      TRUE, FALSE, _T("2.5.5.9") , /*OM_S_INTEGER                   */  2  , 0, NULL ),
 /*SYNTAX_INTEGER_TYPE                        */ CSyntaxDescriptor( IDS_SYNTAX_ENUMERATION,  TRUE, FALSE, _T("2.5.5.9") , /*OM_S_ENUMERATION               */  10 , 0, NULL ),
 /*SYNTAX_OCTET_STRING_TYPE                   */ CSyntaxDescriptor( IDS_SYNTAX_OCTET,       FALSE, FALSE, _T("2.5.5.10"), /*OM_S_OCTET_STRING              */  4  , 0, NULL ),
 /*SYNTAX_OCTET_STRING_TYPE                   */ CSyntaxDescriptor( IDS_SYNTAX_REPLICA_LINK,FALSE, FALSE, _T("2.5.5.10"), /*OM_S_OBJECT                    */  127, 10,(LPBYTE)"\x2A\x86\x48\x86\xF7\x14\x01\x01\x01\x06" ),
 /*SYNTAX_TIME_TYPE                           */ CSyntaxDescriptor( IDS_SYNTAX_UTC,         FALSE, FALSE, _T("2.5.5.11"), /*OM_S_UTC_TIME_STRING           */  23 , 0, NULL ),
 /*SYNTAX_TIME_TYPE                           */ CSyntaxDescriptor( IDS_SYNTAX_GEN_TIME,    FALSE, FALSE, _T("2.5.5.11"), /*OM_S_GENERALISED_TIME_STRING   */  24 , 0, NULL ),
 /*SYNTAX_UNICODE_TYPE                        */ CSyntaxDescriptor( IDS_SYNTAX_UNICODE,     FALSE, TRUE,  _T("2.5.5.12"), /*OM_S_UNICODE_STRING            */  64 , 0, NULL ),
 /*SYNTAX_ADDRESS_TYPE                        */ CSyntaxDescriptor( IDS_SYNTAX_ADDRESS,     FALSE, FALSE, _T("2.5.5.13"), /*OM_S_OBJECT                    */  127, 9, (LPBYTE)"\x2B\x0C\x02\x87\x73\x1C\x00\x85\x5C" ),
 /*SYNTAX_DISTNAME_STRING_TYPE (Access-Point) */ CSyntaxDescriptor( IDS_SYNTAX_ACCESS_POINT,FALSE, FALSE, _T("2.5.5.14"), /*OM_S_OBJECT                    */  127, 9, (LPBYTE)"\x2B\x0C\x02\x87\x73\x1C\x00\x85\x3E" ),
 /*SYNTAX_DISTNAME_STRING_TYPE (DN-String)    */ CSyntaxDescriptor( IDS_SYNTAX_DNSTRING,    FALSE, FALSE, _T("2.5.5.14"), /*OM_S_OBJECT                    */  127, 10,(LPBYTE)"\x2A\x86\x48\x86\xF7\x14\x01\x01\x01\x0C" ),
 /*SYNTAX_NT_SECURITY_DESCRIPTOR_TYPE         */ CSyntaxDescriptor( IDS_SYNTAX_SEC_DESC,    FALSE, FALSE, _T("2.5.5.15"), /*OM_S_OBJECT_SECURITY_DESCRIPTOR*/  66 , 0, NULL ),
 /*SYNTAX_I8_TYPE                             */ CSyntaxDescriptor( IDS_SYNTAX_LINT,        FALSE, FALSE, _T("2.5.5.16"), /*OM_S_I8                        */  65 , 0, NULL ),
 /*SYNTAX_SID_TYPE                            */ CSyntaxDescriptor( IDS_SYNTAX_SID,         FALSE, FALSE, _T("2.5.5.17"), /*OM_S_OCTET_STRING              */  4  , 0, NULL ),
 /*   *** unknown -- must be last ***         */ CSyntaxDescriptor( IDS_SYNTAX_UNKNOWN,     FALSE, TRUE,  NULL,                                                0  , 0, NULL ),
};

const UINT SCHEMA_SYNTAX_UNKNOWN = sizeof( g_Syntax ) / sizeof( g_Syntax[0] ) - 1;


// Number formating printf strings
const LPWSTR g_UINT32_FORMAT	= L"%u";

#ifdef ENABLE_NEGATIVE_INT
    const LPWSTR g_INT32_FORMAT		= L"%d";
#else
	// if there is no negative numbers support, format as unsigned
    const LPWSTR g_INT32_FORMAT		= g_UINT32_FORMAT;
#endif





//
// *******************************************************************
// These are loaded from the resources as they need to be localizable.
// *******************************************************************
//

//
// Global strings for our static nodes.
//

CString g_strSchmMgmt;
CString g_strClasses;
CString g_strAttributes;

//
// Strings for various object types.
//

CString g_88Class;
CString g_StructuralClass;
CString g_AuxClass;
CString g_AbstractClass;
CString g_MandatoryAttribute;
CString g_OptionalAttribute;
CString g_Yes;
CString g_No;
CString g_Unknown;
CString g_Defunct;
CString g_Active;

//
// Message strings.
//

CString g_NoDescription;
CString g_NoName;
CString g_MsgBoxErr;
CString g_MsgBoxWarn;
CString g_SysClassString;
CString g_SysAttrString;

//
// Menu strings.
//

CString g_MenuStrings[MENU_LAST_COMMAND];
CString g_StatusStrings[MENU_LAST_COMMAND];

BOOL g_fScopeStringsLoaded = FALSE;

//
// Utility functions.
//

void
LoadGlobalCookieStrings(
)
/***

Load the global strings out of our resource table.

***/
{
   if ( !g_fScopeStringsLoaded )
   {
      //
      // Static node strings.
      //

      VERIFY( g_strSchmMgmt.LoadString(IDS_SCOPE_SCHMMGMT) );
      VERIFY( g_strClasses.LoadString(IDS_SCOPE_CLASSES) );
      VERIFY( g_strAttributes.LoadString(IDS_SCOPE_ATTRIBUTES) );

      //
      // Object name strings.
      //

      VERIFY( g_88Class.LoadString(IDS_CLASS_88) );
      VERIFY( g_StructuralClass.LoadString(IDS_CLASS_STRUCTURAL) );
      VERIFY( g_AuxClass.LoadString(IDS_CLASS_AUXILIARY) );
      VERIFY( g_AbstractClass.LoadString(IDS_CLASS_ABSTRACT) );
      VERIFY( g_MandatoryAttribute.LoadString(IDS_ATTRIBUTE_MANDATORY) );
      VERIFY( g_OptionalAttribute.LoadString(IDS_ATTRIBUTE_OPTIONAL) );
      VERIFY( g_Yes.LoadString(IDS_YES) );
      VERIFY( g_No.LoadString(IDS_NO) );
      VERIFY( g_Unknown.LoadString(IDS_UNKNOWN) );
      VERIFY( g_Defunct.LoadString(IDS_DEFUNCT) );
      VERIFY( g_Active.LoadString(IDS_ACTIVE) );

      //
      // Message strings.
      //

      VERIFY( g_NoDescription.LoadString(IDS_ERR_NO_DESCRIPTION) );
      VERIFY( g_NoName.LoadString(IDS_ERR_NO_NAME) );
      VERIFY( g_MsgBoxErr.LoadString(IDS_ERR_ERROR) );
      VERIFY( g_MsgBoxWarn.LoadString(IDS_ERR_WARNING) );
      VERIFY( g_SysClassString.LoadString(IDS_CLASS_SYSTEM) );
      VERIFY( g_SysAttrString.LoadString(IDS_ATTR_SYSTEM) );

      //
      // Syntax strings.
      //

      for( UINT i = 0;  i <= SCHEMA_SYNTAX_UNKNOWN;  i++ )
      {
         ASSERT( g_Syntax[i].m_nResourceID );
         VERIFY( g_Syntax[i].m_strSyntaxName.LoadString( g_Syntax[i].m_nResourceID ) );
      }
      

      //
      // Menu Strings
      //

      VERIFY( g_MenuStrings[CLASSES_CREATE_CLASS].LoadString(IDS_MENU_CLASS) );
      VERIFY( g_MenuStrings[NEW_CLASS].LoadString(IDS_MENU_NEW_CLASS) );
      VERIFY( g_MenuStrings[ATTRIBUTES_CREATE_ATTRIBUTE].LoadString(
        IDS_MENU_ATTRIBUTE) );
      VERIFY(g_MenuStrings[NEW_ATTRIBUTE].LoadString(IDS_MENU_NEW_ATTRIBUTE));

      VERIFY( g_MenuStrings[SCHEMA_RETARGET].LoadString(IDS_MENU_RETARGET) );
      VERIFY( g_MenuStrings[SCHEMA_EDIT_FSMO].LoadString(IDS_MENU_EDIT_FSMO) );
      VERIFY( g_MenuStrings[SCHEMA_REFRESH].LoadString(IDS_MENU_REFRESH) );
      VERIFY( g_MenuStrings[SCHEMA_SECURITY].LoadString(IDS_MENU_SECURITY) );


      VERIFY( g_StatusStrings[CLASSES_CREATE_CLASS].LoadString(
                 IDS_STATUS_CREATE_CLASS) );
      VERIFY( g_StatusStrings[ATTRIBUTES_CREATE_ATTRIBUTE].LoadString(
                 IDS_STATUS_CREATE_ATTRIBUTE) );
      VERIFY( g_StatusStrings[NEW_CLASS].LoadString(
                 IDS_STATUS_CREATE_CLASS) );
      VERIFY( g_StatusStrings[NEW_ATTRIBUTE].LoadString(
                 IDS_STATUS_CREATE_ATTRIBUTE) );
      VERIFY( g_StatusStrings[SCHEMA_RETARGET].LoadString(IDS_STATUS_RETARGET) );
      VERIFY( g_StatusStrings[SCHEMA_EDIT_FSMO].LoadString(IDS_STATUS_EDIT_FSMO) );
      VERIFY( g_StatusStrings[SCHEMA_REFRESH].LoadString(IDS_STATUS_REFRESH) );
      VERIFY( g_StatusStrings[SCHEMA_SECURITY].LoadString(IDS_STATUS_SECURITY) );

      g_fScopeStringsLoaded = TRUE;
   }
}

INT
DoErrMsgBox(
    HWND hwndParent,    // IN: Parent of the dialog box
    BOOL fError,        // IN: Is this a warning or an error?
    UINT wIdString      // IN: String resource Id of the error.
)
/***

    Display a message box with the error.

***/
{
    CString Error;

    VERIFY( Error.LoadString( wIdString ) );

	return DoErrMsgBox( hwndParent, fError, Error );
}


INT
DoErrMsgBox(
    HWND hwndParent,    // IN: Parent of the dialog box
    BOOL fError,        // IN: Is this a warning or an error?
    PCWSTR pszError     // IN: String to display.
)
/***

    Display a message box with the error.

***/
{
	return MessageBox(
                    hwndParent,
                    pszError,
                    (fError ? g_MsgBoxErr : g_MsgBoxWarn),
                    (fError ? MB_ICONSTOP : MB_ICONEXCLAMATION) | MB_OK
                     );
}


HRESULT
ComponentData::ForceDsSchemaCacheUpdate(
    VOID
)
/***

    Force the schema container to reload its interal cache.
    If this succeeds, it returns TRUE.  Otherwise, it returns
    FALSE.

***/
{

    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
    CWaitCursor wait;
    CString RootDsePath;
    IADs *pSchemaRootDse = NULL;

    SAFEARRAYBOUND RootDseBoundary[1];
    SAFEARRAY* pSafeArray = NULL;
    VARIANT AdsArray, AdsValue;
    long ArrayLen = 1;
    long ArrayPos = 0;
    HRESULT hr = S_OK;


    do
    {
        //
        // Open the root DSE on the current focus server.
        //

        GetBasePathsInfo()->GetRootDSEPath(RootDsePath);

        hr = ADsGetObject(
                 ( const_cast<BSTR>((LPCTSTR) RootDsePath ) ),
                 IID_IADs,
                 (void **)&pSchemaRootDse );

        BREAK_ON_FAILED_HRESULT(hr);

        //
        // Create the safe array for the PutEx call.
        //

        RootDseBoundary[0].lLbound = 0;
        RootDseBoundary[0].cElements = ArrayLen;

        pSafeArray = SafeArrayCreate( VT_VARIANT, ArrayLen, RootDseBoundary );
        BREAK_ON_FAILED_HRESULT(hr);

        VariantInit( &AdsArray );
        V_VT( &AdsArray ) = VT_ARRAY | VT_VARIANT;
        V_ARRAY( &AdsArray ) = pSafeArray;

        VariantInit( &AdsValue );

        V_VT(&AdsValue) = VT_I4;
        V_I4(&AdsValue) = 1;

        hr = SafeArrayPutElement( pSafeArray, &ArrayPos, &AdsValue );
        BREAK_ON_FAILED_HRESULT(hr);

        //
        // Write the update parameter.  This is synchronous
        // and when it returns, the cache is up to date.
        //

        hr = pSchemaRootDse->PutEx( ADS_PROPERTY_APPEND,
                                    const_cast<BSTR>((LPCTSTR)g_UpdateSchema),
                                    AdsArray );
        BREAK_ON_FAILED_HRESULT(hr);

        hr = pSchemaRootDse->SetInfo();
        BREAK_ON_FAILED_HRESULT(hr);

    } while( FALSE );

   
    SafeArrayDestroy( pSafeArray );

    if( pSchemaRootDse )
        pSchemaRootDse->Release();

    return hr;
}

BOOLEAN
ComponentData::AsynchForceDsSchemaCacheUpdate(
    VOID
) {

    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
    CWaitCursor wait;
    CString szSchemaContainerPath;
    IADs *pSchemaContainer;
    VARIANT AdsValue;
    HRESULT hr;
    SYSTEMTIME CurrentTime;
    double variant_time;

    //
    // Get the schema container path.
    //

    GetBasePathsInfo()->GetSchemaPath(szSchemaContainerPath);

    if (szSchemaContainerPath.IsEmpty() ) {
        return FALSE;
    }

    //
    // Open the schema container.
    //

    hr = ADsGetObject(
             (LPWSTR)(LPCWSTR)szSchemaContainerPath,
             IID_IADs,
             (void **)&pSchemaContainer );

    if ( FAILED(hr) ) {
        return FALSE;
    }

    //
    // Write the update parameter.
    //

    GetSystemTime( &CurrentTime );
    BOOL result = SystemTimeToVariantTime( &CurrentTime, &variant_time );

    ASSERT( result );

    VariantInit( &AdsValue );

    V_VT(&AdsValue) = VT_DATE;
    V_DATE(&AdsValue) = variant_time;

    hr = pSchemaContainer->Put( const_cast<BSTR>((LPCTSTR)g_UpdateSchema),
                                AdsValue );
    ASSERT( SUCCEEDED( hr ) );

    hr = pSchemaContainer->SetInfo();

    pSchemaContainer->Release();

    if ( FAILED( hr ) ) {
        return FALSE;
    }

    return TRUE;
}


HRESULT
InsertEditItems(
    HWND hwnd,
    VARIANT *AdsResult
) {

    HRESULT hr;
    SAFEARRAY *saAttributes;
    long start, end, current;
    VARIANT SingleResult;

    //
    // Check the VARIANT to make sure we have
    // an array of variants.
    //

    ASSERT( V_VT(AdsResult) == ( VT_ARRAY | VT_VARIANT ) );
    saAttributes = V_ARRAY( AdsResult );

    //
    // Figure out the dimensions of the array.
    //

    hr = SafeArrayGetLBound( saAttributes, 1, &start );

    if ( FAILED(hr) ) {
        return S_FALSE;
    }

    hr = SafeArrayGetUBound( saAttributes, 1, &end );

    if ( FAILED(hr) ) {
        return S_FALSE;
    }

    VariantInit( &SingleResult );

    //
    // Process the array elements.
    //

    for ( current = start       ;
          current <= end        ;
          current++   ) {

        hr = SafeArrayGetElement( saAttributes, &current, &SingleResult );

        if ( SUCCEEDED( hr ) ) {

            ASSERT( V_VT(&SingleResult) == VT_BSTR );

            ::SendMessage( hwnd, LB_ADDSTRING, 0,
                           reinterpret_cast<LPARAM>(V_BSTR(&SingleResult)) );

            ::SendMessage( hwnd, LB_SETITEMDATA, 0, NULL );
             
            VariantClear( &SingleResult );
        }
    }

    return S_OK;

}

HRESULT
InsertEditItems(
    CListBox& refListBox,
    CStringList& refstringlist
)
{
    POSITION pos = refstringlist.GetHeadPosition();
    while (pos != NULL)
    {
        int iItem = refListBox.AddString( refstringlist.GetNext(pos) );
        if (0 > iItem)
        {
            ASSERT(FALSE);
            return E_OUTOFMEMORY;
        }
        else
        {
            VERIFY( LB_ERR != refListBox.SetItemDataPtr( iItem, NULL ) );
        }
    }
    return S_OK;
}


inline BOOL
IsEqual( ADS_OCTET_STRING * ostr1, ADS_OCTET_STRING * ostr2 )
{
   ASSERT(ostr1);
   ASSERT(ostr2);

   if( ostr1->dwLength == ostr2->dwLength )
   {
      if( 0 == ostr1->dwLength )
         return TRUE;
      else
         return !memcmp( ostr1->lpValue, ostr2->lpValue, ostr1->dwLength );
   }
   else
      return FALSE;
}


UINT
GetSyntaxOrdinal( PCTSTR attributeSyntax, UINT omSyntax, ADS_OCTET_STRING * pOmObjectClass )
{
      ASSERT( attributeSyntax );
      ASSERT( omSyntax );
      ASSERT( pOmObjectClass );

    //
    // Return the syntax ordinal, or the unknown syntax ordinal.
    //

    UINT Ordinal = 0;

    while ( Ordinal < SCHEMA_SYNTAX_UNKNOWN) {

        if ( !_tcscmp(g_Syntax[Ordinal].m_pszAttributeSyntax, attributeSyntax))
        {
           if( omSyntax && g_Syntax[Ordinal].m_nOmSyntax == omSyntax &&
                  IsEqual( &g_Syntax[Ordinal].m_octstrOmObjectClass, pOmObjectClass ) )
              break;
        }

        Ordinal++;
    }

    return Ordinal;
}


// Coded to fail on anything suspicious
HRESULT
VariantToStringList(
    VARIANT& refvar,
        CStringList& refstringlist
)
{
    HRESULT hr = S_OK;
    long start, end, current;

    //
    // Check the VARIANT to make sure we have
    // an array of variants.
    //

    if ( V_VT(&refvar) != ( VT_ARRAY | VT_VARIANT ) )
        {
                ASSERT(FALSE);
                return E_UNEXPECTED;
        }
    SAFEARRAY *saAttributes = V_ARRAY( &refvar );

    //
    // Figure out the dimensions of the array.
    //

    hr = SafeArrayGetLBound( saAttributes, 1, &start );
        if( FAILED(hr) )
                return hr;

    hr = SafeArrayGetUBound( saAttributes, 1, &end );
        if( FAILED(hr) )
                return hr;

    VARIANT SingleResult;
    VariantInit( &SingleResult );

    //
    // Process the array elements.
    //

    for ( current = start       ;
          current <= end        ;
          current++   ) {

        hr = SafeArrayGetElement( saAttributes, &current, &SingleResult );
        if( FAILED(hr) )
            return hr;
        if ( V_VT(&SingleResult) != VT_BSTR )
                        return E_UNEXPECTED;

                refstringlist.AddHead( V_BSTR(&SingleResult) );
        VariantClear( &SingleResult );
    }

    return S_OK;
}

HRESULT
StringListToVariant(
    VARIANT& refvar,
    CStringList& refstringlist
)
{
    HRESULT hr = S_OK;
    int cCount = (int) refstringlist.GetCount();

    SAFEARRAYBOUND rgsabound[1];
    rgsabound[0].lLbound = 0;
    rgsabound[0].cElements = cCount;

    SAFEARRAY* psa = SafeArrayCreate(VT_VARIANT, 1, rgsabound);
    if (NULL == psa)
        return E_OUTOFMEMORY;

    VariantClear( &refvar );
    V_VT(&refvar) = VT_VARIANT|VT_ARRAY;
    V_ARRAY(&refvar) = psa;

    VARIANT SingleResult;
    VariantInit( &SingleResult );
    V_VT(&SingleResult) = VT_BSTR;
    POSITION pos = refstringlist.GetHeadPosition();
    long i;
    for (i = 0; i < cCount, pos != NULL; i++)
    {
        V_BSTR(&SingleResult) = T2BSTR((LPCTSTR)refstringlist.GetNext(pos));
        hr = SafeArrayPutElement(psa, &i, &SingleResult);
        if( FAILED(hr) )
            return hr;
    }
    if (i != cCount || pos != NULL)
        return E_UNEXPECTED;

    return hr;
}

HRESULT
StringListToColumnList(
    ComponentData* pScopeControl,
    CStringList& refstringlist,
    ListEntry **ppNewList
) {

    //
    // Make a column list from a string list.  We use
    // this to update the cached attributes lists.
    //

    int cCount = (int) refstringlist.GetCount();
    ListEntry *pHead = NULL;
    ListEntry *pCurrent = NULL, *pPrevious = NULL;
    POSITION pos = refstringlist.GetHeadPosition();
    CString Name;
    SchemaObject *pSchemaObject, *pSchemaHead;
    BOOLEAN fNameFound;

    for ( long i = 0; i < cCount, pos != NULL; i++ ) {

        pCurrent = new ListEntry;
        if ( !pCurrent ) {
            pScopeControl->g_SchemaCache.FreeColumnList( pHead );
            return E_OUTOFMEMORY;
        }

        if ( !pHead ) {

            pHead = pPrevious = pCurrent;

        } else {

            pPrevious->pNext = pCurrent;
            pPrevious = pCurrent;
        }

        //
        // We need to list all of these by their ldapDisplayNames,
        // so we have to reverse lookup the oid entries.
        //

        Name = ((LPCTSTR)refstringlist.GetNext(pos));
        pSchemaObject = pScopeControl->g_SchemaCache.LookupSchemaObject(
                                                         Name,
                                                         SCHMMGMT_CLASS );

        if ( !pSchemaObject ) {

            pSchemaObject = pScopeControl->g_SchemaCache.LookupSchemaObject(
                                                             Name,
                                                             SCHMMGMT_ATTRIBUTE );

            if ( !pSchemaObject) {

                //
                // We have to look up this oid.
                // First try the list of classes.
                //

                pSchemaHead = pScopeControl->g_SchemaCache.pSortedClasses;
                pSchemaObject = pSchemaHead;
                fNameFound = FALSE;

                do {

                    if ( pSchemaObject->oid == Name ) {

                        Name = pSchemaObject->ldapDisplayName;
                        fNameFound = TRUE;
                        break;
                    }

                    pSchemaObject = pSchemaObject->pSortedListFlink;

                } while ( pSchemaObject != pSchemaHead );

                //
                // Then try the list of attributes.
                //

                if ( !fNameFound ) {

                    pSchemaHead = pScopeControl->g_SchemaCache.pSortedAttribs;
                    pSchemaObject = pSchemaHead;

                    do {

                        if ( pSchemaObject->oid == Name ) {

                            Name = pSchemaObject->ldapDisplayName;
                            fNameFound = TRUE;
                            break;
                        }

                        pSchemaObject = pSchemaObject->pSortedListFlink;

                    } while ( pSchemaObject != pSchemaHead );
                }

                ASSERT( fNameFound );

            } else {

                pScopeControl->g_SchemaCache.ReleaseRef( pSchemaObject );
            }

        } else {

            pScopeControl->g_SchemaCache.ReleaseRef( pSchemaObject );
        }

        //
        // This is the ldapDisplayName!!
        //

        pCurrent->Attribute = Name;
    }

    ASSERT( cCount == i );
    ASSERT( pos == NULL );

    *ppNewList = pHead;
    return S_OK;
}


const UINT	MAX_ERROR_BUF = 2048;


VOID
DoExtErrMsgBox(
    VOID
)
{
    DWORD dwLastError;
    WCHAR szErrorBuf[MAX_ERROR_BUF + 1];
    WCHAR szNameBuf[MAX_ERROR_BUF + 1];

    // get extended error value
    HRESULT hr_return = ADsGetLastError( &dwLastError,
										   szErrorBuf,
										   MAX_ERROR_BUF,
											szNameBuf,
										   MAX_ERROR_BUF);
    if (SUCCEEDED(hr_return))
    {
		MessageBox( ::GetActiveWindow(),
					szErrorBuf,
					szNameBuf,
					MB_OK | MB_ICONSTOP );
    }
	else
		ASSERT( FALSE );
}


// INVALID_POINTER is returned by CListBox::GetItemDataPtr() in case of an error.
const VOID * INVALID_POINTER = reinterpret_cast<void *>( LB_ERR );


HRESULT
RetrieveEditItemsWithExclusions(
    CListBox& refListBox,
    CStringList& refstringlist,
    CStringList* pstringlistExclusions)
{
    CString     str;
    CString   * pstr    = NULL;
    int         nCount  = refListBox.GetCount();

    if (LB_ERR == nCount)
    {
        ASSERT(FALSE);
        return E_UNEXPECTED;
    }

    for (INT i = 0; i < nCount; i++)
    {
        pstr = static_cast<CString *>( refListBox.GetItemDataPtr(i) );
        ASSERT( INVALID_POINTER != pstr );

        // don't need to search for pstr because pstr can only be a new item,
        // and they are never excluded.

        if( pstr && INVALID_POINTER != pstr )
        {
            refstringlist.AddHead( *pstr );
        }
        else
        {
            refListBox.GetText( i, str );
            if (NULL != pstringlistExclusions)
            {
                POSITION pos = pstringlistExclusions->Find( str );
                if (NULL != pos)
                    continue;
            }

            refstringlist.AddHead( str );
        }

    }
    
    return S_OK;
}


//
// The global cookie lists for scope and result pane items.
//

VOID
CCookieList::AddCookie(
    Cookie *pCookie,
    HSCOPEITEM hScope
) {

    CCookieListEntry *pNewEntry = new CCookieListEntry;

    //
    // If there's no memory, we can't remember this and hence
    // our display may get a little out of whack.
    //

    if ( !pNewEntry ) {
        return;
    }

    pNewEntry->pCookie = pCookie;
    pNewEntry->hScopeItem = hScope;

    if ( !pHead ) {

        //
        // If this is the first one, just set the
        // head pointer.  The constructor for the
        // list entry has already set the next and
        // back pointers.
        //

        pHead = pNewEntry;

    } else {

        //
        // Insert this at the end of the circular
        // doubly-linked list.
        //

        pNewEntry->pBack = pHead->pBack;
        pNewEntry->pNext = pHead;
        pHead->pBack->pNext = pNewEntry;
        pHead->pBack = pNewEntry;
    }

    return;
}


VOID
CCookieList::InsertSortedDisplay(
    ComponentData *pScopeControl,
    SchemaObject *pNewObject
)
/***

Notes:

    This function inserts the object into the
    sorted display list.

    If the object is a class and the ComponentData
    interface pointer is provided, this routine will
    also create a cookie for this object and insert
    the scope item into the view.

***/
{

    HRESULT hr;
    CCookieListEntry *pNewEntry = NULL, *pCurrent = NULL;
    SCOPEDATAITEM ScopeItem;
    Cookie *pNewCookie= NULL;
    int compare;

    //
    // If this cookie list is empty, there's nothing
    // in the display and we don't need to do anything.
    //

    if ( !pHead ) {
        return;
    }

    //
    // Allocate a new cookie list entry.  If we can't
    // do nothing.  The display will be out of sync
    // until the user refreshes.
    //

    pNewEntry = new CCookieListEntry;

    if ( !pNewEntry ) {
        return;
    }

    //
    // Prepare the required mmc structures.
    //

    if ( pNewObject->schemaObjectType == SCHMMGMT_CLASS ) {

        if ( !pScopeControl ) {

            //
            // If there's no scope control, we can't insert anything.
            //

            delete pNewEntry;
            return;
        }

        // prefix believes that this allocation (or construction) may throw
        // an exception, and if an exception is thrown, pNewEntry is
        // leaked.  After a lot of digging, it's possible that a
        // CMemoryException instance may be thrown by one of the base
        // classes of one the members of CBaseCookieBlock, which is a base
        // clase of Cookie.        
        // NTRAID#NTBUG9-294879-2001/01/26-sburns
        
        try
        {
           pNewCookie = new Cookie( SCHMMGMT_CLASS,
                         pParentCookie->QueryNonNULLMachineName() );
        }
        catch (...)
        {
           delete pNewEntry;
           return;
        }

        if ( !pNewCookie ) {

            //
            // If we can't allocate a cookie, do nothing.
            //

            delete pNewEntry;
            return;
        }

        pNewCookie->pParentCookie = pParentCookie;
        pNewCookie->strSchemaObject = pNewObject->commonName;

        pParentCookie->m_listScopeCookieBlocks.AddHead(
            (CBaseCookieBlock*)pNewCookie );

        pNewEntry->pCookie = pNewCookie;

        ::ZeroMemory( &ScopeItem, sizeof(ScopeItem) );
        ScopeItem.displayname = MMC_CALLBACK;
        ScopeItem.nState = 0;

        ScopeItem.lParam = reinterpret_cast<LPARAM>((CCookie*)pNewCookie);
        ScopeItem.nImage = pScopeControl->QueryImage( *pNewCookie, FALSE );
        ScopeItem.nOpenImage = pScopeControl->QueryImage( *pNewCookie, TRUE );

    }

    //
    // Should this be the new head of the list?
    //

    compare = pNewObject->ldapDisplayName.CompareNoCase(
                  pHead->pCookie->strSchemaObject );

    if ( compare < 0 ) {

        if ( pNewObject->schemaObjectType == SCHMMGMT_CLASS ) {

            //
            // Insert this into the scope pane.
            //

            ScopeItem.mask = SDI_STR | SDI_IMAGE | SDI_OPENIMAGE | SDI_STATE |
                             SDI_PARAM | SDI_NEXT | SDI_CHILDREN;
            ScopeItem.cChildren = 0;

            ScopeItem.relativeID = pHead->hScopeItem;

            hr = pScopeControl->m_pConsoleNameSpace->InsertItem( &ScopeItem );

            pNewEntry->hScopeItem = ScopeItem.ID;
            pNewEntry->pCookie->m_hScopeItem = ScopeItem.ID;

        } else {

            hr = S_OK;
        }

        if ( SUCCEEDED(hr) ) {

            pNewEntry->pNext = pHead;
            pNewEntry->pBack = pHead->pBack;
            pHead->pBack->pNext = pNewEntry;
            pHead->pBack = pNewEntry;

            pHead = pNewEntry;

        } else {

            delete pNewEntry;
            delete pNewCookie;
        }

        return;
    }

    //
    // Determine the sorted insertion point.  The sorted list is circular.
    //

    pCurrent = pHead;

    while ( pCurrent->pNext != pHead ) {

        compare = pNewObject->ldapDisplayName.CompareNoCase(
                      pCurrent->pNext->pCookie->strSchemaObject );

        if ( compare < 0 ) {
            break;
        }

        pCurrent = pCurrent->pNext;
    }

    //
    // We want to insert the new object after pCurrent.
    //

    if ( pNewObject->schemaObjectType == SCHMMGMT_CLASS ) {

        ScopeItem.mask = SDI_STR | SDI_IMAGE | SDI_OPENIMAGE | SDI_STATE |
                         SDI_PARAM | SDI_PREVIOUS | SDI_CHILDREN;
        ScopeItem.cChildren = 0;

        ScopeItem.relativeID = pCurrent->hScopeItem;

        hr = pScopeControl->m_pConsoleNameSpace->InsertItem( &ScopeItem );

        pNewEntry->hScopeItem = ScopeItem.ID;
        pNewEntry->pCookie->m_hScopeItem = ScopeItem.ID;

    } else {

        hr = S_OK;
    }

    if ( SUCCEEDED( hr )) {

       pNewEntry->pNext = pCurrent->pNext;
       pNewEntry->pBack = pCurrent;
       pCurrent->pNext->pBack = pNewEntry;
       pCurrent->pNext = pNewEntry;

    } else {

        delete pNewEntry;
        delete pNewCookie;
    }

    return;
}

bool
CCookieList::DeleteCookie(Cookie* pCookie)
{
   bool result = false;

   if (!pHead)
   {
      return result;
   }

   // walk the links and stop when the scope item matches.
   // Since the list is circular,
   // we use pHead as the sentinal value instead of null.

   CCookieListEntry* pCurrent = pHead;
   do
   {
       ASSERT(pCurrent);

       if (pCurrent->pCookie == pCookie)
       {
          // Remove the node from the list

          pCurrent->pBack->pNext = pCurrent->pNext;
          pCurrent->pNext->pBack = pCurrent->pBack;

          if (pCurrent == pHead)
          {
             pHead = pCurrent->pNext;
          }

          result = true;

          delete pCurrent;
          break;
       }

       pCurrent = pCurrent->pNext;

   } while (pCurrent != pHead);

   return result;
}

void
CCookieList::DeleteAll()
{
   if (!pHead)
   {
      return;
   }


   CCookieListEntry* pCurrent = pHead;
   do
   {
      CCookieListEntry* next = pCurrent->pNext;
      delete pCurrent;
      pCurrent = next;
   }
   while (pCurrent != pHead);

   pHead = 0;
}



CString
GetHelpFilename()
{
   TCHAR buf[MAX_PATH + 1];

   UINT result = ::GetSystemWindowsDirectory(buf, MAX_PATH);
   ASSERT(result != 0 && result <= MAX_PATH);

   CString f(buf);
   f += TEXT("\\help\\schmmgmt.hlp");

   return f;
}


BOOL
ShowHelp( HWND hParent, WPARAM wParam, LPARAM lParam, const DWORD ids[], BOOL fContextMenuHelp )
{
   HWND hWndMain = NULL;
   UINT uCommand = 0;

   if( !fContextMenuHelp )
   {
       // The user has clicked ? and the control, or just F1 (if enabled)
       const LPHELPINFO pHelpInfo = (LPHELPINFO)lParam;
       if (pHelpInfo && pHelpInfo->iContextType == HELPINFO_WINDOW)
       {
            hWndMain = (HWND) pHelpInfo->hItemHandle;
            uCommand = HELP_WM_HELP;
       }
   }
   else
   {
       hWndMain = (HWND) wParam;
       uCommand = HELP_CONTEXTMENU;

       // Optimization for non-static enabled windows.
       // This way users don't have to do an extra menu click

       // $$ don't know why this call returns NULL all the time
       // HWND hWnd = ChildWindowFromPoint( hParent, CPoint(lParam) );
       // if( hWnd )
       //   hWndMain = hWnd;

       if( -1 != GET_X_LPARAM(lParam) &&
           -1 != GET_Y_LPARAM(lParam) &&
           hParent                    &&
           hWndMain != hParent )
       {
           uCommand = HELP_WM_HELP;
       }
   }
   

   if( hWndMain && uCommand )
   {
       // Display context help for a control
       ::WinHelp( hWndMain,
                  GetHelpFilename(),
                  uCommand,
                  (DWORD_PTR) ids );
   }

   return TRUE;
}


#if 0

VOID
DebugTrace(
    LPWSTR Format,
    ...
) {

    WCHAR DbgString[1024];
    va_list arglist;
    int Length;

    //
    // Format the output into a buffer and then print it.
    //

    va_start(arglist, Format);

    Length = wvsprintf( DbgString, Format, arglist );

    va_end(arglist);

    ASSERT( Length <= 1024 );
    ASSERT( Length != 0 );

    OutputDebugString( DbgString );

    return;

}

#else


VOID
DebugTrace(
    LPWSTR,
    ...
) {
 ;
}

#endif




// Attempt to locate a message in a given module.  Return the message string
// if found, the empty string if not.
// 
// flags - FormatMessage flags to use
// 
// module - module handle of message dll to look in, or 0 to use the system
// message table.
// 
// code - message code to look for

CString
getMessageHelper(DWORD flags, HMODULE module, HRESULT code)
{
   ASSERT(code);
   ASSERT(flags & FORMAT_MESSAGE_ALLOCATE_BUFFER);

   CString message;

   TCHAR* sys_message = 0;
   DWORD result =
      ::FormatMessage(
         flags,
         module,
         static_cast<DWORD>(code),
         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
         reinterpret_cast<LPTSTR>(&sys_message),
         0,
         0);
   if (result)
   {
      ASSERT(sys_message);
      if (sys_message)
      {
         message = sys_message;
         ::LocalFree(sys_message);
      }
   }

   return message;
}


#define MAX_ERROR_BUF   2048

HRESULT
GetLastADsError( HRESULT hr, CString& refErrorMsg, CString& refName )
{
  ASSERT(FAILED(hr));

  refErrorMsg.Empty();
  refName.Empty();

  if (!FAILED(hr))
  {
       return hr;
  }

   if( FACILITY_WIN32 == HRESULT_FACILITY(hr) )
   {
       DWORD dwLastError = 0;
       WCHAR szErrorBuf[ MAX_ERROR_BUF + 1 ];
       WCHAR szNameBuf[ MAX_ERROR_BUF + 1 ];

       //Get extended error value.
       HRESULT hr_return = ADsGetLastError( &dwLastError,
                                            szErrorBuf,
                                            MAX_ERROR_BUF,
                                            szNameBuf,
                                            MAX_ERROR_BUF );
       
       ASSERT( SUCCEEDED(hr_return) );
       if( SUCCEEDED(hr_return) && dwLastError )
       {
            refErrorMsg = szErrorBuf;
            refName     = szNameBuf;
            return HRESULT_FROM_WIN32( dwLastError );
       }
   }

   return hr;
}

// Attempts to locate message strings for various facility codes in the
// HRESULT.  If fTryADSIExtError is true, check ADsGetLastError() first


CString
GetErrorMessage( HRESULT hr, BOOL fTryADSIExtError /* = FALSE */ )
{
   ASSERT(FAILED(hr));

   if (!FAILED(hr))
   {
      // no messages for success!
      return CString();
   }

   
   CString  strExtMsg;
   
   if( fTryADSIExtError &&
       FACILITY_WIN32 == HRESULT_FACILITY(hr) )
   {
       DWORD dwLastError = 0;
       WCHAR szErrorBuf[ MAX_ERROR_BUF + 1 ];
       WCHAR szNameBuf[ MAX_ERROR_BUF + 1 ];

       //Get extended error value.
       HRESULT hr_return = ADsGetLastError( &dwLastError,
                                            szErrorBuf,
                                            MAX_ERROR_BUF,
                                            szNameBuf,
                                            MAX_ERROR_BUF );
       
       ASSERT( SUCCEEDED(hr_return) );
       if( SUCCEEDED(hr_return) && dwLastError )
       {
            hr = HRESULT_FROM_WIN32( dwLastError );

            strExtMsg = szErrorBuf;
       }
   }

   HRESULT code = HRESULT_CODE(hr);

   CString message;

   // default is the system error message table
   HMODULE module = 0;

   DWORD flags =
         FORMAT_MESSAGE_ALLOCATE_BUFFER
      |  FORMAT_MESSAGE_IGNORE_INSERTS
      |  FORMAT_MESSAGE_FROM_SYSTEM;

   int facility = HRESULT_FACILITY(hr);
   switch (facility)
   {
      case FACILITY_WIN32:    // 0x7
      {
         // included here:
         // lanman error codes (in it's own dll)
         // dns
         // winsock

         static HMODULE lm_err_res_dll = 0;
         if (code >= NERR_BASE && code <= MAX_NERR)
         {
            // use the net error message resource dll
            if (lm_err_res_dll == 0)
            {
               lm_err_res_dll =
                  ::LoadLibraryEx(
                     L"netmsg.dll",
                     0,
                     LOAD_LIBRARY_AS_DATAFILE);
            }

            module = lm_err_res_dll;
            flags |= FORMAT_MESSAGE_FROM_HMODULE;
         }
         break;
      }
      case 0x0:
      {
         if (code >= 0x5000 && code <= 0x50FF)
         {
            // It's an ADSI error.  They put the facility code (5) in the
            // wrong place!
            static HMODULE adsi_err_res_dll = 0;
            // use the net error message resource dll
            if (adsi_err_res_dll == 0)
            {
               adsi_err_res_dll =
                  ::LoadLibraryEx(
                     L"activeds.dll",
                     0,
                     LOAD_LIBRARY_AS_DATAFILE);
            }

            module = adsi_err_res_dll;
            flags |= FORMAT_MESSAGE_FROM_HMODULE;

            // the message dll expects the entire error code
            code = hr;
         }
         break;
      }
      default:
      {
         // do nothing
         break;
      }
   }

   message = getMessageHelper(flags, module, code);


#ifdef SHOW_EXT_LDAP_MSG

   if( !strExtMsg.IsEmpty() )
       message += L"\n" + strExtMsg;

#endif //SHOW_EXT_LDAP_MSG


   if (message.IsEmpty())
   {
      message.LoadString(IDS_UNKNOWN_ERROR_MESSAGE);
   }

   return message;
}



//
// Get range from edit controls, Verify the range, attempt to correct, make sure lower <= upper.
//
//	an exception will be thrown in case of an error.
//
void DDXV_VerifyAttribRange( CDataExchange *pDX, BOOL fIsSigned,
								UINT idcLower, CString & strLower,
								UINT idcUpper, CString & strUpper )
{
	INT64		llLower	= 0;
	INT64		llUpper	= 0;

	ASSERT( pDX );
	ASSERT( pDX->m_pDlgWnd );


	// Update the values.
	llLower = DDXV_SigUnsigINT32Value( pDX, fIsSigned, idcLower, strLower );
	llUpper = DDXV_SigUnsigINT32Value( pDX, fIsSigned, idcUpper, strUpper );


#ifdef ENABLE_NEGATIVE_INT
    // verify that lower <= upper  --  only if supporting ENABLE_NEGATIVE_INT
    if ( pDX->m_bSaveAndValidate && !strLower.IsEmpty() && !strUpper.IsEmpty() )
	{
		if( llLower > llUpper )
		{
			DoErrMsgBox( pDX->m_pDlgWnd->m_hWnd, TRUE, IDS_ERR_EDIT_MINMAX );
			pDX->Fail();		// we are still at the second edit control.
		}
	}
#endif //ENABLE_NEGATIVE_INT
}


//
// Get string from an edit control, verify it attempting to correct
//
//	an exception will be thrown in case of an error.
//
// Returns corrected value
//
INT64 DDXV_SigUnsigINT32Value( CDataExchange *pDX, BOOL fIsSigned,
						UINT idc, CString & str )
{
	INT64	llVal	= 0;
	HRESULT	hr		= S_OK;
	
	ASSERT( pDX );
	ASSERT( pDX->m_pDlgWnd );

	// Get/Put the string
	DDX_Text( pDX, idc, str );

    if ( pDX->m_bSaveAndValidate )
	{
		if( !str.IsEmpty() )
		{
			hr = GetSafeINT32FromString( pDX->m_pDlgWnd, llVal, str,
										fIsSigned, GETSAFEINT_ALLOW_CANCEL );

			if( FAILED(hr) )
			{
				pDX->Fail();
			}
			else if( S_VALUE_MODIFIED == hr )
			{
				// update the string in case of some conversion things ('010' --> '10')
				// or if the value was changed
				pDX->m_pDlgWnd->SetDlgItemText( idc, str );
			}
		}
	}

	return llVal;
}



//
// Converts a string to a DWORD, asks to correct to be within the range.
// returns HRESULT:
//	S_OK				llDst is the value from string
//	S_VALUE_MODIFIED	llDst is the truncated value, strSrc is updated
//	E_ABORT				llDst is unchanged; E_ABORT may be returned only if fAllowCancel is TRUE
//
HRESULT GetSafeSignedDWORDFromString( CWnd * pwndParent, DWORD & dwDst, CString & strSrc,
										BOOL fIsSigned, BOOL fAllowCancel /* =FALSE */)
{
	INT64	llDst	= 0;
	HRESULT	hr		= GetSafeINT32FromString( pwndParent, llDst, strSrc, fIsSigned, fAllowCancel );

	if( SUCCEEDED( hr ) )
		dwDst = (DWORD) llDst;

	return hr;
}


//
//		*** internal use ***
// Converts a string to a INT64, asks to correct to be within the range.
// returns HRESULT:
//	S_OK				llDst is the value from string
//	S_VALUE_MODIFIED	llDst is the truncated value, strSrc is updated
//	E_ABORT				llDst is the truncated value
//							E_ABORT only happens if fAllowCancel is TRUE
//
HRESULT GetSafeINT32FromString( CWnd * pwndParent, INT64 & llDst, CString & strSrc,
								BOOL fIsSigned, BOOL fAllowCancel)
{
	HRESULT		hr				= S_OK;
	UINT		nMessageBoxType	= 0;
	CString		szMsg;
	CString		szSugestedNumber;
	BOOL		fIsValidNumber	= TRUE;
	BOOL		fIsValidString	= TRUE;
	

	ASSERT( pwndParent );

	// the string must be limited in length & not empty
	ASSERT( !strSrc.IsEmpty() );
	ASSERT( strSrc.GetLength() <= cchMinMaxRange );

	fIsValidString	= IsValidNumberString( strSrc );

	llDst			= _wtoi64( (LPCWSTR) strSrc );
	fIsValidNumber	= IsValidNumber32( llDst, fIsSigned );
	szSugestedNumber.Format( fIsSigned ? g_INT32_FORMAT : g_UINT32_FORMAT, (DWORD) llDst );

	if( !fIsValidString || !fIsValidNumber )
	{
		szMsg.FormatMessage( !fIsValidString ? IDS_ERR_NUM_IS_ILLIGAL : IDS_ERR_INT_OVERFLOW,
								(LPCWSTR) strSrc, (LPCWSTR) szSugestedNumber );

		// make sure the user wants to do it
        nMessageBoxType = (fAllowCancel ? MB_OKCANCEL : MB_OK) | MB_ICONEXCLAMATION ;

        if( IDOK == pwndParent->MessageBox( szMsg, g_MsgBoxErr, nMessageBoxType ) )
		{
			strSrc	= szSugestedNumber;
			hr		= S_VALUE_MODIFIED;
		}
		else
		{
			hr		= E_ABORT;
		}
	}
	else if( strSrc != szSugestedNumber )
	{
		// fixing number formating
		strSrc	= szSugestedNumber;
		hr		= S_VALUE_MODIFIED;
	}

	return hr;
}


//
// Verify & correct Min/Max for a signed/unsigned INT64 value
//
BOOL IsValidNumber32( INT64 & llVal, BOOL fIsSigned )
{

#ifdef ENABLE_NEGATIVE_INT
	const INT64	llMinVal	= fIsSigned ? (INT64) _I32_MIN : (INT64) 0 ;
	const INT64	llMaxVal	= fIsSigned ? (INT64) _I32_MAX : (INT64) _UI32_MAX ;
#else
	// if there is no negative numbers support, always use unsigned numbers
	const INT64	llMinVal	= (INT64) 0;
	const INT64	llMaxVal	= (INT64) _UI32_MAX;
#endif

	BOOL		fIsValid	= FALSE;

	// if larger than 32bit number (signed/unsigned), truncate...
	if( llVal < llMinVal )
	{
		llVal		= llMinVal;
	}
	else if( llVal > llMaxVal )
	{
		llVal		= llMaxVal;
	}
	else
	{
		fIsValid	= TRUE;
	}

	return fIsValid;
}


//
// Search number string for illigal characters.
//
BOOL IsValidNumberString( CString & str )
{
	int i = 0;

#ifdef ENABLE_NEGATIVE_INT
	if( str.GetLength() > 0 &&					// allow negative sign in front of the number
		g_chNegativeSign == str[ i ] )
	{
		i++;	// skip first character
	}
#endif //ENABLE_NEGATIVE_INT

	for( ;  i < str.GetLength();  i++ )
	{
		if( !IsCharNumeric( str[i] ) )
			return FALSE;
	}

	return TRUE;
}


/////////////////////////////////////////////////////////////////////////////
// ParsedEdit

BEGIN_MESSAGE_MAP(CParsedEdit, CEdit)
	//{{AFX_MSG_MAP(CParsedEdit)
	ON_WM_CHAR()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// Initialize subclassing

BOOL CParsedEdit::SubclassEdit( UINT nID,
                                CWnd* pParent,
                                int cchMaxTextSize )   // 0 == unlimited
{
    ASSERT( IsInitialized() );
	ASSERT( nID );
	ASSERT( pParent );
	ASSERT( pParent->GetDlgItem(nID) );
    ASSERT( cchMaxTextSize >= 0 );

    ( static_cast<CEdit *>( pParent->GetDlgItem(nID) ) ) -> LimitText( cchMaxTextSize ) ;

    if( EDIT_TYPE_GENERIC == GetEditType() )
    {
        return TRUE;        // no need to subclass - everything is allowed.
    }
    else
    {
        return SubclassDlgItem(nID, pParent);
    }
}

/////////////////////////////////////////////////////////////////////////////
// Input character filter

void CParsedEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
    ASSERT( IsInitialized() ); // initialized?
	
	BOOL	fIsSpecialChar	= ( nChar < 0x20 );

    BOOL    fAllowChar      = FALSE;


    if( fIsSpecialChar )
    {
        fAllowChar = TRUE;      // always allow control chars
    }
    else
    {
        // is this a digit?
        BOOL	fIsDigit		= IsCharNumeric( (TCHAR)nChar );

        switch( GetEditType() )
        {
            default:
                ASSERT( FALSE );
                break;

            case EDIT_TYPE_GENERIC:         // everything is allowed
                fAllowChar = TRUE;
                break;

            case EDIT_TYPE_INT32:
            case EDIT_TYPE_UINT32:
                {
                    #ifdef ENABLE_NEGATIVE_INT
    	              const BOOL    fAllowNegativeNumbers   = TRUE;
                    #else
	                  const BOOL    fAllowNegativeNumbers   = FALSE;
                    #endif

                    DWORD	dwSel			= GetSel();

	                //	is the caret in the begining of the box
	                BOOL	fLineFront		= ! LOWORD( dwSel );

	                //	is the first character selected? (thus, typing anything will overide it)
	                BOOL	fIsSelFirstChar	= fLineFront && HIWORD( dwSel );

	                BOOL	fIsNegSign		= ( (TCHAR)nChar == g_chNegativeSign );

                  WCHAR	szBuf[ 2 ] = {0};		// we only need the first character to check for '-'

	                // if the first character is selected, no matter what we type it will be overwritten
	                // an empty value is a positive value.
	                // rellies on left to right execution.
	                BOOL	fIsAlreadyNeg	= (	!fIsSelFirstChar &&
							                GetWindowText( szBuf, 2 ) &&
							                g_chNegativeSign == szBuf[0] );

	                ASSERT( !fIsDigit || !fIsNegSign ); // cannot be both!


                    if (
                        (	fIsDigit &&                         // allow numeric if ...
                              ( !fAllowNegativeNumbers ||       //      ignore error checking if false
                                !fLineFront ||                  //    	not first position
                                (fLineFront && !fIsAlreadyNeg)) //    	first pos & no '-' sign
                        )
                  
                        ||

                        (	fIsNegSign &&                       // allow '-' if
                              fAllowNegativeNumbers &&          //  negatives are allowed
                              FIsSigned() &&                    //	signed numbers are allowed
                              !fIsAlreadyNeg &&                 //	the number was positive
                              fLineFront                        //	entering as the first character
                        )
                       )
                    {
                        fAllowChar = TRUE;
                    }
                }
                break;

            case EDIT_TYPE_OID:     // do a light checking -- allow digits & periods
                {
                    if( fIsDigit ||
                        g_chPeriod == (TCHAR)nChar )
                    {
                        fAllowChar = TRUE;
                    }
                }
                break;
        }
    }
    
	
    if( fAllowChar )
    {
		CEdit::OnChar(nChar, nRepCnt, nFlags);  // permitted
	}
	else
	{											// not permitted
		MessageBeep((UINT)-1);					// Standard beep
	}
}



/////////////////////////////////////////////////////////////////////////////
//
//  Search a list of PCTSTR for a strValue, returns TRUE if found
//      rgszList[] last element must be NULL
//
//  puIndex - optional pointer, will be set to the position of the value if found.
//
BOOL
IsInList( PCTSTR rgszList[], const CString & strValue, UINT * puIndex /* = NULL */ )
{
    UINT   uIndex = 0;

    while( rgszList[ uIndex ] )
    {
        if( !strValue.CompareNoCase( rgszList[uIndex] ) )
        {
            if( puIndex )
                *puIndex = uIndex;
            return TRUE;
        }
        else
            uIndex++;
    }

    return FALSE;
}


#define ADS_SYSTEMFLAG_SCHEMA_CONSTRUCTED 0x04
#define ADS_SYSTEMFLAG_SCHEMA_BASE_OBJECT 0x10


//
//  Determine if the object pointed to by pIADsObject is a constructed object.
//
HRESULT
IsConstructedObject( IADs *pIADsObject, BOOL & fIsConstructed )
{
    LONG    fSysAttribs = 0;
    HRESULT hr          = GetSystemAttributes( pIADsObject, fSysAttribs );

    if( SUCCEEDED(hr) )
        fIsConstructed = ADS_SYSTEMFLAG_SCHEMA_CONSTRUCTED & fSysAttribs;

    return hr;
}



//
//  Determine if the object pointed to by pIADsObject is category 1 object.
//
HRESULT
IsCategory1Object( IADs *pIADsObject, BOOL & fIsCategory1 )
{
    LONG    fSysAttribs = 0;
    HRESULT hr          = GetSystemAttributes( pIADsObject, fSysAttribs );

    if( SUCCEEDED(hr) )
        fIsCategory1 = ADS_SYSTEMFLAG_SCHEMA_BASE_OBJECT & fSysAttribs;

    return hr;
}



//
//  Read object's System Attribute
//
HRESULT
GetSystemAttributes( IADs *pIADsObject, LONG &fSysAttribs )
{
    HRESULT hr = E_FAIL;
    VARIANT	AdsResult;

    if( !pIADsObject )
        ASSERT( FALSE );
    else
    {
        VariantInit( &AdsResult );

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_systemFlags), &AdsResult );
        
        if ( SUCCEEDED( hr ) )
        {
            ASSERT(AdsResult.vt == VT_I4);
            fSysAttribs = V_I4(&AdsResult);
        }
        else if( E_ADS_PROPERTY_NOT_FOUND == hr )
        {
            fSysAttribs = 0;
            hr = S_OK;
        }

        VariantClear( &AdsResult );
    }

    return hr;
}


HRESULT
DissableReadOnlyAttributes( CWnd * pwnd, IADs *pIADsObject, const CDialogControlsInfo * pCtrls, UINT cCtrls )
{
    ASSERT( pwnd );
    ASSERT( pIADsObject );
    ASSERT( pCtrls );
    ASSERT( cCtrls );

    HRESULT         hr      = S_OK;
    CStringList     strlist;

    do
    {
        // extract the list of allowed attributes
        hr = GetStringListElement( pIADsObject, &g_allowedAttributesEffective, strlist );
        BREAK_ON_FAILED_HRESULT(hr);

        for( UINT ind = 0; ind < cCtrls; ind++ )
        {
            BOOL    fFound = FALSE;

            // search for needed attributes
            for( POSITION pos = strlist.GetHeadPosition(); !fFound && pos != NULL; )
            {
                CString * pstr = &strlist.GetNext( pos );
            
                if( !pstr->CompareNoCase( pCtrls[ind].m_pszAttributeName ) )
                {
                    fFound = TRUE;
                }
            }

            if( !fFound )
            {
                ASSERT( pwnd->GetDlgItem( pCtrls[ind].m_nID ) );

                if( pCtrls[ind].m_fIsEditBox )
                    reinterpret_cast<CEdit *>( pwnd->GetDlgItem(pCtrls[ind].m_nID) )->SetReadOnly();
                else
                    pwnd->GetDlgItem(pCtrls[ind].m_nID)->EnableWindow( FALSE );
            }
        }

    } while( FALSE );

    return hr;
}


HRESULT GetStringListElement( IADs *pIADsObject, LPWSTR *lppPathNames, CStringList &strlist )
{
    ASSERT( pIADsObject );
    ASSERT( lppPathNames );
    ASSERT( *lppPathNames );

    HRESULT         hr      = S_OK;
    VARIANT         varAttributes;

    VariantInit( &varAttributes );

    strlist.RemoveAll();
    
    do
    {
        // build an array of one element
        hr = ADsBuildVarArrayStr( lppPathNames, 1, &varAttributes );
        ASSERT_BREAK_ON_FAILED_HRESULT(hr);

        hr = pIADsObject->GetInfoEx( varAttributes, 0 );
        BREAK_ON_FAILED_HRESULT(hr);

        hr = VariantClear( &varAttributes );
        ASSERT_BREAK_ON_FAILED_HRESULT(hr);


        // Get all allowed attributes
        hr = pIADsObject->GetEx( *lppPathNames, &varAttributes );
        BREAK_ON_FAILED_HRESULT(hr);

        // Convert result to a string list
        hr = VariantToStringList( varAttributes, strlist );
        ASSERT( SUCCEEDED(hr) || E_ADS_PROPERTY_NOT_FOUND == hr );
        BREAK_ON_FAILED_HRESULT(hr);

    } while( FALSE );

    VariantClear( &varAttributes );

    return hr;
}


bool OIDHasValidFormat (PCWSTR pszOidValue, int& rErrorTypeStrID)
{
    rErrorTypeStrID = 0;

    bool bFormatIsValid = false;
    int  nLen = WideCharToMultiByte(
          CP_ACP,                   // code page
          0,                        // performance and mapping flags
          pszOidValue,              // wide-character string
          (int) wcslen (pszOidValue),  // number of chars in string
          0,                        // buffer for new string
          0,                        // size of buffer
          0,                        // default for unmappable chars
          0);                       // set when default char used
    if ( nLen > 0 )
    {
        nLen++; // account for Null terminator
        PSTR    pszAnsiBuf = new CHAR[nLen];
        if ( pszAnsiBuf )
        {
            ZeroMemory (pszAnsiBuf, nLen*sizeof(CHAR));
            nLen = WideCharToMultiByte(
                    CP_ACP,                 // code page
                    0,                      // performance and mapping flags
                    pszOidValue,            // wide-character string
                    (int) wcslen (pszOidValue),   // number of chars in string
                    pszAnsiBuf,             // buffer for new string
                    nLen,                   // size of buffer
                    0,                      // default for unmappable chars
                    0);                     // set when default char used
            if ( nLen )
            {
                // According to PhilH:
                // The first number is limited to 
                // 0,1 or 2. The second number is 
                // limited to 0 - 39 when the first 
                // number is 0 or 1. Otherwise, any 
                // number.
                // Also, according to X.208, there 
                // must be at least 2 numbers.
                bFormatIsValid = true;
                size_t cbAnsiBufLen = strlen (pszAnsiBuf);

                // check for only digits and "."
                size_t nIdx = strspn (pszAnsiBuf, "0123456789.\0");
                if ( nIdx > 0 && nIdx < cbAnsiBufLen )
                {
                    bFormatIsValid = false;
                    rErrorTypeStrID = IDS_OID_CONTAINS_NON_DIGITS;
                }

                // check for consecutive "."s - string not valid if present
                if ( bFormatIsValid && strstr (pszAnsiBuf, "..") )
                {
                    bFormatIsValid = false;
                    rErrorTypeStrID = IDS_OID_CONTAINS_CONSECUTIVE_DOTS;
                }
                

                // must begin with "0." or "1." or "2."
                bool bFirstNumberIs0 = false;
                bool bFirstNumberIs1 = false;
                bool bFirstNumberIs2 = false;
                if ( bFormatIsValid )
                {
                    if ( !strncmp (pszAnsiBuf, "0.", 2) )
                        bFirstNumberIs0 = true;
                    else if ( !strncmp (pszAnsiBuf, "1.", 2) )
                        bFirstNumberIs1 = true;
                    else if ( !strncmp (pszAnsiBuf, "2.", 2) )
                        bFirstNumberIs2 = true;
                    
                    if ( !bFirstNumberIs0 && !bFirstNumberIs1 && !bFirstNumberIs2 )
                    {
                        bFormatIsValid = false;
                        rErrorTypeStrID = IDS_OID_MUST_START_WITH_0_1_2;
                    }
                }

                if ( bFormatIsValid && ( bFirstNumberIs0 || bFirstNumberIs1 ) )
                {
                    PSTR pszBuf = pszAnsiBuf;
                    pszBuf += 2;

                    // there must be a number after the dot
                    if ( strlen (pszBuf) )
                    {
                        // truncate the string at the next dot, if any
                        PSTR pszDot = strstr (pszBuf, ".");
                        if ( pszDot )
                            pszDot[0] = 0;

                        // convert the string to a number and check for range 0-39
                        int nValue = atoi (pszBuf);
                        if ( nValue < 0 || nValue > 39 )
                        {
                            bFormatIsValid = false;
                            rErrorTypeStrID = IDS_OID_0_1_MUST_BE_0_TO_39;
                        }
                    }
                    else
                    {
                        bFormatIsValid = false;
                        rErrorTypeStrID = IDS_OID_MUST_HAVE_TWO_NUMBERS;
                    }
                }

                // ensure no trailing "."
                if ( bFormatIsValid )
                {
                    if ( '.' == pszAnsiBuf[cbAnsiBufLen - 1] )
                    {
                        bFormatIsValid = false;
                        rErrorTypeStrID = IDS_OID_CANNOT_END_WITH_DOT;
                    }
                }

                if ( bFormatIsValid )
                {
                    bFormatIsValid = false;
                    CRYPT_ATTRIBUTE cryptAttr;
                    ::ZeroMemory (&cryptAttr, sizeof (CRYPT_ATTRIBUTE));

                    cryptAttr.cValue = 0;
                    cryptAttr.pszObjId = pszAnsiBuf;
                    cryptAttr.rgValue = 0;

                    DWORD   cbEncoded = 0;
                    BOOL bResult = CryptEncodeObject (X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
                            PKCS_ATTRIBUTE,
                            &cryptAttr,
                            NULL,
                            &cbEncoded);
                    if ( cbEncoded > 0 )
                    {
                        BYTE* pBuffer = new BYTE[cbEncoded];
                        if ( pBuffer )
                        {
                            bResult = CryptEncodeObject (X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
                                    PKCS_ATTRIBUTE,
                                    &cryptAttr,
                                    pBuffer,
                                    &cbEncoded);
                            if ( bResult )
                            {   
                                DWORD   cbStructInfo = 0;
                                bResult = CryptDecodeObject (X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
                                        PKCS_ATTRIBUTE,
                                        pBuffer,
                                        cbEncoded,
                                        0,
                                        0,
                                        &cbStructInfo);
                                if ( cbStructInfo > 0 )
                                {
                                    BYTE* pStructBuf = new BYTE[cbStructInfo];
                                    if ( pStructBuf )
                                    {
                                        bResult = CryptDecodeObject (X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
                                                PKCS_ATTRIBUTE,
                                                pBuffer,
                                                cbEncoded,
                                                0,
                                                pStructBuf,
                                                &cbStructInfo);
                                        if ( bResult )
                                        {
                                            CRYPT_ATTRIBUTE* pCryptAttr = (CRYPT_ATTRIBUTE*) pStructBuf;
                                            if ( !strcmp (pszAnsiBuf, pCryptAttr->pszObjId) )
                                            {
                                                bFormatIsValid = true;
                                            }
                                        }
                                        delete [] pStructBuf;
                                    }
                                }
                            }
                            delete [] pBuffer;
                        }
                    }
                }
            }
            else
            {
                DebugTrace(L"WideCharToMultiByte (%s) failed: 0x%x\n", pszOidValue, 
                        GetLastError ());
            }

            delete [] pszAnsiBuf;
        }
    }
    else
    {
        DebugTrace(L"WideCharToMultiByte (%s) failed: 0x%x\n", pszOidValue, 
                GetLastError ());
    }

    return bFormatIsValid;
}

HRESULT
DeleteObject(
    const CString& path,
    Cookie* pcookie,
    PCWSTR pszClass
)
/***

    This deletes an attribute from the schema

***/
{
   HRESULT hr = S_OK;

   do
   {
      if ( !pcookie )
      {
         hr = E_INVALIDARG;
         break;
      }

      CComPtr<IADsPathname> spIADsPathname;

      hr = ::CoCreateInstance( CLSID_Pathname, NULL, CLSCTX_INPROC_SERVER,
                              IID_IADsPathname, (void**)&spIADsPathname);
      if ( FAILED(hr) )
      {
         break;
      }

      hr = spIADsPathname->Set( (PWSTR)(PCWSTR)path, ADS_SETTYPE_FULL );
      if ( FAILED(hr) )
      {
         break;
      }

      // Get the RDN so that we have it for deleting

      CComBSTR sbstrRDN;
      hr = spIADsPathname->Retrieve( ADS_FORMAT_LEAF, &sbstrRDN );
      if ( FAILED(hr) )
      {
         break;
      }

      // Get the path to the parent container

      hr = spIADsPathname->RemoveLeafElement();
      if ( FAILED(hr) )
      {
         break;
      }

      CComBSTR sbstrParentPath;
      hr = spIADsPathname->Retrieve( ADS_FORMAT_X500, &sbstrParentPath );
      if ( FAILED(hr) )
      {
         break;
      }

      // Now open the parent object

      CComPtr<IADsContainer> spContainer;
      hr = ::ADsOpenObject( sbstrParentPath, NULL, NULL, ADS_SECURE_AUTHENTICATION,
                            IID_IADsContainer, (void**)&spContainer);
      if ( FAILED(hr) )
      {
         break;
      }

      hr = spContainer->Delete( (PWSTR)pszClass, sbstrRDN );
      if ( FAILED(hr) )
      {
         break;
      }

   } while (false);

   return hr;
}