urlcache.c File Reference

#include "ws2tcpip.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "wininet.h"
#include "winineti.h"
#include "winerror.h"
#include "winreg.h"
#include "shlwapi.h"
#include "shlobj.h"
#include "shellapi.h"
#include "internet.h"
#include "wine/unicode.h"
#include "wine/debug.h"

Include dependency graph for urlcache.c:

Go to the source code of this file.

Classes
struct	entry_header
struct	entry_url
struct	hash_entry
struct	entry_hash_table
struct	urlcache_header
struct	urlcache_header::_directory_data
struct	stream_handle
struct	cache_container
struct	find_handle

Macros
#define	NONAMELESSUNION
#define	NONAMELESSSTRUCT
#define	CHAR_BIT   (8 * sizeof(CHAR))
#define	ENTRY_START_OFFSET   0x4000
#define	DIR_LENGTH   8
#define	MAX_DIR_NO   0x20
#define	BLOCKSIZE   128
#define	HASHTABLE_SIZE   448
#define	HASHTABLE_NUM_ENTRIES   64 /* this needs to be power of 2, that divides HASHTABLE_SIZE */
#define	HASHTABLE_BLOCKSIZE   (HASHTABLE_SIZE / HASHTABLE_NUM_ENTRIES)
#define	ALLOCATION_TABLE_OFFSET   0x250
#define	ALLOCATION_TABLE_SIZE   (ENTRY_START_OFFSET - ALLOCATION_TABLE_OFFSET)
#define	MIN_BLOCK_NO   0x80
#define	MAX_BLOCK_NO   (ALLOCATION_TABLE_SIZE * CHAR_BIT)
#define	FILE_SIZE(blocks)   ((blocks) * BLOCKSIZE + ENTRY_START_OFFSET)
#define	HASHTABLE_URL   0
#define	HASHTABLE_DEL   1
#define	HASHTABLE_LOCK   2
#define	HASHTABLE_FREE   3
#define	HASHTABLE_REDR   5
#define	HASHTABLE_FLAG_BITS   6
#define	PENDING_DELETE_CACHE_ENTRY   0x00400000
#define	INSTALLED_CACHE_ENTRY   0x10000000
#define	GET_INSTALLED_ENTRY   0x200
#define	CACHE_CONTAINER_NO_SUBDIR   0xFE
#define	CACHE_HEADER_DATA_ROOT_LEAK_OFFSET   0x16
#define	FILETIME_SECOND   10000000
#define	DWORD_SIG(a, b, c, d)   (a | (b << 8) | (c << 16) | (d << 24))
#define	URL_SIGNATURE   DWORD_SIG('U','R','L',' ')
#define	REDR_SIGNATURE   DWORD_SIG('R','E','D','R')
#define	LEAK_SIGNATURE   DWORD_SIG('L','E','A','K')
#define	HASH_SIGNATURE   DWORD_SIG('H','A','S','H')
#define	DWORD_ALIGN(x)   ( (DWORD)(((DWORD)(x)+sizeof(DWORD)-1)/sizeof(DWORD))*sizeof(DWORD) )
#define	URLCACHE_FIND_ENTRY_HANDLE_MAGIC   0xF389ABCD

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wininet)
static char *	heap_strdupWtoUTF8 (LPCWSTR str)
static BYTE	urlcache_block_is_free (BYTE *allocation_table, DWORD block_number)
static void	urlcache_block_free (BYTE *allocation_table, DWORD block_number)
static void	urlcache_block_alloc (BYTE *allocation_table, DWORD block_number)
static DWORD	urlcache_entry_alloc (urlcache_header *header, DWORD blocks_needed, entry_header **entry)
static BOOL	urlcache_entry_free (urlcache_header *header, entry_header *entry)
static DWORD	urlcache_create_hash_table (urlcache_header *header, entry_hash_table *hash_table_prev, entry_hash_table **hash_table)
static void	cache_container_create_object_name (LPWSTR lpszPath, WCHAR replace)
static HANDLE	cache_container_map_index (HANDLE file, const WCHAR *path, DWORD size, BOOL *validate)
static DWORD	cache_container_set_size (cache_container *container, HANDLE file, DWORD blocks_no)
static BOOL	cache_container_is_valid (urlcache_header *header, DWORD file_size)
static DWORD	cache_container_open_index (cache_container *container, DWORD blocks_no)
static void	cache_container_close_index (cache_container *pContainer)
static BOOL	cache_containers_add (const char *cache_prefix, LPCWSTR path, DWORD default_entry_type, LPWSTR mutex_name)
static void	cache_container_delete_container (cache_container *pContainer)
static void	cache_containers_init (void)
static void	cache_containers_free (void)
static DWORD	cache_containers_find (const char *url, cache_container **ret)
static BOOL	cache_containers_enum (char *search_pattern, DWORD index, cache_container **ret)
static urlcache_header *	cache_container_lock_index (cache_container *pContainer)
static BOOL	cache_container_unlock_index (cache_container *pContainer, urlcache_header *pHeader)
static BOOL	urlcache_create_file_pathW (const cache_container *pContainer, const urlcache_header *pHeader, LPCSTR szLocalFileName, BYTE Directory, LPWSTR wszPath, LPLONG lpBufferSize, BOOL trunc_name)
static BOOL	urlcache_create_file_pathA (const cache_container *pContainer, const urlcache_header *pHeader, LPCSTR szLocalFileName, BYTE Directory, LPSTR szPath, LPLONG lpBufferSize)
static void	file_time_to_dos_date_time (const FILETIME *ft, WORD *fatdate, WORD *fattime)
static DWORD	urlcache_delete_file (const cache_container *container, urlcache_header *header, entry_url *url_entry)
static BOOL	urlcache_clean_leaked_entries (cache_container *container, urlcache_header *header)
static DWORD	cache_container_clean_index (cache_container *container, urlcache_header **file_view)
static void	dos_date_time_to_file_time (WORD fatdate, WORD fattime, FILETIME *ft)
static int	urlcache_decode_url (const char *url, WCHAR *decoded_url, int decoded_len)
static DWORD	urlcache_copy_entry (cache_container *container, const urlcache_header *header, INTERNET_CACHE_ENTRY_INFOA *entry_info, DWORD *info_size, const entry_url *url_entry, BOOL unicode)
static DWORD	urlcache_set_entry_info (entry_url *url_entry, const INTERNET_CACHE_ENTRY_INFOA *entry_info, DWORD field_control)
static DWORD	urlcache_hash_key (LPCSTR lpszKey)
static entry_hash_table *	urlcache_get_hash_table (const urlcache_header *pHeader, DWORD dwOffset)
static BOOL	urlcache_find_hash_entry (const urlcache_header *pHeader, LPCSTR lpszUrl, struct hash_entry **ppHashEntry)
static void	urlcache_hash_entry_set_flags (struct hash_entry *pHashEntry, DWORD dwFlag)
static BOOL	urlcache_hash_entry_delete (struct hash_entry *pHashEntry)
static DWORD	urlcache_hash_entry_create (urlcache_header *pHeader, LPCSTR lpszUrl, DWORD dwOffsetEntry, DWORD dwFieldType)
static BOOL	urlcache_enum_hash_tables (const urlcache_header *pHeader, DWORD *id, entry_hash_table **ppHashEntry)
static BOOL	urlcache_enum_hash_table_entries (const urlcache_header *pHeader, const entry_hash_table *pHashEntry, DWORD *index, const struct hash_entry **ppHashEntry)
static BOOL	cache_container_delete_dir (LPCWSTR lpszPath)
static BOOL	urlcache_hash_entry_is_locked (struct hash_entry *hash_entry, entry_url *url_entry)
static BOOL	urlcache_get_entry_info (const char *url, void *entry_info, DWORD *size, DWORD flags, BOOL unicode)
BOOL WINAPI	GetUrlCacheEntryInfoExA (LPCSTR lpszUrl, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, LPDWORD lpdwCacheEntryInfoBufSize, LPSTR lpszReserved, LPDWORD lpdwReserved, LPVOID lpReserved, DWORD dwFlags)
BOOL WINAPI	GetUrlCacheEntryInfoA (LPCSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, LPDWORD lpdwCacheEntryInfoBufferSize)
static int	urlcache_encode_url (const WCHAR *url, char *encoded_url, int encoded_len)
static BOOL	urlcache_encode_url_alloc (const WCHAR *url, char **encoded_url)
BOOL WINAPI	GetUrlCacheEntryInfoExW (LPCWSTR lpszUrl, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, LPDWORD lpdwCacheEntryInfoBufSize, LPWSTR lpszReserved, LPDWORD lpdwReserved, LPVOID lpReserved, DWORD dwFlags)
BOOL WINAPI	GetUrlCacheEntryInfoW (LPCWSTR lpszUrl, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, LPDWORD lpdwCacheEntryInfoBufferSize)
BOOL WINAPI	SetUrlCacheEntryInfoA (LPCSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, DWORD dwFieldControl)
BOOL WINAPI	SetUrlCacheEntryInfoW (LPCWSTR lpszUrl, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, DWORD dwFieldControl)
static BOOL	urlcache_entry_get_file (const char *url, void *entry_info, DWORD *size, BOOL unicode)
BOOL WINAPI	RetrieveUrlCacheEntryFileA (LPCSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, LPDWORD lpdwCacheEntryInfoBufferSize, DWORD dwReserved)
BOOL WINAPI	RetrieveUrlCacheEntryFileW (LPCWSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, LPDWORD lpdwCacheEntryInfoBufferSize, DWORD dwReserved)
static BOOL	urlcache_entry_delete (const cache_container *pContainer, urlcache_header *pHeader, struct hash_entry *pHashEntry)
static DWORD WINAPI	handle_full_cache_worker (void *param)
static void	handle_full_cache (void)
static BOOL	urlcache_next_entry (urlcache_header *header, DWORD *hash_table_off, DWORD *hash_table_entry, struct hash_entry **hash_entry, entry_header **entry)
static DWORD	urlcache_rate_entry (entry_url *url_entry, FILETIME *cur_time)
static int	dword_cmp (const void *p1, const void *p2)
BOOL WINAPI	FreeUrlCacheSpaceW (LPCWSTR cache_path, DWORD size, DWORD filter)
BOOL WINAPI	FreeUrlCacheSpaceA (LPCSTR lpszCachePath, DWORD dwSize, DWORD dwFilter)
BOOL WINAPI	UnlockUrlCacheEntryFileA (LPCSTR lpszUrlName, DWORD dwReserved)
BOOL WINAPI	UnlockUrlCacheEntryFileW (LPCWSTR lpszUrlName, DWORD dwReserved)
static BOOL	urlcache_entry_create (const char *url, const char *ext, WCHAR *full_path)
BOOL WINAPI	CreateUrlCacheEntryA (LPCSTR lpszUrlName, DWORD dwExpectedFileSize, LPCSTR lpszFileExtension, LPSTR lpszFileName, DWORD dwReserved)
BOOL WINAPI	CreateUrlCacheEntryW (LPCWSTR lpszUrlName, DWORD dwExpectedFileSize, LPCWSTR lpszFileExtension, LPWSTR lpszFileName, DWORD dwReserved)
static BOOL	urlcache_entry_commit (const char *url, const WCHAR *file_name, FILETIME expire_time, FILETIME modify_time, DWORD entry_type, BYTE *header_info, DWORD header_size, const char *file_ext, const char *original_url)
BOOL WINAPI	CommitUrlCacheEntryA (LPCSTR lpszUrlName, LPCSTR lpszLocalFileName, FILETIME ExpireTime, FILETIME LastModifiedTime, DWORD CacheEntryType, LPBYTE lpHeaderInfo, DWORD dwHeaderSize, LPCSTR lpszFileExtension, LPCSTR lpszOriginalUrl)
BOOL WINAPI	CommitUrlCacheEntryW (LPCWSTR lpszUrlName, LPCWSTR lpszLocalFileName, FILETIME ExpireTime, FILETIME LastModifiedTime, DWORD CacheEntryType, LPWSTR lpHeaderInfo, DWORD dwHeaderSize, LPCWSTR lpszFileExtension, LPCWSTR lpszOriginalUrl)
BOOL WINAPI	ReadUrlCacheEntryStream (IN HANDLE hUrlCacheStream, IN DWORD dwLocation, IN OUT LPVOID lpBuffer, IN OUT LPDWORD lpdwLen, IN DWORD dwReserved)
HANDLE WINAPI	RetrieveUrlCacheEntryStreamA (LPCSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo, LPDWORD lpdwCacheEntryInfoBufferSize, BOOL fRandomRead, DWORD dwReserved)
HANDLE WINAPI	RetrieveUrlCacheEntryStreamW (LPCWSTR lpszUrlName, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, LPDWORD lpdwCacheEntryInfoBufferSize, BOOL fRandomRead, DWORD dwReserved)
BOOL WINAPI	UnlockUrlCacheEntryStream (IN HANDLE hUrlCacheStream, IN DWORD dwReserved)
BOOL WINAPI	DeleteUrlCacheEntryA (LPCSTR lpszUrlName)
BOOL WINAPI	DeleteUrlCacheEntryW (LPCWSTR lpszUrlName)
BOOL WINAPI	DeleteUrlCacheContainerA (DWORD d1, DWORD d2)
BOOL WINAPI	DeleteUrlCacheContainerW (DWORD d1, DWORD d2)
BOOL WINAPI	CreateUrlCacheContainerA (DWORD d1, DWORD d2, DWORD d3, DWORD d4, DWORD d5, DWORD d6, DWORD d7, DWORD d8)
BOOL WINAPI	CreateUrlCacheContainerW (DWORD d1, DWORD d2, DWORD d3, DWORD d4, DWORD d5, DWORD d6, DWORD d7, DWORD d8)
HANDLE WINAPI	FindFirstUrlCacheContainerA (LPVOID p1, LPVOID p2, LPVOID p3, DWORD d1)
HANDLE WINAPI	FindFirstUrlCacheContainerW (LPVOID p1, LPVOID p2, LPVOID p3, DWORD d1)
BOOL WINAPI	FindNextUrlCacheContainerA (HANDLE handle, LPVOID p1, LPVOID p2)
BOOL WINAPI	FindNextUrlCacheContainerW (HANDLE handle, LPVOID p1, LPVOID p2)
HANDLE WINAPI	FindFirstUrlCacheEntryExA (LPCSTR lpszUrlSearchPattern, DWORD dwFlags, DWORD dwFilter, GROUPID GroupId, LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize, LPVOID lpReserved, LPDWORD pcbReserved2, LPVOID lpReserved3)
HANDLE WINAPI	FindFirstUrlCacheEntryExW (LPCWSTR lpszUrlSearchPattern, DWORD dwFlags, DWORD dwFilter, GROUPID GroupId, LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize, LPVOID lpReserved, LPDWORD pcbReserved2, LPVOID lpReserved3)
INTERNETAPI HANDLE WINAPI	FindFirstUrlCacheEntryA (LPCSTR lpszUrlSearchPattern, LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize)
INTERNETAPI HANDLE WINAPI	FindFirstUrlCacheEntryW (LPCWSTR lpszUrlSearchPattern, LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize)
static BOOL	urlcache_find_next_entry (HANDLE hEnumHandle, LPINTERNET_CACHE_ENTRY_INFOA lpNextCacheEntryInfo, LPDWORD lpdwNextCacheEntryInfoBufferSize, BOOL unicode)
BOOL WINAPI	FindNextUrlCacheEntryA (HANDLE hEnumHandle, LPINTERNET_CACHE_ENTRY_INFOA lpNextCacheEntryInfo, LPDWORD lpdwNextCacheEntryInfoBufferSize)
BOOL WINAPI	FindNextUrlCacheEntryW (HANDLE hEnumHandle, LPINTERNET_CACHE_ENTRY_INFOW lpNextCacheEntryInfo, LPDWORD lpdwNextCacheEntryInfoBufferSize)
BOOL WINAPI	FindCloseUrlCache (HANDLE hEnumHandle)
HANDLE WINAPI	FindFirstUrlCacheGroup (DWORD dwFlags, DWORD dwFilter, LPVOID lpSearchCondition, DWORD dwSearchCondition, GROUPID *lpGroupId, LPVOID lpReserved)
BOOL WINAPI	FindNextUrlCacheEntryExA (HANDLE hEnumHandle, LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize, LPVOID lpReserved, LPDWORD pcbReserved2, LPVOID lpReserved3)
BOOL WINAPI	FindNextUrlCacheEntryExW (HANDLE hEnumHandle, LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize, LPVOID lpReserved, LPDWORD pcbReserved2, LPVOID lpReserved3)
BOOL WINAPI	FindNextUrlCacheGroup (HANDLE hFind, GROUPID *lpGroupId, LPVOID lpReserved)
INTERNETAPI GROUPID WINAPI	CreateUrlCacheGroup (DWORD dwFlags, LPVOID lpReserved)
BOOL WINAPI	DeleteUrlCacheGroup (GROUPID GroupId, DWORD dwFlags, LPVOID lpReserved)
BOOL WINAPI	DeleteWpadCacheForNetworks (DWORD unk1)
BOOL WINAPI	SetUrlCacheEntryGroupA (LPCSTR lpszUrlName, DWORD dwFlags, GROUPID GroupId, LPBYTE pbGroupAttributes, DWORD cbGroupAttributes, LPVOID lpReserved)
BOOL WINAPI	SetUrlCacheEntryGroupW (LPCWSTR lpszUrlName, DWORD dwFlags, GROUPID GroupId, LPBYTE pbGroupAttributes, DWORD cbGroupAttributes, LPVOID lpReserved)
static cache_container *	find_container (DWORD flags)
BOOL WINAPI	GetUrlCacheConfigInfoW (LPINTERNET_CACHE_CONFIG_INFOW info, LPDWORD size, DWORD flags)
BOOL WINAPI	GetUrlCacheConfigInfoA (LPINTERNET_CACHE_CONFIG_INFOA info, LPDWORD size, DWORD flags)
BOOL WINAPI	GetUrlCacheGroupAttributeA (GROUPID gid, DWORD dwFlags, DWORD dwAttributes, LPINTERNET_CACHE_GROUP_INFOA lpGroupInfo, LPDWORD lpdwGroupInfo, LPVOID lpReserved)
BOOL WINAPI	GetUrlCacheGroupAttributeW (GROUPID gid, DWORD dwFlags, DWORD dwAttributes, LPINTERNET_CACHE_GROUP_INFOW lpGroupInfo, LPDWORD lpdwGroupInfo, LPVOID lpReserved)
BOOL WINAPI	SetUrlCacheGroupAttributeA (GROUPID gid, DWORD dwFlags, DWORD dwAttributes, LPINTERNET_CACHE_GROUP_INFOA lpGroupInfo, LPVOID lpReserved)
BOOL WINAPI	SetUrlCacheGroupAttributeW (GROUPID gid, DWORD dwFlags, DWORD dwAttributes, LPINTERNET_CACHE_GROUP_INFOW lpGroupInfo, LPVOID lpReserved)
BOOL WINAPI	SetUrlCacheConfigInfoA (LPINTERNET_CACHE_CONFIG_INFOA lpCacheConfigInfo, DWORD dwFieldControl)
BOOL WINAPI	SetUrlCacheConfigInfoW (LPINTERNET_CACHE_CONFIG_INFOW lpCacheConfigInfo, DWORD dwFieldControl)
DWORD WINAPI	DeleteIE3Cache (HWND hWnd, HINSTANCE hInst, LPSTR lpszCmdLine, int nCmdShow)
static BOOL	urlcache_entry_is_expired (const entry_url *pUrlEntry, FILETIME *pftLastModified)
BOOL WINAPI	IsUrlCacheEntryExpiredA (LPCSTR url, DWORD dwFlags, FILETIME *pftLastModified)
BOOL WINAPI	IsUrlCacheEntryExpiredW (LPCWSTR url, DWORD dwFlags, FILETIME *pftLastModified)
BOOL WINAPI	GetDiskInfoA (PCSTR path, PDWORD cluster_size, PDWORDLONG free, PDWORDLONG total)
DWORD WINAPI	RegisterUrlCacheNotification (LPVOID a, DWORD b, DWORD c, DWORD d, DWORD e, DWORD f)
BOOL WINAPI	IncrementUrlCacheHeaderData (DWORD index, LPDWORD data)
DWORD WINAPI	RunOnceUrlCache (HWND hwnd, HINSTANCE hinst, LPSTR cmd, int cmdshow)
BOOL	init_urlcache (void)
void	free_urlcache (void)
BOOL WINAPI	LoadUrlCacheContent (void)

Variables
static const char	urlcache_ver_prefix [] = "WINE URLCache Ver "
static const char	urlcache_ver [] = "0.2012001"
static struct list	UrlContainers = LIST_INIT(UrlContainers)
BOOL	bDefaultContainersAdded = FALSE
static HANDLE	free_cache_running
static HANDLE	dll_unload_event

Macro Definition Documentation

ALLOCATION_TABLE_OFFSET

#define ALLOCATION_TABLE_OFFSET   0x250

Definition at line 68 of file urlcache.c.

ALLOCATION_TABLE_SIZE

#define ALLOCATION_TABLE_SIZE   (ENTRY_START_OFFSET - ALLOCATION_TABLE_OFFSET)

Definition at line 69 of file urlcache.c.

BLOCKSIZE

#define BLOCKSIZE   128

Definition at line 64 of file urlcache.c.

CACHE_CONTAINER_NO_SUBDIR

#define CACHE_CONTAINER_NO_SUBDIR   0xFE

Definition at line 84 of file urlcache.c.

CACHE_HEADER_DATA_ROOT_LEAK_OFFSET

#define CACHE_HEADER_DATA_ROOT_LEAK_OFFSET   0x16

Definition at line 86 of file urlcache.c.

CHAR_BIT

#define CHAR_BIT   (8 * sizeof(CHAR))

Definition at line 58 of file urlcache.c.

DIR_LENGTH

#define DIR_LENGTH   8

Definition at line 62 of file urlcache.c.

DWORD_ALIGN

#define DWORD_ALIGN

(

x

)

( (DWORD)(((DWORD)(x)+sizeof(DWORD)-1)/sizeof(DWORD))*sizeof(DWORD) )

Definition at line 96 of file urlcache.c.

DWORD_SIG

#define DWORD_SIG	(		a,
			b,
			c,
			d
	)		(a | (b << 8) | (c << 16) | (d << 24))

Definition at line 90 of file urlcache.c.

ENTRY_START_OFFSET

#define ENTRY_START_OFFSET   0x4000

Definition at line 61 of file urlcache.c.

FILE_SIZE

#define FILE_SIZE

(

blocks

)

((blocks) * BLOCKSIZE + ENTRY_START_OFFSET)

Definition at line 72 of file urlcache.c.

FILETIME_SECOND

#define FILETIME_SECOND   10000000

Definition at line 88 of file urlcache.c.

GET_INSTALLED_ENTRY

#define GET_INSTALLED_ENTRY   0x200

Definition at line 83 of file urlcache.c.

HASH_SIGNATURE

#define HASH_SIGNATURE   DWORD_SIG('H','A','S','H')

Definition at line 94 of file urlcache.c.

HASHTABLE_BLOCKSIZE

#define HASHTABLE_BLOCKSIZE   (HASHTABLE_SIZE / HASHTABLE_NUM_ENTRIES)

Definition at line 67 of file urlcache.c.

HASHTABLE_DEL

#define HASHTABLE_DEL   1

Definition at line 75 of file urlcache.c.

HASHTABLE_FLAG_BITS

#define HASHTABLE_FLAG_BITS   6

Definition at line 79 of file urlcache.c.

HASHTABLE_FREE

#define HASHTABLE_FREE   3

Definition at line 77 of file urlcache.c.

HASHTABLE_LOCK

#define HASHTABLE_LOCK   2

Definition at line 76 of file urlcache.c.

HASHTABLE_NUM_ENTRIES

#define HASHTABLE_NUM_ENTRIES   64 /* this needs to be power of 2, that divides HASHTABLE_SIZE */

Definition at line 66 of file urlcache.c.

HASHTABLE_REDR

#define HASHTABLE_REDR   5

Definition at line 78 of file urlcache.c.

HASHTABLE_SIZE

#define HASHTABLE_SIZE   448

Definition at line 65 of file urlcache.c.

HASHTABLE_URL

#define HASHTABLE_URL   0

Definition at line 74 of file urlcache.c.

INSTALLED_CACHE_ENTRY

#define INSTALLED_CACHE_ENTRY   0x10000000

Definition at line 82 of file urlcache.c.

LEAK_SIGNATURE

#define LEAK_SIGNATURE   DWORD_SIG('L','E','A','K')

Definition at line 93 of file urlcache.c.

MAX_BLOCK_NO

#define MAX_BLOCK_NO   (ALLOCATION_TABLE_SIZE * CHAR_BIT)

Definition at line 71 of file urlcache.c.

MAX_DIR_NO

#define MAX_DIR_NO   0x20

Definition at line 63 of file urlcache.c.

MIN_BLOCK_NO

#define MIN_BLOCK_NO   0x80

Definition at line 70 of file urlcache.c.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 26 of file urlcache.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 25 of file urlcache.c.

PENDING_DELETE_CACHE_ENTRY

#define PENDING_DELETE_CACHE_ENTRY   0x00400000

Definition at line 81 of file urlcache.c.

REDR_SIGNATURE

#define REDR_SIGNATURE   DWORD_SIG('R','E','D','R')

Definition at line 92 of file urlcache.c.

URL_SIGNATURE

#define URL_SIGNATURE   DWORD_SIG('U','R','L',' ')

Definition at line 91 of file urlcache.c.

URLCACHE_FIND_ENTRY_HANDLE_MAGIC

#define URLCACHE_FIND_ENTRY_HANDLE_MAGIC   0xF389ABCD

Definition at line 98 of file urlcache.c.

Function Documentation

cache_container_clean_index()

static DWORD cache_container_clean_index ( cache_container *  container, urlcache_header **  file_view  )

static

Definition at line 1203 of file urlcache.c.

{
    urlcache_header *header = *file_view;
    DWORD ret;

    TRACE("(%s %s)\n", debugstr_a(container->cache_prefix), debugstr_w(container->path));

    if(urlcache_clean_leaked_entries(container, header))
        return ERROR_SUCCESS;

    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->capacity_in_blocks*2);
    if(ret != ERROR_SUCCESS)
        return ret;
    header = MapViewOfFile(container->mapping, FILE_MAP_WRITE, 0, 0, 0);
    if(!header)
        return GetLastError();

    UnmapViewOfFile(*file_view);
    *file_view = header;
    return ERROR_SUCCESS;
}

Referenced by urlcache_entry_commit().

cache_container_close_index()

static void cache_container_close_index ( cache_container *  pContainer )

static

Definition at line 688 of file urlcache.c.

{
    CloseHandle(pContainer->mapping);
    pContainer->mapping = NULL;
}

Referenced by cache_container_clean_index(), cache_container_delete_container(), cache_container_lock_index(), FreeUrlCacheSpaceW(), and GetUrlCacheConfigInfoW().

cache_container_create_object_name()

static void cache_container_create_object_name ( LPWSTR  lpszPath, WCHAR  replace  )

static

Definition at line 389 of file urlcache.c.

{
    for (; *lpszPath; lpszPath++)
    {
        if (*lpszPath == '\\')
            *lpszPath = replace;
    }
}

Referenced by cache_container_map_index(), and cache_containers_add().

cache_container_delete_container()

static void cache_container_delete_container ( cache_container *  pContainer )

static

Definition at line 742 of file urlcache.c.

{
    list_remove(&pContainer->entry);

    cache_container_close_index(pContainer);
    CloseHandle(pContainer->mutex);
    heap_free(pContainer->path);
    heap_free(pContainer->cache_prefix);
    heap_free(pContainer);
}

Referenced by cache_containers_free().

cache_container_delete_dir()

static BOOL cache_container_delete_dir ( LPCWSTR  lpszPath )

static

Definition at line 1745 of file urlcache.c.

{
    DWORD path_len;
    WCHAR path[MAX_PATH + 1];
    SHFILEOPSTRUCTW shfos;
    int ret;

    path_len = strlenW(lpszPath);
    if (path_len >= MAX_PATH)
        return FALSE;
    strcpyW(path, lpszPath);
    path[path_len + 1] = 0;  /* double-NUL-terminate path */

    shfos.hwnd = NULL;
    shfos.wFunc = FO_DELETE;
    shfos.pFrom = path;
    shfos.pTo = NULL;
    shfos.fFlags = FOF_NOCONFIRMATION;
    shfos.fAnyOperationsAborted = FALSE;
    ret = SHFileOperationW(&shfos);
    if (ret)
        ERR("SHFileOperationW on %s returned %i\n", debugstr_w(path), ret);
    return !(ret || shfos.fAnyOperationsAborted);
}

Referenced by FreeUrlCacheSpaceW().

cache_container_is_valid()

static BOOL cache_container_is_valid ( urlcache_header *  header, DWORD  file_size  )

static

Definition at line 555 of file urlcache.c.

{
    DWORD allocation_size, count_bits, i;

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

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

    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->capacity_in_blocks) != file_size)
        return FALSE;

    allocation_size = 0;
    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->blocks_in_use)
        return FALSE;

    for(; i<ALLOCATION_TABLE_SIZE; i++) {
        if(header->allocation_table[i])
            return FALSE;
    }

    return TRUE;
}

Referenced by cache_container_open_index().

cache_container_lock_index()

static urlcache_header* cache_container_lock_index ( cache_container *  pContainer )

static

Definition at line 926 of file urlcache.c.

{
    BYTE index;
    LPVOID pIndexData;
    urlcache_header* pHeader;
    DWORD error;

    /* acquire mutex */
    WaitForSingleObject(pContainer->mutex, INFINITE);

    pIndexData = MapViewOfFile(pContainer->mapping, FILE_MAP_WRITE, 0, 0, 0);

    if (!pIndexData)
    {
        ReleaseMutex(pContainer->mutex);
        ERR("Couldn't MapViewOfFile. Error: %d\n", GetLastError());
        return NULL;
    }
    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->size != pContainer->file_size)
    {
        UnmapViewOfFile( pHeader );
        cache_container_close_index(pContainer);
        error = cache_container_open_index(pContainer, MIN_BLOCK_NO);
        if (error != ERROR_SUCCESS)
        {
            ReleaseMutex(pContainer->mutex);
            SetLastError(error);
            return NULL;
        }
        pIndexData = MapViewOfFile(pContainer->mapping, FILE_MAP_WRITE, 0, 0, 0);

        if (!pIndexData)
        {
            ReleaseMutex(pContainer->mutex);
            ERR("Couldn't MapViewOfFile. Error: %d\n", GetLastError());
            return NULL;
        }
        pHeader = (urlcache_header*)pIndexData;
    }

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

    for (index = 0; index < pHeader->dirs_no; index++)
    {
        TRACE("Directory[%d] = \"%.8s\"\n", index, pHeader->directory_data[index].name);
    }
    
    return pHeader;
}

Referenced by DeleteUrlCacheEntryA(), FreeUrlCacheSpaceW(), IsUrlCacheEntryExpiredA(), SetUrlCacheEntryInfoA(), UnlockUrlCacheEntryFileA(), urlcache_entry_commit(), urlcache_entry_create(), urlcache_entry_get_file(), urlcache_find_next_entry(), and urlcache_get_entry_info().

cache_container_map_index()

static HANDLE cache_container_map_index ( HANDLE  file, const WCHAR *  path, DWORD  size, BOOL *  validate  )

static

Definition at line 399 of file urlcache.c.

{
    static const WCHAR mapping_name_format[]
        = {'%','s','i','n','d','e','x','.','d','a','t','_','%','l','u',0};
    WCHAR mapping_name[MAX_PATH];
    HANDLE mapping;

    wsprintfW(mapping_name, mapping_name_format, path, size);
    cache_container_create_object_name(mapping_name, '_');

    mapping = OpenFileMappingW(FILE_MAP_WRITE, FALSE, mapping_name);
    if(mapping) {
        if(validate) *validate = FALSE;
        return mapping;
    }

    if(validate) *validate = TRUE;
    return CreateFileMappingW(file, NULL, PAGE_READWRITE, 0, 0, mapping_name);
}

Referenced by cache_container_open_index(), and cache_container_set_size().

cache_container_open_index()

static DWORD cache_container_open_index ( cache_container *  container, DWORD  blocks_no  )

static

Definition at line 600 of file urlcache.c.

{
    static const WCHAR index_dat[] = {'i','n','d','e','x','.','d','a','t',0};

    HANDLE file;
    WCHAR index_path[MAX_PATH];
    DWORD file_size;
    BOOL validate;

    WaitForSingleObject(container->mutex, INFINITE);

    if(container->mapping) {
        ReleaseMutex(container->mutex);
        return ERROR_SUCCESS;
    }

    strcpyW(index_path, container->path);
    strcatW(index_path, index_dat);

    file = CreateFileW(index_path, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL);
    if(file == INVALID_HANDLE_VALUE) {
    /* Maybe the directory wasn't there? Try to create it */
    if(CreateDirectoryW(container->path, 0))
            file = CreateFileW(index_path, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL);
    }
    if(file == INVALID_HANDLE_VALUE) {
        TRACE("Could not open or create cache index file \"%s\"\n", debugstr_w(index_path));
        ReleaseMutex(container->mutex);
        return GetLastError();
    }

    file_size = GetFileSize(file, NULL);
    if(file_size == INVALID_FILE_SIZE) {
        CloseHandle(file);
    ReleaseMutex(container->mutex);
        return GetLastError();
    }

    if(blocks_no < MIN_BLOCK_NO)
        blocks_no = MIN_BLOCK_NO;
    else if(blocks_no > MAX_BLOCK_NO)
        blocks_no = MAX_BLOCK_NO;

    if(file_size < FILE_SIZE(blocks_no)) {
        DWORD ret = cache_container_set_size(container, file, blocks_no);
        CloseHandle(file);
        ReleaseMutex(container->mutex);
        return ret;
    }

    container->file_size = file_size;
    container->mapping = cache_container_map_index(file, container->path, file_size, &validate);
    CloseHandle(file);
    if(container->mapping && validate) {
        urlcache_header *header = MapViewOfFile(container->mapping, FILE_MAP_WRITE, 0, 0, 0);

        if(header && !cache_container_is_valid(header, file_size)) {
            WARN("detected old or broken index.dat file\n");
            UnmapViewOfFile(header);
            FreeUrlCacheSpaceW(container->path, 100, 0);
        }else if(header) {
            UnmapViewOfFile(header);
        }else {
            CloseHandle(container->mapping);
            container->mapping = NULL;
        }
    }

    if(!container->mapping)
    {
        ERR("Couldn't create file mapping (error is %d)\n", GetLastError());
        ReleaseMutex(container->mutex);
        return GetLastError();
    }

    ReleaseMutex(container->mutex);
    return ERROR_SUCCESS;
}

Referenced by cache_container_clean_index(), cache_container_lock_index(), DeleteUrlCacheEntryA(), FreeUrlCacheSpaceW(), GetUrlCacheConfigInfoW(), IsUrlCacheEntryExpiredA(), SetUrlCacheEntryInfoA(), UnlockUrlCacheEntryFileA(), urlcache_entry_commit(), urlcache_entry_create(), urlcache_entry_get_file(), urlcache_find_next_entry(), and urlcache_get_entry_info().

cache_container_set_size()

static DWORD cache_container_set_size ( cache_container *  container, HANDLE  file, DWORD  blocks_no  )

static

Definition at line 420 of file urlcache.c.

{
    static const WCHAR cache_content_key[] = {'S','o','f','t','w','a','r','e','\\',
        'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
        'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
        'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
        'C','a','c','h','e','\\','C','o','n','t','e','n','t',0};
    static const WCHAR cache_limit[] = {'C','a','c','h','e','L','i','m','i','t',0};

    DWORD file_size = FILE_SIZE(blocks_no);
    WCHAR dir_path[MAX_PATH], *dir_name;
    entry_hash_table *hashtable_entry;
    urlcache_header *header;
    HANDLE mapping;
    FILETIME ft;
    HKEY key;
    int i, j;

    if(SetFilePointer(file, file_size, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
        return GetLastError();

    if(!SetEndOfFile(file))
        return GetLastError();

    mapping = cache_container_map_index(file, container->path, file_size, NULL);
    if(!mapping)
        return GetLastError();

    header = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0);
    if(!header) {
        CloseHandle(mapping);
        return GetLastError();
    }

    if(blocks_no != MIN_BLOCK_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->mapping);
        container->mapping = mapping;
        container->file_size = file_size;
        return ERROR_SUCCESS;
    }

    memset(header, 0, file_size);
    /* First set some constants and defaults in the header */
    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->cache_limit.QuadPart = 0x07ff5400;
    /* Copied from a Windows 2000 cache index */
    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) {
        DWORD dw, len = sizeof(dw), keytype;

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

    urlcache_create_hash_table(header, NULL, &hashtable_entry);

    /* Last step - create the directories */
    strcpyW(dir_path, container->path);
    dir_name = dir_path + strlenW(dir_path);
    dir_name[8] = 0;

    GetSystemTimeAsFileTime(&ft);

    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;

            /* Generate a file name to attempt to create.
             * This algorithm will create what will appear
             * to be random and unrelated directory names
             * of up to 9 characters in length.
             */
            n <<= 32;
            n += ft.dwLowDateTime;
            n ^= ((ULONGLONG) i << 56) | ((ULONGLONG) j << 48);

            for(k = 0; k < 8; ++k) {
                int r = (n % 36);

                /* Dividing by a prime greater than 36 helps
                 * with the appearance of randomness
                 */
                n /= 37;

                if(r < 10)
                    dir_name[k] = '0' + r;
                else
                    dir_name[k] = 'A' + (r - 10);
            }

            if(CreateDirectoryW(dir_path, 0)) {
                /* The following is OK because we generated an
                 * 8 character directory name made from characters
                 * [A-Z0-9], which are equivalent for all code
                 * pages and for UTF-16
                 */
                for (k = 0; k < 8; ++k)
                    header->directory_data[i].name[k] = dir_name[k];
                break;
            }else if(j >= 255) {
                /* Give up. The most likely cause of this
                 * is a full disk, but whatever the cause
                 * is, it should be more than apparent that
                 * we won't succeed.
                 */
                UnmapViewOfFile(header);
                CloseHandle(mapping);
                return GetLastError();
            }
        }
    }

    UnmapViewOfFile(header);
    CloseHandle(container->mapping);
    container->mapping = mapping;
    container->file_size = file_size;
    return ERROR_SUCCESS;
}

Referenced by cache_container_open_index().

cache_container_unlock_index()

static BOOL cache_container_unlock_index ( cache_container *  pContainer, urlcache_header *  pHeader  )

static

Definition at line 985 of file urlcache.c.

{
    /* release mutex */
    ReleaseMutex(pContainer->mutex);
    return UnmapViewOfFile(pHeader);
}

Referenced by DeleteUrlCacheEntryA(), FreeUrlCacheSpaceW(), IsUrlCacheEntryExpiredA(), SetUrlCacheEntryInfoA(), UnlockUrlCacheEntryFileA(), urlcache_entry_commit(), urlcache_entry_create(), urlcache_entry_get_file(), urlcache_find_next_entry(), and urlcache_get_entry_info().

cache_containers_add()

static BOOL cache_containers_add ( const char *  cache_prefix, LPCWSTR  path, DWORD  default_entry_type, LPWSTR  mutex_name  )

static

Definition at line 694 of file urlcache.c.

{
    cache_container *pContainer = heap_alloc(sizeof(cache_container));
    int cache_prefix_len = strlen(cache_prefix);

    if (!pContainer)
    {
        return FALSE;
    }

    pContainer->mapping = NULL;
    pContainer->file_size = 0;
    pContainer->default_entry_type = default_entry_type;

    pContainer->path = heap_strdupW(path);
    if (!pContainer->path)
    {
        heap_free(pContainer);
        return FALSE;
    }

    pContainer->cache_prefix = heap_alloc(cache_prefix_len+1);
    if (!pContainer->cache_prefix)
    {
        heap_free(pContainer->path);
        heap_free(pContainer);
        return FALSE;
    }

    memcpy(pContainer->cache_prefix, cache_prefix, cache_prefix_len+1);

    CharLowerW(mutex_name);
    cache_container_create_object_name(mutex_name, '!');

    if ((pContainer->mutex = CreateMutexW(NULL, FALSE, mutex_name)) == NULL)
    {
        ERR("couldn't create mutex (error is %d)\n", GetLastError());
        heap_free(pContainer->path);
        heap_free(pContainer);
        return FALSE;
    }

    list_add_head(&UrlContainers, &pContainer->entry);

    return TRUE;
}

Referenced by cache_containers_init().

cache_containers_enum()

static BOOL cache_containers_enum ( char *  search_pattern, DWORD  index, cache_container **  ret  )

static

Definition at line 875 of file urlcache.c.

{
    DWORD i = 0;
    cache_container *container;

    TRACE("searching for prefix: %s\n", debugstr_a(search_pattern));

    /* non-NULL search pattern only returns one container ever */
    if (search_pattern && index > 0)
        return FALSE;

#ifdef __REACTOS__
    /* ReactOS r54992 */
    if (!bDefaultContainersAdded)
        cache_containers_init();
#endif

    LIST_FOR_EACH_ENTRY(container, &UrlContainers, cache_container, entry)
    {
        if (search_pattern)
        {
            if (!strcmp(container->cache_prefix, search_pattern))
            {
                TRACE("found container with prefix %s\n", debugstr_a(container->cache_prefix));
                *ret = container;
                return TRUE;
            }
        }
        else
        {
            if (i == index)
            {
                TRACE("found container with prefix %s\n", debugstr_a(container->cache_prefix));
                *ret = container;
                return TRUE;
            }
        }
        i++;
    }
    return FALSE;
}

Referenced by urlcache_find_next_entry().

cache_containers_find()

static DWORD cache_containers_find ( const char *  url, cache_container **  ret  )

static

Definition at line 845 of file urlcache.c.

{
    cache_container *container;

    TRACE("searching for prefix for URL: %s\n", debugstr_a(url));

    if(!url)
        return ERROR_INVALID_PARAMETER;

#ifdef __REACTOS__
    /* ReactOS r54992 */
    if (!bDefaultContainersAdded)
        cache_containers_init();
#endif

    LIST_FOR_EACH_ENTRY(container, &UrlContainers, cache_container, entry)
    {
        int prefix_len = strlen(container->cache_prefix);

        if(!strncmp(container->cache_prefix, url, prefix_len)) {
            TRACE("found container with prefix %s\n", debugstr_a(container->cache_prefix));
            *ret = container;
            return ERROR_SUCCESS;
        }
    }

    ERR("no container found\n");
    return ERROR_FILE_NOT_FOUND;
}

Referenced by DeleteUrlCacheEntryA(), IsUrlCacheEntryExpiredA(), SetUrlCacheEntryInfoA(), UnlockUrlCacheEntryFileA(), urlcache_entry_commit(), urlcache_entry_create(), urlcache_entry_get_file(), and urlcache_get_entry_info().

cache_containers_free()

static void cache_containers_free ( void  )

static

Definition at line 837 of file urlcache.c.

{
    while(!list_empty(&UrlContainers))
        cache_container_delete_container(
            LIST_ENTRY(list_head(&UrlContainers), cache_container, entry)
        );
}

Referenced by free_urlcache().

cache_containers_init()

static void cache_containers_init ( void  )

static

Definition at line 753 of file urlcache.c.

{
    static const WCHAR UrlSuffix[] = {'C','o','n','t','e','n','t','.','I','E','5',0};
    static const WCHAR HistorySuffix[] = {'H','i','s','t','o','r','y','.','I','E','5',0};
    static const WCHAR CookieSuffix[] = {0};
    /* ReactOS r50916 */
    static const WCHAR UserProfile[] = {'U','S','E','R','P','R','O','F','I','L','E',0};
    static const struct
    {
        int nFolder; /* CSIDL_* constant */
        const WCHAR *shpath_suffix; /* suffix on path returned by SHGetSpecialFolderPath */
        const char *cache_prefix; /* prefix used to reference the container */
        DWORD default_entry_type;
    } DefaultContainerData[] = 
    {
        { CSIDL_INTERNET_CACHE, UrlSuffix, "", NORMAL_CACHE_ENTRY },
        { CSIDL_HISTORY, HistorySuffix, "Visited:", URLHISTORY_CACHE_ENTRY },
        { CSIDL_COOKIES, CookieSuffix, "Cookie:", COOKIE_CACHE_ENTRY },
    };
    DWORD i;

    /* ReactOS r50916 */
    if (GetEnvironmentVariableW(UserProfile, NULL, 0) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND)
    {
        ERR("Environment variable 'USERPROFILE' does not exist!\n");
        return;
    }

    for (i = 0; i < ARRAY_SIZE(DefaultContainerData); i++)
    {
        WCHAR wszCachePath[MAX_PATH];
        WCHAR wszMutexName[MAX_PATH];
        int path_len, suffix_len;
        BOOL def_char;

        if (!SHGetSpecialFolderPathW(NULL, wszCachePath, DefaultContainerData[i].nFolder, TRUE))
        {
            ERR("Couldn't get path for default container %u\n", i);
            continue;
        }
        path_len = strlenW(wszCachePath);
        suffix_len = strlenW(DefaultContainerData[i].shpath_suffix);

        if (path_len + suffix_len + 2 > MAX_PATH)
        {
            ERR("Path too long\n");
            continue;
        }

        wszCachePath[path_len] = '\\';
        wszCachePath[path_len+1] = 0;

        strcpyW(wszMutexName, wszCachePath);
        
        if (suffix_len)
        {
            memcpy(wszCachePath + path_len + 1, DefaultContainerData[i].shpath_suffix, (suffix_len + 1) * sizeof(WCHAR));
            wszCachePath[path_len + suffix_len + 1] = '\\';
            wszCachePath[path_len + suffix_len + 2] = '\0';
        }

        if (!WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, wszCachePath, path_len,
                    NULL, 0, NULL, &def_char) || def_char)
        {
            WCHAR tmp[MAX_PATH];

            /* cannot convert path to ANSI code page */
            if (!(path_len = GetShortPathNameW(wszCachePath, tmp, MAX_PATH)) ||
                !WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, tmp, path_len,
                    NULL, 0, NULL, &def_char) || def_char)
                ERR("Can't create container path accessible by ANSI functions\n");
            else
                memcpy(wszCachePath, tmp, (path_len+1)*sizeof(WCHAR));
        }

        cache_containers_add(DefaultContainerData[i].cache_prefix, wszCachePath,
                DefaultContainerData[i].default_entry_type, wszMutexName);
    }

#ifdef __REACTOS__
    bDefaultContainersAdded = TRUE;
#endif
}

Referenced by cache_containers_enum(), cache_containers_find(), and init_urlcache().

CommitUrlCacheEntryA()

BOOL WINAPI CommitUrlCacheEntryA	(	LPCSTR	lpszUrlName,
		LPCSTR	lpszLocalFileName,
		FILETIME	ExpireTime,
		FILETIME	LastModifiedTime,
		DWORD	CacheEntryType,
		LPBYTE	lpHeaderInfo,
		DWORD	dwHeaderSize,
		LPCSTR	lpszFileExtension,
		LPCSTR	lpszOriginalUrl
	)

Definition at line 3075 of file urlcache.c.

{
    WCHAR *file_name = NULL;
    BOOL ret;

    if(lpszLocalFileName) {
        file_name = heap_strdupAtoW(lpszLocalFileName);
        if(!file_name)
            return FALSE;
    }

    ret = urlcache_entry_commit(lpszUrlName, file_name, ExpireTime, LastModifiedTime,
            CacheEntryType, lpHeaderInfo, dwHeaderSize, lpszFileExtension, lpszOriginalUrl);
    heap_free(file_name);
    return ret;
}

Referenced by create_cache_entry(), test_cache_read(), test_http_cache(), test_trailing_slash(), and test_urlcacheA().

CommitUrlCacheEntryW()

BOOL WINAPI CommitUrlCacheEntryW	(	LPCWSTR	lpszUrlName,
		LPCWSTR	lpszLocalFileName,
		FILETIME	ExpireTime,
		FILETIME	LastModifiedTime,
		DWORD	CacheEntryType,
		LPWSTR	lpHeaderInfo,
		DWORD	dwHeaderSize,
		LPCWSTR	lpszFileExtension,
		LPCWSTR	lpszOriginalUrl
	)

Definition at line 3097 of file urlcache.c.

{
    char *url, *original_url=NULL, *file_ext=NULL, *header_info=NULL;
    BOOL ret;

    if(!urlcache_encode_url_alloc(lpszUrlName, &url))
        return FALSE;

    if(lpHeaderInfo) {
        header_info = heap_strdupWtoUTF8(lpHeaderInfo);
        if(!header_info) {
            heap_free(url);
            return FALSE;
        }
        dwHeaderSize = strlen(header_info);
    }

    if(lpszFileExtension) {
        file_ext = heap_strdupWtoA(lpszFileExtension);
        if(!file_ext) {
            heap_free(url);
            heap_free(header_info);
            return FALSE;
        }
    }

    if(lpszOriginalUrl && !urlcache_encode_url_alloc(lpszOriginalUrl, &original_url)) {
        heap_free(url);
        heap_free(header_info);
        heap_free(file_ext);
        return FALSE;
    }

    ret = urlcache_entry_commit(url, lpszLocalFileName, ExpireTime, LastModifiedTime,
            CacheEntryType, (BYTE*)header_info, dwHeaderSize, file_ext, original_url);
    heap_free(url);
    heap_free(header_info);
    heap_free(file_ext);
    heap_free(original_url);
    return ret;
}

Referenced by commit_cache_entry(), CRYPT_CacheURL(), save_persistent_cookie(), test_urlcacheW(), and URLDownloadToCacheFileW().

CreateUrlCacheContainerA()

BOOL WINAPI CreateUrlCacheContainerA	(	DWORD	d1,
		DWORD	d2,
		DWORD	d3,
		DWORD	d4,
		DWORD	d5,
		DWORD	d6,
		DWORD	d7,
		DWORD	d8
	)

Definition at line 3384 of file urlcache.c.

{
    FIXME("(0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x) stub\n",
          d1, d2, d3, d4, d5, d6, d7, d8);
    return TRUE;
}

CreateUrlCacheContainerW()

BOOL WINAPI CreateUrlCacheContainerW	(	DWORD	d1,
		DWORD	d2,
		DWORD	d3,
		DWORD	d4,
		DWORD	d5,
		DWORD	d6,
		DWORD	d7,
		DWORD	d8
	)

Definition at line 3395 of file urlcache.c.

{
    FIXME("(0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x) stub\n",
          d1, d2, d3, d4, d5, d6, d7, d8);
    return TRUE;
}

CreateUrlCacheEntryA()

BOOL WINAPI CreateUrlCacheEntryA	(	LPCSTR	lpszUrlName,
		DWORD	dwExpectedFileSize,
		LPCSTR	lpszFileExtension,
		LPSTR	lpszFileName,
		DWORD	dwReserved
	)

Definition at line 2808 of file urlcache.c.

{
    WCHAR file_name[MAX_PATH];

    if(dwReserved)
        FIXME("dwReserved 0x%08x\n", dwReserved);

    if(!urlcache_entry_create(lpszUrlName, lpszFileExtension, file_name))
        return FALSE;

    if(!WideCharToMultiByte(CP_ACP, 0, file_name, -1, lpszFileName, MAX_PATH, NULL, NULL))
        return FALSE;
    return TRUE;
}

Referenced by create_cache_entry(), test_cache_read(), test_trailing_slash(), and test_urlcacheA().

CreateUrlCacheEntryW()

BOOL WINAPI CreateUrlCacheEntryW	(	LPCWSTR	lpszUrlName,
		DWORD	dwExpectedFileSize,
		LPCWSTR	lpszFileExtension,
		LPWSTR	lpszFileName,
		DWORD	dwReserved
	)

Definition at line 2827 of file urlcache.c.

{
    char *url, *ext = NULL;
    BOOL ret;

    if(dwReserved)
        FIXME("dwReserved 0x%08x\n", dwReserved);

    if(lpszFileExtension) {
        ext = heap_strdupWtoUTF8(lpszFileExtension);
        if(!ext)
            return FALSE;
    }

    if(!urlcache_encode_url_alloc(lpszUrlName, &url)) {
        heap_free(ext);
        return FALSE;
    }

    ret = urlcache_entry_create(url, ext, lpszFileName);
    heap_free(ext);
    heap_free(url);
    return ret;
}

Referenced by create_cache_entry(), CRYPT_CacheURL(), FTP_FtpOpenFileW(), save_persistent_cookie(), test_urlcacheW(), and URLDownloadToCacheFileW().

CreateUrlCacheGroup()

INTERNETAPI GROUPID WINAPI CreateUrlCacheGroup	(	DWORD	dwFlags,
		LPVOID	lpReserved
	)

Definition at line 3735 of file urlcache.c.

{
  FIXME("(0x%08x, %p): stub\n", dwFlags, lpReserved);
  return FALSE;
}

DeleteIE3Cache()

DWORD WINAPI DeleteIE3Cache	(	HWND	hWnd,
		HINSTANCE	hInst,
		LPSTR	lpszCmdLine,
		int	nCmdShow
	)

Definition at line 3958 of file urlcache.c.

{
    FIXME("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_a(lpszCmdLine), nCmdShow);
    return 0;
}

DeleteUrlCacheContainerA()

BOOL WINAPI DeleteUrlCacheContainerA	(	DWORD	d1,
		DWORD	d2
	)

Definition at line 3369 of file urlcache.c.

{
    FIXME("(0x%08x, 0x%08x) stub\n", d1, d2);
    return TRUE;
}

DeleteUrlCacheContainerW()

BOOL WINAPI DeleteUrlCacheContainerW	(	DWORD	d1,
		DWORD	d2
	)

Definition at line 3375 of file urlcache.c.

{
    FIXME("(0x%08x, 0x%08x) stub\n", d1, d2);
    return TRUE;
}

DeleteUrlCacheEntryA()

BOOL WINAPI DeleteUrlCacheEntryA

(

LPCSTR

lpszUrlName

)

Definition at line 3310 of file urlcache.c.

{
    cache_container *pContainer;
    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    DWORD error;
    BOOL ret;

    TRACE("(%s)\n", debugstr_a(lpszUrlName));

    error = cache_containers_find(lpszUrlName, &pContainer);
    if (error != ERROR_SUCCESS)
    {
        SetLastError(error);
        return FALSE;
    }

    error = cache_container_open_index(pContainer, MIN_BLOCK_NO);
    if (error != ERROR_SUCCESS)
    {
        SetLastError(error);
        return FALSE;
    }

    if (!(pHeader = cache_container_lock_index(pContainer)))
        return FALSE;

    if (!urlcache_find_hash_entry(pHeader, lpszUrlName, &pHashEntry))
    {
        cache_container_unlock_index(pContainer, pHeader);
        TRACE("entry %s not found!\n", debugstr_a(lpszUrlName));
        SetLastError(ERROR_FILE_NOT_FOUND);
        return FALSE;
    }

    ret = urlcache_entry_delete(pContainer, pHeader, pHashEntry);

    cache_container_unlock_index(pContainer, pHeader);

    return ret;
}

Referenced by DeleteUrlCacheEntryW(), InternetOpenUrlA_test(), test_cache_read(), test_cache_read_gzipped(), test_http_cache(), test_no_cache(), and test_trailing_slash().

DeleteUrlCacheEntryW()

BOOL WINAPI DeleteUrlCacheEntryW

(

LPCWSTR

lpszUrlName

)

Definition at line 3356 of file urlcache.c.

{
    char *url;
    BOOL ret;

    if(!urlcache_encode_url_alloc(lpszUrlName, &url))
        return FALSE;

    ret = DeleteUrlCacheEntryA(url);
    heap_free(url);
    return ret;
}

Referenced by CRYPT_CacheURL(), CRYPT_GetObjectFromCache(), save_persistent_cookie(), and test_http_protocol_url().

DeleteUrlCacheGroup()

BOOL WINAPI DeleteUrlCacheGroup	(	GROUPID	GroupId,
		DWORD	dwFlags,
		LPVOID	lpReserved
	)

Definition at line 3745 of file urlcache.c.

{
    FIXME("(0x%s, 0x%08x, %p) stub\n",
          wine_dbgstr_longlong(GroupId), dwFlags, lpReserved);
    return FALSE;
}

DeleteWpadCacheForNetworks()

BOOL WINAPI DeleteWpadCacheForNetworks

(

DWORD

unk1

)

Definition at line 3756 of file urlcache.c.

{
    FIXME("(%d) stub\n", unk1);
    return FALSE;
}

dos_date_time_to_file_time()

static void dos_date_time_to_file_time ( WORD  fatdate, WORD  fattime, FILETIME *  ft  )

static

Definition at line 1234 of file urlcache.c.

{
    if (!fatdate && !fattime)
        ft->dwLowDateTime = ft->dwHighDateTime = 0;
    else
        DosDateTimeToFileTime(fatdate, fattime, ft);
}

Referenced by urlcache_copy_entry(), and urlcache_entry_is_expired().

dword_cmp()

static int dword_cmp ( const void *  p1, const void *  p2  )

static

Definition at line 2361 of file urlcache.c.

{
    return *(const DWORD*)p1 - *(const DWORD*)p2;
}

Referenced by FreeUrlCacheSpaceW().

file_time_to_dos_date_time()

static void file_time_to_dos_date_time ( const FILETIME *  ft, WORD *  fatdate, WORD *  fattime  )

static

Definition at line 1107 of file urlcache.c.

{
    if (!ft->dwLowDateTime && !ft->dwHighDateTime)
        *fatdate = *fattime = 0;
    else
        FileTimeToDosDateTime(ft, fatdate, fattime);
}

Referenced by urlcache_delete_file(), urlcache_entry_commit(), and urlcache_set_entry_info().

find_container()

static cache_container* find_container ( DWORD  flags )

static

Definition at line 3792 of file urlcache.c.

{
    cache_container *container;

    LIST_FOR_EACH_ENTRY(container, &UrlContainers, cache_container, entry)
    {
        switch (flags & (CACHE_CONFIG_CONTENT_PATHS_FC | CACHE_CONFIG_COOKIES_PATHS_FC | CACHE_CONFIG_HISTORY_PATHS_FC))
        {
        case 0:
        case CACHE_CONFIG_CONTENT_PATHS_FC:
            if (container->default_entry_type == NORMAL_CACHE_ENTRY)
                return container;
            break;

        case CACHE_CONFIG_COOKIES_PATHS_FC:
            if (container->default_entry_type == COOKIE_CACHE_ENTRY)
                return container;
            break;

        case CACHE_CONFIG_HISTORY_PATHS_FC:
            if (container->default_entry_type == URLHISTORY_CACHE_ENTRY)
                return container;
            break;

        default:
            FIXME("flags %08x not handled\n", flags);
            break;
        }
    }

    return NULL;
}

Referenced by GetUrlCacheConfigInfoW().

FindCloseUrlCache()

BOOL WINAPI FindCloseUrlCache

(

HANDLE

hEnumHandle

)

Definition at line 3671 of file urlcache.c.

{
    find_handle *pEntryHandle = (find_handle*)hEnumHandle;

    TRACE("(%p)\n", hEnumHandle);

    if (!pEntryHandle || pEntryHandle->magic != URLCACHE_FIND_ENTRY_HANDLE_MAGIC)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    pEntryHandle->magic = 0;
    heap_free(pEntryHandle->url_search_pattern);
    heap_free(pEntryHandle);
    return TRUE;
}

Referenced by test_find_url_cache_entriesA(), and test_FindCloseUrlCache().

FindFirstUrlCacheContainerA()

HANDLE WINAPI FindFirstUrlCacheContainerA	(	LPVOID	p1,
		LPVOID	p2,
		LPVOID	p3,
		DWORD	d1
	)

Definition at line 3406 of file urlcache.c.

{
    FIXME("(%p, %p, %p, 0x%08x) stub\n", p1, p2, p3, d1 );
    return NULL;
}

FindFirstUrlCacheContainerW()

HANDLE WINAPI FindFirstUrlCacheContainerW	(	LPVOID	p1,
		LPVOID	p2,
		LPVOID	p3,
		DWORD	d1
	)

Definition at line 3415 of file urlcache.c.

{
    FIXME("(%p, %p, %p, 0x%08x) stub\n", p1, p2, p3, d1 );
    return NULL;
}

FindFirstUrlCacheEntryA()

INTERNETAPI HANDLE WINAPI FindFirstUrlCacheEntryA	(	LPCSTR	lpszUrlSearchPattern,
		LPINTERNET_CACHE_ENTRY_INFOA	lpFirstCacheEntryInfo,
		LPDWORD	lpdwFirstCacheEntryInfoBufferSize
	)

Definition at line 3481 of file urlcache.c.

{
    find_handle *pEntryHandle;

    TRACE("(%s, %p, %p)\n", debugstr_a(lpszUrlSearchPattern), lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize);

    pEntryHandle = heap_alloc(sizeof(*pEntryHandle));
    if (!pEntryHandle)
        return NULL;

    pEntryHandle->magic = URLCACHE_FIND_ENTRY_HANDLE_MAGIC;
    if (lpszUrlSearchPattern)
    {
        pEntryHandle->url_search_pattern = heap_strdupA(lpszUrlSearchPattern);
        if (!pEntryHandle->url_search_pattern)
        {
            heap_free(pEntryHandle);
            return NULL;
        }
    }
    else
        pEntryHandle->url_search_pattern = NULL;
    pEntryHandle->container_idx = 0;
    pEntryHandle->hash_table_idx = 0;
    pEntryHandle->hash_entry_idx = 0;

    if (!FindNextUrlCacheEntryA(pEntryHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize))
    {
        heap_free(pEntryHandle);
        return NULL;
    }
    return pEntryHandle;
}

Referenced by test_find_url_cache_entriesA().

FindFirstUrlCacheEntryExA()

HANDLE WINAPI FindFirstUrlCacheEntryExA	(	LPCSTR	lpszUrlSearchPattern,
		DWORD	dwFlags,
		DWORD	dwFilter,
		GROUPID	GroupId,
		LPINTERNET_CACHE_ENTRY_INFOA	lpFirstCacheEntryInfo,
		LPDWORD	lpdwFirstCacheEntryInfoBufferSize,
		LPVOID	lpReserved,
		LPDWORD	pcbReserved2,
		LPVOID	lpReserved3
	)

Definition at line 3439 of file urlcache.c.

{
    FIXME("(%s, 0x%08x, 0x%08x, 0x%s, %p, %p, %p, %p, %p) stub\n", debugstr_a(lpszUrlSearchPattern),
          dwFlags, dwFilter, wine_dbgstr_longlong(GroupId), lpFirstCacheEntryInfo,
          lpdwFirstCacheEntryInfoBufferSize, lpReserved, pcbReserved2,lpReserved3);
    SetLastError(ERROR_FILE_NOT_FOUND);
    return NULL;
}

FindFirstUrlCacheEntryExW()

HANDLE WINAPI FindFirstUrlCacheEntryExW	(	LPCWSTR	lpszUrlSearchPattern,
		DWORD	dwFlags,
		DWORD	dwFilter,
		GROUPID	GroupId,
		LPINTERNET_CACHE_ENTRY_INFOW	lpFirstCacheEntryInfo,
		LPDWORD	lpdwFirstCacheEntryInfoBufferSize,
		LPVOID	lpReserved,
		LPDWORD	pcbReserved2,
		LPVOID	lpReserved3
	)

Definition at line 3458 of file urlcache.c.

{
    FIXME("(%s, 0x%08x, 0x%08x, 0x%s, %p, %p, %p, %p, %p) stub\n", debugstr_w(lpszUrlSearchPattern),
          dwFlags, dwFilter, wine_dbgstr_longlong(GroupId), lpFirstCacheEntryInfo,
          lpdwFirstCacheEntryInfoBufferSize, lpReserved, pcbReserved2,lpReserved3);
    SetLastError(ERROR_FILE_NOT_FOUND);
    return NULL;
}

FindFirstUrlCacheEntryW()

INTERNETAPI HANDLE WINAPI FindFirstUrlCacheEntryW	(	LPCWSTR	lpszUrlSearchPattern,
		LPINTERNET_CACHE_ENTRY_INFOW	lpFirstCacheEntryInfo,
		LPDWORD	lpdwFirstCacheEntryInfoBufferSize
	)

Definition at line 3520 of file urlcache.c.

{
    find_handle *pEntryHandle;

    TRACE("(%s, %p, %p)\n", debugstr_w(lpszUrlSearchPattern), lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize);

    pEntryHandle = heap_alloc(sizeof(*pEntryHandle));
    if (!pEntryHandle)
        return NULL;

    pEntryHandle->magic = URLCACHE_FIND_ENTRY_HANDLE_MAGIC;
    if (lpszUrlSearchPattern)
    {
        pEntryHandle->url_search_pattern = heap_strdupWtoA(lpszUrlSearchPattern);
        if (!pEntryHandle->url_search_pattern)
        {
            heap_free(pEntryHandle);
            return NULL;
        }
    }
    else
        pEntryHandle->url_search_pattern = NULL;
    pEntryHandle->container_idx = 0;
    pEntryHandle->hash_table_idx = 0;
    pEntryHandle->hash_entry_idx = 0;

    if (!FindNextUrlCacheEntryW(pEntryHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize))
    {
        heap_free(pEntryHandle);
        return NULL;
    }
    return pEntryHandle;
}

FindFirstUrlCacheGroup()

HANDLE WINAPI FindFirstUrlCacheGroup	(	DWORD	dwFlags,
		DWORD	dwFilter,
		LPVOID	lpSearchCondition,
		DWORD	dwSearchCondition,
		GROUPID *	lpGroupId,
		LPVOID	lpReserved
	)

Definition at line 3689 of file urlcache.c.

{
    FIXME("(0x%08x, 0x%08x, %p, 0x%08x, %p, %p) stub\n", dwFlags, dwFilter, lpSearchCondition,
          dwSearchCondition, lpGroupId, lpReserved);
    return NULL;
}

FindNextUrlCacheContainerA()

BOOL WINAPI FindNextUrlCacheContainerA	(	HANDLE	handle,
		LPVOID	p1,
		LPVOID	p2
	)

Definition at line 3424 of file urlcache.c.

{
    FIXME("(%p, %p, %p) stub\n", handle, p1, p2 );
    return FALSE;
}

FindNextUrlCacheContainerW()

BOOL WINAPI FindNextUrlCacheContainerW	(	HANDLE	handle,
		LPVOID	p1,
		LPVOID	p2
	)

Definition at line 3433 of file urlcache.c.

{
    FIXME("(%p, %p, %p) stub\n", handle, p1, p2 );
    return FALSE;
}

FindNextUrlCacheEntryA()

BOOL WINAPI FindNextUrlCacheEntryA	(	HANDLE	hEnumHandle,
		LPINTERNET_CACHE_ENTRY_INFOA	lpNextCacheEntryInfo,
		LPDWORD	lpdwNextCacheEntryInfoBufferSize
	)

Definition at line 3641 of file urlcache.c.

{
    TRACE("(%p, %p, %p)\n", hEnumHandle, lpNextCacheEntryInfo, lpdwNextCacheEntryInfoBufferSize);

    return urlcache_find_next_entry(hEnumHandle, lpNextCacheEntryInfo,
            lpdwNextCacheEntryInfoBufferSize, FALSE /* not UNICODE */);
}

Referenced by FindFirstUrlCacheEntryA(), and test_find_url_cache_entriesA().

FindNextUrlCacheEntryExA()

BOOL WINAPI FindNextUrlCacheEntryExA	(	HANDLE	hEnumHandle,
		LPINTERNET_CACHE_ENTRY_INFOA	lpFirstCacheEntryInfo,
		LPDWORD	lpdwFirstCacheEntryInfoBufferSize,
		LPVOID	lpReserved,
		LPDWORD	pcbReserved2,
		LPVOID	lpReserved3
	)

Definition at line 3697 of file urlcache.c.

{
    FIXME("(%p, %p, %p, %p, %p, %p) stub\n", hEnumHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize,
          lpReserved, pcbReserved2, lpReserved3);
    return FALSE;
}

FindNextUrlCacheEntryExW()

BOOL WINAPI FindNextUrlCacheEntryExW	(	HANDLE	hEnumHandle,
		LPINTERNET_CACHE_ENTRY_INFOW	lpFirstCacheEntryInfo,
		LPDWORD	lpdwFirstCacheEntryInfoBufferSize,
		LPVOID	lpReserved,
		LPDWORD	pcbReserved2,
		LPVOID	lpReserved3
	)

Definition at line 3711 of file urlcache.c.

{
    FIXME("(%p, %p, %p, %p, %p, %p) stub\n", hEnumHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize,
          lpReserved, pcbReserved2, lpReserved3);
    return FALSE;
}

FindNextUrlCacheEntryW()

BOOL WINAPI FindNextUrlCacheEntryW	(	HANDLE	hEnumHandle,
		LPINTERNET_CACHE_ENTRY_INFOW	lpNextCacheEntryInfo,
		LPDWORD	lpdwNextCacheEntryInfoBufferSize
	)

Definition at line 3655 of file urlcache.c.

{
    TRACE("(%p, %p, %p)\n", hEnumHandle, lpNextCacheEntryInfo, lpdwNextCacheEntryInfoBufferSize);

    return urlcache_find_next_entry(hEnumHandle,
            (LPINTERNET_CACHE_ENTRY_INFOA)lpNextCacheEntryInfo,
            lpdwNextCacheEntryInfoBufferSize, TRUE /* UNICODE */);
}

Referenced by FindFirstUrlCacheEntryW().

FindNextUrlCacheGroup()

BOOL WINAPI FindNextUrlCacheGroup	(	HANDLE	hFind,
		GROUPID *	lpGroupId,
		LPVOID	lpReserved
	)

Definition at line 3725 of file urlcache.c.

{
    FIXME("(%p, %p, %p) stub\n", hFind, lpGroupId, lpReserved);
    return FALSE;
}

free_urlcache()

void free_urlcache

(

void

)

Definition at line 4142 of file urlcache.c.

{
    SetEvent(dll_unload_event);
    WaitForSingleObject(free_cache_running, INFINITE);
    ReleaseSemaphore(free_cache_running, 1, NULL);
    CloseHandle(free_cache_running);
    CloseHandle(dll_unload_event);

    cache_containers_free();
}

Referenced by DllMain().

FreeUrlCacheSpaceA()

BOOL WINAPI FreeUrlCacheSpaceA	(	LPCSTR	lpszCachePath,
		DWORD	dwSize,
		DWORD	dwFilter
	)

Definition at line 2541 of file urlcache.c.

{
    BOOL ret = FALSE;
    LPWSTR path = heap_strdupAtoW(lpszCachePath);
    if (lpszCachePath == NULL || path != NULL)
        ret = FreeUrlCacheSpaceW(path, dwSize, dwFilter);
    heap_free(path);
    return ret;
}

FreeUrlCacheSpaceW()

BOOL WINAPI FreeUrlCacheSpaceW	(	LPCWSTR	cache_path,
		DWORD	size,
		DWORD	filter
	)

Definition at line 2384 of file urlcache.c.

{
    cache_container *container;
    DWORD path_len, err;

    TRACE("(%s, %x, %x)\n", debugstr_w(cache_path), size, filter);

    if(size<1 || size>100) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    if(cache_path) {
        path_len = strlenW(cache_path);
        if(cache_path[path_len-1] == '\\')
            path_len--;
    }else {
        path_len = 0;
    }

    if(size==100 && !filter) {
        LIST_FOR_EACH_ENTRY(container, &UrlContainers, cache_container, entry)
        {
            /* When cache_path==NULL only clean Temporary Internet Files */
            if((!path_len && container->cache_prefix[0]==0) ||
                    (path_len && !strncmpiW(container->path, cache_path, path_len) &&
                     (container->path[path_len]=='\0' || container->path[path_len]=='\\')))
            {
                BOOL ret_del;

                WaitForSingleObject(container->mutex, INFINITE);

                /* unlock, delete, recreate and lock cache */
                cache_container_close_index(container);
                ret_del = cache_container_delete_dir(container->path);
                err = cache_container_open_index(container, MIN_BLOCK_NO);

                ReleaseMutex(container->mutex);
                if(!ret_del || (err != ERROR_SUCCESS))
                    return FALSE;
            }
        }

        return TRUE;
    }

    LIST_FOR_EACH_ENTRY(container, &UrlContainers, cache_container, entry)
    {
        urlcache_header *header;
        struct hash_entry *hash_entry;
        entry_header *entry;
        entry_url *url_entry;
        ULONGLONG desired_size, cur_size;
        DWORD delete_factor, hash_table_off, hash_table_entry;
        DWORD rate[100], rate_no;
        FILETIME cur_time;

        if((path_len || container->cache_prefix[0]!=0) &&
                (!path_len || strncmpiW(container->path, cache_path, path_len) ||
                 (container->path[path_len]!='\0' && container->path[path_len]!='\\')))
            continue;

        err = cache_container_open_index(container, MIN_BLOCK_NO);
        if(err != ERROR_SUCCESS)
            continue;

        header = cache_container_lock_index(container);
        if(!header)
            continue;

        urlcache_clean_leaked_entries(container, header);

        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
            delete_factor = (cur_size-desired_size)*100/cur_size;

        if(!delete_factor) {
            cache_container_unlock_index(container, header);
            continue;
        }

        hash_table_off = 0;
        hash_table_entry = 0;
        rate_no = 0;
        GetSystemTimeAsFileTime(&cur_time);
        while(rate_no < ARRAY_SIZE(rate) &&
                urlcache_next_entry(header, &hash_table_off, &hash_table_entry, &hash_entry, &entry)) {
            if(entry->signature != URL_SIGNATURE) {
                WARN("only url entries are currently supported\n");
                continue;
            }

            url_entry = (entry_url*)entry;
            if(url_entry->cache_entry_type & filter)
                continue;

            rate[rate_no] = urlcache_rate_entry(url_entry, &cur_time);
            if(rate[rate_no] != -1)
                rate_no++;
        }

        if(!rate_no) {
            TRACE("nothing to delete\n");
            cache_container_unlock_index(container, header);
            continue;
        }

        qsort(rate, rate_no, sizeof(DWORD), dword_cmp);

        delete_factor = delete_factor*rate_no/100;
        delete_factor = rate[delete_factor];
        TRACE("deleting files with rating %d or less\n", delete_factor);

        hash_table_off = 0;
        while(urlcache_next_entry(header, &hash_table_off, &hash_table_entry, &hash_entry, &entry)) {
            if(entry->signature != URL_SIGNATURE)
                continue;

            url_entry = (entry_url*)entry;
            if(url_entry->cache_entry_type & filter)
                continue;

            if(urlcache_rate_entry(url_entry, &cur_time) <= delete_factor) {
                TRACE("deleting file: %s\n", debugstr_a((char*)url_entry+url_entry->local_name_off));
                urlcache_entry_delete(container, header, hash_entry);

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

                /* Allow other threads to use cache while cleaning */
                cache_container_unlock_index(container, header);
                if(WaitForSingleObject(dll_unload_event, 0) == WAIT_OBJECT_0) {
                    TRACE("got dll_unload_event - finishing\n");
                    return TRUE;
                }
                Sleep(0);
                header = cache_container_lock_index(container);
            }
        }

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

    return TRUE;
}

Referenced by cache_container_open_index(), delhist_on_command(), FreeUrlCacheSpaceA(), and handle_full_cache_worker().

GetDiskInfoA()

BOOL WINAPI GetDiskInfoA	(	PCSTR	path,
		PDWORD	cluster_size,
		PDWORDLONG	free,
		PDWORDLONG	total
	)

Definition at line 4074 of file urlcache.c.

{
    BOOL ret;
    ULARGE_INTEGER bytes_free, bytes_total;

    TRACE("(%s, %p, %p, %p)\n", debugstr_a(path), cluster_size, free, total);

    if (!path)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    if ((ret = GetDiskFreeSpaceExA(path, NULL, &bytes_total, &bytes_free)))
    {
        if (cluster_size) *cluster_size = 1;
        if (free) *free = bytes_free.QuadPart;
        if (total) *total = bytes_total.QuadPart;
    }
    return ret;
}

Referenced by test_GetDiskInfoA().

GetUrlCacheConfigInfoA()

BOOL WINAPI GetUrlCacheConfigInfoA	(	LPINTERNET_CACHE_CONFIG_INFOA	info,
		LPDWORD	size,
		DWORD	flags
	)

Definition at line 3869 of file urlcache.c.

{
    INTERNET_CACHE_CONFIG_INFOW infoW;

    TRACE("(%p, %p, %x)\n", info, size, flags);

    if (!info)
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    infoW.dwStructSize = sizeof(infoW);
    if (!GetUrlCacheConfigInfoW(&infoW, size, flags))
        return FALSE;

    info->dwContainer = infoW.dwContainer;
    info->dwQuota = infoW.dwQuota;
    info->dwReserved4 = infoW.dwReserved4;
    info->fPerUser = infoW.fPerUser;
    info->dwSyncMode = infoW.dwSyncMode;
    info->dwNumCachePaths = infoW.dwNumCachePaths;
    info->dwNormalUsage = infoW.dwNormalUsage;
    info->dwExemptUsage = infoW.dwExemptUsage;
    info->u.s.dwCacheSize = infoW.u.s.dwCacheSize;
    WideCharToMultiByte(CP_ACP, 0, infoW.u.s.CachePath, -1, info->u.s.CachePath, MAX_PATH, NULL, NULL);

    return TRUE;
}

Referenced by test_GetUrlCacheConfigInfo().

GetUrlCacheConfigInfoW()

BOOL WINAPI GetUrlCacheConfigInfoW	(	LPINTERNET_CACHE_CONFIG_INFOW	info,
		LPDWORD	size,
		DWORD	flags
	)

Definition at line 3828 of file urlcache.c.

{
    cache_container *container;
    DWORD error;

    FIXME("(%p, %p, %x): semi-stub\n", info, size, flags);

    if (!info || !(container = find_container(flags)))
    {
        INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    error = cache_container_open_index(container, MIN_BLOCK_NO);
    if (error != ERROR_SUCCESS)
    {
        INTERNET_SetLastError(error);
        return FALSE;
    }

    info->dwContainer = 0;
    info->dwQuota = FILE_SIZE(MAX_BLOCK_NO) / 1024;
    info->dwReserved4 = 0;
    info->fPerUser = TRUE;
    info->dwSyncMode = 0;
    info->dwNumCachePaths = 1;
    info->dwNormalUsage = 0;
    info->dwExemptUsage = 0;
    info->u.s.dwCacheSize = container->file_size / 1024;
    lstrcpynW(info->u.s.CachePath, container->path, MAX_PATH);

    cache_container_close_index(container);

    TRACE("CachePath %s\n", debugstr_w(info->u.s.CachePath));

    return TRUE;
}

Referenced by GetUrlCacheConfigInfoA().

GetUrlCacheEntryInfoA()

BOOL WINAPI GetUrlCacheEntryInfoA	(	LPCSTR	lpszUrlName,
		LPINTERNET_CACHE_ENTRY_INFOA	lpCacheEntryInfo,
		LPDWORD	lpdwCacheEntryInfoBufferSize
	)

Definition at line 1898 of file urlcache.c.

{
    return GetUrlCacheEntryInfoExA(lpszUrlName, lpCacheEntryInfo,
            lpdwCacheEntryInfoBufferSize, NULL, NULL, NULL, 0);
}

Referenced by cache_entry_exists(), test_complicated_cookie(), test_IsUrlCacheEntryExpiredA(), test_urlcacheA(), and test_urlcacheW().

GetUrlCacheEntryInfoExA()

BOOL WINAPI GetUrlCacheEntryInfoExA	(	LPCSTR	lpszUrl,
		LPINTERNET_CACHE_ENTRY_INFOA	lpCacheEntryInfo,
		LPDWORD	lpdwCacheEntryInfoBufSize,
		LPSTR	lpszReserved,
		LPDWORD	lpdwReserved,
		LPVOID	lpReserved,
		DWORD	dwFlags
	)

Definition at line 1879 of file urlcache.c.

{
    if(lpszReserved!=NULL || lpdwReserved!=NULL || lpReserved!=NULL) {
        ERR("Reserved value was not 0\n");
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    return urlcache_get_entry_info(lpszUrl, lpCacheEntryInfo,
            lpdwCacheEntryInfoBufSize, dwFlags, FALSE);
}

Referenced by GetUrlCacheEntryInfoA(), and test_GetUrlCacheEntryInfoExA().

GetUrlCacheEntryInfoExW()

BOOL WINAPI GetUrlCacheEntryInfoExW	(	LPCWSTR	lpszUrl,
		LPINTERNET_CACHE_ENTRY_INFOW	lpCacheEntryInfo,
		LPDWORD	lpdwCacheEntryInfoBufSize,
		LPWSTR	lpszReserved,
		LPDWORD	lpdwReserved,
		LPVOID	lpReserved,
		DWORD	dwFlags
	)

Definition at line 1992 of file urlcache.c.

{
    char *url;
    BOOL ret;

    if(lpszReserved!=NULL || lpdwReserved!=NULL || lpReserved!=NULL) {
        ERR("Reserved value was not 0\n");
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    /* Ignore GET_INSTALLED_ENTRY flag in unicode version of function */
    dwFlags &= ~GET_INSTALLED_ENTRY;

    if(!urlcache_encode_url_alloc(lpszUrl, &url))
        return FALSE;

    ret = urlcache_get_entry_info(url, lpCacheEntryInfo,
            lpdwCacheEntryInfoBufSize, dwFlags, TRUE);
    heap_free(url);
    return ret;
}

Referenced by GetUrlCacheEntryInfoW(), and test_GetUrlCacheEntryInfoExA().

GetUrlCacheEntryInfoW()

BOOL WINAPI GetUrlCacheEntryInfoW	(	LPCWSTR	lpszUrl,
		LPINTERNET_CACHE_ENTRY_INFOW	lpCacheEntryInfo,
		LPDWORD	lpdwCacheEntryInfoBufferSize
	)

Definition at line 2022 of file urlcache.c.

{
    return GetUrlCacheEntryInfoExW(lpszUrl, lpCacheEntryInfo,
            lpdwCacheEntryInfoBufferSize, NULL, NULL, NULL, 0);
}

Referenced by CRYPT_CacheURL(), HTTPREQ_QueryOption(), msi_download_file(), and test_urlcacheW().

GetUrlCacheGroupAttributeA()

BOOL WINAPI GetUrlCacheGroupAttributeA	(	GROUPID	gid,
		DWORD	dwFlags,
		DWORD	dwAttributes,
		LPINTERNET_CACHE_GROUP_INFOA	lpGroupInfo,
		LPDWORD	lpdwGroupInfo,
		LPVOID	lpReserved
	)

Definition at line 3899 of file urlcache.c.

{
    FIXME("(0x%s, 0x%08x, 0x%08x, %p, %p, %p) stub\n",
          wine_dbgstr_longlong(gid), dwFlags, dwAttributes, lpGroupInfo,
          lpdwGroupInfo, lpReserved);
    return FALSE;
}

GetUrlCacheGroupAttributeW()

BOOL WINAPI GetUrlCacheGroupAttributeW	(	GROUPID	gid,
		DWORD	dwFlags,
		DWORD	dwAttributes,
		LPINTERNET_CACHE_GROUP_INFOW	lpGroupInfo,
		LPDWORD	lpdwGroupInfo,
		LPVOID	lpReserved
	)

Definition at line 3909 of file urlcache.c.

{
    FIXME("(0x%s, 0x%08x, 0x%08x, %p, %p, %p) stub\n",
          wine_dbgstr_longlong(gid), dwFlags, dwAttributes, lpGroupInfo,
          lpdwGroupInfo, lpReserved);
    return FALSE;
}

handle_full_cache()

static void handle_full_cache ( void  )

static

Definition at line 2260 of file urlcache.c.

{
    if(WaitForSingleObject(free_cache_running, 0) == WAIT_OBJECT_0) {
        if(!QueueUserWorkItem(handle_full_cache_worker, NULL, 0))
            ReleaseSemaphore(free_cache_running, 1, NULL);
    }
}

Referenced by urlcache_entry_commit().

handle_full_cache_worker()

static DWORD WINAPI handle_full_cache_worker ( void *  param )

static

Definition at line 2253 of file urlcache.c.

{
    FreeUrlCacheSpaceW(NULL, 20, 0);
    ReleaseSemaphore(free_cache_running, 1, NULL);
    return 0;
}

Referenced by handle_full_cache().

heap_strdupWtoUTF8()

static char* heap_strdupWtoUTF8 ( LPCWSTR  str )

inlinestatic

Definition at line 209 of file urlcache.c.

{
    char *ret = NULL;

    if(str) {
        DWORD size = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
        ret = heap_alloc(size);
        if(ret)
            WideCharToMultiByte(CP_UTF8, 0, str, -1, ret, size, NULL, NULL);
    }

    return ret;
}

Referenced by CommitUrlCacheEntryW(), and CreateUrlCacheEntryW().

IncrementUrlCacheHeaderData()

BOOL WINAPI IncrementUrlCacheHeaderData	(	DWORD	index,
		LPDWORD	data
	)

Definition at line 4108 of file urlcache.c.

{
    FIXME("(%u, %p)\n", index, data);
    return FALSE;
}

init_urlcache()

BOOL init_urlcache

(

void

)

Definition at line 4124 of file urlcache.c.

{
    dll_unload_event = CreateEventW(NULL, FALSE, FALSE, NULL);
    if(!dll_unload_event)
        return FALSE;

    free_cache_running = CreateSemaphoreW(NULL, 1, 1, NULL);
    if(!free_cache_running) {
        CloseHandle(dll_unload_event);
        return FALSE;
    }

#ifndef __REACTOS__
    cache_containers_init();
#endif
    return TRUE;
}

Referenced by DllMain().

IsUrlCacheEntryExpiredA()

BOOL WINAPI IsUrlCacheEntryExpiredA	(	LPCSTR	url,
		DWORD	dwFlags,
		FILETIME *	pftLastModified
	)

Definition at line 3990 of file urlcache.c.

{
    urlcache_header *pHeader;
    struct hash_entry *pHashEntry;
    const entry_header *pEntry;
    const entry_url * pUrlEntry;
    cache_container *pContainer;
    BOOL expired;

    TRACE("(%s, %08x, %p)\n", debugstr_a(url), dwFlags, pftLastModified);

    if (!url || !pftLastModified)
        return TRUE;
    if (dwFlags)
        FIXME("unknown flags 0x%08x\n", dwFlags);

    /* Any error implies that the URL is expired, i.e. not in the cache */
    if (cache_containers_find(url, &pContainer))
    {
        memset(pftLastModified, 0, sizeof(*pftLastModified));
        return TRUE;
    }

    if (cache_container_open_index(pContainer, MIN_BLOCK_NO))
    {
        memset(pftLastModified, 0, sizeof(*pftLastModified));
        return TRUE;
    }

    if (!(pHeader = cache_container_lock_index(pContainer)))
    {
        memset(pftLastModified, 0, sizeof(*pftLastModified));
        return TRUE;
    }

    if (!urlcache_find_hash_entry(pHeader, url, &pHashEntry))
    {
        cache_container_unlock_index(pContainer, pHeader);
        memset(pftLastModified, 0, sizeof(*pftLastModified));
        TRACE("entry %s not found!\n", url);
        return TRUE;
    }

    pEntry = (const entry_header*)((LPBYTE)pHeader + pHashEntry->offset);
    if (pEntry->signature != URL_SIGNATURE)
    {
        cache_container_unlock_index(pContainer, pHeader);
        memset(pftLastModified, 0, sizeof(*pftLastModified));
        FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPCSTR)&pEntry->signature, sizeof(DWORD)));
        return TRUE;
    }

    pUrlEntry = (const entry_url *)pEntry;
    expired = urlcache_entry_is_expired(pUrlEntry, pftLastModified);

    cache_container_unlock_index(pContainer, pHeader);

    return expired;
}

Referenced by IsUrlCacheEntryExpiredW(), and test_IsUrlCacheEntryExpiredA().

IsUrlCacheEntryExpiredW()

BOOL WINAPI IsUrlCacheEntryExpiredW	(	LPCWSTR	url,
		DWORD	dwFlags,
		FILETIME *	pftLastModified
	)

Definition at line 4058 of file urlcache.c.

{
    char *encoded_url;
    BOOL ret;

    if(!urlcache_encode_url_alloc(url, &encoded_url))
        return FALSE;

    ret = IsUrlCacheEntryExpiredA(encoded_url, dwFlags, pftLastModified);
    heap_free(encoded_url);
    return ret;
}

LoadUrlCacheContent()

BOOL WINAPI LoadUrlCacheContent

(

void

)

Definition at line 4156 of file urlcache.c.

{
    FIXME("stub!\n");
    return FALSE;
}

ReadUrlCacheEntryStream()

BOOL WINAPI ReadUrlCacheEntryStream	(	IN HANDLE	hUrlCacheStream,
		IN DWORD	dwLocation,
		IN OUT LPVOID	lpBuffer,
		IN OUT LPDWORD	lpdwLen,
		IN DWORD	dwReserved
	)

Definition at line 3145 of file urlcache.c.

{
    /* Get handle to file from 'stream' */
    stream_handle *pStream = (stream_handle*)hUrlCacheStream;

    if (dwReserved != 0)
    {
        ERR("dwReserved != 0\n");
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    if (IsBadReadPtr(pStream, sizeof(*pStream)) || IsBadStringPtrA(pStream->url, INTERNET_MAX_URL_LENGTH))
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    if (SetFilePointer(pStream->file, dwLocation, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
        return FALSE;
    return ReadFile(pStream->file, lpBuffer, *lpdwLen, lpdwLen, NULL);
}

Referenced by load_persistent_cookie().

RegisterUrlCacheNotification()

DWORD WINAPI RegisterUrlCacheNotification	(	LPVOID	a,
		DWORD	b,
		DWORD	c,
		DWORD	d,
		DWORD	e,
		DWORD	f
	)

Definition at line 4099 of file urlcache.c.

{
    FIXME("(%p %x %x %x %x %x)\n", a, b, c, d, e, f);
    return 0;
}

RetrieveUrlCacheEntryFileA()

BOOL WINAPI RetrieveUrlCacheEntryFileA	(	LPCSTR	lpszUrlName,
		LPINTERNET_CACHE_ENTRY_INFOA	lpCacheEntryInfo,
		LPDWORD	lpdwCacheEntryInfoBufferSize,
		DWORD	dwReserved
	)

Definition at line 2183 of file urlcache.c.

{
    return urlcache_entry_get_file(lpszUrlName, lpCacheEntryInfo,
            lpdwCacheEntryInfoBufferSize, FALSE);
}

Referenced by RetrieveUrlCacheEntryStreamA(), test_RetrieveUrlCacheEntryA(), and test_urlcacheA().

RetrieveUrlCacheEntryFileW()

BOOL WINAPI RetrieveUrlCacheEntryFileW	(	LPCWSTR	lpszUrlName,
		LPINTERNET_CACHE_ENTRY_INFOW	lpCacheEntryInfo,
		LPDWORD	lpdwCacheEntryInfoBufferSize,
		DWORD	dwReserved
	)

Definition at line 2195 of file urlcache.c.

{
    char *url;
    BOOL ret;

    if(!urlcache_encode_url_alloc(lpszUrlName, &url))
        return FALSE;

    ret = urlcache_entry_get_file(url, lpCacheEntryInfo,
            lpdwCacheEntryInfoBufferSize, TRUE);
    heap_free(url);
    return ret;
}

Referenced by CRYPT_GetObjectFromCache(), and RetrieveUrlCacheEntryStreamW().

RetrieveUrlCacheEntryStreamA()

HANDLE WINAPI RetrieveUrlCacheEntryStreamA	(	LPCSTR	lpszUrlName,
		LPINTERNET_CACHE_ENTRY_INFOA	lpCacheEntryInfo,
		LPDWORD	lpdwCacheEntryInfoBufferSize,
		BOOL	fRandomRead,
		DWORD	dwReserved
	)

Definition at line 3178 of file urlcache.c.

{
    /* NOTE: this is not the same as the way that the native
     * version allocates 'stream' handles. I did it this way
     * as it is much easier and no applications should depend
     * on this behaviour. (Native version appears to allocate
     * indices into a table)
     */
    stream_handle *stream;
    HANDLE file;

    TRACE("(%s, %p, %p, %x, 0x%08x)\n", debugstr_a(lpszUrlName), lpCacheEntryInfo,
            lpdwCacheEntryInfoBufferSize, fRandomRead, dwReserved);

    if(!RetrieveUrlCacheEntryFileA(lpszUrlName, lpCacheEntryInfo,
                lpdwCacheEntryInfoBufferSize, dwReserved))
        return NULL;

    file = CreateFileA(lpCacheEntryInfo->lpszLocalFileName, GENERIC_READ, FILE_SHARE_READ,
            NULL, OPEN_EXISTING, fRandomRead ? FILE_FLAG_RANDOM_ACCESS : 0, NULL);
    if(file == INVALID_HANDLE_VALUE) {
        UnlockUrlCacheEntryFileA(lpszUrlName, 0);
        return NULL;
    }

    /* allocate handle storage space */
    stream = heap_alloc(sizeof(stream_handle) + strlen(lpszUrlName) * sizeof(CHAR));
    if(!stream) {
        CloseHandle(file);
        UnlockUrlCacheEntryFileA(lpszUrlName, 0);
        SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }

    stream->file = file;
    strcpy(stream->url, lpszUrlName);
    return stream;
}

RetrieveUrlCacheEntryStreamW()

HANDLE WINAPI RetrieveUrlCacheEntryStreamW	(	LPCWSTR	lpszUrlName,
		LPINTERNET_CACHE_ENTRY_INFOW	lpCacheEntryInfo,
		LPDWORD	lpdwCacheEntryInfoBufferSize,
		BOOL	fRandomRead,
		DWORD	dwReserved
	)

Definition at line 3223 of file urlcache.c.

{
    DWORD len;
    /* NOTE: this is not the same as the way that the native
     * version allocates 'stream' handles. I did it this way
     * as it is much easier and no applications should depend
     * on this behaviour. (Native version appears to allocate
     * indices into a table)
     */
    stream_handle *stream;
    HANDLE file;

    TRACE("(%s, %p, %p, %x, 0x%08x)\n", debugstr_w(lpszUrlName), lpCacheEntryInfo,
            lpdwCacheEntryInfoBufferSize, fRandomRead, dwReserved);

    if(!(len = urlcache_encode_url(lpszUrlName, NULL, 0)))
        return NULL;

    if(!RetrieveUrlCacheEntryFileW(lpszUrlName, lpCacheEntryInfo,
                lpdwCacheEntryInfoBufferSize, dwReserved))
        return NULL;

    file = CreateFileW(lpCacheEntryInfo->lpszLocalFileName, GENERIC_READ, FILE_SHARE_READ,
            NULL, OPEN_EXISTING, fRandomRead ? FILE_FLAG_RANDOM_ACCESS : 0, NULL);
    if(file == INVALID_HANDLE_VALUE) {
        UnlockUrlCacheEntryFileW(lpszUrlName, 0);
        return NULL;
    }

    /* allocate handle storage space */
    stream = heap_alloc(sizeof(stream_handle) + len*sizeof(WCHAR));
    if(!stream) {
        CloseHandle(file);
        UnlockUrlCacheEntryFileW(lpszUrlName, 0);
        SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }

    stream->file = file;
    if(!urlcache_encode_url(lpszUrlName, stream->url, len)) {
        CloseHandle(file);
        UnlockUrlCacheEntryFileW(lpszUrlName, 0);
        heap_free(stream);
        return NULL;
    }
    return stream;
}