#include "stdafx.h"
#include "compdata.h"
#include "cmponent.h"
#include "attrgen.hpp"
#include "resource.h"
#include "dataobj.h"




const TCHAR szUserClass[]               = USER_CLASS_NAME ;

// disable User Copy for the following list of attributes 
const TCHAR * rgszExclClass[]           = { _T("cn"),				_T("displayName"),
                                            _T("sAMAccountName"),	_T("userAccountControl"),
                                            _T("userParameters"),	_T("userPrincipalName"),    
                                            NULL };

//
// The following table is copied from dirsync\ldifds\ldifldap\samrestrict.h
//
// CLASS_USER, SampUserObjectType (ldapdisplayname: user)
//
PCWSTR rgszExclClass2[] = { // user[] = {
    L"memberOf",                // SAMP_USER_GROUPS, ATT_MEMBER
    L"dBCSPwd",                 // SAMP_USER_DBCS_PWD, ATT_DBCS_PWD
    L"ntPwdHistory",            // SAMP_USER_NT_PWD_HISTORY, ATT_NT_PWD_HISTORY
    L"lmPwdHistory",            // SAMP_USER_LM_PWD_HISTORY, ATT_LM_PWD_HISTORY
    L"lastLogon",               // SAMP_FIXED_USER_LAST_LOGON, ATT_LAST_LOGON
    L"lastLogoff",              // SAMP_FIXED_USER_LAST_LOGOFF, ATT_LAST_LOGOFF
    L"badPasswordTime",         // SAMP_FIXED_USER_LAST_BAD_PASSWORD_TIME, 
                                // ATT_BAD_PASSWORD_TIME
    L"rid",                     // SAMP_FIXED_USER_USERID, ATT_RID
    L"badPwdCount",             // SAMP_FIXED_USER_BAD_PWD_COUNT, 
                                // ATT_BAD_PWD_COUNT
    L"logonCount",              // SAMP_FIXED_USER_LOGON_COUNT, ATT_LOGON_COUNT
    L"sAMAccountType",          // SAMP_USER_ACCOUNT_TYPE, ATT_SAM_ACCOUNT_TYPE
    L"supplementalCredentials", // SAMP_FIXED_USER_SUPPLEMENTAL_CREDENTIALS,
                                // ATT_SUPPLEMENTAL_CREDENTIALS
    L"objectSid",               // not in mappings.c, but still required!, 
                                // ATT_OBJECT_SID
    L"pwdLastSet",
    NULL
};



const TCHAR szTopClass[]				= _T("Top");


const CDialogControlsInfo ctrls[] =
{
    { IDC_ATTRIB_GENERAL_DESCRIPTION_EDIT,  g_Description,       TRUE },
    { IDC_ATTRIB_GENERAL_MIN_EDIT,          g_RangeLower,        TRUE }, 
    { IDC_ATTRIB_GENERAL_MAX_EDIT,          g_RangeUpper,        TRUE }, 
    { IDC_ATTRIB_GENERAL_DISPLAYABLE_CHECK, g_ShowInAdvViewOnly, FALSE },
    { IDC_ATTRIB_GENERAL_DEACTIVATE,        g_isDefunct,           FALSE },
    { IDC_ATTRIB_GENERAL_INDEX_CHECK,       g_IndexFlag,         FALSE },
    { IDC_ATTRIB_GENERAL_REPLICATED,        g_GCReplicated,      FALSE },
    { IDC_ATTRIB_GENERAL_CPYATTR_CHECK,     g_IndexFlag,         FALSE },
    { IDC_ATTRIB_GENERAL_ANR_CHECK,         g_IndexFlag,         FALSE },
    { IDC_ATTRIB_GENERAL_CONTAINERIZED_INDEX_CHECK, g_IndexFlag, FALSE},
} ;


const DWORD AttributeGeneralPage::help_map[] =
{
  IDI_ATTRIBUTE,                        NO_HELP,
  IDC_ATTRIB_GENERAL_NAME_STATIC,       NO_HELP,
  IDC_ATTRIB_GENERAL_DESCRIPTION_EDIT,  IDH_ATTRIB_GENERAL_DESCRIPTION_EDIT, 
  IDC_ATTRIB_GENERAL_LDN,               IDH_ATTRIB_GENERAL_LDN,               
  IDC_ATTRIB_GENERAL_OID_EDIT,          IDH_ATTRIB_GENERAL_OID_EDIT,         
  IDC_ATTRIB_GENERAL_VALUE_STATIC,      NO_HELP,
  IDC_ATTRIB_GENERAL_SYNTAX_EDIT,       IDH_ATTRIB_GENERAL_SYNTAX_EDIT,      
  IDC_ATTRIB_GENERAL_MIN_EDIT,          IDH_ATTRIB_GENERAL_MIN_EDIT,         
  IDC_ATTRIB_GENERAL_MAX_EDIT,          IDH_ATTRIB_GENERAL_MAX_EDIT,         
  IDC_ATTRIB_GENERAL_DISPLAYABLE_CHECK, IDH_ATTRIB_GENERAL_DISPLAYABLE_CHECK,
  IDC_ATTRIB_GENERAL_DEACTIVATE,        IDH_ATTRIB_DEACTIVATE,               
  IDC_ATTRIB_GENERAL_INDEX_CHECK,       IDH_ATTRIB_GENERAL_INDEX_CHECK,   
  IDC_ATTRIB_GENERAL_CONTAINERIZED_INDEX_CHECK, IDH_ATTRIB_GENERAL_CONTAINERIZED_INDEX_CHECK,
  IDC_ATTRIB_GENERAL_ANR_CHECK,         IDH_ATTRIB_GENERAL_ANR_CHECK,
  IDC_ATTRIB_GENERAL_REPLICATED,        IDH_REPLICATED,                      
  IDC_ATTRIB_GENERAL_CPYATTR_CHECK,     IDH_ATTRIB_GENERAL_CPYATTR_CHECK,
  IDC_ATTRIB_GENERAL_SYSCLASS_STATIC,   NO_HELP,
  0,                                    0                                    
};



// returns state of bit n

inline
bool
getbit(const DWORD& bits, int n)
{
   return (bits & (1 << n)) ? true : false;
}


// sets bit n to 1

inline
void
setbit(DWORD& bits, int n)
{
   bits |= (1 << n);
}



// sets bit n to 0

inline
void
clearbit(DWORD& bits, int n)
{
   bits &= ~(1 << n);
}



//
// Attribute property sheet routines.
//



BEGIN_MESSAGE_MAP( AttributeGeneralPage, CDialog )
   ON_MESSAGE(WM_HELP, OnHelp)
   ON_MESSAGE(WM_CONTEXTMENU, OnContextHelp)
   ON_BN_CLICKED(IDC_ATTRIB_GENERAL_INDEX_CHECK, OnIndexClick)
   ON_BN_CLICKED(IDC_ATTRIB_GENERAL_DEACTIVATE, OnDeactivateClick)
END_MESSAGE_MAP()



AttributeGeneralPage::AttributeGeneralPage(
   Component*  pResultControl,
   LPDATAOBJECT         lpDataObject)
   :
   CPropertyPage( IDD_ATTRIB_GENERAL ),
   pCookie( NULL ),
   pIADsObject( NULL ),
   pObject( NULL),
   lpResultDataObject( lpDataObject ),
   pComponent( pResultControl ),
   fDataLoaded( FALSE ),
   Displayable( TRUE ),
   DDXDisplayable( TRUE ),
   search_flags(0),
   DDXIndexed( FALSE ),
   DDXANR( FALSE ),
   DDXCopyOnDuplicate( FALSE ),
   Defunct( FALSE ),
   DDXDefunct( FALSE ),
   ReplicatedToGC( FALSE ),
   DDXReplicatedToGC( FALSE ),
   DDXContainerIndexed( FALSE ),   
   m_editLowerRange( CParsedEdit::EDIT_TYPE_UINT32 ),
   m_editUpperRange( CParsedEdit::EDIT_TYPE_UINT32 )
{
}



BOOL
AttributeGeneralPage::OnSetActive()
{
      // If pIADsObject is NULL, close dialog box
   if( CPropertyPage::OnSetActive() )
   {
      if ( !pIADsObject )
      {
         return FALSE;
      }
      else
      {
         // always enable the Apply button 
         SetModified(TRUE);

         return TRUE;
      }
   }
   else
      return FALSE;
}


AttributeGeneralPage::~AttributeGeneralPage(
)
{

    ComponentData& Scope = pComponent->QueryComponentDataRef();

    //
    // Always make sure we free the IADs object.
    //

    if ( pIADsObject ) {
        pIADsObject->Release();
        pIADsObject = NULL;
    }

    //
    // And release the cache.
    //

    if ( pObject ) {
        Scope.g_SchemaCache.ReleaseRef( pObject );
    }
}



BOOL
AttributeGeneralPage::OnInitDialog()
{
    CPropertyPage::OnInitDialog();

    ASSERT( GetDlgItem(IDC_ATTRIB_GENERAL_DESCRIPTION_EDIT) );

    ( static_cast<CEdit *>( GetDlgItem(IDC_ATTRIB_GENERAL_DESCRIPTION_EDIT) ) )
        -> LimitText( 1024 ) ;

    m_editLowerRange.SubclassEdit(IDC_ATTRIB_GENERAL_MIN_EDIT, this, cchMinMaxRange);
    m_editUpperRange.SubclassEdit(IDC_ATTRIB_GENERAL_MAX_EDIT, this, cchMinMaxRange);

    return TRUE;
}



void
AttributeGeneralPage::Load(
    Cookie& CookieRef
) {

    //
    // Store the cookie object pointer.  Everything
    // else gets loaded when the page is displayed.
    //

    pCookie = &CookieRef;
    return;
}



BOOL
AttributeGeneralPage::OnApply(
    VOID
) {

    HRESULT hr;

    VARIANT AdsValue;
    BOOL fChangesMade = FALSE;
    BOOL fRangeChange = FALSE;
    BOOL fApplyAbort  = FALSE;  // stop later saves
    BOOL fApplyFailed = FALSE;  // should not close the box

    DWORD dwRange;
    
    // Enable hourglass
    CWaitCursor wait;
   
    //
    // We have to flush the IADS property cache if we
    // have a failure so later operations won't fail because
    // of a bad cached attribute.
    //

    IADsPropertyList *pPropertyList;

    hr = pIADsObject->QueryInterface( IID_IADsPropertyList,
                                      reinterpret_cast<void**>(&pPropertyList) );
    if ( FAILED( hr ) ) {
        pPropertyList = NULL;
        fApplyAbort   = TRUE;
    }

    //
    // Check to see if something we cared about changed.
    // We care about Description, Min, Max, Indexed,
    // Defunct, ReplicatedToGC, and Displayable.
    //

    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
    VariantInit( &AdsValue );

    //
    // Defunct -- in case it was deactivated, activate the object first
    //
    if( !fApplyAbort && !DDXDefunct && DDXDefunct != Defunct )
    {
        hr = ChangeDefunctState( DDXDefunct, Defunct, pPropertyList, fApplyAbort, fApplyFailed );
    }

    
    //
    // Description
    //

    if ( !fApplyAbort && DDXDescription != Description ) {

        V_VT(&AdsValue) = VT_BSTR;
        V_BSTR(&AdsValue) = const_cast<BSTR>((LPCTSTR)DDXDescription);

        if ( DDXDescription.IsEmpty() ) {

            hr = pIADsObject->PutEx( ADS_PROPERTY_CLEAR,
                                     const_cast<BSTR>((LPCTSTR)g_Description),
                                     AdsValue );

        } else {

            hr = pIADsObject->Put( const_cast<BSTR>((LPCTSTR)g_Description),
                                   AdsValue );
        }

        ASSERT( SUCCEEDED( hr ) );

        hr = pIADsObject->SetInfo();

        if ( SUCCEEDED( hr ) ) {

            pObject->description = DDXDescription;
            fChangesMade = TRUE;
			Description = DDXDescription;

        } else {

            pPropertyList->PurgePropertyList();
            if( ERROR_DS_UNWILLING_TO_PERFORM == HRESULT_CODE(hr) )
            {
                fApplyFailed = TRUE;
                DoErrMsgBox( ::GetActiveWindow(), TRUE, IDS_ERR_EDIT_DESC );
            }
            else
            {
                fApplyAbort = TRUE; 
                DoErrMsgBox( ::GetActiveWindow(), TRUE, GetErrorMessage(hr,TRUE) );
            }

        }

        VariantInit( &AdsValue );
    }

    //
    // Displayable
    //

    if ( !fApplyAbort && DDXDisplayable != Displayable ) {

        V_VT(&AdsValue) = VT_BOOL;

        if ( DDXDisplayable ) {
            V_BOOL(&AdsValue) = 0;
        } else {
            V_BOOL(&AdsValue) = -1;
        }

        hr = pIADsObject->Put(g_ShowInAdvViewOnly, AdsValue);
        ASSERT( SUCCEEDED( hr ) );

        hr = pIADsObject->SetInfo();

        if ( FAILED( hr ) ) {
            pPropertyList->PurgePropertyList();

            if( ERROR_DS_UNWILLING_TO_PERFORM == HRESULT_CODE(hr) )
            {
                fApplyFailed = TRUE;
                DoErrMsgBox( ::GetActiveWindow(), TRUE, IDS_ERR_EDIT_DISPLAYABLE );
            }
            else
            {
                fApplyAbort = TRUE; 
                DoErrMsgBox( ::GetActiveWindow(), TRUE, GetErrorMessage(hr,TRUE) );
            }
        }
		else
		{
			Displayable = DDXDisplayable;
		}

        VariantInit( &AdsValue );
    }

    //
    // ReplicatedToGC
    //

    if ( !fApplyAbort && DDXReplicatedToGC != ReplicatedToGC ) {

        V_VT(&AdsValue) = VT_BOOL;

        if ( DDXReplicatedToGC ) {
            V_BOOL(&AdsValue) = -1;
        } else {
            V_BOOL(&AdsValue) = 0;
        }

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

        hr = pIADsObject->SetInfo();

        if ( FAILED( hr ) ) {
            pPropertyList->PurgePropertyList();
            if( ERROR_DS_UNWILLING_TO_PERFORM == HRESULT_CODE(hr) )
            {
                fApplyFailed = TRUE;
                DoErrMsgBox( ::GetActiveWindow(), TRUE, IDS_ERR_EDIT_GC );
            }
            else
            {
                fApplyAbort = TRUE; 
                DoErrMsgBox( ::GetActiveWindow(), TRUE, GetErrorMessage(hr,TRUE) );
            }
        }
		else
		{
			ReplicatedToGC = DDXReplicatedToGC;
		}

        VariantInit( &AdsValue );
    }

    //
    // Indexed
    //

   // make sure ANR is not set when Indexed is unchecked
   if( !DDXIndexed )
	   DDXANR = FALSE;

   if( !fApplyAbort && 
       (getbit(search_flags, INDEX_BIT_ATTINDEX) != (DDXIndexed ? 1 : 0)
      || getbit(search_flags, INDEX_BIT_ANR) != (DDXANR ? 1 : 0)
      || getbit(search_flags, INDEX_BIT_COPYONDUPLICATE) != (DDXCopyOnDuplicate ? 1 : 0)
      || getbit(search_flags, INDEX_BIT_PDNTATTINDEX) != (DDXContainerIndexed ? 1 : 0)) )
   {
      DWORD DDXsearch_flags = search_flags;

      V_VT(&AdsValue) = VT_I4;

      if (DDXIndexed)
         setbit(DDXsearch_flags, INDEX_BIT_ATTINDEX);
      else
         clearbit(DDXsearch_flags, INDEX_BIT_ATTINDEX);

      ASSERT( DDXIndexed || !DDXANR );
      if (DDXANR)
         setbit(DDXsearch_flags, INDEX_BIT_ANR);
      else
         clearbit(DDXsearch_flags, INDEX_BIT_ANR);

      if (DDXCopyOnDuplicate)
         setbit(DDXsearch_flags, INDEX_BIT_COPYONDUPLICATE);
      else
         clearbit(DDXsearch_flags, INDEX_BIT_COPYONDUPLICATE);

      if (DDXContainerIndexed)
        setbit(DDXsearch_flags, INDEX_BIT_PDNTATTINDEX);
      else
        clearbit(DDXsearch_flags, INDEX_BIT_PDNTATTINDEX);

      V_I4(&AdsValue) = DDXsearch_flags;
      hr = pIADsObject->Put( const_cast<BSTR>((LPCTSTR)g_IndexFlag),
                            AdsValue );
      ASSERT( SUCCEEDED( hr ) );

      hr = pIADsObject->SetInfo();

      if ( FAILED( hr ) ) {
         pPropertyList->PurgePropertyList();
         if( ERROR_DS_UNWILLING_TO_PERFORM == HRESULT_CODE(hr) )
         {
             fApplyFailed = TRUE;
             DoErrMsgBox( ::GetActiveWindow(), TRUE, IDS_ERR_EDIT_INDEXED );
         }
         else
         {
             fApplyAbort = TRUE; 
             DoErrMsgBox( ::GetActiveWindow(), TRUE, GetErrorMessage(hr,TRUE) );
         }
      }
      else
      {
          search_flags = DDXsearch_flags;
      }

      VariantInit( &AdsValue );
   }

    //
    // RangeUpper and RangeLower
    // These have to be set together so the server
    // range validation works correctly.
    //

    if ( !fApplyAbort && RangeUpper != DDXRangeUpper ) {

        if ( DDXRangeUpper.IsEmpty() ) {

            //
            // Clear the value.
            //

            hr = pIADsObject->PutEx( ADS_PROPERTY_CLEAR,
                                     const_cast<BSTR>((LPCTSTR)g_RangeUpper),
                                     AdsValue );
            ASSERT( SUCCEEDED( hr ) );

        } else {

            //
            // Store the new value.
            //
	        ASSERT(pObject);

			hr = GetSafeSignedDWORDFromString( this, dwRange, DDXRangeUpper,
					g_Syntax[ pObject->SyntaxOrdinal ].m_fIsSigned );

			ASSERT( S_OK == hr );	// validation should have taken care of min/max stuff

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

            hr = pIADsObject->Put( const_cast<BSTR>((LPCTSTR)g_RangeUpper),
                                   AdsValue );
            ASSERT( SUCCEEDED( hr ) );
        }

		fRangeChange = TRUE;
        VariantInit( &AdsValue );
    }

    if ( !fApplyAbort && RangeLower != DDXRangeLower ) {

        if ( DDXRangeLower.IsEmpty() ) {

            //
            // Clear the value.
            //

            hr = pIADsObject->PutEx( ADS_PROPERTY_CLEAR,
                                     const_cast<BSTR>((LPCTSTR)g_RangeLower),
                                     AdsValue );
            ASSERT( SUCCEEDED( hr ) );

        } else {

            //
            // Store the new value.
            //

	        ASSERT(pObject);

			hr = GetSafeSignedDWORDFromString( this, dwRange, DDXRangeLower,
					g_Syntax[ pObject->SyntaxOrdinal ].m_fIsSigned );

			ASSERT( S_OK == hr );	// validation should have taken care of min/max stuff

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

            hr = pIADsObject->Put( const_cast<BSTR>((LPCTSTR)g_RangeLower),
                                   AdsValue );
            ASSERT( SUCCEEDED( hr ) );
        }

        fRangeChange = TRUE;
        VariantInit( &AdsValue );
    }

    //
    // Actually commit the changes.
    //

    if ( !fApplyAbort && fRangeChange ) {

        hr = pIADsObject->SetInfo();

        if ( FAILED( hr ) ) {
            pPropertyList->PurgePropertyList();
            if( ERROR_DS_UNWILLING_TO_PERFORM == HRESULT_CODE(hr) )
            {
                fApplyFailed = TRUE;
                DoErrMsgBox( ::GetActiveWindow(), TRUE, IDS_ERR_CREATE_MINMAX );
            }
            else
            {
                fApplyAbort = TRUE; 
                DoErrMsgBox( ::GetActiveWindow(), TRUE, GetErrorMessage(hr,TRUE) );
            }
        }
        else
        {
            RangeLower = DDXRangeLower;
            RangeUpper = DDXRangeUpper;
        }
    }


    //
    // Defunct -- in case it was active, deactivate the object after we are done update
    //
    if( !fApplyAbort && DDXDefunct && DDXDefunct != Defunct )
    {
        hr = ChangeDefunctState( DDXDefunct, Defunct, pPropertyList, fApplyAbort, fApplyFailed );
    }

    
    //
    // If there are visible changes, update the views.
    //

    if ( ( fChangesMade ) &&
         ( pComponent )     &&
         ( lpResultDataObject ) ) {

        CCookie* pBaseCookie;
        Cookie* pCookie;

        hr = ExtractData( lpResultDataObject,
                          CSchmMgmtDataObject::m_CFRawCookie,
                          OUT reinterpret_cast<PBYTE>(&pBaseCookie),
                          sizeof(pBaseCookie) );
        ASSERT( SUCCEEDED(hr) );

        pCookie = pComponent->ActiveCookie(pBaseCookie);
        ASSERT( NULL != pCookie );

        hr = pComponent->m_pResultData->UpdateItem( pCookie->hResultId );
        ASSERT( SUCCEEDED(hr) );
    }

    if ( pPropertyList ) {
        pPropertyList->Release();
    }

    return !fApplyAbort && !fApplyFailed ;      // return TRUE if nothing happened
}



void
AttributeGeneralPage::DoDataExchange(
    CDataExchange *pDX
) {

    HRESULT	hr;
    CString	szAdsPath;
    VARIANT	AdsResult;
    UINT	SyntaxOrdinal		= SCHEMA_SYNTAX_UNKNOWN;

    ComponentData& Scope = pComponent->QueryComponentDataRef();

    AFX_MANAGE_STATE(AfxGetStaticModuleState( ));

    // Enable hourglass
    CWaitCursor wait;
    
    CPropertyPage::DoDataExchange( pDX );

    VariantInit( &AdsResult );

    // We still want to do the DDX exchange at the bottom
    // even if the data is already loaded so make it part
    // of this if statement instead of short circuiting 
    // from within

    if ( !pDX->m_bSaveAndValidate &&
         !fDataLoaded) {

        //
        // Get the schema cache object and the actual ADS object.
        // Keep the ADS object around while the page is loaded.
        //

        ASSERT( !pObject );		// Must be NULL initially

        pObject = Scope.g_SchemaCache.LookupSchemaObjectByCN(
                      pCookie->strSchemaObject,
                      SCHMMGMT_ATTRIBUTE );

        if ( pObject ) {

          Scope.GetSchemaObjectPath( pObject->commonName, szAdsPath );

          if ( !szAdsPath.IsEmpty() ) {

              hr = ADsGetObject( (LPWSTR)(LPCWSTR)szAdsPath,
                                 IID_IADs,
                                 (void **)&pIADsObject );

              if( SUCCEEDED(hr) )
			  {
			      BOOL fIsConstructed = FALSE;

			      // Igrnore error code
			      IsConstructedObject( pIADsObject, fIsConstructed );
			      
				  // Enable check box if ths attribute is not in the excluded
				  // list and available for the User Class
				  GetDlgItem(IDC_ATTRIB_GENERAL_CPYATTR_CHECK)->EnableWindow(
								!fIsConstructed &&
								!IsInList( rgszExclClass, pObject->ldapDisplayName )  &&
								!IsInList( rgszExclClass2, pObject->ldapDisplayName )  &&
								IsAttributeInUserClass( pObject->ldapDisplayName ) );
			  }
          }
        }

        //
        // If we have no ADS object, we should error out!
        //

        if ( !pIADsObject )
        {
          DoErrMsgBox( ::GetActiveWindow(), TRUE, IDS_ERR_NO_SCHEMA_OBJECT );

          // Because there is no pIADsObject, OnSetActive() will close dialog box

          return;
        }

        //
        // ObjectName - Use the ldapDisplayName to be consistent
        // with the other admin components.
        //

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_DisplayName),
                              &AdsResult );

        if ( SUCCEEDED( hr ) ) {

          ASSERT( AdsResult.vt == VT_BSTR );
          ObjectName = AdsResult.bstrVal;
          VariantClear( &AdsResult );
        }

        //
        // Description
        //

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_Description),
                              &AdsResult );

        if ( SUCCEEDED( hr ) ) {

          ASSERT( AdsResult.vt == VT_BSTR );
          Description = AdsResult.bstrVal;
          DDXDescription = AdsResult.bstrVal;
          VariantClear( &AdsResult );
        }

        //
        // CommonName
        //

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_CN),
                              &AdsResult );

        if ( SUCCEEDED( hr ) ) {

          ASSERT( AdsResult.vt == VT_BSTR );
          DisplayName = AdsResult.bstrVal;
          VariantClear( &AdsResult );
        }

        //
        // SysClass
        //

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_SystemOnly),
                              &AdsResult );

        if ( SUCCEEDED( hr ) ) {

          ASSERT( AdsResult.vt == VT_BOOL );

          if ( AdsResult.boolVal ) {
              SysClassString = g_SysAttrString;
          } else {
              SysClassString = L"";
          }

          VariantClear( &AdsResult );

        } else {

           SysClassString = L"";
        }

        //
        // Syntax
        //
		// No need to reload from schema -- syntax never changes
		//
        ASSERT(pObject);
        if( pObject )
            SyntaxOrdinal = pObject->SyntaxOrdinal;
        
        SyntaxString = g_Syntax[ SyntaxOrdinal ].m_strSyntaxName;


        //
        // Syntax min and max values.
        //

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_RangeLower),
                               &AdsResult );

        if ( SUCCEEDED( hr ) ) {

            ASSERT( V_VT( &AdsResult ) == VT_I4 );

            RangeLower.Format( g_Syntax[ SyntaxOrdinal ].m_fIsSigned ?
									g_INT32_FORMAT : g_UINT32_FORMAT,
                               V_I4( &AdsResult ) );

			ASSERT( RangeLower.GetLength() <= cchMinMaxRange );
            DDXRangeLower = RangeLower;

            VariantClear( &AdsResult );
        }

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_RangeUpper),
                               &AdsResult );

        if ( SUCCEEDED( hr ) ) {

            ASSERT( V_VT( &AdsResult ) == VT_I4 );

            RangeUpper.Format( g_Syntax[ SyntaxOrdinal ].m_fIsSigned ?
									g_INT32_FORMAT : g_UINT32_FORMAT,
                               V_I4( &AdsResult ) );

			ASSERT( RangeUpper.GetLength() <= cchMinMaxRange );
            DDXRangeUpper = RangeUpper;

            VariantClear( &AdsResult );
        }

        //
        // Multi-Valued
        //


        MultiValued.LoadString( IDS_ATTRIBUTE_MULTI );

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_IsSingleValued),
                               &AdsResult );

        if ( SUCCEEDED( hr ) ) {

           ASSERT( AdsResult.vt == VT_BOOL );

           if ( AdsResult.boolVal == -1 ) {
               MultiValued.Empty();
               MultiValued.LoadString( IDS_ATTRIBUTE_SINGLE );
           }

           VariantClear( &AdsResult );

        }

        //
        // Displayable
        //

        hr = pIADsObject->Get(g_ShowInAdvViewOnly, &AdsResult);

        if ( SUCCEEDED( hr ) ) {

           ASSERT( AdsResult.vt == VT_BOOL );

           if ( AdsResult.boolVal == -1 ) {
               Displayable = FALSE;
               DDXDisplayable = FALSE;
           }

           VariantClear( &AdsResult );

        }

        //
        // Defunct
        //

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_isDefunct),
                               &AdsResult );

        if ( SUCCEEDED( hr ) ) {

           ASSERT( AdsResult.vt == VT_BOOL );

           if ( AdsResult.boolVal == -1 ) {
               Defunct = TRUE;
               DDXDefunct = TRUE;
           }

           VariantClear( &AdsResult );

        }

        //
        // ReplicatedToGC
        //

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_GCReplicated),
                               &AdsResult );

        if ( SUCCEEDED( hr ) ) {

           ASSERT( AdsResult.vt == VT_BOOL );

           if ( AdsResult.boolVal == -1 ) {
               ReplicatedToGC = TRUE;
               DDXReplicatedToGC = TRUE;
           }

           VariantClear( &AdsResult );

        }

        //
        // OID
        //

        hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_GlobalAttributeID),
                               &AdsResult );

        if ( SUCCEEDED( hr ) ) {

           ASSERT( AdsResult.vt == VT_BSTR );
           OidString = AdsResult.bstrVal;
           VariantClear( &AdsResult );
        }

        //
        // Indexed, ANR, & Copy on duplicate
        //

      hr = pIADsObject->Get( const_cast<BSTR>((LPCTSTR)g_IndexFlag),
                            &AdsResult );

      if (SUCCEEDED(hr))
      {
         ASSERT(AdsResult.vt == VT_I4);

         search_flags = V_I4(&AdsResult);
         
		 // Index this attribute in the Active Directory
		 DDXIndexed = getbit( search_flags, INDEX_BIT_ATTINDEX );
		 
		 // Ambiguous Name Resolution (ANR)
		 // checkbox must exist
		 ASSERT( GetDlgItem(IDC_ATTRIB_GENERAL_ANR_CHECK) );

		 // if not indexed, or not allowed, disable the checkbox
		 GetDlgItem(IDC_ATTRIB_GENERAL_ANR_CHECK)->EnableWindow(
					g_Syntax[ SyntaxOrdinal ].m_fIsANRCapable ? DDXIndexed : FALSE );

		 if( DDXIndexed )
			 DDXANR = getbit( search_flags, INDEX_BIT_ANR );
		 else
		 {
			 DDXANR = FALSE;

			 // if not indexed, ANR in DS should not be set
			 ASSERT( !getbit( search_flags, INDEX_BIT_ANR ) );
		 }

		 // Attribute is copied when duplicating a user
		 DDXCopyOnDuplicate = getbit( search_flags, INDEX_BIT_COPYONDUPLICATE );

         VariantClear( &AdsResult );
      }

      // Containerized index
      DDXContainerIndexed = getbit( search_flags, INDEX_BIT_PDNTATTINDEX );

      // Determine if this is a category 1 object & disable read-only fields
      BOOL  fIsSystemObject = FALSE;

      hr = IsCategory1Object( pIADsObject, fIsSystemObject );
      if( SUCCEEDED(hr) && fIsSystemObject )
      {
         ASSERT( GetDlgItem(IDC_ATTRIB_GENERAL_MIN_EDIT) );
         ASSERT( GetDlgItem(IDC_ATTRIB_GENERAL_MAX_EDIT) );
         ASSERT( GetDlgItem(IDC_ATTRIB_GENERAL_DEACTIVATE) );
         
         reinterpret_cast<CEdit *>( GetDlgItem(IDC_ATTRIB_GENERAL_MIN_EDIT) )->SetReadOnly();
         reinterpret_cast<CEdit *>( GetDlgItem(IDC_ATTRIB_GENERAL_MAX_EDIT) )->SetReadOnly();
         GetDlgItem(IDC_ATTRIB_GENERAL_DEACTIVATE)->EnableWindow( FALSE );
      }

      hr = DissableReadOnlyAttributes( this, pIADsObject, ctrls, sizeof(ctrls)/sizeof(ctrls[0]) );
      ASSERT( SUCCEEDED(hr) );     // shouldn't fail, but unimportant, so ignore error


      // warn the user if this is a read/write defunct object
      ASSERT( GetDlgItem(IDC_ATTRIB_GENERAL_DEACTIVATE) );
      
      if( DDXDefunct &&
          GetDlgItem(IDC_ATTRIB_GENERAL_DEACTIVATE)->IsWindowEnabled() )
      {
          AfxMessageBox( IDS_WARNING_DEFUNCT, MB_OK | MB_ICONINFORMATION );
      }


      //
      // Remember that the data is loaded.
      //

      fDataLoaded = TRUE;

      m_editLowerRange.SetSigned( g_Syntax[ SyntaxOrdinal ].m_fIsSigned );
      m_editUpperRange.SetSigned( g_Syntax[ SyntaxOrdinal ].m_fIsSigned );
    }


    //
    // Set up the dialog data exchange.
    //

    DDX_Text( pDX, IDC_ATTRIB_GENERAL_NAME_STATIC, ObjectName );
    DDX_Text( pDX, IDC_ATTRIB_GENERAL_SYSCLASS_STATIC, SysClassString );
    DDX_Text( pDX, IDC_ATTRIB_GENERAL_SYNTAX_EDIT, SyntaxString );
    DDX_Text( pDX, IDC_ATTRIB_GENERAL_OID_EDIT, OidString );
    DDX_Text( pDX, IDC_ATTRIB_GENERAL_VALUE_STATIC, MultiValued );
    DDX_Text( pDX, IDC_ATTRIB_GENERAL_LDN, DisplayName );
	DDX_Text( pDX, IDC_ATTRIB_GENERAL_DESCRIPTION_EDIT, DDXDescription );

    DDXV_VerifyAttribRange( pDX, g_Syntax[ pObject->SyntaxOrdinal ].m_fIsSigned,
							IDC_ATTRIB_GENERAL_MIN_EDIT, DDXRangeLower,
							IDC_ATTRIB_GENERAL_MAX_EDIT, DDXRangeUpper );
		
    DDX_Check( pDX, IDC_ATTRIB_GENERAL_DISPLAYABLE_CHECK, DDXDisplayable );
    DDX_Check( pDX, IDC_ATTRIB_GENERAL_INDEX_CHECK, DDXIndexed );
    DDX_Check( pDX, IDC_ATTRIB_GENERAL_ANR_CHECK, DDXANR );
    DDX_Check( pDX, IDC_ATTRIB_GENERAL_CPYATTR_CHECK, DDXCopyOnDuplicate );
    DDX_Check( pDX, IDC_ATTRIB_GENERAL_REPLICATED, DDXReplicatedToGC );
    DDX_Check( pDX, IDC_ATTRIB_GENERAL_CONTAINERIZED_INDEX_CHECK, DDXContainerIndexed );

    // Since we want the checkbox label to be positive
    // the value is actually the opposite of defunct

    int checkValue = !Defunct;
    DDX_Check( pDX, IDC_ATTRIB_GENERAL_DEACTIVATE, checkValue );
    DDXDefunct = !checkValue;

    return;
}


void
AttributeGeneralPage::OnIndexClick()
{
	ASSERT( pObject );
	if( pObject && g_Syntax[ pObject->SyntaxOrdinal ].m_fIsANRCapable )
	{
		GetDlgItem(IDC_ATTRIB_GENERAL_ANR_CHECK)->
			EnableWindow(  IsDlgButtonChecked(IDC_ATTRIB_GENERAL_INDEX_CHECK)  );
	}
}


void
AttributeGeneralPage::OnDeactivateClick()
{
	if( !IsDlgButtonChecked(IDC_ATTRIB_GENERAL_DEACTIVATE) )
    {
        if( IDOK != AfxMessageBox( IDS_WARNING_DEFUNCT_SET, MB_OKCANCEL | MB_ICONWARNING ) )
        {
            CheckDlgButton( IDC_ATTRIB_GENERAL_DEACTIVATE, BST_UNCHECKED );
        }
	}
}


//  Search User class & aux classes for the specified attribute
BOOL
AttributeGeneralPage::IsAttributeInUserClass( const CString & strAttribDN )
{
    BOOL            fFound  = FALSE;
    ComponentData & Scope   = pComponent->QueryComponentDataRef();

    SchemaObject  * pObject = Scope.g_SchemaCache.LookupSchemaObject(
                                CString( szUserClass ),
                                SCHMMGMT_CLASS );
    //
    // Call the attribute check routine.  This routine
    // will call itself recursively to search the
    // inheritance structure of the class User.
    //
    if ( pObject ) {

		fFound = RecursiveIsAttributeInUserClass( strAttribDN, pObject );
        Scope.g_SchemaCache.ReleaseRef( pObject );
    }

    return fFound ;
}


//    Search the user class & subclasses
BOOL
AttributeGeneralPage::RecursiveIsAttributeInUserClass(
   const CString &  strAttribDN,
   SchemaObject *   pObject )
{
    BOOL     fFound  = FALSE;
    
    //
    // Don't process "top" here since everyone inherits from it.
    //
    
    // i don't think we ever get "top" here?
    ASSERT( pObject->ldapDisplayName.CompareNoCase( szTopClass ) );

    if ( !pObject->ldapDisplayName.CompareNoCase(szTopClass) )
        return fFound;

    DebugTrace( L"RecursiveIsAttributeInUserClass: %ls\n",
                const_cast<LPWSTR>((LPCTSTR)pObject->ldapDisplayName) );

    // Check every list
    if( !SearchResultList( strAttribDN, pObject->systemMayContain)  &&
        !SearchResultList( strAttribDN, pObject->mayContain)        &&
        !SearchResultList( strAttribDN, pObject->systemMustContain) &&
        !SearchResultList( strAttribDN, pObject->mustContain) )
    {
        //
        //  The attribute was not found in the given class, diging deeper...
        //  Check each auxiliary class...
        //

        fFound = TraverseAuxiliaryClassList( strAttribDN,
                                             pObject->systemAuxiliaryClass );

        if( !fFound )
        {
            fFound = TraverseAuxiliaryClassList( strAttribDN,
                                                 pObject->auxiliaryClass );
        }
    }
    else
    {
        fFound = TRUE;
    }

    return fFound ;
}


// Linear search of the linked list for the string strAttribDN

BOOL
AttributeGeneralPage::SearchResultList(
    const CString   & strAttribDN,
    ListEntry       * pList )
{
    // Traverse the list
    while ( pList )
    {
        // Searching for the existance of the attribute
        if( !pList->Attribute.CompareNoCase( strAttribDN ) )
            return TRUE;

        pList = pList->pNext;
	}

    return FALSE;
}


// Traverse each auxiliary class by recursivly
// calling RecursiveIsAttributeInUserClass()
BOOL
AttributeGeneralPage::TraverseAuxiliaryClassList(
                const CString   & strAttribDN,
                ListEntry       * pList )
{
    SchemaObject  * pInheritFrom    = NULL;
    ComponentData & Scope           = pComponent->QueryComponentDataRef();
    BOOL            fFound          = FALSE;

    while ( !fFound && pList ) {

        pInheritFrom = Scope.g_SchemaCache.LookupSchemaObject( pList->Attribute,
                                                               SCHMMGMT_CLASS );
        if ( pInheritFrom )
        {
            // recursive call
            fFound = RecursiveIsAttributeInUserClass( strAttribDN, pInheritFrom );

            Scope.g_SchemaCache.ReleaseRef( pInheritFrom );
        }

        pList = pList->pNext;
    }

    return fFound ;
}


HRESULT
AttributeGeneralPage::ChangeDefunctState( BOOL               DDXDefunct,
                                          BOOL             & Defunct,
                                          IADsPropertyList * pPropertyList,
                                          BOOL             & fApplyAbort,
                                          BOOL             & fApplyFailed )
{
    ASSERT( !fApplyAbort && DDXDefunct != Defunct );

    VARIANT AdsValue;
    HRESULT hr = S_OK;
    
    VariantInit( &AdsValue );
    V_VT(&AdsValue) = VT_BOOL;

    if ( DDXDefunct ) {
        V_BOOL(&AdsValue) = -1;
    } else {
        V_BOOL(&AdsValue) = 0;
    }

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

    hr = pIADsObject->SetInfo();

    if ( FAILED( hr ) ) {

        pPropertyList->PurgePropertyList();

        if( ERROR_DS_UNWILLING_TO_PERFORM == HRESULT_CODE(hr) )
        {
            fApplyFailed = TRUE;
            DoErrMsgBox( ::GetActiveWindow(),
                         TRUE,
                         DDXDefunct ? IDS_ERR_EDIT_DEFUNCT_SET : IDS_ERR_EDIT_DEFUNCT_REMOVE );
        }
        else
        {
            fApplyAbort = TRUE; 
            DoErrMsgBox( ::GetActiveWindow(), TRUE, GetErrorMessage(hr,TRUE) );
        }

    } else {

        pObject->isDefunct = DDXDefunct;
		Defunct = DDXDefunct;
    }

    return hr;
}