2101 lines
57 KiB
C++
2101 lines
57 KiB
C++
/*++
|
|
Copyright (c) 1998 Microsoft Corporation
|
|
|
|
Module Name: group.hxx
|
|
|
|
Abstract:
|
|
|
|
Manages cache group.
|
|
|
|
Author:
|
|
Danpo Zhang (DanpoZ) 02-08-98
|
|
--*/
|
|
|
|
#include <cache.hxx>
|
|
|
|
GroupMgr::GroupMgr()
|
|
{
|
|
_pContainer = NULL;
|
|
}
|
|
|
|
GroupMgr::~GroupMgr()
|
|
{
|
|
if( _pContainer )
|
|
{
|
|
_pContainer->Release(FALSE);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
GroupMgr::Init(URL_CONTAINER* pCont)
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
if( pCont )
|
|
{
|
|
_pContainer = pCont;
|
|
_pContainer->AddRef();
|
|
}
|
|
else
|
|
{
|
|
SetLastError(ERROR_INTERNET_INTERNAL_ERROR);
|
|
fRet = FALSE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
DWORD
|
|
GroupMgr::CreateGroup(DWORD dwFlags, GROUPID* pGID)
|
|
{
|
|
INET_ASSERT(_pContainer);
|
|
INET_ASSERT(pGID);
|
|
|
|
BOOL fMustUnlock;
|
|
DWORD dwError;
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
|
|
*pGID = 0;
|
|
|
|
if( !_pContainer->LockContainer(&fMustUnlock) )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto exit;
|
|
}
|
|
|
|
if( dwFlags & CACHEGROUP_FLAG_GIDONLY )
|
|
{
|
|
// only needs to return GID, no group needs to be created
|
|
*pGID = ObtainNewGID();
|
|
if( *pGID )
|
|
dwError = ERROR_SUCCESS;
|
|
else
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
|
|
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// find the first available entry by using FindEntry()
|
|
// passing gid = 0 means looking for empty entry
|
|
// passing TRUE means create new page if no entry available
|
|
//
|
|
dwError = FindEntry(0, &pGroupEntry, TRUE );
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
// get a new gid
|
|
*pGID = ObtainNewGID();
|
|
|
|
if( *pGID )
|
|
{
|
|
// insert gid into the first available entry
|
|
|
|
// set the sticky bit for non purgable group
|
|
if( dwFlags & CACHEGROUP_FLAG_NONPURGEABLE )
|
|
{
|
|
*pGID = SetStickyBit(*pGID);
|
|
}
|
|
|
|
pGroupEntry->gid = *pGID;
|
|
pGroupEntry->dwGroupFlags = dwFlags;
|
|
dwError = ERROR_SUCCESS;
|
|
}
|
|
|
|
exit:
|
|
if( fMustUnlock )
|
|
{
|
|
_pContainer->UnlockContainer();
|
|
}
|
|
|
|
return dwError;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GroupMgr::CreateDefaultGroups()
|
|
{
|
|
|
|
INET_ASSERT(_pContainer);
|
|
|
|
BOOL fMustUnlock;
|
|
DWORD dwError;
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
DWORD dwOffsetHead = 0;
|
|
|
|
if( !_pContainer->LockContainer(&fMustUnlock) )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto exit;
|
|
}
|
|
|
|
if( GetHeaderData( CACHE_HEADER_DATA_ROOTGROUP_OFFSET, &dwOffsetHead)
|
|
&& dwOffsetHead )
|
|
{
|
|
BOOL fBadHead = FALSE;
|
|
|
|
// dwOffsetHead may point to a page which has not actually mapped in
|
|
if( _pContainer->_UrlObjStorage->IsBadGroupOffset(dwOffsetHead) )
|
|
{
|
|
fBadHead = TRUE;
|
|
}
|
|
else
|
|
{
|
|
|
|
// if offset is too big, invalid
|
|
FILEMAP_ENTRY* pFM = NULL;
|
|
|
|
pFM = (FILEMAP_ENTRY*)
|
|
(*_pContainer->_UrlObjStorage->GetHeapStart() +
|
|
dwOffsetHead - sizeof(FILEMAP_ENTRY) );
|
|
if(pFM->dwSig != SIG_ALLOC || !pFM->nBlocks )
|
|
{
|
|
fBadHead = TRUE;
|
|
}
|
|
}
|
|
|
|
if( fBadHead )
|
|
{
|
|
// dwOffsetHead is invalid, reset!
|
|
SetHeaderData(CACHE_HEADER_DATA_ROOTGROUP_OFFSET, 0);
|
|
}
|
|
}
|
|
|
|
// if already created, just return success
|
|
dwError = FindEntry(CACHEGROUP_ID_BUILTIN_STICKY, &pGroupEntry, FALSE);
|
|
if( dwError == ERROR_SUCCESS )
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// not found, need to create new default groups
|
|
//
|
|
// find the first available entry by using FindEntry()
|
|
// passing gid = 0 means looking for empty entry
|
|
// passing TRUE means create new page if no entry available
|
|
//
|
|
dwError = FindEntry(0, &pGroupEntry, TRUE );
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
// set the sticky bit for non purgable group
|
|
pGroupEntry->gid = CACHEGROUP_ID_BUILTIN_STICKY;
|
|
pGroupEntry->dwGroupFlags = CACHEGROUP_FLAG_NONPURGEABLE;
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
exit:
|
|
if( fMustUnlock )
|
|
{
|
|
_pContainer->UnlockContainer();
|
|
}
|
|
|
|
return dwError;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GroupMgr::DeleteGroup(GROUPID gid, DWORD dwFlags)
|
|
{
|
|
INET_ASSERT(_pContainer);
|
|
INET_ASSERT(gid);
|
|
|
|
BOOL fMustUnlock;
|
|
DWORD dwError;
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
GROUP_DATA_ENTRY* pData = NULL;
|
|
DWORD hUrlFindHandle = 0;
|
|
URL_FILEMAP_ENTRY* pUrlEntry = 0;
|
|
DWORD dwFindFilter;
|
|
HASH_ITEM* pItem = NULL;
|
|
|
|
|
|
if( !_pContainer->LockContainer(&fMustUnlock) )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto exit;
|
|
}
|
|
|
|
|
|
// find the first available entry
|
|
dwError = FindEntry(gid, &pGroupEntry, FALSE);
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
|
|
// Look for all the url associated with this group
|
|
// mark the groupid to 0
|
|
hUrlFindHandle = _pContainer->GetInitialFindHandle();
|
|
|
|
// set up find filter (do not care about cookie/history)
|
|
dwFindFilter = URLCACHE_FIND_DEFAULT_FILTER
|
|
& ~COOKIE_CACHE_ENTRY
|
|
& ~URLHISTORY_CACHE_ENTRY;
|
|
|
|
//
|
|
// loop find all url belongs to this group
|
|
// WARNING: this can be slow!
|
|
//
|
|
do
|
|
{
|
|
// next url in this group
|
|
pUrlEntry = (URL_FILEMAP_ENTRY*)
|
|
_pContainer->_UrlObjStorage->FindNextEntry(
|
|
&hUrlFindHandle, dwFindFilter, gid);
|
|
|
|
if( pUrlEntry )
|
|
{
|
|
INET_ASSERT(hUrlFindHandle);
|
|
pItem = (HASH_ITEM*)(
|
|
(LPBYTE) *_pContainer->_UrlObjStorage->GetHeapStart() +
|
|
hUrlFindHandle );
|
|
|
|
if( pItem->HasMultiGroup() )
|
|
{
|
|
//
|
|
// examing the group list and remove this group
|
|
// from the list
|
|
//
|
|
DWORD dwNewHeaderOffset = pUrlEntry->dwGroupOffset;
|
|
DWORD dwGroupEntryOffset = PtrDiff32(pGroupEntry, *_pContainer->_UrlObjStorage->GetHeapStart());
|
|
|
|
//
|
|
// find the to be deleted group entry in the list
|
|
// of groups associated with this url, we need to
|
|
// fix this by removing the to be dead group from
|
|
// the list
|
|
//
|
|
DWORD Error = RemoveFromGroupList(
|
|
pUrlEntry->dwGroupOffset,
|
|
dwGroupEntryOffset,
|
|
&dwNewHeaderOffset
|
|
);
|
|
|
|
|
|
//
|
|
// found the entry and head offset has been changed
|
|
//
|
|
if( Error == ERROR_SUCCESS &&
|
|
dwNewHeaderOffset != pUrlEntry->dwGroupOffset )
|
|
{
|
|
pUrlEntry->dwGroupOffset = dwNewHeaderOffset;
|
|
|
|
//
|
|
// no more group associated with this url
|
|
// let's update the hash flags
|
|
//
|
|
if( !dwNewHeaderOffset )
|
|
{
|
|
pItem->ClearMultGroup();
|
|
pItem->ClearGroup();
|
|
}
|
|
}
|
|
|
|
// sticky bit
|
|
if(!pUrlEntry->dwExemptDelta && IsStickyGroup(gid) )
|
|
{
|
|
//
|
|
// unset sticky bit for this url IFF
|
|
// 1) we are about to delete the last group of this url
|
|
// 2) there is no more sticky group associated with this
|
|
// url other than the to be deleted group
|
|
//
|
|
if( !pUrlEntry->dwGroupOffset ||
|
|
( pUrlEntry->dwGroupOffset &&
|
|
NoMoreStickyEntryOnList(pUrlEntry->dwGroupOffset)))
|
|
{
|
|
|
|
_pContainer->UpdateStickness(
|
|
pUrlEntry,
|
|
URLCACHE_OP_UNSET_STICKY,
|
|
hUrlFindHandle
|
|
);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// do not move the url entry now, so we just
|
|
// need to reset the GroupOffset and re-exam the
|
|
// stick bit
|
|
//
|
|
pUrlEntry->dwGroupOffset = 0;
|
|
|
|
// sticky bit
|
|
if(!pUrlEntry->dwExemptDelta && IsStickyGroup(gid) )
|
|
{
|
|
|
|
_pContainer->UpdateStickness(
|
|
pUrlEntry,
|
|
URLCACHE_OP_UNSET_STICKY,
|
|
hUrlFindHandle
|
|
);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
if( dwFlags & CACHEGROUP_FLAG_FLUSHURL_ONDELETE)
|
|
{
|
|
//
|
|
// Container's DeleteUrlEntry method takes two
|
|
// param, the url entry and hash item.
|
|
// The hUrlFindHandle actually contains the
|
|
// offset of the Hash Item, so we can get
|
|
// the hash item from there.
|
|
//
|
|
|
|
// if this url belongs to other groups,
|
|
// do not delete it
|
|
if( !pItem->HasMultiGroup() )
|
|
{
|
|
_pContainer->DeleteUrlEntry(pUrlEntry, pItem, SIG_DELETE);
|
|
}
|
|
}
|
|
|
|
} // find next url
|
|
} while( pUrlEntry);
|
|
|
|
// if data entry exists, we should free them as well
|
|
if( pGroupEntry->dwGroupNameOffset )
|
|
{
|
|
dwError = FindDataEntry(pGroupEntry, &pData, FALSE);
|
|
if( dwError == ERROR_SUCCESS )
|
|
{
|
|
FreeDataEntry(pData);
|
|
}
|
|
}
|
|
|
|
memset(pGroupEntry, 0, sizeof(GROUP_ENTRY) );
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
exit:
|
|
if( fMustUnlock )
|
|
{
|
|
_pContainer->UnlockContainer();
|
|
}
|
|
|
|
return dwError;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
GroupMgr::GetGroup(
|
|
GROUPID gid,
|
|
DWORD dwAttrib,
|
|
INTERNET_CACHE_GROUP_INFOA* pOutGroupInfo,
|
|
DWORD* pdwOutGroupInfoSize
|
|
)
|
|
{
|
|
INET_ASSERT(_pContainer);
|
|
INET_ASSERT(gid && pOutGroupInfo && pdwOutGroupInfoSize);
|
|
|
|
BOOL fMustUnlock;
|
|
DWORD dwError;
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
|
|
if( !_pContainer->LockContainer(&fMustUnlock) )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto exit;
|
|
}
|
|
|
|
|
|
*pdwOutGroupInfoSize = 0;
|
|
|
|
// find the entry
|
|
dwError = FindEntry(gid, &pGroupEntry, FALSE);
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
// init out param
|
|
memset(pOutGroupInfo, 0, sizeof(INTERNET_CACHE_GROUP_INFOA) );
|
|
|
|
// copy over GROUP_ENTRY -> GROUP_INFO
|
|
Translate(
|
|
dwAttrib,
|
|
pOutGroupInfo,
|
|
pGroupEntry,
|
|
GROUP_ENTRY_TO_INFO,
|
|
pdwOutGroupInfoSize
|
|
);
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
exit:
|
|
if( fMustUnlock )
|
|
{
|
|
_pContainer->UnlockContainer();
|
|
}
|
|
|
|
return dwError;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GroupMgr::SetGroup(
|
|
GROUPID gid,
|
|
DWORD dwAttrib,
|
|
INTERNET_CACHE_GROUP_INFOA* pGroupInfo
|
|
)
|
|
{
|
|
INET_ASSERT(_pContainer);
|
|
INET_ASSERT(pGroupInfo && gid);
|
|
|
|
BOOL fMustUnlock;
|
|
DWORD dwError;
|
|
GROUP_ENTRY* pGroupEntry;
|
|
|
|
if( !_pContainer->LockContainer(&fMustUnlock) )
|
|
{
|
|
dwError = GetLastError();
|
|
goto Cleanup;
|
|
}
|
|
|
|
pGroupEntry = NULL;
|
|
|
|
INET_ASSERT(pGroupInfo);
|
|
|
|
if( dwAttrib & ~(CACHEGROUP_READWRITE_MASK) )
|
|
{
|
|
//
|
|
// read only fields are being requested
|
|
//
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if( (dwAttrib & CACHEGROUP_ATTRIBUTE_GROUPNAME) &&
|
|
(strlen(pGroupInfo->szGroupName) >= GROUPNAME_MAX_LENGTH ) )
|
|
{
|
|
//
|
|
// name too long, exceed the buffer limit
|
|
//
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// find the entry
|
|
dwError = FindEntry(gid, &pGroupEntry, FALSE);
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
// copy over GROUP_INFO -> GROUP_ENTRY
|
|
Translate(
|
|
dwAttrib,
|
|
pGroupInfo,
|
|
pGroupEntry,
|
|
GROUP_INFO_TO_ENTRY,
|
|
0
|
|
);
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
Cleanup:
|
|
if( fMustUnlock )
|
|
{
|
|
_pContainer->UnlockContainer();
|
|
}
|
|
|
|
return dwError;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GroupMgr::GetNextGroup(
|
|
DWORD* pdwLastItemOffset,
|
|
GROUPID* pOutGroupId
|
|
)
|
|
{
|
|
INET_ASSERT(_pContainer);
|
|
INET_ASSERT(pOutGroupId);
|
|
|
|
BOOL fMustUnlock;
|
|
BOOL fEndOfGroups;
|
|
GROUP_ENTRY* pGroupEntry;
|
|
DWORD dwNewOffset;
|
|
DWORD dwError;
|
|
|
|
if( !_pContainer->LockContainer(&fMustUnlock) )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
fEndOfGroups = TRUE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
pGroupEntry = NULL;
|
|
dwNewOffset = 0;
|
|
fEndOfGroups = FALSE;
|
|
|
|
if( *pdwLastItemOffset == 0 )
|
|
{
|
|
// get root
|
|
dwError = FindRootEntry(&pGroupEntry, FALSE );
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
//
|
|
// new find and we can not get the root entry
|
|
// this means there are no group at all.
|
|
//
|
|
fEndOfGroups = TRUE;
|
|
goto Cleanup;
|
|
}
|
|
} // IF: no previous offset, this is a new Find
|
|
|
|
else if( *pdwLastItemOffset == OFFSET_NO_MORE_GROUP )
|
|
{
|
|
// this group of search has completed already
|
|
fEndOfGroups = TRUE;
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
goto Cleanup;
|
|
|
|
} // ELSE IF: previous FindNext has already reached the end of the groups
|
|
|
|
else
|
|
{
|
|
//
|
|
// use the offset to jump to the last returned item's entry
|
|
//
|
|
pGroupEntry = (GROUP_ENTRY*)
|
|
(*_pContainer->_UrlObjStorage->GetHeapStart() + *pdwLastItemOffset);
|
|
//
|
|
// one step forward
|
|
//
|
|
INET_ASSERT(pGroupEntry); // can't be null
|
|
INET_ASSERT( !IsIndexToNewPage(pGroupEntry) ); // can't be index item
|
|
pGroupEntry++;
|
|
|
|
} // ELSE: walk to the item which has been returned by previous FindNext()
|
|
|
|
|
|
// loop for next entry
|
|
while(pGroupEntry)
|
|
{
|
|
//
|
|
// if this entry is the last one of the page
|
|
// it contains offset pointing to the next page
|
|
//
|
|
if( IsIndexToNewPage(pGroupEntry) )
|
|
{
|
|
//
|
|
// BUGBUG
|
|
// we currently use dwFlags to indicating if
|
|
// this is pointing to the next offset
|
|
//
|
|
if( pGroupEntry->dwGroupFlags )
|
|
{
|
|
//
|
|
// walk to next page
|
|
//
|
|
pGroupEntry = (GROUP_ENTRY*)
|
|
( *_pContainer->_UrlObjStorage->GetHeapStart()
|
|
+ pGroupEntry->dwGroupFlags );
|
|
} // IF: index entry point to next page
|
|
|
|
else
|
|
{
|
|
//
|
|
// we are done
|
|
//
|
|
fEndOfGroups = TRUE;
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
break;
|
|
|
|
} // ELSE: index page contains nothing (this is the last page)
|
|
|
|
} // special case: current entry is the index(point to next page)
|
|
|
|
|
|
//
|
|
// using gid to test if the entry is empty, if not,
|
|
// walk to the next entry
|
|
//
|
|
if( !pGroupEntry->gid )
|
|
{
|
|
pGroupEntry++;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
} // while(pGroupEntry)
|
|
|
|
|
|
Cleanup:
|
|
// update LastItemOffset
|
|
if (!fEndOfGroups
|
|
&& pGroupEntry)
|
|
{
|
|
LPBYTE lpbBase = *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
dwNewOffset = PtrDiff32(pGroupEntry, lpbBase);
|
|
*pdwLastItemOffset = dwNewOffset;
|
|
|
|
// copy over GROUP_ENTRY -> GROUP_INFO
|
|
*pOutGroupId = pGroupEntry->gid;
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
} // IF: find the item
|
|
|
|
else
|
|
{
|
|
*pdwLastItemOffset = OFFSET_NO_MORE_GROUP;
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
} // ELSE: not find
|
|
|
|
if( fMustUnlock )
|
|
{
|
|
_pContainer->UnlockContainer();
|
|
}
|
|
|
|
return dwError;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GroupMgr::FindRootEntry(
|
|
GROUP_ENTRY** ppOut, // OUT: first empty entry
|
|
BOOL fCreate // allocate new page if needed
|
|
)
|
|
{
|
|
INET_ASSERT(ppOut);
|
|
*ppOut = NULL;
|
|
|
|
GROUPS_ALLOC_FILEMAP_ENTRY* pPage = NULL;
|
|
DWORD dwError;
|
|
DWORD dwOffsetToRootEntry = 0;
|
|
|
|
// get base offset
|
|
if( GetHeaderData( CACHE_HEADER_DATA_ROOTGROUP_OFFSET, &dwOffsetToRootEntry))
|
|
{
|
|
if( !dwOffsetToRootEntry && fCreate )
|
|
{
|
|
dwError = CreateNewPage(&dwOffsetToRootEntry, TRUE);
|
|
|
|
if( dwError != ERROR_SUCCESS)
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
else if( !dwOffsetToRootEntry && !fCreate )
|
|
{
|
|
//
|
|
// there is no offset infomation on the mem file
|
|
// however, the flag says do not create a new page
|
|
// failure is the only option here
|
|
//
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
goto Cleanup;
|
|
}
|
|
|
|
} // IF: retrieve base offset
|
|
|
|
else
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
|
|
} // ELSE: failed to get base offset
|
|
|
|
|
|
//
|
|
// At this point, we should either:
|
|
// 1. retrieved valid dwOffsetToRootEntry or
|
|
// 2. get the new dwOffsetToRootEntry via CreateNewPage() call
|
|
//
|
|
INET_ASSERT( dwOffsetToRootEntry );
|
|
*ppOut = (GROUP_ENTRY*)
|
|
( *_pContainer->_UrlObjStorage->GetHeapStart() + dwOffsetToRootEntry);
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
Cleanup:
|
|
return dwError;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
GroupMgr::FindEntry(
|
|
GROUPID gid, // gid, 0 means find first empty seat
|
|
GROUP_ENTRY** ppOut, // OUT: entry with gid specified
|
|
BOOL fCreate // allocate new page if needed
|
|
// (applied for searching empty seat only)
|
|
)
|
|
{
|
|
INET_ASSERT(ppOut);
|
|
|
|
// fCreate can only be associated with gid == 0
|
|
INET_ASSERT( (fCreate && !gid ) || (!fCreate && gid ) );
|
|
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
DWORD dwError;
|
|
|
|
// get Root Entry
|
|
dwError = FindRootEntry(&pGroupEntry, fCreate);
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
} // failed to get the root entry
|
|
|
|
|
|
INET_ASSERT(pGroupEntry); // pGroupEntry should be available now
|
|
|
|
while(1)
|
|
{
|
|
// special case for end of this page
|
|
if( IsIndexToNewPage(pGroupEntry) )
|
|
{
|
|
//
|
|
// BUGBUG
|
|
// we currently use the dwFlags to indicating
|
|
// if this is pointing to the next offset
|
|
//
|
|
if( pGroupEntry->dwGroupFlags )
|
|
{
|
|
// walk to next page
|
|
pGroupEntry = (GROUP_ENTRY*)
|
|
( *_pContainer->_UrlObjStorage->GetHeapStart()
|
|
+ pGroupEntry->dwGroupFlags );
|
|
|
|
} // IF: index entry points to next page
|
|
|
|
else if( fCreate)
|
|
{
|
|
//////////////////////////////////////////////////////////////////
|
|
// BEGIN WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
DWORD dwOffsetToFirstEntry = 0;
|
|
LPBYTE lpbBase = NULL;
|
|
|
|
// remember the old offset for pGroupEntry
|
|
DWORD_PTR dwpEntryOffset = PtrDifference(pGroupEntry, *_pContainer->_UrlObjStorage->GetHeapStart());
|
|
|
|
// create new page!
|
|
dwError = CreateNewPage(&dwOffsetToFirstEntry, FALSE);
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
// recalculate pGroupEntry using the offset remembered
|
|
lpbBase = *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
pGroupEntry = (GROUP_ENTRY*)(lpbBase + dwpEntryOffset);
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// END WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// pGroupEntry currently is the index item, insert
|
|
// the offset of the first item to the newly created page
|
|
//
|
|
pGroupEntry->dwGroupFlags = dwOffsetToFirstEntry;
|
|
|
|
// walk to the new page
|
|
pGroupEntry = (GROUP_ENTRY*)(lpbBase + dwOffsetToFirstEntry);
|
|
|
|
|
|
} // ELSE IF: index entry not point to new page, fCreate is
|
|
// set, a new page is being created
|
|
|
|
else
|
|
{
|
|
// this is the end of all groups, item still not found,
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
break;
|
|
|
|
} // ELSE: index entry not point to new page, fCreate not set
|
|
|
|
} // IF: this entry is an index entry
|
|
|
|
|
|
//
|
|
// now pGroupEntry must point to a normal group entry
|
|
//
|
|
INET_ASSERT( !IsIndexToNewPage(pGroupEntry) );
|
|
|
|
if( pGroupEntry->gid != gid )
|
|
{
|
|
// not found, walk to next entry
|
|
pGroupEntry++;
|
|
}
|
|
else
|
|
{
|
|
// found entry
|
|
dwError = ERROR_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
} // WHILE: (loop over all page)
|
|
|
|
|
|
Cleanup:
|
|
if( dwError == ERROR_SUCCESS )
|
|
{
|
|
*ppOut = pGroupEntry;
|
|
}
|
|
else
|
|
{
|
|
*ppOut = NULL;
|
|
}
|
|
|
|
return dwError;
|
|
}
|
|
|
|
DWORD
|
|
GroupMgr::CreateNewPage(DWORD* dwOffsetToFirstEntry, BOOL fIsFirstPage)
|
|
{
|
|
DWORD dwError;
|
|
GROUPS_ALLOC_FILEMAP_ENTRY* pPage = NULL;
|
|
DWORD cbSize = sizeof(GROUPS_ALLOC_FILEMAP_ENTRY);
|
|
|
|
pPage = (GROUPS_ALLOC_FILEMAP_ENTRY*)
|
|
_pContainer->_UrlObjStorage->AllocateEntry(cbSize);
|
|
|
|
|
|
if( pPage )
|
|
{
|
|
// clean up allocated page
|
|
cbSize = PAGE_SIZE_FOR_GROUPS;
|
|
memset(pPage->pGroupBlock, 0, cbSize );
|
|
|
|
// calculate the group base offset
|
|
LPBYTE lpbBase = *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
|
|
*dwOffsetToFirstEntry = PtrDiff32(pPage->pGroupBlock, lpbBase);
|
|
|
|
//
|
|
// mark the last entry as index to next page
|
|
// (gid == GID_INDEX_TO_NEXT_PAGE) is the mark,
|
|
// the actual offset is stored at dwGroupFlags field
|
|
//
|
|
GROUP_ENTRY* pEnd = (GROUP_ENTRY*) pPage->pGroupBlock;
|
|
pEnd = pEnd + (GROUPS_PER_PAGE - 1);
|
|
pEnd->gid = GID_INDEX_TO_NEXT_PAGE;
|
|
|
|
if( fIsFirstPage )
|
|
{
|
|
//
|
|
// for first page, we would have to set the offset
|
|
// back to the CacheHeader
|
|
//
|
|
if( !SetHeaderData(
|
|
CACHE_HEADER_DATA_ROOTGROUP_OFFSET, *dwOffsetToFirstEntry))
|
|
{
|
|
// free allocated page
|
|
_pContainer->_UrlObjStorage->FreeEntry(pPage);
|
|
|
|
// set error and go
|
|
*dwOffsetToFirstEntry = 0;
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
|
|
} // IF: failed to set the offset
|
|
}
|
|
|
|
// return the offset to the first entry of the new page
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
} // IF: Allocate new page succeed
|
|
|
|
else
|
|
{
|
|
dwError = ERROR_NOT_ENOUGH_MEMORY;
|
|
} // ELSE: failed to allocate new page
|
|
|
|
Cleanup:
|
|
return dwError;
|
|
}
|
|
|
|
|
|
|
|
GROUPID
|
|
GroupMgr::ObtainNewGID()
|
|
{
|
|
SYSTEMTIME st;
|
|
DWORD dwC[2] = {0, 0};
|
|
GROUPID gid = 0;
|
|
|
|
// get counter from index file
|
|
if( GetHeaderData(CACHE_HEADER_DATA_GID_LOW, &dwC[0]) &&
|
|
GetHeaderData(CACHE_HEADER_DATA_GID_HIGH, &dwC[1]) )
|
|
{
|
|
if( !dwC[0] && !dwC[1] )
|
|
{
|
|
// need to get the current system time
|
|
GetSystemTime( &st );
|
|
SystemTimeToFileTime(&st, (FILETIME*)dwC);
|
|
|
|
} // IF: counter not initialized
|
|
|
|
else
|
|
{
|
|
// increment
|
|
if( dwC[0] != 0xffffffff )
|
|
{
|
|
dwC[0] ++;
|
|
}
|
|
else
|
|
{
|
|
dwC[0] = 0;
|
|
dwC[1] ++;
|
|
}
|
|
} // ELSE: counter initialized
|
|
|
|
// send data back to cache
|
|
if( SetHeaderData(CACHE_HEADER_DATA_GID_LOW, dwC[0] ) &&
|
|
SetHeaderData(CACHE_HEADER_DATA_GID_HIGH, dwC[1] ) )
|
|
{
|
|
//memcpy(&gid, dwC, sizeof(GROUPID) );
|
|
gid = *((GROUPID *)dwC);
|
|
}
|
|
}
|
|
|
|
// apply the mask to newly created gid
|
|
// the first 4 bits are reserved (one bit is used for stickness)
|
|
return (gid & GID_MASK);
|
|
}
|
|
|
|
|
|
BOOL
|
|
GroupMgr::Translate(
|
|
DWORD dwAttrib,
|
|
INTERNET_CACHE_GROUP_INFOA* pGroupInfo,
|
|
GROUP_ENTRY* pGroupEntry,
|
|
DWORD dwFlag,
|
|
DWORD* pdwSize
|
|
)
|
|
{
|
|
INET_ASSERT(pGroupInfo && pGroupEntry);
|
|
BOOL fRet = TRUE;
|
|
GROUP_DATA_ENTRY* pData = NULL;
|
|
DWORD dwError;
|
|
|
|
if( dwFlag == GROUP_ENTRY_TO_INFO )
|
|
{
|
|
INET_ASSERT(pdwSize);
|
|
|
|
// clear
|
|
memset(pGroupInfo, 0, sizeof(INTERNET_CACHE_GROUP_INFOA) );
|
|
*pdwSize = 0;
|
|
|
|
// basic entries
|
|
if( dwAttrib & CACHEGROUP_ATTRIBUTE_BASIC )
|
|
{
|
|
pGroupInfo->dwGroupSize = sizeof(INTERNET_CACHE_GROUP_INFOA);
|
|
pGroupInfo->dwGroupFlags = pGroupEntry->dwGroupFlags;
|
|
pGroupInfo->dwGroupType = pGroupEntry->dwGroupType;
|
|
pGroupInfo->dwDiskUsage = (DWORD)(pGroupEntry->llDiskUsage / 1024);
|
|
pGroupInfo->dwDiskQuota = pGroupEntry->dwDiskQuota;
|
|
}
|
|
|
|
// user friendly name
|
|
if( ( (dwAttrib & CACHEGROUP_ATTRIBUTE_GROUPNAME) |
|
|
(dwAttrib & CACHEGROUP_ATTRIBUTE_STORAGE ) ) &&
|
|
pGroupEntry->dwGroupNameOffset )
|
|
{
|
|
dwError = FindDataEntry(pGroupEntry, &pData, FALSE);
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
fRet = FALSE;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwLen = strlen(pData->szName) + 1;
|
|
INET_ASSERT( dwLen > GROUPNAME_MAX_LENGTH );
|
|
|
|
memcpy( pGroupInfo->szGroupName,
|
|
pData->szName,
|
|
dwLen );
|
|
|
|
memcpy( pGroupInfo->dwOwnerStorage,
|
|
pData->dwOwnerStorage,
|
|
sizeof(DWORD) * GROUP_OWNER_STORAGE_SIZE );
|
|
}
|
|
}
|
|
|
|
// set size
|
|
*pdwSize = sizeof(INTERNET_CACHE_GROUP_INFOA);
|
|
}
|
|
|
|
else
|
|
if( dwFlag == GROUP_INFO_TO_ENTRY )
|
|
{
|
|
// copy
|
|
if( dwAttrib & CACHEGROUP_ATTRIBUTE_FLAG )
|
|
{
|
|
pGroupEntry->dwGroupFlags = pGroupInfo->dwGroupFlags;
|
|
}
|
|
|
|
if( dwAttrib & CACHEGROUP_ATTRIBUTE_TYPE )
|
|
{
|
|
pGroupEntry->dwGroupType = pGroupInfo->dwGroupType;
|
|
}
|
|
|
|
if( dwAttrib & CACHEGROUP_ATTRIBUTE_QUOTA )
|
|
{
|
|
pGroupEntry->dwDiskQuota = pGroupInfo->dwDiskQuota;
|
|
}
|
|
|
|
if( (dwAttrib & CACHEGROUP_ATTRIBUTE_GROUPNAME) |
|
|
(dwAttrib & CACHEGROUP_ATTRIBUTE_STORAGE ) )
|
|
{
|
|
|
|
dwError = FindDataEntry(pGroupEntry, &pData, TRUE);
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
fRet = FALSE;
|
|
}
|
|
else
|
|
{
|
|
|
|
if( dwAttrib & CACHEGROUP_ATTRIBUTE_GROUPNAME )
|
|
{
|
|
DWORD dwLen = strlen(pGroupInfo->szGroupName) + 1;
|
|
INET_ASSERT(dwLen > GROUPNAME_MAX_LENGTH);
|
|
|
|
memcpy( pData->szName,
|
|
pGroupInfo->szGroupName,
|
|
dwLen );
|
|
}
|
|
|
|
if( dwAttrib & CACHEGROUP_ATTRIBUTE_STORAGE )
|
|
{
|
|
memcpy( pData->dwOwnerStorage,
|
|
pGroupInfo->dwOwnerStorage,
|
|
sizeof(DWORD) * GROUP_OWNER_STORAGE_SIZE );
|
|
}
|
|
|
|
|
|
// BUGBUG
|
|
// if both fields are set to be empty, we should free
|
|
// the allocated data itam
|
|
}
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
fRet = FALSE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL
|
|
GroupMgr::IsPageEmpty(GROUP_ENTRY* pHead)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
GROUP_ENTRY* pGroupEntry = pHead;
|
|
for( int i = 0; i < (GROUPS_PER_PAGE - 1); i ++)
|
|
{
|
|
if( pGroupEntry->gid )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
pGroupEntry++;
|
|
}
|
|
}
|
|
|
|
// there is no item found on this page
|
|
if( !pGroupEntry->gid && i == GROUPS_PER_PAGE - 1 )
|
|
{
|
|
fRet = TRUE;
|
|
}
|
|
|
|
|
|
return fRet;
|
|
}
|
|
|
|
BOOL
|
|
GroupMgr::IsLastPage(GROUP_ENTRY* pHead)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
GROUP_ENTRY* pEnd = NULL;
|
|
|
|
// jump to last item
|
|
pEnd = pHead + GROUPS_PER_PAGE;
|
|
|
|
//
|
|
// the gid has to be marked as GID_INDEX_TO_NEXT_PAGE
|
|
// for index entry, and if the dwGroupFlags is 0,
|
|
// that means we are not pointing to any
|
|
// other page, this is the last page indeed.
|
|
//
|
|
if( pEnd->gid == GID_INDEX_TO_NEXT_PAGE && !pEnd->dwGroupFlags )
|
|
{
|
|
fRet = TRUE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
|
|
BOOL
|
|
GroupMgr::FreeEmptyPages(DWORD dwFlags)
|
|
{
|
|
INET_ASSERT(_pContainer);
|
|
BOOL fMustUnlock;
|
|
|
|
BOOL fRet = TRUE;
|
|
GROUP_ENTRY* pHead = NULL;
|
|
GROUP_ENTRY* pPrevHead = NULL;
|
|
GROUP_ENTRY* pEnd = NULL;
|
|
GROUP_ENTRY* pTobeDeleted = NULL;
|
|
BOOL fFirstPage = TRUE;
|
|
|
|
if( !_pContainer->LockContainer(&fMustUnlock) )
|
|
{
|
|
fRet = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// BUGBUG FindRootEntry changed the return code, check for dwError
|
|
if( FindRootEntry(&pHead, FALSE ) )
|
|
{
|
|
pPrevHead = pHead;
|
|
while(pHead)
|
|
{
|
|
pTobeDeleted = NULL;
|
|
|
|
if( IsPageEmpty(pHead) )
|
|
{
|
|
pTobeDeleted = pHead;
|
|
|
|
//
|
|
// find the offset of the next page
|
|
// 0 which means the current page is the last one
|
|
//
|
|
DWORD dwOffsetNextPage = 0;
|
|
pEnd = pHead + GROUPS_PER_PAGE;
|
|
dwOffsetNextPage = pEnd->dwGroupFlags;
|
|
|
|
//
|
|
// if the first page is to be deleted, we have to
|
|
// update the offset which points to the next page
|
|
//
|
|
if( fFirstPage)
|
|
{
|
|
if( !SetHeaderData(
|
|
CACHE_HEADER_DATA_ROOTGROUP_OFFSET, dwOffsetNextPage))
|
|
{
|
|
fRet = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
//
|
|
// Link Prev page to Next page
|
|
//
|
|
GROUP_ENTRY* pPrevEnd = pPrevHead + GROUPS_PER_PAGE;
|
|
pPrevEnd->dwGroupFlags = dwOffsetNextPage;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// update pHead make it point to the next page
|
|
//
|
|
if( !IsLastPage(pHead) )
|
|
{
|
|
// remember pPrev
|
|
pPrevHead = pHead;
|
|
|
|
// walk to next page
|
|
pEnd = pHead + GROUPS_PER_PAGE;
|
|
pHead = (GROUP_ENTRY*)
|
|
( *_pContainer->_UrlObjStorage->GetHeapStart()
|
|
+ pEnd->dwGroupFlags );
|
|
|
|
// not first page anymore
|
|
fFirstPage = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// this is the last page
|
|
pHead = NULL;
|
|
}
|
|
|
|
//
|
|
// free the tobe deleted page
|
|
//
|
|
if( pTobeDeleted )
|
|
{
|
|
GROUPS_ALLOC_FILEMAP_ENTRY* pPage = NULL;
|
|
pPage = (GROUPS_ALLOC_FILEMAP_ENTRY*) ((LPBYTE)pTobeDeleted - sizeof(FILEMAP_ENTRY));
|
|
|
|
_pContainer->_UrlObjStorage->FreeEntry(pPage);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
Cleanup:
|
|
if( fMustUnlock )
|
|
{
|
|
_pContainer->UnlockContainer();
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GroupMgr::FindDataEntry(
|
|
GROUP_ENTRY* pGroupEntry,
|
|
GROUP_DATA_ENTRY** pOutData,
|
|
BOOL fCreate
|
|
)
|
|
{
|
|
INET_ASSERT(_pContainer);
|
|
INET_ASSERT(pGroupEntry && pOutData );
|
|
*pOutData = NULL;
|
|
|
|
BOOL fMustUnlock;
|
|
DWORD dwError;
|
|
LPBYTE lpbBase = NULL;
|
|
|
|
if( !_pContainer->LockContainer(&fMustUnlock) )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto exit;
|
|
}
|
|
|
|
if( pGroupEntry->dwGroupNameOffset )
|
|
{
|
|
lpbBase = *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
*pOutData = (GROUP_DATA_ENTRY*) (lpbBase + pGroupEntry->dwGroupNameOffset);
|
|
dwError = ERROR_SUCCESS;
|
|
}
|
|
|
|
else if( fCreate)
|
|
{
|
|
//////////////////////////////////////////////////////////////////
|
|
// BEGIN WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
// remember the old offset for pGroupEntry
|
|
DWORD_PTR dwpEntryOffset = PtrDifference(pGroupEntry, *_pContainer->_UrlObjStorage->GetHeapStart());
|
|
|
|
// create new data entry
|
|
*pOutData = GetHeadDataEntry(TRUE);
|
|
if( *pOutData )
|
|
{
|
|
//
|
|
// re-calc pGroupEntry
|
|
//
|
|
lpbBase = (LPBYTE) *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
pGroupEntry = (GROUP_ENTRY*)(lpbBase + dwpEntryOffset);
|
|
|
|
//
|
|
// set entry's filename offset field
|
|
//
|
|
pGroupEntry->dwGroupNameOffset = PtrDiff32(*pOutData, lpbBase);
|
|
|
|
// succeed
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
}
|
|
else
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
}
|
|
//////////////////////////////////////////////////////////////////
|
|
// END WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
}
|
|
|
|
else
|
|
{
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
exit:
|
|
if( fMustUnlock )
|
|
{
|
|
_pContainer->UnlockContainer();
|
|
}
|
|
|
|
if( fCreate && (dwError == ERROR_SUCCESS) )
|
|
{
|
|
// for new item, it's nice to mark the next link to 0
|
|
(*pOutData)->dwOffsetNext = 0;
|
|
}
|
|
return dwError;
|
|
}
|
|
|
|
|
|
VOID
|
|
GroupMgr::FreeDataEntry(GROUP_DATA_ENTRY* pDataEntry)
|
|
{
|
|
// get the head entry
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
DWORD dwError = FindRootEntry(&pGroupEntry, FALSE );
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// walk to the index item whose dwGroupNameOffset
|
|
// contains offset the the head of free list
|
|
//
|
|
pGroupEntry += (GROUPS_PER_PAGE - 1);
|
|
INET_ASSERT( pGroupEntry->gid == GID_INDEX_TO_NEXT_PAGE);
|
|
|
|
// memset the freed data entry
|
|
memset(pDataEntry, 0, sizeof(GROUP_DATA_ENTRY) );
|
|
|
|
// make data item's next link points to current head
|
|
pDataEntry->dwOffsetNext = pGroupEntry->dwGroupNameOffset;
|
|
|
|
// make the current head to be the just freed item's offset
|
|
LPBYTE lpbBase = *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
pGroupEntry->dwGroupNameOffset = PtrDiff32(pDataEntry, lpbBase);
|
|
}
|
|
|
|
|
|
LPGROUP_DATA_ENTRY
|
|
GroupMgr::GetHeadDataEntry(BOOL fCreate)
|
|
{
|
|
GROUP_DATA_ENTRY* pDataEntry = NULL;
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
LPBYTE lpbBase = NULL;
|
|
|
|
// get the head entry
|
|
DWORD dwError = FindRootEntry(&pGroupEntry, FALSE );
|
|
if( dwError != ERROR_SUCCESS )
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
// walk to the index item
|
|
pGroupEntry += (GROUPS_PER_PAGE - 1);
|
|
INET_ASSERT( pGroupEntry->gid == GID_INDEX_TO_NEXT_PAGE);
|
|
|
|
// the dwGroupNameOffset contains offset the the head of free list
|
|
if( pGroupEntry->dwGroupNameOffset)
|
|
{
|
|
// get the head
|
|
lpbBase = (LPBYTE) *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
pDataEntry = (GROUP_DATA_ENTRY*) (lpbBase + pGroupEntry->dwGroupNameOffset);
|
|
|
|
// reset head to next one
|
|
pGroupEntry->dwGroupNameOffset = pDataEntry->dwOffsetNext;
|
|
}
|
|
|
|
else if( fCreate )
|
|
{
|
|
//////////////////////////////////////////////////////////////////
|
|
// BEGIN WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// remember the old offset for pGroupEntry
|
|
DWORD_PTR dwpEntryOffset = PtrDifference(pGroupEntry, *_pContainer->_UrlObjStorage->GetHeapStart());
|
|
|
|
// create a new page
|
|
GROUPS_ALLOC_FILEMAP_ENTRY* pPage = NULL;
|
|
DWORD cbSize = sizeof(GROUPS_ALLOC_FILEMAP_ENTRY);
|
|
|
|
pPage = (GROUPS_ALLOC_FILEMAP_ENTRY*)
|
|
_pContainer->_UrlObjStorage->AllocateEntry(cbSize);
|
|
|
|
if( !pPage )
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
// memset
|
|
memset(pPage->pGroupBlock, 0, PAGE_SIZE_FOR_GROUPS);
|
|
|
|
lpbBase = (LPBYTE) *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
GROUP_DATA_ENTRY* pHead = (GROUP_DATA_ENTRY*)pPage->pGroupBlock;
|
|
pDataEntry = pHead;
|
|
|
|
// init list on the newly created page
|
|
for(int i = 0; i < GROUPS_DATA_PER_PAGE - 1; i++)
|
|
{
|
|
// point to next offset
|
|
GROUP_DATA_ENTRY* pNext = pHead + 1;
|
|
pHead->dwOffsetNext = PtrDiff32(pNext, lpbBase);
|
|
pHead = pNext;
|
|
}
|
|
|
|
//
|
|
// pGroupEntry needs to be re-calc!
|
|
//
|
|
pGroupEntry = (GROUP_ENTRY*)(lpbBase + dwpEntryOffset);
|
|
|
|
//
|
|
// pGroupEntry currently is the index entry of the first
|
|
// page, it's dwGroupNameOffset field points the head of
|
|
// the list of a free group data entry
|
|
//
|
|
pGroupEntry->dwGroupNameOffset = pDataEntry->dwOffsetNext;
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// END WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
}
|
|
|
|
else
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
return pDataEntry;
|
|
}
|
|
|
|
DWORD
|
|
GroupMgr::GetOffsetFromList(DWORD dwHeadOffset, GROUPID gid, DWORD* pdwOffset)
|
|
{
|
|
DWORD dwError;
|
|
LIST_GROUP_ENTRY* pListGroup = NULL;
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
|
|
*pdwOffset = 0;
|
|
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(dwHeadOffset);
|
|
if( !pListGroup )
|
|
{
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
goto Cleanup;
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
|
|
if(!_pContainer->_UrlObjStorage->IsBadGroupOffset(pListGroup->dwGroupOffset))
|
|
{
|
|
pGroupEntry = (GROUP_ENTRY*)
|
|
( *_pContainer->_UrlObjStorage->GetHeapStart()
|
|
+ pListGroup->dwGroupOffset );
|
|
}
|
|
else
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if( pGroupEntry && pGroupEntry->gid == gid )
|
|
{
|
|
*pdwOffset = pListGroup->dwGroupOffset;
|
|
break;
|
|
}
|
|
|
|
// end of list, not found
|
|
if( !pListGroup->dwNext )
|
|
{
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
break;
|
|
}
|
|
|
|
// walk to next
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(
|
|
pListGroup->dwNext);
|
|
|
|
if( !pListGroup )
|
|
{
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
if( *pdwOffset )
|
|
{
|
|
dwError = ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
Cleanup:
|
|
return dwError;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GroupMgr::CreateNewGroupList(DWORD* pdwHeadOffset)
|
|
{
|
|
DWORD dwError;
|
|
|
|
// Find empty slot
|
|
*pdwHeadOffset = 0;
|
|
dwError = FindEmptySlotInListPage(pdwHeadOffset);
|
|
if( ERROR_SUCCESS != dwError )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
return dwError;
|
|
}
|
|
|
|
DWORD
|
|
GroupMgr::AddToGroupList(DWORD dwHeadOffset, DWORD dwOffset)
|
|
{
|
|
DWORD dwError;
|
|
DWORD dwEmptySlot;
|
|
LIST_GROUP_ENTRY* pListGroup = NULL;
|
|
LIST_GROUP_ENTRY* pListGroupEmpty = NULL;
|
|
|
|
// if the item already on the list, return success
|
|
if( IsGroupOnList(dwHeadOffset, dwOffset) )
|
|
{
|
|
dwError = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(dwHeadOffset);
|
|
if( !pListGroup )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if( !pListGroup->dwGroupOffset )
|
|
{
|
|
// list is empty, just need to fill up the Head
|
|
pListGroup->dwGroupOffset = dwOffset;
|
|
}
|
|
else
|
|
{
|
|
// List is not empty, we have to walk to end of the list
|
|
// also need to get another empty slot
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// BEGIN WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
// remember the old offset for pListGroup
|
|
DWORD_PTR dwpListGroupOffset = PtrDifference(pListGroup, *_pContainer->_UrlObjStorage->GetHeapStart());
|
|
|
|
// find empty slot
|
|
dwError = FindEmptySlotInListPage(&dwEmptySlot);
|
|
if( ERROR_SUCCESS != dwError )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
// recalculate pListGroup using the offset remembered
|
|
LPBYTE lpbBase = *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
pListGroup = (LIST_GROUP_ENTRY*)(lpbBase + dwpListGroupOffset);
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// END WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
// walk to end of list
|
|
while( pListGroup->dwNext )
|
|
{
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(
|
|
pListGroup->dwNext);
|
|
if( !pListGroup )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
// Get ListGroupEmpty Object from the empty slot
|
|
pListGroupEmpty =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(dwEmptySlot);
|
|
if( !pListGroupEmpty )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// assign the new offset
|
|
pListGroupEmpty->dwGroupOffset = dwOffset;
|
|
|
|
// append empty slot at the end of the list
|
|
// this need to be done at last to prevent some invalid
|
|
// object get on the list
|
|
pListGroup->dwNext = dwEmptySlot;
|
|
}
|
|
|
|
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
Cleanup:
|
|
return dwError;
|
|
}
|
|
|
|
DWORD
|
|
GroupMgr::RemoveFromGroupList(
|
|
DWORD dwHeadOffset,
|
|
DWORD dwOffset,
|
|
LPDWORD pdwNewHeadOffset
|
|
)
|
|
{
|
|
DWORD dwError = ERROR_SUCCESS;
|
|
LIST_GROUP_ENTRY* pListGroup = NULL;
|
|
LIST_GROUP_ENTRY* pListGroupPrev = NULL;
|
|
LPBYTE lpbBase = NULL;
|
|
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(dwHeadOffset);
|
|
if( !pListGroup )
|
|
{
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
goto Cleanup;
|
|
}
|
|
|
|
lpbBase = (LPBYTE) *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
|
|
// header is the one we need, we will have to assign new header
|
|
if( pListGroup->dwGroupOffset == dwOffset )
|
|
{
|
|
// new head
|
|
*pdwNewHeadOffset = pListGroup->dwNext;
|
|
|
|
// empty removed head and added to free list
|
|
pListGroup->dwGroupOffset = 0;
|
|
pListGroup->dwNext= 0;
|
|
AddToFreeList(pListGroup);
|
|
|
|
// done
|
|
dwError = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if( !pListGroup->dwNext )
|
|
{
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
goto Cleanup;
|
|
}
|
|
|
|
pListGroupPrev = pListGroup;
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(pListGroup->dwNext);
|
|
if( !pListGroup)
|
|
{
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
while( pListGroup )
|
|
{
|
|
INET_ASSERT(pListGroup->dwGroupOffset);
|
|
|
|
if( pListGroup->dwGroupOffset == dwOffset )
|
|
{
|
|
pListGroupPrev->dwNext = pListGroup->dwNext;
|
|
|
|
// empty removed item and added it to free list
|
|
pListGroup->dwGroupOffset = 0;
|
|
pListGroup->dwNext= 0;
|
|
AddToFreeList(pListGroup);
|
|
|
|
dwError = ERROR_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
if( pListGroup->dwNext )
|
|
{
|
|
pListGroupPrev = pListGroup;
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(pListGroup->dwNext);
|
|
}
|
|
else
|
|
{
|
|
dwError = ERROR_FILE_NOT_FOUND;
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
return dwError;
|
|
}
|
|
|
|
DWORD
|
|
GroupMgr::FindEmptySlotInListPage(DWORD* pdwOffsetToSlot)
|
|
{
|
|
|
|
DWORD dwError;
|
|
DWORD dwOffsetRoot = 0;
|
|
LPBYTE lpbBase = NULL;
|
|
LIST_GROUP_ENTRY* pListGroupFreeHead = NULL;
|
|
LIST_GROUP_ENTRY* pListGroupEmpty = NULL;
|
|
|
|
if( !GetHeaderData( CACHE_HEADER_DATA_ROOT_GROUPLIST_OFFSET, &dwOffsetRoot))
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if( !dwOffsetRoot)
|
|
{
|
|
// new page needs to be created
|
|
dwError = CreateNewListPage(&dwOffsetRoot, TRUE);
|
|
|
|
if( dwError != ERROR_SUCCESS)
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// At this point, we've got the root entry
|
|
// 1. retrieved valid dwOffsetToRootEntry or
|
|
// 2. get the new dwOffsetToRootEntry via CreateNewPage() call
|
|
//
|
|
INET_ASSERT( dwOffsetRoot);
|
|
|
|
lpbBase = (LPBYTE) *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
pListGroupFreeHead = (LIST_GROUP_ENTRY*) (lpbBase + dwOffsetRoot);
|
|
if( !pListGroupFreeHead )
|
|
{
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// BEGIN WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
// get the next free item from the list
|
|
if( !pListGroupFreeHead->dwNext )
|
|
{
|
|
// no free slot left!, let's create a new page!
|
|
|
|
// remember the old offset free list head entry
|
|
DWORD_PTR dwpFreeHeadOffset = PtrDifference(pListGroupFreeHead, lpbBase);
|
|
|
|
// create a new page
|
|
DWORD dwNewList;
|
|
dwError = CreateNewListPage(&dwNewList, FALSE);
|
|
|
|
if( dwError != ERROR_SUCCESS)
|
|
goto Cleanup;
|
|
|
|
// restore
|
|
lpbBase = (LPBYTE) *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
pListGroupFreeHead = (LIST_GROUP_ENTRY*) (lpbBase + dwpFreeHeadOffset);
|
|
//
|
|
// add the newly created page contains a list of empty
|
|
// slot (already chained together), now update the head
|
|
// of free list pointing to the head of the newly created
|
|
// list
|
|
//
|
|
pListGroupFreeHead->dwNext = dwNewList;
|
|
}
|
|
//////////////////////////////////////////////////////////////////
|
|
// END WARNING: The file might be grown and remapped, so all //
|
|
// pointers into the file before this point may be invalidated. //
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
|
|
// get the empty slot offset
|
|
*pdwOffsetToSlot = pListGroupFreeHead->dwNext;
|
|
|
|
// update the free list to point to the next slot
|
|
pListGroupEmpty = (LIST_GROUP_ENTRY*)(lpbBase + pListGroupFreeHead->dwNext);
|
|
pListGroupFreeHead->dwNext = pListGroupEmpty->dwNext;
|
|
|
|
memset(pListGroupEmpty, 0, sizeof(LIST_GROUP_ENTRY) );
|
|
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
Cleanup:
|
|
return dwError;
|
|
}
|
|
|
|
|
|
DWORD
|
|
GroupMgr::CreateNewListPage(DWORD* pdwOffsetToFirstEntry, BOOL fIsFirstPage)
|
|
{
|
|
DWORD dwError;
|
|
GROUPS_ALLOC_FILEMAP_ENTRY* pPage = NULL;
|
|
DWORD cbSize = sizeof(GROUPS_ALLOC_FILEMAP_ENTRY);
|
|
|
|
pPage = (GROUPS_ALLOC_FILEMAP_ENTRY*)
|
|
_pContainer->_UrlObjStorage->AllocateEntry(cbSize);
|
|
|
|
|
|
if( pPage )
|
|
{
|
|
// clean up allocated page
|
|
cbSize = PAGE_SIZE_FOR_GROUPS;
|
|
memset(pPage->pGroupBlock, 0, cbSize );
|
|
|
|
// calculate the group base offset
|
|
LPBYTE lpbBase = (LPBYTE) *_pContainer->_UrlObjStorage->GetHeapStart();
|
|
|
|
*pdwOffsetToFirstEntry = PtrDiff32(pPage->pGroupBlock, lpbBase);
|
|
|
|
//
|
|
// chain all items together
|
|
// (Last item will have dwNext == 0 since we have alredy memset
|
|
// the whole page )
|
|
//
|
|
LIST_GROUP_ENTRY* pList = (LIST_GROUP_ENTRY*) pPage->pGroupBlock;
|
|
|
|
for( DWORD dwi = 0; dwi < (LIST_GROUPS_PER_PAGE -1); dwi++)
|
|
{
|
|
pList->dwNext = PtrDiff32(pList+1, lpbBase);
|
|
pList++ ;
|
|
}
|
|
|
|
|
|
if( fIsFirstPage )
|
|
{
|
|
//
|
|
// for first page, we would have to set the offset
|
|
// back to the CacheHeader
|
|
//
|
|
if( !SetHeaderData(
|
|
CACHE_HEADER_DATA_ROOT_GROUPLIST_OFFSET,
|
|
*pdwOffsetToFirstEntry))
|
|
{
|
|
// free allocated page
|
|
_pContainer->_UrlObjStorage->FreeEntry(pPage);
|
|
|
|
// set error and go
|
|
*pdwOffsetToFirstEntry = 0;
|
|
dwError = ERROR_INTERNET_INTERNAL_ERROR;
|
|
goto Cleanup;
|
|
|
|
} // IF: failed to set the offset
|
|
}
|
|
|
|
// return the offset to the first entry of the new page
|
|
dwError = ERROR_SUCCESS;
|
|
|
|
} // IF: Allocate new page succeed
|
|
|
|
else
|
|
{
|
|
dwError = ERROR_NOT_ENOUGH_MEMORY;
|
|
} // ELSE: failed to allocate new page
|
|
|
|
Cleanup:
|
|
return dwError;
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
GroupMgr::IsGroupOnList(DWORD dwHeadOffset, DWORD dwGrpOffset)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
LIST_GROUP_ENTRY* pListGroup = NULL;
|
|
|
|
LIST_GROUP_ENTRY *pMilestone = NULL; // used for detecting cycles
|
|
unsigned long dwNodeCount = 1;
|
|
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(dwHeadOffset);
|
|
if( !pListGroup )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
while( pListGroup )
|
|
{
|
|
//INET_ASSERT(pListGroup->dwGroupOffset);
|
|
|
|
if( pListGroup->dwGroupOffset == dwGrpOffset )
|
|
{
|
|
fRet = TRUE;
|
|
break;
|
|
}
|
|
|
|
if( pListGroup->dwNext )
|
|
{
|
|
LIST_GROUP_ENTRY* plgTemp =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(
|
|
pListGroup->dwNext);
|
|
|
|
// Sometimes the list is corrupted and contains a cycle
|
|
// This is detected by comparing against the saved pointer
|
|
// (Revisiting an earlier milestone indicates a cycle)
|
|
if (plgTemp==pMilestone)
|
|
break;
|
|
|
|
// Also check (and fix) simple self-loops
|
|
if (plgTemp==pListGroup)
|
|
{
|
|
pListGroup->dwNext = 0;
|
|
break;
|
|
}
|
|
|
|
// Advance to next node
|
|
pListGroup = plgTemp;
|
|
|
|
// Choose new milestone when node count is power of 2
|
|
dwNodeCount++;
|
|
|
|
if ((dwNodeCount & (dwNodeCount-1)) == 0)
|
|
pMilestone = pListGroup;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
return fRet;
|
|
}
|
|
|
|
|
|
BOOL
|
|
GroupMgr::NoMoreStickyEntryOnList(DWORD dwHeadOffset)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
LIST_GROUP_ENTRY* pListGroup = NULL;
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(dwHeadOffset);
|
|
if( !pListGroup )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
while( pListGroup )
|
|
{
|
|
//INET_ASSERT(pListGroup->dwGroupOffset);
|
|
|
|
// get the GroupEntry structure
|
|
if( !_pContainer->_UrlObjStorage->IsBadGroupOffset(
|
|
pListGroup->dwGroupOffset) )
|
|
{
|
|
pGroupEntry = (GROUP_ENTRY*)
|
|
( *_pContainer->_UrlObjStorage->GetHeapStart() +
|
|
pListGroup->dwGroupOffset );
|
|
|
|
// IsSticky?
|
|
if( IsStickyGroup(pGroupEntry->gid) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
|
|
// end of list
|
|
if( !pListGroup->dwNext )
|
|
{
|
|
break;
|
|
}
|
|
|
|
// next item on list
|
|
pListGroup = _pContainer->_UrlObjStorage->ValidateListGroupOffset(
|
|
pListGroup->dwNext);
|
|
}
|
|
|
|
//
|
|
// reach here means we are at end of the list and can not find
|
|
// any sticky group, return TRUE
|
|
//
|
|
fRet = TRUE;
|
|
|
|
Cleanup:
|
|
return fRet;
|
|
|
|
|
|
}
|
|
|
|
|
|
void
|
|
GroupMgr::AdjustUsageOnList(DWORD dwHeadOffset, LONGLONG llDelta)
|
|
{
|
|
LIST_GROUP_ENTRY* pListGroup = NULL;
|
|
GROUP_ENTRY* pGroupEntry = NULL;
|
|
|
|
pListGroup =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(dwHeadOffset);
|
|
if( !pListGroup )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
while( pListGroup )
|
|
{
|
|
// INET_ASSERT(pListGroup->dwGroupOffset);
|
|
|
|
// get the GroupEntry structure
|
|
if( !_pContainer->_UrlObjStorage->IsBadGroupOffset(
|
|
pListGroup->dwGroupOffset) )
|
|
{
|
|
pGroupEntry = (GROUP_ENTRY*)
|
|
( *_pContainer->_UrlObjStorage->GetHeapStart() +
|
|
pListGroup->dwGroupOffset );
|
|
|
|
// AdjustUsage
|
|
_pContainer->AdjustGroupUsage(pGroupEntry, llDelta);
|
|
}
|
|
|
|
|
|
// end of list
|
|
if( !pListGroup->dwNext )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
// next item on list
|
|
pListGroup = _pContainer->_UrlObjStorage->ValidateListGroupOffset(
|
|
pListGroup->dwNext);
|
|
}
|
|
|
|
Cleanup:
|
|
return;
|
|
|
|
}
|
|
|
|
void
|
|
GroupMgr::AddToFreeList(LIST_GROUP_ENTRY* pFreeListGroup)
|
|
{
|
|
DWORD dwOffsetRoot = 0;
|
|
LIST_GROUP_ENTRY* pFreeListHead = NULL;
|
|
|
|
if( GetHeaderData( CACHE_HEADER_DATA_ROOT_GROUPLIST_OFFSET, &dwOffsetRoot))
|
|
{
|
|
|
|
pFreeListHead =
|
|
_pContainer->_UrlObjStorage->ValidateListGroupOffset(dwOffsetRoot);
|
|
|
|
if( pFreeListHead && pFreeListGroup )
|
|
{
|
|
pFreeListGroup->dwNext = pFreeListHead->dwNext;
|
|
|
|
pFreeListHead->dwNext = PtrDiff32(pFreeListGroup,
|
|
*_pContainer->_UrlObjStorage->GetHeapStart());
|
|
}
|
|
}
|
|
return;
|
|
}
|