windows-server-2003/ds/adsi/winnt/cobjcach.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1995.
//
//  File:       cpdccach.cxx
//
//  Contents:     PDC Names Cache functionality for the WinNT Provider
//
//  Functions:
//                CObjNameCache::addentry
//                CObjNameCache::findentry
//                CObjNameCache::getentry
//                CProperyCache::CObjNameCache
//                CObjNameCache::~CObjNameCache
//                CObjNameCache::CreateClassCache
//
//  History:      25-Apr-96   KrishnaG   Created.
//                30-Aug-96   RamV       Permit cache to store values
//                                       other than PDC names
//
//----------------------------------------------------------------------------
#include "winnt.hxx"

//
// Definition for DsGetDcName on 4.0
//
typedef DWORD (*PF_DsGetDcName) (
    IN LPCWSTR ComputerName OPTIONAL,
    IN LPCWSTR DomainName OPTIONAL,
    IN GUID *DomainGuid OPTIONAL,
    IN LPCWSTR SiteName OPTIONAL,
    IN ULONG Flags,
    OUT PDOMAIN_CONTROLLER_INFO *DomainControllerInfo
);

#ifdef UNICODE
#define GETDCNAME_API        "DsGetDcNameW"
#else
#define GETDCNAME_API        "DsGetDcNameA"
#endif



//
// DsGetDc will be called if applicabel if not we will look
// at the flags and decide if we should call NetGetAnyDCName or
// NetGetDCName - AjayR 11-04-98.
// Note the code below is not exactly "elegant" but I cannot think
// of any other way to build on 4.0, 95 and NT. Please play close
// attention to the #ifdefs when reading.
//
HRESULT
DsGetDcNameNTWrapper(
    IN LPCWSTR DomainName,
    OUT LPWSTR *ppszServerName,
    IN ULONG Flags
    )
{
    LPCWSTR ComputerName = NULL;
    GUID *DomainGuid = NULL;
    LPCWSTR SiteName = NULL;
    PDOMAIN_CONTROLLER_INFO pDomainControllerInfo = NULL;
    DWORD dwStatus = NULL;
    LPWSTR pszNetServerName = NULL;
    HRESULT hr = S_OK;
    ULONG ulDsGetDCFlags = DS_RETURN_FLAT_NAME | DS_WRITABLE_REQUIRED;

    if (Flags & ADS_READONLY_SERVER) {
        ulDsGetDCFlags &= ~DS_WRITABLE_REQUIRED;
    }

    *ppszServerName = NULL;


    static PF_DsGetDcName pfDsGetDcName = NULL ;


    //
    // Load the function if necessary
    //
    if (pfDsGetDcName == NULL) {
        pfDsGetDcName =
            (PF_DsGetDcName) LoadNetApi32Function(GETDCNAME_API) ;
    }

    if (pfDsGetDcName != NULL) {

        dwStatus =  ((*pfDsGetDcName)(
                        ComputerName,
                        DomainName,
                        DomainGuid,
                        SiteName,
                        ulDsGetDCFlags,
                        &pDomainControllerInfo
                        )
                     );

        if (dwStatus == NO_ERROR) {
            *ppszServerName = AllocADsStr(
                                  pDomainControllerInfo->DomainControllerName
                                  );

            if (!*ppszServerName)
                hr = E_OUTOFMEMORY;

        } else {
            hr = HRESULT_FROM_WIN32(dwStatus);
        }

    } else {
        //
        // Could not load library
        //
        if (Flags & ADS_READONLY_SERVER) {

#ifdef WIN95
             dwStatus = NetGetDCName(
                            NULL,
                            DomainName,
                            (LPBYTE *)&pszNetServerName
                            );
#else
             dwStatus = NetGetAnyDCName(
                            NULL,
                            DomainName,
                            (LPBYTE *)&pszNetServerName
                            );
#endif

         } else {

             dwStatus = NetGetDCName(
                            NULL,
                            DomainName,
                            (LPBYTE *)&pszNetServerName
                            );
         }

         if (dwStatus == NO_ERROR) {
             *ppszServerName = AllocADsStr(
                                   pszNetServerName
                                 );

             if (!*ppszServerName)
                 hr = E_OUTOFMEMORY;

         } else {

             hr = HRESULT_FROM_WIN32(dwStatus);

         }

     }


     if (pszNetServerName) {
         (void) NetApiBufferFree( (void*) pszNetServerName);
     }

     if (pDomainControllerInfo) {
         (void) NetApiBufferFree(pDomainControllerInfo);
     }

     RRETURN(hr);
 }







//+------------------------------------------------------------------------
//
//  Function:   CObjNameCache::addentry
//
//  Synopsis:
//
//
//
//  Arguments:  [pszDomainName]       --
//              [pszPDCName]      --
//              [pClassEntry]       --
//
//
//-------------------------------------------------------------------------

HRESULT
CObjNameCache::
addentry(
    LPWSTR pszElementName,
    BOOL fCacheHit,
    DWORD dwElementType,
    LPWSTR pszName
    )
{

    //
    // The parameter pszName is either the Domain/Wkgrp Name (if dwElementType
    // = COMPUTER_ENTRY_TYPE)   and  PDC Name (if   dwElementType     is
    // DOMAIN_ENTRY_TYPE). it will be a blank string if dwElementType is
    // WORKGROUP_ENTRY_TYPE
    //
    // we will support adding cache hits/misses.
    //

    HRESULT hr = S_OK;
    DWORD i = 0;
    DWORD dwLRUEntry = 0;
    DWORD dwIndex = 0;

    EnterCriticalSection(&_cs);

    //
    // before adding entries, let us clean out all existing old entries
    //

    if (_dwMaxCacheSize == 0){
        hr = E_FAIL;
        goto error;
    }

    hr = InvalidateStaleEntries();
    BAIL_ON_FAILURE(hr);

    hr = findentry(
            pszElementName,
            &dwIndex
            );

    //
    // if you find an entry then you cannot add it to the cache
    //

    if(SUCCEEDED(hr)){
        goto error;
    }

    hr = S_OK;

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

        if (!_ClassEntries[i].bInUse) {

            //
            // Found an available entry; use it
            // fill in the name of the entry and related information
            // for this class entry
            //
            break;

        } else {

            if ((dwLRUEntry == -1) || (i == IsOlderThan(i, dwLRUEntry))){
                dwLRUEntry = i;
            }
        }

    }

    if (i == _dwMaxCacheSize){

        //
        // We have no available entries so we need to use
        // the LRUEntry which is busy
        //


        //
        // Free the members of the LRU Entry
        //
        if (_ClassEntries[dwLRUEntry].pszElementName)
        {
            FreeADsStr(_ClassEntries[dwLRUEntry].pszElementName);
            _ClassEntries[dwLRUEntry].pszElementName = NULL;
        }

        //
        // All members of the union are strings so it is not
        // necessary to check for each of the members.  Just free
        // one of them if it is non-null.
        //
        if(_ClassEntries[i].u.pszPDCName)
        {
            FreeADsStr(_ClassEntries[i].u.pszPDCName);
            _ClassEntries[i].u.pszPDCName = NULL;
        }

        _ClassEntries[dwLRUEntry].bInUse = FALSE;

        i = dwLRUEntry;
    }


    //
    // Insert the new entry into the Cache
    //

    _ClassEntries[i].pszElementName = AllocADsStr(pszElementName);

    if(_ClassEntries[i].pszElementName == NULL){
        hr = E_OUTOFMEMORY;
        goto error;
    }


    _ClassEntries[i].dwElementType = dwElementType;

    if ( fCacheHit){

        _ClassEntries[i].fCacheHit = TRUE;

        switch(dwElementType) {

        case DOMAIN_ENTRY_TYPE:

            _ClassEntries[i].u.pszPDCName = AllocADsStr(pszName);
            if(_ClassEntries[i].u.pszPDCName == NULL){
                hr = E_OUTOFMEMORY;
                goto error;
            }

            break;

        case DOMAIN_ENTRY_TYPE_RO:
            _ClassEntries[i].u.pszDCName = AllocADsStr(pszName);
            if (_ClassEntries[i].u.pszDCName == NULL) {
                hr = E_OUTOFMEMORY;
                goto error;
            }

            break;

        case COMPUTER_ENTRY_TYPE:

            _ClassEntries[i].u.pszDomainName = AllocADsStr(pszName);
            if(_ClassEntries[i].u.pszDomainName == NULL){
                hr = E_OUTOFMEMORY;
                goto error;
            }

            break;

        default:
            break;

        }
    } else {

        _ClassEntries[i].fCacheHit = FALSE;
    }

    _ClassEntries[i].bInUse = TRUE;

    //
    // update the time stamp so that we know when this entry was made
    //

    GetSystemTime(&_ClassEntries[i].st);

error:

    LeaveCriticalSection(&_cs);

    RRETURN(hr);
}

//+------------------------------------------------------------------------
//
//  Function:   CObjNameCache::findentry
//
//  Synopsis:
//
//
//
//  Arguments:  [szPropertyName] --
//              [pdwIndex]       --
//
//-------------------------------------------------------------------------

HRESULT
CObjNameCache::
findentry(
    LPWSTR pszElementName,
    PDWORD pdwIndex
    )
{
    DWORD i = 0;


    EnterCriticalSection(&_cs);

    if (_dwMaxCacheSize == 0 ) {

        LeaveCriticalSection(&_cs);
        RRETURN(E_FAIL);
    }

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

        if (_ClassEntries[i].bInUse) {

            if(!_ClassEntries[i].pszElementName ){
                continue;
            }

#ifdef WIN95
            if (!_wcsicmp(_ClassEntries[i].pszElementName, pszElementName)){
#else
            if (CompareStringW(
                    LOCALE_SYSTEM_DEFAULT,
                    NORM_IGNORECASE,
                    _ClassEntries[i].pszElementName,
                    -1,
                    pszElementName,
                    -1
                    ) == CSTR_EQUAL ) {
#endif

                *pdwIndex = i;


                LeaveCriticalSection(&_cs);

                RRETURN(S_OK);

            }
        }
    }

    LeaveCriticalSection(&_cs);

    RRETURN(E_FAIL);
}

//+------------------------------------------------------------------------
//
//  Function:   CObjNameCache::getentry
//
//  Synopsis:
//
//
//
//  Arguments:  [szPropertyName] --
//              [pdwIndex]       --
//
//-------------------------------------------------------------------------

HRESULT
CObjNameCache::
getentry(
    LPWSTR pszElementName,
    PBOOL  pfHit,
    PDWORD pdwEntryType,
    LPWSTR pszName
    )
{
    DWORD dwIndex = 0;
    HRESULT hr = S_OK;
    DWORD i;

    EnterCriticalSection(&_cs);

    //
    // blow away all the entries that have expired
    //

    hr = InvalidateStaleEntries();
    BAIL_ON_FAILURE(hr);

    hr = findentry(
            pszElementName,
            &dwIndex
        );
    BAIL_ON_FAILURE(hr);

    *pfHit = _ClassEntries[dwIndex].fCacheHit;
    *pdwEntryType =  _ClassEntries[dwIndex].dwElementType;


    switch(_ClassEntries[dwIndex].dwElementType) {

    case DOMAIN_ENTRY_TYPE:
        wcscpy(pszName, _ClassEntries[dwIndex].u.pszPDCName);
        break;

    case COMPUTER_ENTRY_TYPE:
        wcscpy(pszName, _ClassEntries[dwIndex].u.pszDomainName);
        break;


    case DOMAIN_ENTRY_TYPE_RO:
        wcscpy(pszName, _ClassEntries[dwIndex].u.pszDCName);
        break;

    default:
        wcscpy(pszName, TEXT(""));
        break;

    }


error:

    LeaveCriticalSection(&_cs);

   RRETURN(hr);

}


HRESULT
CObjNameCache::
InvalidateStaleEntries()
{

    DWORD i=0;
    SYSTEMTIME stCurrentTime;
    BOOL fCacheHit;

    GetSystemTime(&stCurrentTime);

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

        fCacheHit = _ClassEntries[i].fCacheHit;

        if(_ClassEntries[i].bInUse &&
           TimeDifference(stCurrentTime, _ClassEntries[i].st)
           > AGE_LIMIT_VALID_ENTRIES  && fCacheHit == CACHE_HIT) {

            _ClassEntries[i].bInUse = FALSE;
            FreeADsStr(_ClassEntries[i].pszElementName);
            _ClassEntries[i].pszElementName = NULL;

            if((_ClassEntries[i].dwElementType == DOMAIN_ENTRY_TYPE) ||
                (_ClassEntries[i].dwElementType == DOMAIN_ENTRY_TYPE_RO))
            {
                FreeADsStr(_ClassEntries[i].u.pszPDCName);
                _ClassEntries[i].u.pszPDCName = NULL;


            } else if (_ClassEntries[i].dwElementType == COMPUTER_ENTRY_TYPE){
                FreeADsStr(_ClassEntries[i].u.pszDomainName);
                _ClassEntries[i].u.pszPDCName = NULL;

            }
        }else if(_ClassEntries[i].bInUse &&
                 TimeDifference(stCurrentTime, _ClassEntries[i].st)
                 > AGE_LIMIT_INVALID_ENTRIES  && fCacheHit == CACHE_MISS) {

            _ClassEntries[i].bInUse = FALSE;
        }

    }

    RRETURN(S_OK);
}


//+------------------------------------------------------------------------
//
//  Function:   CObjNameCache
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------
CObjNameCache::CObjNameCache() :
    _fCriticalSectionInitialized(FALSE)
{
    _dwMaxCacheSize = 10;
    memset(_ClassEntries, 0, sizeof(CLASSENTRY)* MAX_ENTRIES);
}

//+------------------------------------------------------------------------
//
//  Function:   ~CObjNameCache
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------
CObjNameCache::
~CObjNameCache()
{
    DWORD i= 0;
    for (i=0; i< MAX_ENTRIES; i++){
        if(_ClassEntries[i].pszElementName){
            FreeADsStr(_ClassEntries[i].pszElementName);
        }

        //
        // All members of the union are strings so it is not
        // necessary to check for each of the members.
        //
        if(_ClassEntries[i].u.pszPDCName){
            FreeADsStr(_ClassEntries[i].u.pszPDCName);
        }
    }

    if (_fCriticalSectionInitialized)
        DeleteCriticalSection(&_cs);

}

//+------------------------------------------------------------------------
//
//  Function:
//
//  Synopsis:
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------
HRESULT
CObjNameCache::
CreateClassCache(
    CObjNameCache FAR *FAR * ppClassCache
    )
{
    CObjNameCache FAR * pClassCache = NULL;

    pClassCache = new CObjNameCache();

    if (!pClassCache) {
        RRETURN(E_FAIL);
    }

    __try
    {
        InitializeCriticalSection(&(pClassCache->_cs));

        pClassCache->_fCriticalSectionInitialized = TRUE;
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        RRETURN(E_OUTOFMEMORY);
    }

    *ppClassCache = pClassCache;

    RRETURN(S_OK);
}


DWORD
CObjNameCache::
IsOlderThan(
    DWORD i,
    DWORD j
    )
{
    SYSTEMTIME *pi, *pj;
    DWORD iMs, jMs;
    // DBGMSG(DBG_TRACE, ("IsOlderThan entering with i %d j %d\n", i, j));

    pi = &(_ClassEntries[i].st);
    pj = &(_ClassEntries[j].st);

    if (pi->wYear < pj->wYear) {
        // DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", i));
        return(i);
    } else if (pi->wYear > pj->wYear) {
        // DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", j));
        return(j);
    } else  if (pi->wMonth < pj->wMonth) {
        // DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", i));
        return(i);
    } else if (pi->wMonth > pj->wMonth) {
        // DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", j));
        return(j);
    } else if (pi->wDay < pj->wDay) {
        // DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", i));
        return(i);
    } else if (pi->wDay > pj->wDay) {
        // DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", j));
        return(j);
    } else {
        iMs = ((((pi->wHour * 60) + pi->wMinute)*60) + pi->wSecond)* 1000 + pi->wMilliseconds;
        jMs = ((((pj->wHour * 60) + pj->wMinute)*60) + pj->wSecond)* 1000 + pj->wMilliseconds;

        if (iMs <= jMs) {
            // DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", i));
            return(i);
        } else {
            // DBGMSG(DBG_TRACE, ("IsOlderThan returns %d\n", j));
            return(j);
        }
    }
}


HRESULT
WinNTGetCachedDCName(
    LPWSTR pszDomainName,
    LPWSTR pszPDCName,
    DWORD  dwFlags
    )
{
    WCHAR szSAMName[MAX_PATH];

    // In this case credentials do not help because we do not have
    // any server/domain to connect to. This is because the param
    // pszDomainName is not a domain name for certain.

    CWinNTCredentials nullCredentials;

    // We do want to copy the flags parameter as that will tell
    // us if we need to connect to PDC or not

    nullCredentials.SetFlags(dwFlags);

    RRETURN(WinNTGetCachedObject(pszDomainName,
                                 DOMAIN_ENTRY_TYPE,
                                 pszPDCName,
                                 szSAMName,
                                 dwFlags,
                                 nullCredentials
                                 ));
}



HRESULT
WinNTGetCachedComputerName(
    LPWSTR pszComputerName,
    LPWSTR pszName,
    LPWSTR pszSAMName,
    CWinNTCredentials& Credentials
    )
{

    RRETURN(WinNTGetCachedObject(pszComputerName,
                                 COMPUTER_ENTRY_TYPE,
                                 pszName,
                                 pszSAMName,
                                 Credentials.GetFlags(), // doesnt matter
                                 Credentials
                                 ));

}




HRESULT
WinNTGetCachedObject(
    LPWSTR pszElementName,
    DWORD dwElementType,
    LPWSTR pszName,
    LPWSTR pszSAMName,
    DWORD dwFlags,
    CWinNTCredentials& Credentials
    )
{
    HRESULT hr = S_OK;
    NET_API_STATUS nasStatus = 0;
    BOOL fCacheHit;
    DWORD dwEntryType;
    LPWKSTA_INFO_100 lpWI = NULL;
    DWORD dwObjectsReturned;
    DWORD dwObjectsTotal;
    DWORD dwResumeHandle;
    // Freed using NetAPI
    LPWSTR pszServerName = NULL;
    // Freed using FreeADsStr
    LPWSTR pszADsStrServerName = NULL;
    BOOL fRefAdded = FALSE;
    DWORD dwDomainEntryType = DOMAIN_ENTRY_TYPE;
    // This will be the case most often
    DWORD dwUserFlags = Credentials.GetFlags();
    DSROLE_PRIMARY_DOMAIN_INFO_BASIC* pdomainInfo = NULL;       
    BOOL fNetBIOS = FALSE;
    BOOL fDsRoleCallAttempted = FALSE;

    hr = pgPDCNameCache->getentry(
                    pszElementName,
                    &fCacheHit,
                    &dwEntryType,
                    pszName
                    );

    if (SUCCEEDED(hr)) {
        //
        // we found the entry. Now need to verify that it indeed
        // is an object of type desired
        //

        // Note that dwElement type will never be DOMAIN_ENTRY_TYPE_RO
        if(fCacheHit) {
            if (dwEntryType == dwElementType
                || ((dwElementType == DOMAIN_ENTRY_TYPE)
                    && (dwEntryType == DOMAIN_ENTRY_TYPE_RO)
                    && (dwUserFlags & ADS_READONLY_SERVER))
                ) {

                //
                // If the user now needs a writeable connection
                // should we fail or should we actually pretend
                // that the object is not there in the cache.
                //

                hr = S_OK;
                goto error;

            }

        } else if (!fCacheHit && (dwElementType == WORKGROUP_ENTRY_TYPE)) {
            //
            // looks like we either found a cache miss
            // Return  ok
            //
            hr = S_OK;
            goto error;

        } else {

            hr = E_FAIL;
            goto error;

        }

    }
    switch(dwElementType){

    case DOMAIN_ENTRY_TYPE:

            //
            // A read only server is ok, need to also set the
            // domain entry type accordingly
            //
        if (dwFlags & ADS_READONLY_SERVER) {
            dwDomainEntryType = DOMAIN_ENTRY_TYPE_RO;
        }

        //
        // Call the all encompassing Wrapper.
        //
        hr = DsGetDcNameNTWrapper(
                 pszElementName,
                 &pszADsStrServerName,
                 dwFlags
                 );

        BAIL_ON_FAILURE(hr);

        hr = pgPDCNameCache->addentry(
                pszElementName,
                TRUE,
                dwDomainEntryType,
                pszADsStrServerName
                );

        BAIL_ON_FAILURE(hr);
        //
        // in addition we can also add a computer entry for the PDC
        //

        hr = pgPDCNameCache->addentry(
                pszADsStrServerName+2,  // to get rid of the leading backslashes
                TRUE,
                COMPUTER_ENTRY_TYPE,
                pszElementName
                );

        BAIL_ON_FAILURE(hr);

        wcscpy(pszName, pszADsStrServerName);

        break;

    case COMPUTER_ENTRY_TYPE:

        // Ref the computer, note that RefServer will not
        // do anything if the credentials are null. We are also
        // not worried about errors as we want to use default
        // credentials in that case.

        hr = Credentials.RefServer(pszElementName);

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

        nasStatus = NetWkstaGetInfo(
                        pszElementName,
                        100,
                        (LPBYTE*) &lpWI
                        );

        hr = HRESULT_FROM_WIN32(nasStatus);
        BAIL_ON_FAILURE(hr);

#ifdef WIN95
        //
        // No NetpNameCompare for Win9x
        //
        if (lpWI->wki100_computername
            && (_wcsicmp(pszElementName, lpWI->wki100_computername) == 0)
            )
#else
        if (lpWI->wki100_computername
            && ( NetpNameCompare(
                     NULL,
                     pszElementName,
                     lpWI->wki100_computername,
                     NAMETYPE_COMPUTER,
                     0
                     )
                 == 0 )
            )
#endif
         {


            // Want to add the correct capitalized name
            // Not what the user gave
            hr = pgPDCNameCache->addentry(
                     lpWI->wki100_computername,
                     TRUE,
                     COMPUTER_ENTRY_TYPE,
                     lpWI->wki100_langroup
                     );

            wcscpy(pszSAMName, lpWI->wki100_computername);

            fNetBIOS = TRUE;


         } 
         else {

            DsRoleGetPrimaryDomainInformation(
                                         pszElementName,                      
                                         DsRolePrimaryDomainInfoBasic,   // InfoLevel
                                         (PBYTE*)&pdomainInfo            // pBuffer
                                         );    
            fDsRoleCallAttempted = TRUE;
            // we don't bail out even if the call fails

            //
            // user actually passes in ipaddress as the computer name
            //
            if(IsAddressNumeric(pszElementName)) {
            	hr = pgPDCNameCache->addentry(
                         pszElementName,
                         TRUE,
                         COMPUTER_ENTRY_TYPE,
                         pdomainInfo && pdomainInfo->DomainNameDns ? pdomainInfo->DomainNameDns : lpWI->wki100_langroup
                         );

                wcscpy(pszSAMName, L"");
            }
            //
            // user may pass in the dns name of the computer
            //
            else {
                
            	if(pdomainInfo) {
            		if(((pdomainInfo->DomainNameDns) && _wcsicmp(pszElementName, pdomainInfo->DomainNameDns) == 0)
            			               ||
            			               
            	      ((pdomainInfo->DomainNameFlat) && NetpNameCompare(
                                       NULL,
                                       pszElementName,
                                       pdomainInfo->DomainNameFlat,
                                       NAMETYPE_COMPUTER,
                                       0
                                       )
                                       == 0) )            		             
            		 
            		{
            			BAIL_ON_FAILURE(hr=HRESULT_FROM_WIN32(ERROR_BAD_NETPATH));
            		}
            		else {
            			hr = pgPDCNameCache->addentry(
                                 pszElementName,
                                 TRUE,
                                 COMPUTER_ENTRY_TYPE,
                                 pdomainInfo->DomainNameDns
                                 );

                        wcscpy(pszSAMName, L"");
            		}       			
            			
               	} 
            	else {          		           
           	
                    BAIL_ON_FAILURE(hr=HRESULT_FROM_WIN32(ERROR_BAD_NETPATH));
            	}
        
            }
        }    

        // we need to return the correct format of domain name
        if(!(*pszName))
        {
            // the parent name is NULL
            if(fNetBIOS)
            {
                // if the user specifies the computer netbios name, then we just return the domain netbios name
                wcscpy(pszName, lpWI->wki100_langroup);
            }
            else
            {
                // othereise we tries to return the domain dns name
                wcscpy(pszName, pdomainInfo && pdomainInfo->DomainNameDns ? pdomainInfo->DomainNameDns : lpWI->wki100_langroup);
            }
            
        }
        else
        {
            // we have the parent name passed in, so we need to return pszName accordingly
            if (lpWI->wki100_langroup
            && ( NetpNameCompare(
                     NULL,
                     pszName,
                     lpWI->wki100_langroup,
                     NAMETYPE_DOMAIN,
                     0
                     )
                 ))
            {
                // the parent name passed in is not equal to the domain netbios name

                if(!fDsRoleCallAttempted)
                {
                    DsRoleGetPrimaryDomainInformation(
                                         pszElementName,                      
                                         DsRolePrimaryDomainInfoBasic,   // InfoLevel
                                         (PBYTE*)&pdomainInfo            // pBuffer
                                         );    
                    
                }

                // unless the the parent name passed in is equal to the domain dns name, we just put domain netbios name
                // to the pszName
                    
                if(!(pdomainInfo && pdomainInfo->DomainNameDns && !_wcsicmp(pszName, pdomainInfo->DomainNameDns)))
                {
                    // the parent name passed in is not equal to the domain dns name also
                    wcscpy(pszName, lpWI->wki100_langroup);
                }
                
                
            }
            
        }       
        
        
        break;


    default:
        hr = E_FAIL;
        break;
    }

error:

	if (fRefAdded) {
        Credentials.DeRefServer();
        // even if we fail, we have no recovery path
        fRefAdded = FALSE;
    }

            
    if(lpWI){
        NetApiBufferFree(lpWI);
    }

    if(pszServerName){
        NetApiBufferFree(pszServerName);
    }

    if (pszADsStrServerName) {
        FreeADsStr(pszADsStrServerName);
    }

    if ( pdomainInfo )
	{
		DsRoleFreeMemory(pdomainInfo);
	}

    RRETURN(hr);
}



//+------------------------------------------------------------------------
//
//  Function:
//
//  Synopsis:
//    This function is called by Heuristic GetObject to identify what
//    kind of object we are dealing with. Here we try to get a cached
//    entry if it is a hit/miss. If it fails, then we try each kind
//    of object in turn. (Domain/Computer/Workgroup). Once we do this,
//    we cache this information internally
//
//
//
//  Arguments:
//
//
//-------------------------------------------------------------------------

HRESULT
WinNTGetCachedName(
    LPWSTR pszElementName,
    PDWORD  pdwElementType,
    LPWSTR pszName,
    LPWSTR pszSAMName,
    CWinNTCredentials& Credentials
    )
{
    HRESULT hr = S_OK;
    BOOL fCacheHit;
    DWORD dwEntryType;
    WCHAR szSAMName[MAX_ADS_PATH];
    BOOL fRefAdded = FALSE;
    DWORD dwUserFlags = Credentials.GetFlags();

    szSAMName[0] = pszName[0] = L'\0';

    if (!pszElementName || !*pszElementName) {
        RRETURN(E_FAIL);
    }

    hr = pgPDCNameCache->getentry(
                    pszElementName,
                    &fCacheHit,
                    &dwEntryType,
                    pszName
                    );

    if (SUCCEEDED(hr)) {
        //
        // we found the entry.
        //

        if (!fCacheHit){
            //
            // cache miss saved as a workgroup
            //
            *pdwElementType = WORKGROUP_ENTRY_TYPE;
            goto error;

        } else {
            if(dwEntryType == DOMAIN_ENTRY_TYPE_RO) { 
                if(dwUserFlags & ADS_READONLY_SERVER) {
                    // HeuristicGetObj doesn't recognize DOMAIN_ENTRY_TYPE_RO
                    *pdwElementType = DOMAIN_ENTRY_TYPE;
                    goto error;
                }
            }
            else {
                *pdwElementType = dwEntryType;
                goto error;
            }
        }

    } 

    {

        // at this point, we can try and ref the domain as
        // we are looking to bind to the domain

        hr = Credentials.RefDomain(pszElementName);
        // note that even if this fails we want to continue
        // as there is the chance that the current users
        // credentials are good enough for the operation

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

        hr = WinNTGetCachedObject(
                 pszElementName,
                 DOMAIN_ENTRY_TYPE,
                 pszName,
                 szSAMName,
                 Credentials.GetFlags(),
                 Credentials
                 );

        if (fRefAdded) {
            Credentials.DeRefDomain();
            // we cannot really do anything useful with HR
            fRefAdded = FALSE;
        }

        if (SUCCEEDED(hr)){
            *pdwElementType = DOMAIN_ENTRY_TYPE;
            wcscpy(pszSAMName, szSAMName);
            RRETURN(hr);
        }

        hr = WinNTGetCachedObject(
                 pszElementName,
                 COMPUTER_ENTRY_TYPE,
                 pszName,
                 szSAMName,
                 Credentials.GetFlags(),
                 Credentials
                 );


        if (SUCCEEDED(hr)){
            *pdwElementType = COMPUTER_ENTRY_TYPE;
            wcscpy(pszSAMName, szSAMName);
            RRETURN(hr);
        }


        //
        // if you are here, it means that you have to cache a miss as a
        // workgroup.
        // Note that pszSAMName rather than pszElementName is added
        // if it is valid

        // AjayR - to handle the no workstation case,
        // We should not add anything if the error was NOWksta service

        if (hr != HRESULT_FROM_WIN32(NERR_WkstaNotStarted)) {

            if (szSAMName[0] != L'\0') {

                hr = pgPDCNameCache->addentry(
                         szSAMName,
                         FALSE,
                         WORKGROUP_ENTRY_TYPE,
                         TEXT("")
                         );

            } else {

                hr = pgPDCNameCache->addentry(
                         pszElementName,
                         FALSE,
                         WORKGROUP_ENTRY_TYPE,
                         TEXT("")
                         );

            }
        }  // No Wksta started


        *pdwElementType = WORKGROUP_ENTRY_TYPE;
        wcscpy(pszName, TEXT(""));
        goto error;
    }


error:
    RRETURN(hr);
}

LONG
TimeDifference(
    SYSTEMTIME st1,
    SYSTEMTIME st2
    )

{
   //
   // This function gives the difference between st1 and st2 (st1-st2)in secs.
   // This will be used by our internal cache object so as to find out if
   // a certain entry in the cache is too old.
   // Assumption: st1 is later than st2.


    DWORD dwTime1;
    DWORD dwTime2;
    DWORD dwMonth1;
    DWORD dwMonth2;
    LONG lRetval;
    //
    // Ignore milliseconds because it is immaterial for our purposes
    //


    dwTime1= st1.wSecond + 60 *
        (st1.wMinute + 60* (st1.wHour + 24 * (st1.wDay)));


    dwTime2= st2.wSecond + 60 *
        (st2.wMinute + 60* (st2.wHour + 24 * (st2.wDay)));


    if (dwTime1 == dwTime2) {
        return(0);
    }

    if (dwTime1 > dwTime2 && (st1.wMonth == st2.wMonth) &&
        st1.wYear == st2.wYear) {
        lRetval = (LONG)(dwTime1-dwTime2);
        goto cleanup;
    }


    dwMonth1 = 12*st1.wYear+ st1.wMonth;
    dwMonth2 = 12*st2.wYear+ st2.wMonth;

    if (dwMonth1 < dwMonth2) {
        //
        // looks like we got a bogus value. return -1
        //
        lRetval = -1;
        goto cleanup;
    }

    //
    // if there is a month difference of more than 1 then we return
    // a large positive number (0xFFFFFFF)
    //

    if (dwMonth1 > dwMonth2+1) {
        lRetval = 0xFFFFFFF;
        goto cleanup;
    }


    //
    //  we crossed a month boundary
    //

    dwTime1= st1.wSecond + 60 *
        (st1.wMinute + 60* (st1.wHour));


    dwTime2= st2.wSecond + 60 *
        (st2.wMinute);

    lRetval = ( dwTime2- dwTime1 + 60*60*24);
    goto cleanup;


cleanup:
    return(lRetval);
}

BOOL
IsAddressNumeric(
    LPWSTR HostName
)
{
    BOOLEAN rc = FALSE;

    //
    //  to check to see if it's a TCP address, we check for it to only
    //  contain only numerals and periods.
    //

    while (((*HostName >= L'0') && (*HostName <= L'9')) ||
            (*HostName == L'.')) {
        HostName++;
    }

    //
    //  if we hit the end of the hostname, then it's an address.
    //

    if (*HostName == L'\0' || *HostName == L':') {

        rc = TRUE;
    }
    return rc;

}