wininet: Rename URLCACHE_HEADER to urlcache_header.

2024-09-14 20:05:41 +00:00 · 2013-03-26 09:52:40 +01:00 · 2013-03-26 09:52:40 +01:00 · 39daf43ce3
parent d7ab4d74fe
commit 39daf43ce3
1 changed files with 128 additions and 131 deletions
--- a/dlls/wininet/urlcache.c
+++ b/dlls/wininet/urlcache.c
@ -157,29 +157,26 @@ typedef struct
    struct hash_entry hash_table[HASHTABLE_SIZE];
 } entry_hash_table;

-typedef struct _DIRECTORY_DATA
+typedef struct
 {
-    DWORD dwNumFiles;
-    char filename[DIR_LENGTH];
-} DIRECTORY_DATA;
-
-typedef struct _URLCACHE_HEADER
-{
-    char szSignature[28];
-    DWORD dwFileSize;
-    DWORD dwOffsetFirstHashTable;
-    DWORD dwIndexCapacityInBlocks;
-    DWORD dwBlocksInUse;
-    DWORD dwUnknown1;
-    ULARGE_INTEGER CacheLimit;
-    ULARGE_INTEGER CacheUsage;
-    ULARGE_INTEGER ExemptUsage;
-    DWORD DirectoryCount;
-    DIRECTORY_DATA directory_data[MAX_DIR_NO];
+    char signature[28];
+    DWORD size;
+    DWORD hash_table_off;
+    DWORD capacity_in_blocks;
+    DWORD blocks_in_use;
+    DWORD unk1;
+    ULARGE_INTEGER cache_limit;
+    ULARGE_INTEGER cache_usage;
+    ULARGE_INTEGER exempt_usage;
+    DWORD dirs_no;
+    struct _directory_data
+    {
+        DWORD files_no;
+        char name[DIR_LENGTH];
+    } directory_data[MAX_DIR_NO];
    DWORD options[0x21];
    BYTE allocation_table[ALLOCATION_TABLE_SIZE];
-} URLCACHE_HEADER, *LPURLCACHE_HEADER;
-typedef const URLCACHE_HEADER *LPCURLCACHE_HEADER;
+} urlcache_header;

 typedef struct _STREAM_HANDLE
 {
@ -202,7 +199,7 @@ typedef struct _URLCACHECONTAINER
 /* List of all containers available */
 static struct list UrlContainers = LIST_INIT(UrlContainers);

-static DWORD URLCache_CreateHashTable(LPURLCACHE_HEADER pHeader, entry_hash_table *pPrevHash, entry_hash_table **ppHash);
+static DWORD URLCache_CreateHashTable(urlcache_header *pHeader, entry_hash_table *pPrevHash, entry_hash_table **ppHash);

 /***********************************************************************
 *           URLCache_PathToObjectName (Internal)
@ -258,7 +255,7 @@ static DWORD cache_container_set_size(URLCACHECONTAINER *container, HANDLE file,
    DWORD file_size = FILE_SIZE(blocks_no);
    WCHAR dir_path[MAX_PATH], *dir_name;
    entry_hash_table *hashtable_entry;
-    URLCACHE_HEADER *header;
+    urlcache_header *header;
    HANDLE mapping;
    FILETIME ft;
    HKEY key;
@ -281,10 +278,10 @@ static DWORD cache_container_set_size(URLCACHECONTAINER *container, HANDLE file,
    }

    if(blocks_no != MIN_BLOCK_NO) {
-        if(file_size > header->dwFileSize)
-            memset((char*)header+header->dwFileSize, 0, file_size-header->dwFileSize);
-        header->dwFileSize = file_size;
-        header->dwIndexCapacityInBlocks = blocks_no;
+        if(file_size > header->size)
+            memset((char*)header+header->size, 0, file_size-header->size);
+        header->size = file_size;
+        header->capacity_in_blocks = blocks_no;

        UnmapViewOfFile(header);
        CloseHandle(container->hMapping);
@ -295,14 +292,14 @@ static DWORD cache_container_set_size(URLCACHECONTAINER *container, HANDLE file,

    memset(header, 0, file_size);
    /* First set some constants and defaults in the header */
-    memcpy(header->szSignature, urlcache_ver_prefix, sizeof(urlcache_ver_prefix)-1);
-    memcpy(header->szSignature+sizeof(urlcache_ver_prefix)-1, urlcache_ver, sizeof(urlcache_ver)-1);
-    header->dwFileSize = file_size;
-    header->dwIndexCapacityInBlocks = blocks_no;
+    memcpy(header->signature, urlcache_ver_prefix, sizeof(urlcache_ver_prefix)-1);
+    memcpy(header->signature+sizeof(urlcache_ver_prefix)-1, urlcache_ver, sizeof(urlcache_ver)-1);
+    header->size = file_size;
+    header->capacity_in_blocks = blocks_no;
    /* 127MB - taken from default for Windows 2000 */
-    header->CacheLimit.QuadPart = 0x07ff5400;
+    header->cache_limit.QuadPart = 0x07ff5400;
    /* Copied from a Windows 2000 cache index */
-    header->DirectoryCount = container->default_entry_type==NORMAL_CACHE_ENTRY ? 4 : 0;
+    header->dirs_no = container->default_entry_type==NORMAL_CACHE_ENTRY ? 4 : 0;

    /* If the registry has a cache size set, use the registry value */
    if(RegOpenKeyW(HKEY_CURRENT_USER, cache_content_key, &key) == ERROR_SUCCESS) {
@ -310,7 +307,7 @@ static DWORD cache_container_set_size(URLCACHECONTAINER *container, HANDLE file,

        if(RegQueryValueExW(key, cache_limit, NULL, &keytype, (BYTE*)&dw, &len) == ERROR_SUCCESS &&
                keytype == REG_DWORD)
-            header->CacheLimit.QuadPart = (ULONGLONG)dw * 1024;
+            header->cache_limit.QuadPart = (ULONGLONG)dw * 1024;
        RegCloseKey(key);
    }

@ -323,8 +320,8 @@ static DWORD cache_container_set_size(URLCACHECONTAINER *container, HANDLE file,

    GetSystemTimeAsFileTime(&ft);

-    for(i=0; i<header->DirectoryCount; ++i) {
-        header->directory_data[i].dwNumFiles = 0;
+    for(i=0; i<header->dirs_no; ++i) {
+        header->directory_data[i].files_no = 0;
        for(j=0;; ++j) {
            ULONGLONG n = ft.dwHighDateTime;
            int k;
@ -359,7 +356,7 @@ static DWORD cache_container_set_size(URLCACHECONTAINER *container, HANDLE file,
                 * pages and for UTF-16
                 */
                for (k = 0; k < 8; ++k)
-                    header->directory_data[i].filename[k] = dir_name[k];
+                    header->directory_data[i].name[k] = dir_name[k];
                break;
            }else if(j >= 255) {
                /* Give up. The most likely cause of this
@ -381,31 +378,31 @@ static DWORD cache_container_set_size(URLCACHECONTAINER *container, HANDLE file,
    return ERROR_SUCCESS;
 }

-static BOOL cache_container_is_valid(URLCACHE_HEADER *header, DWORD file_size)
+static BOOL cache_container_is_valid(urlcache_header *header, DWORD file_size)
 {
    DWORD allocation_size, count_bits, i;

    if(file_size < FILE_SIZE(MIN_BLOCK_NO))
        return FALSE;

-    if(file_size != header->dwFileSize)
+    if(file_size != header->size)
        return FALSE;

-    if (!memcmp(header->szSignature, urlcache_ver_prefix, sizeof(urlcache_ver_prefix)-1) &&
-            memcmp(header->szSignature+sizeof(urlcache_ver_prefix)-1, urlcache_ver, sizeof(urlcache_ver)-1))
+    if (!memcmp(header->signature, urlcache_ver_prefix, sizeof(urlcache_ver_prefix)-1) &&
+            memcmp(header->signature+sizeof(urlcache_ver_prefix)-1, urlcache_ver, sizeof(urlcache_ver)-1))
        return FALSE;

-    if(FILE_SIZE(header->dwIndexCapacityInBlocks) != file_size)
+    if(FILE_SIZE(header->capacity_in_blocks) != file_size)
        return FALSE;

    allocation_size = 0;
-    for(i=0; i<header->dwIndexCapacityInBlocks/8; i++) {
+    for(i=0; i<header->capacity_in_blocks/8; i++) {
        for(count_bits = header->allocation_table[i]; count_bits!=0; count_bits>>=1) {
            if(count_bits & 1)
                allocation_size++;
        }
    }
-    if(allocation_size != header->dwBlocksInUse)
+    if(allocation_size != header->blocks_in_use)
        return FALSE;

    for(; i<ALLOCATION_TABLE_SIZE; i++) {
@ -480,7 +477,7 @@ static DWORD cache_container_open_index(URLCACHECONTAINER *container, DWORD bloc
    container->hMapping = cache_container_map_index(file, container->path, file_size, &validate);
    CloseHandle(file);
    if(container->hMapping && validate) {
-        URLCACHE_HEADER *header = MapViewOfFile(container->hMapping, FILE_MAP_WRITE, 0, 0, 0);
+        urlcache_header *header = MapViewOfFile(container->hMapping, FILE_MAP_WRITE, 0, 0, 0);

        if(header && !cache_container_is_valid(header, file_size)) {
            WARN("detected old or broken index.dat file\n");
@ -727,11 +724,11 @@ static BOOL URLCacheContainers_Enum(LPCWSTR lpwszSearchPattern, DWORD dwIndex, U
 *  Cache file header if successful
 *  NULL if failed and calls SetLastError.
 */
-static LPURLCACHE_HEADER cache_container_lock_index(URLCACHECONTAINER * pContainer)
+static urlcache_header* cache_container_lock_index(URLCACHECONTAINER * pContainer)
 {
    BYTE index;
    LPVOID pIndexData;
-    URLCACHE_HEADER * pHeader;
+    urlcache_header* pHeader;
    DWORD error;

    /* acquire mutex */
@ -745,12 +742,12 @@ static LPURLCACHE_HEADER cache_container_lock_index(URLCACHECONTAINER * pContain
        ERR("Couldn't MapViewOfFile. Error: %d\n", GetLastError());
        return NULL;
    }
-    pHeader = (URLCACHE_HEADER *)pIndexData;
+    pHeader = (urlcache_header*)pIndexData;

    /* file has grown - we need to remap to prevent us getting
     * access violations when we try and access beyond the end
     * of the memory mapped file */
-    if (pHeader->dwFileSize != pContainer->file_size)
+    if (pHeader->size != pContainer->file_size)
    {
        UnmapViewOfFile( pHeader );
        cache_container_close_index(pContainer);
@ -769,14 +766,14 @@ static LPURLCACHE_HEADER cache_container_lock_index(URLCACHECONTAINER * pContain
            ERR("Couldn't MapViewOfFile. Error: %d\n", GetLastError());
            return NULL;
        }
-        pHeader = (URLCACHE_HEADER *)pIndexData;
+        pHeader = (urlcache_header*)pIndexData;
    }

-    TRACE("Signature: %s, file size: %d bytes\n", pHeader->szSignature, pHeader->dwFileSize);
+    TRACE("Signature: %s, file size: %d bytes\n", pHeader->signature, pHeader->size);

-    for (index = 0; index < pHeader->DirectoryCount; index++)
+    for (index = 0; index < pHeader->dirs_no; index++)
    {
-        TRACE("Directory[%d] = \"%.8s\"\n", index, pHeader->directory_data[index].filename);
+        TRACE("Directory[%d] = \"%.8s\"\n", index, pHeader->directory_data[index].name);
    }
    
    return pHeader;
@ -786,7 +783,7 @@ static LPURLCACHE_HEADER cache_container_lock_index(URLCACHECONTAINER * pContain
 *           cache_container_unlock_index (Internal)
 *
 */
-static BOOL cache_container_unlock_index(URLCACHECONTAINER * pContainer, LPURLCACHE_HEADER pHeader)
+static BOOL cache_container_unlock_index(URLCACHECONTAINER * pContainer, urlcache_header *pHeader)
 {
    /* release mutex */
    ReleaseMutex(pContainer->hMutex);
@ -860,15 +857,15 @@ static inline void URLCache_Allocation_BlockAllocate(BYTE * AllocationTable, DWO
 *    Any other Win32 error code if the entry could not be added
 *
 */
-static DWORD URLCache_FindFirstFreeEntry(URLCACHE_HEADER * pHeader, DWORD dwBlocksNeeded, entry_header **ppEntry)
+static DWORD URLCache_FindFirstFreeEntry(urlcache_header *pHeader, DWORD dwBlocksNeeded, entry_header **ppEntry)
 {
    DWORD dwBlockNumber;
    DWORD dwFreeCounter;
-    for (dwBlockNumber = 0; dwBlockNumber < pHeader->dwIndexCapacityInBlocks; dwBlockNumber++)
+    for (dwBlockNumber = 0; dwBlockNumber < pHeader->capacity_in_blocks; dwBlockNumber++)
    {
        for (dwFreeCounter = 0; 
            dwFreeCounter < dwBlocksNeeded &&
-              dwFreeCounter + dwBlockNumber < pHeader->dwIndexCapacityInBlocks &&
+              dwFreeCounter + dwBlockNumber < pHeader->capacity_in_blocks &&
              URLCache_Allocation_BlockIsFree(pHeader->allocation_table, dwBlockNumber + dwFreeCounter);
            dwFreeCounter++)
                TRACE("Found free block at no. %d (0x%x)\n", dwBlockNumber, ENTRY_START_OFFSET + dwBlockNumber * BLOCKSIZE);
@ -883,7 +880,7 @@ static DWORD URLCache_FindFirstFreeEntry(URLCACHE_HEADER * pHeader, DWORD dwBloc
            for (index = 0; index < dwBlocksNeeded * BLOCKSIZE / sizeof(DWORD); index++)
                ((DWORD*)*ppEntry)[index] = 0xdeadbeef;
            (*ppEntry)->blocks_used = dwBlocksNeeded;
-            pHeader->dwBlocksInUse += dwBlocksNeeded;
+            pHeader->blocks_in_use += dwBlocksNeeded;
            return ERROR_SUCCESS;
        }
    }
@ -901,7 +898,7 @@ static DWORD URLCache_FindFirstFreeEntry(URLCACHE_HEADER * pHeader, DWORD dwBloc
 *    FALSE if it failed
 *
 */
-static BOOL URLCache_DeleteEntry(LPURLCACHE_HEADER pHeader, entry_header *pEntry)
+static BOOL URLCache_DeleteEntry(urlcache_header *pHeader, entry_header *pEntry)
 {
    DWORD dwStartBlock;
    DWORD dwBlock;
@ -911,7 +908,7 @@ static BOOL URLCache_DeleteEntry(LPURLCACHE_HEADER pHeader, entry_header *pEntry
    for (dwBlock = dwStartBlock; dwBlock < dwStartBlock + pEntry->blocks_used; dwBlock++)
        URLCache_Allocation_BlockFree(pHeader->allocation_table, dwBlock);

-    pHeader->dwBlocksInUse -= pEntry->blocks_used;
+    pHeader->blocks_in_use -= pEntry->blocks_used;
    return TRUE;
 }

@ -929,7 +926,7 @@ static BOOL URLCache_DeleteEntry(LPURLCACHE_HEADER pHeader, entry_header *pEntry
 */
 static BOOL URLCache_LocalFileNameToPathW(
    const URLCACHECONTAINER * pContainer,
-    LPCURLCACHE_HEADER pHeader,
+    const urlcache_header *pHeader,
    LPCSTR szLocalFileName,
    BYTE Directory,
    LPWSTR wszPath,
@ -938,7 +935,7 @@ static BOOL URLCache_LocalFileNameToPathW(
    LONG nRequired;
    int path_len = strlenW(pContainer->path);
    int file_name_len = MultiByteToWideChar(CP_ACP, 0, szLocalFileName, -1, NULL, 0);
-    if (Directory!=CACHE_CONTAINER_NO_SUBDIR && Directory>=pHeader->DirectoryCount)
+    if (Directory!=CACHE_CONTAINER_NO_SUBDIR && Directory>=pHeader->dirs_no)
    {
        *lpBufferSize = 0;
        return FALSE;
@ -954,7 +951,7 @@ static BOOL URLCache_LocalFileNameToPathW(
        memcpy(wszPath, pContainer->path, path_len * sizeof(WCHAR));
        if (Directory != CACHE_CONTAINER_NO_SUBDIR)
        {
-            dir_len = MultiByteToWideChar(CP_ACP, 0, pHeader->directory_data[Directory].filename, DIR_LENGTH, wszPath + path_len, DIR_LENGTH);
+            dir_len = MultiByteToWideChar(CP_ACP, 0, pHeader->directory_data[Directory].name, DIR_LENGTH, wszPath + path_len, DIR_LENGTH);
            wszPath[dir_len + path_len] = '\\';
            dir_len++;
        }
@ -984,7 +981,7 @@ static BOOL URLCache_LocalFileNameToPathW(
 */
 static BOOL URLCache_LocalFileNameToPathA(
    const URLCACHECONTAINER * pContainer,
-    LPCURLCACHE_HEADER pHeader,
+    const urlcache_header *pHeader,
    LPCSTR szLocalFileName,
    BYTE Directory,
    LPSTR szPath,
@ -993,7 +990,7 @@ static BOOL URLCache_LocalFileNameToPathA(
    LONG nRequired;
    int path_len, file_name_len, dir_len;

-    if (Directory!=CACHE_CONTAINER_NO_SUBDIR && Directory>=pHeader->DirectoryCount)
+    if (Directory!=CACHE_CONTAINER_NO_SUBDIR && Directory>=pHeader->dirs_no)
    {
        *lpBufferSize = 0;
        return FALSE;
@ -1011,7 +1008,7 @@ static BOOL URLCache_LocalFileNameToPathA(
    {
        WideCharToMultiByte(CP_ACP, 0, pContainer->path, -1, szPath, path_len, NULL, NULL);
        if(dir_len) {
-            memcpy(szPath+path_len, pHeader->directory_data[Directory].filename, dir_len-1);
+            memcpy(szPath+path_len, pHeader->directory_data[Directory].name, dir_len-1);
            szPath[path_len + dir_len-1] = '\\';
        }
        memcpy(szPath + path_len + dir_len, szLocalFileName, file_name_len);
@ -1038,7 +1035,7 @@ static void URLCache_FileTimeToDosDateTime(const FILETIME *ft, WORD *fatdate,
 *           URLCache_DeleteFile (Internal)
 */
 static DWORD URLCache_DeleteFile(const URLCACHECONTAINER *container,
-        URLCACHE_HEADER *header, entry_url *url_entry)
+        urlcache_header *header, entry_url *url_entry)
 {
    WIN32_FILE_ATTRIBUTE_DATA attr;
    WCHAR path[MAX_PATH];
@ -1065,30 +1062,30 @@ static DWORD URLCache_DeleteFile(const URLCACHECONTAINER *container,
        return err;

 succ:
-    if (url_entry->cache_dir < header->DirectoryCount)
+    if (url_entry->cache_dir < header->dirs_no)
    {
-        if (header->directory_data[url_entry->cache_dir].dwNumFiles)
-            header->directory_data[url_entry->cache_dir].dwNumFiles--;
+        if (header->directory_data[url_entry->cache_dir].files_no)
+            header->directory_data[url_entry->cache_dir].files_no--;
    }
    if (url_entry->cache_entry_type & STICKY_CACHE_ENTRY)
    {
-        if (url_entry->size.QuadPart < header->ExemptUsage.QuadPart)
-            header->ExemptUsage.QuadPart -= url_entry->size.QuadPart;
+        if (url_entry->size.QuadPart < header->exempt_usage.QuadPart)
+            header->exempt_usage.QuadPart -= url_entry->size.QuadPart;
        else
-            header->ExemptUsage.QuadPart = 0;
+            header->exempt_usage.QuadPart = 0;
    }
    else
    {
-        if (url_entry->size.QuadPart < header->CacheUsage.QuadPart)
-            header->CacheUsage.QuadPart -= url_entry->size.QuadPart;
+        if (url_entry->size.QuadPart < header->cache_usage.QuadPart)
+            header->cache_usage.QuadPart -= url_entry->size.QuadPart;
        else
-            header->CacheUsage.QuadPart = 0;
+            header->cache_usage.QuadPart = 0;
    }

    return ERROR_SUCCESS;
 }

-static BOOL urlcache_clean_leaked_entries(URLCACHECONTAINER *container, URLCACHE_HEADER *header)
+static BOOL urlcache_clean_leaked_entries(URLCACHECONTAINER *container, urlcache_header *header)
 {
    DWORD *leak_off;
    BOOL freed = FALSE;
@ -1121,9 +1118,9 @@ static BOOL urlcache_clean_leaked_entries(URLCACHECONTAINER *container, URLCACHE
 *     ERROR_SUCCESS when new memory is available
 *     error code otherwise
 */
-static DWORD cache_container_clean_index(URLCACHECONTAINER *container, URLCACHE_HEADER **file_view)
+static DWORD cache_container_clean_index(URLCACHECONTAINER *container, urlcache_header **file_view)
 {
-    URLCACHE_HEADER *header = *file_view;
+    urlcache_header *header = *file_view;
    DWORD ret;

    TRACE("(%s %s)\n", debugstr_w(container->cache_prefix), debugstr_w(container->path));
@ -1131,13 +1128,13 @@ static DWORD cache_container_clean_index(URLCACHECONTAINER *container, URLCACHE_
    if(urlcache_clean_leaked_entries(container, header))
        return ERROR_SUCCESS;

-    if(header->dwFileSize >= ALLOCATION_TABLE_SIZE*8*BLOCKSIZE + ENTRY_START_OFFSET) {
+    if(header->size >= ALLOCATION_TABLE_SIZE*8*BLOCKSIZE + ENTRY_START_OFFSET) {
        WARN("index file has maximal size\n");
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    cache_container_close_index(container);
-    ret = cache_container_open_index(container, header->dwIndexCapacityInBlocks*2);
+    ret = cache_container_open_index(container, header->capacity_in_blocks*2);
    if(ret != ERROR_SUCCESS)
        return ret;
    header = MapViewOfFile(container->hMapping, FILE_MAP_WRITE, 0, 0, 0);
@ -1173,7 +1170,7 @@ static void URLCache_DosDateTimeToFileTime(WORD fatdate, WORD fattime,
 */
 static DWORD URLCache_CopyEntry(
    URLCACHECONTAINER * pContainer,
-    LPCURLCACHE_HEADER pHeader, 
+    const urlcache_header *pHeader,
    LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, 
    LPDWORD lpdwBufferSize, 
    const entry_url * pUrlEntry,
@ -1386,19 +1383,19 @@ static DWORD URLCache_HashKey(LPCSTR lpszKey)
    return *(DWORD *)key;
 }

-static inline entry_hash_table* URLCache_HashEntryFromOffset(LPCURLCACHE_HEADER pHeader, DWORD dwOffset)
+static inline entry_hash_table* URLCache_HashEntryFromOffset(const urlcache_header *pHeader, DWORD dwOffset)
 {
    return (entry_hash_table*)((LPBYTE)pHeader + dwOffset);
 }

-static inline BOOL URLCache_IsHashEntryValid(LPCURLCACHE_HEADER pHeader, const entry_hash_table *pHashEntry)
+static inline BOOL URLCache_IsHashEntryValid(const urlcache_header *pHeader, const entry_hash_table *pHashEntry)
 {
    /* check pHashEntry located within acceptable bounds in the URL cache mapping */
    return ((DWORD)((const BYTE*)pHashEntry - (const BYTE*)pHeader) >= ENTRY_START_OFFSET) &&
-           ((DWORD)((const BYTE*)pHashEntry - (const BYTE*)pHeader) < pHeader->dwFileSize);
+           ((DWORD)((const BYTE*)pHashEntry - (const BYTE*)pHeader) < pHeader->size);
 }

-static BOOL URLCache_FindHash(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl, struct hash_entry **ppHashEntry)
+static BOOL URLCache_FindHash(const urlcache_header *pHeader, LPCSTR lpszUrl, struct hash_entry **ppHashEntry)
 {
    /* structure of hash table:
     *  448 entries divided into 64 blocks
@ -1419,7 +1416,7 @@ static BOOL URLCache_FindHash(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl, struct

    key >>= HASHTABLE_FLAG_BITS;

-    for (pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->dwOffsetFirstHashTable);
+    for (pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->hash_table_off);
         URLCache_IsHashEntryValid(pHeader, pHashEntry);
         pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHashEntry->next))
    {
@ -1455,7 +1452,7 @@ static BOOL URLCache_FindHash(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl, struct
    return FALSE;
 }

-static BOOL URLCache_FindHashW(LPCURLCACHE_HEADER pHeader, LPCWSTR lpszUrl, struct hash_entry **ppHashEntry)
+static BOOL URLCache_FindHashW(const urlcache_header *pHeader, LPCWSTR lpszUrl, struct hash_entry **ppHashEntry)
 {
    LPSTR urlA;
    BOOL ret;
@ -1515,7 +1512,7 @@ static BOOL URLCache_DeleteEntryFromHash(struct hash_entry *pHashEntry)
 *    Any other Win32 error code if the entry could not be added
 *
 */
-static DWORD URLCache_AddEntryToHash(LPURLCACHE_HEADER pHeader, LPCSTR lpszUrl, DWORD dwOffsetEntry, DWORD dwFieldType)
+static DWORD URLCache_AddEntryToHash(urlcache_header *pHeader, LPCSTR lpszUrl, DWORD dwOffsetEntry, DWORD dwFieldType)
 {
    /* see URLCache_FindEntryInHash for structure of hash tables */

@ -1527,7 +1524,7 @@ static DWORD URLCache_AddEntryToHash(LPURLCACHE_HEADER pHeader, LPCSTR lpszUrl,

    key = ((key >> HASHTABLE_FLAG_BITS) << HASHTABLE_FLAG_BITS) + dwFieldType;

-    for (pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->dwOffsetFirstHashTable);
+    for (pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->hash_table_off);
         URLCache_IsHashEntryValid(pHeader, pHashEntry);
         pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHashEntry->next))
    {
@ -1577,7 +1574,7 @@ static DWORD URLCache_AddEntryToHash(LPURLCACHE_HEADER pHeader, LPCSTR lpszUrl,
 *    ERROR_DISK_FULL if the hash table could not be created
 *
 */
-static DWORD URLCache_CreateHashTable(LPURLCACHE_HEADER pHeader, entry_hash_table *pPrevHash, entry_hash_table **ppHash)
+static DWORD URLCache_CreateHashTable(urlcache_header *pHeader, entry_hash_table *pPrevHash, entry_hash_table **ppHash)
 {
    DWORD dwOffset, error;
    int i;
@ -1590,7 +1587,7 @@ static DWORD URLCache_CreateHashTable(LPURLCACHE_HEADER pHeader, entry_hash_tabl
    if (pPrevHash)
        pPrevHash->next = dwOffset;
    else
-        pHeader->dwOffsetFirstHashTable = dwOffset;
+        pHeader->hash_table_off = dwOffset;
    (*ppHash)->header.signature = HASH_SIGNATURE;
    (*ppHash)->header.blocks_used = 0x20;
    (*ppHash)->next = 0;
@ -1613,9 +1610,9 @@ static DWORD URLCache_CreateHashTable(LPURLCACHE_HEADER pHeader, entry_hash_tabl
 *    FALSE if there are no more tables to enumerate.
 *
 */
-static BOOL URLCache_EnumHashTables(LPCURLCACHE_HEADER pHeader, DWORD *id, entry_hash_table **ppHashEntry)
+static BOOL URLCache_EnumHashTables(const urlcache_header *pHeader, DWORD *id, entry_hash_table **ppHashEntry)
 {
-    for (*ppHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->dwOffsetFirstHashTable);
+    for (*ppHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->hash_table_off);
         URLCache_IsHashEntryValid(pHeader, *ppHashEntry);
         *ppHashEntry = URLCache_HashEntryFromOffset(pHeader, (*ppHashEntry)->next))
    {
@ -1647,7 +1644,7 @@ static BOOL URLCache_EnumHashTables(LPCURLCACHE_HEADER pHeader, DWORD *id, entry
 *     enumerate.
 *
 */
-static BOOL URLCache_EnumHashTableEntries(LPCURLCACHE_HEADER pHeader, const entry_hash_table *pHashEntry,
+static BOOL URLCache_EnumHashTableEntries(const urlcache_header *pHeader, const entry_hash_table *pHashEntry,
                                          DWORD * index, const struct hash_entry **ppHashEntry)
 {
    for (; *index < HASHTABLE_SIZE ; (*index)++)
@ -1742,7 +1739,7 @@ BOOL WINAPI GetUrlCacheEntryInfoExA(
    LPVOID lpReserved,
    DWORD dwFlags)
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    const entry_header *pEntry;
    const entry_url * pUrlEntry;
@ -1882,7 +1879,7 @@ BOOL WINAPI GetUrlCacheEntryInfoExW(
    LPVOID lpReserved,
    DWORD dwFlags)
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    const entry_header *pEntry;
    const entry_url * pUrlEntry;
@ -1987,7 +1984,7 @@ BOOL WINAPI SetUrlCacheEntryInfoA(
    LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
    DWORD dwFieldControl)
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    entry_header *pEntry;
    URLCACHECONTAINER * pContainer;
@ -2044,7 +2041,7 @@ BOOL WINAPI SetUrlCacheEntryInfoA(
 */
 BOOL WINAPI SetUrlCacheEntryInfoW(LPCWSTR lpszUrl, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, DWORD dwFieldControl)
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    entry_header *pEntry;
    URLCACHECONTAINER * pContainer;
@ -2107,7 +2104,7 @@ BOOL WINAPI RetrieveUrlCacheEntryFileA(
    IN DWORD dwReserved
    )
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    entry_header *pEntry;
    entry_url * pUrlEntry;
@ -2205,7 +2202,7 @@ BOOL WINAPI RetrieveUrlCacheEntryFileW(
    IN DWORD dwReserved
    )
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    entry_header *pEntry;
    entry_url * pUrlEntry;
@ -2297,7 +2294,7 @@ BOOL WINAPI RetrieveUrlCacheEntryFileW(
 }

 static BOOL DeleteUrlCacheEntryInternal(const URLCACHECONTAINER * pContainer,
-        LPURLCACHE_HEADER pHeader, struct hash_entry *pHashEntry)
+        urlcache_header *pHeader, struct hash_entry *pHashEntry)
 {
    entry_header *pEntry;
    entry_url * pUrlEntry;
@ -2354,7 +2351,7 @@ static void handle_full_cache(void)
 }

 /* Enumerates entries in cache, allows cache unlocking between calls. */
-static BOOL urlcache_next_entry(URLCACHE_HEADER *header, DWORD *hash_table_off, DWORD *hash_table_entry,
+static BOOL urlcache_next_entry(urlcache_header *header, DWORD *hash_table_off, DWORD *hash_table_entry,
        struct hash_entry **hash_entry, entry_header **entry)
 {
    entry_hash_table *hashtable_entry;
@ -2363,12 +2360,12 @@ static BOOL urlcache_next_entry(URLCACHE_HEADER *header, DWORD *hash_table_off,
    *entry = NULL;

    if(!*hash_table_off) {
-        *hash_table_off = header->dwOffsetFirstHashTable;
+        *hash_table_off = header->hash_table_off;
        *hash_table_entry = 0;

        hashtable_entry = URLCache_HashEntryFromOffset(header, *hash_table_off);
    }else {
-        if(*hash_table_off >= header->dwFileSize) {
+        if(*hash_table_off >= header->size) {
            *hash_table_off = 0;
            return FALSE;
        }
@ -2517,7 +2514,7 @@ BOOL WINAPI FreeUrlCacheSpaceW(LPCWSTR cache_path, DWORD size, DWORD filter)

    LIST_FOR_EACH_ENTRY(container, &UrlContainers, URLCACHECONTAINER, entry)
    {
-        URLCACHE_HEADER *header;
+        urlcache_header *header;
        struct hash_entry *hash_entry;
        entry_header *entry;
        entry_url *url_entry;
@ -2541,8 +2538,8 @@ BOOL WINAPI FreeUrlCacheSpaceW(LPCWSTR cache_path, DWORD size, DWORD filter)

        urlcache_clean_leaked_entries(container, header);

-        desired_size = header->CacheLimit.QuadPart*(100-size)/100;
-        cur_size = header->CacheUsage.QuadPart+header->ExemptUsage.QuadPart;
+        desired_size = header->cache_limit.QuadPart*(100-size)/100;
+        cur_size = header->cache_usage.QuadPart+header->exempt_usage.QuadPart;
        if(cur_size <= desired_size)
            delete_factor = 0;
        else
@ -2598,7 +2595,7 @@ BOOL WINAPI FreeUrlCacheSpaceW(LPCWSTR cache_path, DWORD size, DWORD filter)
                TRACE("deleting file: %s\n", debugstr_a((char*)url_entry+url_entry->local_name_off));
                DeleteUrlCacheEntryInternal(container, header, hash_entry);

-                if(header->CacheUsage.QuadPart+header->ExemptUsage.QuadPart <= desired_size)
+                if(header->cache_usage.QuadPart+header->exempt_usage.QuadPart <= desired_size)
                    break;

                /* Allow other threads to use cache while cleaning */
@ -2613,8 +2610,8 @@ BOOL WINAPI FreeUrlCacheSpaceW(LPCWSTR cache_path, DWORD size, DWORD filter)
        }

        TRACE("cache size after cleaning 0x%s/0x%s\n",
-                wine_dbgstr_longlong(header->CacheUsage.QuadPart+header->ExemptUsage.QuadPart),
-                wine_dbgstr_longlong(header->CacheLimit.QuadPart));
+                wine_dbgstr_longlong(header->cache_usage.QuadPart+header->exempt_usage.QuadPart),
+                wine_dbgstr_longlong(header->cache_limit.QuadPart));
        cache_container_unlock_index(container, header);
    }

@ -2645,7 +2642,7 @@ BOOL WINAPI UnlockUrlCacheEntryFileA(
    IN DWORD dwReserved
    )
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    entry_header *pEntry;
    entry_url * pUrlEntry;
@ -2721,7 +2718,7 @@ BOOL WINAPI UnlockUrlCacheEntryFileA(
 */
 BOOL WINAPI UnlockUrlCacheEntryFileW( LPCWSTR lpszUrlName, DWORD dwReserved )
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    entry_header *pEntry;
    entry_url * pUrlEntry;
@ -2851,7 +2848,7 @@ BOOL WINAPI CreateUrlCacheEntryW(
 )
 {
    URLCACHECONTAINER * pContainer;
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    CHAR szFile[MAX_PATH];
    WCHAR szExtension[MAX_PATH];
    LPCWSTR lpszUrlPart;
@ -2947,8 +2944,8 @@ BOOL WINAPI CreateUrlCacheEntryW(
    if (!(pHeader = cache_container_lock_index(pContainer)))
        return FALSE;

-    if(pHeader->DirectoryCount)
-        CacheDir = (BYTE)(rand() % pHeader->DirectoryCount);
+    if(pHeader->dirs_no)
+        CacheDir = (BYTE)(rand() % pHeader->dirs_no);
    else
        CacheDir = CACHE_CONTAINER_NO_SUBDIR;

@ -3072,7 +3069,7 @@ static BOOL CommitUrlCacheEntryInternal(
    )
 {
    URLCACHECONTAINER * pContainer;
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    entry_header *pEntry;
    entry_url * pUrlEntry;
@ -3163,7 +3160,7 @@ static BOOL CommitUrlCacheEntryInternal(
        DeleteUrlCacheEntryInternal(pContainer, pHeader, pHashEntry);
    }

-    if (pHeader->DirectoryCount)
+    if (pHeader->dirs_no)
        cDirectory = 0;
    else
        cDirectory = CACHE_CONTAINER_NO_SUBDIR;
@ -3185,11 +3182,11 @@ static BOOL CommitUrlCacheEntryInternal(
        WideCharToMultiByte(CP_ACP, 0, lpszLocalFileName, -1, achFile, MAX_PATH, NULL, NULL);
 	pchLocalFileName = achFile;

-        if(pHeader->DirectoryCount)
+        if(pHeader->dirs_no)
        {
-            for (cDirectory = 0; cDirectory < pHeader->DirectoryCount; cDirectory++)
+            for (cDirectory = 0; cDirectory < pHeader->dirs_no; cDirectory++)
            {
-                if (!strncmp(pHeader->directory_data[cDirectory].filename, pchLocalFileName, DIR_LENGTH))
+                if (!strncmp(pHeader->directory_data[cDirectory].name, pchLocalFileName, DIR_LENGTH))
                {
                    bFound = TRUE;
                    break;
@ -3301,14 +3298,14 @@ static BOOL CommitUrlCacheEntryInternal(
        URLCache_DeleteEntry(pHeader, &pUrlEntry->header);
    else
    {
-        if (pUrlEntry->cache_dir < pHeader->DirectoryCount)
-            pHeader->directory_data[pUrlEntry->cache_dir].dwNumFiles++;
+        if (pUrlEntry->cache_dir < pHeader->dirs_no)
+            pHeader->directory_data[pUrlEntry->cache_dir].files_no++;
        if (CacheEntryType & STICKY_CACHE_ENTRY)
-            pHeader->ExemptUsage.QuadPart += file_size.QuadPart;
+            pHeader->exempt_usage.QuadPart += file_size.QuadPart;
        else
-            pHeader->CacheUsage.QuadPart += file_size.QuadPart;
-        if (pHeader->CacheUsage.QuadPart + pHeader->ExemptUsage.QuadPart >
-            pHeader->CacheLimit.QuadPart)
+            pHeader->cache_usage.QuadPart += file_size.QuadPart;
+        if (pHeader->cache_usage.QuadPart + pHeader->exempt_usage.QuadPart >
+            pHeader->cache_limit.QuadPart)
            handle_full_cache();
    }

@ -3635,7 +3632,7 @@ BOOL WINAPI UnlockUrlCacheEntryStream(
 BOOL WINAPI DeleteUrlCacheEntryA(LPCSTR lpszUrlName)
 {
    URLCACHECONTAINER * pContainer;
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    DWORD error;
    BOOL ret;
@ -3681,7 +3678,7 @@ BOOL WINAPI DeleteUrlCacheEntryA(LPCSTR lpszUrlName)
 BOOL WINAPI DeleteUrlCacheEntryW(LPCWSTR lpszUrlName)
 {
    URLCACHECONTAINER * pContainer;
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    LPSTR urlA;
    DWORD error;
@ -3949,7 +3946,7 @@ static BOOL FindNextUrlCacheEntryInternal(
    for (; URLCacheContainers_Enum(pEntryHandle->lpszUrlSearchPattern, pEntryHandle->dwContainerIndex, &pContainer);
         pEntryHandle->dwContainerIndex++, pEntryHandle->dwHashTableIndex = 0)
    {
-        LPURLCACHE_HEADER pHeader;
+        urlcache_header *pHeader;
        entry_hash_table *pHashTableEntry;
        DWORD error;

@ -4281,7 +4278,7 @@ static BOOL IsUrlCacheEntryExpiredInternal(const entry_url *pUrlEntry,
 */
 BOOL WINAPI IsUrlCacheEntryExpiredA( LPCSTR url, DWORD dwFlags, FILETIME* pftLastModified )
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    const entry_header *pEntry;
    const entry_url * pUrlEntry;
@ -4349,7 +4346,7 @@ BOOL WINAPI IsUrlCacheEntryExpiredA( LPCSTR url, DWORD dwFlags, FILETIME* pftLas
 */
 BOOL WINAPI IsUrlCacheEntryExpiredW( LPCWSTR url, DWORD dwFlags, FILETIME* pftLastModified )
 {
-    LPURLCACHE_HEADER pHeader;
+    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    const entry_header *pEntry;
    const entry_url * pUrlEntry;