windows-xp/Source/XPSP1/NT/ds/adsi/router/utilprop.cxx

//-- == 0-------------------------------------------------------------------------
//
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1995
//
//  File:  utilprop.cxx
//
//  Contents:
//
//
//  History:   08-28-96     shanksh    Created.
//
//----------------------------------------------------------------------------
// Notes - there are two main methods in this module:
//     - CUtilProps::GetPropertyInfo, a helper function for
//       GetProperty method on Data Source
//     - CUtilProps::GetProperties, a helper function for
//       GetProperties method on Data Source, Session and Command objects
//     - CUtilProps::SetProperties, a helper function for
//       SetProperties method on Data Source, Session and Command objects
//
//
// The implementation is very simple - we keep a global table of the
// properties we support in s_rgprop. We search this table sequentially.
// 

#include "oleds.hxx"
#pragma hdrstop

PROPSTRUCT s_rgDBInitProp[] =
{
    {DBPROP_AUTH_PASSWORD,         F_DBINITRW, VT_BSTR, VARIANT_FALSE, 0,            OPT_REQ, NULL, L"Password"},
    {DBPROP_AUTH_USERID,           F_DBINITRW, VT_BSTR, VARIANT_FALSE, 0,            OPT_REQ, NULL, L"User ID"},
    {DBPROP_AUTH_ENCRYPT_PASSWORD, F_DBINITRW, VT_BOOL, VARIANT_FALSE, 0,            OPT_REQ, NULL, L"Encrypt Password"},
    {DBPROP_AUTH_INTEGRATED,       F_DBINITRW, VT_BSTR, VARIANT_FALSE, 0,            OPT_REQ, NULL, L"Integrated Security"},
    {DBPROP_INIT_DATASOURCE,       F_DBINITRW, VT_BSTR, VARIANT_FALSE, 0,            OPT_REQ, NULL, L"Data Source"},
    {DBPROP_INIT_LOCATION,         F_DBINITRW, VT_BSTR, VARIANT_FALSE, 0,            OPT_REQ, NULL, L"Location"},
    {DBPROP_INIT_PROVIDERSTRING,   F_DBINITRW, VT_BSTR, VARIANT_FALSE, 0,            OPT_REQ, NULL, L"Extended Properties"},
    {DBPROP_INIT_TIMEOUT,          F_DBINITRW, VT_I4,   VARIANT_FALSE, 90,           OPT_REQ, NULL, L"Connect Timeout"},
    {DBPROP_INIT_PROMPT,           F_DBINITRW, VT_I2,   VARIANT_FALSE, DBPROMPT_NOPROMPT, OPT_REQ, NULL,  L"Prompt"},
    {DBPROP_INIT_HWND,             F_DBINITRW, VT_I4,   VARIANT_FALSE, 0,            OPT_REQ, NULL, L"Window Handle"},
    {DBPROP_INIT_MODE,             F_DBINITRW, VT_I4,   VARIANT_FALSE, DB_MODE_READ,      OPT_REQ, NULL, L"Mode"}
#if (!defined(BUILD_FOR_NT40)) 
    ,
    {DBPROP_INIT_BINDFLAGS,        F_DBINITRW, VT_I4,   VARIANT_FALSE, 0,            OPT_REQ, NULL, L"Bind Flags"}
#endif
};

PROPSTRUCT s_rgADSIBindProp[] =
{
    // initialize this property to a reserved value. The client is not supposed
    // to set this property to the reserved value. This reserved value prevents
    // ADSIFLAG from overriding ENCRYPT_PASSWORD when VB initializes this
    // property to its default value. See IsValidValue().

    {ADSIPROP_ADSIFLAG,            F_DBINITRW, VT_I4,   VARIANT_FALSE, 
     ADS_AUTH_RESERVED, OPT_REQ, NULL, L"ADSI Flag"} 
};

PROPSTRUCT s_rgDSInfoProp[] =
{
    {DBPROP_ACTIVESESSIONS,             F_DSRO,    VT_I4,   VARIANT_FALSE, 0, OPT_REQ, NULL,                                              L"Active Sessions"},
    {DBPROP_BYREFACCESSORS,             F_DSRO,    VT_BOOL, VARIANT_FALSE, 1, OPT_REQ, NULL,                                              L"Pass By Ref Accessors"},
    {DBPROP_CATALOGLOCATION,            F_DSRO,    VT_I4,   VARIANT_FALSE, DBPROPVAL_CL_START, OPT_REQ, NULL,                             L"Catalog Location"},
    {DBPROP_CATALOGTERM,                F_DSRO,    VT_BSTR, VARIANT_FALSE, 0, OPT_REQ, NULL,                                              L"Catalog Term"},
    {DBPROP_CATALOGUSAGE,               F_DSRO,    VT_I4,   VARIANT_FALSE, 0, OPT_REQ, NULL,                                              L"Catalog Usage"},
    {DBPROP_DATASOURCENAME,             F_DSRO,    VT_BSTR, VARIANT_FALSE, 0, OPT_REQ, L"Active Directory Service Interfaces",            L"Data Source Name"},
    {DBPROP_DATASOURCEREADONLY,         F_DSRO,    VT_BOOL, VARIANT_TRUE,  0, OPT_REQ, NULL,                                              L"Read-Only Data Source"},
//  {DBPROP_DBMSNAME,                   F_DSRO,    VT_BSTR, VARIANT_FALSE, 0, OPT_REQ, NULL,                                              L"DBMS Name"},
//  {DBPROP_DBMSVER,                    F_DSRO,    VT_BSTR, VARIANT_FALSE, 0, OPT_REQ, NULL,                                              L"DBMS Version"},
    {DBPROP_DSOTHREADMODEL,             F_DSRO,    VT_I4,   VARIANT_FALSE, DBPROPVAL_RT_FREETHREAD, OPT_REQ, NULL,                        L"Data Source Object Threading Model"},
    {DBPROP_MAXROWSIZE,                 F_DSRO,    VT_I4,   VARIANT_FALSE, 0, OPT_SIC, NULL,                                              L"Maximum Row Size"},
#if (!defined(BUILD_FOR_NT40))
    {DBPROP_OLEOBJECTS,                 F_DSRO,    VT_I4,   VARIANT_FALSE, DBPROPVAL_OO_ROWOBJECT | DBPROPVAL_OO_DIRECTBIND | DBPROPVAL_OO_SINGLETON, OPT_REQ, NULL, L"OLE Object Support"},
#endif
    {DBPROP_PERSISTENTIDTYPE,           F_DSRO,    VT_I4,   VARIANT_FALSE, DBPROPVAL_PT_NAME, OPT_SIC, NULL,                              L"Persistent ID Type"},
    {DBPROP_PROVIDERFRIENDLYNAME,       F_DSRO,    VT_BSTR, VARIANT_FALSE, 0, OPT_REQ, L"Microsoft OLE DB Provider for ADSI",             L"Provider Friendly Name"},
    {DBPROP_PROVIDERNAME,               F_DSRO,    VT_BSTR, VARIANT_FALSE, 0, OPT_REQ, L"ACTIVEDS.DLL",                                   L"Provider Name"},
    {DBPROP_PROVIDEROLEDBVER,           F_DSRO,    VT_BSTR, VARIANT_FALSE, 0, OPT_REQ, L"02.50",                                          L"OLE DB Version"},
    {DBPROP_PROVIDERVER,                F_DSRO,    VT_BSTR, VARIANT_FALSE, 0, OPT_REQ, L"02.50.0000",                                     L"Provider Version"},
    {DBPROP_SQLSUPPORT,                 F_DSRO,    VT_I4,   VARIANT_FALSE, DBPROPVAL_SQL_ODBC_MINIMUM, OPT_REQ, NULL,                     L"SQL Support"},
    {DBPROP_ROWSETCONVERSIONSONCOMMAND, F_DSRO,    VT_BOOL, VARIANT_TRUE,  0, OPT_REQ, NULL,                                              L"Rowset Conversions on Command"},
    {DBPROP_USERNAME,                   F_DSRO,    VT_BSTR, VARIANT_FALSE, 0, OPT_REQ, NULL,                                              L"User Name"}
};

PROPSTRUCT s_rgRowsetProp[] =
{
    {DBPROP_IAccessor,                       F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IAccessor"},
    {DBPROP_IColumnsInfo,                    F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IColumnsInfo"},
#if (!defined(BUILD_FOR_NT40))
    {DBPROP_IColumnsInfo2,                   F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IColumnsInfo2"},
#endif
    {DBPROP_IConvertType,                    F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IConvertType"},
#if (!defined(BUILD_FOR_NT40))
    {DBPROP_IGetSession,                     F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IGetSession"},
    {DBPROP_IRow,                            F_ROWSETRW,     VT_BOOL, VARIANT_FALSE,    0, OPT_REQ, NULL, L"IRow"},
    {DBPROP_IGetRow,                         F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IGetRow"},
#endif
    {DBPROP_IRowset,                         F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IRowset"},
    {DBPROP_IRowsetIdentity,                 F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,   0, OPT_SIC, NULL, L"IRowsetIdentity"},
    {DBPROP_IRowsetInfo,                     F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IRowsetInfo"},
    {DBPROP_IRowsetLocate,                   F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IRowsetLocate"},
    {DBPROP_IRowsetScroll,                   F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"IRowsetScroll"},
    {DBPROP_ABORTPRESERVE,                   F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_REQ, NULL, L"Preserve on Abort"},
    {DBPROP_BLOCKINGSTORAGEOBJECTS,          F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"Blocking Storage Objects"},
    {DBPROP_BOOKMARKS,                       F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"Use Bookmarks"},
    {DBPROP_BOOKMARKSKIPPED,                 F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_REQ, NULL, L"Skip Deleted Bookmarks"},
    {DBPROP_BOOKMARKTYPE,                    F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   DBPROPVAL_BMK_NUMERIC, OPT_REQ, NULL, L"Bookmark Type"},
    {DBPROP_CANFETCHBACKWARDS,               F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,   0, OPT_SIC, NULL, L"Fetch Backwards"},
    {DBPROP_CANHOLDROWS,                     F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,   0, OPT_SIC, NULL, L"Hold Rows"},
    {DBPROP_CANSCROLLBACKWARDS,              F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,   0, OPT_SIC, NULL, L"Scroll Backwards"},
    {DBPROP_COLUMNRESTRICT,                  F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_SIC, NULL, L"Column Privileges"},
    {DBPROP_COMMITPRESERVE,                  F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_REQ, NULL, L"Preserve on Commit"},
    {DBPROP_IMMOBILEROWS,                    F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_SIC, NULL, L"Immobile Rows"},
    {DBPROP_LITERALBOOKMARKS,                F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_SIC, NULL, L"Literal Bookmarks"},
    {DBPROP_LITERALIDENTITY,                 F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,   0, OPT_REQ, NULL, L"Literal Row Identity"},
    {DBPROP_MAXOPENROWS,                     F_ROWSETRW,     VT_I4,   VARIANT_FALSE,   0, OPT_SIC, NULL, L"Maximum Open Rows"},
    {DBPROP_MAXPENDINGROWS,                  F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_SIC, NULL, L"Maximum Pending Rows"},
    {DBPROP_MAXROWS,                         F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_SIC, NULL, L"Maximum Rows"},
    {DBPROP_NOTIFICATIONPHASES,              F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Notification Phases"},
//  {DBPROP_NOTIFYCOLUMNRECALCULATED,        F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"NotifyColumnRecalculated"},
    {DBPROP_NOTIFYCOLUMNSET,                 F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Column Set Notification"},
//  {DBPROP_NOTIFYROWACTIVATE,               F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"NotifyRowActivate"},
    {DBPROP_NOTIFYROWDELETE,                 F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Row Delete Notification"},
    {DBPROP_NOTIFYROWFIRSTCHANGE,            F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Row First Change Notification"},
    {DBPROP_NOTIFYROWINSERT,                 F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Row Insert Notification"},
//  {DBPROP_NOTIFYROWRELEASE,                F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"NotifyRowRelease"},
    {DBPROP_NOTIFYROWRESYNCH,                F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Row Resynchronization Notification"},
    {DBPROP_NOTIFYROWSETRELEASE,             F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Rowset Release Notification"},
    {DBPROP_NOTIFYROWSETFETCHPOSITIONCHANGE, F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Rowset Fetch Position Change Notification"},
    {DBPROP_NOTIFYROWUNDOCHANGE,             F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Row Undo Change Notification"},
    {DBPROP_NOTIFYROWUNDODELETE,             F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Row Undo Delete Notification"},
    {DBPROP_NOTIFYROWUNDOINSERT,             F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Row Undo Insert Notification"},
    {DBPROP_NOTIFYROWUPDATE,                 F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   0, OPT_REQ, NULL, L"Row Update Notification"},
    {DBPROP_ORDEREDBOOKMARKS,                F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_SIC, NULL, L"Bookmarks Ordered"},
    {DBPROP_OWNINSERT,                       F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_SIC, NULL, L"Own Inserts Visible"},
    {DBPROP_OWNUPDATEDELETE,                 F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_SIC, NULL, L"Own Changes Visible"},
    {DBPROP_QUICKRESTART,                    F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,   0, OPT_SIC, NULL, L"Quick Restart"},
    {DBPROP_REENTRANTEVENTS,                 F_ROWSETRO,     VT_BOOL, VARIANT_TRUE,    0, OPT_REQ, NULL, L"Reentrant Events"},
    {DBPROP_REMOVEDELETED,                   F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_SIC, NULL, L"Remove Deleted Rows"},
    {DBPROP_REPORTMULTIPLECHANGES,           F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_REQ, NULL, L"Report Multiple Changes"},
    {DBPROP_ROWRESTRICT,                     F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_REQ, NULL, L"Row Privileges"},
    {DBPROP_ROWTHREADMODEL,                  F_ROWSETRO,     VT_I4,   VARIANT_FALSE,   DBPROPVAL_RT_FREETHREAD, OPT_REQ, NULL, L"Row Threading Model"},
    {DBPROP_STRONGIDENTITY,                  F_ROWSETRO,     VT_BOOL, VARIANT_FALSE,   0, OPT_REQ, NULL, L"Strong Row Identity"},

};

PROPSTRUCT s_rgDBSessProp[] =
{
    {DBPROP_SESS_AUTOCOMMITISOLEVELS, F_SESSRO, VT_I4, VARIANT_FALSE, 0, OPT_REQ, NULL, L"Autocommit Isolation Levels"},
};


PROPSTRUCT s_rgADSISearchProp[12] =
{
    {ADSIPROP_ASYNCHRONOUS,     F_ADSIRW,    VT_BOOL,    VARIANT_FALSE,  0,                         OPT_REQ, NULL, L"Asynchronous"},
    {ADSIPROP_DEREF_ALIASES,    F_ADSIRW,    VT_I4,      VARIANT_FALSE,  ADS_DEREF_NEVER,           OPT_REQ, NULL, L"Deref Aliases"},
    {ADSIPROP_SIZE_LIMIT,       F_ADSIRW,    VT_I4,      VARIANT_FALSE,  0,                         OPT_REQ, NULL, L"Size Limit"},
    {ADSIPROP_TIME_LIMIT,       F_ADSIRW,    VT_I4,      VARIANT_FALSE,  0,                         OPT_REQ, NULL, L"Server Time Limit"},
    {ADSIPROP_ATTRIBTYPES_ONLY, F_ADSIRW,    VT_BOOL,    VARIANT_FALSE,  0,                         OPT_REQ, NULL, L"Column Names only"},
    {ADSIPROP_SEARCH_SCOPE,     F_ADSIRW,    VT_I4,      VARIANT_FALSE,  ADS_SCOPE_SUBTREE,         OPT_REQ, NULL, L"SearchScope"},
    {ADSIPROP_TIMEOUT,          F_ADSIRW,    VT_I4,      VARIANT_FALSE,  0,                         OPT_REQ, NULL, L"Timeout"},
    {ADSIPROP_PAGESIZE,         F_ADSIRW,    VT_I4,      VARIANT_FALSE,  0,                         OPT_REQ, NULL, L"Page size"},
    {ADSIPROP_PAGED_TIME_LIMIT, F_ADSIRW,    VT_I4,      VARIANT_FALSE,  0,                         OPT_REQ, NULL, L"Time limit"},
    {ADSIPROP_CHASE_REFERRALS,  F_ADSIRW,    VT_I4,      VARIANT_FALSE,  ADS_CHASE_REFERRALS_NEVER, OPT_REQ, NULL, L"Chase referrals"},
    {ADSIPROP_SORT_ON,          F_ADSIRW,    VT_BSTR,    VARIANT_FALSE,  0,                         OPT_REQ, NULL, L"Sort On"},
    {ADSIPROP_CACHE_RESULTS,    F_ADSIRW,    VT_BOOL,    VARIANT_TRUE,   0,                         OPT_REQ, NULL, L"Cache Results"}

};

// Number of supported properties per property set
#define    NUMBER_OF_SUPPORTED_PROPERTY_SETS   6

static PROPSET s_rgPropertySets[NUMBER_OF_SUPPORTED_PROPERTY_SETS] =
{
    {&DBPROPSET_DBINIT,         NUMELEM(s_rgDBInitProp),    s_rgDBInitProp},
    {&DBPROPSET_ADSIBIND,       NUMELEM(s_rgADSIBindProp),  s_rgADSIBindProp},
    {&DBPROPSET_DATASOURCEINFO, NUMELEM(s_rgDSInfoProp),    s_rgDSInfoProp},
    {&DBPROPSET_SESSION,        NUMELEM(s_rgDBSessProp),    s_rgDBSessProp},
    {&DBPROPSET_ROWSET,         NUMELEM(s_rgRowsetProp),    s_rgRowsetProp},
    {&DBPROPSET_ADSISEARCH,     NUMELEM(s_rgADSISearchProp),s_rgADSISearchProp}
};

//
// WARNING: Don't change the order. Add new property sets at the end
//
// Update: New property sets should not always be added at the end.
// Property sets which have properties in the Initialization  property group
// have to be added before DATASOURCEINFO and prop. sets with properties
// in the  data source information property groups have to be added
// before INDEX_SESSION and so on. This is for GetProperties to work correctly.
//

#define INDEX_INIT              0
#define INDEX_ADSIBIND          1
#define INDEX_DATASOURCEINFO    2
#define INDEX_SESSION           3
#define INDEX_ROWSET            4
#define INDEX_ADSISEARCH        5

//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::CUtilProp
//
//  Synopsis:  Constructor for this class
//
//  Arguments:
//
//  Returns:
//
//  Modifies:
//
//  History:    08-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------
CUtilProp::CUtilProp(
    void
    )
{
    _pIMalloc      = NULL;
    _pCredentials  = NULL;
    _prgProperties = NULL;
    _dwDescBufferLen = 0;
}


//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::FInit
//
//  Synopsis:
//
//  Arguments:
//
//  Returns:
//
//  Modifies:
//
//  History:    09-20-96   ShankSh     Created.
//
//  Update: pCredentials may be NULL if called from CRowset.
//
//----------------------------------------------------------------------------

STDMETHODIMP
CUtilProp::FInit(
    CCredentials *pCredentials
    )
{
    HRESULT hr=S_OK;
    ULONG i, j;
    ULONG c = 0;

    //
    // Get the IMalloc interface pointer
    //
    hr = CoGetMalloc(MEMCTX_TASK, &_pIMalloc);
    BAIL_ON_FAILURE( hr );

    _pCredentials = pCredentials;
    _prgProperties = (PROPSTRUCT*) AllocADsMem(sizeof(PROPSTRUCT) *
                                               (NUMELEM(s_rgDBInitProp) +
                                                NUMELEM(s_rgADSIBindProp) +
                                                NUMELEM(s_rgDSInfoProp) +
                                                NUMELEM(s_rgDBSessProp) +
                                                NUMELEM(s_rgRowsetProp) +
                                                NUMELEM(s_rgADSISearchProp)) );
    if( !_prgProperties )
        BAIL_ON_FAILURE ( hr=E_OUTOFMEMORY );

    for (i=c=0; i< NUMBER_OF_SUPPORTED_PROPERTY_SETS; i++) {
        for (j=0; j < s_rgPropertySets[i].cProperties; j++) {
            // Copy static structure
            memcpy( &_prgProperties[c],
                    &s_rgPropertySets[i].pUPropInfo[j], sizeof(PROPSTRUCT) );

            // Allocate new BSTR value
            _prgProperties[c].pwstrVal =
                    AllocADsStr(s_rgPropertySets[i].pUPropInfo[j].pwstrVal);

            // Add description length
            if( s_rgPropertySets[i].pUPropInfo[j].pwszDescription ) {
                _dwDescBufferLen += wcslen(s_rgPropertySets[i].pUPropInfo[j].pwszDescription) + 1;
            }

            c++;
        }
    }
    _dwDescBufferLen *= sizeof(WCHAR);

    ADsAssert( c == NUMELEM(s_rgDBInitProp) +
                    NUMELEM(s_rgADSIBindProp) +
                    NUMELEM(s_rgDSInfoProp) +
                    NUMELEM(s_rgDBSessProp) +
                    NUMELEM(s_rgRowsetProp) +
                    NUMELEM(s_rgADSISearchProp) );

error:

    RRETURN( hr );
}


//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::~CUtilProp
//
//  Synopsis:  Destructor for this class
//
//  Arguments:
//
//  Returns:
//
//  Modifies:
//
//  History:    08-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------

CUtilProp:: ~CUtilProp
(
void
)
{
    ULONG c = 0;

    if( _prgProperties )
    {
        // Clear all of the String values
        for (ULONG i=c=0; i< NUMBER_OF_SUPPORTED_PROPERTY_SETS; i++) {
            for (ULONG j=0; j < s_rgPropertySets[i].cProperties; j++) {
                if( _prgProperties[c].pwstrVal )
                    FreeADsStr(_prgProperties[c].pwstrVal);
                c++;
            }
        }

        FreeADsMem(_prgProperties);
    }

    if( _pIMalloc )
        _pIMalloc->Release();

    return;
}


PROPSET *
CUtilProp::GetPropSetFromGuid (
    GUID guidPropSet
    )
{

    for (int j=0; j< NUMELEM(s_rgPropertySets); j++) {
        if (IsEqualGUID(guidPropSet,
                        *(s_rgPropertySets[j].guidPropertySet)))
            return &(s_rgPropertySets[j]);
    }
    return NULL;
}

HRESULT
CUtilProp::GetSearchPrefInfo(
    DBPROPID dwPropId,
    PADS_SEARCHPREF_INFO pSearchPrefInfo
    )
{
    PADS_SORTKEY pSortKey = NULL;
    LPWSTR pszAttrs = NULL;
    LPWSTR pszFirstAttr = NULL;
    LPWSTR pszCurrentAttr = NULL, pszNextAttr = NULL, pszOrder = NULL;
    DWORD cAttrs = 0;
    HRESULT hr = S_OK;
    DWORD index;

    if (!pSearchPrefInfo) {
        RRETURN (E_INVALIDARG);
    }

    if (dwPropId >= g_cMapDBPropToSearchPref)
        RRETURN(E_FAIL);

    pSearchPrefInfo->dwSearchPref = g_MapDBPropIdToSearchPref[dwPropId];

    //
    // Get index of where ADSI search properties begin
    //

    index = NUMELEM(s_rgDBInitProp) +
            NUMELEM(s_rgADSIBindProp) +
            NUMELEM(s_rgDSInfoProp) +
            NUMELEM(s_rgDBSessProp) +
            NUMELEM(s_rgRowsetProp);

    switch (_prgProperties[index + dwPropId].vtType) {
    case VT_BOOL:
        pSearchPrefInfo->vValue.dwType = ADSTYPE_BOOLEAN;
        pSearchPrefInfo->vValue.Boolean =
            _prgProperties[index + dwPropId].boolVal == VARIANT_TRUE ? TRUE : FALSE;
        break;

    case VT_I4:
    case VT_I2:
        pSearchPrefInfo->vValue.dwType = ADSTYPE_INTEGER;
        pSearchPrefInfo->vValue.Integer = _prgProperties[index + dwPropId].longVal;
        break;

    case VT_BSTR: {
        if (pSearchPrefInfo->dwSearchPref != ADS_SEARCHPREF_SORT_ON) {
            //
            // right now, this is the only string preference supported
            //
            RRETURN (E_FAIL);
        }
        //
        // The preference is a list of atributes to be sorted on (in that order
        // and an optional indication of whether it has to be sorted ascending
        // or not.
        // eg., "name ASC, usnchanged DESC, cn"
        //
        pSearchPrefInfo->vValue.dwType = ADSTYPE_PROV_SPECIFIC;

        if (!_prgProperties[index + dwPropId].pwstrVal ||
            !_wcsicmp(_prgProperties[index + dwPropId].pwstrVal, L"")) {

            pSearchPrefInfo->vValue.ProviderSpecific.dwLength = 0;
            pSearchPrefInfo->vValue.ProviderSpecific.lpValue = NULL;

            break;
        }

        // make a copy
        pszAttrs = AllocADsStr(_prgProperties[index + dwPropId].pwstrVal);

        pszCurrentAttr = pszFirstAttr = wcstok(pszAttrs, L",");

        for(cAttrs=0; pszCurrentAttr != NULL; cAttrs++ ) {
            pszCurrentAttr = wcstok(NULL, L",");
        }

        if(cAttrs == 0) {
           BAIL_ON_FAILURE ( hr = E_ADS_BAD_PARAMETER );
        }

        pSortKey = (PADS_SORTKEY) AllocADsMem(sizeof(ADS_SORTKEY) * cAttrs);

        if (!pSortKey) {
            BAIL_ON_FAILURE ( E_OUTOFMEMORY );
        }

        pszCurrentAttr = pszFirstAttr;

        for (DWORD i=0 ; i < cAttrs; i++) {

            pszNextAttr = pszCurrentAttr + wcslen(pszCurrentAttr) + 1;
            pszCurrentAttr = RemoveWhiteSpaces(pszCurrentAttr);

            pszOrder = wcstok(pszCurrentAttr, L" ");
            pszOrder = pszOrder ? wcstok(NULL, L" ") : NULL;

            if (pszOrder && !_wcsicmp(pszOrder, L"DESC"))
                pSortKey[i].fReverseorder = 1;
            else
                pSortKey[i].fReverseorder = 0;  // This is the default

            pSortKey[i].pszAttrType = AllocADsStr(pszCurrentAttr);
            pSortKey[i].pszReserved = NULL;

            pszCurrentAttr = pszNextAttr;

        }

        pSearchPrefInfo->vValue.ProviderSpecific.dwLength = sizeof(ADS_SORTKEY) * cAttrs;
        pSearchPrefInfo->vValue.ProviderSpecific.lpValue = (LPBYTE) pSortKey;

        break;

    }

    default:

        RRETURN (E_FAIL);
    }

error:

    if (pszAttrs) {
        FreeADsStr(pszAttrs);
    }

    RRETURN(hr);

}


HRESULT
CUtilProp::FreeSearchPrefInfo(
    PADS_SEARCHPREF_INFO pSearchPrefInfo,
    DWORD dwNumSearchPrefs
    )
{

    PADS_SORTKEY pSortKey = NULL;
    DWORD nSortKeys = 0;

    if (!pSearchPrefInfo || !dwNumSearchPrefs) {
        RRETURN (S_OK);
    }

    for (DWORD i=0; i<dwNumSearchPrefs; i++) {

        switch(pSearchPrefInfo[i].vValue.dwType) {

        case ADSTYPE_BOOLEAN:
        case ADSTYPE_INTEGER:
            // do nothing
            break;

        case ADSTYPE_PROV_SPECIFIC:

            if (pSearchPrefInfo[i].dwSearchPref == ADS_SEARCHPREF_SORT_ON) {
                //
                // delete the strings allocated for each of the attributes
                // to be sorted

                nSortKeys = pSearchPrefInfo[i].vValue.ProviderSpecific.dwLength / sizeof(ADS_SORTKEY);
                pSortKey = (PADS_SORTKEY) pSearchPrefInfo[i].vValue.ProviderSpecific.lpValue;

                for (DWORD j=0; pSortKey && j<nSortKeys; j++) {
                    FreeADsStr(pSortKey[j].pszAttrType);
                }

                if (pSortKey) {
                    FreeADsMem(pSortKey);
                }

            }

            break;
        }

    }

    RRETURN (S_OK);

}

//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::LoadDBPROPINFO
//
//  Synopsis:  Helper for GetPropertyInfo. Loads field of DBPROPINFO
//             structure.
//
//  Arguments:
//
//  Returns:        TRUE    :  Method succeeded
//                  FALSE   :  Method failed (couldn't allocate memory)
//
//  Modifies:
//
//  History:    08-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CUtilProp::LoadDBPROPINFO (
    PROPSTRUCT* pPropStruct,
    ULONG       cProperties,
    DBPROPINFO* pPropInfo
    )
{
    ULONG cCount;
    PROPSTRUCT* pProp=NULL;

    // asserts
    ADsAssert( pPropInfo );
    if( cProperties ) {
        ADsAssert( pPropStruct );
    }

    //
    // init the variant
    //
    VariantInit( &pPropInfo->vValues );

    for (cCount=0; cCount < cProperties; cCount++) {
        if(pPropInfo->dwPropertyID == pPropStruct[cCount].dwPropertyID)
            break;
    }

    if(cCount == cProperties) {
        pPropInfo->dwFlags = DBPROPFLAGS_NOTSUPPORTED;
        pPropInfo->pwszDescription = NULL;
        RRETURN (DB_S_ERRORSOCCURRED);
    }

    pProp = &(pPropStruct[cCount]);
    //
    // set the easy fields..
    //
    pPropInfo->dwPropertyID    = pProp->dwPropertyID;
    pPropInfo->dwFlags        = pProp->dwFlags;
    pPropInfo->vtType        = pProp->vtType;


    // fill in the description
    if (pPropInfo->pwszDescription)
        wcscpy(pPropInfo->pwszDescription, pProp->pwszDescription);

    RRETURN(S_OK);
}


//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::LoadDBPROP
//
//  Synopsis:  Helper for GetProperties. Loads field of DBPROP structure.
//
//  Arguments:
//
//  Returns:        TRUE    :  Method succeeded
//                  FALSE   :  Method failed (couldn't allocate memory)
//
//  Modifies:
//
//  History:    08-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CUtilProp::LoadDBPROP (
    PROPSTRUCT* pPropStruct,
    ULONG       cProperties,
    DBPROP*     pPropSupport,
    BOOL        IsDBInitPropSet
    )
{
    ULONG cCount;
    PROPSTRUCT* pProp=NULL;
    LPWSTR szUserName=NULL, szPassword=NULL;
    BOOL fAuthFlags=0;

    // asserts
    ADsAssert( pPropSupport );
    if( cProperties ) {
        ADsAssert( pPropStruct );
    }

    //
    // init the variant
    //
    VariantInit( &pPropSupport->vValue );

    for (cCount=0; cCount < cProperties; cCount++) {
        if( pPropSupport->dwPropertyID == pPropStruct[cCount].dwPropertyID )
            break;
    }

    if( cCount == cProperties ) {
        pPropSupport->dwStatus = DBPROPSTATUS_NOTSUPPORTED;
        RRETURN ( DB_S_ERRORSOCCURRED );
    }

    pProp = &(pPropStruct[cCount]);

    pPropSupport->colid = DB_NULLID;
    pPropSupport->dwOptions = pProp->dwOptions;

    //
    // set pPropSupport->vValue based on Variant type
    //
    switch (pProp->vtType) {
        case VT_BOOL:
            V_VT( &pPropSupport->vValue ) = VT_BOOL;
            V_BOOL( &pPropSupport->vValue ) = (SHORT)pProp->boolVal;
            break;

        case VT_I4:
            V_VT( &pPropSupport->vValue ) = VT_I4;
            V_I4( &pPropSupport->vValue ) = pProp->longVal;
            break;

        case VT_I2:
            V_VT( &pPropSupport->vValue ) = VT_I2;
            V_I2( &pPropSupport->vValue ) = (short)pProp->longVal;
            break;

        case VT_BSTR:
            //
            // If requesting password, get it from the credentials structure
            // as it is not stored anywhere else
            //
            if (IsDBInitPropSet &&
                pPropSupport->dwPropertyID == DBPROP_AUTH_PASSWORD)
            {
                PWSTR pszPassword = NULL;

                if (FAILED(_pCredentials->GetPassword(&pszPassword)))
                {
                    VariantClear( &pPropSupport->vValue );
                    return DB_S_ERRORSOCCURRED;
                }

                if (pszPassword)
                {
                    V_VT(&pPropSupport->vValue)  = VT_BSTR;
                    V_BSTR(&pPropSupport->vValue)= SysAllocString(pszPassword);

                    FreeADsMem(pszPassword);

                    if( V_BSTR(&pPropSupport->vValue) == NULL ) {
                        VariantClear( &pPropSupport->vValue );
                        return DB_S_ERRORSOCCURRED;
                    }
                }
            }
            else if( pProp->pwstrVal ) {
                V_VT(&pPropSupport->vValue)  = VT_BSTR;

                V_BSTR(&pPropSupport->vValue)= SysAllocString(pProp->pwstrVal);

                if( V_BSTR(&pPropSupport->vValue) == NULL ) {
                    VariantClear( &pPropSupport->vValue );
                    return DB_S_ERRORSOCCURRED;
                }
            }
            break;

        default:
            ADsAssert( !"LoadDBPROP unknown variant type!\n\r" );
            pPropSupport->dwStatus = DBPROPSTATUS_BADVALUE;
            RRETURN (DB_S_ERRORSOCCURRED);
            break;
    }
    //
    // all went well
    //
    pPropSupport->dwStatus = DBPROPSTATUS_OK;
    RRETURN(S_OK);
}



//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::StoreDBProp
//
//  Synopsis:  Helper for SetProperties. Loads field of DBPROP structure.
//
//  Arguments:
//
//  Returns:
//
//
//  Modifies:
//
//  History:    09-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CUtilProp::StoreDBPROP (
    PROPSTRUCT* pPropStruct,
    PROPSTRUCT* pStaticPropStruct,
    ULONG       cProperties,
    DBPROP*     pPropSupport,
    DWORD       dwPropIndex
)
{
    // asserts
    ADsAssert( pPropStruct );
    ADsAssert( pPropSupport );

    ULONG i;
    HRESULT hr=S_OK;

    // Initialize the status to DBPROPSTATUS_OK
    pPropSupport->dwStatus = DBPROPSTATUS_OK;

    for (i=0; i < cProperties; i++) {
        if(pPropStruct[i].dwPropertyID == pPropSupport->dwPropertyID) {

            // arg checking for the prop
            if( pPropSupport->dwOptions != DBPROPOPTIONS_OPTIONAL &&
                pPropSupport->dwOptions != DBPROPOPTIONS_REQUIRED ) {
                pPropSupport->dwStatus = DBPROPSTATUS_BADOPTION;
                hr = DB_S_ERRORSOCCURRED;
                goto error;
            }

            if( (pPropStruct[i].vtType != V_VT(&pPropSupport->vValue) &&
                 V_VT(&pPropSupport->vValue) != VT_EMPTY) ||
                (IsValidValue(pPropSupport, dwPropIndex) == S_FALSE) ) {

                pPropSupport->dwStatus = DBPROPSTATUS_BADVALUE;
                hr = DB_S_ERRORSOCCURRED;
                goto error;
            }

            //
            // If property being set is password, we get out here.
            // Reason is we have already stored it in the Credentials structure
            // in encrypted form in the function IsVaidValue above.
            // We should not store it in plain text in pPropStruct[i].
            //
            if (dwPropIndex == INDEX_INIT &&
                pPropSupport->dwPropertyID == DBPROP_AUTH_PASSWORD)
            {
                pPropSupport->dwStatus = DBPROPSTATUS_OK;
                pPropStruct[i].dwOptions = pPropSupport->dwOptions;
                goto error;
            }

            if( !(pPropStruct[i].dwFlags & DBPROPFLAGS_WRITE) ) {
                // Check the value - if they are the same, do nothing
                if ( (V_VT(&pPropSupport->vValue) == VT_EMPTY) ||
                     ((V_VT(&pPropSupport->vValue) == VT_BOOL) &&
                      (pPropStruct[i].boolVal == V_BOOL(&pPropSupport->vValue))) ||
                     ((V_VT(&pPropSupport->vValue) == VT_I4) &&
                      (pPropStruct[i].longVal == V_I4(&pPropSupport->vValue))) ||
                     ((V_VT(&pPropSupport->vValue) == VT_I2) &&
                      ((short)pPropStruct[i].longVal == V_I2(&pPropSupport->vValue))) ||
                     ((V_VT(&pPropSupport->vValue) == VT_BSTR) && pPropStruct[i].pwstrVal &&
                      (wcscmp(pPropStruct[i].pwstrVal,V_BSTR(&pPropSupport->vValue)) == 0)) )

                    goto error;

                if( pPropSupport->dwOptions != DBPROPOPTIONS_OPTIONAL )
                    pPropSupport->dwStatus = DBPROPSTATUS_NOTSETTABLE;
                else
                    pPropSupport->dwStatus = DBPROPSTATUS_NOTSET;

                hr = DB_S_ERRORSOCCURRED;
                goto error;
            }

            switch (pPropStruct[i].vtType) {
                case VT_BOOL:
                    if( V_VT(&pPropSupport->vValue) != VT_EMPTY )
                        pPropStruct[i].boolVal = V_BOOL( &pPropSupport->vValue );
                    else
                        pPropStruct[i].boolVal = pStaticPropStruct[i].boolVal;
                    break;

                case VT_I4:
                    if( V_VT(&pPropSupport->vValue) != VT_EMPTY )
                        pPropStruct[i].longVal = V_I4( &pPropSupport->vValue );
                    else
                        pPropStruct[i].longVal = pStaticPropStruct[i].longVal;
                    break;

                case VT_I2:
                    if( V_VT(&pPropSupport->vValue) != VT_EMPTY )
                        pPropStruct[i].longVal = V_I2( &pPropSupport->vValue );
                    else
                        pPropStruct[i].longVal = pStaticPropStruct[i].longVal;
                    break;

                case VT_BSTR:
                    if(pPropStruct[i].pwstrVal) {
                        FreeADsStr(pPropStruct[i].pwstrVal);
                        pPropStruct[i].pwstrVal = NULL;
                    }

                    if( V_VT(&pPropSupport->vValue) == VT_EMPTY )
                        pPropStruct[i].pwstrVal = AllocADsStr(( pStaticPropStruct[i].pwstrVal ));
                    else
                    {
                        if (V_BSTR( &pPropSupport->vValue) == NULL &&
                            pPropSupport->dwPropertyID == DBPROP_AUTH_INTEGRATED)
                        {
                            //
                            // For integrated security, NULL bstrVal implies 'use default
                            // provider', which is "SSPI" for us. The reason we don't set
                            // the defult value to SSPI in the static structure is
                            // because this property is special. Unless set, it should
                            // not be used.
                            //
                            pPropStruct[i].pwstrVal = AllocADsStr(L"SSPI");
                        }
                        else
                            pPropStruct[i].pwstrVal = AllocADsStr(V_BSTR( &pPropSupport->vValue ));
                    }

                    if( !pPropStruct[i].pwstrVal &&
                        V_VT(&pPropSupport->vValue) == VT_BSTR ) {

                        hr = E_FAIL;
                        goto error;
                    }
                    break;

                default:
                    pPropSupport->dwStatus = DBPROPSTATUS_BADVALUE;
                    hr = DB_S_ERRORSOCCURRED;
                    goto error;
            }
            pPropSupport->dwStatus = DBPROPSTATUS_OK;
            pPropStruct[i].dwOptions = pPropSupport->dwOptions;
            break;
        }

    }

    if (i == cProperties) {
        pPropSupport->dwStatus = DBPROPSTATUS_NOTSUPPORTED;
        hr = DB_E_ERRORSOCCURRED;
        goto error;
    }

error:
    RRETURN(hr);
}


//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::IsValidValue
//
//  Synopsis:  Helper for SetProperties. Check the valid values for the Property.
//
//  Arguments:
//
//  Returns:
//
//
//  Modifies:
//
//  History:    09-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------
HRESULT
CUtilProp::IsValidValue
        (
        DBPROP*         pDBProp,
        DWORD           dwPropIndex
        )
{
    // Check BOOLEAN values
    if( (pDBProp->vValue.vt == VT_BOOL) &&
        !((V_BOOL(&(pDBProp->vValue)) == VARIANT_TRUE) ||
          (V_BOOL(&(pDBProp->vValue)) == VARIANT_FALSE)) )
        return S_FALSE;

    if( pDBProp->vValue.vt != VT_EMPTY &&
        dwPropIndex == INDEX_INIT )
    {
        switch( pDBProp->dwPropertyID )
        {
        case DBPROP_INIT_PROMPT:
            // These are the only values we support (from spec).
            if (!(V_I2(&pDBProp->vValue) == DBPROMPT_PROMPT ||
                  V_I2(&pDBProp->vValue) == DBPROMPT_COMPLETE ||
                  V_I2(&pDBProp->vValue) == DBPROMPT_COMPLETEREQUIRED ||
                  V_I2(&pDBProp->vValue) == DBPROMPT_NOPROMPT))
                return S_FALSE;
                break;

        case DBPROP_INIT_TIMEOUT:
            if( (pDBProp->vValue.vt == VT_I4) &&
                (V_I4(&pDBProp->vValue) < 0) )
                return S_FALSE;

            break;

        case DBPROP_AUTH_USERID:
            if( (!_pCredentials) ||
                (S_OK != _pCredentials->SetUserName(V_BSTR(&pDBProp->vValue))) )
                return S_FALSE;

                break;

        case DBPROP_AUTH_PASSWORD:
            if( (!_pCredentials) ||
                (S_OK != _pCredentials->SetPassword(V_BSTR(&pDBProp->vValue))) )
                return S_FALSE;

                break;

        case DBPROP_AUTH_INTEGRATED:
            //
            // For integrated security, NULL bstrVal implies 'use default
            // provider', which is "SSPI" for us.
            //
            if( ((pDBProp->vValue.vt != VT_BSTR) &&
                 (pDBProp->vValue.vt != VT_NULL))    ||
                ((V_BSTR(&pDBProp->vValue) != NULL) &&
                 (wcscmp(V_BSTR(&pDBProp->vValue), L"SSPI") != 0)))
                return S_FALSE;

            break;

        case DBPROP_INIT_MODE:
            if( (pDBProp->vValue.vt != VT_I4) ||
                    (S_FALSE == IsValidInitMode(V_I4(&pDBProp->vValue))) )
                return S_FALSE;

            break;

#if (!defined(BUILD_FOR_NT40))

        case DBPROP_INIT_BINDFLAGS:
            if( (pDBProp->vValue.vt != VT_I4) ||
                    (S_FALSE == IsValidBindFlag(V_I4(&pDBProp->vValue))) )
                return S_FALSE;

            break;
#endif

        case DBPROP_AUTH_ENCRYPT_PASSWORD:
            if( !_pCredentials )
                return S_FALSE;

            if( IsADSIFlagSet() )
                // override this property if the user set the authentication
                break;

            BOOL fAuthFlags = _pCredentials->GetAuthFlags();

            if( V_BOOL(&pDBProp->vValue) )
                _pCredentials->SetAuthFlags(fAuthFlags | ADS_SECURE_AUTHENTICATION);
            else
                _pCredentials->SetAuthFlags(fAuthFlags & ~ADS_SECURE_AUTHENTICATION);

            break;

        }
    }
    else if( pDBProp->vValue.vt != VT_EMPTY &&
             dwPropIndex == INDEX_ADSIBIND )
    {
        switch( pDBProp->dwPropertyID )
        {
            case ADSIPROP_ADSIFLAG:
                if( !_pCredentials )
                    // don't think this will ever happen
                    return S_FALSE;

                // prevent default initialization by VB from setting the
                // AUTH flags. The client should not specify ADS_AUTH_RESERVED
                // for this property (this might happen if the client behaves
                // like VB i.e, does GetProperties and then SetProperties 
                // without ORing in any flags. In this case, ENCRYPT_PASSWORD
                // will not be overwritten by this property due to this check).
                if( ADS_AUTH_RESERVED == (V_I4(&pDBProp->vValue)) )
                    break;

                // the following call might overwrite ENCRYPT_PASSWORD
                _pCredentials->SetAuthFlags((V_I4(&pDBProp->vValue)) & 
                                                     (~ADS_AUTH_RESERVED) );

                break;

        }
    }
    else if( pDBProp->vValue.vt != VT_EMPTY &&
             dwPropIndex == INDEX_SESSION )
    {
        switch( pDBProp->dwPropertyID )
        {
            case DBPROP_SESS_AUTOCOMMITISOLEVELS:
                // These are the only values we support (from spec).
                if( (pDBProp->vValue.vt == VT_I4) &&
                     (V_I4(&pDBProp->vValue) != 0                            &&
                      V_I4(&pDBProp->vValue) != DBPROPVAL_TI_CHAOS           &&
                      V_I4(&pDBProp->vValue) != DBPROPVAL_TI_READUNCOMMITTED &&
                      V_I4(&pDBProp->vValue) != DBPROPVAL_TI_READCOMMITTED   &&
                      V_I4(&pDBProp->vValue) != DBPROPVAL_TI_REPEATABLEREAD  &&
                      V_I4(&pDBProp->vValue) != DBPROPVAL_TI_SERIALIZABLE) )
                    return S_FALSE;

                break;
        }
    }
    else if( pDBProp->vValue.vt != VT_EMPTY &&
             dwPropIndex == INDEX_ROWSET )
    {
        switch( pDBProp->dwPropertyID )
        {
            case DBPROP_MAXOPENROWS:
                if( (pDBProp->vValue.vt != VT_I4) || 
                    (V_I4(&pDBProp->vValue) < 0) )
                    return S_FALSE;

                    break;
        }
    }

    return S_OK;    // Is valid
}

//----------------------------------------------------------------------------
// IsValidInitMode
//
// Checks if a given value is a valid value for DBPROP_INIT_MODE
//
//----------------------------------------------------------------------------
HRESULT
CUtilProp::IsValidInitMode(
    long lVal
    )
{
    // check if any bit that shouldn't be set is actually set
    if( lVal & (~(DB_MODE_READWRITE | 
                  DB_MODE_SHARE_EXCLUSIVE | DB_MODE_SHARE_DENY_NONE)) )
        return S_FALSE;
 
    return S_OK;

}

//---------------------------------------------------------------------------
// IsValidInitBindFlag
//
// Checks if a given value is a valid value for DBPROP_INIT_BINDFLAGS
//
//---------------------------------------------------------------------------
HRESULT
CUtilProp::IsValidBindFlag(
    long lVal
    )
{
#if (!defined(BUILD_FOR_NT40))
    // check if any bit that shouldn't be set is actually set
    if( lVal & (~(DB_BINDFLAGS_DELAYFETCHCOLUMNS | 
                  DB_BINDFLAGS_DELAYFETCHSTREAM | DB_BINDFLAGS_RECURSIVE |
                  DB_BINDFLAGS_OUTPUT | DB_BINDFLAGS_COLLECTION |
                  DB_BINDFLAGS_OPENIFEXISTS | DB_BINDFLAGS_OVERWRITE |
                  DB_BINDFLAGS_ISSTRUCTUREDDOCUMENT)) )
        return S_FALSE;

    // check for mutually exclusive flags
    if( (lVal & DB_BINDFLAGS_OPENIFEXISTS) &&
            (lVal & DB_BINDFLAGS_OVERWRITE) )
        return S_FALSE;

    return S_OK;
#else
    return E_FAIL;
#endif
}

//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::GetPropertiesArgChk
//
//  Synopsis:  Initialize the buffers and check for E_INVALIDARG
//
//  Arguments:
//             cPropertyIDSets       # of restiction property IDs
//             rgPropertyIDSets[]    restriction guids
//             pcPropertySets        count of properties returned
//             prgPropertySets       property information returned
//             dwBitMask             which property group
//
//  Returns:
//             S_OK          | The method succeeded
//             E_INVALIDARG  | pcPropertyIDSets or prgPropertyInfo was NULL
//
//  Modifies:
//
//  History:    08-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------
HRESULT
CUtilProp::GetPropertiesArgChk(
        ULONG                           cPropertySets,
        const DBPROPIDSET               rgPropertySets[],
        ULONG*                          pcProperties,
        DBPROPSET**                     prgProperties,
        DWORD                           dwBitMask
    )
{
    // Initialize values
    if( pcProperties )
        *pcProperties = 0;
    if( prgProperties )
        *prgProperties = NULL;

    // Check Arguments
    if( ((cPropertySets > 0) && !rgPropertySets) ||
         !pcProperties || !prgProperties )
        RRETURN ( E_INVALIDARG );

    // New argument check for > 1 cPropertyIDs and NULL pointer for
    // array of property ids.
    for(ULONG ul=0; ul<cPropertySets; ul++)
    {
        if( rgPropertySets[ul].cPropertyIDs && !(rgPropertySets[ul].rgPropertyIDs) )
            RRETURN ( E_INVALIDARG );

        // Check for propper formation of DBPROPSET_PROPERTIESINERROR
        if( ((dwBitMask & PROPSET_DSO) || (dwBitMask & PROPSET_COMMAND)) &&
            (rgPropertySets[ul].guidPropertySet == DBPROPSET_PROPERTIESINERROR) )
        {
            if( (cPropertySets > 1) ||
                (rgPropertySets[ul].cPropertyIDs != 0) ||
                (rgPropertySets[ul].rgPropertyIDs != NULL) )
                 RRETURN ( E_INVALIDARG );
        }
    }

    RRETURN ( S_OK );
}

//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::GetPropertyInfo
//
//  Synopsis:  Returns information about rowset and data source properties
//            supported by the provider
//
//  Arguments:
//              cPropertyIDSets             # properties
//              rgPropertyIDSets[]          Array of property sets
//              pcPropertyInfoSets          # DBPROPSET structures
//              prgPropertyInfoSets         DBPROPSET structures property
//                                          information returned
//              ppDescBuffer                Property descriptions
//
//  Returns:
//             S_OK          | The method succeeded
//             E_INVALIDARG  | pcPropertyIDSets or prgPropertyInfo was NULL
//             E_OUTOFMEMORY | Out of memory
//
//  Modifies:
//
//  History:    08-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------

STDMETHODIMP CUtilProp::GetPropertyInfo
(
    ULONG                cPropertyIDSets,
    const DBPROPIDSET    rgPropertyIDSets[],
    ULONG*               pcPropertyInfoSets,
    DBPROPINFOSET**      pprgPropertyInfoSets,
    WCHAR**              ppDescBuffer,
    BOOL                 fDSOInitialized
    )
{
    DBPROPINFO*      pPropInfo = NULL;
    DBPROPINFOSET*   pPropInfoSet = NULL;
    BOOL             fNoPropInfoGot = TRUE;
    BOOL             fWarning=FALSE;
    HRESULT          hr;
    LPWSTR           pwszDescBuffer=NULL;
    ULONG            cPropertySets=0, cProperties=0;
    ULONG            cCount, j, i;
    ULONG            cNewPropIDSets    = 0;
    BOOL             fIsSpecialGUID    = FALSE;
    BOOL             fIsNotSpecialGUID = FALSE;
    ULONG            ul;
    BOOL             fNewDescription = TRUE;

    // asserts
    ADsAssert( _pIMalloc );

    // init out params
    if( pcPropertyInfoSets )
        *pcPropertyInfoSets = 0;
    if( pprgPropertyInfoSets )
        *pprgPropertyInfoSets = NULL;
    if( ppDescBuffer )
        *ppDescBuffer = NULL;

    // Check Arguments, on failure post HRESULT to error queue
    if( (cPropertyIDSets > 0 && !rgPropertyIDSets) ||
        !pcPropertyInfoSets || !pprgPropertyInfoSets )
        RRETURN( E_INVALIDARG );

    // New argument check for > 1 cPropertyIDs and NULL pointer for
    // array of property ids.
    for(ul=0; ul<cPropertyIDSets; ul++)
    {
        if( rgPropertyIDSets[ul].cPropertyIDs &&
            !rgPropertyIDSets[ul].rgPropertyIDs )
            RRETURN( E_INVALIDARG );

        // Add 1 for the Provider Specific Rowset Properties
        if( (rgPropertyIDSets[ul].guidPropertySet == DBPROPSET_DBINITALL) ||
            (fDSOInitialized &&
            rgPropertyIDSets[ul].guidPropertySet == DBPROPSET_ROWSETALL) )
            cNewPropIDSets++;

        //
        // Special Guids for Property Sets can not be mixed with ordinary
        // Property Set Guids. Either one or the other, not both
        //
        if (IsSpecialGuid(rgPropertyIDSets[ul].guidPropertySet))
            fIsSpecialGUID = TRUE;
        else
            fIsNotSpecialGUID = TRUE;

        if( fIsSpecialGUID && fIsNotSpecialGUID )
            RRETURN( E_INVALIDARG );
    }

    // save the count of PropertyIDSets
    cNewPropIDSets += cPropertyIDSets;

    // If the consumer does not restrict the property sets
    // by specify an array of property sets and a cPropertySets
    // greater than 0, then we need to make sure we
    // have some to return
    if( cPropertyIDSets == 0 )
    {
        if( fDSOInitialized )
            cNewPropIDSets = NUMBER_OF_SUPPORTED_PROPERTY_SETS;
        else
            // we have 2 property sets in the DBINIT property group
            cNewPropIDSets = 2;
    }

    // use task memory allocater to alloc a DBPROPINFOSET struct
    pPropInfoSet = (DBPROPINFOSET*) _pIMalloc->Alloc(cNewPropIDSets *
                                                                                                sizeof( DBPROPINFOSET ));
    if( !pPropInfoSet )
        BAIL_ON_FAILURE ( hr=E_OUTOFMEMORY );

    memset( pPropInfoSet, 0, (cNewPropIDSets * sizeof( DBPROPINFOSET )));

    if( ppDescBuffer )
    {
        // Allocating more memory than actually required, since 
        // _dwDescBufferLen is th etotal for all property sets together, not
        // just for one property set 
        pwszDescBuffer = (LPWSTR) _pIMalloc->Alloc(_dwDescBufferLen * cNewPropIDSets);
        if( !pwszDescBuffer )
            BAIL_ON_FAILURE ( hr=E_OUTOFMEMORY );

        memset( pwszDescBuffer, 0, _dwDescBufferLen * cNewPropIDSets);
        *ppDescBuffer = pwszDescBuffer;
    }

    // If no restrictions return all properties from the three supported property sets
    if( cPropertyIDSets == 0 )
    {
        // Fill in all of the Providers Properties
        for (j=0; j< cNewPropIDSets; j++)
            pPropInfoSet[j].guidPropertySet = *s_rgPropertySets[j].guidPropertySet;
    }
    else
    {
        cCount = 0;

        //
        // Deal with the Special GUID's
        //
        for (j=0; j< cPropertyIDSets; j++)
        {
            if( rgPropertyIDSets[j].guidPropertySet == DBPROPSET_DBINITALL )
            {
                pPropInfoSet[cCount].guidPropertySet = DBPROPSET_DBINIT;
                // Adjust for ADSI_BIND (provider specific) property set
                cCount++;
                pPropInfoSet[cCount].guidPropertySet = DBPROPSET_ADSIBIND;
            }
            else if( fDSOInitialized &&
                     rgPropertyIDSets[j].guidPropertySet == DBPROPSET_DATASOURCEINFOALL )
                pPropInfoSet[cCount].guidPropertySet = DBPROPSET_DATASOURCEINFO;
            else if( fDSOInitialized &&
                     rgPropertyIDSets[j].guidPropertySet == DBPROPSET_SESSIONALL )
                pPropInfoSet[cCount].guidPropertySet = DBPROPSET_SESSION;
            else if( fDSOInitialized &&
                    rgPropertyIDSets[j].guidPropertySet == DBPROPSET_ROWSETALL )
            {
                pPropInfoSet[cCount].guidPropertySet = DBPROPSET_ROWSET;
                // Adjust for the Provider Specific
                cCount++;
                pPropInfoSet[cCount].guidPropertySet = DBPROPSET_ADSISEARCH;
            }
            else
            {
                pPropInfoSet[cCount].guidPropertySet = rgPropertyIDSets[j].guidPropertySet;
                pPropInfoSet[cCount].cPropertyInfos  = rgPropertyIDSets[j].cPropertyIDs;
            }

            cCount++;
        }
    }

    //
    // For each supported Property Set
    //
    for (cPropertySets=0;
        cPropertySets < cNewPropIDSets;
        cPropertySets++)
    {
        // Set cProperties to the numerber passed in
        cProperties = pPropInfoSet[cPropertySets].cPropertyInfos;
        pPropInfo = NULL;

        // Get the correct Static data. We have 2 property sets in the
        // INIT property group. Note that we assume that both these property
        // sets occur successively in s_rgPropertySets.
        for (j=0; j< (fDSOInitialized ? NUMELEM(s_rgPropertySets) : 2); j++) {
            if( IsEqualGUID(pPropInfoSet[cPropertySets].guidPropertySet,
                            *(s_rgPropertySets[j].guidPropertySet)) ) {
                if( pPropInfoSet[cPropertySets].cPropertyInfos == 0 )
                    cProperties = s_rgPropertySets[j].cProperties;
                break;
            }
        }

        if( cProperties )
        {
            //
            // use task memory allocater to alloc array of DBPROPINFO structs
            //
            pPropInfo = (DBPROPINFO*) _pIMalloc->Alloc(cProperties * sizeof( DBPROPINFO ));
            if( !pPropInfo ) {
                for (i=0; i<cNewPropIDSets; i++)
                    _pIMalloc->Free(pPropInfoSet[i].rgPropertyInfos);
                BAIL_ON_FAILURE ( hr=E_OUTOFMEMORY );
            }

            memset(pPropInfo, 0, cProperties * sizeof(DBPROPINFO));

            for (cCount=0; cCount < cProperties; cCount++)
            {
                if( pPropInfoSet[cPropertySets].cPropertyInfos == 0 )
                    pPropInfo[cCount].dwPropertyID =
                               s_rgPropertySets[j].pUPropInfo[cCount].dwPropertyID;
                else
                    pPropInfo[cCount].dwPropertyID =
                                  rgPropertyIDSets[cPropertySets].rgPropertyIDs[cCount];

                // set the description pointer. If this property was already 
                // requested in this call, then we reuse the same description
                // pointer. 
                DWORD dwTmp;
                for(dwTmp = 0; dwTmp < cCount; dwTmp++)
                    if(pPropInfo[dwTmp].dwPropertyID == 
                                   pPropInfo[cCount].dwPropertyID) 
                    // same property requested more than once
                        break;

                if(dwTmp == cCount)
                {
                    fNewDescription = TRUE;
                    pPropInfo[cCount].pwszDescription = pwszDescBuffer;
                }
                else
                {
                    fNewDescription = FALSE;
                    pPropInfo[cCount].pwszDescription = 
                                      pPropInfo[dwTmp].pwszDescription;
                }

                hr = LoadDBPROPINFO(
                        ((j < (fDSOInitialized ? NUMELEM(s_rgPropertySets) : 2)) ?
                                        s_rgPropertySets[j].pUPropInfo  : NULL),
                        ((j < (fDSOInitialized ? NUMELEM(s_rgPropertySets) : 2)) ?
                                        s_rgPropertySets[j].cProperties : 0),
                         &pPropInfo[cCount]
                         );

                if( FAILED(hr) ) {
                    ULONG ulFor;
                    //
                    // something went wrong
                    // clear all variants used so far..
                    //
                    for (ulFor = 0; ulFor < cCount; ulFor++)
                        VariantClear( &pPropInfo[ulFor].vValues );

                    //
                    // .. delete the pPropInfo array, return failure
                    //
                    for (i=0; i<cNewPropIDSets; i++)
                        _pIMalloc->Free(pPropInfoSet[i].rgPropertyInfos);

                    _pIMalloc->Free(pPropInfo);
                    BAIL_ON_FAILURE ( hr=E_OUTOFMEMORY );
                }

                if( hr != S_OK )
                    fWarning = TRUE;
                else
                    fNoPropInfoGot = FALSE;

                // move the description pointer to the next, if required
                if( pPropInfo[cCount].pwszDescription && fNewDescription)
                    pwszDescBuffer += (wcslen(pPropInfo[cCount].pwszDescription) + 1);
            }
        }
        else
            fWarning = TRUE;

        pPropInfoSet[cPropertySets].rgPropertyInfos = pPropInfo;
        pPropInfoSet[cPropertySets].cPropertyInfos = cProperties;
    }    // for each property set

    //
    // set count of properties and property information
    //
    *pcPropertyInfoSets= cNewPropIDSets;
    *pprgPropertyInfoSets = pPropInfoSet;

    if( fNoPropInfoGot ) {
        if( ppDescBuffer )
            *ppDescBuffer = NULL;
        if( pwszDescBuffer )
            _pIMalloc->Free(pwszDescBuffer);
        RRETURN ( DB_E_ERRORSOCCURRED );
    }
    else if( fWarning )
       RRETURN ( DB_S_ERRORSOCCURRED );
    else
       RRETURN ( S_OK );

error:

    if( pPropInfoSet )
        _pIMalloc->Free(pPropInfoSet);
    if( pwszDescBuffer )
        _pIMalloc->Free(pwszDescBuffer);

        RRETURN ( hr );
}

//----------------------------------------------------------------------------
// IsSpecialGuid
//
// Check if the the property set GUID is one of the special GUIDs
//
//----------------------------------------------------------------------------
BOOL CUtilProp::IsSpecialGuid(
    GUID guidPropSet
    )
{
    if( (DBPROPSET_ROWSETALL == guidPropSet) || 
        (DBPROPSET_DATASOURCEALL == guidPropSet) ||
        (DBPROPSET_DATASOURCEINFOALL == guidPropSet) ||
        (DBPROPSET_SESSIONALL == guidPropSet) ||
        (DBPROPSET_DBINITALL == guidPropSet) 

#if (!defined(BUILD_FOR_NT40)) 
                                             ||
        (DBPROPSET_COLUMNALL == guidPropSet) ||
        (DBPROPSET_CONSTRAINTALL == guidPropSet) ||
        (DBPROPSET_INDEXALL == guidPropSet) ||
        (DBPROPSET_TABLEALL == guidPropSet) ||
        (DBPROPSET_TRUSTEEALL == guidPropSet) ||
        (DBPROPSET_VIEWALL == guidPropSet) 
#endif
                                         )
        
        return TRUE;
    else
        return FALSE;
} 

//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::GetProperties
//
//  Synopsis:  Returns current settings of all properties supported
//             by the DSO/rowset
//
//  Arguments:
//
//             cPropertyIDSets       # of restiction property IDs
//             rgPropertyIDSets[]    restriction guids
//             pcPropertySets        count of properties returned
//             prgPropertySets       property information returned
//
//
//  Returns:
//             S_OK          | The method succeeded
//             E_INVALIDARG  | pcPropertyIDSets or prgPropertyInfo was NULL
//             E_OUTOFMEMORY | Out of memory
//
//  Modifies:
//
//  History:    08-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP CUtilProp::GetProperties
(
    ULONG               cPropertyIDSets,
    const DBPROPIDSET   rgPropertyIDSets[],
    ULONG*              pcPropertySets,
    DBPROPSET**         pprgPropertySets,
    DWORD               dwBitMask
    )
{
    ULONG       cPropertySets, cProperties;
    ULONG       cNewPropIDSets = 0;
    ULONG       cCount, j, i;
    DBPROP*     pProp = NULL;
    DBPROPSET*  pPropSet = NULL;
    HRESULT     hr = E_FAIL;
    BOOL        fNoPropertyGot = TRUE;
    BOOL        fWarning = FALSE;
    BOOL        fFound = FALSE;
    ULONG       cOffset = 0;

    // asserts
    ADsAssert(_pIMalloc);

    // Assign in the count
    cNewPropIDSets = cPropertyIDSets;

    // If the consumer does not restrict the property sets
    // by specify an array of property sets and a cPropertySets
    // greater than 0, then we need to make sure we
    // have some to return
    if( cPropertyIDSets == 0 )
    {
        // Set the count of properties
        cNewPropIDSets = 1;

        if(dwBitMask & PROPSET_DSO)
        {
            if(dwBitMask & PROPSET_INIT)
                // if the data src object has been initialized, return
                // properties in the DBInit, DSInfo and ADSIBind property sets.
                cNewPropIDSets = 3;
            else
                // Return DBInit and ADSIBind property sets only. Note that we
                // are counting on ADSIBind being the second property set in
                // s_rgPropertySets, since we are leaving cOffset as 0
                cNewPropIDSets = 2;
        }

         if(dwBitMask & PROPSET_COMMAND)
            cNewPropIDSets = 2;
    }

    // Figure out the Offset
    if( dwBitMask & PROPSET_SESSION )
        cOffset = INDEX_SESSION;
    else if( dwBitMask & PROPSET_COMMAND )
        cOffset = INDEX_ROWSET;

    //
    // use task memory allocater to alloc a DBPROPSET struct
    //
    pPropSet = (DBPROPSET*) _pIMalloc->Alloc(cNewPropIDSets * sizeof( DBPROPSET ));

    if( !pPropSet )
        BAIL_ON_FAILURE ( hr=E_OUTOFMEMORY );

    memset( pPropSet, 0, (cNewPropIDSets * sizeof( DBPROPSET )));

    //
    // For each supported Property Set
    //
    for (cPropertySets=0; cPropertySets < cNewPropIDSets; cPropertySets++) {

        // Initialize variable
        ULONG cPropOffset = 0;
        int cNumDSOProps = 0;
        cProperties = 0;
        pProp = NULL;
        fFound = FALSE;

        // Setup the PropSet GUID
        if( cPropertyIDSets == 0 ) {
            pPropSet[cPropertySets].guidPropertySet =
                       *s_rgPropertySets[cPropertySets+cOffset].guidPropertySet;
        }
        else {
            cProperties = rgPropertyIDSets[cPropertySets].cPropertyIDs;
            pPropSet[cPropertySets].guidPropertySet =
                    rgPropertyIDSets[cPropertySets].guidPropertySet;
        }

        if(dwBitMask & PROPSET_DSO)
             // we have 2 property sets whose properties can be set before
             // initialization and one whose properties can be set only after
             // init. Set the count of properties accordingly.
             cNumDSOProps = 1 + !!(dwBitMask & PROPSET_INIT);

        // Setup the count of Properties for that PropSet
        for (j=0;
             j <= cOffset+ cNumDSOProps + !!(dwBitMask & PROPSET_COMMAND);
             j++) {
            if( j >= cOffset &&
                IsEqualGUID(pPropSet[cPropertySets].guidPropertySet,
                            *(s_rgPropertySets[j].guidPropertySet)) ) {
                if (rgPropertyIDSets == NULL ||
                    rgPropertyIDSets[cPropertySets].cPropertyIDs == 0)
                    cProperties = s_rgPropertySets[j].cProperties;

                fFound = TRUE;
                break;
            }

            // Move to the next PropSet
            cPropOffset += s_rgPropertySets[j].cProperties;
        }

        if( cProperties != 0 ) {
            // use task memory allocator to alloc array of DBPROP struct
            pProp = (DBPROP*) _pIMalloc->Alloc(cProperties * sizeof( DBPROP ));

            if( pProp == NULL ) {
                for (i=0; i < cPropertySets; i++)
                    _pIMalloc->Free(pPropSet[i].rgProperties);

                BAIL_ON_FAILURE ( hr=E_OUTOFMEMORY );
            }

            memset( pProp, 0, (cProperties * sizeof( DBPROP )));

            if( rgPropertyIDSets == NULL ||
                rgPropertyIDSets[cPropertySets].cPropertyIDs == 0 ) {
                for (cCount=0; cCount < cProperties; cCount++)
                    pProp[cCount].dwPropertyID =
                        s_rgPropertySets[j-!fFound].pUPropInfo[cCount].dwPropertyID;
            }
            else {
                for (cCount=0; cCount < cProperties; cCount++)
                    pProp[cCount].dwPropertyID =
                        rgPropertyIDSets[cPropertySets].rgPropertyIDs[cCount];
            }
        }
        else
            fWarning = TRUE;

        //
        // for each prop in our table..
        //
        for (cCount = 0; cCount < cProperties; cCount++) {
            hr = LoadDBPROP((fFound ? &(_prgProperties[cPropOffset]) :  NULL),
                            (fFound ? s_rgPropertySets[j-!fFound].cProperties : 0),
                            &pProp[cCount],
                            pPropSet[cPropertySets].guidPropertySet == DBPROPSET_DBINIT
                            );

            if( FAILED(hr) ) {
                // something went wrong
                // clear all variants used so far..
                for (i=0; i < cCount; i++)
                    VariantClear( &pProp[i].vValue );

                for (i=0; i < cPropertySets; i++)
                    _pIMalloc->Free(pPropSet[i].rgProperties);

                                _pIMalloc->Free(pProp);

                BAIL_ON_FAILURE( hr );
            }

            if( hr != S_OK )
                fWarning = TRUE;
            else
                fNoPropertyGot = FALSE;

        }    // for each property

        pPropSet[cPropertySets].rgProperties = pProp;
        pPropSet[cPropertySets].cProperties = cProperties;
    }    // for each property set

    // set count of properties and property informatio
    *pcPropertySets   = cNewPropIDSets;
    *pprgPropertySets = pPropSet;

    if( fNoPropertyGot )
       RRETURN( DB_E_ERRORSOCCURRED );
    else if( fWarning )
       RRETURN( DB_S_ERRORSOCCURRED );
    else
       RRETURN( S_OK );

error:
    if( pPropSet )
        _pIMalloc->Free(pPropSet);
    RRETURN( hr );
}


//+---------------------------------------------------------------------------
//
//  Function:  CUtilProp::SetProperties
//
//  Synopsis:  Set current settings of properties supported by the DSO/rowset
//
//  Arguments:
//
//             cPropertyIDSets,      # of DBPROPSET
//             rgPropertyIDSets[]    Array of property sets
//
//  Returns:
//             S_OK          | The method succeeded
//             E_INVALIDARG  | pcPropertyIDSets or prgPropertyInfo was NULL
//             E_OUTOFMEMORY | Out of memory
//
//  Modifies:
//
//  History:    08-28-96   ShankSh     Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CUtilProp::SetProperties(
    ULONG cPropertySets,
    DBPROPSET rgPropertySets[],
    DWORD dwBitMask
    )
{
    ULONG cCount, j, k;
    HRESULT hr;
    BOOL fNoPropertySet = TRUE;
    BOOL fWarning = FALSE;

    // check params
    if( cPropertySets > 0 && !rgPropertySets )
        RRETURN ( E_INVALIDARG );

    // New argument check for > 1 cPropertyIDs and NULL pointer for
    // array of property ids.
    for(ULONG ul=0; ul<cPropertySets; ul++)
    {
        if( rgPropertySets[ul].cProperties &&
            !(rgPropertySets[ul].rgProperties) )
            RRETURN ( E_INVALIDARG );
    }

    for (cCount=0; cCount < cPropertySets; cCount++) {
        // Not legal to Set INIT or DATASOURCE properties after Initializing
        if( (dwBitMask & PROPSET_INIT) &&
            (rgPropertySets[cCount].guidPropertySet == DBPROPSET_DBINIT) ) {
            //
            // Wrong time to set these Properties
            //
            for (k=0; k < rgPropertySets[cCount].cProperties; k++) {
                rgPropertySets[cCount].rgProperties[k].dwStatus = DBPROPSTATUS_NOTSETTABLE;
                fWarning = TRUE;
            }
            continue;
        }

        // Trying to set the wrong Property Set
        if( ((dwBitMask & PROPSET_DSO) && !(dwBitMask & PROPSET_INIT) &&
             (rgPropertySets[cCount].guidPropertySet != DBPROPSET_DBINIT &&
              rgPropertySets[cCount].guidPropertySet != DBPROPSET_ADSIBIND)) ||
            ((dwBitMask & PROPSET_DSO) && (dwBitMask & PROPSET_INIT) &&
             rgPropertySets[cCount].guidPropertySet != DBPROPSET_DATASOURCEINFO) ||
            ((dwBitMask & PROPSET_SESSION) &&
             rgPropertySets[cCount].guidPropertySet != DBPROPSET_SESSION) ||
            ((dwBitMask & PROPSET_COMMAND) &&
             rgPropertySets[cCount].guidPropertySet != DBPROPSET_ROWSET &&
             rgPropertySets[cCount].guidPropertySet != DBPROPSET_ADSISEARCH) ) {

            //
            // Wrong Property Set
            //
            for (k=0; k < rgPropertySets[cCount].cProperties; k++) {
                rgPropertySets[cCount].rgProperties[k].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
                fWarning = TRUE;
            }
            continue;
        }

        ULONG cPropOffset = 0;

        for (j=0; j< NUMELEM(s_rgPropertySets); j++) {
            if (IsEqualGUID(rgPropertySets[cCount].guidPropertySet,
                            *(s_rgPropertySets[j].guidPropertySet))) {
                for (k=0; k < rgPropertySets[cCount].cProperties; k++) {
                    hr = StoreDBPROP(&(_prgProperties[cPropOffset]),
                                     s_rgPropertySets[j].pUPropInfo,
                                     s_rgPropertySets[j].cProperties,
                                     &(rgPropertySets[cCount].rgProperties[k]),
                                     j );

                    if( hr != S_OK )
                        fWarning = TRUE;
                    else
                        fNoPropertySet = FALSE;
                }
                break;
            }
            // Move to the next PropSet
            cPropOffset += s_rgPropertySets[j].cProperties;
        }
    }

    if ( fNoPropertySet && fWarning )
       RRETURN ( DB_E_ERRORSOCCURRED );
    else if (fWarning)
       RRETURN ( DB_S_ERRORSOCCURRED );
    else
       RRETURN ( S_OK );
}


BOOL
CUtilProp::IsIntegratedSecurity(
    void
    )
{
    // Check to see if SSPI is set
    for (ULONG i=0; i< s_rgPropertySets[INDEX_INIT].cProperties; i++) {
        if( _prgProperties[i].dwPropertyID == DBPROP_AUTH_INTEGRATED)
        {
            if (_prgProperties[i].pwstrVal )
                return( wcscmp(_prgProperties[i].pwstrVal, L"SSPI") == 0 );
            break;
        }
    }

    return FALSE;
}

BOOL
CUtilProp::IsADSIFlagSet()
{
    ULONG PropSetOffset = 0, i;

    for(i = 0; i < INDEX_ADSIBIND; i++)
          PropSetOffset += s_rgPropertySets[i].cProperties;

    // Check if "ADSI Flag" is set to something other than ADS_AUTH_RESERVED 
    for (i=0; i < s_rgPropertySets[INDEX_ADSIBIND].cProperties; i++)
        if(_prgProperties[i+PropSetOffset].dwPropertyID == ADSIPROP_ADSIFLAG)
             return (_prgProperties[i+PropSetOffset].longVal != 
                                                           ADS_AUTH_RESERVED);

    // we should never get here
    return FALSE;
}