windows-server-2003/base/fs/remotefs/dfs/dfsserver/serverlibrary/dfsadblobcache.cxx

//
//  Copyright (C) 2000, Microsoft Corporation
//
//  File:       DfsADBlobCache.cxx
//
//  Contents:   the ADBlob DFS Store class, this contains the 
//              old AD blob store specific functionality. 
//
//  Classes:    DfsADBlobCache.
//
//  History:    Dec. 8 2000,   Author: udayh
//              April 9 2001  Rohanp - Added  AD specific code.
//
//-----------------------------------------------------------------------------
  
#include <DfsAdBlobCache.hxx>
#include <dfsrootfolder.hxx>
#include <dfserror.hxx>
#include "dfsadsiapi.hxx"
#include <sddl.h>
#include <dfssecurity.h>
#include <ntdsapi.h>
#include "dfsAdBlobCache.tmh"


DfsADBlobCache::DfsADBlobCache(
    DFSSTATUS *pStatus, 
    PUNICODE_STRING pShareName,
    DfsRootFolder * pRootFolder) :  DfsGeneric(DFS_OBJECT_TYPE_ADBLOB_CACHE)
{
    SHASH_FUNCTABLE FunctionTable;
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DFSSTATUS Status = ERROR_SUCCESS;
    
    *pStatus = ERROR_SUCCESS;

    do {
        m_pBlob = NULL;
        m_pRootBlob = NULL;
        m_pTable = NULL;

        m_pAdHandle = NULL;
        m_AdReferenceCount = 0;
        m_RefreshCount = 0;
        m_ErrorOccured = DFS_DS_NOERROR;

        m_pRootFolder = pRootFolder;

        RtlInitUnicodeString(&m_LogicalShare, NULL);
        RtlInitUnicodeString(&m_ObjectDN, NULL);

        ZeroMemory(&FunctionTable, sizeof(FunctionTable));
        
        FunctionTable.AllocFunc = AllocateShashData;
        FunctionTable.FreeFunc = DeallocateShashData;

        ZeroMemory(&m_BlobAttributePktGuid, sizeof(GUID));
        
        m_fCritInit = InitializeCriticalSectionAndSpinCount( &m_Lock, DFS_CRIT_SPIN_COUNT);
        if(!m_fCritInit)
        {
            Status = GetLastError();
            break;
        }
        
        Status = DfsCreateUnicodeString(&m_LogicalShare, pShareName);

        if (Status != ERROR_SUCCESS)
        {
            break;
        }   

        Status = SetupObjectDN();

        if(Status != ERROR_SUCCESS)
        {
            if(DfsServerGlobalData.bDfsAdAlive)
            {
                DfsServerGlobalData.bDfsAdAlive = FALSE;
                DfsLogDfsEvent(DFS_ERROR_ACTIVEDIRECTORY_OFFLINE, 0, NULL, 0); 
            }
            break;
        }
        
        
        if(DfsServerGlobalData.bDfsAdAlive == FALSE)
        {
            DfsServerGlobalData.bDfsAdAlive = TRUE;
            DfsLogDfsEvent(DFS_INFO_ACTIVEDIRECTORY_ONLINE, 0, NULL, 0); 
        }

        NtStatus = ShashInitHashTable(&m_pTable, &FunctionTable);
        if (NtStatus != STATUS_SUCCESS)
        {
            Status = RtlNtStatusToDosError(NtStatus);
            break;
        }
        
    } while (FALSE);

    *pStatus = Status;
    
    return;
}


DfsADBlobCache::~DfsADBlobCache() 
{

    if(m_pBlob)
    {
        DeallocateShashData(m_pBlob);
        m_pBlob = NULL;
    }
    if(m_pRootBlob)
    {
        DeallocateShashData(m_pRootBlob);
        m_pRootBlob = NULL;
    }

    if (m_pTable != NULL)
    {
        InvalidateCache();
        ShashTerminateHashTable(m_pTable);
        m_pTable = NULL;
    }

    if (m_LogicalShare.Buffer != NULL)
    {
        delete [] m_LogicalShare.Buffer;
        m_LogicalShare.Buffer = NULL;
    }
    if (m_ObjectDN.Buffer != NULL)
    {
        delete [] m_ObjectDN.Buffer;
        m_ObjectDN.Buffer = NULL;
    }

    if(m_fCritInit)
    {
        DeleteCriticalSection(&m_Lock);
        m_fCritInit = FALSE;
    }

}    





#ifndef DFS_USE_LDAP


DFSSTATUS
DfsADBlobCache::UpdateCacheWithDSBlob(
    PVOID pHandle )
{
    HRESULT hr = S_OK;
    DFSSTATUS Status = ERROR_SUCCESS;
    BYTE *pBuffer = NULL;
    ULONG Length = 0;
    VARIANT BinaryBlob;

    IADs *pADs  = (IADs *)pHandle;

    DFS_TRACE_LOW( ADBLOB, "Cache %p: updating cache with blob \n", this);
    VariantInit(&BinaryBlob);

    hr = pADs->Get(ADBlobAttribute, &BinaryBlob);
    if ( SUCCEEDED(hr) )
    {
        Status = GetBinaryFromVariant( &BinaryBlob, &pBuffer, &Length );
        if (Status == ERROR_SUCCESS)
        {
            Status = UnpackBlob( pBuffer, &Length, NULL );

            DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Unpack blob done with status %x\n", Status);
            
            delete [] pBuffer;
        }
    }
    else
    {
        Status = DfsGetErrorFromHr(hr);
    }
    VariantClear(&BinaryBlob);

    DFS_TRACE_ERROR_LOW( Status, ADBLOB, "cache %p: Updated cache (length %x) status %x\n", 
                         this, Length, Status);

    return Status;
}

DFSSTATUS
DfsADBlobCache::GetObjectPktGuid( 
    PVOID pHandle,
    GUID *pGuid )
{
    HRESULT hr = S_OK;
    DFSSTATUS Status = ERROR_SUCCESS;
    BYTE *pBuffer = NULL;
    ULONG Length = 0;
    VARIANT BinaryBlob;

    IADs *pADs = (IADs *)pHandle;

    DFS_TRACE_LOW( ADBLOB, "Cache %p: getting pkt guid\n", this);

    VariantInit(&BinaryBlob);

    hr = pADs->Get(ADBlobPktGuidAttribute, &BinaryBlob);
    if ( SUCCEEDED(hr) )
    {
        Status = GetBinaryFromVariant( &BinaryBlob, &pBuffer, &Length );
        if (Status == ERROR_SUCCESS)
        {
            if (Length > sizeof(GUID)) Length = sizeof(GUID);

            RtlCopyMemory( pGuid, pBuffer, Length);
            
            delete [] pBuffer;
        }
    }
    VariantClear(&BinaryBlob);

    Status = DfsGetErrorFromHr(hr);

    DFS_TRACE_ERROR_LOW( Status, ADBLOB, "cache %p: got pkt guid, Status %x\n", 
                         this, Status );


    return Status;
}


DFSSTATUS 
DfsADBlobCache::UpdateDSBlobFromCache(
    PVOID pHandle,
    GUID *pGuid )
{
    HRESULT HResult = S_OK;
    DFSSTATUS Status = ERROR_SUCCESS;
    BYTE *pBuffer = NULL;
    ULONG Length;
    ULONG UseLength;
    ULONG TotalBlobBytes = 0;
    VARIANT BinaryBlob;
    IADs *pObject = (IADs *)pHandle;

    VariantInit(&BinaryBlob);

    DFS_TRACE_LOW( ADBLOB, "Cache %p: updating ds with cache \n", this);

    UseLength = ADBlobDefaultBlobPackSize;
retry:
    Length = UseLength;
    pBuffer =  (BYTE *) HeapAlloc(GetProcessHeap(), 0, 
                                  Length );
    if(pBuffer != NULL)
    {
        Status = PackBlob(pBuffer, &Length, &TotalBlobBytes); 
        if(Status == STATUS_SUCCESS)
        {
            Status = PutBinaryIntoVariant(&BinaryBlob, pBuffer, TotalBlobBytes);
            if(Status == STATUS_SUCCESS)
            {
                HResult = pObject->Put(ADBlobAttribute, BinaryBlob);
                if (SUCCEEDED(HResult) )
                {
                    HResult = pObject->SetInfo();
                }

                Status = DfsGetErrorFromHr(HResult);

                if (Status == ERROR_SUCCESS)
                {
                    Status = SetObjectPktGuid( pObject, pGuid );
                }
            }
        }
        DFS_TRACE_ERROR_LOW(Status, ADBLOB, "Cache %p: update ds (Buffer Len %x, Length %x) Status %x\n",
                            this, UseLength, Length, Status);

        HeapFree(GetProcessHeap(), 0, pBuffer);

        if (Status == ERROR_BUFFER_OVERFLOW)
        {
            if (UseLength < ADBlobMaximumBlobPackSize)
            {
                UseLength *= 2;
            }
            //
            // If we are still within the maximum bounds, retry.
            //
            if (UseLength <= ADBlobMaximumBlobPackSize)
            {
                goto retry;
            }
        }
    }
    else
    {
        Status = ERROR_NOT_ENOUGH_MEMORY;
    }

    VariantClear(&BinaryBlob);
    DFS_TRACE_ERROR_LOW(Status, ADBLOB, "Cache %p: update ds done (Buffer Length %x, Length %x) Status %x\n",
                        this, UseLength, Length, Status);

    return Status;
}


DFSSTATUS
DfsADBlobCache::SetObjectPktGuid( 
    IADs *pObject,
    GUID *pGuid )
{
    HRESULT HResult = S_OK;
    DFSSTATUS Status = ERROR_SUCCESS;
    VARIANT BinaryBlob;

    DFS_TRACE_LOW( ADBLOB, "Cache %p: setting pkt guid\n", this);
    VariantInit(&BinaryBlob);

    Status = PutBinaryIntoVariant( &BinaryBlob, (PBYTE)pGuid, sizeof(GUID));
    if (Status == ERROR_SUCCESS)
    {
        HResult = pObject->Put(ADBlobPktGuidAttribute, BinaryBlob);
        if (SUCCEEDED(HResult) )
        {
            HResult = pObject->SetInfo();
        }

        Status = DfsGetErrorFromHr(HResult);
    }

    VariantClear(&BinaryBlob);

    DFS_TRACE_ERROR_LOW( Status, ADBLOB, "cache %p: set pkt guid, Status %x\n", 
                         this, Status );


    return Status;
}

#else


DFSSTATUS
DfsADBlobCache::DfsLdapConnect(
    LPWSTR DCName,
    LDAP **ppLdap )
{
    LDAP *pLdap = NULL;
    LPWSTR ActualDC = NULL;
    DFSSTATUS Status = ERROR_SUCCESS;
    DFSSTATUS LocalStatus = ERROR_SUCCESS;
    LONG PreviousState = DFS_DS_ACTIVE;
    const TCHAR * apszSubStrings[4];

    apszSubStrings[0] = DCName;
    ActualDC = DCName;

    pLdap = ldap_initW(DCName, LDAP_PORT);
    if (pLdap != NULL)
    {
        Status = ldap_set_option(pLdap, LDAP_OPT_AREC_EXCLUSIVE, LDAP_OPT_ON);

        if (Status == LDAP_SUCCESS)
        {
            UNICODE_STRING DnsDomain;
            if (DfsGetDnsDomainName( &DnsDomain) == ERROR_SUCCESS)
            {
                Status = ldap_set_option(pLdap, LDAP_OPT_DNSDOMAIN_NAME, &DnsDomain.Buffer);

                DfsReleaseDomainName(&DnsDomain);
            }
        }
        if (Status == LDAP_SUCCESS)
        {

            DFS_TRACE_LOW(ADBLOB, 
                          "Ldap Connect, calling LDAP Bind DC: %ws, init ldap status %x\n",
                           DCName, Status);

            Status = ldap_bind_s(pLdap, NULL, NULL, LDAP_AUTH_NEGOTIATE);


            DFS_TRACE_LOW(ADBLOB, 
                          "Ldap Connect, returning from LDAP Bind DC: %ws, init ldap status %x\n",
                          DCName, Status);
        }
    }
    else
    {
        Status = LdapGetLastError();
        DFS_TRACE_ERROR_HIGH(Status, ADBLOB, 
                             "Ldap Connect, DC: %ws, init ldap status %x\n",
                             DCName, Status);
    }

    if (Status == LDAP_SUCCESS)
    {
        *ppLdap = pLdap;

        if(DCName == NULL)
        {

            //Get the actual host name that we connected to. We don't have to free
            //this name since it will get freed when ldap_unbind is called.
            LocalStatus = ldap_get_optionW(pLdap, LDAP_OPT_HOST_NAME , (void *) &ActualDC);
            apszSubStrings[0] = ActualDC;
        }

        DFS_TRACE_HIGH(ADBLOB, "ADBLOBConnected to actual DC: %ws, ldap status %x\n",
                       ActualDC, Status);

        PreviousState = InterlockedCompareExchange(&DfsServerGlobalData.FirstContact, DFS_DS_ACTIVE, DFS_DS_NOTACTIVE); 
        if(PreviousState == DFS_DS_NOTACTIVE)
        {
            DfsLogDfsEvent(DFS_INFO_DS_RECONNECTED, 1, apszSubStrings, Status);
        }
    }
    else
    {
        PreviousState = InterlockedCompareExchange(&DfsServerGlobalData.FirstContact, DFS_DS_NOTACTIVE, DFS_DS_ACTIVE); 
        if(PreviousState == DFS_DS_ACTIVE)
        {
            DfsLogDfsEvent(DFS_ERROR_DSCONNECT_FAILED, 1, apszSubStrings, Status); 
        }

        DFS_TRACE_ERROR_HIGH(Status, ADBLOB, 
                             "Ldap Connect, DC: %ws, ldap status %x\n",
                             DCName, Status);

        Status = LdapMapErrorToWin32(Status);
    }


    if (Status != ERROR_SUCCESS) 
    {
        if (pLdap != NULL)
        {
            //
            // 565302
            // we need to call ldap_unbind if we have a valid connection!
            // Note that this is true even if ldap_bind failed or we never
            // even called ldap_bind.
            //
            ldap_unbind(pLdap);
        }
    }

    return Status;

}



VOID
DfsADBlobCache::DfsLdapDisconnect(
    LDAP *pLdap )
{
    ldap_unbind(pLdap);
}


DFSSTATUS
DfsADBlobCache::DfsGetPktBlob(
    LDAP *pLdap,
    LPWSTR ObjectDN,
    PVOID *ppBlob,
    PULONG pBlobSize,
    PVOID *ppHandle,
    PVOID *ppHandle1 )
{

    DFSSTATUS Status = ERROR_SUCCESS;
    DFSSTATUS LdapStatus = ERROR_SUCCESS;
    PLDAPMessage pLdapSearchedObject = NULL;
    PLDAPMessage pLdapObject = NULL;
    PLDAP_BERVAL *pLdapPktAttr = NULL;
    LPWSTR Attributes[2];
    struct l_timeval Timeout;



    Status = ERROR_ACCESS_DENIED;     // fix this after we understand
                                      // ldap error correctly. When
                                      // ldap_get_values_len returns NULL
                                      // the old code return no more mem.

    Attributes[0] = ADBlobAttribute;
    Attributes[1] = NULL;

    Timeout.tv_sec = DfsServerGlobalData.LdapTimeOut;


    DFS_TRACE_LOW(ADBLOB, 
                 "DfsGetPktBlob, calling LDAP Search ObjectDN: %ws, init ldap status %x\n",
                  ObjectDN, Status);
    LdapStatus = ldap_search_ext_sW( pLdap,
                                     ObjectDN,
                                     LDAP_SCOPE_BASE,
                                     L"(objectClass=*)",
                                     Attributes,
                                     0,            // attributes only
                                     NULL,         // server controls
                                     NULL,         // client controls
                                     &Timeout,
                                     0,            // size limit
                                     &pLdapSearchedObject);

    DFS_TRACE_LOW(ADBLOB, 
                 "DfsGetPktBlob, returning from LDAP Search ObjectDN: %ws, init ldap status %x\n",
                  ObjectDN, Status);
    if (LdapStatus == LDAP_SUCCESS)
    {
        pLdapObject = ldap_first_entry( pLdap,
                                        pLdapSearchedObject );

        if (pLdapObject != NULL)
        {
            pLdapPktAttr = ldap_get_values_len( pLdap,
                                                pLdapObject,
                                                Attributes[0] );
            if (pLdapPktAttr != NULL)
            {
                *ppBlob = pLdapPktAttr[0]->bv_val;
                *pBlobSize = pLdapPktAttr[0]->bv_len;

                *ppHandle = (PVOID)pLdapPktAttr;
                *ppHandle1 = (PVOID)pLdapSearchedObject;
                pLdapSearchedObject = NULL;

                Status = ERROR_SUCCESS;
            }
            else
            {
                if(pLdap->ld_errno == LDAP_NO_SUCH_ATTRIBUTE)
                {
                    Status = ERROR_ACCESS_DENIED;
                }
                else
                {
                    Status = LdapMapErrorToWin32( pLdap->ld_errno );
                }


                DFS_TRACE_ERROR_HIGH( Status, ADBLOB, "DfsADBlobCache::DfsGetPktBlob1 (ldap error %x) status %x\n", 
                                      pLdap->ld_errno, Status);
            }
        }
    }
    else
    {
        Status = LdapMapErrorToWin32(LdapStatus);

        DFS_TRACE_ERROR_HIGH( Status, ADBLOB, "DfsADBlobCache::DfsGetPktBlob2 (ldap error %x) status %x\n", 
                              LdapStatus, Status);
    }

    if (pLdapSearchedObject != NULL)
    {
        ldap_msgfree( pLdapSearchedObject );
    }

    return Status;
}

VOID
DfsADBlobCache::DfsReleasePktBlob(
    PVOID pHandle,
    PVOID pHandle1 )
{
    PLDAP_BERVAL *pLdapPktAttr = (PLDAP_BERVAL *)pHandle;
    PLDAPMessage pLdapSearchedObject = (PLDAPMessage)pHandle1;

    ldap_value_free_len( pLdapPktAttr );
    ldap_msgfree( pLdapSearchedObject );
}


DFSSTATUS
DfsADBlobCache::UpdateCacheWithDSBlob(
    PVOID pHandle )

{
    DFSSTATUS Status = ERROR_SUCCESS;
    BYTE *pBuffer = NULL;
    ULONG Length = 0;
    PVOID pHandle1, pHandle2;

    LDAP *pLdap = (LDAP *)pHandle;
    UNICODE_STRING ObjectDN;

    
    DFS_TRACE_LOW( ADBLOB, "Cache %p: updating cache with blob \n", this);

    Status = GetObjectDN(&ObjectDN);

    if (Status == ERROR_SUCCESS)
    {
        Status = DfsGetPktBlob( pLdap,
                                ObjectDN.Buffer,
                                (PVOID *)&pBuffer,
                                &Length,
                                &pHandle1,
                                &pHandle2);
    }

    if ( Status == ERROR_SUCCESS)
    {
        Status = UnpackBlob( pBuffer, &Length, NULL );

        DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Unpack blob done with status %x\n", Status);

        DfsReleasePktBlob( pHandle1, pHandle2);
    }

    DFS_TRACE_ERROR_LOW( Status, ADBLOB, "cache %p: Updated cache (length %x) status %x\n", 
                         this, Length, Status);

    return Status;
}




DFSSTATUS
DfsADBlobCache::GetObjectPktGuid(
    PVOID pHandle,
    GUID *pGuid )
{

    DFSSTATUS Status = ERROR_SUCCESS;
    DFSSTATUS LdapStatus = ERROR_SUCCESS;
    PLDAPMessage pLdapSearchedObject = NULL;
    PLDAPMessage pLdapObject = NULL;
    PLDAP_BERVAL *pLdapGuidAttr = NULL;
    ULONG CopySize = 0;    
    LDAP *pLdap = (LDAP *)pHandle;
    UNICODE_STRING ObjectDN;
    struct l_timeval Timeout;
    LPWSTR Attributes[2];

    Status = GetObjectDN(&ObjectDN);
    if (Status != ERROR_SUCCESS)
    {
        return Status;
    }

    Status = ERROR_ACCESS_DENIED;     // fix this after we understand
                                      // ldap error correctly. When
                                      // ldap_get_values_len returns NULL
                                      // the old code return no more mem.


    Attributes[0] = ADBlobPktGuidAttribute;
    Attributes[1] = NULL;

    Timeout.tv_sec = DfsServerGlobalData.LdapTimeOut;



    DFS_TRACE_LOW(ADBLOB, 
                 "DfsGetPktGuid, calling LDAP Search - ldap status %x\n",
                  Status);
    LdapStatus = ldap_search_ext_sW( pLdap,
                                     ObjectDN.Buffer,
                                     LDAP_SCOPE_BASE,
                                     L"(objectClass=*)",
                                     Attributes,
                                     0,            // attributes only
                                     NULL,         // server controls
                                     NULL,         // client controls
                                     &Timeout,
                                     0,            // size limit
                                     &pLdapSearchedObject);

    DFS_TRACE_LOW(ADBLOB, 
                 "DfsGetPktGuid, returning from LDAP Search - ldap status %x\n",
                  Status);

    if (LdapStatus == LDAP_SUCCESS)
    {
        pLdapObject = ldap_first_entry( pLdap,
                                        pLdapSearchedObject );

        if (pLdapObject != NULL)
        {
            pLdapGuidAttr = ldap_get_values_len( pLdap,
                                                 pLdapObject,
                                                 Attributes[0] );
            if (pLdapGuidAttr != NULL)
            {
                CopySize = min( pLdapGuidAttr[0]->bv_len, sizeof(GUID));
                RtlCopyMemory( pGuid, pLdapGuidAttr[0]->bv_val, CopySize );

                ldap_value_free_len( pLdapGuidAttr );
                Status = ERROR_SUCCESS;
            }
            else
            {
                if(pLdap->ld_errno == LDAP_NO_SUCH_ATTRIBUTE)
                {
                    Status = ERROR_ACCESS_DENIED;
                }
                else
                {
                    Status = LdapMapErrorToWin32( pLdap->ld_errno );
                }


                DFS_TRACE_ERROR_HIGH( Status, ADBLOB, "DfsADBlobCache::GetObjectPktGuid1 (ldap error %x) status %x\n", 
                                      LdapStatus, Status);
            }
        }
    }
    else
    {
        Status = LdapMapErrorToWin32(LdapStatus);

        DFS_TRACE_ERROR_HIGH( Status, ADBLOB, "DfsADBlobCache::GetObjectPktGuid2 (ldap error %x) status %x\n", 
                              pLdap->ld_errno, Status);
    }

    if (pLdapSearchedObject != NULL)
    {
        ldap_msgfree( pLdapSearchedObject );
    }

    return Status;
}

DFSSTATUS
DfsADBlobCache::DfsSetPktBlobAndPktGuid ( 
    LDAP *pLdap,
    LPWSTR ObjectDN,
    PVOID pBlob,
    ULONG BlobSize,
    GUID *pGuid )
{
    LDAP_BERVAL  LdapPkt, LdapPktGuid;
    PLDAP_BERVAL  pLdapPktValues[2], pLdapPktGuidValues[2];
    LDAPModW LdapPktMod, LdapPktGuidMod;
    PLDAPModW pLdapDfsMod[3];
    DFSSTATUS Status = ERROR_SUCCESS;
    DFSSTATUS LdapStatus;

    LDAPControlW    LazyCommitControl =
                    {
                        LDAP_SERVER_LAZY_COMMIT_OID_W,  // the control
                        { 0, NULL},                     // no associated data
                        FALSE                           // control isn't mandatory
                    };

    PLDAPControlW   ServerControls[2] =
                    {
                        &LazyCommitControl,
                        NULL
                    };


    LdapPkt.bv_len = BlobSize;
    LdapPkt.bv_val = (PCHAR)pBlob;
    pLdapPktValues[0] = &LdapPkt;
    pLdapPktValues[1] = NULL;
    LdapPktMod.mod_op = LDAP_MOD_REPLACE | LDAP_MOD_BVALUES;
    LdapPktMod.mod_type = ADBlobAttribute;
    LdapPktMod.mod_vals.modv_bvals = pLdapPktValues;

    LdapPktGuid.bv_len = sizeof(GUID);
    LdapPktGuid.bv_val = (PCHAR)pGuid;
    pLdapPktGuidValues[0] = &LdapPktGuid;
    pLdapPktGuidValues[1] = NULL;
    LdapPktGuidMod.mod_op = LDAP_MOD_REPLACE | LDAP_MOD_BVALUES;
    LdapPktGuidMod.mod_type = ADBlobPktGuidAttribute;
    LdapPktGuidMod.mod_vals.modv_bvals = pLdapPktGuidValues;

    pLdapDfsMod[0] = &LdapPktMod;
    pLdapDfsMod[1] = &LdapPktGuidMod;
    pLdapDfsMod[2] = NULL;


    DFS_TRACE_LOW(ADBLOB, 
                 "DfsSetPktBlobAndPktGuid, calling LDAP ldap_modify_ext_sW ObjectDN: %ws, init ldap status %x\n",
                  ObjectDN, Status);
    LdapStatus = ldap_modify_ext_sW( pLdap,
                                     ObjectDN,
                                     pLdapDfsMod,
                                     (PLDAPControlW *)ServerControls,
                                     NULL );

    DFS_TRACE_LOW(ADBLOB, 
                 "DfsSetPktBlobAndPktGuid, returning from LDAP ldap_modify_ext_sW ObjectDN: %ws, init ldap status %x\n",
                  ObjectDN, Status);

    if (LdapStatus != LDAP_SUCCESS)
    {
        Status = LdapMapErrorToWin32(LdapStatus);
    }



    DFS_TRACE_ERROR_LOW( Status, ADBLOB, "DfsADBlobCache::DfsSetPktBlobAndPktGuid cache %p: LDAP Status %x, Win32 status %x\n", 
                         this, LdapStatus, Status);
    return Status;

}

DFSSTATUS 
DfsADBlobCache::UpdateDSBlobFromCache(
    PVOID pHandle,
    GUID *pGuid )
{
    LDAP *pLdap = (LDAP *)pHandle;
    UNICODE_STRING ObjectDN;
    BYTE *pBuffer = NULL;
    ULONG Length = 0;
    ULONG UseLength = 0;
    ULONG TotalBlobBytes = 0;
    DFSSTATUS Status = ERROR_SUCCESS;

    Status = GetObjectDN(&ObjectDN);
    if (Status != ERROR_SUCCESS)
    {
        DFS_TRACE_ERROR_LOW( Status, ADBLOB, "DfsADBlobCache::UpdateDSBlobFromCache cache %p: GetObjectDN failed status %x\n", 
                             this, Status);
        return Status;
    }

    UseLength = ADBlobDefaultBlobPackSize;
retry:
    Length = UseLength;
    pBuffer =  (BYTE *) HeapAlloc(GetProcessHeap(), 0, Length );
    if(pBuffer != NULL)
    {
        Status = PackBlob(pBuffer, &Length, &TotalBlobBytes); 
        if (Status != ERROR_SUCCESS)
        {
            HeapFree(GetProcessHeap(), 0, pBuffer);

            if (Status == ERROR_BUFFER_OVERFLOW)
            {
                if (UseLength < ADBlobMaximumBlobPackSize)
                {
                    UseLength *= 2;
                }
                goto retry;
            }
        }

        if(Status == STATUS_SUCCESS)
        {

            Status = DfsSetPktBlobAndPktGuid( pLdap,
                                              ObjectDN.Buffer,
                                              pBuffer,
                                              TotalBlobBytes,
                                              pGuid );
            DFS_TRACE_ERROR_LOW(Status, ADBLOB, "Cache %p: DfsADBlobCache::UpdateDSBlobFromCache (Buffer Len %x, Length %x) Status %x\n",
                                this, UseLength, Length, Status);


            HeapFree(GetProcessHeap(), 0, pBuffer);
        }
    }
    else
    {
        Status = ERROR_NOT_ENOUGH_MEMORY;
    }
    return Status;
}
#endif

DFSSTATUS
DfsADBlobCache::CacheRefresh(BOOLEAN fForceSync,
                             BOOLEAN fFromPDC)

{
    PVOID           pHandle = NULL;
    DFSSTATUS       Status = ERROR_SUCCESS;
    LONG            PreviousState = DFS_DS_NOERROR;
    LONG            RefreshCount = 0;
    PUNICODE_STRING pUseShare = NULL;
    GUID            CurrentGuid;
    const TCHAR * apszSubStrings[4];

    LPWSTR UseDC = NULL;
    DfsString *pPDC = NULL;
    DFSSTATUS PDCStatus = ERROR_SUCCESS;



    DFS_TRACE_LOW( ADBLOB, "Cache %p: from pdc? %d cache refresh\n", this, fFromPDC);

    if (fFromPDC == TRUE) 
    {
        PDCStatus = DfsGetBlobPDCName( &pPDC, 0 );
        //
        // Ignore the status here. If this call fails, we dont care
        // since we will just use a non-pdc dc. All callers who 
        // *really* care have already got the object with the right dc.
        // see apiprologue for more details.
        //
        if (PDCStatus == ERROR_SUCCESS) 
        {
            UseDC = pPDC->GetString();
        }
    }

    DFS_TRACE_LOW(ADBLOB, "Cache refresh using dc %ws\n", UseDC);

    Status = GetADObject( &pHandle, UseDC);
    
    if ((Status != ERROR_SUCCESS) &&
        (UseDC != NULL))
    {
        //
        // hmmm. failed here going to pdc. Just get the object without bothering
        // about the PDC.
        //
        Status = GetADObject(&pHandle, NULL);

    }

    if (Status == ERROR_SUCCESS)
    {
        // fFromPDC == FALSE means root scalability mode..every so often, get a new
        // Blob and guid
        if(fFromPDC == FALSE)
        {
            RefreshCount = InterlockedIncrement(&m_RefreshCount);
            if(RefreshCount >= DFS_ROOTSCALABILTY_FORCED_REFRESH_INTERVAL)
            {
                fForceSync = TRUE;
                InterlockedExchange((LPLONG volatile ) &m_RefreshCount, 0);
            }
        }

        Status = GetObjectPktGuid( pHandle, &CurrentGuid );

        if(Status == ERROR_SUCCESS)
        {
            if(!fForceSync)
            {
                //
                // here we pass the 2 guids by reference...
                //
                if (IsEqualGUID( CurrentGuid, m_BlobAttributePktGuid) == FALSE)
                {
                    Status = UpdateCacheWithDSBlob( pHandle );
                    if (Status == ERROR_SUCCESS)
                    {
                        m_BlobAttributePktGuid = CurrentGuid;
                    }
                }
            }
            else
            {
                Status = UpdateCacheWithDSBlob( pHandle );
                if (Status == ERROR_SUCCESS)
                {
                    m_BlobAttributePktGuid = CurrentGuid;
                }
            }
        }

        ReleaseADObject( pHandle );

    }

    DfsReleaseBlobPDCName( pPDC );

    if(Status != ERROR_SUCCESS)
    {
        PreviousState = InterlockedCompareExchange(&m_ErrorOccured, DFS_DS_ERROR, DFS_DS_NOERROR); 
        if(PreviousState == DFS_DS_NOERROR)
        {
            pUseShare = m_pRootFolder->GetRootPhysicalShareName();
            apszSubStrings[0] = pUseShare->Buffer;
            DfsLogDfsEvent(DFS_ERROR_NO_DFS_DATA, 1, apszSubStrings, Status);
        }
    }
    else
    {
        PreviousState = InterlockedCompareExchange(&m_ErrorOccured, DFS_DS_NOERROR, DFS_DS_ERROR); 
        if(PreviousState == DFS_DS_ERROR)
        {
            pUseShare  = m_pRootFolder->GetRootPhysicalShareName();
            apszSubStrings[0] = pUseShare->Buffer;
            DfsLogDfsEvent(DFS_INFO_RECONNECT_DATA, 1, apszSubStrings, Status);
        }

    }
    
    DFS_TRACE_ERROR_LOW( Status, ADBLOB, "Cache %p: CacheRefresh status 0x%x\n", this, Status);
    return Status;
}



void 
DfsADBlobCache::InvalidateCache()
{
    PDFSBLOB_DATA pBlobData;
    DFSBOB_ITER Iter;
    DFS_TRACE_LOW( ADBLOB, "Cache %p: invalidate cache\n", this);
    pBlobData = FindFirstBlob(&Iter);
    while (pBlobData != NULL)
    {
        DFSSTATUS RemoveStatus;

        RemoveStatus = RemoveNamedBlob(&pBlobData->BlobName);
        DFS_TRACE_ERROR_LOW( RemoveStatus, REFERRAL_SERVER, "BlobCache %p, invalidate cache, remove blob status %x\n",
                             this, RemoveStatus);
        pBlobData = FindNextBlob(&Iter);
    }

    FindCloseBlob(&Iter);
    DFS_TRACE_LOW( ADBLOB, "Cache %p: invalidate cache done\n", this);
}

DFSSTATUS
DfsADBlobCache::PutBinaryIntoVariant(VARIANT * ovData, BYTE * pBuf,
                                     unsigned long cBufLen)
{
     DFSSTATUS Status = ERROR_INVALID_PARAMETER;
     void * pArrayData = NULL;
     VARIANT var;
     SAFEARRAYBOUND  rgsabound[1];

     VariantInit(&var);  //Initialize our variant

     var.vt = VT_ARRAY | VT_UI1;

     rgsabound[0].cElements = cBufLen;
     rgsabound[0].lLbound = 0;

     var.parray = SafeArrayCreate(VT_UI1,1,rgsabound);

     if(var.parray != NULL)
     {
        //Get a safe pointer to the array
        SafeArrayAccessData(var.parray,&pArrayData);

        //Copy bitmap to it
        memcpy(pArrayData, pBuf, cBufLen);

        //Unlock the variant data
        SafeArrayUnaccessData(var.parray);

        *ovData = var;  

        Status = STATUS_SUCCESS;
     }
     else
     {
         Status = ERROR_NOT_ENOUGH_MEMORY;
        DFS_TRACE_HIGH( REFERRAL_SERVER, "PutBinaryIntoVariant failed error %d\n", Status);
     }


     return Status;
}



DFSSTATUS
DfsADBlobCache::GetBinaryFromVariant(VARIANT *ovData, BYTE ** ppBuf,
                                     unsigned long * pcBufLen)
{
     DFSSTATUS Status = ERROR_INVALID_PARAMETER;
     void * pArrayData = NULL;

     //Binary data is stored in the variant as an array of unsigned char
     if(ovData->vt == (VT_ARRAY|VT_UI1))  
     {
        //Retrieve size of array
        *pcBufLen = ovData->parray->rgsabound[0].cElements;

        *ppBuf = new BYTE[*pcBufLen]; //Allocate a buffer to store the data
        if(*ppBuf != NULL)
        {
            //Obtain safe pointer to the array
            SafeArrayAccessData(ovData->parray,&pArrayData);

            //Copy the bitmap into our buffer
            memcpy(*ppBuf, pArrayData, *pcBufLen);

            //Unlock the variant data
            SafeArrayUnaccessData(ovData->parray);

            Status = ERROR_SUCCESS;
        }
        else
        {
            Status = ERROR_NOT_ENOUGH_MEMORY;
        }
     }

     return Status;
}


DFSSTATUS 
DfsADBlobCache::CacheFlush(
    PVOID pHandle )
{
    DFSSTATUS Status = ERROR_SUCCESS;
    GUID NewGuid;

    IADs *pObject  = (IADs *)pHandle;

    DFS_TRACE_LOW( ADBLOB, "Cache %p: cache flush\n", this);
    Status = UuidCreate(&NewGuid);
    if (Status == ERROR_SUCCESS)
    {
        m_BlobAttributePktGuid = NewGuid;

        Status = UpdateDSBlobFromCache( pObject,
                                        &NewGuid );

    }
    DFS_TRACE_ERROR_LOW( Status, ADBLOB, "Cache %p: cache flush, Status %x\n", this, Status);
    return Status;
}


DFSSTATUS
DfsADBlobCache::UnpackBlob(
    BYTE *pBuffer,
    PULONG pLength,
    PDFSBLOB_DATA * pRetBlob )
{
    ULONG Discard = 0;
    DFSSTATUS Status = ERROR_SUCCESS;
    BYTE *pUseBuffer = NULL;
    ULONG BufferSize = 0;
    ULONG ObjNdx = 0;
    ULONG TotalObjects = 0;
    ULONG  BlobSize = 0;
    BYTE *BlobBuffer = NULL;
    PDFSBLOB_DATA pLocalBlob = NULL;
    UNICODE_STRING BlobName;
    UNICODE_STRING SiteRoot;
    UNICODE_STRING BlobRoot;
     
    pUseBuffer = pBuffer;
    BufferSize = *pLength;

    DFS_TRACE_LOW( ADBLOB, "BlobCache %p, UnPackBlob \n", this);
    UNREFERENCED_PARAMETER(pRetBlob);

    Status = DfsRtlInitUnicodeStringEx( &SiteRoot, ADBlobSiteRoot );
    if (Status != ERROR_SUCCESS)
    {
        goto done;
    }

    Status = DfsRtlInitUnicodeStringEx( &BlobRoot, ADBlobMetaDataNamePrefix);
    if (Status != ERROR_SUCCESS)
    {
        goto done;
    }

    //
    // Note the size of the whole blob.
    //
    m_BlobSize = BufferSize;
    
    //
    // dfsdev: we should not need an interlocked here: this code
    // is already mutex'd by the caller.
    //
    InterlockedIncrement( &m_CurrentSequenceNumber );
    
    //
    // dfsdev: investigate what the first ulong is and add comment
    // here as to why we are discarding it.
    //
    Status = PackGetULong( &Discard, (PVOID *) &pUseBuffer, &BufferSize ); 
    if (Status != ERROR_SUCCESS)
    {
        goto done;
    }

    if(BufferSize == 0)
    {
        goto done;
    }

    Status = PackGetULong(&TotalObjects, (PVOID *) &pUseBuffer, &BufferSize);
    if (Status != ERROR_SUCCESS) 
    {
        goto done;
    }


    for (ObjNdx = 0; ObjNdx < TotalObjects; ObjNdx++)
    {
        BOOLEAN FoundSite = FALSE;
        BOOLEAN FoundRoot = FALSE;

        Status = GetSubBlob( &BlobName,
                             &BlobBuffer,
                             &BlobSize,
                             &pUseBuffer,
                             &BufferSize );

        if (Status == ERROR_SUCCESS)
        {
            if (!FoundSite &&
               (RtlCompareUnicodeString( &BlobName, &SiteRoot, TRUE ) == 0))
            {
               FoundSite = TRUE;
               Status = CreateBlob(&BlobName, 
                                   BlobBuffer, 
                                   BlobSize,
                                   &pLocalBlob
                                   );
               if(Status == STATUS_SUCCESS)
               {
                   DeallocateShashData(m_pBlob);
                   m_pBlob = pLocalBlob;
               }

                continue;
            }
            if (!FoundRoot &&
               (RtlCompareUnicodeString( &BlobName, &BlobRoot, TRUE ) == 0))
            {
               FoundRoot = TRUE;
               UNICODE_STRING RootName;
               RtlInitUnicodeString(&RootName, NULL);
               Status = CreateBlob(&RootName,
                                   BlobBuffer, 
                                   BlobSize,
                                   &pLocalBlob
                                   );
               if(Status == STATUS_SUCCESS)
               {
                   DeallocateShashData(m_pRootBlob);
                   m_pRootBlob = pLocalBlob;
               }

                continue;
            }

            Status = StoreBlobInCache( &BlobName, BlobBuffer, BlobSize);
            if (Status != ERROR_SUCCESS)
            {
                break;
            }
        }
    }


done:

    DFS_TRACE_ERROR_LOW( Status, ADBLOB, "BlobCache %p: UnPackBlob status %x\n", this, Status);
    return Status;
}


DFSSTATUS
DfsADBlobCache::CreateBlob(PUNICODE_STRING BlobName, 
                           PBYTE pBlobBuffer, 
                           ULONG BlobSize,
                           PDFSBLOB_DATA *pNewBlob )
{
    PDFSBLOB_DATA BlobStructure = NULL;
    DFSSTATUS Status = ERROR_SUCCESS;
    PBYTE NextBufOffset;

    ULONG TotalSize = sizeof(DFSBLOB_DATA) + 
                      BlobName->Length + sizeof(WCHAR) +
                      BlobSize;

    BlobStructure = (PDFSBLOB_DATA) AllocateShashData( TotalSize );

    if (BlobStructure != NULL)
    {
        RtlZeroMemory(BlobStructure, sizeof(DFSBLOB_DATA));
        NextBufOffset = (PBYTE)(BlobStructure + 1);

        BlobStructure->Header.RefCount = 1;
        BlobStructure->Header.pvKey = &BlobStructure->BlobName;
        BlobStructure->Header.pData = (PVOID)BlobStructure;

        BlobStructure->SequenceNumber = m_CurrentSequenceNumber;        
        BlobStructure->BlobName.Length = BlobName->Length;
        BlobStructure->BlobName.MaximumLength = BlobName->Length + sizeof(WCHAR);
        BlobStructure->BlobName.Buffer = (WCHAR *) (NextBufOffset);

        NextBufOffset = (PBYTE)((ULONG_PTR)(NextBufOffset) + 
                                BlobName->Length + 
                                sizeof(WCHAR));

        if (BlobName->Length != 0)
        {
            RtlCopyMemory(BlobStructure->BlobName.Buffer, 
                          BlobName->Buffer, 
                          BlobName->Length);
        }
        BlobStructure->BlobName.Buffer[BlobName->Length/sizeof(WCHAR)] = UNICODE_NULL;


        BlobStructure->Size = BlobSize;    
        BlobStructure->pBlob = (PBYTE)(NextBufOffset);

        if(pBlobBuffer && BlobSize)
        {
            RtlCopyMemory(BlobStructure->pBlob, pBlobBuffer, BlobSize);
        }
    }
    else
    {
        Status = ERROR_NOT_ENOUGH_MEMORY;
    }
    *pNewBlob = BlobStructure;

    return Status;
}

DFSSTATUS
DfsADBlobCache::CreateSiteBlobIfNecessary(void)
{
    DFSSTATUS Status = ERROR_SUCCESS;
    PDFSBLOB_DATA pSiteBlob = NULL;
    PBYTE pBuffer = NULL;
    PVOID pUseBuffer = NULL;
    ULONG SiteBlobSize = 0;
    ULONG SizeRemaining = 0;
    GUID NewGuid;
    UNICODE_STRING SiteMetadataName;

    if(m_pBlob == NULL)
    {
        do
        {
            Status = UuidCreate(&NewGuid);
            if (Status != ERROR_SUCCESS)
            {
              break;
            }

            Status = DfsRtlInitUnicodeStringEx(&SiteMetadataName, ADBlobSiteRoot);
            if(Status != ERROR_SUCCESS)
            {
                break;
            }

            SiteBlobSize = sizeof(ULONG) + sizeof(GUID);

            pBuffer = (PBYTE) AllocateShashData (SiteBlobSize);
            if (pBuffer == NULL)
            {
                Status = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }

            pUseBuffer = pBuffer;
            SizeRemaining = SiteBlobSize;

            Status = PackSetGuid( &NewGuid, &pUseBuffer, &SizeRemaining);
            if (Status != ERROR_SUCCESS)
            {
                break;
            }

            Status = PackSetULong( 0, &pUseBuffer, &SizeRemaining );
            if (Status != ERROR_SUCCESS)
            {
                break;
            }

            Status = CreateBlob(&SiteMetadataName, 
                                pBuffer, 
                                SiteBlobSize,
                                &pSiteBlob);
            if(Status != ERROR_SUCCESS)
             {
                break;
             }

            m_pBlob = pSiteBlob;

        }while(0);
    }

    if (pBuffer) 
    {
       DeallocateShashData(pBuffer);
    }

    return Status;

}

//
// UpdateSiteBlob: This routine takes a binary stream and stuffs that
// as the site information. It gets rid of the old site information.
// No update is done here, the caller has to call us back to say
// that data needs to be written out.
//
//
DFSSTATUS
DfsADBlobCache::UpdateSiteBlob(PVOID pBuffer, ULONG Size)
{
    DFSSTATUS Status = ERROR_SUCCESS;
    PDFSBLOB_DATA pSiteBlob = NULL;
    UNICODE_STRING SiteMetadataName;

    Status = DfsRtlInitUnicodeStringEx(&SiteMetadataName, ADBlobSiteRoot);
    if(Status == ERROR_SUCCESS)
    {
        Status = CreateBlob(&SiteMetadataName, 
                            (PBYTE)pBuffer,
                            Size,
                            &pSiteBlob);
        if(Status == ERROR_SUCCESS)
        {
            if (m_pBlob != NULL)
            {
                DeallocateShashData(m_pBlob);
            }
            m_pBlob = pSiteBlob;
        }
    }

    return Status;

}


DFSSTATUS
DfsADBlobCache::StoreBlobInCache(PUNICODE_STRING BlobName, 
                                 PBYTE pBlobBuffer, 
                                 ULONG BlobSize)
{
    PDFSBLOB_DATA BlobStructure = NULL;
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DFSSTATUS Status = ERROR_SUCCESS;

    DFS_TRACE_LOW( ADBLOB, "cache %p: Storing Blob %wZ in cache, size %x\n",
                   this, BlobName, BlobSize );

    Status = CreateBlob( BlobName,
                         pBlobBuffer,
                         BlobSize,
                         &BlobStructure );

    if (Status == ERROR_SUCCESS)
    {
        if (IsEmptyString(BlobStructure->BlobName.Buffer))
        {
            ReleaseRootBlob();
            m_pRootBlob = BlobStructure;
        }
        else
        {
            NtStatus = SHashInsertKey(m_pTable, 
                                      BlobStructure, 
                                      &BlobStructure->BlobName, 
                                      SHASH_REPLACE_IFFOUND);
            if(NtStatus == STATUS_SUCCESS)
            {
                InterlockedDecrement(&BlobStructure->Header.RefCount);
            }
            else
            {
                DeallocateShashData( BlobStructure );
                Status = RtlNtStatusToDosError(NtStatus);
            }
        }
    }
    DFS_TRACE_LOW( ADBLOB, "cache %p: storing Blob %wZ done, status %x\n",
                   this, BlobName, Status);

    return Status;
}




DFSSTATUS
DfsADBlobCache::WriteBlobToAd(
    BOOLEAN ForceFlush)
{
    DFSSTATUS Status = STATUS_SUCCESS;
    PVOID pHandle = NULL;

    DFS_TRACE_LOW(ADBLOB, "cache %p: writing blob to ad\n", this);

    //
    //  ForceFlush flag is currently implemented as a DirectMode
    //  specific functionality. Essentially all normal flushes that happen
    //  during direct-mode operations are no-ops unless the ForceFlush
    //  flag is specified. All regular mode operations are left unaffected.
    //
    if (DfsCheckDirectMode() && !ForceFlush) 
    {
        DFS_TRACE_LOW(ADBLOB, "cache %p: WriteBlobToAd is a NOOP\n", this);
        return Status;
    }

    Status = GetCachedADObject ( &pHandle );

    if(Status == ERROR_SUCCESS)
    {
        Status = CacheFlush(pHandle);

        ReleaseADObject( pHandle );
    }
    DFS_TRACE_ERROR_LOW(Status, ADBLOB, "cache %p: writing blob to ad, status %x\n",
                        this, Status);

    return Status;

}



//+-------------------------------------------------------------------------
//
//  Function:   GetSubBlob
//
//  Arguments:    
//
//   PUNICODE_STRING pBlobName (name of the sub blob)
//   BYTE **ppBlobBuffer - holds pointer to sub blob buffer
//   PULONG  pBlobSize -  holds the blob size
//   BYTE **ppBuffer -  holds the pointer to the main blob buffer 
//   PULONG pSize  - holds size of the main blob stream.
//
//  Returns:    Status: Success or Error status code
//
//  Description: This routine reads the next stream in the main blob, and
//               returns all the information necessary to unravel the
//               sub blob held within the main blob,
//               It adjusts the main blob buffer and size appropriately
//               to point to the next stream or sub-blob within the main
//               blob.
//
//--------------------------------------------------------------------------

DFSSTATUS
DfsADBlobCache::GetSubBlob(
    PUNICODE_STRING pName,
    BYTE **ppBlobBuffer,
    PULONG  pBlobSize,
    BYTE **ppBuffer,
    PULONG pSize )
{
    DFSSTATUS Status = ERROR_SUCCESS;

    //
    // ppbuffer is the main blob, and it is point to a stream at this
    // point
    // the first part is the name of the sub-blob.
    //
    Status = PackGetString( pName, (PVOID *) ppBuffer, pSize );
    if (Status == ERROR_SUCCESS)
    {
        //
        // now get the size of the sub blob.
        //
        Status = PackGetULong( pBlobSize, (PVOID *) ppBuffer, pSize );
        if (Status == ERROR_SUCCESS)
        {
            if(*pBlobSize > *pSize)
            {
                Status = ERROR_INVALID_DATA ;
            }
            else
            {

                //
                // At this point the main blob is point to the sub-blob itself.
                // So copy the pointer of the main blob so we can return it
                // as the sub blob.
                //
                *ppBlobBuffer = *ppBuffer;

                //
                // update the main blob pointer to point to the next stream
                // in the blob.

                *ppBuffer = (BYTE *)*ppBuffer + *pBlobSize;
                *pSize -= *pBlobSize;
            }
        }
    }

    return Status;
}


DFSSTATUS
DfsADBlobCache::GetNamedBlob(PUNICODE_STRING pBlobName,
                             PDFSBLOB_DATA *pBlobStructure)
{
    DFSSTATUS Status = ERROR_SUCCESS;
    NTSTATUS NtStatus = STATUS_SUCCESS;

    if (IsEmptyString(pBlobName->Buffer))
    {
        *pBlobStructure = AcquireRootBlob();
        if (*pBlobStructure == NULL)
        {
            Status = ERROR_NOT_FOUND;
        }
    }
    else
    {
        NtStatus = SHashGetDataFromTable(m_pTable, 
                                         (void *)pBlobName,
                                         (void **) pBlobStructure);
        Status = RtlNtStatusToDosError(NtStatus);
    }

    return Status;
}


DFSSTATUS
DfsADBlobCache::SetNamedBlob(PDFSBLOB_DATA pBlobStructure)
{
    NTSTATUS NtStatus = STATUS_SUCCESS;
    DFSSTATUS Status = ERROR_SUCCESS;

    if (IsEmptyString(pBlobStructure->BlobName.Buffer))
    {
        ReleaseRootBlob();
        m_pRootBlob = pBlobStructure;
        AcquireRootBlob();
    }
    else
    {
        NtStatus = SHashInsertKey(m_pTable, 
                                  pBlobStructure, 
                                  &pBlobStructure->BlobName, 
                                  SHASH_REPLACE_IFFOUND);

        Status = RtlNtStatusToDosError(NtStatus);
    }
    
    return Status;
}

DFSSTATUS
DfsADBlobCache::RemoveNamedBlob(PUNICODE_STRING pBlobName )
{
    NTSTATUS NtStatus;
    DFSSTATUS Status = ERROR_SUCCESS;

    if (IsEmptyString(pBlobName->Buffer))
    {
        if (m_pRootBlob == NULL)
        {
            Status = ERROR_NOT_FOUND;
        }
        ReleaseRootBlob();
    }
    else
    {
        NtStatus = SHashRemoveKey(m_pTable, 
                                  pBlobName,
                                  NULL );

        Status = RtlNtStatusToDosError(NtStatus);
    }
    
    return Status;

}

DWORD 
PackBlobEnumerator( PSHASH_HEADER   pEntry,
                    void*  pContext ) 
{
    NTSTATUS Status = STATUS_SUCCESS;
    PUNICODE_STRING pBlobName = (PUNICODE_STRING) pEntry->pvKey;
    PDFSBLOB_DATA pBlobStructure = (PDFSBLOB_DATA) pEntry;
    PPACKBLOB_ENUMCTX pEnumCtx = (PPACKBLOB_ENUMCTX) pContext;

    if (pBlobStructure->SequenceNumber == pEnumCtx->SequenceNumber)
    {
        Status = AddStreamToBlob( pBlobName,
                                  pBlobStructure->pBlob,
                                  pBlobStructure->Size,
                                  &pEnumCtx->pBuffer,
                                  &pEnumCtx->Size );

    
        pEnumCtx->NumItems++;
        pEnumCtx->CurrentSize += (pBlobName->Length + 
                                  sizeof(USHORT) +
                                  sizeof(ULONG) +
                                  pBlobStructure->Size);
    }
    return Status;
}

//
// skeleton of pack blob. 
// The buffer is passed in. The length is passed in.
// If the information does not fit the buffer, return required length.
// Required for API implementation.
//
//
DFSSTATUS
DfsADBlobCache::PackBlob(
    BYTE *pBuffer,
    PULONG pLength,
    PULONG TotalBlobBytes )

{
    ULONG Discard = 0;
    DFSSTATUS Status = ERROR_SUCCESS;
    NTSTATUS NtStatus = STATUS_SUCCESS;
    BYTE *pUseBuffer = NULL;
    BYTE *pSavedBuffer = NULL;
    ULONG SavedBufferSize = 0;
    ULONG BufferSize = 0;
    PACKBLOB_ENUMCTX EnumCtx;
     
    pUseBuffer = pBuffer;
    BufferSize = *pLength;

    DFS_TRACE_LOW(ADBLOB, "BlobCache %p: packing blob\n", this);
    //
    // dfsdev: investigate what the first ulong is and add comment
    // here as to why we are setting it to 0.
    //
    Status = PackSetULong( 0, (PVOID *) &pUseBuffer, &BufferSize ); 
    if (Status == ERROR_SUCCESS)
    {

        //save the place where we should write back the number of objects
        pSavedBuffer = pUseBuffer;
        SavedBufferSize = BufferSize;
        //
        // the next argument is the number of objects in the blob.
        // set 0 until we find how many blobs there are
        //
        Status = PackSetULong(0, (PVOID *) &pUseBuffer, &BufferSize);
    }

    if (Status == ERROR_SUCCESS) 
    {

        EnumCtx.pBuffer = pUseBuffer;
        EnumCtx.Size = BufferSize;
        EnumCtx.NumItems = 0;
        EnumCtx.SequenceNumber = m_CurrentSequenceNumber;
        EnumCtx.CurrentSize = sizeof(ULONG);
    }

    if (Status == ERROR_SUCCESS)
    {
        if (m_pRootBlob != NULL)
        {
            PDFSBLOB_DATA pRootBlob;
            UNICODE_STRING RootMetadataName;

            Status = DfsRtlInitUnicodeStringEx(&RootMetadataName, ADBlobMetaDataNamePrefix);
            if(Status == ERROR_SUCCESS)
            {
                Status = CreateBlob( &RootMetadataName,
                                     m_pRootBlob->pBlob,
                                     m_pRootBlob->Size,
                                     &pRootBlob);

                if (Status == ERROR_SUCCESS)
                {
                    Status = PackBlobEnumerator( (SHASH_HEADER *)pRootBlob, (PVOID) &EnumCtx);    

                    DeallocateShashData(pRootBlob);
                }
            }

        }
    }


    
    if (Status == ERROR_SUCCESS)
    {
        NtStatus = ShashEnumerateItems(m_pTable, 
                                       PackBlobEnumerator, 
                                       &EnumCtx);

        //dfsdev: make sure that shash enumerate retuns NTSTATUS.
        // it does not appear to do so... I think it is the packblobenumerator
        // that is returning a non-ntstatus. Till we fix it dont convert err

        //    Status = RtlNtStatusToDosError(NtStatus);
        Status = NtStatus;
    }

    //
    // Now add the site blob as the LAST blob. It appears that old
    // downlevel dfs may rely on this.
    //
    if (Status == ERROR_SUCCESS) 
    {
        CreateSiteBlobIfNecessary();

        if (m_pBlob != NULL)
        {
            Status = PackBlobEnumerator( (SHASH_HEADER *) m_pBlob, (PVOID) &EnumCtx);    
        }
    }

    if (Status == ERROR_SUCCESS)
    {

        if (EnumCtx.NumItems > 0)
        {
            Status = PackSetULong(EnumCtx.NumItems, 
                                  (PVOID *) &pSavedBuffer, 
                                  &SavedBufferSize);

            EnumCtx.CurrentSize += sizeof(ULONG);
        }

        *TotalBlobBytes = EnumCtx.CurrentSize;
    }

    m_BlobSize = *TotalBlobBytes;
    //*TotalBlobBytes =  (ULONG) (EnumCtx.pBuffer -  pBuffer);

    DFS_TRACE_ERROR_LOW( Status, ADBLOB, "BlobCache %p, PackBlob status %x\n",
                         this, Status);
    return Status;
}

ULONG
DfsADBlobCache::GetBlobSize()
{
    return m_BlobSize;
}



PDFSBLOB_DATA
DfsADBlobCache::FindFirstBlob(PDFSBLOB_ITER pIter)
{
    PDFSBLOB_DATA pBlob = NULL;

    pIter->RootReferenced = AcquireRootBlob();
    if (pIter->RootReferenced != NULL) 
    {
        pIter->Started = FALSE;
        pBlob = pIter->RootReferenced;
    }
    else
    {
        pIter->Started = TRUE;
        pBlob = (PDFSBLOB_DATA) SHashStartEnumerate(&pIter->Iter, m_pTable);
    }

    return pBlob;
}


PDFSBLOB_DATA
DfsADBlobCache::FindNextBlob(PDFSBLOB_ITER pIter)
{
    PDFSBLOB_DATA pBlob = NULL;

    if (pIter->Started == FALSE)
    {
        pIter->Started = TRUE;
        pBlob = (PDFSBLOB_DATA) SHashStartEnumerate(&pIter->Iter, m_pTable);
    }
    else
    {
        pBlob = (PDFSBLOB_DATA) SHashNextEnumerate(&pIter->Iter, m_pTable);
    }

    return pBlob;
}



void
DfsADBlobCache::FindCloseBlob(PDFSBLOB_ITER pIter)
{

    if (pIter->RootReferenced)
    {
        ReleaseBlobReference(pIter->RootReferenced);
        pIter->RootReferenced = NULL;
    }
    if (pIter->Started)
    {
        SHashFinishEnumerate(&pIter->Iter, m_pTable);    
        pIter->Started = FALSE;
    }
}


DFSSTATUS
AddStreamToBlob(PUNICODE_STRING BlobName,
                BYTE *pBlobBuffer,
                ULONG  BlobSize,
                BYTE ** pUseBuffer,
                ULONG *BufferSize )
{
    DFSSTATUS Status = ERROR_SUCCESS;

    Status = PackSetString(BlobName, (PVOID *) pUseBuffer, BufferSize);
    if(Status == ERROR_SUCCESS)
    {
         Status = PackSetULong(BlobSize, (PVOID *) pUseBuffer, BufferSize);
         if(Status == ERROR_SUCCESS)
         {
             if ( *BufferSize >= BlobSize )
             {
                 RtlCopyMemory((*pUseBuffer), pBlobBuffer, BlobSize);

                 *pUseBuffer = (BYTE *)((ULONG_PTR)*pUseBuffer + BlobSize);
                 *BufferSize -= BlobSize;
             }
             else
             {
                 Status = ERROR_BUFFER_OVERFLOW;
             }
         }

    }
    if (Status == ERROR_INVALID_DATA)
    {
        Status = ERROR_BUFFER_OVERFLOW;
    }

    return Status;
}

PVOID
AllocateShashData(ULONG Size )
{
    PVOID RetValue = NULL;

    if (Size)
    {
        RetValue = (PVOID) new BYTE[Size];
    }
    return RetValue;
}

VOID
DeallocateShashData(PVOID pPointer )
{
    if(pPointer)
    {
        delete [] (PBYTE)pPointer;
    }
}

DFSSTATUS 
DfsADBlobCache::DfsDoesUserHaveAccess(DWORD DesiredAccess)
{
    DFSSTATUS Status = ERROR_SUCCESS;
    PSECURITY_DESCRIPTOR pSD = NULL;
    PVOID pHandle = NULL;
    UNICODE_STRING ObjectDN;
    
    DFS_TRACE_LOW(ADBLOB, "BlobCache %p: DfsADBlobCache::DfsDoesUserHaveAccess\n", this);

    do
    {

        Status = GetCachedADObject ( &pHandle );
        if(Status != ERROR_SUCCESS)
        {
            DFS_TRACE_ERROR_HIGH( Status, ADBLOB, "DfsADBlobCache::DfsDoesUserHaveAccess: GetCachedADObject failed status %x\n", 
                                 Status);
            break;
        }

        Status = GetObjectDN(&ObjectDN);
        if(Status != ERROR_SUCCESS)
        {
            DFS_TRACE_ERROR_HIGH( Status, ADBLOB, "DfsADBlobCache::DfsDoesUserHaveAccess: GetObjectDN failed status %x\n", 
                                 Status);
            break;
        }


        Status = DfsGetObjSecurity((LDAP *) pHandle,
                                   ObjectDN.Buffer,
                                   &pSD);

        if(Status != ERROR_SUCCESS)
        {
            DFS_TRACE_ERROR_HIGH( Status, ADBLOB, "DfsADBlobCache::DfsDoesUserHaveAccess: DfsGetObjectSecurity failed status %x\n", 
                                 Status);
            break;
        }

        Status = DfsDoesUserHaveDesiredAccessToAd(DesiredAccess, 
                                                  pSD);
        if(Status != ERROR_SUCCESS)
        {
            DFS_TRACE_ERROR_HIGH( Status, ADBLOB, "DfsADBlobCache::DfsDoesUserHaveAccess: DfsDoesUserHaveDesiredAccessToAd failed status %x\n", 
                                 Status);
            break;
        }

    }while (0);

    if(pHandle != NULL)
    {
        ReleaseADObject( pHandle );
    }

    if(pSD)
    {
        DfsDeallocateSecurityData (pSD);
    }

    return Status;
}