windows-xp/Source/XPSP1/NT/ds/adsi/ldap/cschema.cxx

//---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1996
//
//  File:  cschema.cxx
//
//  Contents:  LDAP
//
//
//  History:   09-01-96     yihsins    Created.
//
//----------------------------------------------------------------------------
#include "ldap.hxx"
#pragma hdrstop

#define NT_SCHEMA_CLASS_NAME     TEXT("classSchema")
#define NT_SCHEMA_PROPERTY_NAME  TEXT("attributeSchema")
#define BEGIN_FILTER TEXT("(& (lDAPDisplayName=")
#define END_FILTER TEXT(") (! (isdefunct=TRUE)))")

struct _syntaxmapping
{
    LPTSTR pszSyntax;
    LPTSTR pszOID;
    DWORD  dwOMSyntax;
} aSyntaxMap[] =
{
    { TEXT("Boolean"), TEXT("2.5.5.8"), 1 },
    { TEXT("Integer"), TEXT("2.5.5.9"), 2 },
    { TEXT("OctetString"), TEXT("2.5.5.10"), 4 },

    // The following are in ADS only
    { TEXT("Counter"), TEXT("2.5.5.9"), 2 },
    { TEXT("ADsPath"), TEXT("2.5.5.12"), 64 },
    { TEXT("EmailAddress"), TEXT("2.5.5.12"), 64 },
    { TEXT("FaxNumber"), TEXT("2.5.5.12"), 64 },
    { TEXT("Interval"), TEXT("2.5.5.9"), 2 },
    { TEXT("List"), TEXT("2.5.5.10"), 4 },
    { TEXT("NetAddress"), TEXT("2.5.5.12"), 64 },
    { TEXT("Path"), TEXT("2.5.5.12"), 64 },
    { TEXT("PhoneNumber"), TEXT("2.5.5.12"), 64 },
    { TEXT("PostalAddress"), TEXT("2.5.5.12"), 64 },
    { TEXT("SmallInterval"), TEXT("2.5.5.9"), 2 },
    { TEXT("String"), TEXT("2.5.5.12"), 64 },
    { TEXT("Time"), TEXT("2.5.5.11"), 23 },

    // The following are in NTDS only
    { TEXT("INTEGER8"), TEXT("2.5.5.16"), 65 },
    { TEXT("UTCTime"), TEXT("2.5.5.11"), 23 },
    { TEXT("DN"), TEXT("2.5.5.1"), 127 },
    { TEXT("OID"), TEXT("2.5.5.2"), 6 },
    { TEXT("DirectoryString"), TEXT("2.5.5.12"), 64 },
    { TEXT("PrintableString"), TEXT("2.5.5.5"), 19 },
    { TEXT("CaseIgnoreString"), TEXT("2.5.5.4"), 20 },
    { TEXT("NumericString"), TEXT("2.5.5.6"), 18 },
    { TEXT("IA5String"), TEXT("2.5.5.5"), 22 },
    { TEXT("PresentationAddresses"), TEXT("2.5.5.13"), 127 },
    { TEXT("ORName"), TEXT("2.5.5.7"), 127 },
    { TEXT("DNWithBinary"), TEXT("2.5.5.7"), 127},
    // needs additional information to distinguish from ORName
    { TEXT("AccessPointDN"), TEXT("2.5.5.14"), 127 },
    { TEXT("DNWithString"), TEXT("2.5.5.14"), 127 },
    // needs additional information to distinguish from AccessPointDN
    { TEXT("NTSecurityDescriptor"), TEXT("2.5.5.15"), 66},
    { TEXT("GeneralizedTime"), TEXT("2.5.5.11"), 24},
    { TEXT("Enumeration"), TEXT("2.5.5.9"), 10 },
    { TEXT("ReplicaLink"), TEXT("2.5.5.10"), 127 },
    { TEXT("Sid"), TEXT("2.5.5.17"), 4 },
    { TEXT("CaseExactString"), TEXT("2.5.5.3"), 27 }
};

struct _classmapping
{
    LPTSTR pszLdapClassName;
    LPTSTR pszADsClassName;
    const GUID *pCLSID;
    const GUID *pPrimaryInterfaceGUID;
} aClassMap[] =
{
  { TEXT("user"),  USER_CLASS_NAME,
    &CLSID_LDAPUser, &IID_IADsUser },  // NTDS
  { TEXT("group"),  GROUP_CLASS_NAME,
    &CLSID_LDAPGroup, &IID_IADsGroup },  // NTDS
  { TEXT("localGroup"),  GROUP_CLASS_NAME,
    &CLSID_LDAPGroup, &IID_IADsGroup },    // NTDS
//  { TEXT("computer"), COMPUTER_CLASS_NAME,
//  &CLSID_LDAPComputer, &IID_IADsComputer },  // NTDS
  { TEXT("printQueue"), PRINTER_CLASS_NAME,
    &CLSID_LDAPPrintQueue, &IID_IADsPrintQueue }, // NTDS

  { TEXT("country"), TEXT("Country"),
    &CLSID_LDAPCountry, &IID_IADs },
  { TEXT("locality"), TEXT("Locality"),
    &CLSID_LDAPLocality, &IID_IADsLocality },
  { TEXT("organization"), TEXT("Organization"),
    &CLSID_LDAPO, &IID_IADsO },
  { TEXT("organizationalUnit"), TEXT("Organizational Unit"),
    &CLSID_LDAPOU, &IID_IADsOU },
  { TEXT("domain"), DOMAIN_CLASS_NAME,
    &CLSID_LDAPDomain, &IID_IADsDomain },

  { TEXT("person"), USER_CLASS_NAME,
    &CLSID_LDAPUser, &IID_IADsUser },
  { TEXT("organizationalPerson"), USER_CLASS_NAME,
    &CLSID_LDAPUser, &IID_IADsUser },
  { TEXT("residentialPerson"), USER_CLASS_NAME,
    &CLSID_LDAPUser, &IID_IADsUser },

  { TEXT("groupOfNames"), GROUP_CLASS_NAME,
    &CLSID_LDAPGroup, &IID_IADsGroup },
  { TEXT("groupOfUniqueNames"), GROUP_CLASS_NAME,
    &CLSID_LDAPGroup, &IID_IADsGroup }

  // { TEXT("alias"), TEXT("Alias") },
  // ..other classes in RFC 1788 new
};

SYNTAXINFO g_aLDAPSyntax[] =
{ {  TEXT("Boolean"),               VT_BOOL },
  {  TEXT("Counter"),               VT_I4 },
  {  TEXT("ADsPath"),               VT_BSTR },
  {  TEXT("EmailAddress"),          VT_BSTR },
  {  TEXT("FaxNumber"),             VT_BSTR },
  {  TEXT("Integer"),               VT_I4 },
  {  TEXT("Interval"),              VT_I4 },
  {  TEXT("List"),                  VT_VARIANT },  // VT_BSTR | VT_ARRAY
  {  TEXT("NetAddress"),            VT_BSTR },
  {  TEXT("OctetString"),           VT_VARIANT },  // VT_UI1| VT_ARRAY
  {  TEXT("Path"),                  VT_BSTR },
  {  TEXT("PhoneNumber"),           VT_BSTR },
  {  TEXT("PostalAddress"),         VT_BSTR },
  {  TEXT("SmallInterval"),         VT_I4 },
  {  TEXT("String"),                VT_BSTR },
  {  TEXT("Time"),                  VT_DATE },
  {  TEXT("Integer8"),              VT_DISPATCH },
  {  TEXT("UTCTime"),               VT_DATE },
  {  TEXT("DN"),                    VT_BSTR },
  {  TEXT("OID"),                   VT_BSTR },
  {  TEXT("DirectoryString"),       VT_BSTR },
  {  TEXT("PrintableString"),       VT_BSTR },
  {  TEXT("CaseIgnoreString"),      VT_BSTR },
  {  TEXT("NumericString"),         VT_BSTR },
  {  TEXT("IA5String"),             VT_BSTR },
  {  TEXT("PresentationAddresses"), VT_BSTR },
  {  TEXT("ORName"),                VT_BSTR },
  {  TEXT("DNWithBinary"),          VT_DISPATCH },
  {  TEXT("AccessPointDN"),         VT_BSTR },
  {  TEXT("DNWithString"),          VT_DISPATCH },
  {  TEXT("NTSecurityDescriptor"),  VT_DISPATCH },
  {  TEXT("ObjectSecurityDescriptor"), VT_DISPATCH },
  {  TEXT("PresentationAddress"), VT_BSTR },
  {  TEXT("GeneralizedTime"),       VT_DATE },
  //
  // We do not support these
  //  {  TEXT("Enumeration")},
  //  {  TEXT("ReplicaLink") },
  //  {  TEXT("Sid") },
  {  TEXT("CaseExactString"),       VT_BSTR}
};

struct _OIDToNamemapping
{
    LPTSTR pszAttributeTypeOID;
    LPTSTR pszFriendlyName;
} aOIDtoNameMap[] =
{
    { TEXT("1.2.840.113556.1.4.903"),        TEXT("DNWithBinary") },
    { TEXT("1.2.840.113556.1.4.904"),        TEXT("DNWithString") },
    // DnString also has the same OID as above
    { TEXT("1.2.840.113556.1.4.905"),        TEXT("CaseIgnoreString") },
    { TEXT("1.2.840.113556.1.4.906"),        TEXT("INTEGER8") },
    { TEXT("1.2.840.113556.1.4.907"),        TEXT("ObjectSecurityDescriptor") },
    // the type is ORName a type of string -> mapped to string.
    { TEXT("1.2.840.113556.1.4.1221"),       TEXT("ORName") },
    // the type is Undefined syntax in the server, so we are defaulting.
    { TEXT("1.2.840.113556.1.4.1222"),       TEXT("Undefined") },
    { TEXT("1.2.840.113556.1.4.1362"),       TEXT("CaseExactString") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.10"), TEXT("CertificatePair") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.11"), TEXT("CountryString") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.12"), TEXT("DN") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.13"), TEXT("DataQualitySyntax") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.14"), TEXT("DeliveryMethod") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.15"), TEXT("DirectoryString") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.19"), TEXT("DSAQualitySyntax") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.2"),  TEXT("AccessPointDN") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.21"), TEXT("EmhancedGuide") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.22"), TEXT("FacsimileTelephoneNumber") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.23"), TEXT("Fax") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.24"), TEXT("GeneralizedTime") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.25"), TEXT("Guide") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.26"), TEXT("IA5String") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.27"), TEXT("INTEGER") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.28"), TEXT("JPEG") },// not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.3"),  TEXT("AttributeTypeDescription") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.32"), TEXT("MailPreference") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.33"), TEXT("ORAddress") },  // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.34"), TEXT("NameAndOptionalUID") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.36"), TEXT("NumericString") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.37"), TEXT("ObjectClassDescription") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.38"), TEXT("OID") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.39"), TEXT("OtherMailBox") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.4"),  TEXT("Audio") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.40"), TEXT("OctetString") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.41"), TEXT("PostalAddress") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.43"), TEXT("PresentationAddress") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.44"), TEXT("PrintableString") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.5"),  TEXT("OctetString") }, // not in ours we map to Octet
    { TEXT("1.3.6.1.4.1.1466.115.121.1.50"), TEXT("TelephoneNumber") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.51"), TEXT("TeletexTerminalIdentifier") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.52"), TEXT("TelexNumber") }, // not in ours
    { TEXT("1.3.6.1.4.1.1466.115.121.1.53"), TEXT("UTCTime") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.6"),  TEXT("BitString") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.7"),  TEXT("Boolean") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.8"),  TEXT("Certificate") },
    { TEXT("1.3.6.1.4.1.1466.115.121.1.9"),  TEXT("CertificateList") },
};


DWORD g_cLDAPSyntax = (sizeof(g_aLDAPSyntax)/sizeof(g_aLDAPSyntax[0]));


typedef struct _classnamelist {

    LPTSTR pszClassName;
    _classnamelist *pNext;

} CLASSNAME_LIST, *PCLASSNAME_LIST;


BOOL
GetSyntaxOID(
    LPTSTR  pszSyntax,
    LPTSTR  *ppszOID,
    DWORD   *pdwOMSyntax
)
{
    for ( int i = 0; i < ARRAY_SIZE(aSyntaxMap); i++ )
    {
        if (_tcsicmp(pszSyntax, aSyntaxMap[i].pszSyntax) == 0 )
        {
            *ppszOID = aSyntaxMap[i].pszOID;
            *pdwOMSyntax = aSyntaxMap[i].dwOMSyntax;
            return TRUE;
        }
    }

    *ppszOID = NULL;
    return FALSE;
}


BOOL
GetFriendlyNameFromOID(
    LPTSTR  pszOID,
    LPTSTR  *ppszFriendlyName
)
{
    HRESULT hr = S_OK;

    for ( int i = 0; i < ARRAY_SIZE(aOIDtoNameMap); i++ )
    {
        if ( _tcsicmp( pszOID, aOIDtoNameMap[i].pszAttributeTypeOID ) == 0 )
        {
            hr = ADsAllocString(
                     aOIDtoNameMap[i].pszFriendlyName,
                      ppszFriendlyName
                     );

            if (SUCCEEDED(hr))
                return TRUE;
            else
                return FALSE;
        }
    }

    *ppszFriendlyName = NULL;
    return FALSE;
}


HRESULT
MakeVariantFromStringArray(
    BSTR *bstrList,
    VARIANT *pvVariant
);

HRESULT
MakeVariantFromPropStringTable(
    int *propList,
    LDAP_SCHEMA_HANDLE hSchema,
    VARIANT *pvVariant
);

HRESULT
ConvertSafeArrayToVariantArray(
    VARIANT   varSafeArray,
    PVARIANT *ppVarArray,
    PDWORD    pdwNumVariants
);

/* No Longer needed
HRESULT
DeleteSchemaEntry(
    LPTSTR pszADsPath,
    LPTSTR pszRelativeName,
    LPTSTR pszClassName,
    LPTSTR pszSubSchemaSubEntry,
    CCredentials& Credentials
);
*/

HRESULT
BuildSchemaLDAPPathAndGetAttribute(
    IN  LPTSTR pszParent,
    IN  LPTSTR pszClass,
    IN  LPTSTR pszSubSchemaSubEntry,
    IN  BOOL   fNew,
    IN  CCredentials& Credentials,
    IN  LPTSTR pszAttribs[],
    OUT LPWSTR * ppszSchemaLDAPServer,
    OUT LPWSTR * ppszSchemaLDAPDn,
    IN OUT PADS_LDP *pLd,
    OUT LDAPMessage **ppRes
);

HRESULT
BuildSchemaLDAPPath(
    LPTSTR pszParent,
    LPTSTR pszClass,
    LPTSTR pszSubSchemaSubEntry,
    LPWSTR * ppszSchemaLDAPServer,
    LPWSTR * ppszSchemaLDAPDn,
    BOOL   fNew,
    ADS_LDP   **pld,
    CCredentials& Credentials
);

HRESULT
MakePropArrayFromVariant(
    VARIANT vProp,
    SCHEMAINFO *hSchema,
    int **pOIDs,
    DWORD *pNumOfOids
);

HRESULT
MakePropArrayFromStringArray(
    LPTSTR *aValues,
    DWORD  nCount,
    SCHEMAINFO *hSchema,
    int **pOIDs,
    DWORD *pNumOfOids
);

HRESULT
SchemaGetPrimaryInterface(
    LDAP_SCHEMA_HANDLE hSchema,
    LPTSTR pszClassName,
    GUID **ppPrimaryInterfaceGUID,
    GUID **ppCLSID
);


STDMETHODIMP
makeUnionVariantFromLdapObjects(
    LDAPOBJECTARRAY ldapSrcObjects1,
    LDAPOBJECTARRAY ldapSrcObjects2,
    VARIANT FAR * pvPossSuperiors
    );

STDMETHODIMP
addStringIfAbsent(
    BSTR addString,
    BSTR *strArray,
    PDWORD dwArrIndx
    );

//
// This functions puts the named string property into the cache
// of the object as a CaseIgnoreString. It is meant for usage from
// umi to put the simulated name property on schema objects.
//
HRESULT
HelperPutStringPropertyInCache(
    LPWSTR pszName,
    LPWSTR pszStrProperty,
    CCredentials &Credentials,
    CPropertyCache *pPropCache
    )
{
    HRESULT hr = E_NOTIMPL;
    DWORD dwIndex = 0;
    VARIANT varBstr;
    LDAPOBJECTARRAY ldapDestObjects;

    LDAPOBJECTARRAY_INIT(ldapDestObjects);
    VariantInit(&varBstr);

    hr = ADsAllocString(pszStrProperty, &(varBstr.bstrVal));
    BAIL_ON_FAILURE(hr);

    varBstr.vt = VT_BSTR;
    //
    // Conver the variant to LDAP objects we can cache.
    //
    hr = VarTypeToLdapTypeCopyConstruct(
             NULL, //ServerName not needed here,
             Credentials,
             LDAPTYPE_CASEIGNORESTRING,
             &varBstr,
             1,
             &ldapDestObjects
             );
    BAIL_ON_FAILURE(hr);

    //
    // Find this property in the cache
    //
    hr = pPropCache->findproperty(
                         pszName,
                         &dwIndex
                         );

    //
    // If this property does not exist in the
    // cache, add this property into the cache.
    //
    if (FAILED(hr)) {
        hr = pPropCache->addproperty( pszName );
        BAIL_ON_FAILURE(hr);
    }

    //
    // Now update the property in the cache
    //
    hr = pPropCache->putproperty(
             pszName,
             PROPERTY_INIT,
             LDAPTYPE_CASEIGNORESTRING,
             ldapDestObjects
             );
    BAIL_ON_FAILURE(hr);

error:

    VariantClear(&varBstr);
    LdapTypeFreeLdapObjects( &ldapDestObjects );

    RRETURN_EXP_IF_ERR(hr);
}

/******************************************************************/
/*  Class CLDAPSchema
/******************************************************************/

DEFINE_IDispatch_Implementation(CLDAPSchema)
DEFINE_IADs_Implementation(CLDAPSchema)

CLDAPSchema::CLDAPSchema()
    : _pDispMgr( NULL ),
      _pPropertyCache(NULL)
{
    VariantInit( &_vFilter );
    VariantInit( &_vHints );

    _szServerPath[0] = 0;

    ENLIST_TRACKING(CLDAPSchema);
}

CLDAPSchema::~CLDAPSchema()
{
    VariantClear( &_vFilter );
    VariantClear( &_vHints );

    delete _pDispMgr;
    delete _pPropertyCache;

}

HRESULT
CLDAPSchema::CreateSchema(
    BSTR   bstrParent,
    BSTR   bstrName,
    LPTSTR pszServerPath,
    CCredentials& Credentials,
    DWORD  dwObjectState,
    REFIID riid,
    void **ppvObj
    )
{
    CLDAPSchema FAR *pSchema = NULL;
    HRESULT hr = S_OK;

    OBJECTINFO ObjectInfo;
    POBJECTINFO pObjectInfo = &ObjectInfo;

    memset(pObjectInfo, 0, sizeof(OBJECTINFO));

    hr = AllocateSchemaObject( &pSchema, Credentials );
    BAIL_ON_FAILURE(hr);

    _tcscpy( pSchema->_szServerPath, pszServerPath );

    hr = ADsObject(bstrParent, pObjectInfo);
    BAIL_ON_FAILURE(hr);

    pSchema->_dwPort = pObjectInfo->PortNumber;

    FreeObjectInfo(pObjectInfo);
    pObjectInfo = NULL;

    hr = pSchema->InitializeCoreObject(
             bstrParent,
             bstrName,
             SCHEMA_CLASS_NAME,
             CLSID_LDAPSchema,
             dwObjectState );
    BAIL_ON_FAILURE(hr);

    //
    // See if we need to create the Umi object.
    //
    if (Credentials.GetAuthFlags() & ADS_AUTH_RESERVED) {
        hr = ((CCoreADsObject*)pSchema)->InitUmiObject(
                   IntfPropsSchema,
                   pSchema->_pPropertyCache,
                   (IADs*) pSchema,
                   (IADs*) pSchema,
                   riid,
                   ppvObj,
                   &(pSchema->_Credentials),
                   pSchema->_dwPort
                   );

        BAIL_ON_FAILURE(hr);


        hr = HelperPutStringPropertyInCache(
                 L"Name",
                 bstrName,
                 pSchema->_Credentials,
                 pSchema->_pPropertyCache
                 );
        BAIL_ON_FAILURE(hr);

        RRETURN(S_OK);
    }

    hr = pSchema->QueryInterface( riid, ppvObj );
    BAIL_ON_FAILURE(hr);

    pSchema->Release();

    RRETURN(hr);

error:

    FreeObjectInfo(pObjectInfo);

    *ppvObj = NULL;
    delete pSchema;
    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    if (ppv == NULL) {
    RRETURN(E_POINTER);
    }

    if (IsEqualIID(iid, IID_IUnknown))
    {
        *ppv = (IADs FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IDispatch))
    {
        *ppv = (IADs FAR *)this;
    }
    else if (IsEqualIID(iid, IID_IADs))
    {
        *ppv = (IADs FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IADsContainer))
    {
        *ppv = (IADsContainer FAR *) this;
    }
    else if (IsEqualIID(iid, IID_ISupportErrorInfo))
    {
        *ppv = (ISupportErrorInfo FAR *) this;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    AddRef();
    return NOERROR;
}

/* ISupportErrorInfo method */
STDMETHODIMP
CLDAPSchema::InterfaceSupportsErrorInfo(THIS_ REFIID riid)
{
    if (IsEqualIID(riid, IID_IADs) ||
    IsEqualIID(riid, IID_IADsContainer)) {
        RRETURN(S_OK);
    } else {
        RRETURN(S_FALSE);
    }
}

/* IADs methods */

STDMETHODIMP
CLDAPSchema::SetInfo(THIS)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

STDMETHODIMP
CLDAPSchema::GetInfo(THIS)
{
    HRESULT hr;
    hr = LDAPRefreshSchema();
    RRETURN_EXP_IF_ERR(hr);
}

//
// Helper function for Umi - defined in CCoreADsObject.
//
STDMETHODIMP
CLDAPSchema::GetInfo(DWORD dwFlags)
{
    if (dwFlags == GETINFO_FLAG_EXPLICIT) {
        RRETURN(GetInfo());
    } 

    //
    // All other cases we just say OK cause there is no way to go.
    //
    RRETURN(S_OK);
}

/* IADsContainer methods */

STDMETHODIMP
CLDAPSchema::get_Count(long FAR* retval)
{
    HRESULT hr;

    DWORD nNumOfClasses;
    DWORD nNumOfProperties;

    if ( !retval )
        RRETURN(E_ADS_BAD_PARAMETER);

    hr = LdapGetSchemaObjectCount(
             _szServerPath,
             &nNumOfClasses,
             &nNumOfProperties,
             _Credentials,
             _dwPort
             );

    if ( SUCCEEDED(hr))
        *retval = nNumOfClasses + nNumOfProperties + g_cLDAPSyntax;

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::get_Filter(THIS_ VARIANT FAR* pVar)
{
    if ( !pVar )
        RRETURN(E_ADS_BAD_PARAMETER);

    HRESULT hr;
    VariantInit( pVar );
    hr = VariantCopy( pVar, &_vFilter );
    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::put_Filter(THIS_ VARIANT Var)
{
    HRESULT hr;
    hr = VariantCopy( &_vFilter, &Var );
    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::get_Hints(THIS_ VARIANT FAR* pVar)
{
    if ( !pVar )
        RRETURN(E_ADS_BAD_PARAMETER);

    HRESULT hr;
    VariantInit( pVar );
    hr = VariantCopy( pVar, &_vHints );
    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::put_Hints(THIS_ VARIANT Var)
{
    HRESULT hr;
    VariantClear(&_vHints);

    hr = VariantCopy( &_vHints, &Var );
    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::GetObject(
    THIS_ BSTR ClassName,
    BSTR RelativeName,
    IDispatch * FAR* ppObject)
{
    DWORD dwBufferSize = 0;
    TCHAR *pszBuffer = NULL;
    HRESULT hr = S_OK;

    if (!RelativeName || !*RelativeName) {
        RRETURN(E_ADS_UNKNOWN_OBJECT);
    }

    dwBufferSize = ( _tcslen(_ADsPath) + _tcslen(RelativeName)
                     + 2  ) * sizeof(TCHAR);   // includes "/"

    pszBuffer = (LPTSTR) AllocADsMem( dwBufferSize );

    if ( pszBuffer == NULL )
    {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    _tcscpy(pszBuffer, _ADsPath);
    _tcscat(pszBuffer, TEXT("/"));
    _tcscat(pszBuffer, RelativeName);

    hr = ::GetObject(
                pszBuffer,
                _Credentials,
                (LPVOID *)ppObject
                );
    BAIL_ON_FAILURE(hr);

error:

    if ( pszBuffer )
        FreeADsMem( pszBuffer );

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::get__NewEnum(THIS_ IUnknown * FAR* retval)
{
    HRESULT hr;
    IEnumVARIANT *penum = NULL;

    if ( !retval )
        RRETURN(E_ADS_BAD_PARAMETER);

    *retval = NULL;

    //
    // Create new enumerator for items currently
    // in collection and QI for IUnknown
    //

    hr = CLDAPSchemaEnum::Create( (CLDAPSchemaEnum **)&penum,
                                   _ADsPath,
                                   _szServerPath,
                                   _vFilter,
                                   _Credentials
                                   );
    BAIL_ON_FAILURE(hr);

    hr = penum->QueryInterface( IID_IUnknown, (VOID FAR* FAR*)retval );
    BAIL_ON_FAILURE(hr);

    if ( penum )
        penum->Release();

    RRETURN(hr);

error:

    if ( penum )
        delete penum;

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::Create(
    THIS_ BSTR ClassName,
    BSTR RelativeName,
    IDispatch * FAR* ppObject)
{
    HRESULT hr = S_OK;
    LDAP_SCHEMA_HANDLE hSchema = NULL;

    hr = SchemaOpen( _szServerPath, &hSchema, _Credentials, _dwPort );
    BAIL_ON_FAILURE(hr);

    //
    // We can only create "Class","Property" here, "Syntax" is read-only
    //


    if (  ( _tcsicmp( ClassName, CLASS_CLASS_NAME ) == 0 )
       || ( _tcsicmp( ClassName, NT_SCHEMA_CLASS_NAME ) == 0 )
       )
    {
        //
        // Now, create the class
        //
        hr = CLDAPClass::CreateClass(
                         _ADsPath,
                         hSchema,
                         RelativeName,
                         NULL,
                         _Credentials,
                         ADS_OBJECT_UNBOUND,
                         IID_IUnknown,
                         (void **) ppObject );
    }
    else if (  ( _tcsicmp( ClassName, PROPERTY_CLASS_NAME ) == 0 )
            || ( _tcsicmp( ClassName, NT_SCHEMA_PROPERTY_NAME ) == 0 )
            )
    {
        hr = CLDAPProperty::CreateProperty(
                         _ADsPath,
                         hSchema,
                         RelativeName,
                         NULL,
                         _Credentials,
                         ADS_OBJECT_UNBOUND,
                         IID_IUnknown,
                         (void **) ppObject );

    }
    else
    {
        hr = E_ADS_BAD_PARAMETER;
    }

error:

    if ( hSchema )
        SchemaClose( &hSchema );

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::Delete(THIS_ BSTR bstrClassName, BSTR bstrRelativeName )
{
    RRETURN(E_NOTIMPL);
}

STDMETHODIMP
CLDAPSchema::CopyHere(THIS_ BSTR SourceName,
                       BSTR NewName,
                       IDispatch * FAR* ppObject)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

STDMETHODIMP
CLDAPSchema::MoveHere(THIS_ BSTR SourceName,
                       BSTR NewName,
                       IDispatch * FAR* ppObject)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

STDMETHODIMP
CLDAPSchema::Get(THIS_ BSTR bstrName, VARIANT FAR* pvProp)
{
    HRESULT hr = S_OK;
    LPTSTR pszSubSchemaSubEntry = NULL;
    LPTSTR pszSchemaRoot = NULL;

    //
    // For folks who know now what they do.
    //
    if (!pvProp) {
        BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
    }

    VariantInit( pvProp );

    // Temporary hack
    if ( _tcsicmp( bstrName, TEXT("NTSchemaPath")) == 0 )
    {
        hr = LdapGetSubSchemaSubEntryPath(
                 _szServerPath,
                 &pszSubSchemaSubEntry,
                 _Credentials,
                 _dwPort
                 );
        BAIL_ON_FAILURE(hr);

        if ( pszSubSchemaSubEntry == NULL )   // not NTDS server
        {
            hr = E_NOTIMPL;
            BAIL_ON_FAILURE(hr);
        }

        // the _tcschr is to get rid of "CN=Aggregate"
        pszSchemaRoot = _tcschr(pszSubSchemaSubEntry, TEXT(','));

        if ( pszSchemaRoot == NULL )   // not NTDS server
        {
            hr = E_NOTIMPL;
            BAIL_ON_FAILURE(hr);
        }

        hr = ADsAllocString( pszSchemaRoot + 1,
                             &(pvProp->bstrVal));
        BAIL_ON_FAILURE(hr);

        pvProp->vt = VT_BSTR;
    }
    else 
    {
        hr = E_NOTIMPL;
    }

error:

    if ( pszSubSchemaSubEntry )
        FreeADsStr( pszSubSchemaSubEntry );

    if ( FAILED(hr))
        VariantClear( pvProp );

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSchema::Put(THIS_ BSTR bstrName, VARIANT vProp)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

STDMETHODIMP
CLDAPSchema::GetEx(THIS_ BSTR bstrName, VARIANT FAR* pvProp)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

STDMETHODIMP
CLDAPSchema::PutEx(THIS_ long lnControlCode, BSTR bstrName, VARIANT vProp)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

STDMETHODIMP
CLDAPSchema::GetInfoEx(THIS_ VARIANT vProperties, long lnReserved)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

HRESULT
CLDAPSchema::AllocateSchemaObject(
    CLDAPSchema FAR * FAR * ppSchema,
    CCredentials& Credentials
    )
{
    CLDAPSchema FAR *pSchema = NULL;
    CAggregatorDispMgr FAR *pDispMgr = NULL;
    CPropertyCache FAR *pPropertyCache = NULL;
    HRESULT hr = S_OK;

    pSchema = new CLDAPSchema();
    if ( pSchema == NULL )
        hr = E_OUTOFMEMORY;
    BAIL_ON_FAILURE(hr);

    pDispMgr = new CAggregatorDispMgr(Credentials);
    if ( pDispMgr == NULL )
        hr = E_OUTOFMEMORY;
    BAIL_ON_FAILURE(hr);

    hr = pDispMgr->LoadTypeInfoEntry(
                            LIBID_ADs,
                            IID_IADs,
                            (IADs *) pSchema,
                            DISPID_REGULAR );
    BAIL_ON_FAILURE(hr);

    hr = pDispMgr->LoadTypeInfoEntry(
                            LIBID_ADs,
                            IID_IADsContainer,
                            (IADsContainer *) pSchema,
                            DISPID_NEWENUM );
    BAIL_ON_FAILURE(hr);

    hr = CPropertyCache::createpropertycache(
                            (CCoreADsObject FAR *) pSchema,
                            (IGetAttributeSyntax *) pSchema,
                            &pPropertyCache
                            );
    BAIL_ON_FAILURE(hr);

    pSchema->_pPropertyCache = pPropertyCache;
    pSchema->_Credentials = Credentials;
    pSchema->_pDispMgr = pDispMgr;
    *ppSchema = pSchema;

    RRETURN(hr);

error:

    delete pDispMgr;
    delete pSchema;
    delete pPropertyCache;

    RRETURN(hr);

}

HRESULT
CLDAPSchema::LDAPRefreshSchema(THIS)
{
    HRESULT hr = S_OK;

    //
    // Make the old schema obsolete.
    // We cannot delete the old schema since other objects might have
    // references to it.
    //

    hr = LdapMakeSchemaCacheObsolete(
             _szServerPath,
             _Credentials,
             _dwPort
             );

    RRETURN_EXP_IF_ERR(hr);
}

//
// Needed for dynamic dispid's in the property cache.
//
HRESULT
CLDAPSchema::GetAttributeSyntax(
    LPWSTR szPropertyName,
    PDWORD pdwSyntaxId
    )
{
    HRESULT hr = S_OK;

    if ((_Credentials.GetAuthFlags() & ADS_AUTH_RESERVED)
        && !_wcsicmp(L"Name", szPropertyName)) {
        *pdwSyntaxId = LDAPTYPE_CASEIGNORESTRING;
    } 
    else {
        hr = E_ADS_PROPERTY_NOT_FOUND;
    }

    RRETURN_EXP_IF_ERR(hr);
}

/******************************************************************/
/*  Class CLDAPClass
/******************************************************************/

DEFINE_IDispatch_Implementation(CLDAPClass)
DEFINE_IADs_Implementation(CLDAPClass)

CLDAPClass::CLDAPClass()
    : _pDispMgr( NULL ),
      _pPropertyCache( NULL ),
      _bstrCLSID( NULL ),
      _bstrPrimaryInterface( NULL ),
      _bstrHelpFileName( NULL ),
      _lHelpFileContext( 0 ),
      _hSchema( NULL ),
      _pClassInfo( NULL ),
      _fNTDS( TRUE ),
      _pszLDAPServer(NULL),
      _pszLDAPDn(NULL),
      _ld( NULL ),
      _fLoadedInterfaceInfo(FALSE)
{
    ENLIST_TRACKING(CLDAPClass);
}

CLDAPClass::~CLDAPClass()
{
    delete _pDispMgr;

    delete _pPropertyCache;

    if ( _bstrCLSID ) {
        ADsFreeString( _bstrCLSID );
    }

    if ( _bstrPrimaryInterface ) {
        ADsFreeString( _bstrPrimaryInterface );
    }

    if ( _bstrHelpFileName ) {
        ADsFreeString( _bstrHelpFileName );
    }

    if ( _hSchema ) {
        SchemaClose( &_hSchema );
        _hSchema = NULL;
    }

    if ( _pszLDAPServer ) {
        FreeADsStr( _pszLDAPServer );
    }

    if (_pszLDAPDn) {
        FreeADsStr(_pszLDAPDn);

    }


    if ( _ld ) {
        LdapCloseObject( _ld );
        _ld = NULL;
    }

}

HRESULT      
CLDAPClass::CreateClass(
    BSTR   bstrParent,
    LDAP_SCHEMA_HANDLE hSchema,
    BSTR   bstrName,
    CLASSINFO *pClassInfo,
    CCredentials& Credentials,
    DWORD  dwObjectState,
    REFIID riid,
    void **ppvObj
    )
{
    CLDAPClass FAR *pClass = NULL;
    HRESULT hr = S_OK;
    BOOL fUmiCall = FALSE;

    OBJECTINFO ObjectInfo;
    POBJECTINFO pObjectInfo = &ObjectInfo;
    VARIANT var;

    VariantInit(&var);

    memset(pObjectInfo, 0, sizeof(OBJECTINFO));

    hr = AllocateClassObject(Credentials,  &pClass );
    BAIL_ON_FAILURE(hr);

    //
    // Some extra things need to be done if the call is from umi.
    //
    fUmiCall = Credentials.GetAuthFlags() & ADS_AUTH_RESERVED;

    pClass->_pClassInfo = pClassInfo;
    SchemaAddRef( hSchema );
    pClass->_hSchema = hSchema;

    if ( pClassInfo )  // an existing class
    {
    
        if ( pClassInfo->pszHelpFileName )
        {
            hr = ADsAllocString( pClassInfo->pszHelpFileName,
                                 &pClass->_bstrHelpFileName );
        }

        pClass->_lHelpFileContext = pClassInfo->lHelpFileContext;

        hr = put_BSTR_Property( pClass, TEXT("governsID"), pClassInfo->pszOID);

        if ( SUCCEEDED(hr))
        {
            hr = put_LONG_Property( pClass, TEXT("objectClassCategory"),
                                    pClassInfo->dwType );
            BAIL_ON_FAILURE(hr);

            VariantInit( &var );
            hr = MakeVariantFromPropStringTable( pClassInfo->pOIDsMustContain,
                                                 pClass->_hSchema,
                                                 &var );
            BAIL_ON_FAILURE(hr);
            hr = put_VARIANT_Property( pClass, TEXT("mustContain"), var );
            BAIL_ON_FAILURE(hr);
            if (fUmiCall) {
                //
                // Need to add this to the cache as mandatoryProperties.
                //
                hr = put_VARIANT_Property(
                         pClass,
                         TEXT("mandatoryProperties"),
                         var
                         );
                BAIL_ON_FAILURE(hr);

                //
                // We also need a dummy property called Name.
                //
                hr = put_BSTR_Property(
                         pClass,
                         TEXT("Name"),
                         bstrName
                         );
                BAIL_ON_FAILURE(hr);
            }

            VariantClear( &var );

            hr = MakeVariantFromPropStringTable( pClassInfo->pOIDsMayContain,
                                                 pClass->_hSchema,
                                                 &var );
            BAIL_ON_FAILURE(hr);
            hr = put_VARIANT_Property( pClass, TEXT("mayContain"), var );
            BAIL_ON_FAILURE(hr);
            if (fUmiCall) {
                //
                // Again need to add as optionalProperties.
                //
                hr = put_VARIANT_Property(
                         pClass,
                         TEXT("optionalProperties"),
                         var
                         );
                BAIL_ON_FAILURE(hr);
            }

            VariantClear( &var );

            hr = MakeVariantFromStringArray( pClassInfo->pOIDsSuperiorClasses,
                                             &var );
            BAIL_ON_FAILURE(hr);

            hr = put_VARIANT_Property( pClass, TEXT("subClassOf"), var );
            BAIL_ON_FAILURE(hr);
            VariantClear( &var );

            hr = MakeVariantFromStringArray( pClassInfo->pOIDsAuxClasses,
                                             &var );
            BAIL_ON_FAILURE(hr);

            hr = put_VARIANT_Property( pClass, TEXT("auxiliaryClass"), var );
            BAIL_ON_FAILURE(hr);
            VariantClear( &var );

            pClass->_pPropertyCache->ClearAllPropertyFlags();

            pClass->_fNTDS = TRUE;
        }
        else
        {
            pClass->_fNTDS = FALSE;
        }
    }


    hr = ADsObject(bstrParent, pObjectInfo);
    BAIL_ON_FAILURE(hr);

    pClass->_dwPort = pObjectInfo->PortNumber;

    FreeObjectInfo(pObjectInfo);
    pObjectInfo = NULL;

    hr = pClass->InitializeCoreObject(
             bstrParent,
             bstrName,
             CLASS_CLASS_NAME,
             CLSID_LDAPClass,
             dwObjectState );
    BAIL_ON_FAILURE(hr);

    //
    // At this point update the info in the property cache
    //

    pClass->_pPropertyCache->SetObjInformation(
                                     &(pClass->_Credentials),
                                     pClass->_pszLDAPServer,
                                     pClass->_dwPort
                                     );

    BAIL_ON_FAILURE(hr);

    //
    // If this is a umi call we need to return umi object.
    //
    if (fUmiCall) {
        hr = ((CCoreADsObject*)pClass)->InitUmiObject(
                   IntfPropsSchema,
                   pClass->_pPropertyCache,
                   (IADs *) pClass,
                   (IADs *) pClass,
                   riid,
                   ppvObj,
                   &(pClass->_Credentials),
                   pClass->_dwPort,
                   pClass->_pszLDAPServer,
                   pClass->_pszLDAPDn
                   );
        
        BAIL_ON_FAILURE(hr);

        RRETURN(S_OK);
    }

    hr = pClass->QueryInterface( riid, ppvObj );
    BAIL_ON_FAILURE(hr);

    pClass->Release();

    RRETURN(hr);

error:

    *ppvObj = NULL;
    delete pClass;

    VariantClear(&var);
    FreeObjectInfo(pObjectInfo);

    RRETURN_EXP_IF_ERR(hr);
}


STDMETHODIMP
CLDAPClass::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    if (ppv == NULL) {
    RRETURN(E_POINTER);
    }

    if (IsEqualIID(iid, IID_IUnknown))
    {
        *ppv = (IADsClass FAR * ) this;
    }
    else if (IsEqualIID(iid, IID_IDispatch))
    {
        *ppv = (IADs FAR *) this;
    }
    else if (IsEqualIID(iid, IID_ISupportErrorInfo))
    {
        *ppv = (ISupportErrorInfo FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IADs))
    {
        *ppv = (IADs FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IADsClass))
    {
        *ppv = (IADsClass FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IADsUmiHelperPrivate)) {
        *ppv = (IADsUmiHelperPrivate FAR *) this;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    AddRef();
    return NOERROR;
}

/* ISupportErrorInfo method */
STDMETHODIMP
CLDAPClass::InterfaceSupportsErrorInfo(THIS_ REFIID riid)
{
    if (IsEqualIID(riid, IID_IADs) ||
    IsEqualIID(riid, IID_IADsClass)) {
        RRETURN(S_OK);
    } else {
        RRETURN(S_FALSE);
    }
}

/* IADs methods */

STDMETHODIMP
CLDAPClass::SetInfo(THIS)
{
    HRESULT hr = S_OK;
    BOOL fChanged = FALSE;

    if ( !_fNTDS )
        RRETURN(E_NOTIMPL);

    if ( GetObjectState() == ADS_OBJECT_UNBOUND )
    {
        hr = LDAPCreateObject();
        BAIL_ON_FAILURE(hr);

        fChanged = TRUE;

        //
        // If the create succeded, set the object type to bound
        //

        SetObjectState(ADS_OBJECT_BOUND);

    }
    else
    {
        hr = LDAPSetObject( &fChanged );
        BAIL_ON_FAILURE(hr);
    }

    //
    //  Need to refresh the schema
    //

    if ( SUCCEEDED(hr) && fChanged )
        hr = LDAPRefreshSchema();

error:

    RRETURN_EXP_IF_ERR(hr);
}

HRESULT
CLDAPClass::LDAPSetObject( BOOL *pfChanged )
{
    HRESULT hr = S_OK;

    BOOL fUpdated = FALSE;
    BOOL fUpdateMustContain = FALSE;
    BOOL fUpdateMayContain = FALSE;

    VARIANT var;
    int *pOIDs = NULL;
    DWORD nNumOfOids = 0;

    LDAPModW **aMod = NULL;
    DWORD dwNumOfMods = 0;
    DWORD dwNumOfModsNeedFreeing = 0;

    *pfChanged = FALSE;

    hr = _pPropertyCache->IsPropertyUpdated( TEXT("mustContain"), &fUpdated);
    BAIL_ON_FAILURE(hr);

    if ( fUpdated )
    {
        VariantInit(&var);
        hr = get_VARIANT_Property( this, TEXT("mustContain"), &var );
        BAIL_ON_FAILURE(hr);

        hr = MakePropArrayFromVariant( var,
                                       (SCHEMAINFO *) _hSchema,
                                       &pOIDs,
                                       &nNumOfOids );
        BAIL_ON_FAILURE(hr);

        hr = FindModifications( pOIDs,
                                nNumOfOids,
                                TEXT("mustContain"),
                                &aMod,
                                &dwNumOfMods );
        BAIL_ON_FAILURE(hr);

        // This flag needs to be cleared temporarily so that
        // LDAPMarshallProperties2 below will not try to update
        // this property. We will reset the flag right later.

        hr = _pPropertyCache->ClearPropertyFlag( TEXT("mustContain"));
        BAIL_ON_FAILURE(hr);

        fUpdateMustContain = TRUE;

        VariantClear(&var);
        FreeADsMem( pOIDs );
        pOIDs = NULL;
    }

    hr = _pPropertyCache->IsPropertyUpdated( TEXT("mayContain"), &fUpdated);
    BAIL_ON_FAILURE(hr);

    if ( fUpdated )
    {
        VariantInit(&var);
        hr = get_VARIANT_Property( this, TEXT("mayContain"), &var );
        BAIL_ON_FAILURE(hr);

        hr = MakePropArrayFromVariant( var,
                                       (SCHEMAINFO *) _hSchema,
                                       &pOIDs,
                                       &nNumOfOids );
        BAIL_ON_FAILURE(hr);

        hr = FindModifications( pOIDs,
                                nNumOfOids,
                                TEXT("mayContain"),
                                &aMod,
                                &dwNumOfMods );
        BAIL_ON_FAILURE(hr);

        // This flag needs to be cleared temporarily so that
        // LDAPMarshallProperties2 below will not try to update
        // this property. We will reset the flag later on.

        hr = _pPropertyCache->ClearPropertyFlag( TEXT("mayContain"));
        BAIL_ON_FAILURE(hr);

        fUpdateMayContain = TRUE;

        VariantClear(&var);
        FreeADsMem( pOIDs );
        pOIDs = NULL;
    }

    dwNumOfModsNeedFreeing = dwNumOfMods;

    hr = _pPropertyCache->LDAPMarshallProperties2(
                            &aMod,
                            &dwNumOfMods
                            );
    BAIL_ON_FAILURE(hr);

    if ( aMod == NULL )  // There are no changes that needs to be modified
        RRETURN(S_OK);

    //
    // Reset the flags so that if LdapModifyS fails, they are still flagged
    // as needed to be updated.
    //
    if ( fUpdateMustContain )
    {
        hr = _pPropertyCache->SetPropertyFlag( TEXT("mustContain"),
                                               PROPERTY_UPDATE );
        BAIL_ON_FAILURE(hr);
    }

    if ( fUpdateMayContain )
    {
        hr = _pPropertyCache->SetPropertyFlag( TEXT("mayContain"),
                                               PROPERTY_UPDATE );
        BAIL_ON_FAILURE(hr);
    }

    //
    // Send the request to the server
    //

    if (_pszLDAPDn == NULL )
    {
        hr = BuildSchemaLDAPPath( _Parent,
                                  _Name,
                                  ((SCHEMAINFO*)_hSchema)->pszSubSchemaSubEntry,
                                  &_pszLDAPServer,
                                  &_pszLDAPDn,
                                  _pClassInfo == NULL,
                                  &_ld,
                                  _Credentials
                                  );


        BAIL_ON_FAILURE(hr);
    }

    hr = LdapModifyS(
                   _ld,
                   _pszLDAPDn,
                   aMod
                   );
    BAIL_ON_FAILURE(hr);

    // We are successful at this point,
    // So, clean up the flags in the cache so the same operation
    // won't be repeated on the next SetInfo()

    _pPropertyCache->ClearAllPropertyFlags();

    *pfChanged = TRUE;

error:

    VariantClear(&var);

    if ( pOIDs )
        FreeADsMem( pOIDs );

    if (aMod) {

        for ( DWORD i = 0; i < dwNumOfModsNeedFreeing; i++ )
        {
            FreeADsMem((*aMod)[i].mod_values);
        }

        if ( *aMod )
            FreeADsMem( *aMod );

        FreeADsMem( aMod );
    }

    RRETURN_EXP_IF_ERR(hr);
}

HRESULT
CLDAPClass::LDAPCreateObject()
{
    HRESULT hr = S_OK;
    LDAPModW **aMod = NULL;
    DWORD dwIndex = 0;
    VARIANT v;
    BOOL fNTSecDes = FALSE;
    SECURITY_INFORMATION NewSeInfo;

    //
    // Get the LDAP path of the schema entry
    //
    if (_pszLDAPDn == NULL )
    {
        hr = BuildSchemaLDAPPath( _Parent,
                                  _Name,
                                  ((SCHEMAINFO*)_hSchema)->pszSubSchemaSubEntry,
                                  &_pszLDAPServer,
                                  &_pszLDAPDn,
                                  _pClassInfo == NULL,
                                  &_ld,
                                  _Credentials
                                  );

        BAIL_ON_FAILURE(hr);
    }

    if ( _pPropertyCache->findproperty( TEXT("objectClass"), &dwIndex )
         == E_ADS_PROPERTY_NOT_FOUND )
    {

        VariantInit(&v);
        v.vt = VT_BSTR;
        V_BSTR(&v) = NT_SCHEMA_CLASS_NAME;

        hr = Put( TEXT("objectClass"), v );
        BAIL_ON_FAILURE(hr);
    }

    if ( _pPropertyCache->findproperty( TEXT("cn"), &dwIndex )
         == E_ADS_PROPERTY_NOT_FOUND )
    {
        VariantInit(&v);
        v.vt = VT_BSTR;
        V_BSTR(&v) = _Name;

        hr = Put( TEXT("cn"), v );
        BAIL_ON_FAILURE(hr);
    }

    if ( _pPropertyCache->findproperty( TEXT("lDAPDisplayName"), &dwIndex )
         == E_ADS_PROPERTY_NOT_FOUND )
    {
        VariantInit(&v);
        v.vt = VT_BSTR;
        V_BSTR(&v) = _Name;

        hr = Put( TEXT("lDAPDisplayName"), v );
        BAIL_ON_FAILURE(hr);
    }

    if ( _pPropertyCache->findproperty( TEXT("objectClassCategory"), &dwIndex)
         == E_ADS_PROPERTY_NOT_FOUND )
    {
        VariantInit(&v);
        v.vt = VT_I4;
        V_I4(&v) = CLASS_TYPE_STRUCTURAL;

        hr = Put( TEXT("objectClassCategory"), v );
        BAIL_ON_FAILURE(hr);
    }

    hr = _pPropertyCache->LDAPMarshallProperties(
                            &aMod,
                            &fNTSecDes,
                            &NewSeInfo
                            );
    BAIL_ON_FAILURE(hr);

    if ( _ld == NULL )
    {
        hr = LdapOpenObject(
                       _pszLDAPServer,
                       _pszLDAPDn,
                       &_ld,
                       _Credentials,
                       _dwPort
                       );

    BAIL_ON_FAILURE(hr);

    }

    hr = LdapAddS(
                    _ld,
                    _pszLDAPDn,
                    aMod
                    );

    BAIL_ON_FAILURE(hr);

    // We are successful at this point,
    // So, clean up the flags in the cache so the same operation
    // won't be repeated on the next SetInfo()

    _pPropertyCache->ClearAllPropertyFlags();

error:

    if (aMod) {

        if ( *aMod )
            FreeADsMem( *aMod );
        FreeADsMem( aMod );
    }

    RRETURN_EXP_IF_ERR(hr);
}

HRESULT
CLDAPClass::LDAPRefreshSchema(THIS)
{
    HRESULT hr = S_OK;
    TCHAR *pszLDAPServer = NULL;
    TCHAR *pszLDAPDn = NULL;
    DWORD dwPort = 0;

    //
    // Get the server name
    //

    hr = BuildLDAPPathFromADsPath2(
             _Parent,
             &pszLDAPServer,
             &pszLDAPDn,
             &dwPort
             );
    BAIL_ON_FAILURE(hr);

    //
    // Make the old schema obsolete so we will get the new schema next
    // time we asked for it.
    // We cannot delete the old schema since other objects might have
    // references to it.
    //
    hr = LdapMakeSchemaCacheObsolete(
             pszLDAPServer,
             _Credentials,
             _dwPort
             );
    BAIL_ON_FAILURE(hr);

error:

    if (pszLDAPServer) {

        FreeADsStr(pszLDAPServer);
    }

    if (pszLDAPDn) {
        FreeADsStr(pszLDAPDn);
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::GetInfo(THIS)
{
    HRESULT hr = S_OK;
    VARIANT var;
    BOOL fUmiCall = FALSE;

    LPWSTR pszLDAPServer = NULL;
    LPWSTR pszLDAPDn = NULL;
    DWORD dwPort = 0;

    VariantInit(&var);
    if ( GetObjectState() == ADS_OBJECT_UNBOUND )
        RRETURN(E_ADS_OBJECT_UNBOUND);

    //
    // Update the umicall flag - we need to add items to prop cache
    // if the call is from Umi.
    //
    fUmiCall = _Credentials.GetAuthFlags() & ADS_AUTH_RESERVED;
    
    //
    // Get the server name
    //

    hr = BuildLDAPPathFromADsPath2(
             _Parent,
             &pszLDAPServer,
             &pszLDAPDn,
             &dwPort
             );
    BAIL_ON_FAILURE(hr);


    //
    // AjayR - 04-05-99 do not understand why this is done
    // I do not think you need to obsolete the cache on the
    // GetInfo for a class - for the schema container yes.
    //
    hr = LdapMakeSchemaCacheObsolete(
             pszLDAPServer,
             _Credentials,
             dwPort
             );
    BAIL_ON_FAILURE(hr);

    //
    // Release the original schema info
    //
    SchemaClose( &_hSchema );

    //
    // Get the new schema info
    //
    hr = SchemaOpen(
                pszLDAPServer,
                &_hSchema,
                _Credentials,
                _dwPort             // IsGCNamespace(_Parent)
                );
    BAIL_ON_FAILURE(hr);

    //
    // Find the new class info
    //

    hr = SchemaGetClassInfo(
             _hSchema,
             _Name,
             &_pClassInfo );

    BAIL_ON_FAILURE( hr );

    if ( _pClassInfo == NULL )
    {
        // Class name not found, set error

        hr = E_ADS_BAD_PATHNAME;
        BAIL_ON_FAILURE(hr);
    }

    _pPropertyCache->flushpropertycache();

    hr = put_BSTR_Property( this, TEXT("governsID"), _pClassInfo->pszOID);
    BAIL_ON_FAILURE(hr);

    hr = put_LONG_Property( this, TEXT("objectClassCategory"),
                            _pClassInfo->dwType );
    BAIL_ON_FAILURE(hr);

    hr = MakeVariantFromPropStringTable( _pClassInfo->pOIDsMustContain,
                                         _hSchema, &var );
    BAIL_ON_FAILURE(hr);
    hr = put_VARIANT_Property( this, TEXT("mustContain"), var );
    BAIL_ON_FAILURE(hr);
    if (fUmiCall) {
        //
        // Add as mandatoryProperties to cache.
        //
        hr = put_VARIANT_Property( this, TEXT("mandatoryProperties"), var );
        BAIL_ON_FAILURE(hr);

        hr = put_BSTR_Property( this, TEXT("Name"), this->_Name);
        BAIL_ON_FAILURE(hr);
    }
    VariantClear( &var );

    hr = MakeVariantFromPropStringTable( _pClassInfo->pOIDsMayContain,
                                         _hSchema, &var );
    BAIL_ON_FAILURE(hr);
    hr = put_VARIANT_Property( this, TEXT("mayContain"), var );
    BAIL_ON_FAILURE(hr);
    if (fUmiCall) {
        //
        // Add to the cache as optionalProperties.
        //
        hr = put_VARIANT_Property( this, TEXT("optionalProperties"), var );
        BAIL_ON_FAILURE(hr);
    }
    VariantClear( &var );

    hr = MakeVariantFromStringArray( _pClassInfo->pOIDsSuperiorClasses, &var );
    BAIL_ON_FAILURE(hr);

    hr = put_VARIANT_Property( this, TEXT("subClassOf"), var );
    BAIL_ON_FAILURE(hr);
    VariantClear( &var );

    hr = MakeVariantFromStringArray( _pClassInfo->pOIDsAuxClasses, &var );
    BAIL_ON_FAILURE(hr);

    hr = put_VARIANT_Property( this, TEXT("auxiliaryClass"), var );
    BAIL_ON_FAILURE(hr);
    VariantClear( &var );

    if (_fNTDS) {
        //
        // Read the extra NTDS specific schema properties.
        //
        hr = GetNTDSSchemaInfo(TRUE);
        BAIL_ON_FAILURE(hr);
    }

    _pPropertyCache->ClearAllPropertyFlags();
    _pPropertyCache->setGetInfoFlag();

error:

    if (pszLDAPServer) {
        FreeADsStr(pszLDAPServer);
    }

    if (pszLDAPDn) {
        FreeADsStr(pszLDAPDn);
    }

    VariantClear(&var);

    RRETURN_EXP_IF_ERR(hr);   // All current information are in _pClassInfo
}

//
// This routine is called only when the server is AD.
//
HRESULT
CLDAPClass::GetNTDSSchemaInfo(
    BOOL fForce
    )
{
    HRESULT hr = S_OK;
    LPTSTR aStrings[] = {
        TEXT("cn"),
        TEXT("displaySpecification"),
        TEXT("schemaIDGUID"),
        TEXT("possibleInferiors"),
        TEXT("rDNAttid"),
        TEXT("possSuperiors"),
        TEXT("systemPossSuperiors"),
        NULL
    };

    LDAPMessage *res = NULL;


    if (_pszLDAPDn == NULL) {
        //
        // Need to get the dn for this object and also 
        // the attributes we are interested in.
        //
        hr = BuildSchemaLDAPPathAndGetAttribute(
                 _Parent,
                 _Name,
                 ((SCHEMAINFO*)_hSchema)->pszSubSchemaSubEntry,
                 _pClassInfo == NULL,
                 _Credentials,
                 aStrings,
                 &_pszLDAPServer,
                 &_pszLDAPDn,
                 &_ld,
                 &res
                 );

    }
    else {
        //
        // Looks like we just need the attributes in this case.
        //
        hr = LdapSearchS(
                 _ld,
                 _pszLDAPDn,
                 LDAP_SCOPE_BASE,
                 L"(objectClass=*)",
                 aStrings,
                 FALSE,
                 &res
                 );
    }
        
    BAIL_ON_FAILURE(hr);

    //
    // If we succeeded we should unmarshall properties into the cache.
    //
    hr = _pPropertyCache->LDAPUnMarshallProperties(
             _pszLDAPServer,
             _ld,
             res,
             fForce,
             _Credentials
             );
    BAIL_ON_FAILURE(hr);

    _pPropertyCache->setGetInfoFlag();

error:

    if (res) {
        LdapMsgFree(res);
    }

    RRETURN(hr);
}

//
// Helper function for Umi - defined in CCoreADsObject.
//
STDMETHODIMP
CLDAPClass::GetInfo(DWORD dwFlags)
{
    HRESULT hr = S_OK;
    
    if (dwFlags ==  GETINFO_FLAG_EXPLICIT) {
        RRETURN(GetInfo());
    } 
    else {
        //
        // Read NTDS info if this is not an implicit as needed call.
        // That is this just a regular implicit GetInfo.
        //
        if (_fNTDS
            && dwFlags != GETINFO_FLAG_IMPLICIT_AS_NEEDED
            ) {
            //
            // Read the extra NTDS specific schema properties.
            //
            hr = GetNTDSSchemaInfo(FALSE);
        }   
    }

    RRETURN(hr);
}

STDMETHODIMP
CLDAPClass::Get(THIS_ BSTR bstrName, VARIANT FAR* pvProp)
{
    HRESULT hr = S_OK;
    DWORD dwSyntaxId;
    LDAPOBJECTARRAY ldapSrcObjects;
    DWORD dwStatus = 0;

    LDAPOBJECTARRAY_INIT(ldapSrcObjects);

    //
    // For folks who know now what they do.
    //
    if (!pvProp) {
        BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
    }

    //
    // retrieve data object from cache; if one exists
    //

    if ( GetObjectState() == ADS_OBJECT_UNBOUND ) {

        hr = _pPropertyCache->unboundgetproperty(
                    bstrName,
                    &dwSyntaxId,
                    &dwStatus,
                    &ldapSrcObjects
                    );

        // For backward compatibility
        if (!ldapSrcObjects.pLdapObjects && SUCCEEDED(hr)) {
            hr = E_FAIL;
        }

    } else {

        hr = _pPropertyCache->getproperty(
                    bstrName,
                    &dwSyntaxId,
                    &dwStatus,
                    &ldapSrcObjects
                    );

        // For backward compatibility
        if (!ldapSrcObjects.pLdapObjects && SUCCEEDED(hr)) {
            hr = E_ADS_PROPERTY_NOT_FOUND;
        }

    }

    BAIL_ON_FAILURE(hr);

    //
    // translate the Ldap objects to variants
    //

    if ( ldapSrcObjects.dwCount == 1 ) {

        hr = LdapTypeToVarTypeCopy(
                 _pszLDAPServer,
                 _Credentials,
                 ldapSrcObjects.pLdapObjects,
                 dwSyntaxId,
                 pvProp
                 );
    } else {

        hr = LdapTypeToVarTypeCopyConstruct(
                 _pszLDAPServer,
                 _Credentials,
                 ldapSrcObjects,
                 dwSyntaxId,
                 pvProp
                 );
    }
    BAIL_ON_FAILURE(hr);

error:

    LdapTypeFreeLdapObjects( &ldapSrcObjects );

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::Put(THIS_ BSTR bstrName, VARIANT vProp)
{
    HRESULT hr = S_OK;
    DWORD dwSyntaxId = 0;

    DWORD dwIndex = 0;
    LDAPOBJECTARRAY ldapDestObjects;

    DWORD dwNumValues = 0;
    VARIANT * pVarArray = NULL;
    VARIANT * pvProp = NULL;
    VARIANT vDefProp;

    VariantInit(&vDefProp);

    LDAPOBJECTARRAY_INIT(ldapDestObjects);

    hr = SchemaGetSyntaxOfAttribute( _hSchema, bstrName, &dwSyntaxId );
    if (FAILED(hr)) {
        //
        // Need to see if this is either mandatoryProperties or
        // OptionalProperties that we special case for Umi Objects.
        //
        if (!_wcsicmp(L"mandatoryProperties", bstrName)
            || !_wcsicmp(L"optionalProperties", bstrName)
            ) {
            dwSyntaxId = LDAPTYPE_CASEIGNORESTRING;
            hr = S_OK;
        }
    }

    BAIL_ON_FAILURE(hr);

    if ( dwSyntaxId == LDAPTYPE_UNKNOWN )
    {
        hr = E_ADS_CANT_CONVERT_DATATYPE;
        BAIL_ON_FAILURE(hr);
    }

    //
    // A VT_BYREF|VT_VARIANT may expand to a VT_VARIANT|VT_ARRAY.
    // We should dereference a VT_BYREF|VT_VARIANT once and see
    // what's inside.
    //
    pvProp = &vProp;
    if (V_VT(pvProp) == (VT_BYREF|VT_VARIANT)) {
        pvProp = V_VARIANTREF(&vProp);
    }

    if ((V_VT(pvProp) == (VT_VARIANT|VT_ARRAY|VT_BYREF)) ||
    (V_VT(pvProp) == (VT_VARIANT|VT_ARRAY))) {

        hr  = ConvertSafeArrayToVariantArray(
                    *pvProp,
                    &pVarArray,
                    &dwNumValues
                    );
        // returns E_FAIL if *pvProp is invalid
        if (hr == E_FAIL)
            hr = E_ADS_BAD_PARAMETER;                 
        BAIL_ON_FAILURE(hr);
        pvProp = pVarArray;

    } else {

        //
        // If pvProp is a reference to a fundamental type, we
        // have to derefernce it once.
        //
        if (V_ISBYREF(pvProp)) {
            hr = VariantCopyInd(&vDefProp, pvProp);
            BAIL_ON_FAILURE(hr);
            pvProp = &vDefProp;
        }
        dwNumValues = 1;
    }


#if 0
    //
    // check if this is a legal property for this object,
    //

    hr = ValidatePropertyinCache(
                szLDAPTreeName,
                _ADsClass,
                bstrName,
                &dwSyntaxId
                );
    BAIL_ON_FAILURE(hr);
#endif

    //
    // check if the variant maps to the syntax of this property
    //

    if ( dwNumValues > 0 )
    {
        hr = VarTypeToLdapTypeCopyConstruct(
                 _pszLDAPServer,
                 _Credentials,
                 dwSyntaxId,
                 pvProp,
                 dwNumValues,
                 &ldapDestObjects
                 );
        BAIL_ON_FAILURE(hr);
    }

    //
    // Find this property in the cache
    //

    hr = _pPropertyCache->findproperty(
                        bstrName,
                        &dwIndex
                        );

    //
    // If this property does not exist in the
    // cache, add this property into the cache.
    //


    if (FAILED(hr)) {

        hr = _pPropertyCache->addproperty( bstrName );

        BAIL_ON_FAILURE(hr);
    }

    //
    // Now update the property in the cache
    //
    hr = _pPropertyCache->putproperty(
                    bstrName,
                    PROPERTY_UPDATE,
                    dwSyntaxId,
                    ldapDestObjects
                    );

    BAIL_ON_FAILURE(hr);

error:

    VariantClear(&vDefProp);

    LdapTypeFreeLdapObjects( &ldapDestObjects );

    if (pVarArray) {

        DWORD i = 0;

        for (i = 0; i < dwNumValues; i++) {
            VariantClear(pVarArray + i);
        }
        FreeADsMem(pVarArray);
    }

    RRETURN_EXP_IF_ERR(hr);
}


STDMETHODIMP
CLDAPClass::GetEx(THIS_ BSTR bstrName, VARIANT FAR* pvProp)
{
    HRESULT hr = S_OK;
    DWORD dwSyntaxId;
    LDAPOBJECTARRAY ldapSrcObjects;
    DWORD dwStatus = 0;

    LDAPOBJECTARRAY_INIT(ldapSrcObjects);

    //
    // For those who know no not what they do
    //
    if (!pvProp) {
        BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
    }

    //
    // retrieve data object from cache; if one exists
    //

    if ( GetObjectState() == ADS_OBJECT_UNBOUND ) {

        hr = _pPropertyCache->unboundgetproperty(
                    bstrName,
                    &dwSyntaxId,
                    &dwStatus,
                    &ldapSrcObjects
                    );

        // For backward compatibility
        if (!ldapSrcObjects.pLdapObjects && SUCCEEDED(hr)) {
            hr = E_FAIL;
        }

    } else {

        hr = _pPropertyCache->getproperty(
                    bstrName,
                    &dwSyntaxId,
                    &dwStatus,
                    &ldapSrcObjects
                    );

        // For backward compatibility
        if (!ldapSrcObjects.pLdapObjects && SUCCEEDED(hr)) {
            hr = E_ADS_PROPERTY_NOT_FOUND;
        }

    }

    BAIL_ON_FAILURE(hr);

    //
    // translate the Ldap objects to variants
    //

    hr = LdapTypeToVarTypeCopyConstruct(
             _pszLDAPServer,
             _Credentials,
             ldapSrcObjects,
             dwSyntaxId,
             pvProp
             );
    BAIL_ON_FAILURE(hr);

error:

    LdapTypeFreeLdapObjects( &ldapSrcObjects );

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::PutEx(THIS_ long lnControlCode, BSTR bstrName, VARIANT vProp)
{
    HRESULT hr = S_OK;
    DWORD dwSyntaxId = 0;
    DWORD dwFlags = 0;

    DWORD dwIndex = 0;
    LDAPOBJECTARRAY ldapDestObjects;

    DWORD dwNumValues = 0;
    VARIANT * pVarArray = NULL;
    VARIANT * pvProp = NULL;

    LDAPOBJECTARRAY_INIT(ldapDestObjects);

    switch (lnControlCode) {
    case ADS_PROPERTY_CLEAR:
        dwFlags = PROPERTY_DELETE;
        break;

    case ADS_PROPERTY_UPDATE:
        dwFlags = PROPERTY_UPDATE;
        break;

    default:
       RRETURN(hr = E_ADS_BAD_PARAMETER);

    }

    hr = SchemaGetSyntaxOfAttribute( _hSchema, bstrName, &dwSyntaxId );
    BAIL_ON_FAILURE(hr);

    if ( dwSyntaxId == LDAPTYPE_UNKNOWN )
    {
        hr = E_ADS_CANT_CONVERT_DATATYPE;
        BAIL_ON_FAILURE(hr);
    }

#if 0
    //
    // check if this is a legal property for this object,
    //

    hr = ValidatePropertyinCache(
                szLDAPTreeName,
                _ADsClass,
                bstrName,
                &dwSyntaxId
                );
    BAIL_ON_FAILURE(hr);
#endif

    if ( dwFlags != PROPERTY_DELETE )
    {

    //
    // A VT_BYREF|VT_VARIANT may expand to a VT_VARIANT|VT_ARRAY.
    // We should dereference a VT_BYREF|VT_VARIANT once and see
    // what's inside.
    //
    pvProp = &vProp;
    if (V_VT(pvProp) == (VT_BYREF|VT_VARIANT)) {
        pvProp = V_VARIANTREF(&vProp);
    }

        if ((V_VT(pvProp) == (VT_VARIANT|VT_ARRAY|VT_BYREF)) ||
        (V_VT(pvProp) ==  (VT_VARIANT|VT_ARRAY))) {

            hr  = ConvertSafeArrayToVariantArray(
                      *pvProp,
                      &pVarArray,
                      &dwNumValues
                      );
            // returns E_FAIL if *pvProp is invalid
            if (hr == E_FAIL)
                hr = E_ADS_BAD_PARAMETER;           
            BAIL_ON_FAILURE(hr);
            pvProp = pVarArray;

        } else {

            hr = E_FAIL;
            BAIL_ON_FAILURE(hr);
        }

        //
        // check if the variant maps to the syntax of this property
        //

        if ( dwNumValues > 0 )
        {
            hr = VarTypeToLdapTypeCopyConstruct(
                     _pszLDAPServer,
                     _Credentials,
                     dwSyntaxId,
                     pvProp,
                     dwNumValues,
                     &ldapDestObjects
                     );
            BAIL_ON_FAILURE(hr);
        }
    }

    //
    // Find this property in the cache
    //

    hr = _pPropertyCache->findproperty(
                        bstrName,
                        &dwIndex
                        );

    //
    // If this property does not exist in the
    // cache, add this property into the cache.
    //


    if (FAILED(hr)) {

        hr = _pPropertyCache->addproperty( bstrName );

        BAIL_ON_FAILURE(hr);

    }

    //
    // Now update the property in the cache
    //
    hr = _pPropertyCache->putproperty(
                    bstrName,
                    PROPERTY_UPDATE,
                    dwSyntaxId,
                    ldapDestObjects
                    );

    BAIL_ON_FAILURE(hr);

error:

    LdapTypeFreeLdapObjects( &ldapDestObjects );

    if (pVarArray) {

        DWORD i = 0;

        for (i = 0; i < dwNumValues; i++) {
            VariantClear(pVarArray + i);
        }
        FreeADsMem(pVarArray);
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::GetInfoEx(THIS_ VARIANT vProperties, long lnReserved)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

/* IADsContainer methods */

/* IADsClass methods */


HRESULT
CLDAPClass::LoadInterfaceInfo(void)
{
    HRESULT hr = S_OK;
    BSTR bstrTmp = NULL;

    if ( _pClassInfo )  {
    
        GUID *pPrimaryInterfaceGUID = NULL;
        GUID *pCLSID = NULL;

        hr = SchemaGetPrimaryInterface( _hSchema,
                                        _Name,
                                        &pPrimaryInterfaceGUID,
                                        &pCLSID );

        if ( pPrimaryInterfaceGUID == NULL )
            pPrimaryInterfaceGUID = (GUID *) &IID_IADs;

        //
        // Set the primary interface string
        //

        hr = StringFromCLSID((REFCLSID)*(pPrimaryInterfaceGUID),
                             &bstrTmp );
        BAIL_ON_FAILURE(hr);

        hr = ADsAllocString( bstrTmp,
                             &_bstrPrimaryInterface);
        BAIL_ON_FAILURE(hr);

        CoTaskMemFree(bstrTmp);
        bstrTmp = NULL;

        if ( pCLSID )
        {
            //
            // Set the CLSID string
            //

            hr = StringFromCLSID( (REFCLSID) *(pCLSID),
                                   &bstrTmp );
            BAIL_ON_FAILURE(hr);

            hr = ADsAllocString( bstrTmp,
                                   &_bstrCLSID );

            BAIL_ON_FAILURE(hr);

            CoTaskMemFree(bstrTmp);
            bstrTmp = NULL;
        }
    }

error:

    if ( bstrTmp != NULL )
        CoTaskMemFree(bstrTmp);

    RRETURN(hr);
}


STDMETHODIMP
CLDAPClass::get_PrimaryInterface( THIS_ BSTR FAR *pbstrGUID )
{
    HRESULT hr;

    if ( !pbstrGUID )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    if (!_fLoadedInterfaceInfo) {
        hr = LoadInterfaceInfo();
        BAIL_ON_FAILURE(hr);
        
        _fLoadedInterfaceInfo = TRUE;
    }
    
    hr = ADsAllocString(
                 _bstrPrimaryInterface? _bstrPrimaryInterface : TEXT(""),
                 pbstrGUID );

error:

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_CLSID( THIS_ BSTR FAR *pbstrCLSID )
{
    HRESULT hr;

    if ( !pbstrCLSID )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    if (!_fLoadedInterfaceInfo) {
        hr = LoadInterfaceInfo();
        BAIL_ON_FAILURE(hr);
        
        _fLoadedInterfaceInfo = TRUE;
    }

    hr = ADsAllocString( _bstrCLSID? _bstrCLSID: TEXT(""), pbstrCLSID );

error:

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_CLSID( THIS_ BSTR bstrCLSID )
{
    RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}

STDMETHODIMP
CLDAPClass::get_OID( THIS_ BSTR FAR *retval )
{
    if ( !retval )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    HRESULT hr;

    if ( _fNTDS )
    {
        GET_PROPERTY_BSTR( this, governsID );
    }
    else if ( _pClassInfo )
    {
        hr = ADsAllocString( _pClassInfo->pszOID?
                                   _pClassInfo->pszOID : TEXT(""), retval );
    RRETURN_EXP_IF_ERR(hr);
    }
    else
    {
        hr = ADsAllocString( TEXT(""), retval );
    RRETURN_EXP_IF_ERR(hr);
    }
}

STDMETHODIMP
CLDAPClass::put_OID( THIS_ BSTR bstrOID )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR(E_NOTIMPL);

    HRESULT hr = put_BSTR_Property( this, TEXT("governsID"), bstrOID );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_Abstract( THIS_ VARIANT_BOOL FAR *pfAbstract )
{
    if ( !pfAbstract )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    HRESULT hr = S_OK;
    long lClassType = CLASS_TYPE_STRUCTURAL;  // by default

    if ( _fNTDS )
    {
        hr = get_LONG_Property( this, TEXT("objectClassCategory"),
                                &lClassType );
        BAIL_ON_FAILURE(hr);
    }
    else if ( _pClassInfo )
    {
        lClassType = _pClassInfo->dwType;
    }

    *pfAbstract = lClassType == CLASS_TYPE_ABSTRACT ?
                      VARIANT_TRUE : VARIANT_FALSE;

error:

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_Abstract( THIS_ VARIANT_BOOL fAbstract )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    long lClassType;
    HRESULT hr = get_LONG_Property( this, TEXT("objectClassCategory"),
                                    &lClassType );
    if ( SUCCEEDED(hr))
    {
        if (  ( fAbstract && lClassType == CLASS_TYPE_ABSTRACT )
           || ( !fAbstract && lClassType != CLASS_TYPE_ABSTRACT )
           )
        {
            RRETURN(S_OK);  // Nothing to set
        }
    }

    hr = put_LONG_Property( (IADs *) this,
                            TEXT("objectClassCategory"),
                            fAbstract? CLASS_TYPE_ABSTRACT
                                     : CLASS_TYPE_STRUCTURAL );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_Auxiliary( THIS_ VARIANT_BOOL FAR *pfAuxiliary )
{
    if ( !pfAuxiliary )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    HRESULT hr = S_OK;
    long lClassType = CLASS_TYPE_STRUCTURAL;  // by default

    if ( _fNTDS )
    {
        hr = get_LONG_Property( this, TEXT("objectClassCategory"),
                                &lClassType );
        BAIL_ON_FAILURE(hr);
    }
    else if ( _pClassInfo )
    {
        lClassType = _pClassInfo->dwType;
    }

    *pfAuxiliary = lClassType == CLASS_TYPE_AUXILIARY ?
                       VARIANT_TRUE : VARIANT_FALSE;

error:

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_Auxiliary( THIS_ VARIANT_BOOL fAuxiliary )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    long lClassType = CLASS_TYPE_STRUCTURAL;
    HRESULT hr = get_LONG_Property( this, TEXT("objectClassCategory"),
                                    &lClassType );
    if ( SUCCEEDED(hr))
    {
        if (  ( fAuxiliary && lClassType == CLASS_TYPE_AUXILIARY )
           || ( !fAuxiliary && lClassType != CLASS_TYPE_AUXILIARY )
           )
        {
            RRETURN(S_OK);  // Nothing to set
        }
    }

    hr = put_LONG_Property( (IADs *) this,
                            TEXT("objectClassCategory"),
                            fAuxiliary? CLASS_TYPE_AUXILIARY
                                      : CLASS_TYPE_STRUCTURAL );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_MandatoryProperties( THIS_ VARIANT FAR *retval )
{
    HRESULT hr = S_OK;

    if ( !retval )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    VariantInit( retval );

    if ( _fNTDS )
    {
        GET_PROPERTY_VARIANT( this, mustContain );
    }
    else if ( _pClassInfo )
    {
        hr = MakeVariantFromPropStringTable( _pClassInfo->pOIDsMustContain,
                                             _hSchema,
                                             retval );
    }
    else
    {
        hr = MakeVariantFromStringArray( NULL,
                                         retval );
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_MandatoryProperties( THIS_ VARIANT vMandatoryProperties )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    HRESULT hr = put_VARIANT_Property( this, TEXT("mustContain"),
                                       vMandatoryProperties );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_OptionalProperties( THIS_ VARIANT FAR *retval )
{
    HRESULT hr = S_OK;

    if ( !retval )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    VariantInit( retval );

    if ( _fNTDS )
    {
        GET_PROPERTY_VARIANT( this, mayContain );
    }
    else if ( _pClassInfo )
    {
        hr = MakeVariantFromPropStringTable( _pClassInfo->pOIDsMayContain,
                                             _hSchema,
                                             retval );
    }
    else
    {
        hr = MakeVariantFromStringArray( NULL,
                                         retval );
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_OptionalProperties( THIS_ VARIANT vOptionalProperties )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    HRESULT hr = put_VARIANT_Property( this, TEXT("mayContain"),
                                       vOptionalProperties );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_NamingProperties( THIS_ VARIANT FAR *pvNamingProperties )
{
    HRESULT hr = S_OK;

    if ( !pvNamingProperties )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    VariantInit( pvNamingProperties );

    hr = get_VARIANT_Property( this, TEXT("rDNAttId"), pvNamingProperties );

    if ( SUCCEEDED(hr) )
        RRETURN(hr);

    hr = get_NTDSProp_Helper( TEXT("rDNAttId"), pvNamingProperties );
    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_NamingProperties( THIS_ VARIANT vNamingProperties )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    HRESULT hr = put_VARIANT_Property( this, TEXT("rDNAttId"),
                                       vNamingProperties );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_DerivedFrom( THIS_ VARIANT FAR *retval )
{
    HRESULT hr = S_OK;

    if ( !retval )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    VariantInit( retval );

    if ( _fNTDS )
    {
        GET_PROPERTY_VARIANT( this, subClassOf );
    }
    else if ( _pClassInfo )
    {
        hr = MakeVariantFromStringArray( _pClassInfo->pOIDsSuperiorClasses,
                                         retval );
    }
    else
    {
        hr = MakeVariantFromStringArray( NULL,
                                         retval );
    }

    RRETURN_EXP_IF_ERR(hr);

}

STDMETHODIMP
CLDAPClass::put_DerivedFrom( THIS_ VARIANT vDerivedFrom )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    HRESULT hr = put_VARIANT_Property( this, TEXT("subClassOf"),
                                       vDerivedFrom );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_AuxDerivedFrom( THIS_ VARIANT FAR *retval )
{
    HRESULT hr = S_OK;

    if ( !retval )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    VariantInit( retval );

    if ( _fNTDS )
    {
        GET_PROPERTY_VARIANT( this, auxiliaryClass );
    }
    else if ( _pClassInfo )
    {
        hr = MakeVariantFromStringArray( _pClassInfo->pOIDsAuxClasses,
                                         retval );
    }
    else
    {
        hr = MakeVariantFromStringArray( NULL,
                                         retval );
    }

    RRETURN_EXP_IF_ERR(hr);

}

STDMETHODIMP
CLDAPClass::put_AuxDerivedFrom( THIS_ VARIANT vAuxDerivedFrom )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    HRESULT hr = put_VARIANT_Property( this, TEXT("auxiliaryClass"),
                                       vAuxDerivedFrom );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_PossibleSuperiors( THIS_ VARIANT FAR *pvPossSuperiors)
{
    HRESULT hr = S_OK;
    VARIANT vSysPossSuperiors;
    DWORD dwSyntaxId;
    DWORD dwStatus = 0;
    // Boolean values used to indicate if the values exist
    BOOL fpossSuperiors = FALSE;
    BOOL fsysPossSuperiors = FALSE;

    // Used in case we need a union of the values
    LDAPOBJECTARRAY ldapSrcObjects1;
    LDAPOBJECTARRAY ldapSrcObjects2;

    LDAPOBJECTARRAY_INIT(ldapSrcObjects1);
    LDAPOBJECTARRAY_INIT(ldapSrcObjects2);

    VariantInit(&vSysPossSuperiors);

    if ( !pvPossSuperiors )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    VariantInit( pvPossSuperiors );

    hr = get_VARIANT_Property( this, TEXT("possSuperiors"), pvPossSuperiors );

    if ( SUCCEEDED(hr) ){
        fpossSuperiors = TRUE;
    }

    hr = get_VARIANT_Property(
             this, TEXT("systemPossSuperiors"), &vSysPossSuperiors
             );
    if (SUCCEEDED(hr)) {
        fsysPossSuperiors = TRUE;
    }

    if (!fpossSuperiors) {
        hr = get_NTDSProp_Helper( TEXT("possSuperiors"), pvPossSuperiors );
        if (SUCCEEDED(hr)) {
            fpossSuperiors = TRUE;
        }
    }

    if (!fsysPossSuperiors) {
        hr = get_NTDSProp_Helper(
                 TEXT("systemPossSuperiors"), &vSysPossSuperiors
                 );
        if (SUCCEEDED(hr)) {
            fsysPossSuperiors = TRUE;
        }
    }

    // Now if both are true, we need to do a union
    if (fpossSuperiors && fsysPossSuperiors) {
        // need to do the union
        // it is easier for me to handle strings in the ldap format
        // than to handle them as variants as there are helpers available
        // for that already
        hr = _pPropertyCache->unboundgetproperty(
                                  L"possSuperiors",
                                  &dwSyntaxId,
                                  &dwStatus,
                                  &ldapSrcObjects1
                                  );

        // No compatibility -- below it resets hr

        if (hr == E_FAIL) {
            hr = S_OK;
        }

        BAIL_ON_FAILURE(hr);

        hr = _pPropertyCache->unboundgetproperty(
                                  L"systemPossSuperiors",
                                  &dwSyntaxId,
                                  &dwStatus,
                                  &ldapSrcObjects2
                                  );

        // No compatibility -- below it resets hr

        if (hr == E_FAIL) {
            hr = S_OK;
        }

        BAIL_ON_FAILURE(hr);

        // Clear them as we no longer need the data here
        VariantClear(pvPossSuperiors);
        VariantClear(&vSysPossSuperiors);

        hr = makeUnionVariantFromLdapObjects(
                 ldapSrcObjects1,
                 ldapSrcObjects2,
                 pvPossSuperiors
                 );

        BAIL_ON_FAILURE(hr);

    }
    else if (fpossSuperiors || fsysPossSuperiors) {
        // return the appropriate value in the variant
        if (fsysPossSuperiors) {
            hr = VariantCopy(pvPossSuperiors, &vSysPossSuperiors);
            VariantClear(&vSysPossSuperiors);
            BAIL_ON_FAILURE(hr);
        }
    }

error:

    LdapTypeFreeLdapObjects(&ldapSrcObjects1);
    LdapTypeFreeLdapObjects(&ldapSrcObjects2);

    // this will make sure we handle fall through correctly

    if (SUCCEEDED(hr)) {
        RRETURN(hr);
    }

    VariantClear(pvPossSuperiors);
    VariantClear(&vSysPossSuperiors);

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_PossibleSuperiors( THIS_ VARIANT vPossSuperiors)
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    HRESULT hr = put_VARIANT_Property( this, TEXT("possSuperiors"),
                                       vPossSuperiors);

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::get_Containment( THIS_ VARIANT *pvContainment )
{
    HRESULT hr = S_OK;
    LPTSTR *aValues = NULL;

    if ( !pvContainment )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    VariantInit( pvContainment );

    //
    // This call will fetch possibleInferiors if necessary using
    // an implicit GetInfo. 
    //
    hr = GetEx(L"possibleInferiors", pvContainment);
   
    if (FAILED(hr) && 
        (hr == E_ADS_PROPERTY_NOT_FOUND)
        ) {
        //
        // In this case we need to return an empty array 
        //
        hr = MakeVariantFromStringArray(
                 aValues,
                 pvContainment
                 );
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_Containment( THIS_ VARIANT vContainment)
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}

STDMETHODIMP
CLDAPClass::get_Container( THIS_ VARIANT_BOOL FAR *pfContainer )
{

    HRESULT hr = S_OK;
    VARIANT vVar;
    
    if (!pfContainer) {
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);
    }

    *pfContainer = VARIANT_FALSE;

    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    VariantInit(&vVar);

    //
    // We now cache possibleInferiors as part of a GetInfo call.
    //
    hr = GetEx(L"possibleInferiors", &vVar);

    if (SUCCEEDED(hr)) {
        //
        // Need to see if there were any values and not just NULL.
        //
        if (V_VT(&vVar) != (VT_VARIANT | VT_ARRAY)) {
            //
            // Not the expected result has
            //
            *pfContainer = VARIANT_FALSE;
        } 
        else {
            //
            // Need to see how many elements are there.
            //
            LONG lnLBound = 0, lnUBound = 0;

            hr = SafeArrayGetUBound(
                     V_ARRAY(&vVar),
                     1,
                     &lnUBound
                     );
            if (SUCCEEDED(hr)) {
                hr = SafeArrayGetLBound(
                         V_ARRAY(&vVar),
                         1,
                         &lnLBound
                         );
                if (SUCCEEDED(hr)) {
                    //
                    // Check the length and make sure it is not 0 vals.
                    //
                    if ((lnUBound - lnLBound) + 1) {
                        *pfContainer = VARIANT_TRUE;
                    }
                } 
                else {
                    //
                    // Default to not container in this case
                    //  
                    *pfContainer = VARIANT_FALSE;
                }
            }

            hr = S_OK;
        }

        // we need to release the memory in vVar
        VariantClear(&vVar);
        
    } 
    else if (FAILED(hr) 
             && (hr == E_ADS_PROPERTY_NOT_FOUND)
             ) {
        *pfContainer = VARIANT_FALSE;
        hr = S_OK;
    } 
    
    //
    // Anything other than these and we should return the
    // appropriate hr back.
    //

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_Container( THIS_ VARIANT_BOOL fContainer )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}

STDMETHODIMP
CLDAPClass::get_HelpFileName( THIS_ BSTR FAR *pbstrHelpFileName )
{
    if ( !pbstrHelpFileName )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    HRESULT hr;
    hr = ADsAllocString( _bstrHelpFileName?
                               _bstrHelpFileName: TEXT(""),
                               pbstrHelpFileName );
    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPClass::put_HelpFileName( THIS_ BSTR bstrHelpFile )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);

#if 0
    RRETURN( ADsReAllocString( &_bstrHelpFileName,
                                 bstrHelpFile? bstrHelpFile: TEXT("") ));
#endif
}

STDMETHODIMP
CLDAPClass::get_HelpFileContext( THIS_ long FAR *plHelpContext )
{
    if ( !plHelpContext )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    *plHelpContext = _lHelpFileContext;
    RRETURN(S_OK);
}

STDMETHODIMP
CLDAPClass::put_HelpFileContext( THIS_ long lHelpContext )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);

#if 0
    _lHelpFileContext = lHelpContext;
    RRETURN(S_OK);
#endif
}

STDMETHODIMP
CLDAPClass::Qualifiers(THIS_ IADsCollection FAR* FAR* ppQualifiers)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

HRESULT
CLDAPClass::AllocateClassObject(
    CCredentials& Credentials,
    CLDAPClass FAR * FAR * ppClass
    )
{

    CLDAPClass FAR  *pClass = NULL;
    CAggregatorDispMgr FAR *pDispMgr = NULL;
    CPropertyCache FAR *pPropertyCache = NULL;
    HRESULT hr = S_OK;

    pClass = new CLDAPClass();
    if ( pClass == NULL )
        hr = E_OUTOFMEMORY;
    BAIL_ON_FAILURE(hr);

    pDispMgr = new CAggregatorDispMgr(Credentials);
    if ( pDispMgr == NULL )
        hr = E_OUTOFMEMORY;
    BAIL_ON_FAILURE(hr);

    hr = pDispMgr->LoadTypeInfoEntry(
                            LIBID_ADs,
                            IID_IADs,
                            (IADs *) pClass,
                            DISPID_REGULAR );
    BAIL_ON_FAILURE(hr);

    hr = pDispMgr->LoadTypeInfoEntry(
                            LIBID_ADs,
                            IID_IADsClass,
                            (IADsClass *) pClass,
                            DISPID_REGULAR );
    BAIL_ON_FAILURE(hr);

    hr = CPropertyCache::createpropertycache(
                            (CCoreADsObject FAR *) pClass,
                            (IGetAttributeSyntax *) pClass,
                            &pPropertyCache
                            );

    BAIL_ON_FAILURE(hr);

    pDispMgr->RegisterPropertyCache(pPropertyCache);

    pClass->_Credentials = Credentials;
    pClass->_pDispMgr = pDispMgr;
    pClass->_pPropertyCache = pPropertyCache;
    *ppClass = pClass;

    RRETURN(hr);

error:

    delete pDispMgr;
    delete pClass;

    RRETURN_EXP_IF_ERR(hr);

}

HRESULT CLDAPClass::FindModifications(
    int    *pOIDs,
    DWORD  nNumOfOids,
    LPTSTR pszPropName,
    LDAPModW ***aMods,
    DWORD  *pdwNumOfMods
    )
{
    HRESULT hr = S_OK;
    int *pOIDsOld = _tcsicmp(pszPropName, TEXT("mustContain")) == 0
                        ? _pClassInfo->pOIDsMustContain
                        : _pClassInfo->pOIDsMayContain;
    DWORD i = 0;
    DWORD j = 0;
    DWORD k = 0;

    BOOL fReadProperty = FALSE;
    int *pOIDsCurrent = NULL;
    DWORD nNumOfOidsCurrent = 0;
    BOOL fFound = FALSE;

    LPTSTR *aValuesAdd = NULL;
    DWORD nValuesAdd = 0;
    DWORD nValuesAddTotal = 10;
    LPTSTR *aValuesRemove = NULL;
    DWORD nValuesRemove = 0;
    DWORD nValuesRemoveTotal = 10;
    DWORD nIndex = 0;
    LDAPMessage *res = NULL;
    LDAPMessage *e = NULL;
    LPTSTR aStrings[] = {
        TEXT("cn"),
        pszPropName,
        NULL
    };


    aValuesAdd = (LPTSTR *) AllocADsMem(sizeof(LPTSTR) * nValuesAddTotal );
    if ( aValuesAdd == NULL )
    {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    aValuesRemove = (LPTSTR *) AllocADsMem(sizeof(LPTSTR) * nValuesRemoveTotal);
    if ( aValuesRemove == NULL )
    {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    //
    // We need to find the differences between the properties that needs to be
    // set and the properties that is currently on the server.
    //

    while ((pOIDs[j] != -1) || (pOIDsOld[k] != -1))
    {
        if ( pOIDs[j] == pOIDsOld[k] )
        {
            // No changes here
            j++; k++;
        }
        else if (  ( pOIDsOld[k] == -1 )
                || ( ( pOIDs[j] != -1 ) && ( pOIDs[j] < pOIDsOld[k] ))
                )
        {
            //
            // A new property has been added.
            //
            if ( nValuesAdd == nValuesAddTotal )
            {
                aValuesAdd = (LPTSTR *) ReallocADsMem( aValuesAdd,
                                          sizeof(LPTSTR) * nValuesAddTotal,
                                          sizeof(LPTSTR) * nValuesAddTotal * 2 );
                if ( aValuesAdd == NULL )
                {
                    hr = E_OUTOFMEMORY;
                    BAIL_ON_FAILURE(hr);
                }
                nValuesAddTotal *= 2;
            }

            nIndex = (((SCHEMAINFO *)_hSchema)->aPropertiesSearchTable[pOIDs[j]]).nIndex;

            aValuesAdd[nValuesAdd++] =
                (((SCHEMAINFO *)_hSchema)->aProperties[nIndex]).pszPropertyName;

            j++;
        }
        else  // ( pOIDs[j] == -1 || pOIDs[j] > pOIDsOld[k] )
        {
            // Some property has been removed, we need to read the current class
            // set of "mayContain" or "mustContain" to make sure we
            // aren't removing any "systemMustContain" or "systemMayContain"
            // and we are not trying to remove any parent classes
            // may/mustContain

            if ( !fReadProperty )
            {
                LPTSTR *aValues = NULL;
                int nCount = 0;

                if ( _pszLDAPDn == NULL )
                {
                    hr = BuildSchemaLDAPPathAndGetAttribute(
                             _Parent,
                             _Name,
                             ((SCHEMAINFO*)_hSchema)->pszSubSchemaSubEntry,
                             _pClassInfo == NULL,
                             _Credentials,
                             aStrings,
                             &_pszLDAPServer,
                             &_pszLDAPDn,
                             &_ld,
                             &res
                             );
                    BAIL_ON_FAILURE(hr);

                    hr = LdapFirstEntry(
                                _ld,
                                res,
                                &e
                                );
                    BAIL_ON_FAILURE(hr);

                    hr = LdapGetValues(
                                _ld,
                                e,
                                pszPropName,
                                &aValues,
                                &nCount
                                );
                }

                else
                {
                    hr = LdapReadAttribute(
                               _pszLDAPServer,
                               _pszLDAPDn,
                               pszPropName,
                               &aValues,
                               &nCount,
                               _Credentials,
                               _dwPort
                               );
                }

                if ( hr == HRESULT_FROM_WIN32(ERROR_DS_NO_ATTRIBUTE_OR_VALUE) )
                {
                    hr = S_OK;
                }
                BAIL_ON_FAILURE(hr);

                fReadProperty = TRUE;

                if ( nCount > 0 )
                {
                    hr = MakePropArrayFromStringArray( aValues,
                                                       nCount,
                                                       (SCHEMAINFO *) _hSchema,
                                                       &pOIDsCurrent,
                                                       &nNumOfOidsCurrent );
                    LdapValueFree( aValues );
                    BAIL_ON_FAILURE(hr);
                }
            }

            //
            // See if we can find the property that we want to remove from.
            // We don't need to reset i since both arrays are sorted.
            //
            for ( fFound = FALSE; i < nNumOfOidsCurrent; i++ )
            {
                 if ( pOIDsOld[k] == pOIDsCurrent[i] )
                 {
                     fFound = TRUE;
                     break;
                 }
                 else if ( pOIDsOld[k] < pOIDsCurrent[i] )
                 {
                     // Both arrays are sorted, so we can break here
                     break;
                 }
            }

            if ( nNumOfOidsCurrent == 0 || !fFound )
            {
                int err = NO_ERROR;

                // This property is not in "mustContain" or "mayContain",
                // so nothing can be removed

                hr = E_ADS_SCHEMA_VIOLATION;
                BAIL_ON_FAILURE(hr);
            }

            //
            // Modify the request to remove the property here
            //
            if ( nValuesRemove == nValuesRemoveTotal )
            {
                aValuesRemove = (LPTSTR *) ReallocADsMem( aValuesRemove,
                                     sizeof(LPTSTR) * nValuesRemoveTotal,
                                     sizeof(LPTSTR) * nValuesRemoveTotal * 2 );
                if ( aValuesRemove == NULL )
                {
                    hr = E_OUTOFMEMORY;
                    BAIL_ON_FAILURE(hr);
                }
                nValuesRemoveTotal *= 2;
            }

            nIndex = (((SCHEMAINFO *)_hSchema)->aPropertiesSearchTable[pOIDsOld[k]]).nIndex;

            aValuesRemove[nValuesRemove++] =
                (((SCHEMAINFO *)_hSchema)->aProperties[nIndex]).pszPropertyName;

            k++;
        }
    }

    if ( nValuesAdd == 0 )
    {
        FreeADsMem( aValuesAdd );
        aValuesAdd = NULL;
    }

    if ( nValuesRemove == 0 )
    {
        FreeADsMem( aValuesRemove );
        aValuesRemove = NULL;
    }

    if ( aValuesAdd || aValuesRemove )
    {
        hr = AddModifyRequest(
                 aMods,
                 pdwNumOfMods,
                 pszPropName,
                 aValuesAdd,
                 aValuesRemove );
    }

error:

    if ( pOIDsCurrent )
        FreeADsMem( pOIDsCurrent );

    if (res)
        LdapMsgFree(res);

    if ( FAILED(hr))
    {
        if ( aValuesAdd )
            FreeADsMem( aValuesAdd );

        if ( aValuesRemove )
            FreeADsMem( aValuesRemove );
    }

    RRETURN_EXP_IF_ERR(hr);
}

HRESULT CLDAPClass::AddModifyRequest(
    LDAPModW ***aMods,
    DWORD    *pdwNumOfMods,
    LPTSTR   pszPropName,
    LPTSTR   *aValuesAdd,
    LPTSTR   *aValuesRemove
    )
{
    HRESULT hr = S_OK;
    LDAPModW *aModsBuffer = NULL;
    DWORD j = 0;
    DWORD nCount = 0;

    if ( aValuesAdd != NULL )
        nCount++;

    if ( aValuesRemove != NULL )
        nCount++;

    if ( nCount == 0 )
        RRETURN(S_OK);

    if ( *aMods == NULL )
    {
        *aMods = (LDAPModW **) AllocADsMem( (nCount + 1) * sizeof(LDAPModW *));

        if ( *aMods == NULL )
        {
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }

        aModsBuffer = (LDAPModW *) AllocADsMem( nCount * sizeof(LDAPModW));

        if ( aModsBuffer == NULL )
        {
            FreeADsMem( *aMods );
            *aMods = NULL;
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }
    }
    else
    {
        LDAPModW **aModsTemp = NULL;

        aModsTemp = (LDAPModW **) AllocADsMem(
                        (*pdwNumOfMods + nCount + 1) * sizeof(LDAPModW *));

        if ( aModsTemp == NULL )
        {
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }

        aModsBuffer = (LDAPModW *) AllocADsMem(
                          (*pdwNumOfMods + nCount) * sizeof(LDAPModW));

        if ( aModsBuffer == NULL )
        {
            FreeADsMem( aModsTemp );
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }

        memcpy( aModsBuffer, **aMods, *pdwNumOfMods * sizeof(LDAPModW));
        FreeADsMem( **aMods );
        FreeADsMem( *aMods );

        *aMods = aModsTemp;

        for ( j = 0; j < *pdwNumOfMods; j++ )
        {
            (*aMods)[j] = &aModsBuffer[j];
        }
    }

    if ( aValuesAdd )
    {
        (*aMods)[j] = &aModsBuffer[j];
        aModsBuffer[j].mod_type = pszPropName;
        aModsBuffer[j].mod_values = aValuesAdd;
        aModsBuffer[j].mod_op |= LDAP_MOD_ADD;
        j++;
    }

    if ( aValuesRemove )
    {
        (*aMods)[j] = &aModsBuffer[j];
        aModsBuffer[j].mod_type = pszPropName;
        aModsBuffer[j].mod_values = aValuesRemove;
        aModsBuffer[j].mod_op |= LDAP_MOD_DELETE;
    }

    *pdwNumOfMods += nCount;

error:

    RRETURN_EXP_IF_ERR(hr);

}

HRESULT
CLDAPClass::get_NTDSProp_Helper( THIS_ BSTR bstrName, VARIANT FAR *pvProp )
{
    HRESULT hr = S_OK;
    LPTSTR *aValues = NULL;
    int nCount = 0;
    LDAPMessage *res = NULL;
    LDAPMessage *e = NULL;
    LPTSTR aStrings[3];
    
    aStrings[0] = TEXT("cn");
    aStrings[1] = bstrName;
    aStrings[2] = NULL;

    if ( _pClassInfo == NULL )  // new class
    {
        hr = MakeVariantFromStringArray( NULL,
                                         pvProp );
        RRETURN_EXP_IF_ERR(hr);
    }

    //
    // If the dn is NULL we have not got the info so fetch it.
    //
    if (_pszLDAPDn == NULL )
    {
        hr = BuildSchemaLDAPPathAndGetAttribute(
                _Parent,
                _Name,
               ((SCHEMAINFO*)_hSchema)->pszSubSchemaSubEntry,
                _pClassInfo == NULL,
                _Credentials,
                aStrings,
                &_pszLDAPServer,
                &_pszLDAPDn,
                &_ld,
                &res
                );
        BAIL_IF_ERROR(hr);

        hr = LdapFirstEntry(
                _ld,
                res,
                &e
                );
        BAIL_IF_ERROR(hr);

        hr = LdapGetValues(
                _ld,
                e,
                bstrName,
                &aValues,
                &nCount
                );
    }

    else
    {
        hr = LdapReadAttribute(
                    _pszLDAPServer,
                    _pszLDAPDn,
                    bstrName,
                    &aValues,
                    &nCount,
                    _Credentials,
                    _dwPort
                    );
    }

    if ( hr == HRESULT_FROM_WIN32(ERROR_DS_NO_ATTRIBUTE_OR_VALUE) )
    {
        hr = NO_ERROR;
    }
    BAIL_IF_ERROR(hr);

    hr = MakeVariantFromStringArray( aValues,
                                     pvProp );
    BAIL_IF_ERROR(hr);

    hr = put_VARIANT_Property( this, bstrName, *pvProp );
    BAIL_IF_ERROR(hr);

    hr = _pPropertyCache->ClearPropertyFlag( bstrName );
    BAIL_IF_ERROR(hr);

cleanup:

    if ( aValues )
        LdapValueFree( aValues );

    if (res)
        LdapMsgFree(res);

    RRETURN_EXP_IF_ERR(hr);
}

//
// Needed for dynamic dispid's in the property cache.
//
HRESULT
CLDAPClass::GetAttributeSyntax(
    LPWSTR szPropertyName,
    PDWORD pdwSyntaxId
    )
{
    HRESULT hr;
    hr = LdapGetSyntaxOfAttributeOnServer(
         _pszLDAPServer,
         szPropertyName,
         pdwSyntaxId,
         _Credentials,
         _dwPort
         );

    RRETURN_EXP_IF_ERR(hr);
}

/* IUmiHelperPrivate support. */

//+---------------------------------------------------------------------------
// Function:   CLDAPClass::GetPropertiesHelper
//
// Synopsis:   Returns an array of PPROPERTYINFO that points to the
//          property definitions this class can hold.
//
// Arguments:  ppProperties    -   Ret values for the property info.
//             pdwCount        -   Ret value for the number of properties.
//
//
// Returns:    HRESULT - S_OK or any failure error code.
//
// Modifies:   ppProperties and pdwCount appropriately.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CLDAPClass::GetPropertiesHelper(
    void **ppProperties,
    PDWORD pdwPropCount
    )
{
    HRESULT hr = S_OK;
    PPROPERTYINFO *pPropArray = NULL;
    DWORD dwPropCount = 0;
    DWORD dwCtr;
    SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) _hSchema;

    //
    // Initialize out params to default values.
    //
    *pdwPropCount = 0;
    *ppProperties  = NULL;

    //
    // If there is no classInfo then we do not have any further processing
    // to do as there are no properties on this class.
    //
    if (!this->_pClassInfo) {
        RRETURN(E_FAIL);
    }
    
    //
    // We need to know how many entries are there in the list of properties.
    // The total is made up of both the mandatory and optional properties.
    // Note that we will adjust this value suitably as we process the array.
    // 
    dwPropCount = _pClassInfo->nNumOfMayContain 
                + _pClassInfo->nNumOfMustContain;                

    pPropArray = (PPROPERTYINFO *) AllocADsMem(
                     sizeof(PPROPERTY*) * dwPropCount
                     );
    if (!pPropArray) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    //
    // Go through and get the info for the must contain.
    //
    for (
         dwCtr = 0;
         ((dwCtr < (_pClassInfo->nNumOfMustContain))
         && (_pClassInfo->pOIDsMustContain[dwCtr] != -1));
         dwCtr++) 
        {
        //
        // Assign the appropriate prop info ptrs from the may contain list.
        //
        pPropArray[dwCtr] = &(pSchemaInfo->aProperties[
                             (pSchemaInfo->aPropertiesSearchTable[
                              _pClassInfo->pOIDsMustContain[dwCtr]].nIndex
                              )]);
    }

    DWORD dwAdjust;
    
    //
    // We could have less than the number in the array if we hit -1, or
    // -1 could be pointing correctly to the last element !!!
    //
    if ((_pClassInfo->pOIDsMustContain[dwCtr] == -1)
        && (dwCtr < _pClassInfo->nNumOfMustContain)) {
        dwCtr++;
    }
    
    dwAdjust = dwCtr;

    //
    // Now get the may contain information.
    //
    for (
         dwCtr = 0;
         ((dwCtr < (_pClassInfo->nNumOfMayContain))
          && (_pClassInfo->pOIDsMayContain[dwCtr]) != -1);
         dwCtr++) 
         {
        DWORD dwTemp = dwCtr + dwAdjust;
        pPropArray[dwTemp] = &(pSchemaInfo->aProperties[
                               (pSchemaInfo->aPropertiesSearchTable[
                                _pClassInfo->pOIDsMayContain[dwCtr]].nIndex
                                )]);
    }

    *ppProperties = (void *) pPropArray;

    if ((_pClassInfo->pOIDsMayContain[dwCtr] == -1)
        && (dwCtr < _pClassInfo->nNumOfMustContain)) {
        *pdwPropCount = dwAdjust + dwCtr + 1;
    }
    else {
        *pdwPropCount = dwAdjust + dwCtr;
    }

error:

    if (FAILED(hr)) {
        if (pPropArray) {
            FreeADsMem(pPropArray);
        }
    }

    RRETURN(hr);
}

HRESULT 
IsPropertyInList(
    LPCWSTR pszName,
    VARIANT vProp,
    BOOL *pfInList
    )
{
    HRESULT hr = S_OK;
    VARIANT *pvProp = &vProp;
    SAFEARRAY *pArray = V_ARRAY(pvProp);
    DWORD dwSLBound;
    DWORD dwSUBound;
    DWORD dwLength = 0;
    VARIANT vVar;

    VariantInit(&vVar);

    *pfInList = FALSE;

    hr = SafeArrayGetLBound(pArray,
                            1,
                            (long FAR *)&dwSLBound
                            );
    BAIL_ON_FAILURE(hr);

    hr = SafeArrayGetUBound(pArray,
                            1,
                            (long FAR *)&dwSUBound
                            );
    BAIL_ON_FAILURE(hr);
    
    dwLength = dwSUBound - dwSLBound;

    //
    // If there are 0 elements in cannot be in the list.
    //
    if (!dwLength) {
        RRETURN(S_OK);
    }
    
    for (DWORD dwCtr = 0;
         (dwCtr <= dwLength) && (*pfInList != TRUE);
         dwCtr++)
         {
        //
        // Go through the array to see if we find the name in the list.
        //
        VariantClear(&vVar);
        hr = SafeArrayGetElement(pArray,
                                (long FAR *)&dwCtr,
                                &vVar
                                );
        BAIL_ON_FAILURE(hr);

        if (V_VT(&vVar) != VT_BSTR) {
            BAIL_ON_FAILURE(hr = E_FAIL);
        }

        if (!_wcsicmp(pszName, vVar.bstrVal)) {
            *pfInList = TRUE;
        }
    }

error:

    VariantClear(&vVar);

    RRETURN(hr);

}

//+---------------------------------------------------------------------------
// Function:   CLDAPClass::GetOriginHelper
//
// Synopsis:   Returns the name of the class this property originated on.
//
// Arguments:  pszName         -   Name of the property whose origin is needed.
//             pbstrOrigin     -   Return value - name of class.
//
// Returns:    HRESULT - S_OK or any failure error code.
//
// Modifies:   pbstrOrigin on success.
//
//----------------------------------------------------------------------------
STDMETHODIMP 
CLDAPClass::GetOriginHelper(
    LPCWSTR pszName,
    BSTR *pbstrOrigin
    )
{
    HRESULT hr = S_OK;
    CCredentials cCreds = _Credentials;
    IUnknown *pUnk = NULL;
    IADsContainer *pContainer = NULL;
    BSTR bstrTemp = NULL;
    DWORD dwAuthFlags = cCreds.GetAuthFlags();
    BOOL fDone = FALSE;
    BOOL fInMustContain = FALSE;
    BOOL fInList = FALSE;
    IADsClass *pClass = NULL;
    IDispatch *pDispObj = NULL;
    BOOL fMustContain = FALSE;
    VARIANT vVar, vVarProps;

    VariantInit(&vVar);
    VariantInit(&vVarProps);

    //
    // If we are already at the top.
    //
    if (!_wcsicmp(_Name, L"top")) {
        hr = ADsAllocString(L"top", pbstrOrigin);
        RRETURN(hr);
    }

    //
    // We want to chase up either the mandatory or optional list and
    // not both. So we first update this flag.
    //
    hr = get_MandatoryProperties(&vVarProps);
    BAIL_ON_FAILURE(hr);

    hr = IsPropertyInList(pszName, vVarProps, &fInMustContain);
    BAIL_ON_FAILURE(hr)

    //
    // Mask out the reserved flags - we want to be in ADSI land now.
    //
    cCreds.SetAuthFlags(dwAuthFlags & ~(ADS_AUTH_RESERVED));

    //
    // This will be the default class name to return.
    //  
    hr = ADsAllocString(_Name, &bstrTemp);
    BAIL_ON_FAILURE(hr);
    //
    // Need to get hold of the schema container.
    //
    hr = GetObject(_Parent, cCreds, (void **)&pUnk);
    BAIL_ON_FAILURE(hr);

    hr = pUnk->QueryInterface(IID_IADsContainer, (void **) &pContainer);
    BAIL_ON_FAILURE(hr);

    while (!fDone) {
        //
        // Need to keep finding the derived from until we hit top
        // or we hit a class that does not support the attribute.
        //
        VariantClear(&vVar);
        VariantClear(&vVarProps);

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

        if (!pClass) {
            //
            // Need to get the derived from for the current class.
            //
            hr = get_DerivedFrom(&vVar);
        } 
        else {
            hr = pClass->get_DerivedFrom(&vVar);
            pClass->Release();
            pClass = NULL;
        }

        //
        // Get the derived from classes object.
        //
        hr = pContainer->GetObject(
                 L"Class",
                 vVar.bstrVal,
                 &pDispObj
                 );
        BAIL_ON_FAILURE(hr);

        hr = pDispObj->QueryInterface(
                 IID_IADsClass,
                 (void **) &pClass
                 );
        BAIL_ON_FAILURE(hr);

        if (!_wcsicmp(vVar.bstrVal, L"top")) {
            fDone = TRUE;
        }

        if (fInMustContain) {
            hr = pClass->get_MandatoryProperties(&vVarProps);
        } 
        else {
            hr = pClass->get_OptionalProperties(&vVarProps);
        }
        BAIL_ON_FAILURE(hr);

        hr = IsPropertyInList(pszName, vVarProps, &fInList);
        BAIL_ON_FAILURE(hr);

        if (!fInList) {
            //
            // The value in temp is the correct class name
            //
            hr = ADsAllocString(bstrTemp, pbstrOrigin);
            BAIL_ON_FAILURE(hr);

            fDone = TRUE;
        }

        //
        // This will be true only if we found the item in top.
        //
        if (fInList && fDone) {
            hr = ADsAllocString(L"Top", pbstrOrigin);
            BAIL_ON_FAILURE(hr);
        }

        if (bstrTemp) {
            SysFreeString(bstrTemp);
            bstrTemp = NULL;
        }

        //
        // Need to get the current class name in bstrTemp.
        //
        hr = ADsAllocString(vVar.bstrVal, &bstrTemp);
        BAIL_ON_FAILURE(hr);
    }

    //
    // We will default to the current class.
    //
    if (!pbstrOrigin) {
        hr = ADsAllocString(_Name, pbstrOrigin);
        BAIL_ON_FAILURE(hr);
    }

error:

    if (bstrTemp) {
        SysFreeString(bstrTemp);
    }

    VariantClear(&vVar);
    VariantClear(&vVarProps);
    
    if (pContainer) {
        pContainer->Release();
    }

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

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

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

    RRETURN(hr);
}
/******************************************************************/
/*  Class CLDAPProperty
/******************************************************************/

DEFINE_IDispatch_Implementation(CLDAPProperty)
DEFINE_IADs_Implementation(CLDAPProperty)

CLDAPProperty::CLDAPProperty()
    : _pDispMgr( NULL ),
      _pPropertyCache( NULL ),
      _bstrSyntax( NULL ),
      _hSchema( NULL ),
      _pPropertyInfo( NULL ),
      _pszLDAPServer(NULL),
      _pszLDAPDn(NULL),
      _fNTDS( TRUE ),
      _ld( NULL )
{
    ENLIST_TRACKING(CLDAPProperty);
}

CLDAPProperty::~CLDAPProperty()
{
    delete _pDispMgr;

    delete _pPropertyCache;

    if ( _bstrSyntax ) {
        ADsFreeString( _bstrSyntax );
    }

    if ( _hSchema ) {
        SchemaClose( &_hSchema );
        _hSchema = NULL;
    }


    if (_pszLDAPServer) {
        FreeADsStr(_pszLDAPServer);
    }

    if (_pszLDAPDn) {
        FreeADsStr(_pszLDAPDn);
    }

    if ( _ld ) {
        LdapCloseObject( _ld );
        _ld = NULL;
    }
}

HRESULT
CLDAPProperty::CreateProperty(
    BSTR   bstrParent,
    LDAP_SCHEMA_HANDLE hSchema,
    BSTR   bstrName,
    PROPERTYINFO *pPropertyInfo,
    CCredentials& Credentials,
    DWORD  dwObjectState,
    REFIID riid,
    void **ppvObj
    )
{
    CLDAPProperty FAR * pProperty = NULL;
    HRESULT hr = S_OK;
    BSTR bstrSyntax = NULL;

    OBJECTINFO ObjectInfo;
    POBJECTINFO pObjectInfo = &ObjectInfo;

    memset(pObjectInfo, 0, sizeof(OBJECTINFO));

    hr = AllocatePropertyObject(Credentials, &pProperty );
    BAIL_ON_FAILURE(hr);

    pProperty->_pPropertyInfo = pPropertyInfo;

    SchemaAddRef( hSchema );
    pProperty->_hSchema = hSchema;

    if ( pPropertyInfo )
    {
        hr = put_BSTR_Property( pProperty, TEXT("attributeID"),
                                pPropertyInfo->pszOID);

        if ( SUCCEEDED(hr))
        {
            hr = put_VARIANT_BOOL_Property( pProperty, TEXT("isSingleValued"),
                                            (VARIANT_BOOL)pPropertyInfo->fSingleValued );
            BAIL_ON_FAILURE(hr);

            pProperty->_pPropertyCache->ClearAllPropertyFlags();

            pProperty->_fNTDS = TRUE;

        }
        else
        {
            pProperty->_fNTDS = FALSE;
        }
    }

    hr = ADsObject(bstrParent, pObjectInfo);
    BAIL_ON_FAILURE(hr);

    pProperty->_dwPort = pObjectInfo->PortNumber;

    FreeObjectInfo(pObjectInfo);
    pObjectInfo = NULL;

    hr = pProperty->InitializeCoreObject(
             bstrParent,
             bstrName,
             PROPERTY_CLASS_NAME,
             CLSID_LDAPProperty,
             dwObjectState );
    BAIL_ON_FAILURE(hr);

    //
    // At this point update the info in the property cache
    //
    pProperty->_pPropertyCache->SetObjInformation(
                                     &(pProperty->_Credentials),
                                     pProperty->_pszLDAPServer,
                                     pProperty->_dwPort
                                     );

    BAIL_ON_FAILURE(hr);

    //
    // Need to create the umi object if applicable.
    //
    if (Credentials.GetAuthFlags() & ADS_AUTH_RESERVED) {
        hr = ((CCoreADsObject*)pProperty)->InitUmiObject(
                   IntfPropsSchema,
                   pProperty->_pPropertyCache,
                   (IADs *) pProperty,
                   (IADs *) pProperty,
                   riid,
                   ppvObj,
                   &(pProperty->_Credentials),
                   pProperty->_dwPort,
                   pProperty->_pszLDAPServer,
                   pProperty->_pszLDAPDn
                   );
        BAIL_ON_FAILURE(hr);
        //
        // Need to put syntax in the cache.
        //
        if (pProperty->_pPropertyInfo->pszSyntax) {
            hr = GetFriendlyNameFromOID(
                    pProperty->_pPropertyInfo->pszSyntax,
                     &bstrSyntax
                    );
            if (FAILED(hr)) {
                //
                // ok if this failed.
                //
                hr = S_OK;
            } 
            else {
                hr = put_BSTR_Property( 
                         pProperty, TEXT("syntax"),
                         bstrSyntax
                         );
                SysFreeString(bstrSyntax);
                //
                // Not critical failure
                //
                hr = S_OK;
            }
        }
        //
        // Name is a simulated propert used for UMI.
        //
        hr = put_BSTR_Property(
                 pProperty,
                 TEXT("Name"),
                 bstrName
                 );
        BAIL_ON_FAILURE(hr);

        RRETURN(S_OK);

    }

    //
    // Get the LDAP path of the schema entry
    //

    hr = pProperty->QueryInterface( riid, ppvObj );
    BAIL_ON_FAILURE(hr);

    pProperty->Release();

    RRETURN(hr);

error:

    *ppvObj = NULL;
    delete pProperty;

    FreeObjectInfo(pObjectInfo);

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    if (ppv == NULL) {
    RRETURN(E_POINTER);
    }

    if (IsEqualIID(iid, IID_IUnknown))
    {
        *ppv = (IADsProperty FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IDispatch))
    {
        *ppv = (IADs FAR *) this;
    }
    else if (IsEqualIID(iid, IID_ISupportErrorInfo))
    {
        *ppv = (ISupportErrorInfo FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IADs))
    {
        *ppv = (IADs FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IADsProperty))
    {
        *ppv = (IADsProperty FAR *) this;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    AddRef();
    return NOERROR;
}

/* ISupportErrorInfo method */
STDMETHODIMP
CLDAPProperty::InterfaceSupportsErrorInfo(THIS_ REFIID riid)
{
    if (IsEqualIID(riid, IID_IADs) |
    IsEqualIID(riid, IID_IADsProperty)) {
        RRETURN(S_OK);
    } else {
        RRETURN(S_FALSE);
    }
}
/* IADs methods */

STDMETHODIMP
CLDAPProperty::SetInfo(THIS)
{
    HRESULT hr = S_OK;
    BOOL fChanged = FALSE;

    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR(E_NOTIMPL);

    if ( GetObjectState() == ADS_OBJECT_UNBOUND )
    {
        hr = LDAPCreateObject();
        BAIL_ON_FAILURE(hr);

        fChanged = TRUE;

        //
        // If the create succeded, set the object type to bound
        //

        SetObjectState(ADS_OBJECT_BOUND);

    }
    else
    {
        hr = LDAPSetObject( &fChanged );
        BAIL_ON_FAILURE(hr);
    }

    //
    //  Need to refresh the schema
    //

    if ( SUCCEEDED(hr) && fChanged )
        hr = LDAPRefreshSchema();

error:

    RRETURN_EXP_IF_ERR(hr);
}

HRESULT
CLDAPProperty::LDAPSetObject( BOOL *pfChanged )
{
    HRESULT hr = S_OK;
    LDAPModW **aMod = NULL;
    BOOL fNTSecDes = FALSE;
    SECURITY_INFORMATION NewSeInfo;

    *pfChanged = FALSE;

    hr = _pPropertyCache->LDAPMarshallProperties(
                            &aMod,
                            &fNTSecDes,
                            &NewSeInfo
                            );
    BAIL_ON_FAILURE(hr);

    if ( aMod == NULL )  // There are no changes that needs to be modified
        RRETURN(S_OK);

    if ( _pszLDAPDn == NULL )
    {
        hr = BuildSchemaLDAPPath( _Parent,
                                  _Name,
                                  ((SCHEMAINFO*)_hSchema)->pszSubSchemaSubEntry,
                                  &_pszLDAPServer,
                                  &_pszLDAPDn,
                                  _pPropertyInfo == NULL,
                                  &_ld,
                                  _Credentials
                                  );
        BAIL_ON_FAILURE(hr);
    }

    if ( _ld == NULL )
    {
        hr = LdapOpenObject(
                       _pszLDAPServer,
                       _pszLDAPDn,
                       &_ld,
                       _Credentials,
                       _dwPort
                       );
    BAIL_ON_FAILURE(hr);
    }

    hr = LdapModifyS(
                   _ld,
                   _pszLDAPDn,
                   aMod
                   );
    BAIL_ON_FAILURE(hr);

    // We are successful at this point,
    // So, clean up the flags in the cache so the same operation
    // won't be repeated on the next SetInfo()

    _pPropertyCache->ClearAllPropertyFlags();

    *pfChanged = TRUE;

error:

    if (aMod) {

        if ( *aMod )
            FreeADsMem( *aMod );

        FreeADsMem( aMod );
    }

    RRETURN_EXP_IF_ERR(hr);
}

HRESULT
CLDAPProperty::LDAPCreateObject()
{
    HRESULT hr = S_OK;
    LDAPModW **aMod = NULL;
    DWORD dwIndex = 0;
    VARIANT v;
    BOOL fNTSecDes= FALSE;
    SECURITY_INFORMATION NewSeInfo;

    //
    // Get the LDAP path of the schema entry
    //
    if ( (_pszLDAPServer == NULL) && (_pszLDAPDn == NULL))
    {
        hr = BuildSchemaLDAPPath( _Parent,
                                  _Name,
                                  ((SCHEMAINFO*)_hSchema)->pszSubSchemaSubEntry,
                                  &_pszLDAPServer,
                                  &_pszLDAPDn,
                                  _pPropertyInfo == NULL,
                                  &_ld,
                                  _Credentials
                                  );

        BAIL_ON_FAILURE(hr);
    }

    if ( _pPropertyCache->findproperty( TEXT("objectClass"), &dwIndex )
         == E_ADS_PROPERTY_NOT_FOUND )
    {

        VariantInit(&v);
        v.vt = VT_BSTR;
        V_BSTR(&v) = NT_SCHEMA_PROPERTY_NAME;

        hr = Put( TEXT("objectClass"), v );
        BAIL_ON_FAILURE(hr);
    }

    if ( _pPropertyCache->findproperty( TEXT("cn"), &dwIndex )
         == E_ADS_PROPERTY_NOT_FOUND )
    {
        VariantInit(&v);
        v.vt = VT_BSTR;
        V_BSTR(&v) = _Name;

        hr = Put( TEXT("cn"), v );
        BAIL_ON_FAILURE(hr);
    }

    if ( _pPropertyCache->findproperty( TEXT("lDAPDisplayName"), &dwIndex )
         == E_ADS_PROPERTY_NOT_FOUND )
    {
        VariantInit(&v);
        v.vt = VT_BSTR;
        V_BSTR(&v) = _Name;

        hr = Put( TEXT("lDAPDisplayName"), v );
        BAIL_ON_FAILURE(hr);
    }

    hr = _pPropertyCache->LDAPMarshallProperties(
                            &aMod,
                            &fNTSecDes,
                            &NewSeInfo
                            );
    BAIL_ON_FAILURE(hr);

    if ( _ld == NULL )
    {
        hr = LdapOpenObject(
                       _pszLDAPServer,
                       _pszLDAPDn,
                       &_ld,
                       _Credentials,
                       _dwPort
                       );
    BAIL_ON_FAILURE(hr);
    }

    hr = LdapAddS(
                    _ld,
                    _pszLDAPDn,
                    aMod
                    );


    BAIL_ON_FAILURE(hr);

    // We are successful at this point,
    // So, clean up the flags in the cache so the same operation
    // won't be repeated on the next SetInfo()

    _pPropertyCache->ClearAllPropertyFlags();

error:

    if (aMod) {

        if ( *aMod )
            FreeADsMem( *aMod );
        FreeADsMem( aMod );
    }

    RRETURN_EXP_IF_ERR(hr);
}

HRESULT
CLDAPProperty::LDAPRefreshSchema(THIS)
{
    HRESULT hr = S_OK;

    if (( _pszLDAPServer == NULL) && (_pszLDAPDn == NULL))
    {
        hr = BuildSchemaLDAPPath( _Parent,
                                  _Name,
                                  ((SCHEMAINFO*)_hSchema)->pszSubSchemaSubEntry,
                                  &_pszLDAPServer,
                                  &_pszLDAPDn,
                                  _pPropertyInfo == NULL,
                                  &_ld,
                                  _Credentials
                                  );

        BAIL_ON_FAILURE(hr);
    }

    //
    // Make the old schema obsolete and get the new schema
    // We cannot delete the old schema since other objects might have
    // references to it.
    //
    hr = LdapMakeSchemaCacheObsolete(
             _pszLDAPServer,
             _Credentials,
             _dwPort
             );
    BAIL_ON_FAILURE(hr);

error:

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::GetInfo(THIS)
{
    HRESULT hr = S_OK;
    BSTR bstrSyntax = NULL;

    if ( GetObjectState() == ADS_OBJECT_UNBOUND )
        RRETURN_EXP_IF_ERR(E_ADS_OBJECT_UNBOUND);

    hr = LDAPRefreshSchema();
    BAIL_ON_FAILURE(hr);

    SchemaClose( &_hSchema );

    hr = SchemaOpen( _pszLDAPServer, &_hSchema, _Credentials, _dwPort );
    BAIL_ON_FAILURE(hr);

    //
    // Find the new property info in the new schemainfo
    //

    hr = SchemaGetPropertyInfo(
             _hSchema,
             _Name,
             &_pPropertyInfo );

    BAIL_ON_FAILURE( hr );

    if ( _pPropertyInfo == NULL )
    {
        // Property name not found, set error

        hr = E_ADS_BAD_PATHNAME;
        BAIL_ON_FAILURE(hr);
    }

    _pPropertyCache->flushpropertycache();

    hr = put_BSTR_Property( this, TEXT("attributeID"),
                            _pPropertyInfo->pszOID);
    BAIL_ON_FAILURE(hr);

    if ( _bstrSyntax )
    {
        ADsFreeString( _bstrSyntax );
        _bstrSyntax = NULL;
    }

    hr = put_VARIANT_BOOL_Property( this, TEXT("isSingleValued"),
                                    (VARIANT_BOOL)_pPropertyInfo->fSingleValued );
    BAIL_ON_FAILURE(hr);

    //
    // If we are calling from Umi land then we need to set 
    // additional properties.
    //
    if (_Credentials.GetAuthFlags() & ADS_AUTH_RESERVED) {
        if (_pPropertyInfo->pszSyntax) {
            hr = GetFriendlyNameFromOID(
                     _pPropertyInfo->pszSyntax,
                     &bstrSyntax
                     );
            if (FAILED(hr)) {
                //
                // ok if this failed.
                //
                hr = S_OK;
            } 
            else {
                hr = put_BSTR_Property( 
                         this, TEXT("syntax"),
                         bstrSyntax
                         );
                SysFreeString(bstrSyntax);
                //
                // Not critical failure
                //
                hr = S_OK;
            }
        }
        //
        // Name is a simulated propert used for UMI.
        //
        hr = put_BSTR_Property(
                 this,
                 TEXT("Name"),
                 _Name
                 );
        BAIL_ON_FAILURE(hr);

    } // special props for Umi.

    if (_fNTDS) {
        hr = GetNTDSSchemaInfo(TRUE);
    }

    _pPropertyCache->ClearAllPropertyFlags();
    _pPropertyCache->setGetInfoFlag();

error:

    if (bstrSyntax) {
        SysFreeString(bstrSyntax);
    }

    RRETURN_EXP_IF_ERR(hr);
}

//
// Helper function for Umi - defined in CCoreADsObject.
//
STDMETHODIMP
CLDAPProperty::GetInfo(DWORD dwFlags)
{
    HRESULT hr = S_OK;

    if (dwFlags ==  GETINFO_FLAG_EXPLICIT) {
        RRETURN(GetInfo());
    } 
    else if (_fNTDS
             && dwFlags != GETINFO_FLAG_IMPLICIT_AS_NEEDED
             ) {
        //
        // Read the extra NTDS specific schema properties.
        //
        hr = GetNTDSSchemaInfo(FALSE);
    }
    
    //
    // Any other flags means nothing to do.
    //
    RRETURN(hr);
}

HRESULT
CLDAPProperty::GetNTDSSchemaInfo(
    BOOL fForce
    )
{
    HRESULT hr = S_OK;
    LPTSTR aStrings[] = {
        TEXT("cn"),
        TEXT("schemaIDGUID"),
        TEXT("rangeUpper"),
        TEXT("rangeLower"),
        NULL
    };

    LDAPMessage *res = NULL;

    if (_pszLDAPDn == NULL) {
        //
        // Need to get the dn for this object and also 
        // the attributes we are interested in.
        //
        hr = BuildSchemaLDAPPathAndGetAttribute(
                 _Parent,
                 _Name,
                 ((SCHEMAINFO*)_hSchema)->pszSubSchemaSubEntry,
                 _pPropertyInfo == NULL,
                 _Credentials,
                 aStrings,
                 &_pszLDAPServer,
                 &_pszLDAPDn,
                 &_ld,
                 &res
                 );
    }
    else {
        //
        // Looks like we just need the attributes in this case.
        //
        hr = LdapSearchS(
                 _ld,
                 _pszLDAPDn,
                 LDAP_SCOPE_BASE,
                 L"(objectClass=*)",
                 aStrings,
                 FALSE,
                 &res
                 );
    }
        
    BAIL_ON_FAILURE(hr);

    //
    // If we succeeded we should unmarshall properties into the cache.
    //
    hr = _pPropertyCache->LDAPUnMarshallProperties(
             _pszLDAPServer,
             _ld,
             res,
             fForce,
             _Credentials
             );
    BAIL_ON_FAILURE(hr);

    _pPropertyCache->setGetInfoFlag();

error:

    if (res) {
        LdapMsgFree(res);
    }

    RRETURN(hr);
}

STDMETHODIMP
CLDAPProperty::Get(THIS_ BSTR bstrName, VARIANT FAR* pvProp)
{
    HRESULT hr = S_OK;
    DWORD dwSyntaxId;
    LDAPOBJECTARRAY ldapSrcObjects;
    DWORD dwStatus = 0;

    LDAPOBJECTARRAY_INIT(ldapSrcObjects);

    //
    // For folks who know now what they do.
    //
    if (!pvProp) {
        BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
    }

    //
    // retrieve data object from cache; if one exists
    //

    if ( GetObjectState() == ADS_OBJECT_UNBOUND ) {

        hr = _pPropertyCache->unboundgetproperty(
                    bstrName,
                    &dwSyntaxId,
                    &dwStatus,
                    &ldapSrcObjects
                    );

        // For backward compatibility
        if (!ldapSrcObjects.pLdapObjects && SUCCEEDED(hr)) {
            hr = E_FAIL;
        }

    } else {

        hr = _pPropertyCache->getproperty(
                    bstrName,
                    &dwSyntaxId,
                    &dwStatus,
                    &ldapSrcObjects
                    );

        // For backward compatibility
        if (!ldapSrcObjects.pLdapObjects && SUCCEEDED(hr)) {
            hr = E_ADS_PROPERTY_NOT_FOUND;
        }
    }

    BAIL_ON_FAILURE(hr);

    //
    // translate the Ldap objects to variants
    //

    if ( ldapSrcObjects.dwCount == 1 ) {

        hr = LdapTypeToVarTypeCopy(
                 _pszLDAPServer,
                 _Credentials,
                 ldapSrcObjects.pLdapObjects,
                 dwSyntaxId,
                 pvProp
                 );

    } else {

        hr = LdapTypeToVarTypeCopyConstruct(
                 _pszLDAPServer,
                 _Credentials,
                 ldapSrcObjects,
                 dwSyntaxId,
                 pvProp
                 );
    }
    BAIL_ON_FAILURE(hr);

error:

    LdapTypeFreeLdapObjects( &ldapSrcObjects );

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::Put(THIS_ BSTR bstrName, VARIANT vProp)
{
    HRESULT hr = S_OK;
    DWORD dwSyntaxId = 0;

    DWORD dwIndex = 0;
    LDAPOBJECTARRAY ldapDestObjects;

    DWORD dwNumValues = 0;
    VARIANT * pVarArray = NULL;
    VARIANT * pvProp = NULL;
    VARIANT vDefProp;

    VariantInit(&vDefProp);

    LDAPOBJECTARRAY_INIT(ldapDestObjects);

    hr = SchemaGetSyntaxOfAttribute( _hSchema, bstrName, &dwSyntaxId );
    if (FAILED(hr)) {
        //
        // Need to see if this is syntax if so we special case
        // for Umi Objects.
        //
        if (!_wcsicmp(L"syntax", bstrName)) {
            dwSyntaxId = LDAPTYPE_CASEIGNORESTRING;
            hr = S_OK;
        }
    }
    BAIL_ON_FAILURE(hr);


    if ( dwSyntaxId == LDAPTYPE_UNKNOWN )
    {
        hr = E_ADS_CANT_CONVERT_DATATYPE;
        BAIL_ON_FAILURE(hr);
    }

    //
    // A VT_BYREF|VT_VARIANT may expand to a VT_VARIANT|VT_ARRAY.
    // We should dereference a VT_BYREF|VT_VARIANT once and see
    // what's inside.
    //
    pvProp = &vProp;
    if (V_VT(pvProp) == (VT_BYREF|VT_VARIANT)) {
    pvProp = V_VARIANTREF(&vProp);
    }

    if ((V_VT(pvProp) == (VT_VARIANT|VT_ARRAY|VT_BYREF)) ||
    (V_VT(pvProp) == (VT_VARIANT|VT_ARRAY))) {

        hr  = ConvertSafeArrayToVariantArray(
                    *pvProp,
                    &pVarArray,
                    &dwNumValues
                        );
        // returns E_FAIL if *pvProp is invalid
        if (hr == E_FAIL)
            hr = E_ADS_BAD_PARAMETER;                    
        BAIL_ON_FAILURE(hr);
        pvProp = pVarArray;

    }else {

    //
    // If pvProp is a reference to a fundamental type,
    // we have to dereference it once.
    //
    if (V_ISBYREF(pvProp)) {
        hr = VariantCopyInd(&vDefProp, pvProp);
        BAIL_ON_FAILURE(hr);
        pvProp = &vDefProp;
    }
        dwNumValues = 1;
    }


#if 0
    //
    // check if this is a legal property for this object,
    //

    hr = ValidatePropertyinCache(
                szLDAPTreeName,
                _ADsClass,
                bstrName,
                &dwSyntaxId
                );
    BAIL_ON_FAILURE(hr);
#endif

    //
    // check if the variant maps to the syntax of this property
    //

    if ( dwNumValues > 0 )
    {
        hr = VarTypeToLdapTypeCopyConstruct(
                 _pszLDAPServer,
                 _Credentials,
                 dwSyntaxId,
                 pvProp,
                 dwNumValues,
                 &ldapDestObjects
                 );
        BAIL_ON_FAILURE(hr);
    }

    //
    // Find this property in the cache
    //

    hr = _pPropertyCache->findproperty(
                        bstrName,
                        &dwIndex
                        );

    //
    // If this property does not exist in the
    // cache, add this property into the cache.
    //


    if (FAILED(hr)) {

        hr = _pPropertyCache->addproperty( bstrName );

        BAIL_ON_FAILURE(hr);
    }

    //
    // Now update the property in the cache
    //
    hr = _pPropertyCache->putproperty(
                    bstrName,
                    PROPERTY_UPDATE,
                    dwSyntaxId,
                    ldapDestObjects
                    );

    BAIL_ON_FAILURE(hr);

error:

    VariantClear(&vDefProp);

    LdapTypeFreeLdapObjects( &ldapDestObjects );

    if (pVarArray) {

        DWORD i = 0;

        for (i = 0; i < dwNumValues; i++) {
            VariantClear(pVarArray + i);
        }
        FreeADsMem(pVarArray);
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::GetEx(THIS_ BSTR bstrName, VARIANT FAR* pvProp)
{
    HRESULT hr = S_OK;
    DWORD dwSyntaxId;
    DWORD dwNumValues;
    DWORD dwStatus = 0;
    LDAPOBJECTARRAY ldapSrcObjects;

    LDAPOBJECTARRAY_INIT(ldapSrcObjects);

    //
    // For those who know no not what they do
    //
    if (!pvProp) {
        BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
    }

    //
    // retrieve data object from cache; if one exists
    //

    if ( GetObjectState() == ADS_OBJECT_UNBOUND ) {

        hr = _pPropertyCache->unboundgetproperty(
                    bstrName,
                    &dwSyntaxId,
                    &dwStatus,
                    &ldapSrcObjects
                    );

        // For backward compatibility
        if (!ldapSrcObjects.pLdapObjects && SUCCEEDED(hr)) {
            hr = E_FAIL;
        }

    } else {

        hr = _pPropertyCache->getproperty(
                    bstrName,
                    &dwSyntaxId,
                    &dwStatus,
                    &ldapSrcObjects
                    );

        // For backward compatibility
        if (!ldapSrcObjects.pLdapObjects && SUCCEEDED(hr)) {
            hr = E_ADS_PROPERTY_NOT_FOUND;
        }

    }

    BAIL_ON_FAILURE(hr);

    //
    // translate the Ldap objects to variants
    //

    hr = LdapTypeToVarTypeCopyConstruct(
             _pszLDAPServer,
             _Credentials,
             ldapSrcObjects,
             dwSyntaxId,
             pvProp
             );
    BAIL_ON_FAILURE(hr);

error:

    LdapTypeFreeLdapObjects( &ldapSrcObjects );

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::PutEx(THIS_ long lnControlCode, BSTR bstrName, VARIANT vProp)
{
    HRESULT hr = S_OK;
    DWORD dwSyntaxId = 0;
    DWORD dwFlags = 0;

    DWORD dwIndex = 0;
    LDAPOBJECTARRAY ldapDestObjects;

    DWORD dwNumValues = 0;
    VARIANT * pVarArray = NULL;
    VARIANT * pvProp = NULL;

    LDAPOBJECTARRAY_INIT(ldapDestObjects);

    switch (lnControlCode) {
    case ADS_PROPERTY_CLEAR:
        dwFlags = PROPERTY_DELETE;
        break;

    case ADS_PROPERTY_UPDATE:
        dwFlags = PROPERTY_UPDATE;
        break;

    default:
       RRETURN_EXP_IF_ERR(hr = E_ADS_BAD_PARAMETER);

    }

    hr = SchemaGetSyntaxOfAttribute( _hSchema, bstrName, &dwSyntaxId );
    BAIL_ON_FAILURE(hr);

    if ( dwSyntaxId == LDAPTYPE_UNKNOWN )
    {
        hr = E_ADS_CANT_CONVERT_DATATYPE;
        BAIL_ON_FAILURE(hr);
    }

#if 0
    //
    // check if this is a legal property for this object,
    //

    hr = ValidatePropertyinCache(
                szLDAPTreeName,
                _ADsClass,
                bstrName,
                &dwSyntaxId
                );
    BAIL_ON_FAILURE(hr);
#endif

    if ( dwFlags != PROPERTY_DELETE )
    {

    //
    // A VT_BYREF|VT_VARIANT may expand to a VT_VARIANT|VT_ARRAY.
    // We should dereference a VT_BYREF|VT_VARIANT once and see
    // what's inside.
    //
    pvProp = &vProp;
    if (V_VT(pvProp) == (VT_BYREF|VT_VARIANT)) {
        pvProp = V_VARIANTREF(&vProp);
    }

        if ((V_VT(pvProp) == (VT_VARIANT|VT_ARRAY|VT_BYREF)) ||
        (V_VT(pvProp) == (VT_VARIANT|VT_ARRAY))) {

            hr  = ConvertSafeArrayToVariantArray(
                      *pvProp,
                      &pVarArray,
                      &dwNumValues
                      );
            // returns E_FAIL if *pvProp is invalid
            if (hr == E_FAIL)
                hr = E_ADS_BAD_PARAMETER;                      
            BAIL_ON_FAILURE(hr);
            pvProp = pVarArray;

        } else {

            hr = E_FAIL;
            BAIL_ON_FAILURE(hr);
        }


        //
        // check if the variant maps to the syntax of this property
        //

        if ( dwNumValues > 0 )
        {
            hr = VarTypeToLdapTypeCopyConstruct(
                     _pszLDAPServer,
                     _Credentials,
                     dwSyntaxId,
                     pvProp,
                     dwNumValues,
                     &ldapDestObjects
                     );
            BAIL_ON_FAILURE(hr);
        }
    }

    //
    // Find this property in the cache
    //

    hr = _pPropertyCache->findproperty(
                        bstrName,
                        &dwIndex
                        );

    //
    // If this property does not exist in the
    // cache, add this property into the cache.
    //


    if (FAILED(hr)) {

        hr = _pPropertyCache->addproperty( bstrName );

        BAIL_ON_FAILURE(hr);
    }

    //
    // Now update the property in the cache
    //
    hr = _pPropertyCache->putproperty(
                    bstrName,
                    PROPERTY_UPDATE,
                    dwSyntaxId,
                    ldapDestObjects
                    );

    BAIL_ON_FAILURE(hr);

error:

    LdapTypeFreeLdapObjects( &ldapDestObjects );

    if (pVarArray) {

        DWORD i = 0;

        for (i = 0; i < dwNumValues; i++) {
            VariantClear(pVarArray + i);
        }
        FreeADsMem(pVarArray);
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::GetInfoEx(THIS_ VARIANT vProperties, long lnReserved)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

/* IADsProperty methods */


STDMETHODIMP
CLDAPProperty::get_OID( THIS_ BSTR FAR *retval )
{
    HRESULT hr;
    if ( !retval )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    if ( _fNTDS )
    {
        GET_PROPERTY_BSTR( this, attributeID );
    }
    else if ( _pPropertyInfo )
    {
        hr =  ADsAllocString( _pPropertyInfo->pszOID?
                                   _pPropertyInfo->pszOID : TEXT(""), retval);
    }
    else
    {
        hr = ADsAllocString( TEXT(""), retval );
    }
    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::put_OID( THIS_ BSTR bstrOID )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR(E_NOTIMPL);

    HRESULT hr = put_BSTR_Property( this, TEXT("attributeID"), bstrOID );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::get_Syntax( THIS_ BSTR FAR *retval )
{
    HRESULT hr = S_OK;

    if ( !retval )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    if ( _fNTDS )
    {

        if ( _bstrSyntax )  // New property or syntax has been reset
        {
            hr = ADsAllocString( _bstrSyntax, retval);

        } else if (_pPropertyInfo && !_pPropertyInfo->pszSyntax) {
            //
            // New property but syntax has not been set
            //
            hr = E_ADS_PROPERTY_NOT_FOUND;
        }
    }

    //
    // Need to return if hr or retVal as we have what we need
    //
    if (FAILED(hr) || _bstrSyntax) {

        RRETURN_EXP_IF_ERR(hr);
    }

    // If we have the syntax in _pPropertyInfo we need to
    // continue and see if we can get a friendly name to return.
    if ( _pPropertyInfo ) {

        if (_pPropertyInfo->pszSyntax) {

            if (!GetFriendlyNameFromOID(
                         _pPropertyInfo->pszSyntax, retval)
                 ) {

                    // in this case we want to set the retVal
                    // to the OID as we could not find a match
                    hr = ADsAllocString(_pPropertyInfo->pszSyntax, retval);

            }
        }

    } else {

        hr = ADsAllocString( TEXT(""), retval );

    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::put_Syntax( THIS_ BSTR bstrSyntax )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR(E_NOTIMPL);

    LPTSTR pszOID;
    DWORD  dwOMSyntax;
    HRESULT hr = S_OK;


    BYTE btDNWithBinary[] = { 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x14, 0x01,
                              0x01, 0x01, 0x0B };


    BYTE btDNWithString[]      = { 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x14, 0x01,
                                   0x01, 0x01, 0x0C
                                   };


    if ( GetSyntaxOID( bstrSyntax, &pszOID, &dwOMSyntax))
    {
        hr = put_BSTR_Property( this, TEXT("attributeSyntax"),
                                pszOID );
        BAIL_ON_FAILURE(hr);

        hr = put_LONG_Property( this, TEXT("oMSyntax"),
                                dwOMSyntax );
        BAIL_ON_FAILURE(hr);

        if ( _bstrSyntax )
            ADsFreeString( _bstrSyntax );

        hr = ADsAllocString( bstrSyntax, &_bstrSyntax );
        BAIL_ON_FAILURE(hr);

        //
        // We need to handle the special case of DNWithBinary
        // and DNString
        //
        if (_wcsicmp(bstrSyntax, L"DNWithBinary") == 0) {
            //
            // Need to set additional byte attribute
            //
            hr = put_OCTETSTRING_Property(
                     this,
                     TEXT("omObjectClass"),
                     btDNWithBinary,
                     (sizeof(btDNWithBinary)/sizeof(btDNWithBinary[0]))
                     );

            BAIL_ON_FAILURE(hr);

        }
        else if (_wcsicmp(bstrSyntax, L"DNWithString") == 0) {
            //
            // Need to set omObjectClass here too
            //
            hr = put_OCTETSTRING_Property(
                     this,
                     TEXT("omObjectClass"),
                     btDNWithString,
                     (sizeof(btDNWithString)/sizeof(btDNWithString[0]))
                     );

            BAIL_ON_FAILURE(hr);

        }
    }
    else
    {
        // Unknown syntax
        hr = E_ADS_BAD_PARAMETER;
        BAIL_ON_FAILURE(hr);
    }

error:
    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::get_MaxRange( THIS_ long FAR *plMaxRange )
{
    HRESULT hr = S_OK;

    if ( !plMaxRange )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    hr = get_LONG_Property(this, TEXT("rangeUpper"), plMaxRange );

    if ( SUCCEEDED(hr) )
        RRETURN(hr);

    if ( _pPropertyInfo == NULL )  // new class
    {
        hr = E_ADS_PROPERTY_NOT_SET;
        RRETURN_EXP_IF_ERR(hr);
    }

    RRETURN_EXP_IF_ERR(hr);

}

STDMETHODIMP
CLDAPProperty::put_MaxRange( THIS_ long lMaxRange )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    HRESULT hr = put_LONG_Property( this, TEXT("rangeUpper"),
                                    lMaxRange );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::get_MinRange( THIS_ long FAR *plMinRange )
{
    HRESULT hr = S_OK;
    
    if ( !plMinRange )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    hr = get_LONG_Property(this, TEXT("rangeLower"), plMinRange );

    if ( SUCCEEDED(hr) )
        RRETURN(hr);

    if ( _pPropertyInfo == NULL )  // new class
    {
        hr = E_ADS_PROPERTY_NOT_SET;
        RRETURN_EXP_IF_ERR(hr);
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::put_MinRange( THIS_ long lMinRange )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    HRESULT hr = put_LONG_Property( this, TEXT("rangeLower"),
                                    lMinRange );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::get_MultiValued( THIS_ VARIANT_BOOL FAR *pfMultiValued )
{
    if ( !pfMultiValued )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    HRESULT hr = S_OK;
    VARIANT_BOOL fSingleValued = FALSE;  // by default

    if ( _fNTDS )
    {
        hr = get_VARIANT_BOOL_Property( this, TEXT("isSingleValued"),
                                        &fSingleValued );
        BAIL_ON_FAILURE(hr);
    }
    else if ( _pPropertyInfo )
    {
        fSingleValued = (VARIANT_BOOL)_pPropertyInfo->fSingleValued;
    }

    *pfMultiValued = fSingleValued? VARIANT_FALSE : VARIANT_TRUE;

error:

    RRETURN_EXP_IF_ERR(hr);

}

STDMETHODIMP
CLDAPProperty::put_MultiValued( THIS_ VARIANT_BOOL fMultiValued )
{
    if ( !_fNTDS )
        RRETURN_EXP_IF_ERR( E_NOTIMPL );

    HRESULT hr = put_VARIANT_BOOL_Property( (IADs *) this,
                                            TEXT("isSingleValued"),
                                            !fMultiValued );

    if ( hr == E_ADS_CANT_CONVERT_DATATYPE )
    {
        _fNTDS = FALSE;
        hr = E_NOTIMPL;
    }

    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPProperty::Qualifiers(THIS_ IADsCollection FAR* FAR* ppQualifiers)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

HRESULT
CLDAPProperty::AllocatePropertyObject(
    CCredentials& Credentials,
    CLDAPProperty FAR * FAR * ppProperty
    )
{
    CLDAPProperty FAR *pProperty = NULL;
    CAggregatorDispMgr FAR *pDispMgr = NULL;
    CPropertyCache FAR *pPropertyCache = NULL;
    HRESULT hr = S_OK;

    pProperty = new CLDAPProperty();
    if ( pProperty == NULL )
        hr = E_OUTOFMEMORY;
    BAIL_ON_FAILURE(hr);

    pDispMgr = new CAggregatorDispMgr(Credentials);
    if ( pDispMgr == NULL )
        hr = E_OUTOFMEMORY;
    BAIL_ON_FAILURE(hr);

    hr = pDispMgr->LoadTypeInfoEntry(
                            LIBID_ADs,
                            IID_IADs,
                            (IADs *) pProperty,
                            DISPID_REGULAR );
    BAIL_ON_FAILURE(hr);

    hr = pDispMgr->LoadTypeInfoEntry(
                            LIBID_ADs,
                            IID_IADsProperty,
                            (IADsProperty *) pProperty,
                            DISPID_REGULAR );
    BAIL_ON_FAILURE(hr);

    hr = CPropertyCache::createpropertycache(
                            (CCoreADsObject FAR *) pProperty,
                            (IGetAttributeSyntax *) pProperty,
                            &pPropertyCache
                            );

    BAIL_ON_FAILURE(hr);

    pDispMgr->RegisterPropertyCache(pPropertyCache);

    pProperty->_Credentials = Credentials;
    pProperty->_pDispMgr = pDispMgr;
    pProperty->_pPropertyCache = pPropertyCache;
    *ppProperty = pProperty;

    RRETURN(hr);

error:

    delete pDispMgr;
    delete pProperty;

    RRETURN(hr);

}

//
// Needed for dynamic dispid's in the property cache.
//
HRESULT
CLDAPProperty::GetAttributeSyntax(
    LPWSTR szPropertyName,
    PDWORD pdwSyntaxId
    )
{
    HRESULT hr;
    hr = LdapGetSyntaxOfAttributeOnServer(
    _pszLDAPServer,
    szPropertyName,
    pdwSyntaxId,
    _Credentials,
    _dwPort
    );
    RRETURN_EXP_IF_ERR(hr);
}


/******************************************************************/
/*  Class CLDAPSyntax
/******************************************************************/

DEFINE_IDispatch_Implementation(CLDAPSyntax)
DEFINE_IADs_Implementation(CLDAPSyntax)
DEFINE_IADsPutGet_UnImplementation(CLDAPSyntax)

CLDAPSyntax::CLDAPSyntax()
    : _pDispMgr( NULL ),
      _pPropertyCache(NULL)
{
    ENLIST_TRACKING(CLDAPSyntax);
}

CLDAPSyntax::~CLDAPSyntax()
{
    delete _pDispMgr;
    delete _pPropertyCache;
}

HRESULT
CLDAPSyntax::CreateSyntax(
    BSTR   bstrParent,
    SYNTAXINFO *pSyntaxInfo,
    CCredentials& Credentials,
    DWORD  dwObjectState,
    REFIID riid,
    void **ppvObj
    )
{
    CLDAPSyntax FAR *pSyntax = NULL;
    HRESULT hr = S_OK;

    hr = AllocateSyntaxObject(Credentials, &pSyntax );
    BAIL_ON_FAILURE(hr);

    hr = pSyntax->InitializeCoreObject(
             bstrParent,
             pSyntaxInfo->pszName,
             SYNTAX_CLASS_NAME,
             CLSID_LDAPSyntax,
             dwObjectState );
    BAIL_ON_FAILURE(hr);

    pSyntax->_lOleAutoDataType = pSyntaxInfo->lOleAutoDataType;

    //
    // If the call is from umi we need to instantiate the umi object.
    //
    if (Credentials.GetAuthFlags() & ADS_AUTH_RESERVED) {
        hr = ((CCoreADsObject*)pSyntax)->InitUmiObject(
                   IntfPropsSchema,
                   pSyntax->_pPropertyCache,
                   (IADs *) pSyntax,
                   (IADs *) pSyntax,
                   riid,
                   ppvObj,
                   &(pSyntax->_Credentials)
                   );
        BAIL_ON_FAILURE(hr);

        //
        // Set the simulated Name property.
        //
        hr = HelperPutStringPropertyInCache(
                 L"Name",
                 pSyntaxInfo->pszName,
                 pSyntax->_Credentials,
                 pSyntax->_pPropertyCache
                 );
        BAIL_ON_FAILURE(hr);

        RRETURN(S_OK);
    }

    hr = pSyntax->QueryInterface( riid, ppvObj );
    BAIL_ON_FAILURE(hr);

    pSyntax->Release();

    RRETURN(hr);

error:

    *ppvObj = NULL;
    delete pSyntax;
    RRETURN_EXP_IF_ERR(hr);
}

STDMETHODIMP
CLDAPSyntax::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    if (ppv == NULL) {
    RRETURN(E_POINTER);
    }

    if (IsEqualIID(iid, IID_IUnknown))
    {
        *ppv = (IADs FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IDispatch))
    {
        *ppv = (IADs FAR *) this;
    }
    else if (IsEqualIID(iid, IID_ISupportErrorInfo))
    {
        *ppv = (ISupportErrorInfo FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IADs))
    {
        *ppv = (IADs FAR *) this;
    }
    else if (IsEqualIID(iid, IID_IADsSyntax))
    {
        *ppv = (IADsSyntax FAR *) this;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    AddRef();
    return NOERROR;
}

/* ISupportErrorInfo method */
STDMETHODIMP
CLDAPSyntax::InterfaceSupportsErrorInfo(THIS_ REFIID riid)
{
    if (IsEqualIID(riid, IID_IADs) ||
    IsEqualIID(riid, IID_IADsSyntax)) {
        RRETURN(S_OK);
    } else {
        RRETURN(S_FALSE);
    }
}
/* IADs methods */

STDMETHODIMP
CLDAPSyntax::SetInfo(THIS)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

STDMETHODIMP
CLDAPSyntax::GetInfo(THIS)
{
    RRETURN(S_OK);
}

STDMETHODIMP
CLDAPSyntax::GetInfoEx(THIS_ VARIANT vProperties, long lnReserved)
{
    RRETURN_EXP_IF_ERR(E_NOTIMPL);
}

HRESULT
CLDAPSyntax::AllocateSyntaxObject(
    CCredentials& Credentials,
    CLDAPSyntax FAR * FAR * ppSyntax
    )
{
    CLDAPSyntax FAR *pSyntax = NULL;
    CAggregatorDispMgr FAR *pDispMgr = NULL;
    CPropertyCache FAR *pPropertyCache = NULL;
    HRESULT hr = S_OK;

    pSyntax = new CLDAPSyntax();
    if ( pSyntax == NULL )
        hr = E_OUTOFMEMORY;
    BAIL_ON_FAILURE(hr);

    pDispMgr = new CAggregatorDispMgr(Credentials);
    if ( pDispMgr == NULL )
        hr = E_OUTOFMEMORY;
    BAIL_ON_FAILURE(hr);

    hr = pDispMgr->LoadTypeInfoEntry(
                            LIBID_ADs,
                            IID_IADsSyntax,
                            (IADsSyntax *) pSyntax,
                            DISPID_REGULAR );
    BAIL_ON_FAILURE(hr);

    hr = CPropertyCache::createpropertycache(
                            (CCoreADsObject FAR *) pSyntax,
                            (IGetAttributeSyntax *) pSyntax,
                            &pPropertyCache
                            );
    BAIL_ON_FAILURE(hr);

    pSyntax->_pPropertyCache = pPropertyCache;

    pSyntax->_Credentials = Credentials;
    pSyntax->_pDispMgr = pDispMgr;
    *ppSyntax = pSyntax;

    RRETURN(hr);

error:

    delete pDispMgr;
    delete pSyntax;
    delete pPropertyCache;

    RRETURN_EXP_IF_ERR(hr);

}

STDMETHODIMP
CLDAPSyntax::get_OleAutoDataType( THIS_ long FAR *plOleAutoDataType )
{
    if ( !plOleAutoDataType )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    *plOleAutoDataType = _lOleAutoDataType;
    RRETURN(S_OK);
}

STDMETHODIMP
CLDAPSyntax::put_OleAutoDataType( THIS_ long lOleAutoDataType )
{
    RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}

//
// Needed for dynamic dispid's in the property cache.
//
HRESULT
CLDAPSyntax::GetAttributeSyntax(
    LPWSTR szPropertyName,
    PDWORD pdwSyntaxId
    )
{
    HRESULT hr = S_OK;

    if ((_Credentials.GetAuthFlags() & ADS_AUTH_RESERVED)
        && !_wcsicmp(L"Name", szPropertyName)) {
        *pdwSyntaxId = LDAPTYPE_CASEIGNORESTRING;
    } 
    else {
        hr = E_ADS_PROPERTY_NOT_FOUND;
    }

    RRETURN_EXP_IF_ERR(hr);
}

/******************************************************************/
/*  Misc Helpers
/******************************************************************/

HRESULT
MakeVariantFromStringArray(
    BSTR *bstrList,
    VARIANT *pvVariant
)
{
    HRESULT hr = S_OK;
    SAFEARRAY *aList = NULL;
    SAFEARRAYBOUND aBound;

    if ( (bstrList != NULL) && (*bstrList != 0) )
    {
        long i = 0;
        long j = 0;
        long nCount = 0;

        while ( bstrList[nCount] )
            nCount++;

        if ( nCount == 1 )
        {
            VariantInit( pvVariant );
            V_VT(pvVariant) = VT_BSTR;
            hr = ADsAllocString( bstrList[0], &(V_BSTR(pvVariant)));
            RRETURN_EXP_IF_ERR(hr);
        }

        aBound.lLbound = 0;
        aBound.cElements = nCount;

        aList = SafeArrayCreate( VT_VARIANT, 1, &aBound );

        if ( aList == NULL )
        {
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }

        i = 0;
        while ( bstrList[i] )
        {
            VARIANT v;

            VariantInit(&v);
            V_VT(&v) = VT_BSTR;

            hr = ADsAllocString( bstrList[i], &(V_BSTR(&v)));
            BAIL_ON_FAILURE(hr);

            hr = SafeArrayPutElement( aList,
                                      &i,
                                      &v );

            VariantClear(&v);
            BAIL_ON_FAILURE(hr);

            i++;
        }

        VariantInit( pvVariant );
        V_VT(pvVariant) = VT_ARRAY | VT_VARIANT;
        V_ARRAY(pvVariant) = aList;

    }
    else
    {
        aBound.lLbound = 0;
        aBound.cElements = 0;

        aList = SafeArrayCreate( VT_VARIANT, 1, &aBound );

        if ( aList == NULL )
        {
            hr = E_OUTOFMEMORY;
            BAIL_ON_FAILURE(hr);
        }

        VariantInit( pvVariant );
        V_VT(pvVariant) = VT_ARRAY | VT_VARIANT;
        V_ARRAY(pvVariant) = aList;
    }

    return S_OK;

error:

    if ( aList )
        SafeArrayDestroy( aList );

    return hr;
}

HRESULT
MakeVariantFromPropStringTable(
    int *propList,
    LDAP_SCHEMA_HANDLE hSchema,
    VARIANT *pvVariant
)
{
    HRESULT hr = S_OK;
    DWORD nCount = 0;
    BSTR *aStrings = NULL;

    if ( propList != NULL )
    {
        while ( propList[nCount] != -1 )
            nCount++;
    }

    if ( nCount > 0 )
    {
        hr = SchemaGetStringsFromStringTable(
                 hSchema,
                 propList,
                 nCount,
                 &aStrings );

        if (FAILED(hr))
            RRETURN_EXP_IF_ERR(hr);
    }

    hr =  MakeVariantFromStringArray(
              aStrings,
              pvVariant );

    for ( DWORD i = 0; i < nCount; i ++ )
    {
        FreeADsStr( aStrings[i] );
    }

    if (aStrings)
    {
        FreeADsMem( aStrings );
    }

    RRETURN(hr);

}

/* No longer needed
HRESULT
DeleteSchemaEntry(
    LPTSTR szADsPath,
    LPTSTR szRelativeName,
    LPTSTR szClassName,
    LPTSTR szSubSchemaSubEntry,
    CCredentials& Credentials
)
{
    HRESULT hr = S_OK;
    ADS_LDP *ld = NULL;


    TCHAR  *pszParentLDAPServer = NULL;
    LPWSTR pszParentLDAPDn = NULL;
    DWORD dwPort = 0;
    LPWSTR pszLDAPDn = NULL;
    LPTSTR *aValues = NULL;
    int nCount = 0;

    //
    // Need to distinguish between LDAP Display Name and ...
    //

    //
    // Get the LDAP server name
    //
    hr = BuildLDAPPathFromADsPath2(
                szADsPath,
                &pszParentLDAPServer,
                &pszParentLDAPDn,
                &dwPort
                );
    BAIL_ON_FAILURE(hr);

    if ( szSubSchemaSubEntry == NULL )  // not NTDS
    {
        hr = E_NOTIMPL;
        BAIL_ON_FAILURE(hr);
    }
    //
    // Get the name of the schema object
    //
    pszLDAPDn = (LPTSTR) AllocADsMem((_tcslen(szRelativeName )
                          + _tcslen( _tcschr(szSubSchemaSubEntry,TEXT(',')))
                           ) * sizeof(TCHAR));  // includes "\\"

    if ( pszLDAPDn == NULL ){
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    _tcscpy( pszLDAPDn, szRelativeName );
    _tcscat( pszLDAPDn, _tcschr( szSubSchemaSubEntry, TEXT(',')) );

    if ( aValues )
    {
        LdapValueFree( aValues );
        aValues = NULL;
        nCount = 0;
    }

    //
    //  Validate the class name first
    //
    hr = LdapReadAttribute(
                    pszParentLDAPServer,
                    pszLDAPDn,
                    TEXT("objectClass"),
                    &aValues,
                    &nCount,
                    Credentials,
                    dwPort
                    );
    BAIL_ON_FAILURE(hr);

    if ( nCount > 0 )
    {
        if ( _tcsicmp( szClassName, GET_BASE_CLASS( aValues, nCount) ) != 0 )
        {
            hr = E_ADS_BAD_PARAMETER;
            BAIL_ON_FAILURE(hr);
        }
    }

    //
    // Class name has been verified, so delete the object
    //
    hr = LdapDeleteS(
                    ld,
                    pszLDAPDn
                    );
    BAIL_ON_FAILURE(hr);

error:

    if (pszParentLDAPServer) {
        FreeADsStr(pszParentLDAPServer);
    }

    if (pszParentLDAPDn) {
       FreeADsStr(pszParentLDAPDn);
    }
    if (pszLDAPDn) {
        FreeADsStr(pszLDAPDn);
    }

    if ( aValues ) {
        LdapValueFree( aValues );
    }

    if ( ld ) {
        LdapCloseObject( ld );
    }

    RRETURN(hr);
}

*/


//
// ******** Important usage note **********
//  Users of this function must make sure that cn is part of
// the list of attributes passed in. This is a requirement and
// the array must contain a NULL string as the last element.
// ******** Important usage note **********
//
HRESULT
BuildSchemaLDAPPathAndGetAttribute(
    IN LPTSTR pszParent,
    IN LPTSTR pszName,
    IN LPTSTR pszSubSchemaSubEntry,
    IN BOOL fNew,
    IN CCredentials& Credentials,
    IN LPTSTR pszAttribs[],
    OUT LPWSTR * ppszSchemaLDAPServer,
    OUT LPWSTR * ppszSchemaLDAPDn,
    IN OUT PADS_LDP *ppLd,              // optional in,
    OUT PLDAPMessage *ppRes             // caller need to get first entry
)
{
    HRESULT hr = S_OK;
    LPTSTR pszLDAPServer = NULL;
    LPWSTR pszLDAPDn = NULL;
    DWORD dwPort = 0;
    BOOL  fOpenLd = FALSE;
    LPTSTR pszSchemaRoot = NULL;
    TCHAR szFilter[MAX_PATH] = BEGIN_FILTER;    // name on ldap svr
    LDAPMessage *pE = NULL;
    int nCount = 0;
    LPTSTR pszClassName = NULL;
    LPTSTR *aValues = NULL;
    int nNumberOfEntries = 0;


    if ( !ppszSchemaLDAPServer || !ppszSchemaLDAPDn || !ppLd || !ppRes)
    {
        RRETURN(E_ADS_BAD_PARAMETER);
    }


    //
    //  Using pszSubSchemaSubEntry to test NTDS is no longer accurate.
    //  But the following codes are written to work for NTDS.
    //

    if ( pszSubSchemaSubEntry == NULL )   // not NTDS
    {
        hr = E_NOTIMPL;
        BAIL_IF_ERROR(hr);
    }


    //
    // Get the server name & port #
    //

    hr = BuildLDAPPathFromADsPath2(
             pszParent,
             &pszLDAPServer,
             &pszLDAPDn,
             &dwPort
             );
    BAIL_IF_ERROR(hr);


    //
    // Connect and bind to schema Root object (in NTDS only)
    //

    pszSchemaRoot = _tcschr(                    // strip CN=Aggregate
                        pszSubSchemaSubEntry,
                        TEXT(',')
                        );

    if ( *ppLd == NULL )
    {
        hr = LdapOpenObject(
                pszLDAPServer,
                pszSchemaRoot+1,    // go past ",", we've stripped CN=Aggregate
                ppLd,
                Credentials,
                dwPort
                );
        BAIL_IF_ERROR(hr);

        fOpenLd = TRUE;
    }


    //
    // Set Serach Filter to (& (lDAPDisplayName=<pszName>)
    //                         (! (isDefunct=TRUE) )
    //                      )
    //

     _tcscat( szFilter, pszName );
     _tcscat( szFilter, END_FILTER );

    //
    // Search for scheam pszName (class object) under schema root
    //

    hr = LdapSearchS(
            *ppLd,
            pszSchemaRoot+1,        // go past ",", we've stripped CN=Aggregate
            LDAP_SCOPE_ONELEVEL,
            szFilter,
            pszAttribs,
            0,
            ppRes
            );

    //
    // Confirm with anoopa & johnsona (ntds5) :
    //      If 1 out of the 2 attributes asked for is not on the svr,
    //      LdapSearchS (ldap_search_s) returns the 1 located and hr = S_OK
    //
    BAIL_IF_ERROR(hr);


    //
    // Only one active entry should be returned.
    // If more than one entry is returned, return E_ADS_SCHEMA_VIOLATION
    // Get cn to build schemalLDAPDn
    //

    nNumberOfEntries = LdapCountEntries( *ppLd, *ppRes );

    if ( nNumberOfEntries != 1 )
        RRETURN(E_ADS_SCHEMA_VIOLATION);

    if ( fNew)      // ? still keep this
    {
        pszClassName = pszName;
    }
    else
    {
        hr = LdapFirstEntry(
                *ppLd,
                *ppRes,
                &pE
                );
        BAIL_IF_ERROR(hr);

        hr = LdapGetValues(
                *ppLd,
                pE,
                L"cn",
                &aValues,
                &nCount
                );
        BAIL_IF_ERROR(hr);

        if (nCount == 0)
        {
            // use lDAPDisplayName as common name (cn) if cn not set on svr
            pszClassName = pszName;
        }
        else
        {
            pszClassName = aValues[0];
        }
    }

    if (pszLDAPServer!=NULL)
    {
        *ppszSchemaLDAPServer = (LPWSTR) AllocADsStr(
                                        pszLDAPServer
                                        );

        if (*ppszSchemaLDAPServer == NULL)
        {
            hr = E_OUTOFMEMORY;
            BAIL_IF_ERROR(hr);
        }
    }
    else    // pszLDAPServer allowed to be NULL
    {
        *ppszSchemaLDAPServer = NULL;
    }

    *ppszSchemaLDAPDn =  (LPWSTR) AllocADsMem(
                                        (_tcslen(L"CN=") +
                                         _tcslen(pszClassName) +
                                         _tcslen(pszSchemaRoot) + 1 ) *
                                         sizeof(TCHAR)
                                        );
    if ( *ppszSchemaLDAPDn == NULL )
    {
        hr = E_OUTOFMEMORY;
        BAIL_IF_ERROR(hr);
    }

    _tcscpy( *ppszSchemaLDAPDn, L"CN=");
    _tcscat( *ppszSchemaLDAPDn, pszClassName );
    _tcscat( *ppszSchemaLDAPDn, pszSchemaRoot );


    //
    // clean up for both success and failure
    //

    if ( pszLDAPServer )
        FreeADsStr( pszLDAPServer );

    if (pszLDAPDn) {
        FreeADsMem( pszLDAPDn );
    }

    if ( aValues )
        LdapValueFree( aValues );


    RRETURN(hr);


cleanup:

    //
    // clean up if failure only
    //
    if (fOpenLd==TRUE)  {
        LdapCloseObject(*ppLd);
        *ppLd= NULL;
    }

    if (*ppRes) {
        LdapMsgFree(*ppRes);
        *ppRes=NULL;
    }

    if (*ppszSchemaLDAPServer) {
        FreeADsStr(*ppszSchemaLDAPServer);
        *ppszSchemaLDAPServer=NULL;
    }

    if (*ppszSchemaLDAPDn) {
        FreeADsMem(*ppszSchemaLDAPDn);
        *ppszSchemaLDAPDn=NULL;
    }

    RRETURN(hr);
}


HRESULT
BuildSchemaLDAPPath(
    LPTSTR pszParent,
    LPTSTR pszName,
    LPTSTR pszSubSchemaSubEntry,
    LPWSTR * ppszSchemaLDAPServer,
    LPWSTR * ppszSchemaLDAPDn,
    BOOL   fNew,
    ADS_LDP   **pld,
    CCredentials& Credentials
)
{
    HRESULT hr = S_OK;
    LPTSTR *aValues = NULL;
    LPTSTR *aValues2 = NULL;
    int nCount = 0;
    TCHAR szFilter[MAX_PATH] = TEXT("lDAPDisplayName=");
    LPTSTR aStrings[2];
    LDAPMessage *res = NULL;
    LDAPMessage *e = NULL;
    LPTSTR pszLDAPServer = NULL;
    LPWSTR pszLDAPDn = NULL;
    DWORD dwPort = 0;

    LPTSTR pszSchemaRoot = NULL;
    LPTSTR pszClassName = NULL;

    //
    // Get the server name
    //

    hr = BuildLDAPPathFromADsPath2(
             pszParent,
             &pszLDAPServer,
             &pszLDAPDn,
             &dwPort
             );
    BAIL_IF_ERROR(hr);

    if ( pszSubSchemaSubEntry == NULL )   // not NTDS
    {
        hr = E_NOTIMPL;
        BAIL_IF_ERROR(hr);
    }

    // the _tcschr is to get rid of "CN=Aggregate"

    pszSchemaRoot = _tcschr(pszSubSchemaSubEntry, TEXT(','));

    if ( fNew )
    {
        pszClassName = pszName;
    }
    else
    {
        _tcscat( szFilter, pszName );
        aStrings[0] = TEXT("cn");
        aStrings[1] = NULL;

        if ( *pld == NULL )
        {
            hr = LdapOpenObject(
                pszLDAPServer,
                pszSchemaRoot  + 1,     // go past the , - we've stripped off "CN=Aggregate"
                pld,
                Credentials,
                dwPort
                );
        BAIL_IF_ERROR(hr);

        }

        hr = LdapSearchS(
                       *pld,
                       pszSchemaRoot + 1,
                       LDAP_SCOPE_ONELEVEL,
                       szFilter,
                       aStrings,
                       0,
                       &res
                       );

       // Only one entry should be returned

       if (FAILED(hr)
          || (FAILED(hr = LdapFirstEntry( *pld, res, &e )))
          || (FAILED(hr = LdapGetValues( *pld, e, aStrings[0], &aValues2, &nCount)))
          )
       {
           BAIL_IF_ERROR(hr);
       }

       if ( nCount == 0 )
           pszClassName = pszName;
       else
           pszClassName = aValues2[0];
    }


    *ppszSchemaLDAPServer = (LPWSTR)AllocADsStr(pszLDAPServer);
    //
    // pszLDAPServer might be NULL, in which case NULL is the
    // expected return value from the alloc.
    //
    if ( (*ppszSchemaLDAPServer == NULL) && pszLDAPServer) {
        hr = E_OUTOFMEMORY;
        BAIL_IF_ERROR(hr);
    }

    *ppszSchemaLDAPDn =  (LPTSTR) AllocADsMem(
                                            (_tcslen(L"CN=") +
                                            _tcslen(pszClassName) +
                                            _tcslen(pszSchemaRoot) + 1 ) *
                                            sizeof(TCHAR));

    if ( *ppszSchemaLDAPDn == NULL )
    {
        hr = E_OUTOFMEMORY;
        BAIL_IF_ERROR(hr);
    }
    _tcscpy( *ppszSchemaLDAPDn, L"CN=");
    _tcscat( *ppszSchemaLDAPDn, pszClassName );
    _tcscat( *ppszSchemaLDAPDn, pszSchemaRoot );

cleanup:

    if ( aValues )
        LdapValueFree( aValues );

    if ( aValues2 )
        LdapValueFree( aValues2 );

    if ( pszLDAPServer )
        FreeADsStr( pszLDAPServer );

    if (pszLDAPDn) {
        FreeADsStr( pszLDAPDn);
    }

    if ( res )
        LdapMsgFree( res );

    RRETURN(hr);
}

HRESULT
MakePropArrayFromVariant(
    VARIANT vProp,
    SCHEMAINFO *hSchema,
    int **pOIDs,
    DWORD *pnNumOfOids )
{
    HRESULT hr = S_OK;
    int nIndex;
    LONG dwSLBound;
    LONG dwSUBound;
    LONG i = 0;
    LONG j, k;
    DWORD nCurrent = 0;

    *pOIDs = NULL;
    *pnNumOfOids = 0;

    if ( !V_ISARRAY( &vProp))
    {
        // special case of one object (not an array)

        nIndex = FindSearchTableIndex( V_BSTR(&vProp),
                                       hSchema->aPropertiesSearchTable,
                                       hSchema->nNumOfProperties * 2 );

        if ( nIndex != -1 )
        {
            *pOIDs = (int *) AllocADsMem( sizeof(int) * 2);
            if ( *pOIDs == NULL )
            {
                hr = E_OUTOFMEMORY;
                BAIL_ON_FAILURE(hr);
            }

            (*pOIDs)[nCurrent++] = nIndex;
            (*pOIDs)[nCurrent] = -1;
            *pnNumOfOids = 1;
        }
        else
        {
            hr = E_ADS_PROPERTY_NOT_FOUND;
        }

        RRETURN_EXP_IF_ERR(hr);
    }

    //
    // Here, we have an array of properties. We want to create an array of
    // indexes into the aPropertiesSearchTable
    //

    hr = SafeArrayGetLBound(V_ARRAY(&vProp),
                            1,
                            (long FAR *)&dwSLBound
                            );
    BAIL_ON_FAILURE(hr);

    hr = SafeArrayGetUBound(V_ARRAY(&vProp),
                            1,
                            (long FAR *)&dwSUBound
                            );
    BAIL_ON_FAILURE(hr);

    *pOIDs = (int *) AllocADsMem( sizeof(int) * (dwSUBound - dwSLBound + 2));
    if ( *pOIDs == NULL )
    {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    for (i = dwSLBound; i <= dwSUBound; i++) {

        VARIANT v;

        VariantInit(&v);
        hr = SafeArrayGetElement(V_ARRAY(&vProp),
                                (long FAR *)&i,
                                &v
                                );
        BAIL_ON_FAILURE(hr);

        nIndex = FindSearchTableIndex( V_BSTR(&v),
                                       hSchema->aPropertiesSearchTable,
                                       hSchema->nNumOfProperties * 2 );

        VariantClear(&v);

        if ( nIndex != -1 )
        {
            (*pOIDs)[nCurrent++] = nIndex;
        }
        else
        {
            hr = E_ADS_PROPERTY_NOT_FOUND;
            BAIL_ON_FAILURE(hr);
        }
    }

    (*pOIDs)[nCurrent] = -1;
    *pnNumOfOids = nCurrent;

    SortAndRemoveDuplicateOIDs( *pOIDs, pnNumOfOids );

error:

    if (FAILED(hr))
    {
        if ( *pOIDs )
        {
            FreeADsMem( *pOIDs );
            *pOIDs = NULL;
        }
    }

    RRETURN(hr);

}

HRESULT
MakePropArrayFromStringArray(
    LPTSTR *aValues,
    DWORD  nCount,
    SCHEMAINFO *hSchema,
    int **pOIDs,
    DWORD *pnNumOfOids
)
{
    HRESULT hr = S_OK;
    int nIndex;
    DWORD i = 0;
    DWORD nCurrent = 0;

    *pOIDs = NULL;
    *pnNumOfOids = 0;

    //
    // Here, we have an array of properties. We want to create an array of
    // indexes into the aPropertiesSearchTable
    //

    *pOIDs = (int *) AllocADsMem( sizeof(int) * (nCount+1));
    if ( *pOIDs == NULL )
    {
        hr = E_OUTOFMEMORY;
        BAIL_ON_FAILURE(hr);
    }

    for (i = 0; i < nCount ; i++) {

        nIndex = FindSearchTableIndex( aValues[i],
                                       hSchema->aPropertiesSearchTable,
                                       hSchema->nNumOfProperties * 2 );

        if ( nIndex != -1 )
        {
            (*pOIDs)[nCurrent++] = nIndex;
        }
        else
        {
            hr = E_ADS_PROPERTY_NOT_FOUND;
            BAIL_ON_FAILURE(hr);
        }
    }

    (*pOIDs)[nCurrent] = -1;
    *pnNumOfOids = nCurrent;

    qsort( *pOIDs, *pnNumOfOids, sizeof((*pOIDs)[0]), intcmp );

error:

    if (FAILED(hr))
    {
        if ( *pOIDs )
        {
            FreeADsMem( *pOIDs );
            *pOIDs = NULL;
        }
    }

    RRETURN(hr);
}

/******************************************************************/
/*  Misc Schema functions
/******************************************************************/

BOOL
GetLdapClassPrimaryInterface(
    LPTSTR  pszLdapClass,
    GUID  **ppPrimaryInterfaceGUID,
    GUID  **ppCLSID
)
{
    for ( int i = 0; i < ARRAY_SIZE(aClassMap); i++ )
    {
        if ( _tcsicmp( pszLdapClass, aClassMap[i].pszLdapClassName ) == 0 )
        {
            *ppPrimaryInterfaceGUID = (GUID *) aClassMap[i].pPrimaryInterfaceGUID;
            *ppCLSID = (GUID *) aClassMap[i].pCLSID;
            return TRUE;
        }
    }

    return FALSE;
}

BOOL
GetPrimaryInterface(
    LPTSTR pszClassName,
    SCHEMAINFO *pSchemaInfo,
    PCLASSNAME_LIST pClassNames,
    GUID **ppPrimaryInterfaceGUID,
    GUID **ppCLSID
)
{
    int i = 0;
    CLASSINFO *pClassInfo;
    LPTSTR pszName;
    DWORD index;

    PCLASSNAME_LIST pClass = NULL;
    PCLASSNAME_LIST pNextClass = NULL;
    BOOL fExitStatus = FALSE;

    if ( GetLdapClassPrimaryInterface( pszClassName,
                                       ppPrimaryInterfaceGUID,
                                       ppCLSID ))
    {
        return TRUE;
    }

    index = (DWORD) FindEntryInSearchTable(
                        pszClassName,
                        pSchemaInfo->aClassesSearchTable,
                        2 * pSchemaInfo->nNumOfClasses );

    if ( index == ((DWORD) -1) )
        return FALSE;

    //
    // Recursively search the list of superiors and
    // aux classes.  To avoid loops, we maintain a list
    // of classes we have already reached.  If we are called
    // with a class on this list, we abort.
    //

    //
    // Make sure the current class isn't already on the list
    //
    if (pClassNames) {

        for (pNextClass = pClassNames;
             pNextClass != NULL;
             pNextClass = pNextClass->pNext)
        {

            if (_tcscmp(pNextClass->pszClassName, pszClassName) == 0)
            {
                // found match, bail
                fExitStatus = FALSE;
                BAIL_ON_SUCCESS(S_OK);
            }
        }
    }

    //
    // Construct a node for the current class & add it to the list
    //
    pClass = static_cast<PCLASSNAME_LIST>(AllocADsMem(sizeof(CLASSNAME_LIST)));
    if (!pClass) {
        BAIL_ON_FAILURE(E_OUTOFMEMORY);
    }

    pClass->pszClassName = static_cast<LPTSTR>(AllocADsMem((_tcslen(pszClassName)+1) * sizeof(TCHAR)));
    if (!pClass->pszClassName) {
        BAIL_ON_FAILURE(E_OUTOFMEMORY);
    }

    _tcscpy(pClass->pszClassName, pszClassName);

    pClass->pNext = pClassNames;
    

    //
    // Perform the recursive search
    //
    pClassInfo = &(pSchemaInfo->aClasses[index]);

    if ( pClassInfo->pOIDsSuperiorClasses )
    {
        for ( i = 0;
              (pszName = pClassInfo->pOIDsSuperiorClasses[i]);
              i++  )
        {
            if ( GetPrimaryInterface( pszName, pSchemaInfo, pClass,
                                      ppPrimaryInterfaceGUID, ppCLSID )) 
            {
                fExitStatus = TRUE;
                BAIL_ON_SUCCESS(S_OK);
            }
        }
    }

    if ( pClassInfo->pOIDsAuxClasses )
    {
        for ( i = 0;
              (pszName = pClassInfo->pOIDsAuxClasses[i]);
              i++  )
        {
            if ( GetPrimaryInterface( pszName, pSchemaInfo, pClass,
                                      ppPrimaryInterfaceGUID, ppCLSID )) 
            {
                fExitStatus = TRUE;
                BAIL_ON_SUCCESS(S_OK);
            }
        }
    }

error:

    //
    // Each level of recursion is responsible for freeing
    // its own corresponding node.
    //
    if (pClass) {

        if (pClass->pszClassName) {
            FreeADsMem(pClass->pszClassName);
        }
    
        FreeADsMem(pClass);
    }

    return fExitStatus;
}

HRESULT
SchemaGetPrimaryInterface(
    LDAP_SCHEMA_HANDLE hSchema,
    LPTSTR pszClassName,
    GUID **ppPrimaryInterfaceGUID,
    GUID **ppCLSID
)
{
    HRESULT hr = S_OK;
    SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;

    if ( !pSchemaInfo )
        RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);

    GetPrimaryInterface(
        pszClassName,
        pSchemaInfo,
        NULL,
        ppPrimaryInterfaceGUID,
        ppCLSID );

    RRETURN(hr);
}


BOOL
MapLdapClassToADsClass(
    LPTSTR *aLdapClasses,
    int nCount,
    LPTSTR pszADsClass
)
{
    *pszADsClass = 0;

    if ( nCount == 0 )
        return FALSE;

    if ( _tcsicmp( aLdapClasses[nCount-1], TEXT("Top")) == 0 )
    {
        for ( int j = 0; j < nCount; j++ )
        {
            LPTSTR pszLdapClass = aLdapClasses[j];

            for ( int i = 0; i < ARRAY_SIZE(aClassMap); i++ )
            {
                if ( _tcsicmp( pszLdapClass, aClassMap[i].pszLdapClassName ) == 0 )
                {
                    _tcscpy( pszADsClass, aClassMap[i].pszADsClassName );
                    return TRUE;
                }
            }
        }

        _tcscpy( pszADsClass, aLdapClasses[0] );
        return FALSE;

    }
    else
    {
        for ( int j = nCount-1; j >= 0; j-- )
        {
            LPTSTR pszLdapClass = aLdapClasses[j];

            for ( int i = 0; i < ARRAY_SIZE(aClassMap); i++ )
            {
                if ( _tcsicmp( pszLdapClass, aClassMap[i].pszLdapClassName ) == 0 )
                {
                    _tcscpy( pszADsClass, aClassMap[i].pszADsClassName );
                    return TRUE;
                }
            }
        }

        _tcscpy( pszADsClass, aLdapClasses[nCount-1] );
        return FALSE;
    }

}

BOOL
MapLdapClassToADsClass(
    LPTSTR pszClassName,
    LDAP_SCHEMA_HANDLE hSchema,
    LPTSTR pszADsClass
)
{
    LPTSTR aClasses[1];
    CLASSINFO *pClassInfo = NULL;
    SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;

    *pszADsClass = 0;

    aClasses[0] = pszClassName;
    if ( MapLdapClassToADsClass( aClasses, 1, pszADsClass ))
        return TRUE;

    DWORD index = (DWORD) FindEntryInSearchTable(
                        pszClassName,
                        pSchemaInfo->aClassesSearchTable,
                        2 * pSchemaInfo->nNumOfClasses );

    if ( index == ((DWORD) -1) )  // cannot find the class name in the schema
    {
        _tcscpy( pszADsClass, pszClassName );
        return FALSE;
    }

    pClassInfo = &(pSchemaInfo->aClasses[index]);

    if ( pClassInfo->pOIDsSuperiorClasses )
    {
        LPTSTR pszName = NULL;
        for ( int i = 0;
              (pszName = pClassInfo->pOIDsSuperiorClasses[i]);
              i++  )
        {
            if ( MapLdapClassToADsClass( pszName, pSchemaInfo, pszADsClass))
                return TRUE;
        }
    }

    _tcscpy( pszADsClass, pszClassName );
    return FALSE;
}

LPTSTR
MapADsClassToLdapClass(
    LPTSTR pszADsClass,
    LPTSTR pszLdapClass
)
{
    for ( int i=0; i < ARRAY_SIZE(aClassMap); i++ )
    {
        if ( _tcsicmp( pszADsClass, aClassMap[i].pszADsClassName ) == 0 )
        {
            _tcscpy( pszLdapClass, aClassMap[i].pszLdapClassName );
            return pszLdapClass;
        }
    }

    _tcscpy( pszLdapClass, pszADsClass );
    return pszLdapClass;
}


STDMETHODIMP
makeUnionVariantFromLdapObjects(
    LDAPOBJECTARRAY ldapSrcObjects1,
    LDAPOBJECTARRAY ldapSrcObjects2,
    VARIANT FAR * pvPossSuperiors
    )
{
    HRESULT hr = S_OK;
    BSTR *retVals = NULL;
    DWORD dwNumVals = 0;
    BSTR curString = NULL;
    DWORD dwMaxVals = 0;
    DWORD dwCtr = 0;
    DWORD dwArrIndx = 0;
    PLDAPOBJECT pLdapObject;

    dwMaxVals = ldapSrcObjects1.dwCount + ldapSrcObjects2.dwCount + 1;

    retVals = (BSTR *)AllocADsMem(dwMaxVals * sizeof(BSTR *));

    if (!retVals) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }


    for (dwCtr = 0; dwCtr < ldapSrcObjects1.dwCount; dwCtr++) {

        pLdapObject = ldapSrcObjects1.pLdapObjects + dwCtr;
        curString = LDAPOBJECT_STRING(pLdapObject);
        hr = addStringIfAbsent(curString, retVals, &dwArrIndx);
        BAIL_ON_FAILURE(hr);
    }


    for (dwCtr = 0; dwCtr < ldapSrcObjects2.dwCount; dwCtr++) {

        pLdapObject = ldapSrcObjects2.pLdapObjects + dwCtr;
        curString = LDAPOBJECT_STRING(pLdapObject);
        hr = addStringIfAbsent(curString, retVals, &dwArrIndx);
        BAIL_ON_FAILURE(hr);
    }

    // do the same for the second ldapobjectarray

    hr = MakeVariantFromStringArray(retVals, pvPossSuperiors);

error:
    // clean up the string array either way
    for (dwCtr=0; dwCtr < dwArrIndx; dwCtr++) {
        ADsFreeString(retVals[dwCtr]);
    }
    FreeADsMem(retVals);

    RRETURN(hr);
}

STDMETHODIMP
addStringIfAbsent(
    BSTR addString,
    BSTR *strArray,
    PDWORD dwArrIndx
    )
{
    HRESULT hr = S_OK;
    DWORD dwCtr = 0;
    BOOLEAN fFound = FALSE;

    for (dwCtr = 0; (dwCtr < *dwArrIndx) && !fFound; dwCtr ++) {
        if (!_wcsicmp(addString, strArray[dwCtr])) {
            fFound = TRUE;
        }
    }

    if (!fFound) {

        hr = ADsAllocString(
                 addString,
                 &strArray[*dwArrIndx]
                 );

        BAIL_ON_FAILURE(hr);

        (*dwArrIndx)++;

        strArray[*dwArrIndx] = NULL;
    }

error:

    RRETURN(hr);

}