?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msi: Check transform validation flags.
[wine/wine-gecko.git] / dlls / wininet / urlcache.c
blob3487aa89efaab915fe473d43139bc3643b93aeae
1 /*
2 * Wininet - Url Cache functions
3 *
4 * Copyright 2001,2002 CodeWeavers
5 * Copyright 2003-2008 Robert Shearman
6 *
7 * Eric Kohl
8 * Aric Stewart
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #define NONAMELESSUNION
29 #define NONAMELESSSTRUCT
30
31 #if defined(__MINGW32__) || defined (_MSC_VER)
32 #include <ws2tcpip.h>
33 #endif
34
35 #include <stdarg.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <sys/types.h>
40 #ifdef HAVE_SYS_SOCKET_H
41 # include <sys/socket.h>
42 #endif
43 #include <time.h>
44
45 #include "windef.h"
46 #include "winbase.h"
47 #include "winuser.h"
48 #include "wininet.h"
49 #include "winineti.h"
50 #include "winerror.h"
51 #include "winreg.h"
52 #include "shlwapi.h"
53 #include "shlobj.h"
54 #include "shellapi.h"
55
56 #include "internet.h"
57
58 #include "wine/unicode.h"
59 #include "wine/debug.h"
60
61 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
62
63 static const char urlcache_ver_prefix[] = "WINE URLCache Ver ";
64 static const char urlcache_ver[] = "0.2012001";
65
66 #ifndef CHAR_BIT
67 #define CHAR_BIT (8 * sizeof(CHAR))
68 #endif
69
70 #define ENTRY_START_OFFSET 0x4000
71 #define DIR_LENGTH 8
72 #define MAX_DIR_NO 0x20
73 #define BLOCKSIZE 128
74 #define HASHTABLE_SIZE 448
75 #define HASHTABLE_NUM_ENTRIES 64 /* this needs to be power of 2, that divides HASHTABLE_SIZE */
76 #define HASHTABLE_BLOCKSIZE (HASHTABLE_SIZE / HASHTABLE_NUM_ENTRIES)
77 #define ALLOCATION_TABLE_OFFSET 0x250
78 #define ALLOCATION_TABLE_SIZE (ENTRY_START_OFFSET - ALLOCATION_TABLE_OFFSET)
79 #define MIN_BLOCK_NO 0x80
80 #define MAX_BLOCK_NO (ALLOCATION_TABLE_SIZE * CHAR_BIT)
81 #define FILE_SIZE(blocks) ((blocks) * BLOCKSIZE + ENTRY_START_OFFSET)
82
83 #define HASHTABLE_URL 0
84 #define HASHTABLE_DEL 1
85 #define HASHTABLE_LOCK 2
86 #define HASHTABLE_FREE 3
87 #define HASHTABLE_REDR 5
88 #define HASHTABLE_FLAG_BITS 6
89
90 #define PENDING_DELETE_CACHE_ENTRY 0x00400000
91 #define INSTALLED_CACHE_ENTRY 0x10000000
92 #define GET_INSTALLED_ENTRY 0x200
93 #define CACHE_CONTAINER_NO_SUBDIR 0xFE
94
95 #define CACHE_HEADER_DATA_ROOT_LEAK_OFFSET 0x16
96
97 #define FILETIME_SECOND 10000000
98
99 #define DWORD_SIG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
100 #define URL_SIGNATURE DWORD_SIG('U','R','L',' ')
101 #define REDR_SIGNATURE DWORD_SIG('R','E','D','R')
102 #define LEAK_SIGNATURE DWORD_SIG('L','E','A','K')
103 #define HASH_SIGNATURE DWORD_SIG('H','A','S','H')
104
105 #define DWORD_ALIGN(x) ( (DWORD)(((DWORD)(x)+sizeof(DWORD)-1)/sizeof(DWORD))*sizeof(DWORD) )
106
107 #define URLCACHE_FIND_ENTRY_HANDLE_MAGIC 0xF389ABCD
108
109 typedef struct
110 {
111 DWORD signature;
112 DWORD blocks_used; /* number of 128byte blocks used by this entry */
113 } entry_header;
114
115 typedef struct
116 {
117 entry_header header;
118 FILETIME modification_time;
119 FILETIME access_time;
120 WORD expire_date; /* expire date in dos format */
121 WORD expire_time; /* expire time in dos format */
122 DWORD unk1; /* usually zero */
123 ULARGE_INTEGER size; /* see INTERNET_CACHE_ENTRY_INFO::dwSizeLow/High */
124 DWORD unk2; /* usually zero */
125 DWORD exempt_delta; /* see INTERNET_CACHE_ENTRY_INFO::dwExemptDelta */
126 DWORD unk3; /* usually 0x60 */
127 DWORD url_off; /* offset of start of url from start of entry */
128 BYTE cache_dir; /* index of cache directory this url is stored in */
129 BYTE unk4; /* usually zero */
130 WORD unk5; /* usually 0x1010 */
131 DWORD local_name_off; /* offset of start of local filename from start of entry */
132 DWORD cache_entry_type; /* see INTERNET_CACHE_ENTRY_INFO::CacheEntryType */
133 DWORD header_info_off; /* offset of start of header info from start of entry */
134 DWORD header_info_size;
135 DWORD file_extension_off; /* offset of start of file extension from start of entry */
136 WORD sync_date; /* last sync date in dos format */
137 WORD sync_time; /* last sync time in dos format */
138 DWORD hit_rate; /* see INTERNET_CACHE_ENTRY_INFO::dwHitRate */
139 DWORD use_count; /* see INTERNET_CACHE_ENTRY_INFO::dwUseCount */
140 WORD write_date;
141 WORD write_time;
142 DWORD unk7; /* usually zero */
143 DWORD unk8; /* usually zero */
144 /* packing to dword align start of next field */
145 /* CHAR szSourceUrlName[]; (url) */
146 /* packing to dword align start of next field */
147 /* CHAR szLocalFileName[]; (local file name excluding path) */
148 /* packing to dword align start of next field */
149 /* CHAR szHeaderInfo[]; (header info) */
150 } entry_url;
151
152 struct hash_entry
153 {
154 DWORD key;
155 DWORD offset;
156 };
157
158 typedef struct
159 {
160 entry_header header;
161 DWORD next;
162 DWORD id;
163 struct hash_entry hash_table[HASHTABLE_SIZE];
164 } entry_hash_table;
165
166 typedef struct
167 {
168 char signature[28];
169 DWORD size;
170 DWORD hash_table_off;
171 DWORD capacity_in_blocks;
172 DWORD blocks_in_use;
173 DWORD unk1;
174 ULARGE_INTEGER cache_limit;
175 ULARGE_INTEGER cache_usage;
176 ULARGE_INTEGER exempt_usage;
177 DWORD dirs_no;
178 struct _directory_data
179 {
180 DWORD files_no;
181 char name[DIR_LENGTH];
182 } directory_data[MAX_DIR_NO];
183 DWORD options[0x21];
184 BYTE allocation_table[ALLOCATION_TABLE_SIZE];
185 } urlcache_header;
186
187 typedef struct
188 {
189 HANDLE file;
190 CHAR url[1];
191 } stream_handle;
192
193 typedef struct
194 {
195 struct list entry; /* part of a list */
196 char *cache_prefix; /* string that has to be prefixed for this container to be used */
197 LPWSTR path; /* path to url container directory */
198 HANDLE mapping; /* handle of file mapping */
199 DWORD file_size; /* size of file when mapping was opened */
200 HANDLE mutex; /* handle of mutex */
201 DWORD default_entry_type;
202 } cache_container;
203
204 typedef struct
205 {
206 DWORD magic;
207 char *url_search_pattern;
208 DWORD container_idx;
209 DWORD hash_table_idx;
210 DWORD hash_entry_idx;
211 } find_handle;
212
213 /* List of all containers available */
214 static struct list UrlContainers = LIST_INIT(UrlContainers);
215
216 static inline char *heap_strdupWtoUTF8(LPCWSTR str)
217 {
218 char *ret = NULL;
219
220 if(str) {
221 DWORD size = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
222 ret = heap_alloc(size);
223 if(ret)
224 WideCharToMultiByte(CP_UTF8, 0, str, -1, ret, size, NULL, NULL);
225 }
226
227 return ret;
228 }
229
230 /***********************************************************************
231 * urlcache_block_is_free (Internal)
232 *
233 * Is the specified block number free?
234 *
235 * RETURNS
236 * zero if free
237 * non-zero otherwise
238 *
239 */
240 static inline BYTE urlcache_block_is_free(BYTE *allocation_table, DWORD block_number)
241 {
242 BYTE mask = 1 << (block_number%CHAR_BIT);
243 return (allocation_table[block_number/CHAR_BIT] & mask) == 0;
244 }
245
246 /***********************************************************************
247 * urlcache_block_free (Internal)
248 *
249 * Marks the specified block as free
250 *
251 * CAUTION
252 * this function is not updating used blocks count
253 *
254 * RETURNS
255 * nothing
256 *
257 */
258 static inline void urlcache_block_free(BYTE *allocation_table, DWORD block_number)
259 {
260 BYTE mask = ~(1 << (block_number%CHAR_BIT));
261 allocation_table[block_number/CHAR_BIT] &= mask;
262 }
263
264 /***********************************************************************
265 * urlcache_block_alloc (Internal)
266 *
267 * Marks the specified block as allocated
268 *
269 * CAUTION
270 * this function is not updating used blocks count
271 *
272 * RETURNS
273 * nothing
274 *
275 */
276 static inline void urlcache_block_alloc(BYTE *allocation_table, DWORD block_number)
277 {
278 BYTE mask = 1 << (block_number%CHAR_BIT);
279 allocation_table[block_number/CHAR_BIT] |= mask;
280 }
281
282 /***********************************************************************
283 * urlcache_entry_alloc (Internal)
284 *
285 * Finds and allocates the first block of free space big enough and
286 * sets entry to point to it.
287 *
288 * RETURNS
289 * ERROR_SUCCESS when free memory block was found
290 * Any other Win32 error code if the entry could not be added
291 *
292 */
293 static DWORD urlcache_entry_alloc(urlcache_header *header, DWORD blocks_needed, entry_header **entry)
294 {
295 DWORD block, block_size;
296
297 for(block=0; block<header->capacity_in_blocks; block+=block_size+1)
298 {
299 block_size = 0;
300 while(block_size<blocks_needed && block_size+block<header->capacity_in_blocks
301 && urlcache_block_is_free(header->allocation_table, block+block_size))
302 block_size++;
303
304 if(block_size == blocks_needed)
305 {
306 DWORD index;
307
308 TRACE("Found free blocks starting at no. %d (0x%x)\n", block, ENTRY_START_OFFSET+block*BLOCKSIZE);
309
310 for(index=0; index<blocks_needed; index++)
311 urlcache_block_alloc(header->allocation_table, block+index);
312
313 *entry = (entry_header*)((BYTE*)header+ENTRY_START_OFFSET+block*BLOCKSIZE);
314 for(index=0; index<blocks_needed*BLOCKSIZE/sizeof(DWORD); index++)
315 ((DWORD*)*entry)[index] = 0xdeadbeef;
316 (*entry)->blocks_used = blocks_needed;
317
318 header->blocks_in_use += blocks_needed;
319 return ERROR_SUCCESS;
320 }
321 }
322
323 return ERROR_HANDLE_DISK_FULL;
324 }
325
326 /***********************************************************************
327 * urlcache_entry_free (Internal)
328 *
329 * Deletes the specified entry and frees the space allocated to it
330 *
331 * RETURNS
332 * TRUE if it succeeded
333 * FALSE if it failed
334 *
335 */
336 static BOOL urlcache_entry_free(urlcache_header *header, entry_header *entry)
337 {
338 DWORD start_block, block;
339
340 /* update allocation table */
341 start_block = ((DWORD)((BYTE*)entry - (BYTE*)header) - ENTRY_START_OFFSET) / BLOCKSIZE;
342 for(block = start_block; block < start_block+entry->blocks_used; block++)
343 urlcache_block_free(header->allocation_table, block);
344
345 header->blocks_in_use -= entry->blocks_used;
346 return TRUE;
347 }
348
349 /***********************************************************************
350 * urlcache_create_hash_table (Internal)
351 *
352 * Creates a new hash table in free space and adds it to the chain of existing
353 * hash tables.
354 *
355 * RETURNS
356 * ERROR_SUCCESS if the hash table was created
357 * ERROR_DISK_FULL if the hash table could not be created
358 *
359 */
360 static DWORD urlcache_create_hash_table(urlcache_header *header, entry_hash_table *hash_table_prev, entry_hash_table **hash_table)
361 {
362 DWORD dwOffset, error;
363 int i;
364
365 if((error = urlcache_entry_alloc(header, 0x20, (entry_header**)hash_table)) != ERROR_SUCCESS)
366 return error;
367
368 dwOffset = (BYTE*)*hash_table-(BYTE*)header;
369
370 if(hash_table_prev)
371 hash_table_prev->next = dwOffset;
372 else
373 header->hash_table_off = dwOffset;
374
375 (*hash_table)->header.signature = HASH_SIGNATURE;
376 (*hash_table)->next = 0;
377 (*hash_table)->id = hash_table_prev ? hash_table_prev->id+1 : 0;
378 for(i = 0; i < HASHTABLE_SIZE; i++) {
379 (*hash_table)->hash_table[i].offset = HASHTABLE_FREE;
380 (*hash_table)->hash_table[i].key = HASHTABLE_FREE;
381 }
382 return ERROR_SUCCESS;
383 }
384
385 /***********************************************************************
386 * cache_container_create_object_name (Internal)
387 *
388 * Converts a path to a name suitable for use as a Win32 object name.
389 * Replaces '\\' characters in-place with the specified character
390 * (usually '_' or '!')
391 *
392 * RETURNS
393 * nothing
394 *
395 */
396 static void cache_container_create_object_name(LPWSTR lpszPath, WCHAR replace)
397 {
398 for (; *lpszPath; lpszPath++)
399 {
400 if (*lpszPath == '\\')
401 *lpszPath = replace;
402 }
403 }
404
405 /* Caller must hold container lock */
406 static HANDLE cache_container_map_index(HANDLE file, const WCHAR *path, DWORD size, BOOL *validate)
407 {
408 static const WCHAR mapping_name_format[]
409 = {'%','s','i','n','d','e','x','.','d','a','t','_','%','l','u',0};
410 WCHAR mapping_name[MAX_PATH];
411 HANDLE mapping;
412
413 wsprintfW(mapping_name, mapping_name_format, path, size);
414 cache_container_create_object_name(mapping_name, '_');
415
416 mapping = OpenFileMappingW(FILE_MAP_WRITE, FALSE, mapping_name);
417 if(mapping) {
418 if(validate) *validate = FALSE;
419 return mapping;
420 }
421
422 if(validate) *validate = TRUE;
423 return CreateFileMappingW(file, NULL, PAGE_READWRITE, 0, 0, mapping_name);
424 }
425
426 /* Caller must hold container lock */
427 static DWORD cache_container_set_size(cache_container *container, HANDLE file, DWORD blocks_no)
428 {
429 static const WCHAR cache_content_key[] = {'S','o','f','t','w','a','r','e','\\',
430 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
431 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
432 'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
433 'C','a','c','h','e','\\','C','o','n','t','e','n','t',0};
434 static const WCHAR cache_limit[] = {'C','a','c','h','e','L','i','m','i','t',0};
435
436 DWORD file_size = FILE_SIZE(blocks_no);
437 WCHAR dir_path[MAX_PATH], *dir_name;
438 entry_hash_table *hashtable_entry;
439 urlcache_header *header;
440 HANDLE mapping;
441 FILETIME ft;
442 HKEY key;
443 int i, j;
444
445 if(SetFilePointer(file, file_size, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
446 return GetLastError();
447
448 if(!SetEndOfFile(file))
449 return GetLastError();
450
451 mapping = cache_container_map_index(file, container->path, file_size, NULL);
452 if(!mapping)
453 return GetLastError();
454
455 header = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0);
456 if(!header) {
457 CloseHandle(mapping);
458 return GetLastError();
459 }
460
461 if(blocks_no != MIN_BLOCK_NO) {
462 if(file_size > header->size)
463 memset((char*)header+header->size, 0, file_size-header->size);
464 header->size = file_size;
465 header->capacity_in_blocks = blocks_no;
466
467 UnmapViewOfFile(header);
468 CloseHandle(container->mapping);
469 container->mapping = mapping;
470 container->file_size = file_size;
471 return ERROR_SUCCESS;
472 }
473
474 memset(header, 0, file_size);
475 /* First set some constants and defaults in the header */
476 memcpy(header->signature, urlcache_ver_prefix, sizeof(urlcache_ver_prefix)-1);
477 memcpy(header->signature+sizeof(urlcache_ver_prefix)-1, urlcache_ver, sizeof(urlcache_ver)-1);
478 header->size = file_size;
479 header->capacity_in_blocks = blocks_no;
480 /* 127MB - taken from default for Windows 2000 */
481 header->cache_limit.QuadPart = 0x07ff5400;
482 /* Copied from a Windows 2000 cache index */
483 header->dirs_no = container->default_entry_type==NORMAL_CACHE_ENTRY ? 4 : 0;
484
485 /* If the registry has a cache size set, use the registry value */
486 if(RegOpenKeyW(HKEY_CURRENT_USER, cache_content_key, &key) == ERROR_SUCCESS) {
487 DWORD dw, len = sizeof(dw), keytype;
488
489 if(RegQueryValueExW(key, cache_limit, NULL, &keytype, (BYTE*)&dw, &len) == ERROR_SUCCESS &&
490 keytype == REG_DWORD)
491 header->cache_limit.QuadPart = (ULONGLONG)dw * 1024;
492 RegCloseKey(key);
493 }
494
495 urlcache_create_hash_table(header, NULL, &hashtable_entry);
496
497 /* Last step - create the directories */
498 strcpyW(dir_path, container->path);
499 dir_name = dir_path + strlenW(dir_path);
500 dir_name[8] = 0;
501
502 GetSystemTimeAsFileTime(&ft);
503
504 for(i=0; i<header->dirs_no; ++i) {
505 header->directory_data[i].files_no = 0;
506 for(j=0;; ++j) {
507 ULONGLONG n = ft.dwHighDateTime;
508 int k;
509
510 /* Generate a file name to attempt to create.
511 * This algorithm will create what will appear
512 * to be random and unrelated directory names
513 * of up to 9 characters in length.
514 */
515 n <<= 32;
516 n += ft.dwLowDateTime;
517 n ^= ((ULONGLONG) i << 56) | ((ULONGLONG) j << 48);
518
519 for(k = 0; k < 8; ++k) {
520 int r = (n % 36);
521
522 /* Dividing by a prime greater than 36 helps
523 * with the appearance of randomness
524 */
525 n /= 37;
526
527 if(r < 10)
528 dir_name[k] = '0' + r;
529 else
530 dir_name[k] = 'A' + (r - 10);
531 }
532
533 if(CreateDirectoryW(dir_path, 0)) {
534 /* The following is OK because we generated an
535 * 8 character directory name made from characters
536 * [A-Z0-9], which are equivalent for all code
537 * pages and for UTF-16
538 */
539 for (k = 0; k < 8; ++k)
540 header->directory_data[i].name[k] = dir_name[k];
541 break;
542 }else if(j >= 255) {
543 /* Give up. The most likely cause of this
544 * is a full disk, but whatever the cause
545 * is, it should be more than apparent that
546 * we won't succeed.
547 */
548 UnmapViewOfFile(header);
549 CloseHandle(mapping);
550 return GetLastError();
551 }
552 }
553 }
554
555 UnmapViewOfFile(header);
556 CloseHandle(container->mapping);
557 container->mapping = mapping;
558 container->file_size = file_size;
559 return ERROR_SUCCESS;
560 }
561
562 static BOOL cache_container_is_valid(urlcache_header *header, DWORD file_size)
563 {
564 DWORD allocation_size, count_bits, i;
565
566 if(file_size < FILE_SIZE(MIN_BLOCK_NO))
567 return FALSE;
568
569 if(file_size != header->size)
570 return FALSE;
571
572 if (!memcmp(header->signature, urlcache_ver_prefix, sizeof(urlcache_ver_prefix)-1) &&
573 memcmp(header->signature+sizeof(urlcache_ver_prefix)-1, urlcache_ver, sizeof(urlcache_ver)-1))
574 return FALSE;
575
576 if(FILE_SIZE(header->capacity_in_blocks) != file_size)
577 return FALSE;
578
579 allocation_size = 0;
580 for(i=0; i<header->capacity_in_blocks/8; i++) {
581 for(count_bits = header->allocation_table[i]; count_bits!=0; count_bits>>=1) {
582 if(count_bits & 1)
583 allocation_size++;
584 }
585 }
586 if(allocation_size != header->blocks_in_use)
587 return FALSE;
588
589 for(; i<ALLOCATION_TABLE_SIZE; i++) {
590 if(header->allocation_table[i])
591 return FALSE;
592 }
593
594 return TRUE;
595 }
596
597 /***********************************************************************
598 * cache_container_open_index (Internal)
599 *
600 * Opens the index file and saves mapping handle
601 *
602 * RETURNS
603 * ERROR_SUCCESS if succeeded
604 * Any other Win32 error code if failed
605 *
606 */
607 static DWORD cache_container_open_index(cache_container *container, DWORD blocks_no)
608 {
609 static const WCHAR index_dat[] = {'i','n','d','e','x','.','d','a','t',0};
610
611 HANDLE file;
612 WCHAR index_path[MAX_PATH];
613 DWORD file_size;
614 BOOL validate;
615
616 WaitForSingleObject(container->mutex, INFINITE);
617
618 if(container->mapping) {
619 ReleaseMutex(container->mutex);
620 return ERROR_SUCCESS;
621 }
622
623 strcpyW(index_path, container->path);
624 strcatW(index_path, index_dat);
625
626 file = CreateFileW(index_path, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL);
627 if(file == INVALID_HANDLE_VALUE) {
628 /* Maybe the directory wasn't there? Try to create it */
629 if(CreateDirectoryW(container->path, 0))
630 file = CreateFileW(index_path, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL);
631 }
632 if(file == INVALID_HANDLE_VALUE) {
633 TRACE("Could not open or create cache index file \"%s\"\n", debugstr_w(index_path));
634 ReleaseMutex(container->mutex);
635 return GetLastError();
636 }
637
638 file_size = GetFileSize(file, NULL);
639 if(file_size == INVALID_FILE_SIZE) {
640 CloseHandle(file);
641 ReleaseMutex(container->mutex);
642 return GetLastError();
643 }
644
645 if(blocks_no < MIN_BLOCK_NO)
646 blocks_no = MIN_BLOCK_NO;
647 else if(blocks_no > MAX_BLOCK_NO)
648 blocks_no = MAX_BLOCK_NO;
649
650 if(file_size < FILE_SIZE(blocks_no)) {
651 DWORD ret = cache_container_set_size(container, file, blocks_no);
652 CloseHandle(file);
653 ReleaseMutex(container->mutex);
654 return ret;
655 }
656
657 container->file_size = file_size;
658 container->mapping = cache_container_map_index(file, container->path, file_size, &validate);
659 CloseHandle(file);
660 if(container->mapping && validate) {
661 urlcache_header *header = MapViewOfFile(container->mapping, FILE_MAP_WRITE, 0, 0, 0);
662
663 if(header && !cache_container_is_valid(header, file_size)) {
664 WARN("detected old or broken index.dat file\n");
665 UnmapViewOfFile(header);
666 FreeUrlCacheSpaceW(container->path, 100, 0);
667 }else if(header) {
668 UnmapViewOfFile(header);
669 }else {
670 CloseHandle(container->mapping);
671 container->mapping = NULL;
672 }
673 }
674
675 if(!container->mapping)
676 {
677 ERR("Couldn't create file mapping (error is %d)\n", GetLastError());
678 ReleaseMutex(container->mutex);
679 return GetLastError();
680 }
681
682 ReleaseMutex(container->mutex);
683 return ERROR_SUCCESS;
684 }
685
686 /***********************************************************************
687 * cache_container_close_index (Internal)
688 *
689 * Closes the index
690 *
691 * RETURNS
692 * nothing
693 *
694 */
695 static void cache_container_close_index(cache_container *pContainer)
696 {
697 CloseHandle(pContainer->mapping);
698 pContainer->mapping = NULL;
699 }
700
701 static BOOL cache_containers_add(const char *cache_prefix, LPCWSTR path,
702 DWORD default_entry_type, LPWSTR mutex_name)
703 {
704 cache_container *pContainer = heap_alloc(sizeof(cache_container));
705 int cache_prefix_len = strlen(cache_prefix);
706
707 if (!pContainer)
708 {
709 return FALSE;
710 }
711
712 pContainer->mapping = NULL;
713 pContainer->file_size = 0;
714 pContainer->default_entry_type = default_entry_type;
715
716 pContainer->path = heap_strdupW(path);
717 if (!pContainer->path)
718 {
719 heap_free(pContainer);
720 return FALSE;
721 }
722
723 pContainer->cache_prefix = heap_alloc(cache_prefix_len+1);
724 if (!pContainer->cache_prefix)
725 {
726 heap_free(pContainer->path);
727 heap_free(pContainer);
728 return FALSE;
729 }
730
731 memcpy(pContainer->cache_prefix, cache_prefix, cache_prefix_len+1);
732
733 CharLowerW(mutex_name);
734 cache_container_create_object_name(mutex_name, '!');
735
736 if ((pContainer->mutex = CreateMutexW(NULL, FALSE, mutex_name)) == NULL)
737 {
738 ERR("couldn't create mutex (error is %d)\n", GetLastError());
739 heap_free(pContainer->path);
740 heap_free(pContainer);
741 return FALSE;
742 }
743
744 list_add_head(&UrlContainers, &pContainer->entry);
745
746 return TRUE;
747 }
748
749 static void cache_container_delete_container(cache_container *pContainer)
750 {
751 list_remove(&pContainer->entry);
752
753 cache_container_close_index(pContainer);
754 CloseHandle(pContainer->mutex);
755 heap_free(pContainer->path);
756 heap_free(pContainer->cache_prefix);
757 heap_free(pContainer);
758 }
759
760 static void cache_containers_init(void)
761 {
762 static const WCHAR UrlSuffix[] = {'C','o','n','t','e','n','t','.','I','E','5',0};
763 static const WCHAR HistorySuffix[] = {'H','i','s','t','o','r','y','.','I','E','5',0};
764 static const WCHAR CookieSuffix[] = {0};
765 static const struct
766 {
767 int nFolder; /* CSIDL_* constant */
768 const WCHAR *shpath_suffix; /* suffix on path returned by SHGetSpecialFolderPath */
769 const char *cache_prefix; /* prefix used to reference the container */
770 DWORD default_entry_type;
771 } DefaultContainerData[] =
772 {
773 { CSIDL_INTERNET_CACHE, UrlSuffix, "", NORMAL_CACHE_ENTRY },
774 { CSIDL_HISTORY, HistorySuffix, "Visited:", URLHISTORY_CACHE_ENTRY },
775 { CSIDL_COOKIES, CookieSuffix, "Cookie:", COOKIE_CACHE_ENTRY },
776 };
777 DWORD i;
778
779 for (i = 0; i < sizeof(DefaultContainerData) / sizeof(DefaultContainerData[0]); i++)
780 {
781 WCHAR wszCachePath[MAX_PATH];
782 WCHAR wszMutexName[MAX_PATH];
783 int path_len, suffix_len;
784 BOOL def_char;
785
786 if (!SHGetSpecialFolderPathW(NULL, wszCachePath, DefaultContainerData[i].nFolder, TRUE))
787 {
788 ERR("Couldn't get path for default container %u\n", i);
789 continue;
790 }
791 path_len = strlenW(wszCachePath);
792 suffix_len = strlenW(DefaultContainerData[i].shpath_suffix);
793
794 if (path_len + suffix_len + 2 > MAX_PATH)
795 {
796 ERR("Path too long\n");
797 continue;
798 }
799
800 wszCachePath[path_len] = '\\';
801 wszCachePath[path_len+1] = 0;
802
803 strcpyW(wszMutexName, wszCachePath);
804
805 if (suffix_len)
806 {
807 memcpy(wszCachePath + path_len + 1, DefaultContainerData[i].shpath_suffix, (suffix_len + 1) * sizeof(WCHAR));
808 wszCachePath[path_len + suffix_len + 1] = '\\';
809 wszCachePath[path_len + suffix_len + 2] = '\0';
810 }
811
812 if (!WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, wszCachePath, path_len,
813 NULL, 0, NULL, &def_char) || def_char)
814 {
815 WCHAR tmp[MAX_PATH];
816
817 /* cannot convert path to ANSI code page */
818 if (!(path_len = GetShortPathNameW(wszCachePath, tmp, MAX_PATH)) ||
819 !WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, tmp, path_len,
820 NULL, 0, NULL, &def_char) || def_char)
821 ERR("Can't create container path accessible by ANSI functions\n");
822 else
823 memcpy(wszCachePath, tmp, (path_len+1)*sizeof(WCHAR));
824 }
825
826 cache_containers_add(DefaultContainerData[i].cache_prefix, wszCachePath,
827 DefaultContainerData[i].default_entry_type, wszMutexName);
828 }
829 }
830
831 static void cache_containers_free(void)
832 {
833 while(!list_empty(&UrlContainers))
834 cache_container_delete_container(
835 LIST_ENTRY(list_head(&UrlContainers), cache_container, entry)
836 );
837 }
838
839 static DWORD cache_containers_find(const char *url, cache_container **ret)
840 {
841 cache_container *container;
842
843 TRACE("searching for prefix for URL: %s\n", debugstr_a(url));
844
845 if(!url)
846 return ERROR_INVALID_PARAMETER;
847
848 LIST_FOR_EACH_ENTRY(container, &UrlContainers, cache_container, entry)
849 {
850 int prefix_len = strlen(container->cache_prefix);
851
852 if(!strncmp(container->cache_prefix, url, prefix_len)) {
853 TRACE("found container with prefix %s\n", debugstr_a(container->cache_prefix));
854 *ret = container;
855 return ERROR_SUCCESS;
856 }
857 }
858
859 ERR("no container found\n");
860 return ERROR_FILE_NOT_FOUND;
861 }
862
863 static BOOL cache_containers_enum(char *search_pattern, DWORD index, cache_container **ret)
864 {
865 DWORD i = 0;
866 cache_container *container;
867
868 TRACE("searching for prefix: %s\n", debugstr_a(search_pattern));
869
870 /* non-NULL search pattern only returns one container ever */
871 if (search_pattern && index > 0)
872 return FALSE;
873
874 LIST_FOR_EACH_ENTRY(container, &UrlContainers, cache_container, entry)
875 {
876 if (search_pattern)
877 {
878 if (!strcmp(container->cache_prefix, search_pattern))
879 {
880 TRACE("found container with prefix %s\n", debugstr_a(container->cache_prefix));
881 *ret = container;
882 return TRUE;
883 }
884 }
885 else
886 {
887 if (i == index)
888 {
889 TRACE("found container with prefix %s\n", debugstr_a(container->cache_prefix));
890 *ret = container;
891 return TRUE;
892 }
893 }
894 i++;
895 }
896 return FALSE;
897 }
898
899 /***********************************************************************
900 * cache_container_lock_index (Internal)
901 *
902 * Locks the index for system-wide exclusive access.
903 *
904 * RETURNS
905 * Cache file header if successful
906 * NULL if failed and calls SetLastError.
907 */
908 static urlcache_header* cache_container_lock_index(cache_container *pContainer)
909 {
910 BYTE index;
911 LPVOID pIndexData;
912 urlcache_header* pHeader;
913 DWORD error;
914
915 /* acquire mutex */
916 WaitForSingleObject(pContainer->mutex, INFINITE);
917
918 pIndexData = MapViewOfFile(pContainer->mapping, FILE_MAP_WRITE, 0, 0, 0);
919
920 if (!pIndexData)
921 {
922 ReleaseMutex(pContainer->mutex);
923 ERR("Couldn't MapViewOfFile. Error: %d\n", GetLastError());
924 return NULL;
925 }
926 pHeader = (urlcache_header*)pIndexData;
927
928 /* file has grown - we need to remap to prevent us getting
929 * access violations when we try and access beyond the end
930 * of the memory mapped file */
931 if (pHeader->size != pContainer->file_size)
932 {
933 UnmapViewOfFile( pHeader );
934 cache_container_close_index(pContainer);
935 error = cache_container_open_index(pContainer, MIN_BLOCK_NO);
936 if (error != ERROR_SUCCESS)
937 {
938 ReleaseMutex(pContainer->mutex);
939 SetLastError(error);
940 return NULL;
941 }
942 pIndexData = MapViewOfFile(pContainer->mapping, FILE_MAP_WRITE, 0, 0, 0);
943
944 if (!pIndexData)
945 {
946 ReleaseMutex(pContainer->mutex);
947 ERR("Couldn't MapViewOfFile. Error: %d\n", GetLastError());
948 return NULL;
949 }
950 pHeader = (urlcache_header*)pIndexData;
951 }
952
953 TRACE("Signature: %s, file size: %d bytes\n", pHeader->signature, pHeader->size);
954
955 for (index = 0; index < pHeader->dirs_no; index++)
956 {
957 TRACE("Directory[%d] = \"%.8s\"\n", index, pHeader->directory_data[index].name);
958 }
959
960 return pHeader;
961 }
962
963 /***********************************************************************
964 * cache_container_unlock_index (Internal)
965 *
966 */
967 static BOOL cache_container_unlock_index(cache_container *pContainer, urlcache_header *pHeader)
968 {
969 /* release mutex */
970 ReleaseMutex(pContainer->mutex);
971 return UnmapViewOfFile(pHeader);
972 }
973
974 /***********************************************************************
975 * urlcache_create_file_pathW (Internal)
976 *
977 * Copies the full path to the specified buffer given the local file
978 * name and the index of the directory it is in. Always sets value in
979 * lpBufferSize to the required buffer size (in bytes).
980 *
981 * RETURNS
982 * TRUE if the buffer was big enough
983 * FALSE if the buffer was too small
984 *
985 */
986 static BOOL urlcache_create_file_pathW(
987 const cache_container *pContainer,
988 const urlcache_header *pHeader,
989 LPCSTR szLocalFileName,
990 BYTE Directory,
991 LPWSTR wszPath,
992 LPLONG lpBufferSize)
993 {
994 LONG nRequired;
995 int path_len = strlenW(pContainer->path);
996 int file_name_len = MultiByteToWideChar(CP_ACP, 0, szLocalFileName, -1, NULL, 0);
997 if (Directory!=CACHE_CONTAINER_NO_SUBDIR && Directory>=pHeader->dirs_no)
998 {
999 *lpBufferSize = 0;
1000 return FALSE;
1001 }
1002
1003 nRequired = (path_len + file_name_len) * sizeof(WCHAR);
1004 if(Directory != CACHE_CONTAINER_NO_SUBDIR)
1005 nRequired += (DIR_LENGTH + 1) * sizeof(WCHAR);
1006 if (nRequired <= *lpBufferSize)
1007 {
1008 int dir_len;
1009
1010 memcpy(wszPath, pContainer->path, path_len * sizeof(WCHAR));
1011 if (Directory != CACHE_CONTAINER_NO_SUBDIR)
1012 {
1013 dir_len = MultiByteToWideChar(CP_ACP, 0, pHeader->directory_data[Directory].name, DIR_LENGTH, wszPath + path_len, DIR_LENGTH);
1014 wszPath[dir_len + path_len] = '\\';
1015 dir_len++;
1016 }
1017 else
1018 {
1019 dir_len = 0;
1020 }
1021 MultiByteToWideChar(CP_ACP, 0, szLocalFileName, -1, wszPath + dir_len + path_len, file_name_len);
1022 *lpBufferSize = nRequired;
1023 return TRUE;
1024 }
1025 *lpBufferSize = nRequired;
1026 return FALSE;
1027 }
1028
1029 /***********************************************************************
1030 * urlcache_create_file_pathA (Internal)
1031 *
1032 * Copies the full path to the specified buffer given the local file
1033 * name and the index of the directory it is in. Always sets value in
1034 * lpBufferSize to the required buffer size.
1035 *
1036 * RETURNS
1037 * TRUE if the buffer was big enough
1038 * FALSE if the buffer was too small
1039 *
1040 */
1041 static BOOL urlcache_create_file_pathA(
1042 const cache_container *pContainer,
1043 const urlcache_header *pHeader,
1044 LPCSTR szLocalFileName,
1045 BYTE Directory,
1046 LPSTR szPath,
1047 LPLONG lpBufferSize)
1048 {
1049 LONG nRequired;
1050 int path_len, file_name_len, dir_len;
1051
1052 if (Directory!=CACHE_CONTAINER_NO_SUBDIR && Directory>=pHeader->dirs_no)
1053 {
1054 *lpBufferSize = 0;
1055 return FALSE;
1056 }
1057
1058 path_len = WideCharToMultiByte(CP_ACP, 0, pContainer->path, -1, NULL, 0, NULL, NULL) - 1;
1059 file_name_len = strlen(szLocalFileName) + 1 /* for nul-terminator */;
1060 if (Directory!=CACHE_CONTAINER_NO_SUBDIR)
1061 dir_len = DIR_LENGTH+1;
1062 else
1063 dir_len = 0;
1064
1065 nRequired = (path_len + dir_len + file_name_len) * sizeof(char);
1066 if (nRequired <= *lpBufferSize)
1067 {
1068 WideCharToMultiByte(CP_ACP, 0, pContainer->path, -1, szPath, path_len, NULL, NULL);
1069 if(dir_len) {
1070 memcpy(szPath+path_len, pHeader->directory_data[Directory].name, dir_len-1);
1071 szPath[path_len + dir_len-1] = '\\';
1072 }
1073 memcpy(szPath + path_len + dir_len, szLocalFileName, file_name_len);
1074 *lpBufferSize = nRequired;
1075 return TRUE;
1076 }
1077 *lpBufferSize = nRequired;
1078 return FALSE;
1079 }
1080
1081 /* Just like FileTimeToDosDateTime, except that it also maps the special
1082 * case of a filetime of (0,0) to a DOS date/time of (0,0).
1083 */
1084 static void file_time_to_dos_date_time(const FILETIME *ft, WORD *fatdate,
1085 WORD *fattime)
1086 {
1087 if (!ft->dwLowDateTime && !ft->dwHighDateTime)
1088 *fatdate = *fattime = 0;
1089 else
1090 FileTimeToDosDateTime(ft, fatdate, fattime);
1091 }
1092
1093 /***********************************************************************
1094 * urlcache_delete_file (Internal)
1095 */
1096 static DWORD urlcache_delete_file(const cache_container *container,
1097 urlcache_header *header, entry_url *url_entry)
1098 {
1099 WIN32_FILE_ATTRIBUTE_DATA attr;
1100 WCHAR path[MAX_PATH];
1101 LONG path_size = sizeof(path);
1102 DWORD err;
1103 WORD date, time;
1104
1105 if(!url_entry->local_name_off)
1106 goto succ;
1107
1108 if(!urlcache_create_file_pathW(container, header,
1109 (LPCSTR)url_entry+url_entry->local_name_off,
1110 url_entry->cache_dir, path, &path_size))
1111 goto succ;
1112
1113 if(!GetFileAttributesExW(path, GetFileExInfoStandard, &attr))
1114 goto succ;
1115 file_time_to_dos_date_time(&attr.ftLastWriteTime, &date, &time);
1116 if(date != url_entry->write_date || time != url_entry->write_time)
1117 goto succ;
1118
1119 err = (DeleteFileW(path) ? ERROR_SUCCESS : GetLastError());
1120 if(err == ERROR_ACCESS_DENIED || err == ERROR_SHARING_VIOLATION)
1121 return err;
1122
1123 succ:
1124 if (url_entry->cache_dir < header->dirs_no)
1125 {
1126 if (header->directory_data[url_entry->cache_dir].files_no)
1127 header->directory_data[url_entry->cache_dir].files_no--;
1128 }
1129 if (url_entry->cache_entry_type & STICKY_CACHE_ENTRY)
1130 {
1131 if (url_entry->size.QuadPart < header->exempt_usage.QuadPart)
1132 header->exempt_usage.QuadPart -= url_entry->size.QuadPart;
1133 else
1134 header->exempt_usage.QuadPart = 0;
1135 }
1136 else
1137 {
1138 if (url_entry->size.QuadPart < header->cache_usage.QuadPart)
1139 header->cache_usage.QuadPart -= url_entry->size.QuadPart;
1140 else
1141 header->cache_usage.QuadPart = 0;
1142 }
1143
1144 return ERROR_SUCCESS;
1145 }
1146
1147 static BOOL urlcache_clean_leaked_entries(cache_container *container, urlcache_header *header)
1148 {
1149 DWORD *leak_off;
1150 BOOL freed = FALSE;
1151
1152 leak_off = &header->options[CACHE_HEADER_DATA_ROOT_LEAK_OFFSET];
1153 while(*leak_off) {
1154 entry_url *url_entry = (entry_url*)((LPBYTE)header + *leak_off);
1155
1156 if(SUCCEEDED(urlcache_delete_file(container, header, url_entry))) {
1157 *leak_off = url_entry->exempt_delta;
1158 urlcache_entry_free(header, &url_entry->header);
1159 freed = TRUE;
1160 }else {
1161 leak_off = &url_entry->exempt_delta;
1162 }
1163 }
1164
1165 return freed;
1166 }
1167
1168 /***********************************************************************
1169 * cache_container_clean_index (Internal)
1170 *
1171 * This function is meant to make place in index file by removing leaked
1172 * files entries and resizing the file.
1173 *
1174 * CAUTION: file view may get mapped to new memory
1175 *
1176 * RETURNS
1177 * ERROR_SUCCESS when new memory is available
1178 * error code otherwise
1179 */
1180 static DWORD cache_container_clean_index(cache_container *container, urlcache_header **file_view)
1181 {
1182 urlcache_header *header = *file_view;
1183 DWORD ret;
1184
1185 TRACE("(%s %s)\n", debugstr_a(container->cache_prefix), debugstr_w(container->path));
1186
1187 if(urlcache_clean_leaked_entries(container, header))
1188 return ERROR_SUCCESS;
1189
1190 if(header->size >= ALLOCATION_TABLE_SIZE*8*BLOCKSIZE + ENTRY_START_OFFSET) {
1191 WARN("index file has maximal size\n");
1192 return ERROR_NOT_ENOUGH_MEMORY;
1193 }
1194
1195 cache_container_close_index(container);
1196 ret = cache_container_open_index(container, header->capacity_in_blocks*2);
1197 if(ret != ERROR_SUCCESS)
1198 return ret;
1199 header = MapViewOfFile(container->mapping, FILE_MAP_WRITE, 0, 0, 0);
1200 if(!header)
1201 return GetLastError();
1202
1203 UnmapViewOfFile(*file_view);
1204 *file_view = header;
1205 return ERROR_SUCCESS;
1206 }
1207
1208 /* Just like DosDateTimeToFileTime, except that it also maps the special
1209 * case of a DOS date/time of (0,0) to a filetime of (0,0).
1210 */
1211 static void dos_date_time_to_file_time(WORD fatdate, WORD fattime,
1212 FILETIME *ft)
1213 {
1214 if (!fatdate && !fattime)
1215 ft->dwLowDateTime = ft->dwHighDateTime = 0;
1216 else
1217 DosDateTimeToFileTime(fatdate, fattime, ft);
1218 }
1219
1220 static int urlcache_decode_url(const char *url, WCHAR *decoded_url, int decoded_len)
1221 {
1222 URL_COMPONENTSA uc;
1223 DWORD len, part_len;
1224 WCHAR *host_name;
1225
1226 memset(&uc, 0, sizeof(uc));
1227 uc.dwStructSize = sizeof(uc);
1228 uc.dwHostNameLength = 1;
1229 if(!InternetCrackUrlA(url, 0, 0, &uc))
1230 uc.nScheme = INTERNET_SCHEME_UNKNOWN;
1231
1232 if(uc.nScheme!=INTERNET_SCHEME_HTTP && uc.nScheme!=INTERNET_SCHEME_HTTPS)
1233 return MultiByteToWideChar(CP_UTF8, 0, url, -1, decoded_url, decoded_len);
1234
1235 if(!decoded_url)
1236 decoded_len = 0;
1237
1238 len = MultiByteToWideChar(CP_UTF8, 0, url, uc.lpszHostName-url, decoded_url, decoded_len);
1239 if(!len)
1240 return 0;
1241 if(decoded_url)
1242 decoded_len -= len;
1243
1244 host_name = heap_alloc(uc.dwHostNameLength*sizeof(WCHAR));
1245 if(!host_name)
1246 return 0;
1247 if(!MultiByteToWideChar(CP_UTF8, 0, uc.lpszHostName, uc.dwHostNameLength,
1248 host_name, uc.dwHostNameLength)) {
1249 heap_free(host_name);
1250 return 0;
1251 }
1252 part_len = IdnToUnicode(0, host_name, uc.dwHostNameLength,
1253 decoded_url ? decoded_url+len : NULL, decoded_len);
1254 heap_free(host_name);
1255 if(!part_len) {
1256 SetLastError(ERROR_INTERNET_INVALID_URL);
1257 return 0;
1258 }
1259 len += part_len;
1260 if(decoded_url)
1261 decoded_len -= part_len;
1262
1263 part_len = MultiByteToWideChar(CP_UTF8, 0,
1264 uc.lpszHostName+uc.dwHostNameLength,
1265 -1, decoded_url ? decoded_url+len : NULL, decoded_len);
1266 if(!part_len)
1267 return 0;
1268 len += part_len;
1269
1270 return len;
1271 }
1272
1273 /***********************************************************************
1274 * urlcache_copy_entry (Internal)
1275 *
1276 * Copies an entry from the cache index file to the Win32 structure
1277 *
1278 * RETURNS
1279 * ERROR_SUCCESS if the buffer was big enough
1280 * ERROR_INSUFFICIENT_BUFFER if the buffer was too small
1281 *
1282 */
1283 static DWORD urlcache_copy_entry(cache_container *container, const urlcache_header *header,
1284 INTERNET_CACHE_ENTRY_INFOA *entry_info, DWORD *info_size, const entry_url *url_entry, BOOL unicode)
1285 {
1286 int url_len;
1287 DWORD size = sizeof(*entry_info);
1288
1289 if(*info_size >= size) {
1290 entry_info->lpHeaderInfo = NULL;
1291 entry_info->lpszFileExtension = NULL;
1292 entry_info->lpszLocalFileName = NULL;
1293 entry_info->lpszSourceUrlName = NULL;
1294 entry_info->CacheEntryType = url_entry->cache_entry_type;
1295 entry_info->u.dwExemptDelta = url_entry->exempt_delta;
1296 entry_info->dwHeaderInfoSize = url_entry->header_info_size;
1297 entry_info->dwHitRate = url_entry->hit_rate;
1298 entry_info->dwSizeHigh = url_entry->size.u.HighPart;
1299 entry_info->dwSizeLow = url_entry->size.u.LowPart;
1300 entry_info->dwStructSize = sizeof(*entry_info);
1301 entry_info->dwUseCount = url_entry->use_count;
1302 dos_date_time_to_file_time(url_entry->expire_date, url_entry->expire_time, &entry_info->ExpireTime);
1303 entry_info->LastAccessTime = url_entry->access_time;
1304 entry_info->LastModifiedTime = url_entry->modification_time;
1305 dos_date_time_to_file_time(url_entry->sync_date, url_entry->sync_time, &entry_info->LastSyncTime);
1306 }
1307
1308 if(size%4 && size<*info_size)
1309 ZeroMemory((LPBYTE)entry_info+size, 4-size%4);
1310 size = DWORD_ALIGN(size);
1311 if(unicode)
1312 url_len = urlcache_decode_url((const char*)url_entry+url_entry->url_off, NULL, 0);
1313 else
1314 url_len = strlen((LPCSTR)url_entry+url_entry->url_off) + 1;
1315 size += url_len * (unicode ? sizeof(WCHAR) : sizeof(CHAR));
1316
1317 if(*info_size >= size) {
1318 DWORD url_size = url_len * (unicode ? sizeof(WCHAR) : sizeof(CHAR));
1319
1320 entry_info->lpszSourceUrlName = (LPSTR)entry_info+size-url_size;
1321 if(unicode)
1322 urlcache_decode_url((const char*)url_entry+url_entry->url_off, (WCHAR*)entry_info->lpszSourceUrlName, url_len);
1323 else
1324 memcpy(entry_info->lpszSourceUrlName, (LPCSTR)url_entry+url_entry->url_off, url_size);
1325 }
1326
1327 if(size%4 && size<*info_size)
1328 ZeroMemory((LPBYTE)entry_info+size, 4-size%4);
1329 size = DWORD_ALIGN(size);
1330
1331 if(url_entry->local_name_off) {
1332 LONG file_name_size;
1333 LPSTR file_name;
1334 file_name = (LPSTR)entry_info+size;
1335 file_name_size = *info_size-size;
1336 if((unicode && urlcache_create_file_pathW(container, header, (LPCSTR)url_entry+url_entry->local_name_off, url_entry->cache_dir, (LPWSTR)file_name, &file_name_size)) ||
1337 (!unicode && urlcache_create_file_pathA(container, header, (LPCSTR)url_entry+url_entry->local_name_off, url_entry->cache_dir, file_name, &file_name_size))) {
1338 entry_info->lpszLocalFileName = file_name;
1339 }
1340 size += file_name_size;
1341
1342 if(size%4 && size<*info_size)
1343 ZeroMemory((LPBYTE)entry_info+size, 4-size%4);
1344 size = DWORD_ALIGN(size);
1345 }
1346
1347 if(url_entry->header_info_off) {
1348 DWORD header_len;
1349
1350 if(unicode)
1351 header_len = MultiByteToWideChar(CP_UTF8, 0, (const char*)url_entry+url_entry->header_info_off,
1352 url_entry->header_info_size, NULL, 0);
1353 else
1354 header_len = url_entry->header_info_size;
1355 size += header_len * (unicode ? sizeof(WCHAR) : sizeof(CHAR));
1356
1357 if(*info_size >= size) {
1358 DWORD header_size = header_len * (unicode ? sizeof(WCHAR) : sizeof(CHAR));
1359 entry_info->lpHeaderInfo = (LPBYTE)entry_info+size-header_size;
1360 if(unicode)
1361 MultiByteToWideChar(CP_UTF8, 0, (const char*)url_entry+url_entry->header_info_off,
1362 url_entry->header_info_size, (LPWSTR)entry_info->lpHeaderInfo, header_len);
1363 else
1364 memcpy(entry_info->lpHeaderInfo, (LPCSTR)url_entry+url_entry->header_info_off, header_len);
1365 }
1366 if(size%4 && size<*info_size)
1367 ZeroMemory((LPBYTE)entry_info+size, 4-size%4);
1368 size = DWORD_ALIGN(size);
1369 }
1370
1371 if(url_entry->file_extension_off) {
1372 int ext_len;
1373
1374 if(unicode)
1375 ext_len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)url_entry+url_entry->file_extension_off, -1, NULL, 0);
1376 else
1377 ext_len = strlen((LPCSTR)url_entry+url_entry->file_extension_off) + 1;
1378 size += ext_len * (unicode ? sizeof(WCHAR) : sizeof(CHAR));
1379
1380 if(*info_size >= size) {
1381 DWORD ext_size = ext_len * (unicode ? sizeof(WCHAR) : sizeof(CHAR));
1382 entry_info->lpszFileExtension = (LPSTR)entry_info+size-ext_size;
1383 if(unicode)
1384 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)url_entry+url_entry->file_extension_off, -1, (LPWSTR)entry_info->lpszFileExtension, ext_len);
1385 else
1386 memcpy(entry_info->lpszFileExtension, (LPCSTR)url_entry+url_entry->file_extension_off, ext_len*sizeof(CHAR));
1387 }
1388
1389 if(size%4 && size<*info_size)
1390 ZeroMemory((LPBYTE)entry_info+size, 4-size%4);
1391 size = DWORD_ALIGN(size);
1392 }
1393
1394 if(size > *info_size) {
1395 *info_size = size;
1396 return ERROR_INSUFFICIENT_BUFFER;
1397 }
1398 *info_size = size;
1399 return ERROR_SUCCESS;
1400 }
1401
1402 /***********************************************************************
1403 * urlcache_set_entry_info (Internal)
1404 *
1405 * Helper for SetUrlCacheEntryInfo{A,W}. Sets fields in URL entry
1406 * according to the flags set by field_control.
1407 *
1408 * RETURNS
1409 * ERROR_SUCCESS if the buffer was big enough
1410 * ERROR_INSUFFICIENT_BUFFER if the buffer was too small
1411 *
1412 */
1413 static DWORD urlcache_set_entry_info(entry_url *url_entry, const INTERNET_CACHE_ENTRY_INFOA *entry_info, DWORD field_control)
1414 {
1415 if (field_control & CACHE_ENTRY_ACCTIME_FC)
1416 url_entry->access_time = entry_info->LastAccessTime;
1417 if (field_control & CACHE_ENTRY_ATTRIBUTE_FC)
1418 url_entry->cache_entry_type = entry_info->CacheEntryType;
1419 if (field_control & CACHE_ENTRY_EXEMPT_DELTA_FC)
1420 url_entry->exempt_delta = entry_info->u.dwExemptDelta;
1421 if (field_control & CACHE_ENTRY_EXPTIME_FC)
1422 file_time_to_dos_date_time(&entry_info->ExpireTime, &url_entry->expire_date, &url_entry->expire_time);
1423 if (field_control & CACHE_ENTRY_HEADERINFO_FC)
1424 FIXME("CACHE_ENTRY_HEADERINFO_FC unimplemented\n");
1425 if (field_control & CACHE_ENTRY_HITRATE_FC)
1426 url_entry->hit_rate = entry_info->dwHitRate;
1427 if (field_control & CACHE_ENTRY_MODTIME_FC)
1428 url_entry->modification_time = entry_info->LastModifiedTime;
1429 if (field_control & CACHE_ENTRY_SYNCTIME_FC)
1430 file_time_to_dos_date_time(&entry_info->LastAccessTime, &url_entry->sync_date, &url_entry->sync_time);
1431
1432 return ERROR_SUCCESS;
1433 }
1434
1435 /***********************************************************************
1436 * urlcache_hash_key (Internal)
1437 *
1438 * Returns the hash key for a given string
1439 *
1440 * RETURNS
1441 * hash key for the string
1442 *
1443 */
1444 static DWORD urlcache_hash_key(LPCSTR lpszKey)
1445 {
1446 /* NOTE: this uses the same lookup table as SHLWAPI.UrlHash{A,W}
1447 * but the algorithm and result are not the same!
1448 */
1449 static const unsigned char lookupTable[256] =
1450 {
1451 0x01, 0x0E, 0x6E, 0x19, 0x61, 0xAE, 0x84, 0x77,
1452 0x8A, 0xAA, 0x7D, 0x76, 0x1B, 0xE9, 0x8C, 0x33,
1453 0x57, 0xC5, 0xB1, 0x6B, 0xEA, 0xA9, 0x38, 0x44,
1454 0x1E, 0x07, 0xAD, 0x49, 0xBC, 0x28, 0x24, 0x41,
1455 0x31, 0xD5, 0x68, 0xBE, 0x39, 0xD3, 0x94, 0xDF,
1456 0x30, 0x73, 0x0F, 0x02, 0x43, 0xBA, 0xD2, 0x1C,
1457 0x0C, 0xB5, 0x67, 0x46, 0x16, 0x3A, 0x4B, 0x4E,
1458 0xB7, 0xA7, 0xEE, 0x9D, 0x7C, 0x93, 0xAC, 0x90,
1459 0xB0, 0xA1, 0x8D, 0x56, 0x3C, 0x42, 0x80, 0x53,
1460 0x9C, 0xF1, 0x4F, 0x2E, 0xA8, 0xC6, 0x29, 0xFE,
1461 0xB2, 0x55, 0xFD, 0xED, 0xFA, 0x9A, 0x85, 0x58,
1462 0x23, 0xCE, 0x5F, 0x74, 0xFC, 0xC0, 0x36, 0xDD,
1463 0x66, 0xDA, 0xFF, 0xF0, 0x52, 0x6A, 0x9E, 0xC9,
1464 0x3D, 0x03, 0x59, 0x09, 0x2A, 0x9B, 0x9F, 0x5D,
1465 0xA6, 0x50, 0x32, 0x22, 0xAF, 0xC3, 0x64, 0x63,
1466 0x1A, 0x96, 0x10, 0x91, 0x04, 0x21, 0x08, 0xBD,
1467 0x79, 0x40, 0x4D, 0x48, 0xD0, 0xF5, 0x82, 0x7A,
1468 0x8F, 0x37, 0x69, 0x86, 0x1D, 0xA4, 0xB9, 0xC2,
1469 0xC1, 0xEF, 0x65, 0xF2, 0x05, 0xAB, 0x7E, 0x0B,
1470 0x4A, 0x3B, 0x89, 0xE4, 0x6C, 0xBF, 0xE8, 0x8B,
1471 0x06, 0x18, 0x51, 0x14, 0x7F, 0x11, 0x5B, 0x5C,
1472 0xFB, 0x97, 0xE1, 0xCF, 0x15, 0x62, 0x71, 0x70,
1473 0x54, 0xE2, 0x12, 0xD6, 0xC7, 0xBB, 0x0D, 0x20,
1474 0x5E, 0xDC, 0xE0, 0xD4, 0xF7, 0xCC, 0xC4, 0x2B,
1475 0xF9, 0xEC, 0x2D, 0xF4, 0x6F, 0xB6, 0x99, 0x88,
1476 0x81, 0x5A, 0xD9, 0xCA, 0x13, 0xA5, 0xE7, 0x47,
1477 0xE6, 0x8E, 0x60, 0xE3, 0x3E, 0xB3, 0xF6, 0x72,
1478 0xA2, 0x35, 0xA0, 0xD7, 0xCD, 0xB4, 0x2F, 0x6D,
1479 0x2C, 0x26, 0x1F, 0x95, 0x87, 0x00, 0xD8, 0x34,
1480 0x3F, 0x17, 0x25, 0x45, 0x27, 0x75, 0x92, 0xB8,
1481 0xA3, 0xC8, 0xDE, 0xEB, 0xF8, 0xF3, 0xDB, 0x0A,
1482 0x98, 0x83, 0x7B, 0xE5, 0xCB, 0x4C, 0x78, 0xD1
1483 };
1484 BYTE key[4];
1485 DWORD i;
1486
1487 for (i = 0; i < sizeof(key) / sizeof(key[0]); i++)
1488 key[i] = lookupTable[(*lpszKey + i) & 0xFF];
1489
1490 for (lpszKey++; *lpszKey; lpszKey++)
1491 {
1492 for (i = 0; i < sizeof(key) / sizeof(key[0]); i++)
1493 key[i] = lookupTable[*lpszKey ^ key[i]];
1494 }
1495
1496 return *(DWORD *)key;
1497 }
1498
1499 static inline entry_hash_table* urlcache_get_hash_table(const urlcache_header *pHeader, DWORD dwOffset)
1500 {
1501 if(!dwOffset)
1502 return NULL;
1503 return (entry_hash_table*)((LPBYTE)pHeader + dwOffset);
1504 }
1505
1506 static BOOL urlcache_find_hash_entry(const urlcache_header *pHeader, LPCSTR lpszUrl, struct hash_entry **ppHashEntry)
1507 {
1508 /* structure of hash table:
1509 * 448 entries divided into 64 blocks
1510 * each block therefore contains a chain of 7 key/offset pairs
1511 * how position in table is calculated:
1512 * 1. the url is hashed in helper function
1513 * 2. the key % HASHTABLE_NUM_ENTRIES is the bucket number
1514 * 3. bucket number * HASHTABLE_BLOCKSIZE is offset of the bucket
1515 *
1516 * note:
1517 * there can be multiple hash tables in the file and the offset to
1518 * the next one is stored in the header of the hash table
1519 */
1520 DWORD key = urlcache_hash_key(lpszUrl);
1521 DWORD offset = (key & (HASHTABLE_NUM_ENTRIES-1)) * HASHTABLE_BLOCKSIZE;
1522 entry_hash_table* pHashEntry;
1523 DWORD id = 0;
1524
1525 key >>= HASHTABLE_FLAG_BITS;
1526
1527 for (pHashEntry = urlcache_get_hash_table(pHeader, pHeader->hash_table_off);
1528 pHashEntry; pHashEntry = urlcache_get_hash_table(pHeader, pHashEntry->next))
1529 {
1530 int i;
1531 if (pHashEntry->id != id++)
1532 {
1533 ERR("Error: not right hash table number (%d) expected %d\n", pHashEntry->id, id);
1534 continue;
1535 }
1536 /* make sure that it is in fact a hash entry */
1537 if (pHashEntry->header.signature != HASH_SIGNATURE)
1538 {
1539 ERR("Error: not right signature (\"%.4s\") - expected \"HASH\"\n", (LPCSTR)&pHashEntry->header.signature);
1540 continue;
1541 }
1542
1543 for (i = 0; i < HASHTABLE_BLOCKSIZE; i++)
1544 {
1545 struct hash_entry *pHashElement = &pHashEntry->hash_table[offset + i];
1546 if (key == pHashElement->key>>HASHTABLE_FLAG_BITS)
1547 {
1548 /* FIXME: we should make sure that this is the right element
1549 * before returning and claiming that it is. We can do this
1550 * by doing a simple compare between the URL we were given
1551 * and the URL stored in the entry. However, this assumes
1552 * we know the format of all the entries stored in the
1553 * hash table */
1554 *ppHashEntry = pHashElement;
1555 return TRUE;
1556 }
1557 }
1558 }
1559 return FALSE;
1560 }
1561
1562 /***********************************************************************
1563 * urlcache_hash_entry_set_flags (Internal)
1564 *
1565 * Sets special bits in hash key
1566 *
1567 * RETURNS
1568 * nothing
1569 *
1570 */
1571 static void urlcache_hash_entry_set_flags(struct hash_entry *pHashEntry, DWORD dwFlag)
1572 {
1573 pHashEntry->key = (pHashEntry->key >> HASHTABLE_FLAG_BITS << HASHTABLE_FLAG_BITS) | dwFlag;
1574 }
1575
1576 /***********************************************************************
1577 * urlcache_hash_entry_delete (Internal)
1578 *
1579 * Searches all the hash tables in the index for the given URL and
1580 * then if found deletes the entry.
1581 *
1582 * RETURNS
1583 * TRUE if the entry was found
1584 * FALSE if the entry could not be found
1585 *
1586 */
1587 static BOOL urlcache_hash_entry_delete(struct hash_entry *pHashEntry)
1588 {
1589 pHashEntry->key = HASHTABLE_DEL;
1590 return TRUE;
1591 }
1592
1593 /***********************************************************************
1594 * urlcache_hash_entry_create (Internal)
1595 *
1596 * Searches all the hash tables for a free slot based on the offset
1597 * generated from the hash key. If a free slot is found, the offset and
1598 * key are entered into the hash table.
1599 *
1600 * RETURNS
1601 * ERROR_SUCCESS if the entry was added
1602 * Any other Win32 error code if the entry could not be added
1603 *
1604 */
1605 static DWORD urlcache_hash_entry_create(urlcache_header *pHeader, LPCSTR lpszUrl, DWORD dwOffsetEntry, DWORD dwFieldType)
1606 {
1607 /* see urlcache_find_hash_entry for structure of hash tables */
1608
1609 DWORD key = urlcache_hash_key(lpszUrl);
1610 DWORD offset = (key & (HASHTABLE_NUM_ENTRIES-1)) * HASHTABLE_BLOCKSIZE;
1611 entry_hash_table* pHashEntry, *pHashPrev = NULL;
1612 DWORD id = 0;
1613 DWORD error;
1614
1615 key = ((key >> HASHTABLE_FLAG_BITS) << HASHTABLE_FLAG_BITS) + dwFieldType;
1616
1617 for (pHashEntry = urlcache_get_hash_table(pHeader, pHeader->hash_table_off);
1618 pHashEntry; pHashEntry = urlcache_get_hash_table(pHeader, pHashEntry->next))
1619 {
1620 int i;
1621 pHashPrev = pHashEntry;
1622
1623 if (pHashEntry->id != id++)
1624 {
1625 ERR("not right hash table number (%d) expected %d\n", pHashEntry->id, id);
1626 break;
1627 }
1628 /* make sure that it is in fact a hash entry */
1629 if (pHashEntry->header.signature != HASH_SIGNATURE)
1630 {
1631 ERR("not right signature (\"%.4s\") - expected \"HASH\"\n", (LPCSTR)&pHashEntry->header.signature);
1632 break;
1633 }
1634
1635 for (i = 0; i < HASHTABLE_BLOCKSIZE; i++)
1636 {
1637 struct hash_entry *pHashElement = &pHashEntry->hash_table[offset + i];
1638 if (pHashElement->key==HASHTABLE_FREE || pHashElement->key==HASHTABLE_DEL) /* if the slot is free */
1639 {
1640 pHashElement->key = key;
1641 pHashElement->offset = dwOffsetEntry;
1642 return ERROR_SUCCESS;
1643 }
1644 }
1645 }
1646 error = urlcache_create_hash_table(pHeader, pHashPrev, &pHashEntry);
1647 if (error != ERROR_SUCCESS)
1648 return error;
1649
1650 pHashEntry->hash_table[offset].key = key;
1651 pHashEntry->hash_table[offset].offset = dwOffsetEntry;
1652 return ERROR_SUCCESS;
1653 }
1654
1655 /***********************************************************************
1656 * urlcache_enum_hash_tables (Internal)
1657 *
1658 * Enumerates the hash tables in a container.
1659 *
1660 * RETURNS
1661 * TRUE if an entry was found
1662 * FALSE if there are no more tables to enumerate.
1663 *
1664 */
1665 static BOOL urlcache_enum_hash_tables(const urlcache_header *pHeader, DWORD *id, entry_hash_table **ppHashEntry)
1666 {
1667 for (*ppHashEntry = urlcache_get_hash_table(pHeader, pHeader->hash_table_off);
1668 *ppHashEntry; *ppHashEntry = urlcache_get_hash_table(pHeader, (*ppHashEntry)->next))
1669 {
1670 TRACE("looking at hash table number %d\n", (*ppHashEntry)->id);
1671 if ((*ppHashEntry)->id != *id)
1672 continue;
1673 /* make sure that it is in fact a hash entry */
1674 if ((*ppHashEntry)->header.signature != HASH_SIGNATURE)
1675 {
1676 ERR("Error: not right signature (\"%.4s\") - expected \"HASH\"\n", (LPCSTR)&(*ppHashEntry)->header.signature);
1677 (*id)++;
1678 continue;
1679 }
1680
1681 TRACE("hash table number %d found\n", *id);
1682 return TRUE;
1683 }
1684 return FALSE;
1685 }
1686
1687 /***********************************************************************
1688 * urlcache_enum_hash_table_entries (Internal)
1689 *
1690 * Enumerates entries in a hash table and returns the next non-free entry.
1691 *
1692 * RETURNS
1693 * TRUE if an entry was found
1694 * FALSE if the hash table is empty or there are no more entries to
1695 * enumerate.
1696 *
1697 */
1698 static BOOL urlcache_enum_hash_table_entries(const urlcache_header *pHeader, const entry_hash_table *pHashEntry,
1699 DWORD * index, const struct hash_entry **ppHashEntry)
1700 {
1701 for (; *index < HASHTABLE_SIZE ; (*index)++)
1702 {
1703 if (pHashEntry->hash_table[*index].key==HASHTABLE_FREE || pHashEntry->hash_table[*index].key==HASHTABLE_DEL)
1704 continue;
1705
1706 *ppHashEntry = &pHashEntry->hash_table[*index];
1707 TRACE("entry found %d\n", *index);
1708 return TRUE;
1709 }
1710 TRACE("no more entries (%d)\n", *index);
1711 return FALSE;
1712 }
1713
1714 /***********************************************************************
1715 * cache_container_delete_dir (Internal)
1716 *
1717 * Erase a directory containing an URL cache.
1718 *
1719 * RETURNS
1720 * TRUE success, FALSE failure/aborted.
1721 *
1722 */
1723 static BOOL cache_container_delete_dir(LPCWSTR lpszPath)
1724 {
1725 DWORD path_len;
1726 WCHAR path[MAX_PATH + 1];
1727 SHFILEOPSTRUCTW shfos;
1728 int ret;
1729
1730 path_len = strlenW(lpszPath);
1731 if (path_len >= MAX_PATH)
1732 return FALSE;
1733 strcpyW(path, lpszPath);
1734 path[path_len + 1] = 0; /* double-NUL-terminate path */
1735
1736 shfos.hwnd = NULL;
1737 shfos.wFunc = FO_DELETE;
1738 shfos.pFrom = path;
1739 shfos.pTo = NULL;
1740 shfos.fFlags = FOF_NOCONFIRMATION;
1741 shfos.fAnyOperationsAborted = FALSE;
1742 ret = SHFileOperationW(&shfos);
1743 if (ret)
1744 ERR("SHFileOperationW on %s returned %i\n", debugstr_w(path), ret);
1745 return !(ret || shfos.fAnyOperationsAborted);
1746 }
1747
1748 /***********************************************************************
1749 * urlcache_hash_entry_is_locked (Internal)
1750 *
1751 * Checks if entry is locked. Unlocks it if possible.
1752 */
1753 static BOOL urlcache_hash_entry_is_locked(struct hash_entry *hash_entry, entry_url *url_entry)
1754 {
1755 FILETIME cur_time;
1756 ULARGE_INTEGER acc_time, time;
1757
1758 if ((hash_entry->key & ((1<<HASHTABLE_FLAG_BITS)-1)) != HASHTABLE_LOCK)
1759 return FALSE;
1760
1761 GetSystemTimeAsFileTime(&cur_time);
1762 time.u.LowPart = cur_time.dwLowDateTime;
1763 time.u.HighPart = cur_time.dwHighDateTime;
1764
1765 acc_time.u.LowPart = url_entry->access_time.dwLowDateTime;
1766 acc_time.u.HighPart = url_entry->access_time.dwHighDateTime;
1767
1768 time.QuadPart -= acc_time.QuadPart;
1769
1770 /* check if entry was locked for at least a day */
1771 if(time.QuadPart > (ULONGLONG)24*60*60*FILETIME_SECOND) {
1772 urlcache_hash_entry_set_flags(hash_entry, HASHTABLE_URL);
1773 url_entry->use_count = 0;
1774 return FALSE;
1775 }
1776
1777 return TRUE;
1778 }
1779
1780 static BOOL urlcache_get_entry_info(const char *url, void *entry_info,
1781 DWORD *size, DWORD flags, BOOL unicode)
1782 {
1783 urlcache_header *header;
1784 struct hash_entry *hash_entry;
1785 const entry_url *url_entry;
1786 cache_container *container;
1787 DWORD error;
1788
1789 TRACE("(%s, %p, %p, %x, %x)\n", debugstr_a(url), entry_info, size, flags, unicode);
1790
1791 if(flags & ~GET_INSTALLED_ENTRY)
1792 FIXME("ignoring unsupported flags: %x\n", flags);
1793
1794 error = cache_containers_find(url, &container);
1795 if(error != ERROR_SUCCESS) {
1796 SetLastError(error);
1797 return FALSE;
1798 }
1799
1800 error = cache_container_open_index(container, MIN_BLOCK_NO);
1801 if(error != ERROR_SUCCESS) {
1802 SetLastError(error);
1803 return FALSE;
1804 }
1805
1806 if(!(header = cache_container_lock_index(container)))
1807 return FALSE;
1808
1809 if(!urlcache_find_hash_entry(header, url, &hash_entry)) {
1810 cache_container_unlock_index(container, header);
1811 WARN("entry %s not found!\n", debugstr_a(url));
1812 SetLastError(ERROR_FILE_NOT_FOUND);
1813 return FALSE;
1814 }
1815
1816 url_entry = (const entry_url*)((LPBYTE)header + hash_entry->offset);
1817 if(url_entry->header.signature != URL_SIGNATURE) {
1818 cache_container_unlock_index(container, header);
1819 FIXME("Trying to retrieve entry of unknown format %s\n",
1820 debugstr_an((LPCSTR)&url_entry->header.signature, sizeof(DWORD)));
1821 SetLastError(ERROR_FILE_NOT_FOUND);
1822 return FALSE;
1823 }
1824
1825 TRACE("Found URL: %s\n", debugstr_a((LPCSTR)url_entry + url_entry->url_off));
1826 TRACE("Header info: %s\n", debugstr_an((LPCSTR)url_entry +
1827 url_entry->header_info_off, url_entry->header_info_size));
1828
1829 if((flags & GET_INSTALLED_ENTRY) && !(url_entry->cache_entry_type & INSTALLED_CACHE_ENTRY)) {
1830 cache_container_unlock_index(container, header);
1831 SetLastError(ERROR_FILE_NOT_FOUND);
1832 return FALSE;
1833 }
1834
1835 if(size) {
1836 if(!entry_info)
1837 *size = 0;
1838
1839 error = urlcache_copy_entry(container, header, entry_info, size, url_entry, unicode);
1840 if(error != ERROR_SUCCESS) {
1841 cache_container_unlock_index(container, header);
1842 SetLastError(error);
1843 return FALSE;
1844 }
1845 if(url_entry->local_name_off)
1846 TRACE("Local File Name: %s\n", debugstr_a((LPCSTR)url_entry + url_entry->local_name_off));
1847 }
1848
1849 cache_container_unlock_index(container, header);
1850 return TRUE;
1851 }
1852
1853 /***********************************************************************
1854 * GetUrlCacheEntryInfoExA (WININET.@)
1855 *
1856 */
1857 BOOL WINAPI GetUrlCacheEntryInfoExA(LPCSTR lpszUrl,
1858 LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1859 LPDWORD lpdwCacheEntryInfoBufSize, LPSTR lpszReserved,
1860 LPDWORD lpdwReserved, LPVOID lpReserved, DWORD dwFlags)
1861 {
1862 if(lpszReserved!=NULL || lpdwReserved!=NULL || lpReserved!=NULL) {
1863 ERR("Reserved value was not 0\n");
1864 SetLastError(ERROR_INVALID_PARAMETER);
1865 return FALSE;
1866 }
1867
1868 return urlcache_get_entry_info(lpszUrl, lpCacheEntryInfo,
1869 lpdwCacheEntryInfoBufSize, dwFlags, FALSE);
1870 }
1871
1872 /***********************************************************************
1873 * GetUrlCacheEntryInfoA (WININET.@)
1874 *
1875 */
1876 BOOL WINAPI GetUrlCacheEntryInfoA(LPCSTR lpszUrlName,
1877 LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1878 LPDWORD lpdwCacheEntryInfoBufferSize)
1879 {
1880 return GetUrlCacheEntryInfoExA(lpszUrlName, lpCacheEntryInfo,
1881 lpdwCacheEntryInfoBufferSize, NULL, NULL, NULL, 0);
1882 }
1883
1884 static int urlcache_encode_url(const WCHAR *url, char *encoded_url, int encoded_len)
1885 {
1886 URL_COMPONENTSW uc;
1887 DWORD len, part_len;
1888 WCHAR *punycode;
1889
1890 TRACE("%s\n", debugstr_w(url));
1891
1892 memset(&uc, 0, sizeof(uc));
1893 uc.dwStructSize = sizeof(uc);
1894 uc.dwHostNameLength = 1;
1895 if(!InternetCrackUrlW(url, 0, 0, &uc))
1896 uc.nScheme = INTERNET_SCHEME_UNKNOWN;
1897
1898 if(uc.nScheme!=INTERNET_SCHEME_HTTP && uc.nScheme!=INTERNET_SCHEME_HTTPS)
1899 return WideCharToMultiByte(CP_UTF8, 0, url, -1, encoded_url, encoded_len, NULL, NULL);
1900
1901 len = WideCharToMultiByte(CP_UTF8, 0, url, uc.lpszHostName-url,
1902 encoded_url, encoded_len, NULL, NULL);
1903 if(!len)
1904 return 0;
1905 if(encoded_url)
1906 encoded_len -= len;
1907
1908 part_len = IdnToAscii(0, uc.lpszHostName, uc.dwHostNameLength, NULL, 0);
1909 if(!part_len) {
1910 SetLastError(ERROR_INTERNET_INVALID_URL);
1911 return 0;
1912 }
1913
1914 punycode = heap_alloc(part_len*sizeof(WCHAR));
1915 if(!punycode)
1916 return 0;
1917
1918 part_len = IdnToAscii(0, uc.lpszHostName, uc.dwHostNameLength, punycode, part_len);
1919 if(!part_len) {
1920 heap_free(punycode);
1921 return 0;
1922 }
1923
1924 part_len = WideCharToMultiByte(CP_UTF8, 0, punycode, part_len,
1925 encoded_url ? encoded_url+len : NULL, encoded_len, NULL, NULL);
1926 heap_free(punycode);
1927 if(!part_len)
1928 return 0;
1929 if(encoded_url)
1930 encoded_len -= part_len;
1931 len += part_len;
1932
1933 part_len = WideCharToMultiByte(CP_UTF8, 0, uc.lpszHostName+uc.dwHostNameLength,
1934 -1, encoded_url ? encoded_url+len : NULL, encoded_len, NULL, NULL);
1935 if(!part_len)
1936 return 0;
1937 len += part_len;
1938
1939 TRACE("got (%d)%s\n", len, debugstr_a(encoded_url));
1940 return len;
1941 }
1942
1943 static BOOL urlcache_encode_url_alloc(const WCHAR *url, char **encoded_url)
1944 {
1945 DWORD encoded_len;
1946 char *ret;
1947
1948 encoded_len = urlcache_encode_url(url, NULL, 0);
1949 if(!encoded_len)
1950 return FALSE;
1951
1952 ret = heap_alloc(encoded_len*sizeof(WCHAR));
1953 if(!ret)
1954 return FALSE;
1955
1956 encoded_len = urlcache_encode_url(url, ret, encoded_len);
1957 if(!encoded_len) {
1958 heap_free(ret);
1959 return FALSE;
1960 }
1961
1962 *encoded_url = ret;
1963 return TRUE;
1964 }
1965
1966 /***********************************************************************
1967 * GetUrlCacheEntryInfoExW (WININET.@)
1968 *
1969 */
1970 BOOL WINAPI GetUrlCacheEntryInfoExW(LPCWSTR lpszUrl,
1971 LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
1972 LPDWORD lpdwCacheEntryInfoBufSize, LPWSTR lpszReserved,
1973 LPDWORD lpdwReserved, LPVOID lpReserved, DWORD dwFlags)
1974 {
1975 char *url;
1976 BOOL ret;
1977
1978 if(lpszReserved!=NULL || lpdwReserved!=NULL || lpReserved!=NULL) {
1979 ERR("Reserved value was not 0\n");
1980 SetLastError(ERROR_INVALID_PARAMETER);
1981 return FALSE;
1982 }
1983
1984 /* Ignore GET_INSTALLED_ENTRY flag in unicode version of function */
1985 dwFlags &= ~GET_INSTALLED_ENTRY;
1986
1987 if(!urlcache_encode_url_alloc(lpszUrl, &url))
1988 return FALSE;
1989
1990 ret = urlcache_get_entry_info(url, lpCacheEntryInfo,
1991 lpdwCacheEntryInfoBufSize, dwFlags, TRUE);
1992 heap_free(url);
1993 return ret;
1994 }
1995
1996 /***********************************************************************
1997 * GetUrlCacheEntryInfoW (WININET.@)
1998 *
1999 */
2000 BOOL WINAPI GetUrlCacheEntryInfoW(LPCWSTR lpszUrl,
2001 LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
2002 LPDWORD lpdwCacheEntryInfoBufferSize)
2003 {
2004 return GetUrlCacheEntryInfoExW(lpszUrl, lpCacheEntryInfo,
2005 lpdwCacheEntryInfoBufferSize, NULL, NULL, NULL, 0);
2006 }
2007
2008 /***********************************************************************
2009 * SetUrlCacheEntryInfoA (WININET.@)
2010 */
2011 BOOL WINAPI SetUrlCacheEntryInfoA(LPCSTR lpszUrlName,
2012 LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
2013 DWORD dwFieldControl)
2014 {
2015 urlcache_header *pHeader;
2016 struct hash_entry *pHashEntry;
2017 entry_header *pEntry;
2018 cache_container *pContainer;
2019 DWORD error;
2020
2021 TRACE("(%s, %p, 0x%08x)\n", debugstr_a(lpszUrlName), lpCacheEntryInfo, dwFieldControl);
2022
2023 error = cache_containers_find(lpszUrlName, &pContainer);
2024 if (error != ERROR_SUCCESS)
2025 {
2026 SetLastError(error);
2027 return FALSE;
2028 }
2029
2030 error = cache_container_open_index(pContainer, MIN_BLOCK_NO);
2031 if (error != ERROR_SUCCESS)
2032 {
2033 SetLastError(error);
2034 return FALSE;
2035 }
2036
2037 if (!(pHeader = cache_container_lock_index(pContainer)))
2038 return FALSE;
2039
2040 if (!urlcache_find_hash_entry(pHeader, lpszUrlName, &pHashEntry))
2041 {
2042 cache_container_unlock_index(pContainer, pHeader);
2043 WARN("entry %s not found!\n", debugstr_a(lpszUrlName));
2044 SetLastError(ERROR_FILE_NOT_FOUND);
2045 return FALSE;
2046 }
2047
2048 pEntry = (entry_header*)((LPBYTE)pHeader + pHashEntry->offset);
2049 if (pEntry->signature != URL_SIGNATURE)
2050 {
2051 cache_container_unlock_index(pContainer, pHeader);
2052 FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->signature, sizeof(DWORD)));
2053 SetLastError(ERROR_FILE_NOT_FOUND);
2054 return FALSE;
2055 }
2056
2057 urlcache_set_entry_info((entry_url*)pEntry, lpCacheEntryInfo, dwFieldControl);
2058
2059 cache_container_unlock_index(pContainer, pHeader);
2060
2061 return TRUE;
2062 }
2063
2064 /***********************************************************************
2065 * SetUrlCacheEntryInfoW (WININET.@)
2066 */
2067 BOOL WINAPI SetUrlCacheEntryInfoW(LPCWSTR lpszUrl,
2068 LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
2069 DWORD dwFieldControl)
2070 {
2071 char *url;
2072 BOOL ret;
2073
2074 if(!urlcache_encode_url_alloc(lpszUrl, &url))
2075 return FALSE;
2076
2077 ret = SetUrlCacheEntryInfoA(url, (INTERNET_CACHE_ENTRY_INFOA*)lpCacheEntryInfo, dwFieldControl);
2078 heap_free(url);
2079 return ret;
2080 }
2081
2082 static BOOL urlcache_entry_get_file(const char *url, void *entry_info, DWORD *size, BOOL unicode)
2083 {
2084 urlcache_header *header;
2085 struct hash_entry *hash_entry;
2086 entry_url *url_entry;
2087 cache_container *container;
2088 DWORD error;
2089
2090 TRACE("(%s, %p, %p, %x)\n", debugstr_a(url), entry_info, size, unicode);
2091
2092 if(!url || !size || (!entry_info && *size)) {
2093 SetLastError(ERROR_INVALID_PARAMETER);
2094 return FALSE;
2095 }
2096
2097 error = cache_containers_find(url, &container);
2098 if(error != ERROR_SUCCESS) {
2099 SetLastError(error);
2100 return FALSE;
2101 }
2102
2103 error = cache_container_open_index(container, MIN_BLOCK_NO);
2104 if (error != ERROR_SUCCESS) {
2105 SetLastError(error);
2106 return FALSE;
2107 }
2108
2109 if (!(header = cache_container_lock_index(container)))
2110 return FALSE;
2111
2112 if (!urlcache_find_hash_entry(header, url, &hash_entry)) {
2113 cache_container_unlock_index(container, header);
2114 TRACE("entry %s not found!\n", url);
2115 SetLastError(ERROR_FILE_NOT_FOUND);
2116 return FALSE;
2117 }
2118
2119 url_entry = (entry_url*)((LPBYTE)header + hash_entry->offset);
2120 if(url_entry->header.signature != URL_SIGNATURE) {
2121 cache_container_unlock_index(container, header);
2122 FIXME("Trying to retrieve entry of unknown format %s\n",
2123 debugstr_an((LPSTR)&url_entry->header.signature, sizeof(DWORD)));
2124 SetLastError(ERROR_FILE_NOT_FOUND);
2125 return FALSE;
2126 }
2127
2128 if(!url_entry->local_name_off) {
2129 cache_container_unlock_index(container, header);
2130 SetLastError(ERROR_INVALID_DATA);
2131 return FALSE;
2132 }
2133
2134 TRACE("Found URL: %s\n", debugstr_a((LPCSTR)url_entry + url_entry->url_off));
2135 TRACE("Header info: %s\n", debugstr_an((LPCSTR)url_entry + url_entry->header_info_off,
2136 url_entry->header_info_size));
2137
2138 error = urlcache_copy_entry(container, header, entry_info,
2139 size, url_entry, unicode);
2140 if(error != ERROR_SUCCESS) {
2141 cache_container_unlock_index(container, header);
2142 SetLastError(error);
2143 return FALSE;
2144 }
2145 TRACE("Local File Name: %s\n", debugstr_a((LPCSTR)url_entry + url_entry->local_name_off));
2146
2147 url_entry->hit_rate++;
2148 url_entry->use_count++;
2149 urlcache_hash_entry_set_flags(hash_entry, HASHTABLE_LOCK);
2150 GetSystemTimeAsFileTime(&url_entry->access_time);
2151
2152 cache_container_unlock_index(container, header);
2153
2154 return TRUE;
2155 }
2156
2157 /***********************************************************************
2158 * RetrieveUrlCacheEntryFileA (WININET.@)
2159 *
2160 */
2161 BOOL WINAPI RetrieveUrlCacheEntryFileA(LPCSTR lpszUrlName,
2162 LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
2163 LPDWORD lpdwCacheEntryInfoBufferSize, DWORD dwReserved)
2164 {
2165 return urlcache_entry_get_file(lpszUrlName, lpCacheEntryInfo,
2166 lpdwCacheEntryInfoBufferSize, FALSE);
2167 }
2168
2169 /***********************************************************************
2170 * RetrieveUrlCacheEntryFileW (WININET.@)
2171 *
2172 */
2173 BOOL WINAPI RetrieveUrlCacheEntryFileW(LPCWSTR lpszUrlName,
2174 LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
2175 LPDWORD lpdwCacheEntryInfoBufferSize, DWORD dwReserved)
2176 {
2177 char *url;
2178 BOOL ret;
2179
2180 if(!urlcache_encode_url_alloc(lpszUrlName, &url))
2181 return FALSE;
2182
2183 ret = urlcache_entry_get_file(url, lpCacheEntryInfo,
2184 lpdwCacheEntryInfoBufferSize, TRUE);
2185 heap_free(url);
2186 return ret;
2187 }
2188
2189 static BOOL urlcache_entry_delete(const cache_container *pContainer,
2190 urlcache_header *pHeader, struct hash_entry *pHashEntry)
2191 {
2192 entry_header *pEntry;
2193 entry_url * pUrlEntry;
2194
2195 pEntry = (entry_header*)((LPBYTE)pHeader + pHashEntry->offset);
2196 if (pEntry->signature != URL_SIGNATURE)
2197 {
2198 FIXME("Trying to delete entry of unknown format %s\n",
2199 debugstr_an((LPCSTR)&pEntry->signature, sizeof(DWORD)));
2200 SetLastError(ERROR_FILE_NOT_FOUND);
2201 return FALSE;
2202 }
2203
2204 pUrlEntry = (entry_url *)pEntry;
2205 if(urlcache_hash_entry_is_locked(pHashEntry, pUrlEntry))
2206 {
2207 TRACE("Trying to delete locked entry\n");
2208 pUrlEntry->cache_entry_type |= PENDING_DELETE_CACHE_ENTRY;
2209 SetLastError(ERROR_SHARING_VIOLATION);
2210 return FALSE;
2211 }
2212
2213 if(!urlcache_delete_file(pContainer, pHeader, pUrlEntry))
2214 {
2215 urlcache_entry_free(pHeader, pEntry);
2216 }
2217 else
2218 {
2219 /* Add entry to leaked files list */
2220 pUrlEntry->header.signature = LEAK_SIGNATURE;
2221 pUrlEntry->exempt_delta = pHeader->options[CACHE_HEADER_DATA_ROOT_LEAK_OFFSET];
2222 pHeader->options[CACHE_HEADER_DATA_ROOT_LEAK_OFFSET] = pHashEntry->offset;
2223 }
2224
2225 urlcache_hash_entry_delete(pHashEntry);
2226 return TRUE;
2227 }
2228
2229 static HANDLE free_cache_running;
2230 static HANDLE dll_unload_event;
2231 static DWORD WINAPI handle_full_cache_worker(void *param)
2232 {
2233 FreeUrlCacheSpaceW(NULL, 20, 0);
2234 ReleaseSemaphore(free_cache_running, 1, NULL);
2235 return 0;
2236 }
2237
2238 static void handle_full_cache(void)
2239 {
2240 if(WaitForSingleObject(free_cache_running, 0) == WAIT_OBJECT_0) {
2241 if(!QueueUserWorkItem(handle_full_cache_worker, NULL, 0))
2242 ReleaseSemaphore(free_cache_running, 1, NULL);
2243 }
2244 }
2245
2246 /* Enumerates entries in cache, allows cache unlocking between calls. */
2247 static BOOL urlcache_next_entry(urlcache_header *header, DWORD *hash_table_off, DWORD *hash_table_entry,
2248 struct hash_entry **hash_entry, entry_header **entry)
2249 {
2250 entry_hash_table *hashtable_entry;
2251
2252 *hash_entry = NULL;
2253 *entry = NULL;
2254
2255 if(!*hash_table_off) {
2256 *hash_table_off = header->hash_table_off;
2257 *hash_table_entry = 0;
2258
2259 hashtable_entry = urlcache_get_hash_table(header, *hash_table_off);
2260 }else {
2261 if(*hash_table_off >= header->size) {
2262 *hash_table_off = 0;
2263 return FALSE;
2264 }
2265
2266 hashtable_entry = urlcache_get_hash_table(header, *hash_table_off);
2267 }
2268
2269 if(hashtable_entry->header.signature != HASH_SIGNATURE) {
2270 *hash_table_off = 0;
2271 return FALSE;
2272 }
2273
2274 while(1) {
2275 if(*hash_table_entry >= HASHTABLE_SIZE) {
2276 *hash_table_off = hashtable_entry->next;
2277 if(!*hash_table_off) {
2278 *hash_table_off = 0;
2279 return FALSE;
2280 }
2281
2282 hashtable_entry = urlcache_get_hash_table(header, *hash_table_off);
2283 *hash_table_entry = 0;
2284 }
2285
2286 if(hashtable_entry->hash_table[*hash_table_entry].key != HASHTABLE_DEL &&
2287 hashtable_entry->hash_table[*hash_table_entry].key != HASHTABLE_FREE) {
2288 *hash_entry = &hashtable_entry->hash_table[*hash_table_entry];
2289 *entry = (entry_header*)((LPBYTE)header + hashtable_entry->hash_table[*hash_table_entry].offset);
2290 (*hash_table_entry)++;
2291 return TRUE;
2292 }
2293
2294 (*hash_table_entry)++;
2295 }
2296
2297 *hash_table_off = 0;
2298 return FALSE;
2299 }
2300
2301 /* Rates an urlcache entry to determine if it can be deleted.
2302 *
2303 * Score 0 means that entry can safely be removed, the bigger rating
2304 * the smaller chance of entry being removed.
2305 * DWORD_MAX means that entry can't be deleted at all.
2306 *
2307 * Rating system is currently not fully compatible with native implementation.
2308 */
2309 static DWORD urlcache_rate_entry(entry_url *url_entry, FILETIME *cur_time)
2310 {
2311 ULARGE_INTEGER time, access_time;
2312 DWORD rating;
2313
2314 access_time.u.LowPart = url_entry->access_time.dwLowDateTime;
2315 access_time.u.HighPart = url_entry->access_time.dwHighDateTime;
2316
2317 time.u.LowPart = cur_time->dwLowDateTime;
2318 time.u.HighPart = cur_time->dwHighDateTime;
2319
2320 /* Don't touch entries that were added less than 10 minutes ago */
2321 if(time.QuadPart < access_time.QuadPart + (ULONGLONG)10*60*FILETIME_SECOND)
2322 return -1;
2323
2324 if(url_entry->cache_entry_type & STICKY_CACHE_ENTRY)
2325 if(time.QuadPart < access_time.QuadPart + (ULONGLONG)url_entry->exempt_delta*FILETIME_SECOND)
2326 return -1;
2327
2328 time.QuadPart = (time.QuadPart-access_time.QuadPart)/FILETIME_SECOND;
2329 rating = 400*60*60*24/(60*60*24+time.QuadPart);
2330
2331 if(url_entry->hit_rate > 100)
2332 rating += 100;
2333 else
2334 rating += url_entry->hit_rate;
2335
2336 return rating;
2337 }
2338
2339 static int dword_cmp(const void *p1, const void *p2)
2340 {
2341 return *(const DWORD*)p1 - *(const DWORD*)p2;
2342 }
2343
2344 /***********************************************************************
2345 * FreeUrlCacheSpaceW (WININET.@)
2346 *
2347 * Frees up some cache.
2348 *
2349 * PARAMETERS
2350 * cache_path [I] Which volume to free up from, or NULL if you don't care.
2351 * size [I] Percentage of the cache that should be free.
2352 * filter [I] Which entries can't be deleted (CacheEntryType)
2353 *
2354 * RETURNS
2355 * TRUE success. FALSE failure.
2356 *
2357 * IMPLEMENTATION
2358 * This implementation just retrieves the path of the cache directory, and
2359 * deletes its contents from the filesystem. The correct approach would
2360 * probably be to implement and use {FindFirst,FindNext,Delete}UrlCacheGroup().
2361 */
2362 BOOL WINAPI FreeUrlCacheSpaceW(LPCWSTR cache_path, DWORD size, DWORD filter)
2363 {
2364 cache_container *container;
2365 DWORD path_len, err;
2366
2367 TRACE("(%s, %x, %x)\n", debugstr_w(cache_path), size, filter);
2368
2369 if(size<1 || size>100) {
2370 SetLastError(ERROR_INVALID_PARAMETER);
2371 return FALSE;
2372 }
2373
2374 if(cache_path) {
2375 path_len = strlenW(cache_path);
2376 if(cache_path[path_len-1] == '\\')
2377 path_len--;
2378 }else {
2379 path_len = 0;
2380 }
2381
2382 if(size==100 && !filter) {
2383 LIST_FOR_EACH_ENTRY(container, &UrlContainers, cache_container, entry)
2384 {
2385 /* When cache_path==NULL only clean Temporary Internet Files */
2386 if((!path_len && container->cache_prefix[0]==0) ||
2387 (path_len && !strncmpiW(container->path, cache_path, path_len) &&
2388 (container->path[path_len]=='\0' || container->path[path_len]=='\\')))
2389 {
2390 BOOL ret_del;
2391
2392 WaitForSingleObject(container->mutex, INFINITE);
2393
2394 /* unlock, delete, recreate and lock cache */
2395 cache_container_close_index(container);
2396 ret_del = cache_container_delete_dir(container->path);
2397 err = cache_container_open_index(container, MIN_BLOCK_NO);
2398
2399 ReleaseMutex(container->mutex);
2400 if(!ret_del || (err != ERROR_SUCCESS))
2401 return FALSE;
2402 }
2403 }
2404
2405 return TRUE;
2406 }
2407
2408 LIST_FOR_EACH_ENTRY(container, &UrlContainers, cache_container, entry)
2409 {
2410 urlcache_header *header;
2411 struct hash_entry *hash_entry;
2412 entry_header *entry;
2413 entry_url *url_entry;
2414 ULONGLONG desired_size, cur_size;
2415 DWORD delete_factor, hash_table_off, hash_table_entry;
2416 DWORD rate[100], rate_no;
2417 FILETIME cur_time;
2418
2419 if((path_len || container->cache_prefix[0]!=0) &&
2420 (!path_len || strncmpiW(container->path, cache_path, path_len) ||
2421 (container->path[path_len]!='\0' && container->path[path_len]!='\\')))
2422 continue;
2423
2424 err = cache_container_open_index(container, MIN_BLOCK_NO);
2425 if(err != ERROR_SUCCESS)
2426 continue;
2427
2428 header = cache_container_lock_index(container);
2429 if(!header)
2430 continue;
2431
2432 urlcache_clean_leaked_entries(container, header);
2433
2434 desired_size = header->cache_limit.QuadPart*(100-size)/100;
2435 cur_size = header->cache_usage.QuadPart+header->exempt_usage.QuadPart;
2436 if(cur_size <= desired_size)
2437 delete_factor = 0;
2438 else
2439 delete_factor = (cur_size-desired_size)*100/cur_size;
2440
2441 if(!delete_factor) {
2442 cache_container_unlock_index(container, header);
2443 continue;
2444 }
2445
2446 hash_table_off = 0;
2447 hash_table_entry = 0;
2448 rate_no = 0;
2449 GetSystemTimeAsFileTime(&cur_time);
2450 while(rate_no<sizeof(rate)/sizeof(*rate) &&
2451 urlcache_next_entry(header, &hash_table_off, &hash_table_entry, &hash_entry, &entry)) {
2452 if(entry->signature != URL_SIGNATURE) {
2453 WARN("only url entries are currently supported\n");
2454 continue;
2455 }
2456
2457 url_entry = (entry_url*)entry;
2458 if(url_entry->cache_entry_type & filter)
2459 continue;
2460
2461 rate[rate_no] = urlcache_rate_entry(url_entry, &cur_time);
2462 if(rate[rate_no] != -1)
2463 rate_no++;
2464 }
2465
2466 if(!rate_no) {
2467 TRACE("nothing to delete\n");
2468 cache_container_unlock_index(container, header);
2469 continue;
2470 }
2471
2472 qsort(rate, rate_no, sizeof(DWORD), dword_cmp);
2473
2474 delete_factor = delete_factor*rate_no/100;
2475 delete_factor = rate[delete_factor];
2476 TRACE("deleting files with rating %d or less\n", delete_factor);
2477
2478 hash_table_off = 0;
2479 while(urlcache_next_entry(header, &hash_table_off, &hash_table_entry, &hash_entry, &entry)) {
2480 if(entry->signature != URL_SIGNATURE)
2481 continue;
2482
2483 url_entry = (entry_url*)entry;
2484 if(url_entry->cache_entry_type & filter)
2485 continue;
2486
2487 if(urlcache_rate_entry(url_entry, &cur_time) <= delete_factor) {
2488 TRACE("deleting file: %s\n", debugstr_a((char*)url_entry+url_entry->local_name_off));
2489 urlcache_entry_delete(container, header, hash_entry);
2490
2491 if(header->cache_usage.QuadPart+header->exempt_usage.QuadPart <= desired_size)
2492 break;
2493
2494 /* Allow other threads to use cache while cleaning */
2495 cache_container_unlock_index(container, header);
2496 if(WaitForSingleObject(dll_unload_event, 0) == WAIT_OBJECT_0) {
2497 TRACE("got dll_unload_event - finishing\n");
2498 return TRUE;
2499 }
2500 Sleep(0);
2501 header = cache_container_lock_index(container);
2502 }
2503 }
2504
2505 TRACE("cache size after cleaning 0x%s/0x%s\n",
2506 wine_dbgstr_longlong(header->cache_usage.QuadPart+header->exempt_usage.QuadPart),
2507 wine_dbgstr_longlong(header->cache_limit.QuadPart));
2508 cache_container_unlock_index(container, header);
2509 }
2510
2511 return TRUE;
2512 }
2513
2514 /***********************************************************************
2515 * FreeUrlCacheSpaceA (WININET.@)
2516 *
2517 * See FreeUrlCacheSpaceW.
2518 */
2519 BOOL WINAPI FreeUrlCacheSpaceA(LPCSTR lpszCachePath, DWORD dwSize, DWORD dwFilter)
2520 {
2521 BOOL ret = FALSE;
2522 LPWSTR path = heap_strdupAtoW(lpszCachePath);
2523 if (lpszCachePath == NULL || path != NULL)
2524 ret = FreeUrlCacheSpaceW(path, dwSize, dwFilter);
2525 heap_free(path);
2526 return ret;
2527 }
2528
2529 /***********************************************************************
2530 * UnlockUrlCacheEntryFileA (WININET.@)
2531 *
2532 */
2533 BOOL WINAPI UnlockUrlCacheEntryFileA(LPCSTR lpszUrlName, DWORD dwReserved)
2534 {
2535 urlcache_header *pHeader;
2536 struct hash_entry *pHashEntry;
2537 entry_header *pEntry;
2538 entry_url * pUrlEntry;
2539 cache_container *pContainer;
2540 DWORD error;
2541
2542 TRACE("(%s, 0x%08x)\n", debugstr_a(lpszUrlName), dwReserved);
2543
2544 if (dwReserved)
2545 {
2546 ERR("dwReserved != 0\n");
2547 SetLastError(ERROR_INVALID_PARAMETER);
2548 return FALSE;
2549 }
2550
2551 error = cache_containers_find(lpszUrlName, &pContainer);
2552 if (error != ERROR_SUCCESS)
2553 {
2554 SetLastError(error);
2555 return FALSE;
2556 }
2557
2558 error = cache_container_open_index(pContainer, MIN_BLOCK_NO);
2559 if (error != ERROR_SUCCESS)
2560 {
2561 SetLastError(error);
2562 return FALSE;
2563 }
2564
2565 if (!(pHeader = cache_container_lock_index(pContainer)))
2566 return FALSE;
2567
2568 if (!urlcache_find_hash_entry(pHeader, lpszUrlName, &pHashEntry))
2569 {
2570 cache_container_unlock_index(pContainer, pHeader);
2571 TRACE("entry %s not found!\n", lpszUrlName);
2572 SetLastError(ERROR_FILE_NOT_FOUND);
2573 return FALSE;
2574 }
2575
2576 pEntry = (entry_header*)((LPBYTE)pHeader + pHashEntry->offset);
2577 if (pEntry->signature != URL_SIGNATURE)
2578 {
2579 cache_container_unlock_index(pContainer, pHeader);
2580 FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->signature, sizeof(DWORD)));
2581 SetLastError(ERROR_FILE_NOT_FOUND);
2582 return FALSE;
2583 }
2584
2585 pUrlEntry = (entry_url *)pEntry;
2586
2587 if (pUrlEntry->use_count == 0)
2588 {
2589 cache_container_unlock_index(pContainer, pHeader);
2590 return FALSE;
2591 }
2592 pUrlEntry->use_count--;
2593 if (!pUrlEntry->use_count)
2594 {
2595 urlcache_hash_entry_set_flags(pHashEntry, HASHTABLE_URL);
2596 if (pUrlEntry->cache_entry_type & PENDING_DELETE_CACHE_ENTRY)
2597 urlcache_entry_delete(pContainer, pHeader, pHashEntry);
2598 }
2599
2600 cache_container_unlock_index(pContainer, pHeader);
2601
2602 return TRUE;
2603 }
2604
2605 /***********************************************************************
2606 * UnlockUrlCacheEntryFileW (WININET.@)
2607 *
2608 */
2609 BOOL WINAPI UnlockUrlCacheEntryFileW(LPCWSTR lpszUrlName, DWORD dwReserved)
2610 {
2611 char *url;
2612 BOOL ret;
2613
2614 if(!urlcache_encode_url_alloc(lpszUrlName, &url))
2615 return FALSE;
2616
2617 ret = UnlockUrlCacheEntryFileA(url, dwReserved);
2618 heap_free(url);
2619 return ret;
2620 }
2621
2622 static BOOL urlcache_entry_create(const char *url, const char *ext, WCHAR *full_path)
2623 {
2624 cache_container *container;
2625 urlcache_header *header;
2626 char file_name[MAX_PATH];
2627 WCHAR extW[MAX_PATH];
2628 BYTE cache_dir;
2629 LONG full_path_len;
2630 BOOL generate_name = FALSE;
2631 DWORD error;
2632 HANDLE file;
2633 FILETIME ft;
2634 URL_COMPONENTSA uc;
2635 int i;
2636
2637 TRACE("(%s, %s, %p)\n", debugstr_a(url), debugstr_a(ext), full_path);
2638
2639 memset(&uc, 0, sizeof(uc));
2640 uc.dwStructSize = sizeof(uc);
2641 uc.dwUrlPathLength = 1;
2642 uc.dwExtraInfoLength = 1;
2643 if(!InternetCrackUrlA(url, 0, 0, &uc))
2644 uc.dwUrlPathLength = 0;
2645
2646 if(!uc.dwUrlPathLength) {
2647 file_name[0] = 0;
2648 }else {
2649 char *p, *e;
2650
2651 p = e = uc.lpszUrlPath+uc.dwUrlPathLength;
2652 while(p>uc.lpszUrlPath && *(p-1)!='/' && *(p-1)!='\\' && *(p-1)!='.')
2653 p--;
2654 if(p>uc.lpszUrlPath && *(p-1)=='.') {
2655 e = p-1;
2656 while(p>uc.lpszUrlPath && *(p-1)!='/' && *(p-1)!='\\')
2657 p--;
2658 }
2659
2660 memcpy(file_name, p, e-p);
2661 file_name[e-p] = 0;
2662
2663 for(p=file_name; *p; p++) {
2664 switch(*p) {
2665 case '<': case '>':
2666 case ':': case '"':
2667 case '|': case '?':
2668 case '*':
2669 *p = '_'; break;
2670 default: break;
2671 }
2672 }
2673 }
2674
2675 if(!file_name[0])
2676 generate_name = TRUE;
2677
2678 error = cache_containers_find(url, &container);
2679 if(error != ERROR_SUCCESS) {
2680 SetLastError(error);
2681 return FALSE;
2682 }
2683
2684 error = cache_container_open_index(container, MIN_BLOCK_NO);
2685 if(error != ERROR_SUCCESS) {
2686 SetLastError(error);
2687 return FALSE;
2688 }
2689
2690 if(!(header = cache_container_lock_index(container)))
2691 return FALSE;
2692
2693 if(header->dirs_no)
2694 cache_dir = (BYTE)(rand() % header->dirs_no);
2695 else
2696 cache_dir = CACHE_CONTAINER_NO_SUBDIR;
2697
2698 full_path_len = MAX_PATH * sizeof(WCHAR);
2699 if(!urlcache_create_file_pathW(container, header, file_name, cache_dir, full_path, &full_path_len)) {
2700 WARN("Failed to get full path for filename %s, needed %u bytes.\n",
2701 debugstr_a(file_name), full_path_len);
2702 cache_container_unlock_index(container, header);
2703 return FALSE;
2704 }
2705 full_path_len = full_path_len/sizeof(WCHAR) - 1;
2706
2707 cache_container_unlock_index(container, header);
2708
2709 if(ext) {
2710 WCHAR *p;
2711
2712 extW[0] = '.';
2713 MultiByteToWideChar(CP_ACP, 0, ext, -1, extW+1, MAX_PATH-1);
2714
2715 for(p=extW; *p; p++) {
2716 switch(*p) {
2717 case '<': case '>':
2718 case ':': case '"':
2719 case '|': case '?':
2720 case '*':
2721 *p = '_'; break;
2722 default: break;
2723 }
2724 }
2725 if(p[-1]==' ' || p[-1]=='.')
2726 p[-1] = '_';
2727 }else {
2728 extW[0] = '\0';
2729 }
2730
2731 for(i=0; i<255 && !generate_name; i++) {
2732 static const WCHAR format[] = {'[','%','u',']','%','s',0};
2733
2734 wsprintfW(full_path+full_path_len, format, i, extW);
2735
2736 TRACE("Trying: %s\n", debugstr_w(full_path));
2737 file = CreateFileW(full_path, GENERIC_READ, 0, NULL, CREATE_NEW, 0, NULL);
2738 if(file != INVALID_HANDLE_VALUE) {
2739 CloseHandle(file);
2740 return TRUE;
2741 }
2742 }
2743
2744 /* Try to generate random name */
2745 GetSystemTimeAsFileTime(&ft);
2746 strcpyW(full_path+full_path_len+8, extW);
2747
2748 for(i=0; i<255; i++) {
2749 int j;
2750 ULONGLONG n = ft.dwHighDateTime;
2751 n <<= 32;
2752 n += ft.dwLowDateTime;
2753 n ^= (ULONGLONG)i<<48;
2754
2755 for(j=0; j<8; j++) {
2756 int r = (n % 36);
2757 n /= 37;
2758 full_path[full_path_len+j] = (r < 10 ? '0' + r : 'A' + r - 10);
2759 }
2760
2761 TRACE("Trying: %s\n", debugstr_w(full_path));
2762 file = CreateFileW(full_path, GENERIC_READ, 0, NULL, CREATE_NEW, 0, NULL);
2763 if(file != INVALID_HANDLE_VALUE) {
2764 CloseHandle(file);
2765 return TRUE;
2766 }
2767 }
2768
2769 WARN("Could not find a unique filename\n");
2770 return FALSE;
2771 }
2772
2773 /***********************************************************************
2774 * CreateUrlCacheEntryA (WININET.@)
2775 *
2776 */
2777 BOOL WINAPI CreateUrlCacheEntryA(LPCSTR lpszUrlName, DWORD dwExpectedFileSize,
2778 LPCSTR lpszFileExtension, LPSTR lpszFileName, DWORD dwReserved)
2779 {
2780 WCHAR file_name[MAX_PATH];
2781
2782 if(dwReserved)
2783 FIXME("dwReserved 0x%08x\n", dwReserved);
2784
2785 if(!urlcache_entry_create(lpszUrlName, lpszFileExtension, file_name))
2786 return FALSE;
2787
2788 if(!WideCharToMultiByte(CP_ACP, 0, file_name, -1, lpszFileName, MAX_PATH, NULL, NULL))
2789 return FALSE;
2790 return TRUE;
2791 }
2792 /***********************************************************************
2793 * CreateUrlCacheEntryW (WININET.@)
2794 *
2795 */
2796 BOOL WINAPI CreateUrlCacheEntryW(LPCWSTR lpszUrlName, DWORD dwExpectedFileSize,
2797 LPCWSTR lpszFileExtension, LPWSTR lpszFileName, DWORD dwReserved)
2798 {
2799 char *url, *ext = NULL;
2800 BOOL ret;
2801
2802 if(dwReserved)
2803 FIXME("dwReserved 0x%08x\n", dwReserved);
2804
2805 if(lpszFileExtension) {
2806 ext = heap_strdupWtoUTF8(lpszFileExtension);
2807 if(!ext)
2808 return FALSE;
2809 }
2810
2811 if(!urlcache_encode_url_alloc(lpszUrlName, &url)) {
2812 heap_free(ext);
2813 return FALSE;
2814 }
2815
2816 ret = urlcache_entry_create(url, ext, lpszFileName);
2817 heap_free(ext);
2818 heap_free(url);
2819 return ret;
2820 }
2821
2822 static BOOL urlcache_entry_commit(const char *url, const WCHAR *file_name,
2823 FILETIME expire_time, FILETIME modify_time, DWORD entry_type,
2824 BYTE *header_info, DWORD header_size, const char *file_ext,
2825 const char *original_url)
2826 {
2827 cache_container *container;
2828 urlcache_header *header;
2829 struct hash_entry *hash_entry;
2830 entry_header *entry;
2831 entry_url *url_entry;
2832 DWORD url_entry_offset;
2833 DWORD size = DWORD_ALIGN(sizeof(*url_entry));
2834 DWORD file_name_off = 0;
2835 DWORD header_info_off = 0;
2836 DWORD file_ext_off = 0;
2837 WIN32_FILE_ATTRIBUTE_DATA file_attr;
2838 LARGE_INTEGER file_size;
2839 BYTE dir_id;
2840 char file_name_no_container[MAX_PATH];
2841 char *local_file_name = 0;
2842 DWORD hit_rate = 0;
2843 DWORD exempt_delta = 0;
2844 DWORD error;
2845
2846 TRACE("(%s, %s, ..., ..., %x, %p, %d, %s, %s)\n", debugstr_a(url), debugstr_w(file_name),
2847 entry_type, header_info, header_size, debugstr_a(file_ext), debugstr_a(original_url));
2848
2849 if(entry_type & STICKY_CACHE_ENTRY && !file_name) {
2850 SetLastError(ERROR_INVALID_PARAMETER);
2851 return FALSE;
2852 }
2853 if(original_url)
2854 WARN(": original_url ignored\n");
2855
2856 memset(&file_attr, 0, sizeof(file_attr));
2857 if(file_name) {
2858 if(!GetFileAttributesExW(file_name, GetFileExInfoStandard, &file_attr))
2859 return FALSE;
2860 }
2861 file_size.u.LowPart = file_attr.nFileSizeLow;
2862 file_size.u.HighPart = file_attr.nFileSizeHigh;
2863
2864 error = cache_containers_find(url, &container);
2865 if(error != ERROR_SUCCESS) {
2866 SetLastError(error);
2867 return FALSE;
2868 }
2869
2870 error = cache_container_open_index(container, MIN_BLOCK_NO);
2871 if(error != ERROR_SUCCESS) {
2872 SetLastError(error);
2873 return FALSE;
2874 }
2875
2876 if(!(header = cache_container_lock_index(container)))
2877 return FALSE;
2878
2879 if(urlcache_find_hash_entry(header, url, &hash_entry)) {
2880 entry_url *url_entry = (entry_url*)((LPBYTE)header + hash_entry->offset);
2881
2882 if(urlcache_hash_entry_is_locked(hash_entry, url_entry)) {
2883 TRACE("Trying to overwrite locked entry\n");
2884 cache_container_unlock_index(container, header);
2885 SetLastError(ERROR_SHARING_VIOLATION);
2886 return FALSE;
2887 }
2888
2889 hit_rate = url_entry->hit_rate;
2890 exempt_delta = url_entry->exempt_delta;
2891 urlcache_entry_delete(container, header, hash_entry);
2892 }
2893
2894 if(header->dirs_no)
2895 dir_id = 0;
2896 else
2897 dir_id = CACHE_CONTAINER_NO_SUBDIR;
2898
2899 if(file_name) {
2900 BOOL bFound = FALSE;
2901
2902 if(strncmpW(file_name, container->path, lstrlenW(container->path))) {
2903 ERR("path %s must begin with cache content path %s\n", debugstr_w(file_name), debugstr_w(container->path));
2904 cache_container_unlock_index(container, header);
2905 SetLastError(ERROR_INVALID_PARAMETER);
2906 return FALSE;
2907 }
2908
2909 /* skip container path prefix */
2910 file_name += lstrlenW(container->path);
2911
2912 WideCharToMultiByte(CP_ACP, 0, file_name, -1, file_name_no_container, MAX_PATH, NULL, NULL);
2913 local_file_name = file_name_no_container;
2914
2915 if(header->dirs_no) {
2916 for(dir_id = 0; dir_id < header->dirs_no; dir_id++) {
2917 if(!strncmp(header->directory_data[dir_id].name, local_file_name, DIR_LENGTH)) {
2918 bFound = TRUE;
2919 break;
2920 }
2921 }
2922
2923 if(!bFound) {
2924 ERR("cache directory not found in path %s\n", debugstr_w(file_name));
2925 cache_container_unlock_index(container, header);
2926 SetLastError(ERROR_INVALID_PARAMETER);
2927 return FALSE;
2928 }
2929
2930 file_name += DIR_LENGTH + 1;
2931 local_file_name += DIR_LENGTH + 1;
2932 }
2933 }
2934
2935 size = DWORD_ALIGN(size + strlen(url) + 1);
2936 if(file_name) {
2937 file_name_off = size;
2938 size = DWORD_ALIGN(size + strlen(local_file_name) + 1);
2939 }
2940 if(header_info && header_size) {
2941 header_info_off = size;
2942 size = DWORD_ALIGN(size + header_size);
2943 }
2944 if(file_ext && (file_ext_off = strlen(file_ext))) {
2945 DWORD len = file_ext_off;
2946
2947 file_ext_off = size;
2948 size = DWORD_ALIGN(size + len + 1);
2949 }
2950
2951 /* round up to next block */
2952 if(size % BLOCKSIZE) {
2953 size -= size % BLOCKSIZE;
2954 size += BLOCKSIZE;
2955 }
2956
2957 error = urlcache_entry_alloc(header, size / BLOCKSIZE, &entry);
2958 while(error == ERROR_HANDLE_DISK_FULL) {
2959 error = cache_container_clean_index(container, &header);
2960 if(error == ERROR_SUCCESS)
2961 error = urlcache_entry_alloc(header, size / BLOCKSIZE, &entry);
2962 }
2963 if(error != ERROR_SUCCESS) {
2964 cache_container_unlock_index(container, header);
2965 SetLastError(error);
2966 return FALSE;
2967 }
2968
2969 /* FindFirstFreeEntry fills in blocks used */
2970 url_entry = (entry_url *)entry;
2971 url_entry_offset = (LPBYTE)url_entry - (LPBYTE)header;
2972 url_entry->header.signature = URL_SIGNATURE;
2973 url_entry->cache_dir = dir_id;
2974 url_entry->cache_entry_type = entry_type | container->default_entry_type;
2975 url_entry->header_info_size = header_size;
2976 if((entry_type & STICKY_CACHE_ENTRY) && !exempt_delta) {
2977 /* Sticky entries have a default exempt time of one day */
2978 exempt_delta = 86400;
2979 }
2980 url_entry->exempt_delta = exempt_delta;
2981 url_entry->hit_rate = hit_rate+1;
2982 url_entry->file_extension_off = file_ext_off;
2983 url_entry->header_info_off = header_info_off;
2984 url_entry->local_name_off = file_name_off;
2985 url_entry->url_off = DWORD_ALIGN(sizeof(*url_entry));
2986 url_entry->size.QuadPart = file_size.QuadPart;
2987 url_entry->use_count = 0;
2988 GetSystemTimeAsFileTime(&url_entry->access_time);
2989 url_entry->modification_time = modify_time;
2990 file_time_to_dos_date_time(&url_entry->access_time, &url_entry->sync_date, &url_entry->sync_time);
2991 file_time_to_dos_date_time(&expire_time, &url_entry->expire_date, &url_entry->expire_time);
2992 file_time_to_dos_date_time(&file_attr.ftLastWriteTime, &url_entry->write_date, &url_entry->write_time);
2993
2994 /*** Unknowns ***/
2995 url_entry->unk1 = 0;
2996 url_entry->unk2 = 0;
2997 url_entry->unk3 = 0x60;
2998 url_entry->unk4 = 0;
2999 url_entry->unk5 = 0x1010;
3000 url_entry->unk7 = 0;
3001 url_entry->unk8 = 0;
3002
3003
3004 strcpy((LPSTR)url_entry + url_entry->url_off, url);
3005 if(file_name_off)
3006 strcpy((LPSTR)((LPBYTE)url_entry + file_name_off), local_file_name);
3007 if(header_info_off)
3008 memcpy((LPBYTE)url_entry + header_info_off, header_info, header_size);
3009 if(file_ext_off)
3010 strcpy((LPSTR)((LPBYTE)url_entry + file_ext_off), file_ext);
3011
3012 error = urlcache_hash_entry_create(header, url, url_entry_offset, HASHTABLE_URL);
3013 while(error == ERROR_HANDLE_DISK_FULL) {
3014 error = cache_container_clean_index(container, &header);
3015 if(error == ERROR_SUCCESS) {
3016 url_entry = (entry_url *)((LPBYTE)header + url_entry_offset);
3017 error = urlcache_hash_entry_create(header, url,
3018 url_entry_offset, HASHTABLE_URL);
3019 }
3020 }
3021 if(error != ERROR_SUCCESS) {
3022 urlcache_entry_free(header, &url_entry->header);
3023 cache_container_unlock_index(container, header);
3024 SetLastError(error);
3025 return FALSE;
3026 }
3027
3028 if(url_entry->cache_dir < header->dirs_no)
3029 header->directory_data[url_entry->cache_dir].files_no++;
3030 if(entry_type & STICKY_CACHE_ENTRY)
3031 header->exempt_usage.QuadPart += file_size.QuadPart;
3032 else
3033 header->cache_usage.QuadPart += file_size.QuadPart;
3034 if(header->cache_usage.QuadPart+header->exempt_usage.QuadPart > header->cache_limit.QuadPart)
3035 handle_full_cache();
3036
3037 cache_container_unlock_index(container, header);
3038 return TRUE;
3039 }
3040
3041 /***********************************************************************
3042 * CommitUrlCacheEntryA (WININET.@)
3043 */
3044 BOOL WINAPI CommitUrlCacheEntryA(LPCSTR lpszUrlName, LPCSTR lpszLocalFileName,
3045 FILETIME ExpireTime, FILETIME LastModifiedTime, DWORD CacheEntryType,
3046 LPBYTE lpHeaderInfo, DWORD dwHeaderSize, LPCSTR lpszFileExtension, LPCSTR lpszOriginalUrl)
3047 {
3048 WCHAR *file_name = NULL;
3049 BOOL ret;
3050
3051 if(lpszLocalFileName) {
3052 file_name = heap_strdupAtoW(lpszLocalFileName);
3053 if(!file_name)
3054 return FALSE;
3055 }
3056
3057 ret = urlcache_entry_commit(lpszUrlName, file_name, ExpireTime, LastModifiedTime,
3058 CacheEntryType, lpHeaderInfo, dwHeaderSize, lpszFileExtension, lpszOriginalUrl);
3059 heap_free(file_name);
3060 return ret;
3061 }
3062
3063 /***********************************************************************
3064 * CommitUrlCacheEntryW (WININET.@)
3065 */
3066 BOOL WINAPI CommitUrlCacheEntryW(LPCWSTR lpszUrlName, LPCWSTR lpszLocalFileName,
3067 FILETIME ExpireTime, FILETIME LastModifiedTime, DWORD CacheEntryType,
3068 LPWSTR lpHeaderInfo, DWORD dwHeaderSize, LPCWSTR lpszFileExtension, LPCWSTR lpszOriginalUrl)
3069 {
3070 char *url, *original_url=NULL, *file_ext=NULL, *header_info=NULL;
3071 BOOL ret;
3072
3073 if(!urlcache_encode_url_alloc(lpszUrlName, &url))
3074 return FALSE;
3075
3076 if(lpHeaderInfo) {
3077 header_info = heap_strdupWtoUTF8(lpHeaderInfo);
3078 if(!header_info) {
3079 heap_free(url);
3080 return FALSE;
3081 }
3082 dwHeaderSize = strlen(header_info);
3083 }
3084
3085 if(lpszFileExtension) {
3086 file_ext = heap_strdupWtoA(lpszFileExtension);
3087 if(!file_ext) {
3088 heap_free(url);
3089 heap_free(header_info);
3090 return FALSE;
3091 }
3092 }
3093
3094 if(lpszOriginalUrl && !urlcache_encode_url_alloc(lpszOriginalUrl, &original_url)) {
3095 heap_free(url);
3096 heap_free(header_info);
3097 heap_free(file_ext);
3098 return FALSE;
3099 }
3100
3101 ret = urlcache_entry_commit(url, lpszLocalFileName, ExpireTime, LastModifiedTime,
3102 CacheEntryType, (BYTE*)header_info, dwHeaderSize, file_ext, original_url);
3103 heap_free(url);
3104 heap_free(header_info);
3105 heap_free(file_ext);
3106 heap_free(original_url);
3107 return ret;
3108 }
3109
3110 /***********************************************************************
3111 * ReadUrlCacheEntryStream (WININET.@)
3112 *
3113 */
3114 BOOL WINAPI ReadUrlCacheEntryStream(
3115 IN HANDLE hUrlCacheStream,
3116 IN DWORD dwLocation,
3117 IN OUT LPVOID lpBuffer,
3118 IN OUT LPDWORD lpdwLen,
3119 IN DWORD dwReserved
3120 )
3121 {
3122 /* Get handle to file from 'stream' */
3123 stream_handle *pStream = (stream_handle*)hUrlCacheStream;
3124
3125 if (dwReserved != 0)
3126 {
3127 ERR("dwReserved != 0\n");
3128 SetLastError(ERROR_INVALID_PARAMETER);
3129 return FALSE;
3130 }
3131
3132 if (IsBadReadPtr(pStream, sizeof(*pStream)) || IsBadStringPtrA(pStream->url, INTERNET_MAX_URL_LENGTH))
3133 {
3134 SetLastError(ERROR_INVALID_HANDLE);
3135 return FALSE;
3136 }
3137
3138 if (SetFilePointer(pStream->file, dwLocation, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
3139 return FALSE;
3140 return ReadFile(pStream->file, lpBuffer, *lpdwLen, lpdwLen, NULL);
3141 }
3142
3143 /***********************************************************************
3144 * RetrieveUrlCacheEntryStreamA (WININET.@)
3145 *
3146 */
3147 HANDLE WINAPI RetrieveUrlCacheEntryStreamA(LPCSTR lpszUrlName,
3148 LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
3149 LPDWORD lpdwCacheEntryInfoBufferSize, BOOL fRandomRead, DWORD dwReserved)
3150 {
3151 /* NOTE: this is not the same as the way that the native
3152 * version allocates 'stream' handles. I did it this way
3153 * as it is much easier and no applications should depend
3154 * on this behaviour. (Native version appears to allocate
3155 * indices into a table)
3156 */
3157 stream_handle *stream;
3158 HANDLE file;
3159
3160 TRACE("(%s, %p, %p, %x, 0x%08x)\n", debugstr_a(lpszUrlName), lpCacheEntryInfo,
3161 lpdwCacheEntryInfoBufferSize, fRandomRead, dwReserved);
3162
3163 if(!RetrieveUrlCacheEntryFileA(lpszUrlName, lpCacheEntryInfo,
3164 lpdwCacheEntryInfoBufferSize, dwReserved))
3165 return NULL;
3166
3167 file = CreateFileA(lpCacheEntryInfo->lpszLocalFileName, GENERIC_READ, FILE_SHARE_READ,
3168 NULL, OPEN_EXISTING, fRandomRead ? FILE_FLAG_RANDOM_ACCESS : 0, NULL);
3169 if(file == INVALID_HANDLE_VALUE) {
3170 UnlockUrlCacheEntryFileA(lpszUrlName, 0);
3171 return NULL;
3172 }
3173
3174 /* allocate handle storage space */
3175 stream = heap_alloc(sizeof(stream_handle) + strlen(lpszUrlName) * sizeof(CHAR));
3176 if(!stream) {
3177 CloseHandle(file);
3178 UnlockUrlCacheEntryFileA(lpszUrlName, 0);
3179 SetLastError(ERROR_OUTOFMEMORY);
3180 return NULL;
3181 }
3182
3183 stream->file = file;
3184 strcpy(stream->url, lpszUrlName);
3185 return stream;
3186 }
3187
3188 /***********************************************************************
3189 * RetrieveUrlCacheEntryStreamW (WININET.@)
3190 *
3191 */
3192 HANDLE WINAPI RetrieveUrlCacheEntryStreamW(LPCWSTR lpszUrlName,
3193 LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
3194 LPDWORD lpdwCacheEntryInfoBufferSize, BOOL fRandomRead, DWORD dwReserved)
3195 {
3196 DWORD len;
3197 /* NOTE: this is not the same as the way that the native
3198 * version allocates 'stream' handles. I did it this way
3199 * as it is much easier and no applications should depend
3200 * on this behaviour. (Native version appears to allocate
3201 * indices into a table)
3202 */
3203 stream_handle *stream;
3204 HANDLE file;
3205
3206 TRACE("(%s, %p, %p, %x, 0x%08x)\n", debugstr_w(lpszUrlName), lpCacheEntryInfo,
3207 lpdwCacheEntryInfoBufferSize, fRandomRead, dwReserved);
3208
3209 if(!(len = urlcache_encode_url(lpszUrlName, NULL, 0)))
3210 return NULL;
3211
3212 if(!RetrieveUrlCacheEntryFileW(lpszUrlName, lpCacheEntryInfo,
3213 lpdwCacheEntryInfoBufferSize, dwReserved))
3214 return NULL;
3215
3216 file = CreateFileW(lpCacheEntryInfo->lpszLocalFileName, GENERIC_READ, FILE_SHARE_READ,
3217 NULL, OPEN_EXISTING, fRandomRead ? FILE_FLAG_RANDOM_ACCESS : 0, NULL);
3218 if(file == INVALID_HANDLE_VALUE) {
3219 UnlockUrlCacheEntryFileW(lpszUrlName, 0);
3220 return NULL;
3221 }
3222
3223 /* allocate handle storage space */
3224 stream = heap_alloc(sizeof(stream_handle) + len*sizeof(WCHAR));
3225 if(!stream) {
3226 CloseHandle(file);
3227 UnlockUrlCacheEntryFileW(lpszUrlName, 0);
3228 SetLastError(ERROR_OUTOFMEMORY);
3229 return NULL;
3230 }
3231
3232 stream->file = file;
3233 if(!urlcache_encode_url(lpszUrlName, stream->url, len)) {
3234 CloseHandle(file);
3235 UnlockUrlCacheEntryFileW(lpszUrlName, 0);
3236 heap_free(stream);
3237 return NULL;
3238 }
3239 return stream;
3240 }
3241
3242 /***********************************************************************
3243 * UnlockUrlCacheEntryStream (WININET.@)
3244 *
3245 */
3246 BOOL WINAPI UnlockUrlCacheEntryStream(
3247 IN HANDLE hUrlCacheStream,
3248 IN DWORD dwReserved
3249 )
3250 {
3251 stream_handle *pStream = (stream_handle*)hUrlCacheStream;
3252
3253 if (dwReserved != 0)
3254 {
3255 ERR("dwReserved != 0\n");
3256 SetLastError(ERROR_INVALID_PARAMETER);
3257 return FALSE;
3258 }
3259
3260 if (IsBadReadPtr(pStream, sizeof(*pStream)) || IsBadStringPtrA(pStream->url, INTERNET_MAX_URL_LENGTH))
3261 {
3262 SetLastError(ERROR_INVALID_HANDLE);
3263 return FALSE;
3264 }
3265
3266 if (!UnlockUrlCacheEntryFileA(pStream->url, 0))
3267 return FALSE;
3268
3269 CloseHandle(pStream->file);
3270 heap_free(pStream);
3271 return TRUE;
3272 }
3273
3274
3275 /***********************************************************************
3276 * DeleteUrlCacheEntryA (WININET.@)
3277 *
3278 */
3279 BOOL WINAPI DeleteUrlCacheEntryA(LPCSTR lpszUrlName)
3280 {
3281 cache_container *pContainer;
3282 urlcache_header *pHeader;
3283 struct hash_entry *pHashEntry;
3284 DWORD error;
3285 BOOL ret;
3286
3287 TRACE("(%s)\n", debugstr_a(lpszUrlName));
3288
3289 error = cache_containers_find(lpszUrlName, &pContainer);
3290 if (error != ERROR_SUCCESS)
3291 {
3292 SetLastError(error);
3293 return FALSE;
3294 }
3295
3296 error = cache_container_open_index(pContainer, MIN_BLOCK_NO);
3297 if (error != ERROR_SUCCESS)
3298 {
3299 SetLastError(error);
3300 return FALSE;
3301 }
3302
3303 if (!(pHeader = cache_container_lock_index(pContainer)))
3304 return FALSE;
3305
3306 if (!urlcache_find_hash_entry(pHeader, lpszUrlName, &pHashEntry))
3307 {
3308 cache_container_unlock_index(pContainer, pHeader);
3309 TRACE("entry %s not found!\n", lpszUrlName);
3310 SetLastError(ERROR_FILE_NOT_FOUND);
3311 return FALSE;
3312 }
3313
3314 ret = urlcache_entry_delete(pContainer, pHeader, pHashEntry);
3315
3316 cache_container_unlock_index(pContainer, pHeader);
3317
3318 return ret;
3319 }
3320
3321 /***********************************************************************
3322 * DeleteUrlCacheEntryW (WININET.@)
3323 *
3324 */
3325 BOOL WINAPI DeleteUrlCacheEntryW(LPCWSTR lpszUrlName)
3326 {
3327 char *url;
3328 BOOL ret;
3329
3330 if(!urlcache_encode_url_alloc(lpszUrlName, &url))
3331 return FALSE;
3332
3333 ret = DeleteUrlCacheEntryA(url);
3334 heap_free(url);
3335 return ret;
3336 }
3337
3338 BOOL WINAPI DeleteUrlCacheContainerA(DWORD d1, DWORD d2)
3339 {
3340 FIXME("(0x%08x, 0x%08x) stub\n", d1, d2);
3341 return TRUE;
3342 }
3343
3344 BOOL WINAPI DeleteUrlCacheContainerW(DWORD d1, DWORD d2)
3345 {
3346 FIXME("(0x%08x, 0x%08x) stub\n", d1, d2);
3347 return TRUE;
3348 }
3349
3350 /***********************************************************************
3351 * CreateCacheContainerA (WININET.@)
3352 */
3353 BOOL WINAPI CreateUrlCacheContainerA(DWORD d1, DWORD d2, DWORD d3, DWORD d4,
3354 DWORD d5, DWORD d6, DWORD d7, DWORD d8)
3355 {
3356 FIXME("(0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x) stub\n",
3357 d1, d2, d3, d4, d5, d6, d7, d8);
3358 return TRUE;
3359 }
3360
3361 /***********************************************************************
3362 * CreateCacheContainerW (WININET.@)
3363 */
3364 BOOL WINAPI CreateUrlCacheContainerW(DWORD d1, DWORD d2, DWORD d3, DWORD d4,
3365 DWORD d5, DWORD d6, DWORD d7, DWORD d8)
3366 {
3367 FIXME("(0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x) stub\n",
3368 d1, d2, d3, d4, d5, d6, d7, d8);
3369 return TRUE;
3370 }
3371
3372 /***********************************************************************
3373 * FindFirstUrlCacheContainerA (WININET.@)
3374 */
3375 HANDLE WINAPI FindFirstUrlCacheContainerA( LPVOID p1, LPVOID p2, LPVOID p3, DWORD d1 )
3376 {
3377 FIXME("(%p, %p, %p, 0x%08x) stub\n", p1, p2, p3, d1 );
3378 return NULL;
3379 }
3380
3381 /***********************************************************************
3382 * FindFirstUrlCacheContainerW (WININET.@)
3383 */
3384 HANDLE WINAPI FindFirstUrlCacheContainerW( LPVOID p1, LPVOID p2, LPVOID p3, DWORD d1 )
3385 {
3386 FIXME("(%p, %p, %p, 0x%08x) stub\n", p1, p2, p3, d1 );
3387 return NULL;
3388 }
3389
3390 /***********************************************************************
3391 * FindNextUrlCacheContainerA (WININET.@)
3392 */
3393 BOOL WINAPI FindNextUrlCacheContainerA( HANDLE handle, LPVOID p1, LPVOID p2 )
3394 {
3395 FIXME("(%p, %p, %p) stub\n", handle, p1, p2 );
3396 return FALSE;
3397 }
3398
3399 /***********************************************************************
3400 * FindNextUrlCacheContainerW (WININET.@)
3401 */
3402 BOOL WINAPI FindNextUrlCacheContainerW( HANDLE handle, LPVOID p1, LPVOID p2 )
3403 {
3404 FIXME("(%p, %p, %p) stub\n", handle, p1, p2 );
3405 return FALSE;
3406 }
3407
3408 HANDLE WINAPI FindFirstUrlCacheEntryExA(
3409 LPCSTR lpszUrlSearchPattern,
3410 DWORD dwFlags,
3411 DWORD dwFilter,
3412 GROUPID GroupId,
3413 LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo,
3414 LPDWORD lpdwFirstCacheEntryInfoBufferSize,
3415 LPVOID lpReserved,
3416 LPDWORD pcbReserved2,
3417 LPVOID lpReserved3
3418 )
3419 {
3420 FIXME("(%s, 0x%08x, 0x%08x, 0x%08x%08x, %p, %p, %p, %p, %p) stub\n", debugstr_a(lpszUrlSearchPattern),
3421 dwFlags, dwFilter, (ULONG)(GroupId >> 32), (ULONG)GroupId, lpFirstCacheEntryInfo,
3422 lpdwFirstCacheEntryInfoBufferSize, lpReserved, pcbReserved2,lpReserved3);
3423 SetLastError(ERROR_FILE_NOT_FOUND);
3424 return NULL;
3425 }
3426
3427 HANDLE WINAPI FindFirstUrlCacheEntryExW(
3428 LPCWSTR lpszUrlSearchPattern,
3429 DWORD dwFlags,
3430 DWORD dwFilter,
3431 GROUPID GroupId,
3432 LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo,
3433 LPDWORD lpdwFirstCacheEntryInfoBufferSize,
3434 LPVOID lpReserved,
3435 LPDWORD pcbReserved2,
3436 LPVOID lpReserved3
3437 )
3438 {
3439 FIXME("(%s, 0x%08x, 0x%08x, 0x%08x%08x, %p, %p, %p, %p, %p) stub\n", debugstr_w(lpszUrlSearchPattern),
3440 dwFlags, dwFilter, (ULONG)(GroupId >> 32), (ULONG)GroupId, lpFirstCacheEntryInfo,
3441 lpdwFirstCacheEntryInfoBufferSize, lpReserved, pcbReserved2,lpReserved3);
3442 SetLastError(ERROR_FILE_NOT_FOUND);
3443 return NULL;
3444 }
3445
3446 /***********************************************************************
3447 * FindFirstUrlCacheEntryA (WININET.@)
3448 *
3449 */
3450 INTERNETAPI HANDLE WINAPI FindFirstUrlCacheEntryA(LPCSTR lpszUrlSearchPattern,
3451 LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize)
3452 {
3453 find_handle *pEntryHandle;
3454
3455 TRACE("(%s, %p, %p)\n", debugstr_a(lpszUrlSearchPattern), lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize);
3456
3457 pEntryHandle = heap_alloc(sizeof(*pEntryHandle));
3458 if (!pEntryHandle)
3459 return NULL;
3460
3461 pEntryHandle->magic = URLCACHE_FIND_ENTRY_HANDLE_MAGIC;
3462 if (lpszUrlSearchPattern)
3463 {
3464 pEntryHandle->url_search_pattern = heap_strdupA(lpszUrlSearchPattern);
3465 if (!pEntryHandle->url_search_pattern)
3466 {
3467 heap_free(pEntryHandle);
3468 return NULL;
3469 }
3470 }
3471 else
3472 pEntryHandle->url_search_pattern = NULL;
3473 pEntryHandle->container_idx = 0;
3474 pEntryHandle->hash_table_idx = 0;
3475 pEntryHandle->hash_entry_idx = 0;
3476
3477 if (!FindNextUrlCacheEntryA(pEntryHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize))
3478 {
3479 heap_free(pEntryHandle);
3480 return NULL;
3481 }
3482 return pEntryHandle;
3483 }
3484
3485 /***********************************************************************
3486 * FindFirstUrlCacheEntryW (WININET.@)
3487 *
3488 */
3489 INTERNETAPI HANDLE WINAPI FindFirstUrlCacheEntryW(LPCWSTR lpszUrlSearchPattern,
3490 LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize)
3491 {
3492 find_handle *pEntryHandle;
3493
3494 TRACE("(%s, %p, %p)\n", debugstr_w(lpszUrlSearchPattern), lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize);
3495
3496 pEntryHandle = heap_alloc(sizeof(*pEntryHandle));
3497 if (!pEntryHandle)
3498 return NULL;
3499
3500 pEntryHandle->magic = URLCACHE_FIND_ENTRY_HANDLE_MAGIC;
3501 if (lpszUrlSearchPattern)
3502 {
3503 pEntryHandle->url_search_pattern = heap_strdupWtoA(lpszUrlSearchPattern);
3504 if (!pEntryHandle->url_search_pattern)
3505 {
3506 heap_free(pEntryHandle);
3507 return NULL;
3508 }
3509 }
3510 else
3511 pEntryHandle->url_search_pattern = NULL;
3512 pEntryHandle->container_idx = 0;
3513 pEntryHandle->hash_table_idx = 0;
3514 pEntryHandle->hash_entry_idx = 0;
3515
3516 if (!FindNextUrlCacheEntryW(pEntryHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize))
3517 {
3518 heap_free(pEntryHandle);
3519 return NULL;
3520 }
3521 return pEntryHandle;
3522 }
3523
3524 static BOOL urlcache_find_next_entry(
3525 HANDLE hEnumHandle,
3526 LPINTERNET_CACHE_ENTRY_INFOA lpNextCacheEntryInfo,
3527 LPDWORD lpdwNextCacheEntryInfoBufferSize,
3528 BOOL unicode)
3529 {
3530 find_handle *pEntryHandle = (find_handle*)hEnumHandle;
3531 cache_container *pContainer;
3532
3533 if (pEntryHandle->magic != URLCACHE_FIND_ENTRY_HANDLE_MAGIC)
3534 {
3535 SetLastError(ERROR_INVALID_HANDLE);
3536 return FALSE;
3537 }
3538
3539 for (; cache_containers_enum(pEntryHandle->url_search_pattern, pEntryHandle->container_idx, &pContainer);
3540 pEntryHandle->container_idx++, pEntryHandle->hash_table_idx = 0)
3541 {
3542 urlcache_header *pHeader;
3543 entry_hash_table *pHashTableEntry;
3544 DWORD error;
3545
3546 error = cache_container_open_index(pContainer, MIN_BLOCK_NO);
3547 if (error != ERROR_SUCCESS)
3548 {
3549 SetLastError(error);
3550 return FALSE;
3551 }
3552
3553 if (!(pHeader = cache_container_lock_index(pContainer)))
3554 return FALSE;
3555
3556 for (; urlcache_enum_hash_tables(pHeader, &pEntryHandle->hash_table_idx, &pHashTableEntry);
3557 pEntryHandle->hash_table_idx++, pEntryHandle->hash_entry_idx = 0)
3558 {
3559 const struct hash_entry *pHashEntry = NULL;
3560 for (; urlcache_enum_hash_table_entries(pHeader, pHashTableEntry, &pEntryHandle->hash_entry_idx, &pHashEntry);
3561 pEntryHandle->hash_entry_idx++)
3562 {
3563 const entry_url *pUrlEntry;
3564 const entry_header *pEntry = (const entry_header*)((LPBYTE)pHeader + pHashEntry->offset);
3565
3566 if (pEntry->signature != URL_SIGNATURE)
3567 continue;
3568
3569 pUrlEntry = (const entry_url *)pEntry;
3570 TRACE("Found URL: %s\n",
3571 debugstr_a((LPCSTR)pUrlEntry + pUrlEntry->url_off));
3572 TRACE("Header info: %s\n",
3573 debugstr_an((LPCSTR)pUrlEntry + pUrlEntry->header_info_off,
3574 pUrlEntry->header_info_size));
3575
3576 error = urlcache_copy_entry(
3577 pContainer,
3578 pHeader,
3579 lpNextCacheEntryInfo,
3580 lpdwNextCacheEntryInfoBufferSize,
3581 pUrlEntry,
3582 unicode);
3583 if (error != ERROR_SUCCESS)
3584 {
3585 cache_container_unlock_index(pContainer, pHeader);
3586 SetLastError(error);
3587 return FALSE;
3588 }
3589 if(pUrlEntry->local_name_off)
3590 TRACE("Local File Name: %s\n", debugstr_a((LPCSTR)pUrlEntry + pUrlEntry->local_name_off));
3591
3592 /* increment the current index so that next time the function
3593 * is called the next entry is returned */
3594 pEntryHandle->hash_entry_idx++;
3595 cache_container_unlock_index(pContainer, pHeader);
3596 return TRUE;
3597 }
3598 }
3599
3600 cache_container_unlock_index(pContainer, pHeader);
3601 }
3602
3603 SetLastError(ERROR_NO_MORE_ITEMS);
3604 return FALSE;
3605 }
3606
3607 /***********************************************************************
3608 * FindNextUrlCacheEntryA (WININET.@)
3609 */
3610 BOOL WINAPI FindNextUrlCacheEntryA(
3611 HANDLE hEnumHandle,
3612 LPINTERNET_CACHE_ENTRY_INFOA lpNextCacheEntryInfo,
3613 LPDWORD lpdwNextCacheEntryInfoBufferSize)
3614 {
3615 TRACE("(%p, %p, %p)\n", hEnumHandle, lpNextCacheEntryInfo, lpdwNextCacheEntryInfoBufferSize);
3616
3617 return urlcache_find_next_entry(hEnumHandle, lpNextCacheEntryInfo,
3618 lpdwNextCacheEntryInfoBufferSize, FALSE /* not UNICODE */);
3619 }
3620
3621 /***********************************************************************
3622 * FindNextUrlCacheEntryW (WININET.@)
3623 */
3624 BOOL WINAPI FindNextUrlCacheEntryW(
3625 HANDLE hEnumHandle,
3626 LPINTERNET_CACHE_ENTRY_INFOW lpNextCacheEntryInfo,
3627 LPDWORD lpdwNextCacheEntryInfoBufferSize
3628 )
3629 {
3630 TRACE("(%p, %p, %p)\n", hEnumHandle, lpNextCacheEntryInfo, lpdwNextCacheEntryInfoBufferSize);
3631
3632 return urlcache_find_next_entry(hEnumHandle,
3633 (LPINTERNET_CACHE_ENTRY_INFOA)lpNextCacheEntryInfo,
3634 lpdwNextCacheEntryInfoBufferSize, TRUE /* UNICODE */);
3635 }
3636
3637 /***********************************************************************
3638 * FindCloseUrlCache (WININET.@)
3639 */
3640 BOOL WINAPI FindCloseUrlCache(HANDLE hEnumHandle)
3641 {
3642 find_handle *pEntryHandle = (find_handle*)hEnumHandle;
3643
3644 TRACE("(%p)\n", hEnumHandle);
3645
3646 if (!pEntryHandle || pEntryHandle->magic != URLCACHE_FIND_ENTRY_HANDLE_MAGIC)
3647 {
3648 SetLastError(ERROR_INVALID_HANDLE);
3649 return FALSE;
3650 }
3651
3652 pEntryHandle->magic = 0;
3653 heap_free(pEntryHandle->url_search_pattern);
3654 heap_free(pEntryHandle);
3655 return TRUE;
3656 }
3657
3658 HANDLE WINAPI FindFirstUrlCacheGroup( DWORD dwFlags, DWORD dwFilter, LPVOID lpSearchCondition,
3659 DWORD dwSearchCondition, GROUPID* lpGroupId, LPVOID lpReserved )
3660 {
3661 FIXME("(0x%08x, 0x%08x, %p, 0x%08x, %p, %p) stub\n", dwFlags, dwFilter, lpSearchCondition,
3662 dwSearchCondition, lpGroupId, lpReserved);
3663 return NULL;
3664 }
3665
3666 BOOL WINAPI FindNextUrlCacheEntryExA(
3667 HANDLE hEnumHandle,
3668 LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo,
3669 LPDWORD lpdwFirstCacheEntryInfoBufferSize,
3670 LPVOID lpReserved,
3671 LPDWORD pcbReserved2,
3672 LPVOID lpReserved3
3673 )
3674 {
3675 FIXME("(%p, %p, %p, %p, %p, %p) stub\n", hEnumHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize,
3676 lpReserved, pcbReserved2, lpReserved3);
3677 return FALSE;
3678 }
3679
3680 BOOL WINAPI FindNextUrlCacheEntryExW(
3681 HANDLE hEnumHandle,
3682 LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo,
3683 LPDWORD lpdwFirstCacheEntryInfoBufferSize,
3684 LPVOID lpReserved,
3685 LPDWORD pcbReserved2,
3686 LPVOID lpReserved3
3687 )
3688 {
3689 FIXME("(%p, %p, %p, %p, %p, %p) stub\n", hEnumHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize,
3690 lpReserved, pcbReserved2, lpReserved3);
3691 return FALSE;
3692 }
3693
3694 BOOL WINAPI FindNextUrlCacheGroup( HANDLE hFind, GROUPID* lpGroupId, LPVOID lpReserved )
3695 {
3696 FIXME("(%p, %p, %p) stub\n", hFind, lpGroupId, lpReserved);
3697 return FALSE;
3698 }
3699
3700 /***********************************************************************
3701 * CreateUrlCacheGroup (WININET.@)
3702 *
3703 */
3704 INTERNETAPI GROUPID WINAPI CreateUrlCacheGroup(DWORD dwFlags, LPVOID lpReserved)
3705 {
3706 FIXME("(0x%08x, %p): stub\n", dwFlags, lpReserved);
3707 return FALSE;
3708 }
3709
3710 /***********************************************************************
3711 * DeleteUrlCacheGroup (WININET.@)
3712 *
3713 */
3714 BOOL WINAPI DeleteUrlCacheGroup(GROUPID GroupId, DWORD dwFlags, LPVOID lpReserved)
3715 {
3716 FIXME("(0x%08x%08x, 0x%08x, %p) stub\n",
3717 (ULONG)(GroupId >> 32), (ULONG)GroupId, dwFlags, lpReserved);
3718 return FALSE;
3719 }
3720
3721 /***********************************************************************
3722 * DeleteWpadCacheForNetworks (WININET.@)
3723 * Undocumented, added in IE8
3724 */
3725 BOOL WINAPI DeleteWpadCacheForNetworks(DWORD unk1)
3726 {
3727 FIXME("(%d) stub\n", unk1);
3728 return FALSE;
3729 }
3730
3731 /***********************************************************************
3732 * SetUrlCacheEntryGroupA (WININET.@)
3733 *
3734 */
3735 BOOL WINAPI SetUrlCacheEntryGroupA(LPCSTR lpszUrlName, DWORD dwFlags,
3736 GROUPID GroupId, LPBYTE pbGroupAttributes, DWORD cbGroupAttributes,
3737 LPVOID lpReserved)
3738 {
3739 FIXME("(%s, 0x%08x, 0x%08x%08x, %p, 0x%08x, %p) stub\n",
3740 debugstr_a(lpszUrlName), dwFlags, (ULONG)(GroupId >> 32), (ULONG)GroupId,
3741 pbGroupAttributes, cbGroupAttributes, lpReserved);
3742 SetLastError(ERROR_FILE_NOT_FOUND);
3743 return FALSE;
3744 }
3745
3746 /***********************************************************************
3747 * SetUrlCacheEntryGroupW (WININET.@)
3748 *
3749 */
3750 BOOL WINAPI SetUrlCacheEntryGroupW(LPCWSTR lpszUrlName, DWORD dwFlags,
3751 GROUPID GroupId, LPBYTE pbGroupAttributes, DWORD cbGroupAttributes,
3752 LPVOID lpReserved)
3753 {
3754 FIXME("(%s, 0x%08x, 0x%08x%08x, %p, 0x%08x, %p) stub\n",
3755 debugstr_w(lpszUrlName), dwFlags, (ULONG)(GroupId >> 32), (ULONG)GroupId,
3756 pbGroupAttributes, cbGroupAttributes, lpReserved);
3757 SetLastError(ERROR_FILE_NOT_FOUND);
3758 return FALSE;
3759 }
3760
3761 /***********************************************************************
3762 * GetUrlCacheConfigInfoW (WININET.@)
3763 */
3764 BOOL WINAPI GetUrlCacheConfigInfoW(LPINTERNET_CACHE_CONFIG_INFOW CacheInfo, LPDWORD size, DWORD bitmask)
3765 {
3766 FIXME("(%p, %p, %x)\n", CacheInfo, size, bitmask);
3767 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
3768 return FALSE;
3769 }
3770
3771 /***********************************************************************
3772 * GetUrlCacheConfigInfoA (WININET.@)
3773 */
3774 BOOL WINAPI GetUrlCacheConfigInfoA(LPINTERNET_CACHE_CONFIG_INFOA CacheInfo, LPDWORD size, DWORD bitmask)
3775 {
3776 FIXME("(%p, %p, %x)\n", CacheInfo, size, bitmask);
3777 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
3778 return FALSE;
3779 }
3780
3781 BOOL WINAPI GetUrlCacheGroupAttributeA( GROUPID gid, DWORD dwFlags, DWORD dwAttributes,
3782 LPINTERNET_CACHE_GROUP_INFOA lpGroupInfo,
3783 LPDWORD lpdwGroupInfo, LPVOID lpReserved )
3784 {
3785 FIXME("(0x%08x%08x, 0x%08x, 0x%08x, %p, %p, %p) stub\n",
3786 (ULONG)(gid >> 32), (ULONG)gid, dwFlags, dwAttributes, lpGroupInfo,
3787 lpdwGroupInfo, lpReserved);
3788 return FALSE;
3789 }
3790
3791 BOOL WINAPI GetUrlCacheGroupAttributeW( GROUPID gid, DWORD dwFlags, DWORD dwAttributes,
3792 LPINTERNET_CACHE_GROUP_INFOW lpGroupInfo,
3793 LPDWORD lpdwGroupInfo, LPVOID lpReserved )
3794 {
3795 FIXME("(0x%08x%08x, 0x%08x, 0x%08x, %p, %p, %p) stub\n",
3796 (ULONG)(gid >> 32), (ULONG)gid, dwFlags, dwAttributes, lpGroupInfo,
3797 lpdwGroupInfo, lpReserved);
3798 return FALSE;
3799 }
3800
3801 BOOL WINAPI SetUrlCacheGroupAttributeA( GROUPID gid, DWORD dwFlags, DWORD dwAttributes,
3802 LPINTERNET_CACHE_GROUP_INFOA lpGroupInfo, LPVOID lpReserved )
3803 {
3804 FIXME("(0x%08x%08x, 0x%08x, 0x%08x, %p, %p) stub\n",
3805 (ULONG)(gid >> 32), (ULONG)gid, dwFlags, dwAttributes, lpGroupInfo, lpReserved);
3806 return TRUE;
3807 }
3808
3809 BOOL WINAPI SetUrlCacheGroupAttributeW( GROUPID gid, DWORD dwFlags, DWORD dwAttributes,
3810 LPINTERNET_CACHE_GROUP_INFOW lpGroupInfo, LPVOID lpReserved )
3811 {
3812 FIXME("(0x%08x%08x, 0x%08x, 0x%08x, %p, %p) stub\n",
3813 (ULONG)(gid >> 32), (ULONG)gid, dwFlags, dwAttributes, lpGroupInfo, lpReserved);
3814 return TRUE;
3815 }
3816
3817 BOOL WINAPI SetUrlCacheConfigInfoA( LPINTERNET_CACHE_CONFIG_INFOA lpCacheConfigInfo, DWORD dwFieldControl )
3818 {
3819 FIXME("(%p, 0x%08x) stub\n", lpCacheConfigInfo, dwFieldControl);
3820 return TRUE;
3821 }
3822
3823 BOOL WINAPI SetUrlCacheConfigInfoW( LPINTERNET_CACHE_CONFIG_INFOW lpCacheConfigInfo, DWORD dwFieldControl )
3824 {
3825 FIXME("(%p, 0x%08x) stub\n", lpCacheConfigInfo, dwFieldControl);
3826 return TRUE;
3827 }
3828
3829 /***********************************************************************
3830 * DeleteIE3Cache (WININET.@)
3831 *
3832 * Deletes the files used by the IE3 URL caching system.
3833 *
3834 * PARAMS
3835 * hWnd [I] A dummy window.
3836 * hInst [I] Instance of process calling the function.
3837 * lpszCmdLine [I] Options used by function.
3838 * nCmdShow [I] The nCmdShow value to use when showing windows created, if any.
3839 */
3840 DWORD WINAPI DeleteIE3Cache(HWND hWnd, HINSTANCE hInst, LPSTR lpszCmdLine, int nCmdShow)
3841 {
3842 FIXME("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_a(lpszCmdLine), nCmdShow);
3843 return 0;
3844 }
3845
3846 static BOOL urlcache_entry_is_expired(const entry_url *pUrlEntry,
3847 FILETIME *pftLastModified)
3848 {
3849 BOOL ret;
3850 FILETIME now, expired;
3851
3852 *pftLastModified = pUrlEntry->modification_time;
3853 GetSystemTimeAsFileTime(&now);
3854 dos_date_time_to_file_time(pUrlEntry->expire_date,
3855 pUrlEntry->expire_time, &expired);
3856 /* If the expired time is 0, it's interpreted as not expired */
3857 if (!expired.dwLowDateTime && !expired.dwHighDateTime)
3858 ret = FALSE;
3859 else
3860 ret = CompareFileTime(&expired, &now) < 0;
3861 return ret;
3862 }
3863
3864 /***********************************************************************
3865 * IsUrlCacheEntryExpiredA (WININET.@)
3866 *
3867 * PARAMS
3868 * url [I] Url
3869 * dwFlags [I] Unknown
3870 * pftLastModified [O] Last modified time
3871 */
3872 BOOL WINAPI IsUrlCacheEntryExpiredA(LPCSTR url, DWORD dwFlags, FILETIME* pftLastModified)
3873 {
3874 urlcache_header *pHeader;
3875 struct hash_entry *pHashEntry;
3876 const entry_header *pEntry;
3877 const entry_url * pUrlEntry;
3878 cache_container *pContainer;
3879 BOOL expired;
3880
3881 TRACE("(%s, %08x, %p)\n", debugstr_a(url), dwFlags, pftLastModified);
3882
3883 if (!url || !pftLastModified)
3884 return TRUE;
3885 if (dwFlags)
3886 FIXME("unknown flags 0x%08x\n", dwFlags);
3887
3888 /* Any error implies that the URL is expired, i.e. not in the cache */
3889 if (cache_containers_find(url, &pContainer))
3890 {
3891 memset(pftLastModified, 0, sizeof(*pftLastModified));
3892 return TRUE;
3893 }
3894
3895 if (cache_container_open_index(pContainer, MIN_BLOCK_NO))
3896 {
3897 memset(pftLastModified, 0, sizeof(*pftLastModified));
3898 return TRUE;
3899 }
3900
3901 if (!(pHeader = cache_container_lock_index(pContainer)))
3902 {
3903 memset(pftLastModified, 0, sizeof(*pftLastModified));
3904 return TRUE;
3905 }
3906
3907 if (!urlcache_find_hash_entry(pHeader, url, &pHashEntry))
3908 {
3909 cache_container_unlock_index(pContainer, pHeader);
3910 memset(pftLastModified, 0, sizeof(*pftLastModified));
3911 TRACE("entry %s not found!\n", url);
3912 return TRUE;
3913 }
3914
3915 pEntry = (const entry_header*)((LPBYTE)pHeader + pHashEntry->offset);
3916 if (pEntry->signature != URL_SIGNATURE)
3917 {
3918 cache_container_unlock_index(pContainer, pHeader);
3919 memset(pftLastModified, 0, sizeof(*pftLastModified));
3920 FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPCSTR)&pEntry->signature, sizeof(DWORD)));
3921 return TRUE;
3922 }
3923
3924 pUrlEntry = (const entry_url *)pEntry;
3925 expired = urlcache_entry_is_expired(pUrlEntry, pftLastModified);
3926
3927 cache_container_unlock_index(pContainer, pHeader);
3928
3929 return expired;
3930 }
3931
3932 /***********************************************************************
3933 * IsUrlCacheEntryExpiredW (WININET.@)
3934 *
3935 * PARAMS
3936 * url [I] Url
3937 * dwFlags [I] Unknown
3938 * pftLastModified [O] Last modified time
3939 */
3940 BOOL WINAPI IsUrlCacheEntryExpiredW(LPCWSTR url, DWORD dwFlags, FILETIME* pftLastModified)
3941 {
3942 char *encoded_url;
3943 BOOL ret;
3944
3945 if(!urlcache_encode_url_alloc(url, &encoded_url))
3946 return FALSE;
3947
3948 ret = IsUrlCacheEntryExpiredA(encoded_url, dwFlags, pftLastModified);
3949 heap_free(encoded_url);
3950 return ret;
3951 }
3952
3953 /***********************************************************************
3954 * GetDiskInfoA (WININET.@)
3955 */
3956 BOOL WINAPI GetDiskInfoA(PCSTR path, PDWORD cluster_size, PDWORDLONG free, PDWORDLONG total)
3957 {
3958 BOOL ret;
3959 ULARGE_INTEGER bytes_free, bytes_total;
3960
3961 TRACE("(%s, %p, %p, %p)\n", debugstr_a(path), cluster_size, free, total);
3962
3963 if (!path)
3964 {
3965 SetLastError(ERROR_INVALID_PARAMETER);
3966 return FALSE;
3967 }
3968
3969 if ((ret = GetDiskFreeSpaceExA(path, NULL, &bytes_total, &bytes_free)))
3970 {
3971 if (cluster_size) *cluster_size = 1;
3972 if (free) *free = bytes_free.QuadPart;
3973 if (total) *total = bytes_total.QuadPart;
3974 }
3975 return ret;
3976 }
3977
3978 /***********************************************************************
3979 * RegisterUrlCacheNotification (WININET.@)
3980 */
3981 DWORD WINAPI RegisterUrlCacheNotification(LPVOID a, DWORD b, DWORD c, DWORD d, DWORD e, DWORD f)
3982 {
3983 FIXME("(%p %x %x %x %x %x)\n", a, b, c, d, e, f);
3984 return 0;
3985 }
3986
3987 /***********************************************************************
3988 * IncrementUrlCacheHeaderData (WININET.@)
3989 */
3990 BOOL WINAPI IncrementUrlCacheHeaderData(DWORD index, LPDWORD data)
3991 {
3992 FIXME("(%u, %p)\n", index, data);
3993 return FALSE;
3994 }
3995
3996 /***********************************************************************
3997 * RunOnceUrlCache (WININET.@)
3998 */
3999
4000 DWORD WINAPI RunOnceUrlCache(HWND hwnd, HINSTANCE hinst, LPSTR cmd, int cmdshow)
4001 {
4002 FIXME("(%p, %p, %s, %d): stub\n", hwnd, hinst, debugstr_a(cmd), cmdshow);
4003 return 0;
4004 }
4005
4006 BOOL init_urlcache(void)
4007 {
4008 dll_unload_event = CreateEventW(NULL, FALSE, FALSE, NULL);
4009 if(!dll_unload_event)
4010 return FALSE;
4011
4012 free_cache_running = CreateSemaphoreW(NULL, 1, 1, NULL);
4013 if(!free_cache_running) {
4014 CloseHandle(dll_unload_event);
4015 return FALSE;
4016 }
4017
4018 cache_containers_init();
4019 return TRUE;
4020 }
4021
4022 void free_urlcache(void)
4023 {
4024 SetEvent(dll_unload_event);
4025 WaitForSingleObject(free_cache_running, INFINITE);
4026 ReleaseSemaphore(free_cache_running, 1, NULL);
4027 CloseHandle(free_cache_running);
4028 CloseHandle(dll_unload_event);
4029
4030 cache_containers_free();
4031 }
4032
4033 /***********************************************************************
4034 * LoadUrlCacheContent (WININET.@)
4035 */
4036 BOOL WINAPI LoadUrlCacheContent(void)
4037 {
4038 FIXME("stub!\n");
4039 return FALSE;
4040 }
Wine tree for Wine Gecko development