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	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)
BOOL WINAPI	GetUrlCacheConfigInfoW (LPINTERNET_CACHE_CONFIG_INFOW CacheInfo, LPDWORD size, DWORD bitmask)
BOOL WINAPI	GetUrlCacheConfigInfoA (LPINTERNET_CACHE_CONFIG_INFOA CacheInfo, LPDWORD size, DWORD bitmask)
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 67 of file urlcache.c.

ALLOCATION_TABLE_SIZE

#define ALLOCATION_TABLE_SIZE   (ENTRY_START_OFFSET - ALLOCATION_TABLE_OFFSET)

Definition at line 68 of file urlcache.c.

BLOCKSIZE

#define BLOCKSIZE   128

Definition at line 63 of file urlcache.c.

CACHE_CONTAINER_NO_SUBDIR

#define CACHE_CONTAINER_NO_SUBDIR   0xFE

Definition at line 83 of file urlcache.c.

CACHE_HEADER_DATA_ROOT_LEAK_OFFSET

#define CACHE_HEADER_DATA_ROOT_LEAK_OFFSET   0x16

Definition at line 85 of file urlcache.c.

CHAR_BIT

#define CHAR_BIT   (8 * sizeof(CHAR))

Definition at line 57 of file urlcache.c.

DIR_LENGTH

#define DIR_LENGTH   8

Definition at line 61 of file urlcache.c.

DWORD_ALIGN

#define DWORD_ALIGN

(

x

)

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

Definition at line 95 of file urlcache.c.

DWORD_SIG

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

Definition at line 89 of file urlcache.c.

ENTRY_START_OFFSET

#define ENTRY_START_OFFSET   0x4000

Definition at line 60 of file urlcache.c.

FILE_SIZE

#define FILE_SIZE

(

blocks

)

((blocks) * BLOCKSIZE + ENTRY_START_OFFSET)

Definition at line 71 of file urlcache.c.

FILETIME_SECOND

#define FILETIME_SECOND   10000000

Definition at line 87 of file urlcache.c.

GET_INSTALLED_ENTRY

#define GET_INSTALLED_ENTRY   0x200

Definition at line 82 of file urlcache.c.

HASH_SIGNATURE

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

Definition at line 93 of file urlcache.c.

HASHTABLE_BLOCKSIZE

#define HASHTABLE_BLOCKSIZE   (HASHTABLE_SIZE / HASHTABLE_NUM_ENTRIES)

Definition at line 66 of file urlcache.c.

HASHTABLE_DEL

#define HASHTABLE_DEL   1

Definition at line 74 of file urlcache.c.

HASHTABLE_FLAG_BITS

#define HASHTABLE_FLAG_BITS   6

Definition at line 78 of file urlcache.c.

HASHTABLE_FREE

#define HASHTABLE_FREE   3

Definition at line 76 of file urlcache.c.

HASHTABLE_LOCK

#define HASHTABLE_LOCK   2

Definition at line 75 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 65 of file urlcache.c.

HASHTABLE_REDR

#define HASHTABLE_REDR   5

Definition at line 77 of file urlcache.c.

HASHTABLE_SIZE

#define HASHTABLE_SIZE   448

Definition at line 64 of file urlcache.c.

HASHTABLE_URL

#define HASHTABLE_URL   0

Definition at line 73 of file urlcache.c.

INSTALLED_CACHE_ENTRY

#define INSTALLED_CACHE_ENTRY   0x10000000

Definition at line 81 of file urlcache.c.

LEAK_SIGNATURE

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

Definition at line 92 of file urlcache.c.

MAX_BLOCK_NO

#define MAX_BLOCK_NO   (ALLOCATION_TABLE_SIZE * CHAR_BIT)

Definition at line 70 of file urlcache.c.

MAX_DIR_NO

#define MAX_DIR_NO   0x20

Definition at line 62 of file urlcache.c.

MIN_BLOCK_NO

#define MIN_BLOCK_NO   0x80

Definition at line 69 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 80 of file urlcache.c.

REDR_SIGNATURE

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

Definition at line 91 of file urlcache.c.

URL_SIGNATURE

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

Definition at line 90 of file urlcache.c.

URLCACHE_FIND_ENTRY_HANDLE_MAGIC

#define URLCACHE_FIND_ENTRY_HANDLE_MAGIC   0xF389ABCD

Definition at line 97 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 1202 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 687 of file urlcache.c.

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

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

cache_container_create_object_name()

static void cache_container_create_object_name ( LPWSTR  lpszPath, WCHAR  replace  )

static

Definition at line 388 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 741 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 1744 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 554 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 925 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 398 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 599 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(), 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 419 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 984 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 693 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 874 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 844 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 836 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 752 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 < sizeof(DefaultContainerData) / sizeof(DefaultContainerData[0]); 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 3074 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 3096 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 3383 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 3394 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 2807 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 2826 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 3734 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 3870 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 3368 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 3374 of file urlcache.c.

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

DeleteUrlCacheEntryA()

BOOL WINAPI DeleteUrlCacheEntryA

(

LPCSTR

lpszUrlName

)

Definition at line 3309 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 3355 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 3744 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 3755 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 1233 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 2360 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 1106 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().

FindCloseUrlCache()

BOOL WINAPI FindCloseUrlCache

(

HANDLE

hEnumHandle

)

Definition at line 3670 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 3405 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 3414 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 3480 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 3438 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 3457 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 3519 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 3688 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 3423 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 3432 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 3640 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 3696 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 3710 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 3654 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 3724 of file urlcache.c.

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

free_urlcache()

void free_urlcache

(

void

)

Definition at line 4054 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 2540 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 2383 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<sizeof(rate)/sizeof(*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 3986 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	CacheInfo,
		LPDWORD	size,
		DWORD	bitmask
	)

Definition at line 3804 of file urlcache.c.

{
    FIXME("(%p, %p, %x)\n", CacheInfo, size, bitmask);
    INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
}

GetUrlCacheConfigInfoW()

BOOL WINAPI GetUrlCacheConfigInfoW	(	LPINTERNET_CACHE_CONFIG_INFOW	CacheInfo,
		LPDWORD	size,
		DWORD	bitmask
	)

Definition at line 3794 of file urlcache.c.

{
    FIXME("(%p, %p, %x)\n", CacheInfo, size, bitmask);
    INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
}

GetUrlCacheEntryInfoA()

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

Definition at line 1897 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 1878 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 1991 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 2021 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 3811 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 3821 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 2259 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 2252 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 208 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 4020 of file urlcache.c.

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

init_urlcache()

BOOL init_urlcache

(

void

)

Definition at line 4036 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 3902 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 3970 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 4068 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 3144 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 4011 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 2182 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 2194 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 3177 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 3222 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;
}

Referenced by load_persistent_cookie().

RunOnceUrlCache()

DWORD WINAPI RunOnceUrlCache	(	HWND	hwnd,
		HINSTANCE	hinst,
		LPSTR	cmd,
		int	cmdshow
	)

Definition at line 4030 of file urlcache.c.

{
    FIXME("(%p, %p, %s, %d): stub\n", hwnd, hinst, debugstr_a(cmd), cmdshow);
    return 0;
}

SetUrlCacheConfigInfoA()

BOOL WINAPI SetUrlCacheConfigInfoA	(	LPINTERNET_CACHE_CONFIG_INFOA	lpCacheConfigInfo,
		DWORD	dwFieldControl
	)

Definition at line 3847 of file urlcache.c.

{
    FIXME("(%p, 0x%08x) stub\n", lpCacheConfigInfo, dwFieldControl);
    return TRUE;
}

SetUrlCacheConfigInfoW()

BOOL WINAPI SetUrlCacheConfigInfoW	(	LPINTERNET_CACHE_CONFIG_INFOW	lpCacheConfigInfo,
		DWORD	dwFieldControl
	)

Definition at line 3853 of file urlcache.c.

{
    FIXME("(%p, 0x%08x) stub\n", lpCacheConfigInfo, dwFieldControl);
    return TRUE;
}

SetUrlCacheEntryGroupA()

BOOL WINAPI SetUrlCacheEntryGroupA	(	LPCSTR	lpszUrlName,
		DWORD	dwFlags,
		GROUPID	GroupId,
		LPBYTE	pbGroupAttributes,
		DWORD	cbGroupAttributes,
		LPVOID	lpReserved
	)

Definition at line 3765 of file urlcache.c.

{
    FIXME("(%s, 0x%08x, 0x%s, %p, 0x%08x, %p) stub\n",
          debugstr_a(lpszUrlName), dwFlags, wine_dbgstr_longlong(GroupId),
          pbGroupAttributes, cbGroupAttributes, lpReserved);
    SetLastError(ERROR_FILE_NOT_FOUND);
    return FALSE;
}

SetUrlCacheEntryGroupW()

BOOL WINAPI SetUrlCacheEntryGroupW	(	LPCWSTR	lpszUrlName,
		DWORD	dwFlags,
		GROUPID	GroupId,
		LPBYTE	pbGroupAttributes,
		DWORD	cbGroupAttributes,
		LPVOID	lpReserved
	)

Definition at line 3780 of file urlcache.c.

{
    FIXME("(%s, 0x%08x, 0x%s, %p, 0x%08x, %p) stub\n",
          debugstr_w(lpszUrlName), dwFlags, wine_dbgstr_longlong(GroupId),
          pbGroupAttributes, cbGroupAttributes, lpReserved);
    SetLastError(ERROR_FILE_NOT_FOUND);
    return FALSE;
}

SetUrlCacheEntryInfoA()