?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wine.inf: We should not override existing associations.
[wine/hacks.git] / dlls / wininet / urlcache.c
blob15fc4eb33a4dd9f31af5f8cdc657a00a28fd88d4
1 /*
2 * Wininet - Url Cache functions
3 *
4 * Copyright 2001,2002 CodeWeavers
5 * Copyright 2003 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 #define COM_NO_WINDOWS_H
26 #include "config.h"
27 #include "wine/port.h"
28
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <time.h>
34
35 #define NONAMELESSUNION
36 #define NONAMELESSSTRUCT
37
38 #include "windef.h"
39 #include "winbase.h"
40 #include "winuser.h"
41 #include "wininet.h"
42 #include "winerror.h"
43 #include "internet.h"
44 #include "winreg.h"
45 #include "shlwapi.h"
46 #include "wingdi.h"
47 #include "shlobj.h"
48
49 #include "wine/unicode.h"
50 #include "wine/list.h"
51 #include "wine/debug.h"
52
53 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
54
55 #define ENTRY_START_OFFSET 0x4000
56 #define DIR_LENGTH 8
57 #define BLOCKSIZE 128
58 #define HASHTABLE_SIZE 448
59 #define HASHTABLE_BLOCKSIZE 7
60 #define HASHTABLE_FREE 3
61 #define ALLOCATION_TABLE_OFFSET 0x250
62 #define ALLOCATION_TABLE_SIZE (0x1000 - ALLOCATION_TABLE_OFFSET)
63 #define HASHTABLE_NUM_ENTRIES (HASHTABLE_SIZE / HASHTABLE_BLOCKSIZE)
64 #define NEWFILE_NUM_BLOCKS 0xd80
65 #define NEWFILE_SIZE (NEWFILE_NUM_BLOCKS * BLOCKSIZE + ENTRY_START_OFFSET)
66
67 #define DWORD_SIG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
68 #define URL_SIGNATURE DWORD_SIG('U','R','L',' ')
69 #define REDR_SIGNATURE DWORD_SIG('R','E','D','R')
70 #define LEAK_SIGNATURE DWORD_SIG('L','E','A','K')
71 #define HASH_SIGNATURE DWORD_SIG('H','A','S','H')
72
73 #define DWORD_ALIGN(x) ( (DWORD)(((DWORD)(x)+sizeof(DWORD)-1)/sizeof(DWORD))*sizeof(DWORD) )
74
75 typedef struct _CACHEFILE_ENTRY
76 {
77 /* union
78 {*/
79 DWORD dwSignature; /* e.g. "URL " */
80 /* CHAR szSignature[4];
81 };*/
82 DWORD dwBlocksUsed; /* number of 128byte blocks used by this entry */
83 } CACHEFILE_ENTRY;
84
85 typedef struct _URL_CACHEFILE_ENTRY
86 {
87 CACHEFILE_ENTRY CacheFileEntry;
88 FILETIME LastModifiedTime;
89 FILETIME LastAccessTime;
90 WORD wExpiredDate; /* expire date in dos format */
91 WORD wExpiredTime; /* expire time in dos format */
92 DWORD dwUnknown1; /* usually zero */
93 DWORD dwSizeLow; /* see INTERNET_CACHE_ENTRY_INFO::dwSizeLow */
94 DWORD dwSizeHigh; /* see INTERNET_CACHE_ENTRY_INFO::dwSizeHigh */
95 DWORD dwUnknown2; /* usually zero */
96 DWORD dwExemptDelta; /* see INTERNET_CACHE_ENTRY_INFO::dwExemptDelta */
97 DWORD dwUnknown3; /* usually 0x60 */
98 DWORD dwOffsetUrl; /* offset of start of url from start of entry */
99 BYTE CacheDir; /* index of cache directory this url is stored in */
100 BYTE Unknown4; /* usually zero */
101 WORD wUnknown5; /* usually 0x1010 */
102 DWORD dwOffsetLocalName; /* offset of start of local filename from start of entry */
103 DWORD CacheEntryType; /* see INTERNET_CACHE_ENTRY_INFO::CacheEntryType */
104 DWORD dwOffsetHeaderInfo; /* offset of start of header info from start of entry */
105 DWORD dwHeaderInfoSize;
106 DWORD dwUnknown6; /* usually zero */
107 WORD wLastSyncDate; /* last sync date in dos format */
108 WORD wLastSyncTime; /* last sync time in dos format */
109 DWORD dwHitRate; /* see INTERNET_CACHE_ENTRY_INFO::dwHitRate */
110 DWORD dwUseCount; /* see INTERNET_CACHE_ENTRY_INFO::dwUseCount */
111 WORD wUnknownDate; /* usually same as wLastSyncDate */
112 WORD wUnknownTime; /* usually same as wLastSyncTime */
113 DWORD dwUnknown7; /* usually zero */
114 DWORD dwUnknown8; /* usually zero */
115 /* packing to dword align start of next field */
116 /* CHAR szSourceUrlName[]; (url) */
117 /* packing to dword align start of next field */
118 /* CHAR szLocalFileName[]; (local file name exluding path) */
119 /* packing to dword align start of next field */
120 /* CHAR szHeaderInfo[]; (header info) */
121 } URL_CACHEFILE_ENTRY;
122
123 struct _HASH_ENTRY
124 {
125 DWORD dwHashKey;
126 DWORD dwOffsetEntry;
127 };
128
129 typedef struct _HASH_CACHEFILE_ENTRY
130 {
131 CACHEFILE_ENTRY CacheFileEntry;
132 DWORD dwAddressNext;
133 DWORD dwHashTableNumber;
134 struct _HASH_ENTRY HashTable[HASHTABLE_SIZE];
135 } HASH_CACHEFILE_ENTRY;
136
137 typedef struct _DIRECTORY_DATA
138 {
139 DWORD dwUnknown;
140 char filename[DIR_LENGTH];
141 } DIRECTORY_DATA;
142
143 typedef struct _URLCACHE_HEADER
144 {
145 char szSignature[28];
146 DWORD dwFileSize;
147 DWORD dwOffsetFirstHashTable;
148 DWORD dwIndexCapacityInBlocks;
149 DWORD dwBlocksInUse;
150 DWORD dwUnknown1;
151 DWORD dwCacheLimitLow; /* disk space limit for cache */
152 DWORD dwCacheLimitHigh; /* disk space limit for cache */
153 DWORD dwUnknown4; /* current disk space usage for cache */
154 DWORD dwUnknown5; /* current disk space usage for cache */
155 DWORD dwUnknown6; /* possibly a flag? */
156 DWORD dwUnknown7;
157 BYTE DirectoryCount; /* number of directory_data's */
158 BYTE Unknown8[3]; /* just padding? */
159 DIRECTORY_DATA directory_data[1]; /* first directory entry */
160 } URLCACHE_HEADER, *LPURLCACHE_HEADER;
161 typedef const URLCACHE_HEADER *LPCURLCACHE_HEADER;
162
163 typedef struct _STREAM_HANDLE
164 {
165 HANDLE hFile;
166 CHAR lpszUrl[1];
167 } STREAM_HANDLE;
168
169 typedef struct _URLCACHECONTAINER
170 {
171 struct list entry; /* part of a list */
172 LPWSTR cache_prefix; /* string that has to be prefixed for this container to be used */
173 LPWSTR path; /* path to url container directory */
174 HANDLE hMapping; /* handle of file mapping */
175 DWORD file_size; /* size of file when mapping was opened */
176 HANDLE hMutex; /* hande of mutex */
177 } URLCACHECONTAINER;
178
179
180 /* List of all containers available */
181 static struct list UrlContainers = LIST_INIT(UrlContainers);
182
183 static HASH_CACHEFILE_ENTRY *URLCache_CreateHashTable(LPURLCACHE_HEADER pHeader, HASH_CACHEFILE_ENTRY *pPrevHash);
184
185 /***********************************************************************
186 * URLCache_PathToObjectName (Internal)
187 *
188 * Converts a path to a name suitable for use as a Win32 object name.
189 * Replaces '\\' characters in-place with the specified character
190 * (usually '_' or '!')
191 *
192 * RETURNS
193 * nothing
194 *
195 */
196 static void URLCache_PathToObjectName(LPWSTR lpszPath, WCHAR replace)
197 {
198 for (; *lpszPath; lpszPath++)
199 {
200 if (*lpszPath == '\\')
201 *lpszPath = replace;
202 }
203 }
204
205 /***********************************************************************
206 * URLCacheContainer_OpenIndex (Internal)
207 *
208 * Opens the index file and saves mapping handle in hCacheIndexMapping
209 *
210 * RETURNS
211 * TRUE if succeeded
212 * FALSE if failed
213 *
214 */
215 static BOOL URLCacheContainer_OpenIndex(URLCACHECONTAINER * pContainer)
216 {
217 HANDLE hFile;
218 WCHAR wszFilePath[MAX_PATH];
219 DWORD dwFileSize;
220
221 static const WCHAR wszIndex[] = {'i','n','d','e','x','.','d','a','t',0};
222 static const WCHAR wszMappingFormat[] = {'%','s','%','s','_','%','l','u',0};
223
224 if (pContainer->hMapping)
225 return TRUE;
226
227 strcpyW(wszFilePath, pContainer->path);
228 strcatW(wszFilePath, wszIndex);
229
230 hFile = CreateFileW(wszFilePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL);
231 if (hFile == INVALID_HANDLE_VALUE)
232 {
233 /* Maybe the directory wasn't there? Try to create it */
234 if (CreateDirectoryW(pContainer->path, 0))
235 hFile = CreateFileW(wszFilePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL);
236 }
237 if (hFile == INVALID_HANDLE_VALUE)
238 {
239 TRACE("Could not open or create cache index file \"%s\"\n", debugstr_w(wszFilePath));
240 return FALSE;
241 }
242
243 /* At this stage we need the mutex because we may be about to create the
244 * file.
245 */
246 WaitForSingleObject(pContainer->hMutex, INFINITE);
247
248 dwFileSize = GetFileSize(hFile, NULL);
249 if (dwFileSize == INVALID_FILE_SIZE)
250 {
251 ReleaseMutex(pContainer->hMutex);
252 return FALSE;
253 }
254
255 if (dwFileSize == 0)
256 {
257 static CHAR const szCacheContent[] = "Software\\Microsoft\\Windows\\CurrentVersion\\Cache\\Content";
258 HKEY key;
259 char achZeroes[0x1000];
260 DWORD dwOffset;
261 DWORD dwError = 0;
262
263 /* Write zeroes to the entire file so we can safely map it without
264 * fear of getting a SEGV because the disk is full.
265 */
266 memset(achZeroes, 0, sizeof(achZeroes));
267 for (dwOffset = 0; dwOffset < NEWFILE_SIZE; dwOffset += sizeof(achZeroes))
268 {
269 DWORD dwWrite = sizeof(achZeroes);
270 DWORD dwWritten;
271
272 if (NEWFILE_SIZE - dwOffset < dwWrite)
273 dwWrite = NEWFILE_SIZE - dwOffset;
274 if (!WriteFile(hFile, achZeroes, dwWrite, &dwWritten, 0) ||
275 dwWritten != dwWrite)
276 {
277 /* If we fail to write, we need to return the error that
278 * cause the problem and also make sure the file is no
279 * longer there, if possible.
280 */
281 dwError = GetLastError();
282
283 break;
284 }
285 }
286
287 if (!dwError)
288 {
289 HANDLE hMapping = CreateFileMappingW(hFile, NULL, PAGE_READWRITE, 0, NEWFILE_SIZE, NULL);
290
291 if (hMapping)
292 {
293 URLCACHE_HEADER *pHeader = MapViewOfFile(hMapping, FILE_MAP_WRITE, 0, 0, NEWFILE_SIZE);
294
295 if (pHeader)
296 {
297 WCHAR *pwchDir;
298 WCHAR wszDirPath[MAX_PATH];
299 FILETIME ft;
300 int i, j;
301
302 dwFileSize = NEWFILE_SIZE;
303
304 /* First set some constants and defaults in the header */
305 strcpy(pHeader->szSignature, "WINE URLCache Ver 0.2005001");
306 pHeader->dwFileSize = dwFileSize;
307 pHeader->dwIndexCapacityInBlocks = NEWFILE_NUM_BLOCKS;
308 /* 127MB - taken from default for Windows 2000 */
309 pHeader->dwCacheLimitHigh = 0;
310 pHeader->dwCacheLimitLow = 0x07ff5400;
311 /* Copied from a Windows 2000 cache index */
312 pHeader->DirectoryCount = 4;
313
314 /* If the registry has a cache size set, use the registry value */
315 if (RegOpenKeyA(HKEY_CURRENT_USER, szCacheContent, &key) == ERROR_SUCCESS)
316 {
317 DWORD dw;
318 DWORD len = sizeof(dw);
319 DWORD keytype;
320
321 if (RegQueryValueExA(key, "CacheLimit", NULL, &keytype,
322 (BYTE *) &dw, &len) == ERROR_SUCCESS &&
323 keytype == REG_DWORD)
324 {
325 pHeader->dwCacheLimitHigh = (dw >> 22);
326 pHeader->dwCacheLimitLow = dw << 10;
327 }
328 RegCloseKey(key);
329 }
330
331 URLCache_CreateHashTable(pHeader, NULL);
332
333 /* Last step - create the directories */
334
335 strcpyW(wszDirPath, pContainer->path);
336 pwchDir = wszDirPath + strlenW(wszDirPath);
337 pwchDir[8] = 0;
338
339 GetSystemTimeAsFileTime(&ft);
340
341 for (i = 0; !dwError && i < pHeader->DirectoryCount; ++i)
342 {
343 /* The following values were copied from a Windows index.
344 * I don't know what the values are supposed to mean but
345 * have made them the same in the hope that this will
346 * be better for compatibility
347 */
348 pHeader->directory_data[i].dwUnknown = (i > 1) ? 0xfe : 0xff;
349 for (j = 0;; ++j)
350 {
351 int k;
352 ULONGLONG n = ft.dwHighDateTime;
353
354 /* Generate a file name to attempt to create.
355 * This algorithm will create what will appear
356 * to be random and unrelated directory names
357 * of up to 9 characters in length.
358 */
359 n <<= 32;
360 n += ft.dwLowDateTime;
361 n ^= ((ULONGLONG) i << 56) | ((ULONGLONG) j << 48);
362
363 for (k = 0; k < 8; ++k)
364 {
365 int r = (n % 36);
366
367 /* Dividing by a prime greater than 36 helps
368 * with the appearance of randomness
369 */
370 n /= 37;
371
372 if (r < 10)
373 pwchDir[k] = '0' + r;
374 else
375 pwchDir[k] = 'A' + (r - 10);
376 }
377
378 if (CreateDirectoryW(wszDirPath, 0))
379 {
380 int k;
381
382 /* The following is OK because we generated an
383 * 8 character directory name made from characters
384 * [A-Z0-9], which are equivalent for all code
385 * pages and for UTF-16
386 */
387 for (k = 0; k < 8; ++k)
388 pHeader->directory_data[i].filename[k] = pwchDir[k];
389 break;
390 }
391 else if (j >= 255)
392 {
393 /* Give up. The most likely cause of this
394 * is a full disk, but whatever the cause
395 * is, it should be more than apparent that
396 * we won't succeed.
397 */
398 dwError = GetLastError();
399 break;
400 }
401 }
402 }
403
404 UnmapViewOfFile(pHeader);
405 }
406 else
407 {
408 dwError = GetLastError();
409 }
410 CloseHandle(hMapping);
411 }
412 else
413 {
414 dwError = GetLastError();
415 }
416 }
417
418 if (dwError)
419 {
420 CloseHandle(hFile);
421 DeleteFileW(wszFilePath);
422 ReleaseMutex(pContainer->hMutex);
423 SetLastError(dwError);
424 return FALSE;
425 }
426
427 }
428
429 ReleaseMutex(pContainer->hMutex);
430
431 wsprintfW(wszFilePath, wszMappingFormat, pContainer->path, wszIndex, dwFileSize);
432 URLCache_PathToObjectName(wszFilePath, '_');
433 pContainer->hMapping = OpenFileMappingW(FILE_MAP_WRITE, FALSE, wszFilePath);
434 if (!pContainer->hMapping)
435 pContainer->hMapping = CreateFileMappingW(hFile, NULL, PAGE_READWRITE, 0, 0, wszFilePath);
436 CloseHandle(hFile);
437 if (!pContainer->hMapping)
438 {
439 ERR("Couldn't create file mapping (error is %ld)\n", GetLastError());
440 return FALSE;
441 }
442
443 return TRUE;
444 }
445
446 /***********************************************************************
447 * URLCacheContainer_CloseIndex (Internal)
448 *
449 * Closes the index
450 *
451 * RETURNS
452 * nothing
453 *
454 */
455 static void URLCacheContainer_CloseIndex(URLCACHECONTAINER * pContainer)
456 {
457 CloseHandle(pContainer->hMapping);
458 pContainer->hMapping = NULL;
459 }
460
461 static BOOL URLCacheContainers_AddContainer(LPCWSTR cache_prefix, LPCWSTR path, LPWSTR mutex_name)
462 {
463 URLCACHECONTAINER * pContainer = HeapAlloc(GetProcessHeap(), 0, sizeof(URLCACHECONTAINER));
464 int path_len = strlenW(path);
465 int cache_prefix_len = strlenW(cache_prefix);
466
467 if (!pContainer)
468 {
469 return FALSE;
470 }
471
472 pContainer->hMapping = NULL;
473 pContainer->file_size = 0;
474
475 pContainer->path = HeapAlloc(GetProcessHeap(), 0, (path_len + 1) * sizeof(WCHAR));
476 if (!pContainer->path)
477 {
478 HeapFree(GetProcessHeap(), 0, pContainer);
479 return FALSE;
480 }
481
482 memcpy(pContainer->path, path, (path_len + 1) * sizeof(WCHAR));
483
484 pContainer->cache_prefix = HeapAlloc(GetProcessHeap(), 0, (cache_prefix_len + 1) * sizeof(WCHAR));
485 if (!pContainer->cache_prefix)
486 {
487 HeapFree(GetProcessHeap(), 0, pContainer->path);
488 HeapFree(GetProcessHeap(), 0, pContainer);
489 return FALSE;
490 }
491
492 memcpy(pContainer->cache_prefix, cache_prefix, (cache_prefix_len + 1) * sizeof(WCHAR));
493
494 CharLowerW(mutex_name);
495 URLCache_PathToObjectName(mutex_name, '!');
496
497 if ((pContainer->hMutex = CreateMutexW(NULL, FALSE, mutex_name)) == NULL)
498 {
499 ERR("couldn't create mutex (error is %ld)\n", GetLastError());
500 HeapFree(GetProcessHeap(), 0, pContainer->path);
501 HeapFree(GetProcessHeap(), 0, pContainer);
502 return FALSE;
503 }
504
505 list_add_head(&UrlContainers, &pContainer->entry);
506
507 return TRUE;
508 }
509
510 static void URLCacheContainer_DeleteContainer(URLCACHECONTAINER * pContainer)
511 {
512 list_remove(&pContainer->entry);
513
514 URLCacheContainer_CloseIndex(pContainer);
515 CloseHandle(pContainer->hMutex);
516 HeapFree(GetProcessHeap(), 0, pContainer->path);
517 HeapFree(GetProcessHeap(), 0, pContainer->cache_prefix);
518 HeapFree(GetProcessHeap(), 0, pContainer);
519 }
520
521 void URLCacheContainers_CreateDefaults(void)
522 {
523 static const WCHAR UrlSuffix[] = {'C','o','n','t','e','n','t','.','I','E','5',0};
524 static const WCHAR UrlPrefix[] = {0};
525 static const WCHAR HistorySuffix[] = {'H','i','s','t','o','r','y','.','I','E','5',0};
526 static const WCHAR HistoryPrefix[] = {'V','i','s','i','t','e','d',':',0};
527 static const WCHAR CookieSuffix[] = {0};
528 static const WCHAR CookiePrefix[] = {'C','o','o','k','i','e',':',0};
529 static const struct
530 {
531 int nFolder; /* CSIDL_* constant */
532 const WCHAR * shpath_suffix; /* suffix on path returned by SHGetSpecialFolderPath */
533 const WCHAR * cache_prefix; /* prefix used to reference the container */
534 } DefaultContainerData[] =
535 {
536 { CSIDL_INTERNET_CACHE, UrlSuffix, UrlPrefix },
537 { CSIDL_HISTORY, HistorySuffix, HistoryPrefix },
538 { CSIDL_COOKIES, CookieSuffix, CookiePrefix },
539 };
540 DWORD i;
541
542 for (i = 0; i < sizeof(DefaultContainerData) / sizeof(DefaultContainerData[0]); i++)
543 {
544 WCHAR wszCachePath[MAX_PATH];
545 WCHAR wszMutexName[MAX_PATH];
546 int path_len, suffix_len;
547
548 if (FAILED(SHGetSpecialFolderPathW(NULL, wszCachePath, DefaultContainerData[i].nFolder, TRUE)))
549 {
550 ERR("Couldn't get path for default container %lu\n", i);
551 continue;
552 }
553 path_len = strlenW(wszCachePath);
554 suffix_len = strlenW(DefaultContainerData[i].shpath_suffix);
555
556 if (path_len + suffix_len + 2 > MAX_PATH)
557 {
558 ERR("Path too long\n");
559 continue;
560 }
561
562 wszCachePath[path_len] = '\\';
563 wszCachePath[path_len+1] = 0;
564
565 strcpyW(wszMutexName, wszCachePath);
566
567 if (suffix_len)
568 {
569 memcpy(wszCachePath + path_len + 1, DefaultContainerData[i].shpath_suffix, (suffix_len + 1) * sizeof(WCHAR));
570 wszCachePath[path_len + suffix_len + 1] = '\\';
571 wszCachePath[path_len + suffix_len + 2] = '\0';
572 }
573
574 URLCacheContainers_AddContainer(DefaultContainerData[i].cache_prefix, wszCachePath, wszMutexName);
575 }
576 }
577
578 void URLCacheContainers_DeleteAll(void)
579 {
580 while(!list_empty(&UrlContainers))
581 URLCacheContainer_DeleteContainer(
582 LIST_ENTRY(list_head(&UrlContainers), URLCACHECONTAINER, entry)
583 );
584 }
585
586 static BOOL URLCacheContainers_FindContainerW(LPCWSTR lpwszUrl, URLCACHECONTAINER ** ppContainer)
587 {
588 struct list * cursor;
589
590 TRACE("searching for prefix for URL: %s\n", debugstr_w(lpwszUrl));
591
592 LIST_FOR_EACH(cursor, &UrlContainers)
593 {
594 URLCACHECONTAINER * pContainer = LIST_ENTRY(cursor, URLCACHECONTAINER, entry);
595 int prefix_len = strlenW(pContainer->cache_prefix);
596 if (!strncmpW(pContainer->cache_prefix, lpwszUrl, prefix_len))
597 {
598 TRACE("found container with prefx %s for URL %s\n", debugstr_w(pContainer->cache_prefix), debugstr_w(lpwszUrl));
599 *ppContainer = pContainer;
600 return TRUE;
601 }
602 }
603 ERR("no container found\n");
604 SetLastError(ERROR_FILE_NOT_FOUND);
605 return FALSE;
606 }
607
608 static BOOL URLCacheContainers_FindContainerA(LPCSTR lpszUrl, URLCACHECONTAINER ** ppContainer)
609 {
610 BOOL ret;
611 LPWSTR lpwszUrl;
612 int url_len = MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, NULL, 0);
613 if (url_len && (lpwszUrl = HeapAlloc(GetProcessHeap(), 0, url_len * sizeof(WCHAR))))
614 {
615 MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, lpwszUrl, url_len);
616 ret = URLCacheContainers_FindContainerW(lpwszUrl, ppContainer);
617 HeapFree(GetProcessHeap(), 0, lpwszUrl);
618 return ret;
619 }
620 return FALSE;
621 }
622
623 /***********************************************************************
624 * URLCacheContainer_LockIndex (Internal)
625 *
626 */
627 static LPURLCACHE_HEADER URLCacheContainer_LockIndex(URLCACHECONTAINER * pContainer)
628 {
629 BYTE index;
630 LPVOID pIndexData;
631 URLCACHE_HEADER * pHeader;
632
633 /* acquire mutex */
634 WaitForSingleObject(pContainer->hMutex, INFINITE);
635
636 pIndexData = MapViewOfFile(pContainer->hMapping, FILE_MAP_WRITE, 0, 0, 0);
637
638 if (!pIndexData)
639 {
640 ReleaseMutex(pContainer->hMutex);
641 ERR("Couldn't MapViewOfFile. Error: %ld\n", GetLastError());
642 return FALSE;
643 }
644 pHeader = (URLCACHE_HEADER *)pIndexData;
645
646 /* file has grown - we need to remap to prevent us getting
647 * access violations when we try and access beyond the end
648 * of the memory mapped file */
649 if (pHeader->dwFileSize != pContainer->file_size)
650 {
651 URLCacheContainer_CloseIndex(pContainer);
652 if (!URLCacheContainer_OpenIndex(pContainer))
653 {
654 ReleaseMutex(pContainer->hMutex);
655 return FALSE;
656 }
657 pIndexData = MapViewOfFile(pContainer->hMapping, FILE_MAP_WRITE, 0, 0, 0);
658
659 if (!pIndexData)
660 {
661 ReleaseMutex(pContainer->hMutex);
662 ERR("Couldn't MapViewOfFile. Error: %ld\n", GetLastError());
663 return FALSE;
664 }
665 pHeader = (URLCACHE_HEADER *)pIndexData;
666 }
667
668 TRACE("Signature: %s, file size: %ld bytes\n", pHeader->szSignature, pHeader->dwFileSize);
669
670 for (index = 0; index < pHeader->DirectoryCount; index++)
671 {
672 TRACE("Directory[%d] = \"%.8s\"\n", index, pHeader->directory_data[index].filename);
673 }
674
675 return pHeader;
676 }
677
678 /***********************************************************************
679 * URLCacheContainer_UnlockIndex (Internal)
680 *
681 */
682 static BOOL URLCacheContainer_UnlockIndex(URLCACHECONTAINER * pContainer, LPURLCACHE_HEADER pHeader)
683 {
684 /* release mutex */
685 ReleaseMutex(pContainer->hMutex);
686 return UnmapViewOfFile(pHeader);
687 }
688
689
690 #ifndef CHAR_BIT
691 #define CHAR_BIT (8 * sizeof(CHAR))
692 #endif
693
694 /***********************************************************************
695 * URLCache_Allocation_BlockIsFree (Internal)
696 *
697 * Is the specified block number free?
698 *
699 * RETURNS
700 * zero if free
701 * non-zero otherwise
702 *
703 */
704 static inline BYTE URLCache_Allocation_BlockIsFree(BYTE * AllocationTable, DWORD dwBlockNumber)
705 {
706 BYTE mask = 1 << (dwBlockNumber % CHAR_BIT);
707 return (AllocationTable[dwBlockNumber / CHAR_BIT] & mask) == 0;
708 }
709
710 /***********************************************************************
711 * URLCache_Allocation_BlockFree (Internal)
712 *
713 * Marks the specified block as free
714 *
715 * RETURNS
716 * nothing
717 *
718 */
719 static inline void URLCache_Allocation_BlockFree(BYTE * AllocationTable, DWORD dwBlockNumber)
720 {
721 BYTE mask = ~(1 << (dwBlockNumber % CHAR_BIT));
722 AllocationTable[dwBlockNumber / CHAR_BIT] &= mask;
723 }
724
725 /***********************************************************************
726 * URLCache_Allocation_BlockAllocate (Internal)
727 *
728 * Marks the specified block as allocated
729 *
730 * RETURNS
731 * nothing
732 *
733 */
734 static inline void URLCache_Allocation_BlockAllocate(BYTE * AllocationTable, DWORD dwBlockNumber)
735 {
736 BYTE mask = 1 << (dwBlockNumber % CHAR_BIT);
737 AllocationTable[dwBlockNumber / CHAR_BIT] |= mask;
738 }
739
740 /***********************************************************************
741 * URLCache_FindFirstFreeEntry (Internal)
742 *
743 * Finds and allocates the first block of free space big enough and
744 * sets ppEntry to point to it.
745 *
746 * RETURNS
747 * TRUE if it had enough space
748 * FALSE if it couldn't find enough space
749 *
750 */
751 static BOOL URLCache_FindFirstFreeEntry(URLCACHE_HEADER * pHeader, DWORD dwBlocksNeeded, CACHEFILE_ENTRY ** ppEntry)
752 {
753 LPBYTE AllocationTable = (LPBYTE)pHeader + ALLOCATION_TABLE_OFFSET;
754 DWORD dwBlockNumber;
755 DWORD dwFreeCounter;
756 for (dwBlockNumber = 0; dwBlockNumber < pHeader->dwIndexCapacityInBlocks; dwBlockNumber++)
757 {
758 for (dwFreeCounter = 0;
759 dwFreeCounter < dwBlocksNeeded &&
760 dwFreeCounter + dwBlockNumber < pHeader->dwIndexCapacityInBlocks &&
761 URLCache_Allocation_BlockIsFree(AllocationTable, dwBlockNumber + dwFreeCounter);
762 dwFreeCounter++)
763 TRACE("Found free block at no. %ld (0x%lx)\n", dwBlockNumber, ENTRY_START_OFFSET + dwBlockNumber * BLOCKSIZE);
764
765 if (dwFreeCounter == dwBlocksNeeded)
766 {
767 DWORD index;
768 TRACE("Found free blocks starting at no. %ld (0x%lx)\n", dwBlockNumber, ENTRY_START_OFFSET + dwBlockNumber * BLOCKSIZE);
769 for (index = 0; index < dwBlocksNeeded; index++)
770 URLCache_Allocation_BlockAllocate(AllocationTable, dwBlockNumber + index);
771 *ppEntry = (CACHEFILE_ENTRY *)((LPBYTE)pHeader + ENTRY_START_OFFSET + dwBlockNumber * BLOCKSIZE);
772 (*ppEntry)->dwBlocksUsed = dwBlocksNeeded;
773 return TRUE;
774 }
775 }
776 FIXME("Grow file\n");
777 return FALSE;
778 }
779
780 /***********************************************************************
781 * URLCache_DeleteEntry (Internal)
782 *
783 * Deletes the specified entry and frees the space allocated to it
784 *
785 * RETURNS
786 * TRUE if it succeeded
787 * FALSE if it failed
788 *
789 */
790 static BOOL URLCache_DeleteEntry(LPURLCACHE_HEADER pHeader, CACHEFILE_ENTRY * pEntry)
791 {
792 DWORD dwStartBlock;
793 DWORD dwBlock;
794 BYTE * AllocationTable = (LPBYTE)pHeader + ALLOCATION_TABLE_OFFSET;
795
796 /* update allocation table */
797 dwStartBlock = ((DWORD)((BYTE *)pEntry - (BYTE *)pHeader)) / BLOCKSIZE;
798 for (dwBlock = dwStartBlock; dwBlock < dwStartBlock + pEntry->dwBlocksUsed; dwBlock++)
799 URLCache_Allocation_BlockFree(AllocationTable, dwBlock);
800
801 ZeroMemory(pEntry, pEntry->dwBlocksUsed * BLOCKSIZE);
802 return TRUE;
803 }
804
805 /***********************************************************************
806 * URLCache_LocalFileNameToPathW (Internal)
807 *
808 * Copies the full path to the specified buffer given the local file
809 * name and the index of the directory it is in. Always sets value in
810 * lpBufferSize to the required buffer size (in bytes).
811 *
812 * RETURNS
813 * TRUE if the buffer was big enough
814 * FALSE if the buffer was too small
815 *
816 */
817 static BOOL URLCache_LocalFileNameToPathW(
818 const URLCACHECONTAINER * pContainer,
819 LPCURLCACHE_HEADER pHeader,
820 LPCSTR szLocalFileName,
821 BYTE Directory,
822 LPWSTR wszPath,
823 LPLONG lpBufferSize)
824 {
825 LONG nRequired;
826 int path_len = strlenW(pContainer->path);
827 int file_name_len = MultiByteToWideChar(CP_ACP, 0, szLocalFileName, -1, NULL, 0);
828 if (Directory >= pHeader->DirectoryCount)
829 {
830 *lpBufferSize = 0;
831 return FALSE;
832 }
833
834 nRequired = (path_len + DIR_LENGTH + file_name_len + 1) * sizeof(WCHAR);
835 if (nRequired < *lpBufferSize)
836 {
837 int dir_len;
838
839 memcpy(wszPath, pContainer->path, path_len * sizeof(WCHAR));
840 dir_len = MultiByteToWideChar(CP_ACP, 0, pHeader->directory_data[Directory].filename, DIR_LENGTH, wszPath + path_len, DIR_LENGTH);
841 wszPath[dir_len + path_len] = '\\';
842 MultiByteToWideChar(CP_ACP, 0, szLocalFileName, -1, wszPath + dir_len + path_len + 1, file_name_len);
843 *lpBufferSize = nRequired;
844 return TRUE;
845 }
846 *lpBufferSize = nRequired;
847 return FALSE;
848 }
849
850 /***********************************************************************
851 * URLCache_LocalFileNameToPathA (Internal)
852 *
853 * Copies the full path to the specified buffer given the local file
854 * name and the index of the directory it is in. Always sets value in
855 * lpBufferSize to the required buffer size.
856 *
857 * RETURNS
858 * TRUE if the buffer was big enough
859 * FALSE if the buffer was too small
860 *
861 */
862 static BOOL URLCache_LocalFileNameToPathA(
863 const URLCACHECONTAINER * pContainer,
864 LPCURLCACHE_HEADER pHeader,
865 LPCSTR szLocalFileName,
866 BYTE Directory,
867 LPSTR szPath,
868 LPLONG lpBufferSize)
869 {
870 LONG nRequired;
871 int path_len, file_name_len, dir_len;
872
873 if (Directory >= pHeader->DirectoryCount)
874 {
875 *lpBufferSize = 0;
876 return FALSE;
877 }
878
879 path_len = WideCharToMultiByte(CP_ACP, 0, pContainer->path, -1, NULL, 0, NULL, NULL);
880 file_name_len = strlen(szLocalFileName);
881 dir_len = DIR_LENGTH;
882
883 nRequired = (path_len + dir_len + 1 + file_name_len) * sizeof(WCHAR);
884 if (nRequired < *lpBufferSize)
885 {
886 WideCharToMultiByte(CP_ACP, 0, pContainer->path, -1, szPath, -1, NULL, NULL);
887 memcpy(szPath+path_len, pHeader->directory_data[Directory].filename, dir_len);
888 szPath[path_len + dir_len] = '\\';
889 memcpy(szPath + path_len + dir_len + 1, szLocalFileName, file_name_len);
890 *lpBufferSize = nRequired;
891 return TRUE;
892 }
893 *lpBufferSize = nRequired;
894 return FALSE;
895 }
896
897 /***********************************************************************
898 * URLCache_CopyEntry (Internal)
899 *
900 * Copies an entry from the cache index file to the Win32 structure
901 *
902 * RETURNS
903 * TRUE if the buffer was big enough
904 * FALSE if the buffer was too small
905 *
906 */
907 static BOOL URLCache_CopyEntry(
908 URLCACHECONTAINER * pContainer,
909 LPCURLCACHE_HEADER pHeader,
910 LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
911 LPDWORD lpdwBufferSize,
912 URL_CACHEFILE_ENTRY * pUrlEntry,
913 BOOL bUnicode)
914 {
915 int lenUrl;
916 DWORD dwRequiredSize = sizeof(*lpCacheEntryInfo);
917
918 if (*lpdwBufferSize >= dwRequiredSize)
919 {
920 lpCacheEntryInfo->lpHeaderInfo = NULL;
921 lpCacheEntryInfo->lpszFileExtension = NULL;
922 lpCacheEntryInfo->lpszLocalFileName = NULL;
923 lpCacheEntryInfo->lpszSourceUrlName = NULL;
924 lpCacheEntryInfo->CacheEntryType = pUrlEntry->CacheEntryType;
925 lpCacheEntryInfo->u.dwExemptDelta = pUrlEntry->dwExemptDelta;
926 lpCacheEntryInfo->dwHeaderInfoSize = pUrlEntry->dwHeaderInfoSize;
927 lpCacheEntryInfo->dwHitRate = pUrlEntry->dwHitRate;
928 lpCacheEntryInfo->dwSizeHigh = pUrlEntry->dwSizeHigh;
929 lpCacheEntryInfo->dwSizeLow = pUrlEntry->dwSizeLow;
930 lpCacheEntryInfo->dwStructSize = sizeof(*lpCacheEntryInfo);
931 lpCacheEntryInfo->dwUseCount = pUrlEntry->dwUseCount;
932 DosDateTimeToFileTime(pUrlEntry->wExpiredDate, pUrlEntry->wExpiredTime, &lpCacheEntryInfo->ExpireTime);
933 lpCacheEntryInfo->LastAccessTime.dwHighDateTime = pUrlEntry->LastAccessTime.dwHighDateTime;
934 lpCacheEntryInfo->LastAccessTime.dwLowDateTime = pUrlEntry->LastAccessTime.dwLowDateTime;
935 lpCacheEntryInfo->LastModifiedTime.dwHighDateTime = pUrlEntry->LastModifiedTime.dwHighDateTime;
936 lpCacheEntryInfo->LastModifiedTime.dwLowDateTime = pUrlEntry->LastModifiedTime.dwLowDateTime;
937 DosDateTimeToFileTime(pUrlEntry->wLastSyncDate, pUrlEntry->wLastSyncTime, &lpCacheEntryInfo->LastSyncTime);
938 }
939
940 if ((dwRequiredSize % 4) && (dwRequiredSize < *lpdwBufferSize))
941 ZeroMemory((LPBYTE)lpCacheEntryInfo + dwRequiredSize, 4 - (dwRequiredSize % 4));
942 dwRequiredSize = DWORD_ALIGN(dwRequiredSize);
943 if (bUnicode)
944 lenUrl = MultiByteToWideChar(CP_ACP, 0, (LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl, -1, NULL, 0);
945 else
946 lenUrl = strlen((LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl);
947 dwRequiredSize += (lenUrl + 1) * (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
948
949 /* FIXME: is source url optional? */
950 if (*lpdwBufferSize >= dwRequiredSize)
951 {
952 lpCacheEntryInfo->lpszSourceUrlName = (LPSTR)lpCacheEntryInfo + dwRequiredSize - lenUrl - 1;
953 if (bUnicode)
954 MultiByteToWideChar(CP_ACP, 0, (LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl, -1, (LPWSTR)lpCacheEntryInfo->lpszSourceUrlName, lenUrl + 1);
955 else
956 memcpy(lpCacheEntryInfo->lpszSourceUrlName, (LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl, (lenUrl + 1) * sizeof(CHAR));
957 }
958
959 if ((dwRequiredSize % 4) && (dwRequiredSize < *lpdwBufferSize))
960 ZeroMemory((LPBYTE)lpCacheEntryInfo + dwRequiredSize, 4 - (dwRequiredSize % 4));
961 dwRequiredSize = DWORD_ALIGN(dwRequiredSize);
962
963 if (pUrlEntry->dwOffsetLocalName)
964 {
965 LONG nLocalFilePathSize;
966 LPSTR lpszLocalFileName;
967 lpszLocalFileName = (LPSTR)lpCacheEntryInfo + dwRequiredSize;
968 nLocalFilePathSize = *lpdwBufferSize - dwRequiredSize;
969 if ((bUnicode && URLCache_LocalFileNameToPathW(pContainer, pHeader, (LPCSTR)pUrlEntry + pUrlEntry->dwOffsetLocalName, pUrlEntry->CacheDir, (LPWSTR)lpszLocalFileName, &nLocalFilePathSize)) ||
970 URLCache_LocalFileNameToPathA(pContainer, pHeader, (LPCSTR)pUrlEntry + pUrlEntry->dwOffsetLocalName, pUrlEntry->CacheDir, lpszLocalFileName, &nLocalFilePathSize))
971 {
972 lpCacheEntryInfo->lpszLocalFileName = lpszLocalFileName;
973 }
974 dwRequiredSize += nLocalFilePathSize * (bUnicode ? sizeof(WCHAR) : sizeof(CHAR)) ;
975
976 if ((dwRequiredSize % 4) && (dwRequiredSize < *lpdwBufferSize))
977 ZeroMemory((LPBYTE)lpCacheEntryInfo + dwRequiredSize, 4 - (dwRequiredSize % 4));
978 dwRequiredSize = DWORD_ALIGN(dwRequiredSize);
979 }
980 dwRequiredSize += pUrlEntry->dwHeaderInfoSize + 1;
981
982 if (*lpdwBufferSize >= dwRequiredSize)
983 {
984 lpCacheEntryInfo->lpHeaderInfo = (LPBYTE)lpCacheEntryInfo + dwRequiredSize - pUrlEntry->dwHeaderInfoSize - 1;
985 memcpy(lpCacheEntryInfo->lpHeaderInfo, (LPSTR)pUrlEntry + pUrlEntry->dwOffsetHeaderInfo, pUrlEntry->dwHeaderInfoSize);
986 ((LPBYTE)lpCacheEntryInfo)[dwRequiredSize - 1] = '\0';
987 }
988 if ((dwRequiredSize % 4) && (dwRequiredSize < *lpdwBufferSize))
989 ZeroMemory((LPBYTE)lpCacheEntryInfo + dwRequiredSize, 4 - (dwRequiredSize % 4));
990 dwRequiredSize = DWORD_ALIGN(dwRequiredSize);
991
992 if (dwRequiredSize > *lpdwBufferSize)
993 {
994 *lpdwBufferSize = dwRequiredSize;
995 SetLastError(ERROR_INSUFFICIENT_BUFFER);
996 return FALSE;
997 }
998 *lpdwBufferSize = dwRequiredSize;
999 return TRUE;
1000 }
1001
1002
1003 /***********************************************************************
1004 * URLCache_SetEntryInfo (Internal)
1005 *
1006 * Helper for SetUrlCacheEntryInfo{A,W}. Sets fields in URL entry
1007 * according the the flags set by dwFieldControl.
1008 *
1009 * RETURNS
1010 * TRUE if the buffer was big enough
1011 * FALSE if the buffer was too small
1012 *
1013 */
1014 static BOOL URLCache_SetEntryInfo(URL_CACHEFILE_ENTRY * pUrlEntry, const INTERNET_CACHE_ENTRY_INFOW * lpCacheEntryInfo, DWORD dwFieldControl)
1015 {
1016 if (dwFieldControl & CACHE_ENTRY_ACCTIME_FC)
1017 pUrlEntry->LastAccessTime = lpCacheEntryInfo->LastAccessTime;
1018 if (dwFieldControl & CACHE_ENTRY_ATTRIBUTE_FC)
1019 pUrlEntry->CacheEntryType = lpCacheEntryInfo->CacheEntryType;
1020 if (dwFieldControl & CACHE_ENTRY_EXEMPT_DELTA_FC)
1021 pUrlEntry->dwExemptDelta = lpCacheEntryInfo->u.dwExemptDelta;
1022 if (dwFieldControl & CACHE_ENTRY_EXPTIME_FC)
1023 FIXME("CACHE_ENTRY_EXPTIME_FC unimplemented\n");
1024 if (dwFieldControl & CACHE_ENTRY_HEADERINFO_FC)
1025 FIXME("CACHE_ENTRY_HEADERINFO_FC unimplemented\n");
1026 if (dwFieldControl & CACHE_ENTRY_HITRATE_FC)
1027 pUrlEntry->dwHitRate = lpCacheEntryInfo->dwHitRate;
1028 if (dwFieldControl & CACHE_ENTRY_MODTIME_FC)
1029 pUrlEntry->LastModifiedTime = lpCacheEntryInfo->LastModifiedTime;
1030 if (dwFieldControl & CACHE_ENTRY_SYNCTIME_FC)
1031 FileTimeToDosDateTime(&lpCacheEntryInfo->LastAccessTime, &pUrlEntry->wLastSyncDate, &pUrlEntry->wLastSyncTime);
1032
1033 return TRUE;
1034 }
1035
1036 /***********************************************************************
1037 * URLCache_HashKey (Internal)
1038 *
1039 * Returns the hash key for a given string
1040 *
1041 * RETURNS
1042 * hash key for the string
1043 *
1044 */
1045 static DWORD URLCache_HashKey(LPCSTR lpszKey)
1046 {
1047 /* NOTE: this uses the same lookup table as SHLWAPI.UrlHash{A,W}
1048 * but the algorithm and result are not the same!
1049 */
1050 static const unsigned char lookupTable[256] =
1051 {
1052 0x01, 0x0E, 0x6E, 0x19, 0x61, 0xAE, 0x84, 0x77,
1053 0x8A, 0xAA, 0x7D, 0x76, 0x1B, 0xE9, 0x8C, 0x33,
1054 0x57, 0xC5, 0xB1, 0x6B, 0xEA, 0xA9, 0x38, 0x44,
1055 0x1E, 0x07, 0xAD, 0x49, 0xBC, 0x28, 0x24, 0x41,
1056 0x31, 0xD5, 0x68, 0xBE, 0x39, 0xD3, 0x94, 0xDF,
1057 0x30, 0x73, 0x0F, 0x02, 0x43, 0xBA, 0xD2, 0x1C,
1058 0x0C, 0xB5, 0x67, 0x46, 0x16, 0x3A, 0x4B, 0x4E,
1059 0xB7, 0xA7, 0xEE, 0x9D, 0x7C, 0x93, 0xAC, 0x90,
1060 0xB0, 0xA1, 0x8D, 0x56, 0x3C, 0x42, 0x80, 0x53,
1061 0x9C, 0xF1, 0x4F, 0x2E, 0xA8, 0xC6, 0x29, 0xFE,
1062 0xB2, 0x55, 0xFD, 0xED, 0xFA, 0x9A, 0x85, 0x58,
1063 0x23, 0xCE, 0x5F, 0x74, 0xFC, 0xC0, 0x36, 0xDD,
1064 0x66, 0xDA, 0xFF, 0xF0, 0x52, 0x6A, 0x9E, 0xC9,
1065 0x3D, 0x03, 0x59, 0x09, 0x2A, 0x9B, 0x9F, 0x5D,
1066 0xA6, 0x50, 0x32, 0x22, 0xAF, 0xC3, 0x64, 0x63,
1067 0x1A, 0x96, 0x10, 0x91, 0x04, 0x21, 0x08, 0xBD,
1068 0x79, 0x40, 0x4D, 0x48, 0xD0, 0xF5, 0x82, 0x7A,
1069 0x8F, 0x37, 0x69, 0x86, 0x1D, 0xA4, 0xB9, 0xC2,
1070 0xC1, 0xEF, 0x65, 0xF2, 0x05, 0xAB, 0x7E, 0x0B,
1071 0x4A, 0x3B, 0x89, 0xE4, 0x6C, 0xBF, 0xE8, 0x8B,
1072 0x06, 0x18, 0x51, 0x14, 0x7F, 0x11, 0x5B, 0x5C,
1073 0xFB, 0x97, 0xE1, 0xCF, 0x15, 0x62, 0x71, 0x70,
1074 0x54, 0xE2, 0x12, 0xD6, 0xC7, 0xBB, 0x0D, 0x20,
1075 0x5E, 0xDC, 0xE0, 0xD4, 0xF7, 0xCC, 0xC4, 0x2B,
1076 0xF9, 0xEC, 0x2D, 0xF4, 0x6F, 0xB6, 0x99, 0x88,
1077 0x81, 0x5A, 0xD9, 0xCA, 0x13, 0xA5, 0xE7, 0x47,
1078 0xE6, 0x8E, 0x60, 0xE3, 0x3E, 0xB3, 0xF6, 0x72,
1079 0xA2, 0x35, 0xA0, 0xD7, 0xCD, 0xB4, 0x2F, 0x6D,
1080 0x2C, 0x26, 0x1F, 0x95, 0x87, 0x00, 0xD8, 0x34,
1081 0x3F, 0x17, 0x25, 0x45, 0x27, 0x75, 0x92, 0xB8,
1082 0xA3, 0xC8, 0xDE, 0xEB, 0xF8, 0xF3, 0xDB, 0x0A,
1083 0x98, 0x83, 0x7B, 0xE5, 0xCB, 0x4C, 0x78, 0xD1
1084 };
1085 BYTE key[4];
1086 DWORD i;
1087 int subscript[sizeof(key) / sizeof(key[0])];
1088
1089 subscript[0] = *lpszKey;
1090 subscript[1] = (char)(*lpszKey + 1);
1091 subscript[2] = (char)(*lpszKey + 2);
1092 subscript[3] = (char)(*lpszKey + 3);
1093
1094 for (i = 0; i < sizeof(key) / sizeof(key[0]); i++)
1095 key[i] = lookupTable[i];
1096
1097 for (lpszKey++; *lpszKey && ((lpszKey[0] != '/') || (lpszKey[1] != 0)); lpszKey++)
1098 {
1099 for (i = 0; i < sizeof(key) / sizeof(key[0]); i++)
1100 key[i] = lookupTable[*lpszKey ^ key[i]];
1101 }
1102
1103 return *(DWORD *)key;
1104 }
1105
1106 static inline HASH_CACHEFILE_ENTRY * URLCache_HashEntryFromOffset(LPCURLCACHE_HEADER pHeader, DWORD dwOffset)
1107 {
1108 return (HASH_CACHEFILE_ENTRY *)((LPBYTE)pHeader + dwOffset);
1109 }
1110
1111 static BOOL URLCache_FindHash(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl, struct _HASH_ENTRY ** ppHashEntry)
1112 {
1113 /* structure of hash table:
1114 * 448 entries divided into 64 blocks
1115 * each block therefore contains a chain of 7 key/offset pairs
1116 * how position in table is calculated:
1117 * 1. the url is hashed in helper function
1118 * 2. the key % 64 * 8 is the offset
1119 * 3. the key in the hash table is the hash key aligned to 64
1120 *
1121 * note:
1122 * there can be multiple hash tables in the file and the offset to
1123 * the next one is stored in the header of the hash table
1124 */
1125 DWORD key = URLCache_HashKey(lpszUrl);
1126 DWORD offset = (key % HASHTABLE_NUM_ENTRIES) * sizeof(struct _HASH_ENTRY);
1127 HASH_CACHEFILE_ENTRY * pHashEntry;
1128 DWORD dwHashTableNumber = 0;
1129
1130 key = (DWORD)(key / HASHTABLE_NUM_ENTRIES) * HASHTABLE_NUM_ENTRIES;
1131
1132 for (pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->dwOffsetFirstHashTable);
1133 ((DWORD)((LPBYTE)pHashEntry - (LPBYTE)pHeader) >= ENTRY_START_OFFSET) && ((DWORD)((LPBYTE)pHashEntry - (LPBYTE)pHeader) < pHeader->dwFileSize);
1134 pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHashEntry->dwAddressNext))
1135 {
1136 int i;
1137 if (pHashEntry->dwHashTableNumber != dwHashTableNumber++)
1138 {
1139 ERR("Error: not right hash table number (%ld) expected %ld\n", pHashEntry->dwHashTableNumber, dwHashTableNumber);
1140 continue;
1141 }
1142 /* make sure that it is in fact a hash entry */
1143 if (pHashEntry->CacheFileEntry.dwSignature != HASH_SIGNATURE)
1144 {
1145 ERR("Error: not right signature (\"%.4s\") - expected \"HASH\"\n", (LPCSTR)&pHashEntry->CacheFileEntry.dwSignature);
1146 continue;
1147 }
1148
1149 for (i = 0; i < HASHTABLE_BLOCKSIZE; i++)
1150 {
1151 struct _HASH_ENTRY * pHashElement = &pHashEntry->HashTable[offset + i];
1152 if (key == (DWORD)(pHashElement->dwHashKey / HASHTABLE_NUM_ENTRIES) * HASHTABLE_NUM_ENTRIES)
1153 {
1154 /* FIXME: we should make sure that this is the right element
1155 * before returning and claiming that it is. We can do this
1156 * by doing a simple compare between the URL we were given
1157 * and the URL stored in the entry. However, this assumes
1158 * we know the format of all the entries stored in the
1159 * hash table */
1160 *ppHashEntry = pHashElement;
1161 return TRUE;
1162 }
1163 }
1164 }
1165 return FALSE;
1166 }
1167
1168 /***********************************************************************
1169 * URLCache_FindEntryInHash (Internal)
1170 *
1171 * Searches all the hash tables in the index for the given URL and
1172 * returns the entry, if it was found, in ppEntry
1173 *
1174 * RETURNS
1175 * TRUE if the entry was found
1176 * FALSE if the entry could not be found
1177 *
1178 */
1179 static BOOL URLCache_FindEntryInHash(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl, CACHEFILE_ENTRY ** ppEntry)
1180 {
1181 struct _HASH_ENTRY * pHashEntry;
1182 if (URLCache_FindHash(pHeader, lpszUrl, &pHashEntry))
1183 {
1184 *ppEntry = (CACHEFILE_ENTRY *)((LPBYTE)pHeader + pHashEntry->dwOffsetEntry);
1185 return TRUE;
1186 }
1187 return FALSE;
1188 }
1189
1190 /***********************************************************************
1191 * URLCache_HashEntrySetUse (Internal)
1192 *
1193 * Searches all the hash tables in the index for the given URL and
1194 * sets the use count (stored or'ed with key)
1195 *
1196 * RETURNS
1197 * TRUE if the entry was found
1198 * FALSE if the entry could not be found
1199 *
1200 */
1201 static BOOL URLCache_HashEntrySetUse(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl, DWORD dwUseCount)
1202 {
1203 struct _HASH_ENTRY * pHashEntry;
1204 if (URLCache_FindHash(pHeader, lpszUrl, &pHashEntry))
1205 {
1206 pHashEntry->dwHashKey = dwUseCount | (DWORD)(pHashEntry->dwHashKey / HASHTABLE_NUM_ENTRIES) * HASHTABLE_NUM_ENTRIES;
1207 return TRUE;
1208 }
1209 return FALSE;
1210 }
1211
1212 /***********************************************************************
1213 * URLCache_DeleteEntryFromHash (Internal)
1214 *
1215 * Searches all the hash tables in the index for the given URL and
1216 * then if found deletes the entry.
1217 *
1218 * RETURNS
1219 * TRUE if the entry was found
1220 * FALSE if the entry could not be found
1221 *
1222 */
1223 static BOOL URLCache_DeleteEntryFromHash(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl)
1224 {
1225 struct _HASH_ENTRY * pHashEntry;
1226 if (URLCache_FindHash(pHeader, lpszUrl, &pHashEntry))
1227 {
1228 pHashEntry->dwHashKey = HASHTABLE_FREE;
1229 pHashEntry->dwOffsetEntry = HASHTABLE_FREE;
1230 return TRUE;
1231 }
1232 return FALSE;
1233 }
1234
1235 /***********************************************************************
1236 * URLCache_AddEntryToHash (Internal)
1237 *
1238 * Searches all the hash tables for a free slot based on the offset
1239 * generated from the hash key. If a free slot is found, the offset and
1240 * key are entered into the hash table.
1241 *
1242 * RETURNS
1243 * TRUE if the entry was added
1244 * FALSE if the entry could not be added
1245 *
1246 */
1247 static BOOL URLCache_AddEntryToHash(LPURLCACHE_HEADER pHeader, LPCSTR lpszUrl, DWORD dwOffsetEntry)
1248 {
1249 /* see URLCache_FindEntryInHash for structure of hash tables */
1250
1251 DWORD key = URLCache_HashKey(lpszUrl);
1252 DWORD offset = (key % HASHTABLE_NUM_ENTRIES) * sizeof(struct _HASH_ENTRY);
1253 HASH_CACHEFILE_ENTRY * pHashEntry;
1254 DWORD dwHashTableNumber = 0;
1255
1256 key = (DWORD)(key / HASHTABLE_NUM_ENTRIES) * HASHTABLE_NUM_ENTRIES;
1257
1258 for (pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->dwOffsetFirstHashTable);
1259 ((DWORD)((LPBYTE)pHashEntry - (LPBYTE)pHeader) >= ENTRY_START_OFFSET) && ((DWORD)((LPBYTE)pHashEntry - (LPBYTE)pHeader) < pHeader->dwFileSize);
1260 pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHashEntry->dwAddressNext))
1261 {
1262 int i;
1263 if (pHashEntry->dwHashTableNumber != dwHashTableNumber++)
1264 {
1265 ERR("not right hash table number (%ld) expected %ld\n", pHashEntry->dwHashTableNumber, dwHashTableNumber);
1266 break;
1267 }
1268 /* make sure that it is in fact a hash entry */
1269 if (pHashEntry->CacheFileEntry.dwSignature != HASH_SIGNATURE)
1270 {
1271 ERR("not right signature (\"%.4s\") - expected \"HASH\"\n", (LPCSTR)&pHashEntry->CacheFileEntry.dwSignature);
1272 break;
1273 }
1274
1275 for (i = 0; i < HASHTABLE_BLOCKSIZE; i++)
1276 {
1277 struct _HASH_ENTRY * pHashElement = &pHashEntry->HashTable[offset + i];
1278 if (pHashElement->dwHashKey == HASHTABLE_FREE) /* if the slot is free */
1279 {
1280 pHashElement->dwHashKey = key;
1281 pHashElement->dwOffsetEntry = dwOffsetEntry;
1282 return TRUE;
1283 }
1284 }
1285 }
1286 pHashEntry = URLCache_CreateHashTable(pHeader, pHashEntry);
1287 if (!pHashEntry)
1288 return FALSE;
1289
1290 pHashEntry->HashTable[offset].dwHashKey = key;
1291 pHashEntry->HashTable[offset].dwOffsetEntry = dwOffsetEntry;
1292 return TRUE;
1293 }
1294
1295 static HASH_CACHEFILE_ENTRY *URLCache_CreateHashTable(LPURLCACHE_HEADER pHeader, HASH_CACHEFILE_ENTRY *pPrevHash)
1296 {
1297 HASH_CACHEFILE_ENTRY *pHash;
1298 DWORD dwOffset;
1299 int i;
1300
1301 if (!URLCache_FindFirstFreeEntry(pHeader, 0x20, (CACHEFILE_ENTRY **)&pHash))
1302 {
1303 FIXME("no free space for hash table\n");
1304 SetLastError(ERROR_DISK_FULL);
1305 return NULL;
1306 }
1307
1308 dwOffset = (BYTE *)pHash - (BYTE *)pHeader;
1309
1310 if (pPrevHash)
1311 pPrevHash->dwAddressNext = dwOffset;
1312 else
1313 pHeader->dwOffsetFirstHashTable = dwOffset;
1314 pHash->CacheFileEntry.dwSignature = HASH_SIGNATURE;
1315 pHash->CacheFileEntry.dwBlocksUsed = 0x20;
1316 pHash->dwHashTableNumber = pPrevHash ? pPrevHash->dwHashTableNumber + 1 : 0;
1317 for (i = 0; i < HASHTABLE_SIZE; i++)
1318 {
1319 pHash->HashTable[i].dwOffsetEntry = 0;
1320 pHash->HashTable[i].dwHashKey = HASHTABLE_FREE;
1321 }
1322 return pHash;
1323 }
1324
1325 /***********************************************************************
1326 * GetUrlCacheEntryInfoExA (WININET.@)
1327 *
1328 */
1329 BOOL WINAPI GetUrlCacheEntryInfoExA(
1330 LPCSTR lpszUrl,
1331 LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1332 LPDWORD lpdwCacheEntryInfoBufSize,
1333 LPSTR lpszReserved,
1334 LPDWORD lpdwReserved,
1335 LPVOID lpReserved,
1336 DWORD dwFlags)
1337 {
1338 TRACE("(%s, %p, %p, %p, %p, %p, %lx)\n",
1339 debugstr_a(lpszUrl),
1340 lpCacheEntryInfo,
1341 lpdwCacheEntryInfoBufSize,
1342 lpszReserved,
1343 lpdwReserved,
1344 lpReserved,
1345 dwFlags);
1346
1347 if ((lpszReserved != NULL) ||
1348 (lpdwReserved != NULL) ||
1349 (lpReserved != NULL))
1350 {
1351 ERR("Reserved value was not 0\n");
1352 SetLastError(ERROR_INVALID_PARAMETER);
1353 return FALSE;
1354 }
1355 if (dwFlags != 0)
1356 FIXME("Undocumented flag(s): %lx\n", dwFlags);
1357 return GetUrlCacheEntryInfoA(lpszUrl, lpCacheEntryInfo, lpdwCacheEntryInfoBufSize);
1358 }
1359
1360 /***********************************************************************
1361 * GetUrlCacheEntryInfoA (WININET.@)
1362 *
1363 */
1364 BOOL WINAPI GetUrlCacheEntryInfoA(
1365 IN LPCSTR lpszUrlName,
1366 IN LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1367 IN OUT LPDWORD lpdwCacheEntryInfoBufferSize
1368 )
1369 {
1370 LPURLCACHE_HEADER pHeader;
1371 CACHEFILE_ENTRY * pEntry;
1372 URL_CACHEFILE_ENTRY * pUrlEntry;
1373 URLCACHECONTAINER * pContainer;
1374
1375 TRACE("(%s, %p, %p)\n", debugstr_a(lpszUrlName), lpCacheEntryInfo, lpdwCacheEntryInfoBufferSize);
1376
1377 if (!URLCacheContainers_FindContainerA(lpszUrlName, &pContainer))
1378 return FALSE;
1379
1380 if (!URLCacheContainer_OpenIndex(pContainer))
1381 return FALSE;
1382
1383 if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1384 return FALSE;
1385
1386 if (!URLCache_FindEntryInHash(pHeader, lpszUrlName, &pEntry))
1387 {
1388 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1389 WARN("entry %s not found!\n", debugstr_a(lpszUrlName));
1390 SetLastError(ERROR_FILE_NOT_FOUND);
1391 return FALSE;
1392 }
1393
1394 if (pEntry->dwSignature != URL_SIGNATURE)
1395 {
1396 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1397 FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1398 SetLastError(ERROR_FILE_NOT_FOUND);
1399 return FALSE;
1400 }
1401
1402 pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
1403 TRACE("Found URL: %s\n", debugstr_a((LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl));
1404 if (pUrlEntry->dwOffsetHeaderInfo)
1405 TRACE("Header info: %s\n", debugstr_a((LPSTR)pUrlEntry + pUrlEntry->dwOffsetHeaderInfo));
1406
1407 if (!URLCache_CopyEntry(
1408 pContainer,
1409 pHeader,
1410 lpCacheEntryInfo,
1411 lpdwCacheEntryInfoBufferSize,
1412 pUrlEntry,
1413 FALSE /* ANSI */))
1414 {
1415 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1416 return FALSE;
1417 }
1418 TRACE("Local File Name: %s\n", debugstr_a(lpCacheEntryInfo->lpszLocalFileName));
1419
1420 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1421
1422 return TRUE;
1423 }
1424
1425 /***********************************************************************
1426 * GetUrlCacheEntryInfoW (WININET.@)
1427 *
1428 */
1429 BOOL WINAPI GetUrlCacheEntryInfoW(LPCWSTR lpszUrl,
1430 LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
1431 LPDWORD lpdwCacheEntryInfoBufferSize)
1432 {
1433 LPURLCACHE_HEADER pHeader;
1434 CACHEFILE_ENTRY * pEntry;
1435 URL_CACHEFILE_ENTRY * pUrlEntry;
1436 URLCACHECONTAINER * pContainer;
1437 LPSTR lpszUrlA;
1438 int url_len;
1439
1440 TRACE("(%s, %p, %p)\n", debugstr_w(lpszUrl), lpCacheEntryInfo, lpdwCacheEntryInfoBufferSize);
1441
1442 url_len = WideCharToMultiByte(CP_ACP, 0, lpszUrl, -1, NULL, 0, NULL, NULL);
1443 lpszUrlA = HeapAlloc(GetProcessHeap(), 0, url_len * sizeof(CHAR));
1444 if (!lpszUrlA)
1445 {
1446 SetLastError(ERROR_OUTOFMEMORY);
1447 return FALSE;
1448 }
1449 WideCharToMultiByte(CP_ACP, 0, lpszUrl, -1, lpszUrlA, url_len, NULL, NULL);
1450
1451 if (!URLCacheContainers_FindContainerW(lpszUrl, &pContainer))
1452 {
1453 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1454 return FALSE;
1455 }
1456
1457 if (!URLCacheContainer_OpenIndex(pContainer))
1458 {
1459 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1460 return FALSE;
1461 }
1462
1463 if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1464 {
1465 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1466 return FALSE;
1467 }
1468
1469 if (!URLCache_FindEntryInHash(pHeader, lpszUrlA, &pEntry))
1470 {
1471 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1472 WARN("entry %s not found!\n", debugstr_a(lpszUrlA));
1473 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1474 SetLastError(ERROR_FILE_NOT_FOUND);
1475 return FALSE;
1476 }
1477 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1478
1479 if (pEntry->dwSignature != URL_SIGNATURE)
1480 {
1481 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1482 FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1483 SetLastError(ERROR_FILE_NOT_FOUND);
1484 return FALSE;
1485 }
1486
1487 pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
1488 TRACE("Found URL: %s\n", debugstr_a((LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl));
1489 TRACE("Header info: %s\n", debugstr_a((LPSTR)pUrlEntry + pUrlEntry->dwOffsetHeaderInfo));
1490
1491 if (!URLCache_CopyEntry(
1492 pContainer,
1493 pHeader,
1494 (LPINTERNET_CACHE_ENTRY_INFOA)lpCacheEntryInfo,
1495 lpdwCacheEntryInfoBufferSize,
1496 pUrlEntry,
1497 TRUE /* UNICODE */))
1498 {
1499 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1500 return FALSE;
1501 }
1502 TRACE("Local File Name: %s\n", debugstr_w(lpCacheEntryInfo->lpszLocalFileName));
1503
1504 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1505
1506 return TRUE;
1507 }
1508
1509 /***********************************************************************
1510 * GetUrlCacheEntryInfoExW (WININET.@)
1511 *
1512 */
1513 BOOL WINAPI GetUrlCacheEntryInfoExW(
1514 LPCWSTR lpszUrl,
1515 LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
1516 LPDWORD lpdwCacheEntryInfoBufSize,
1517 LPWSTR lpszReserved,
1518 LPDWORD lpdwReserved,
1519 LPVOID lpReserved,
1520 DWORD dwFlags)
1521 {
1522 TRACE("(%s, %p, %p, %p, %p, %p, %lx)\n",
1523 debugstr_w(lpszUrl),
1524 lpCacheEntryInfo,
1525 lpdwCacheEntryInfoBufSize,
1526 lpszReserved,
1527 lpdwReserved,
1528 lpReserved,
1529 dwFlags);
1530
1531 if ((lpszReserved != NULL) ||
1532 (lpdwReserved != NULL) ||
1533 (lpReserved != NULL))
1534 {
1535 ERR("Reserved value was not 0\n");
1536 SetLastError(ERROR_INVALID_PARAMETER);
1537 return FALSE;
1538 }
1539 if (dwFlags != 0)
1540 FIXME("Undocumented flag(s): %lx\n", dwFlags);
1541 return GetUrlCacheEntryInfoW(lpszUrl, lpCacheEntryInfo, lpdwCacheEntryInfoBufSize);
1542 }
1543
1544 /***********************************************************************
1545 * SetUrlCacheEntryInfoA (WININET.@)
1546 */
1547 BOOL WINAPI SetUrlCacheEntryInfoA(
1548 LPCSTR lpszUrlName,
1549 LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1550 DWORD dwFieldControl)
1551 {
1552 LPURLCACHE_HEADER pHeader;
1553 CACHEFILE_ENTRY * pEntry;
1554 URLCACHECONTAINER * pContainer;
1555
1556 TRACE("(%s, %p, 0x%08lx)\n", debugstr_a(lpszUrlName), lpCacheEntryInfo, dwFieldControl);
1557
1558 if (!URLCacheContainers_FindContainerA(lpszUrlName, &pContainer))
1559 return FALSE;
1560
1561 if (!URLCacheContainer_OpenIndex(pContainer))
1562 return FALSE;
1563
1564 if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1565 return FALSE;
1566
1567 if (!URLCache_FindEntryInHash(pHeader, lpszUrlName, &pEntry))
1568 {
1569 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1570 WARN("entry %s not found!\n", debugstr_a(lpszUrlName));
1571 SetLastError(ERROR_FILE_NOT_FOUND);
1572 return FALSE;
1573 }
1574
1575 if (pEntry->dwSignature != URL_SIGNATURE)
1576 {
1577 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1578 FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1579 SetLastError(ERROR_FILE_NOT_FOUND);
1580 return FALSE;
1581 }
1582
1583 URLCache_SetEntryInfo(
1584 (URL_CACHEFILE_ENTRY *)pEntry,
1585 (const INTERNET_CACHE_ENTRY_INFOW *)lpCacheEntryInfo,
1586 dwFieldControl);
1587
1588 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1589
1590 return TRUE;
1591 }
1592
1593 /***********************************************************************
1594 * SetUrlCacheEntryInfoW (WININET.@)
1595 */
1596 BOOL WINAPI SetUrlCacheEntryInfoW(LPCWSTR lpszUrl, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, DWORD dwFieldControl)
1597 {
1598 LPURLCACHE_HEADER pHeader;
1599 CACHEFILE_ENTRY * pEntry;
1600 URLCACHECONTAINER * pContainer;
1601 LPSTR lpszUrlA;
1602 int url_len;
1603
1604 TRACE("(%s, %p, 0x%08lx)\n", debugstr_w(lpszUrl), lpCacheEntryInfo, dwFieldControl);
1605
1606 url_len = WideCharToMultiByte(CP_ACP, 0, lpszUrl, -1, NULL, 0, NULL, NULL);
1607 lpszUrlA = HeapAlloc(GetProcessHeap(), 0, url_len * sizeof(CHAR));
1608 if (!lpszUrlA)
1609 {
1610 SetLastError(ERROR_OUTOFMEMORY);
1611 return FALSE;
1612 }
1613 WideCharToMultiByte(CP_ACP, 0, lpszUrl, -1, lpszUrlA, url_len, NULL, NULL);
1614
1615 if (!URLCacheContainers_FindContainerW(lpszUrl, &pContainer))
1616 {
1617 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1618 return FALSE;
1619 }
1620
1621 if (!URLCacheContainer_OpenIndex(pContainer))
1622 {
1623 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1624 return FALSE;
1625 }
1626
1627 if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1628 {
1629 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1630 return FALSE;
1631 }
1632
1633 if (!URLCache_FindEntryInHash(pHeader, lpszUrlA, &pEntry))
1634 {
1635 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1636 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1637 WARN("entry %s not found!\n", debugstr_a(lpszUrlA));
1638 SetLastError(ERROR_FILE_NOT_FOUND);
1639 return FALSE;
1640 }
1641 HeapFree(GetProcessHeap(), 0, lpszUrlA);
1642
1643 if (pEntry->dwSignature != URL_SIGNATURE)
1644 {
1645 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1646 FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1647 SetLastError(ERROR_FILE_NOT_FOUND);
1648 return FALSE;
1649 }
1650
1651 URLCache_SetEntryInfo(
1652 (URL_CACHEFILE_ENTRY *)pEntry,
1653 lpCacheEntryInfo,
1654 dwFieldControl);
1655
1656 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1657
1658 return TRUE;
1659 }
1660
1661 /***********************************************************************
1662 * RetrieveUrlCacheEntryFileA (WININET.@)
1663 *
1664 */
1665 BOOL WINAPI RetrieveUrlCacheEntryFileA(
1666 IN LPCSTR lpszUrlName,
1667 OUT LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1668 IN OUT LPDWORD lpdwCacheEntryInfoBufferSize,
1669 IN DWORD dwReserved
1670 )
1671 {
1672 LPURLCACHE_HEADER pHeader;
1673 CACHEFILE_ENTRY * pEntry;
1674 URL_CACHEFILE_ENTRY * pUrlEntry;
1675 URLCACHECONTAINER * pContainer;
1676
1677 TRACE("(%s, %p, %p, 0x%08lx)\n",
1678 debugstr_a(lpszUrlName),
1679 lpCacheEntryInfo,
1680 lpdwCacheEntryInfoBufferSize,
1681 dwReserved);
1682
1683 if (!URLCacheContainers_FindContainerA(lpszUrlName, &pContainer))
1684 return FALSE;
1685
1686 if (!URLCacheContainer_OpenIndex(pContainer))
1687 return FALSE;
1688
1689 if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1690 return FALSE;
1691
1692 if (!URLCache_FindEntryInHash(pHeader, lpszUrlName, &pEntry))
1693 {
1694 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1695 TRACE("entry %s not found!\n", lpszUrlName);
1696 SetLastError(ERROR_FILE_NOT_FOUND);
1697 return FALSE;
1698 }
1699
1700 if (pEntry->dwSignature != URL_SIGNATURE)
1701 {
1702 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1703 FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1704 SetLastError(ERROR_FILE_NOT_FOUND);
1705 return FALSE;
1706 }
1707
1708 pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
1709 TRACE("Found URL: %s\n", (LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl);
1710 TRACE("Header info: %s\n", (LPBYTE)pUrlEntry + pUrlEntry->dwOffsetHeaderInfo);
1711
1712 pUrlEntry->dwHitRate++;
1713 pUrlEntry->dwUseCount++;
1714 URLCache_HashEntrySetUse(pHeader, lpszUrlName, pUrlEntry->dwUseCount);
1715
1716 if (!URLCache_CopyEntry(pContainer, pHeader, lpCacheEntryInfo, lpdwCacheEntryInfoBufferSize, pUrlEntry, FALSE))
1717 {
1718 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1719 return FALSE;
1720 }
1721 TRACE("Local File Name: %s\n", lpCacheEntryInfo->lpszLocalFileName);
1722
1723 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1724
1725 return TRUE;
1726 }
1727
1728 /***********************************************************************
1729 * RetrieveUrlCacheEntryFileW (WININET.@)
1730 *
1731 */
1732 BOOL WINAPI RetrieveUrlCacheEntryFileW(
1733 IN LPCWSTR lpszUrlName,
1734 OUT LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
1735 IN OUT LPDWORD lpdwCacheEntryInfoBufferSize,
1736 IN DWORD dwReserved
1737 )
1738 {
1739 TRACE("(%s, %p, %p, 0x%08lx)\n",
1740 debugstr_w(lpszUrlName),
1741 lpCacheEntryInfo,
1742 lpdwCacheEntryInfoBufferSize,
1743 dwReserved);
1744
1745 return FALSE;
1746 }
1747
1748 /***********************************************************************
1749 * UnlockUrlCacheEntryFileA (WININET.@)
1750 *
1751 */
1752 BOOL WINAPI UnlockUrlCacheEntryFileA(
1753 IN LPCSTR lpszUrlName,
1754 IN DWORD dwReserved
1755 )
1756 {
1757 LPURLCACHE_HEADER pHeader;
1758 CACHEFILE_ENTRY * pEntry;
1759 URL_CACHEFILE_ENTRY * pUrlEntry;
1760 URLCACHECONTAINER * pContainer;
1761
1762 TRACE("(%s, 0x%08lx)\n", debugstr_a(lpszUrlName), dwReserved);
1763
1764 if (dwReserved)
1765 {
1766 ERR("dwReserved != 0\n");
1767 SetLastError(ERROR_INVALID_PARAMETER);
1768 return FALSE;
1769 }
1770
1771 if (!URLCacheContainers_FindContainerA(lpszUrlName, &pContainer))
1772 return FALSE;
1773
1774 if (!URLCacheContainer_OpenIndex(pContainer))
1775 return FALSE;
1776
1777 if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1778 return FALSE;
1779
1780 if (!URLCache_FindEntryInHash(pHeader, lpszUrlName, &pEntry))
1781 {
1782 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1783 TRACE("entry %s not found!\n", lpszUrlName);
1784 SetLastError(ERROR_FILE_NOT_FOUND);
1785 return FALSE;
1786 }
1787
1788 if (pEntry->dwSignature != URL_SIGNATURE)
1789 {
1790 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1791 FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1792 SetLastError(ERROR_FILE_NOT_FOUND);
1793 return FALSE;
1794 }
1795
1796 pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
1797
1798 if (pUrlEntry->dwUseCount == 0)
1799 {
1800 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1801 return FALSE;
1802 }
1803 pUrlEntry->dwUseCount--;
1804 URLCache_HashEntrySetUse(pHeader, lpszUrlName, pUrlEntry->dwUseCount);
1805
1806 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1807
1808 return TRUE;
1809 }
1810
1811 /***********************************************************************
1812 * UnlockUrlCacheEntryFileW (WININET.@)
1813 *
1814 */
1815 BOOL WINAPI UnlockUrlCacheEntryFileW( LPCWSTR lpszUrlName, DWORD dwReserved )
1816 {
1817 FIXME("(%s, 0x%08lx)\n", debugstr_w(lpszUrlName), dwReserved);
1818 return TRUE;
1819 }
1820
1821 /***********************************************************************
1822 * CreateUrlCacheEntryA (WININET.@)
1823 *
1824 */
1825 BOOL WINAPI CreateUrlCacheEntryA(
1826 IN LPCSTR lpszUrlName,
1827 IN DWORD dwExpectedFileSize,
1828 IN LPCSTR lpszFileExtension,
1829 OUT LPSTR lpszFileName,
1830 IN DWORD dwReserved
1831 )
1832 {
1833 DWORD len;
1834 WCHAR *url_name;
1835 WCHAR *file_extension;
1836 WCHAR file_name[MAX_PATH];
1837 BOOL bSuccess = FALSE;
1838 DWORD dwError = 0;
1839
1840 if ((len = MultiByteToWideChar(CP_ACP, 0, lpszUrlName, -1, NULL, 0)) != 0 &&
1841 (url_name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0)
1842 {
1843 MultiByteToWideChar(CP_ACP, 0, lpszUrlName, -1, url_name, len);
1844 if ((len = MultiByteToWideChar(CP_ACP, 0, lpszFileExtension, -1, NULL, 0)) != 0 &&
1845 (file_extension = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0)
1846 {
1847 MultiByteToWideChar(CP_ACP, 0, lpszFileExtension, -1, file_extension, len);
1848 if (CreateUrlCacheEntryW(url_name, dwExpectedFileSize, file_extension, file_name, dwReserved))
1849 {
1850 if (WideCharToMultiByte(CP_ACP, 0, file_name, -1, lpszFileName, MAX_PATH, NULL, NULL) < MAX_PATH)
1851 {
1852 bSuccess = TRUE;
1853 }
1854 else
1855 {
1856 dwError = GetLastError();
1857 }
1858 }
1859 else
1860 {
1861 dwError = GetLastError();
1862 }
1863 HeapFree(GetProcessHeap(), 0, file_extension);
1864 }
1865 else
1866 {
1867 dwError = GetLastError();
1868 }
1869 HeapFree(GetProcessHeap(), 0, url_name);
1870 if (!bSuccess)
1871 SetLastError(dwError);
1872 }
1873 return bSuccess;
1874 }
1875 /***********************************************************************
1876 * CreateUrlCacheEntryW (WININET.@)
1877 *
1878 */
1879 BOOL WINAPI CreateUrlCacheEntryW(
1880 IN LPCWSTR lpszUrlName,
1881 IN DWORD dwExpectedFileSize,
1882 IN LPCWSTR lpszFileExtension,
1883 OUT LPWSTR lpszFileName,
1884 IN DWORD dwReserved
1885 )
1886 {
1887 URLCACHECONTAINER * pContainer;
1888 LPURLCACHE_HEADER pHeader;
1889 CHAR szFile[MAX_PATH];
1890 WCHAR szExtension[MAX_PATH];
1891 LPCWSTR lpszUrlPart;
1892 LPCWSTR lpszUrlEnd;
1893 LPCWSTR lpszFileNameExtension;
1894 LPWSTR lpszFileNameNoPath;
1895 int i;
1896 int countnoextension;
1897 BYTE CacheDir;
1898 LONG lBufferSize;
1899 BOOL bFound = FALSE;
1900 int count;
1901 static const WCHAR szWWW[] = {'w','w','w',0};
1902
1903 TRACE("(%s, 0x%08lx, %s, %p, 0x%08lx)\n",
1904 debugstr_w(lpszUrlName),
1905 dwExpectedFileSize,
1906 debugstr_w(lpszFileExtension),
1907 lpszFileName,
1908 dwReserved);
1909
1910 if (dwReserved)
1911 {
1912 ERR("dwReserved != 0\n");
1913 SetLastError(ERROR_INVALID_PARAMETER);
1914 return FALSE;
1915 }
1916
1917 for (lpszUrlEnd = lpszUrlName; *lpszUrlEnd; lpszUrlEnd++)
1918 ;
1919
1920 if (((lpszUrlEnd - lpszUrlName) > 1) && (*(lpszUrlEnd - 1) == '/' || *(lpszUrlEnd - 1) == '\\'))
1921 lpszUrlEnd--;
1922
1923 for (lpszUrlPart = lpszUrlEnd;
1924 (lpszUrlPart >= lpszUrlName);
1925 lpszUrlPart--)
1926 {
1927 if ((*lpszUrlPart == '/' || *lpszUrlPart == '\\') && ((lpszUrlEnd - lpszUrlPart) > 1))
1928 {
1929 bFound = TRUE;
1930 lpszUrlPart++;
1931 break;
1932 }
1933 }
1934 if (!lstrcmpW(lpszUrlPart, szWWW))
1935 {
1936 lpszUrlPart += lstrlenW(szWWW);
1937 }
1938
1939 count = lpszUrlEnd - lpszUrlPart;
1940
1941 if (bFound && (count < MAX_PATH))
1942 {
1943 int len = WideCharToMultiByte(CP_ACP, 0, lpszUrlPart, count, szFile, sizeof(szFile) - 1, NULL, NULL);
1944 if (!len)
1945 return FALSE;
1946 szFile[len] = '\0';
1947 /* FIXME: get rid of illegal characters like \, / and : */
1948 }
1949 else
1950 {
1951 FIXME("need to generate a random filename\n");
1952 }
1953
1954 TRACE("File name: %s\n", debugstr_a(szFile));
1955
1956 if (!URLCacheContainers_FindContainerW(lpszUrlName, &pContainer))
1957 return FALSE;
1958
1959 if (!URLCacheContainer_OpenIndex(pContainer))
1960 return FALSE;
1961
1962 if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1963 return FALSE;
1964
1965 CacheDir = (BYTE)(rand() % pHeader->DirectoryCount);
1966
1967 lBufferSize = MAX_PATH * sizeof(WCHAR);
1968 URLCache_LocalFileNameToPathW(pContainer, pHeader, szFile, CacheDir, lpszFileName, &lBufferSize);
1969
1970 URLCacheContainer_UnlockIndex(pContainer, pHeader);
1971
1972 for (lpszFileNameNoPath = lpszFileName + lBufferSize / sizeof(WCHAR) - 2;
1973 lpszFileNameNoPath >= lpszFileName;
1974 --lpszFileNameNoPath)
1975 {
1976 if (*lpszFileNameNoPath == '/' || *lpszFileNameNoPath == '\\')
1977 break;
1978 }
1979
1980 countnoextension = lstrlenW(lpszFileNameNoPath);
1981 lpszFileNameExtension = PathFindExtensionW(lpszFileNameNoPath);
1982 if (lpszFileNameExtension)
1983 countnoextension -= lstrlenW(lpszFileNameExtension);
1984 *szExtension = '\0';
1985
1986 if (lpszFileExtension)
1987 {
1988 szExtension[0] = '.';
1989 lstrcpyW(szExtension+1, lpszFileExtension);
1990 }
1991
1992 for (i = 0; i < 255; i++)
1993 {
1994 static const WCHAR szFormat[] = {'[','%','u',']','%','s',0};
1995 HANDLE hFile;
1996 wsprintfW(lpszFileNameNoPath + countnoextension, szFormat, i, szExtension);
1997 TRACE("Trying: %s\n", debugstr_w(lpszFileName));
1998 hFile = CreateFileW(lpszFileName, GENERIC_READ, 0, NULL, CREATE_NEW, 0, NULL);
1999 if (hFile != INVALID_HANDLE_VALUE)
2000 {
2001 CloseHandle(hFile);
2002 return TRUE;
2003 }
2004 }
2005
2006 return FALSE;
2007 }
2008
2009
2010 /***********************************************************************
2011 * CommitUrlCacheEntryInternal (Compensates for an MS bug)
2012 *
2013 * The bug we are compensating for is that some drongo at Microsoft
2014 * used lpHeaderInfo to pass binary data to CommitUrlCacheEntryA.
2015 * As a consequence, CommitUrlCacheEntryA has been effectively
2016 * redefined as LPBYTE rather than LPCSTR. But CommitUrlCacheEntryW
2017 * is still defined as LPCWSTR. The result (other than madness) is
2018 * that we always need to store lpHeaderInfo in CP_ACP rather than
2019 * in UTF16, and we need to avoid converting lpHeaderInfo in
2020 * CommitUrlCacheEntryA to UTF16 and then back to CP_ACP, since the
2021 * result will lose data for arbitrary binary data.
2022 *
2023 */
2024 static BOOL WINAPI CommitUrlCacheEntryInternal(
2025 IN LPCWSTR lpszUrlName,
2026 IN LPCWSTR lpszLocalFileName,
2027 IN FILETIME ExpireTime,
2028 IN FILETIME LastModifiedTime,
2029 IN DWORD CacheEntryType,
2030 IN LPBYTE lpHeaderInfo,
2031 IN DWORD dwHeaderSize,
2032 IN LPCWSTR lpszFileExtension,
2033 IN LPCWSTR lpszOriginalUrl
2034 )
2035 {
2036 URLCACHECONTAINER * pContainer;
2037 LPURLCACHE_HEADER pHeader;
2038 CACHEFILE_ENTRY * pEntry;
2039 URL_CACHEFILE_ENTRY * pUrlEntry;
2040 DWORD dwBytesNeeded = DWORD_ALIGN(sizeof(*pUrlEntry));
2041 DWORD dwOffsetLocalFileName = 0;
2042 DWORD dwOffsetHeader = 0;
2043 DWORD dwFileSizeLow = 0;
2044 DWORD dwFileSizeHigh = 0;
2045 BYTE cDirectory = 0;
2046 char achFile[MAX_PATH];
2047 char achUrl[MAX_PATH];
2048 char *pchLocalFileName = 0;
2049
2050 TRACE("(%s, %s, ..., ..., %lx, %p, %ld, %s, %s)\n",
2051 debugstr_w(lpszUrlName),
2052 debugstr_w(lpszLocalFileName),
2053 CacheEntryType,
2054 lpHeaderInfo,
2055 dwHeaderSize,
2056 debugstr_w(lpszFileExtension),
2057 debugstr_w(lpszOriginalUrl));
2058
2059 if (lpszOriginalUrl)
2060 WARN(": lpszOriginalUrl ignored\n");
2061
2062 if (lpszLocalFileName)
2063 {
2064 HANDLE hFile;
2065
2066 hFile = CreateFileW(lpszLocalFileName, FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL);
2067 if (hFile == INVALID_HANDLE_VALUE)
2068 {
2069 ERR("couldn't open file %s (error is %ld)\n", debugstr_w(lpszLocalFileName), GetLastError());
2070 return FALSE;
2071 }
2072
2073 /* Get file size */
2074 dwFileSizeLow = GetFileSize(hFile, &dwFileSizeHigh);
2075 if ((dwFileSizeLow == INVALID_FILE_SIZE) && (GetLastError() != NO_ERROR))
2076 {
2077 ERR("couldn't get file size (error is %ld)\n", GetLastError());
2078 CloseHandle(hFile);
2079 return FALSE;
2080 }
2081
2082 CloseHandle(hFile);
2083 }
2084
2085 if (!URLCacheContainers_FindContainerW(lpszUrlName, &pContainer))
2086 return FALSE;
2087
2088 if (!URLCacheContainer_OpenIndex(pContainer))
2089 return FALSE;
2090
2091 if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
2092 return FALSE;
2093
2094 WideCharToMultiByte(CP_ACP, 0, lpszUrlName, -1, achUrl, -1, NULL, NULL);
2095
2096 if (URLCache_FindEntryInHash(pHeader, achUrl, &pEntry))
2097 {
2098 URLCacheContainer_UnlockIndex(pContainer, pHeader);
2099 FIXME("entry already in cache - don't know what to do!\n");
2100 /*
2101 * SetLastError(ERROR_FILE_NOT_FOUND);
2102 * return FALSE;
2103 */
2104 return TRUE;
2105 }
2106
2107 if (lpszLocalFileName)
2108 {
2109 BOOL bFound = FALSE;
2110
2111 if (strncmpW(lpszLocalFileName, pContainer->path, lstrlenW(pContainer->path)))
2112 {
2113 URLCacheContainer_UnlockIndex(pContainer, pHeader);
2114 ERR("path %s must begin with cache content path %s\n", debugstr_w(lpszLocalFileName), debugstr_w(pContainer->path));
2115 SetLastError(ERROR_INVALID_PARAMETER);
2116 return FALSE;
2117 }
2118
2119 /* skip container path prefix */
2120 lpszLocalFileName += lstrlenW(pContainer->path);
2121
2122 WideCharToMultiByte(CP_ACP, 0, lpszLocalFileName, -1, achFile, -1, NULL, NULL);
2123 pchLocalFileName = achFile;
2124
2125 for (cDirectory = 0; cDirectory < pHeader->DirectoryCount; cDirectory++)
2126 {
2127 if (!strncmp(pHeader->directory_data[cDirectory].filename, pchLocalFileName, DIR_LENGTH))
2128 {
2129 bFound = TRUE;
2130 break;
2131 }
2132 }
2133
2134 if (!bFound)
2135 {
2136 URLCacheContainer_UnlockIndex(pContainer, pHeader);
2137 ERR("cache directory not found in path %s\n", debugstr_w(lpszLocalFileName));
2138 SetLastError(ERROR_INVALID_PARAMETER);
2139 return FALSE;
2140 }
2141
2142 lpszLocalFileName += (DIR_LENGTH + 1); /* "1234WXYZ\" */
2143 }
2144
2145 dwBytesNeeded = DWORD_ALIGN(dwBytesNeeded + strlen(achUrl) + 1);
2146 if (lpszLocalFileName)
2147 {
2148 dwOffsetLocalFileName = dwBytesNeeded;
2149 dwBytesNeeded = DWORD_ALIGN(dwBytesNeeded + strlen(pchLocalFileName) + 1);
2150 }
2151 if (lpHeaderInfo)
2152 {
2153 dwOffsetHeader = dwBytesNeeded;
2154 dwBytesNeeded = DWORD_ALIGN(dwBytesNeeded + dwHeaderSize);
2155 }
2156
2157 /* round up to next block */
2158 if (dwBytesNeeded % BLOCKSIZE)
2159 {
2160 dwBytesNeeded -= dwBytesNeeded % BLOCKSIZE;
2161 dwBytesNeeded += BLOCKSIZE;
2162 }
2163
2164 if (!URLCache_FindFirstFreeEntry(pHeader, dwBytesNeeded / BLOCKSIZE, &pEntry))
2165 {
2166 URLCacheContainer_UnlockIndex(pContainer, pHeader);
2167 ERR("no free entries\n");
2168 SetLastError(ERROR_DISK_FULL);
2169 return FALSE;
2170 }
2171
2172 /* FindFirstFreeEntry fills in blocks used */
2173 pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
2174 pUrlEntry->CacheFileEntry.dwSignature = URL_SIGNATURE;
2175 pUrlEntry->CacheDir = cDirectory;
2176 pUrlEntry->CacheEntryType = CacheEntryType;
2177 pUrlEntry->dwHeaderInfoSize = dwHeaderSize;
2178 pUrlEntry->dwExemptDelta = 0;
2179 pUrlEntry->dwHitRate = 0;
2180 pUrlEntry->dwOffsetHeaderInfo = dwOffsetHeader;
2181 pUrlEntry->dwOffsetLocalName = dwOffsetLocalFileName;
2182 pUrlEntry->dwOffsetUrl = DWORD_ALIGN(sizeof(*pUrlEntry));
2183 pUrlEntry->dwSizeHigh = 0;
2184 pUrlEntry->dwSizeLow = dwFileSizeLow;
2185 pUrlEntry->dwSizeHigh = dwFileSizeHigh;
2186 pUrlEntry->dwUseCount = 0;
2187 GetSystemTimeAsFileTime(&pUrlEntry->LastAccessTime);
2188 pUrlEntry->LastModifiedTime = LastModifiedTime;
2189 FileTimeToDosDateTime(&pUrlEntry->LastAccessTime, &pUrlEntry->wLastSyncDate, &pUrlEntry->wLastSyncTime);
2190 FileTimeToDosDateTime(&ExpireTime, &pUrlEntry->wExpiredDate, &pUrlEntry->wExpiredTime);
2191 pUrlEntry->wUnknownDate = pUrlEntry->wLastSyncDate;
2192 pUrlEntry->wUnknownTime = pUrlEntry->wLastSyncTime;
2193
2194 /*** Unknowns ***/
2195 pUrlEntry->dwUnknown1 = 0;
2196 pUrlEntry->dwUnknown2 = 0;
2197 pUrlEntry->dwUnknown3 = 0x60;
2198 pUrlEntry->Unknown4 = 0;
2199 pUrlEntry->wUnknown5 = 0x1010;
2200 pUrlEntry->dwUnknown6 = 0;
2201 pUrlEntry->dwUnknown7 = 0;
2202 pUrlEntry->dwUnknown8 = 0;
2203
2204
2205 strcpy((LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl, achUrl);
2206 if (dwOffsetLocalFileName)
2207 strcpy((LPSTR)((LPBYTE)pUrlEntry + dwOffsetLocalFileName), pchLocalFileName + DIR_LENGTH + 1);
2208 if (dwOffsetHeader)
2209 memcpy((LPBYTE)pUrlEntry + dwOffsetHeader, lpHeaderInfo, dwHeaderSize);
2210
2211 if (!URLCache_AddEntryToHash(pHeader, achUrl, (DWORD)((LPBYTE)pUrlEntry - (LPBYTE)pHeader)))
2212 {
2213 URLCache_DeleteEntry(pHeader, &pUrlEntry->CacheFileEntry);
2214 URLCacheContainer_UnlockIndex(pContainer, pHeader);
2215 return FALSE;
2216 }
2217
2218 URLCacheContainer_UnlockIndex(pContainer, pHeader);
2219
2220 return TRUE;
2221 }
2222
2223 /***********************************************************************
2224 * CommitUrlCacheEntryA (WININET.@)
2225 *
2226 */
2227 BOOL WINAPI CommitUrlCacheEntryA(
2228 IN LPCSTR lpszUrlName,
2229 IN LPCSTR lpszLocalFileName,
2230 IN FILETIME ExpireTime,
2231 IN FILETIME LastModifiedTime,
2232 IN DWORD CacheEntryType,
2233 IN LPBYTE lpHeaderInfo,
2234 IN DWORD dwHeaderSize,
2235 IN LPCSTR lpszFileExtension,
2236 IN LPCSTR lpszOriginalUrl
2237 )
2238 {
2239 DWORD len;
2240 WCHAR *url_name;
2241 WCHAR *local_file_name;
2242 WCHAR *original_url = NULL;
2243 BOOL bSuccess = FALSE;
2244 DWORD dwError = 0;
2245
2246 TRACE("(%s, %s, ..., ..., %lx, %p, %ld, %s, %s)\n",
2247 debugstr_a(lpszUrlName),
2248 debugstr_a(lpszLocalFileName),
2249 CacheEntryType,
2250 lpHeaderInfo,
2251 dwHeaderSize,
2252 debugstr_a(lpszFileExtension),
2253 debugstr_a(lpszOriginalUrl));
2254
2255 if (lpszFileExtension != 0)
2256 {
2257 SetLastError(ERROR_INVALID_PARAMETER);
2258 return FALSE;
2259 }
2260 if ((len = MultiByteToWideChar(CP_ACP, 0, lpszUrlName, -1, NULL, 0)) != 0 &&
2261 (url_name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0)
2262 {
2263 MultiByteToWideChar(CP_ACP, 0, lpszUrlName, -1, url_name, len);
2264 if ((len = MultiByteToWideChar(CP_ACP, 0, lpszLocalFileName, -1, NULL, 0)) != 0 &&
2265 (local_file_name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0)
2266 {
2267 MultiByteToWideChar(CP_ACP, 0, lpszLocalFileName, -1, local_file_name, len);
2268 if (!lpszOriginalUrl ||
2269 ((len = MultiByteToWideChar(CP_ACP, 0, lpszOriginalUrl, -1, NULL, 0)) != 0 &&
2270 (original_url = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0))
2271 {
2272 if (original_url)
2273 MultiByteToWideChar(CP_ACP, 0, lpszOriginalUrl, -1, original_url, len);
2274 if (CommitUrlCacheEntryInternal(url_name, local_file_name, ExpireTime, LastModifiedTime,
2275 CacheEntryType, lpHeaderInfo, dwHeaderSize,
2276 NULL, original_url))
2277 {
2278 bSuccess = TRUE;
2279 }
2280 else
2281 {
2282 dwError = GetLastError();
2283 }
2284 HeapFree(GetProcessHeap(), 0, original_url);
2285 }
2286 else
2287 {
2288 dwError = GetLastError();
2289 }
2290 HeapFree(GetProcessHeap(), 0, local_file_name);
2291 }
2292 else
2293 {
2294 dwError = GetLastError();
2295 }
2296 HeapFree(GetProcessHeap(), 0, url_name);
2297 if (!bSuccess)
2298 SetLastError(dwError);
2299 }
2300 return bSuccess;
2301 }
2302
2303 /***********************************************************************
2304 * CommitUrlCacheEntryW (WININET.@)
2305 *
2306 */
2307 BOOL WINAPI CommitUrlCacheEntryW(
2308 IN LPCWSTR lpszUrlName,
2309 IN LPCWSTR lpszLocalFileName,
2310 IN FILETIME ExpireTime,
2311 IN FILETIME LastModifiedTime,
2312 IN DWORD CacheEntryType,
2313 IN LPWSTR lpHeaderInfo,
2314 IN DWORD dwHeaderSize,
2315 IN LPCWSTR lpszFileExtension,
2316 IN LPCWSTR lpszOriginalUrl
2317 )
2318 {
2319 DWORD dwError = 0;
2320 BOOL bSuccess = FALSE;
2321 DWORD len = 0;
2322 CHAR *header_info = NULL;
2323
2324 TRACE("(%s, %s, ..., ..., %lx, %p, %ld, %s, %s)\n",
2325 debugstr_w(lpszUrlName),
2326 debugstr_w(lpszLocalFileName),
2327 CacheEntryType,
2328 lpHeaderInfo,
2329 dwHeaderSize,
2330 debugstr_w(lpszFileExtension),
2331 debugstr_w(lpszOriginalUrl));
2332
2333 if (!lpHeaderInfo ||
2334 ((len = WideCharToMultiByte(CP_ACP, 0, lpHeaderInfo, -1, NULL, 0, NULL, NULL)) != 0 &&
2335 (header_info = HeapAlloc(GetProcessHeap(), 0, sizeof(CHAR) * len)) != 0))
2336 {
2337 if (header_info)
2338 WideCharToMultiByte(CP_ACP, 0, lpHeaderInfo, -1, header_info, len, NULL, NULL);
2339 if (CommitUrlCacheEntryInternal(lpszUrlName, lpszLocalFileName, ExpireTime, LastModifiedTime,
2340 CacheEntryType, (LPBYTE)header_info, len, lpszFileExtension, lpszOriginalUrl))
2341 {
2342 bSuccess = TRUE;
2343 }
2344 else
2345 {
2346 dwError = GetLastError();
2347 }
2348 if (header_info)
2349 {
2350 HeapFree(GetProcessHeap(), 0, header_info);
2351 if (!bSuccess)
2352 SetLastError(dwError);
2353 }
2354 }
2355 return bSuccess;
2356 }
2357
2358 /***********************************************************************
2359 * ReadUrlCacheEntryStream (WININET.@)
2360 *
2361 */
2362 BOOL WINAPI ReadUrlCacheEntryStream(
2363 IN HANDLE hUrlCacheStream,
2364 IN DWORD dwLocation,
2365 IN OUT LPVOID lpBuffer,
2366 IN OUT LPDWORD lpdwLen,
2367 IN DWORD dwReserved
2368 )
2369 {
2370 /* Get handle to file from 'stream' */
2371 STREAM_HANDLE * pStream = (STREAM_HANDLE *)hUrlCacheStream;
2372
2373 if (dwReserved != 0)
2374 {
2375 ERR("dwReserved != 0\n");
2376 SetLastError(ERROR_INVALID_PARAMETER);
2377 return FALSE;
2378 }
2379
2380 if (IsBadReadPtr(pStream, sizeof(*pStream)) || IsBadStringPtrA(pStream->lpszUrl, INTERNET_MAX_URL_LENGTH))
2381 {
2382 SetLastError(ERROR_INVALID_HANDLE);
2383 return FALSE;
2384 }
2385
2386 if (SetFilePointer(pStream->hFile, dwLocation, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
2387 return FALSE;
2388 return ReadFile(pStream->hFile, lpBuffer, *lpdwLen, lpdwLen, NULL);
2389 }
2390
2391 /***********************************************************************
2392 * RetrieveUrlCacheEntryStreamA (WININET.@)
2393 *
2394 */
2395 HANDLE WINAPI RetrieveUrlCacheEntryStreamA(
2396 IN LPCSTR lpszUrlName,
2397 OUT LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
2398 IN OUT LPDWORD lpdwCacheEntryInfoBufferSize,
2399 IN BOOL fRandomRead,
2400 IN DWORD dwReserved
2401 )
2402 {
2403 /* NOTE: this is not the same as the way that the native
2404 * version allocates 'stream' handles. I did it this way
2405 * as it is much easier and no applications should depend
2406 * on this behaviour. (Native version appears to allocate
2407 * indices into a table)
2408 */
2409 STREAM_HANDLE * pStream;
2410 HANDLE hFile;
2411
2412 TRACE( "(%s, %p, %p, %x, 0x%08lx)\n", debugstr_a(lpszUrlName), lpCacheEntryInfo,
2413 lpdwCacheEntryInfoBufferSize, fRandomRead, dwReserved );
2414
2415 if (!RetrieveUrlCacheEntryFileA(lpszUrlName,
2416 lpCacheEntryInfo,
2417 lpdwCacheEntryInfoBufferSize,
2418 dwReserved))
2419 {
2420 return NULL;
2421 }
2422
2423 hFile = CreateFileA(lpCacheEntryInfo->lpszLocalFileName,
2424 GENERIC_READ,
2425 FILE_SHARE_READ,
2426 NULL,
2427 OPEN_EXISTING,
2428 fRandomRead ? FILE_FLAG_RANDOM_ACCESS : 0,
2429 NULL);
2430 if (hFile == INVALID_HANDLE_VALUE)
2431 return FALSE;
2432
2433 /* allocate handle storage space */
2434 pStream = HeapAlloc(GetProcessHeap(), 0, sizeof(STREAM_HANDLE) + strlen(lpszUrlName) * sizeof(CHAR));
2435 if (!pStream)
2436 {
2437 CloseHandle(hFile);
2438 SetLastError(ERROR_OUTOFMEMORY);
2439 return FALSE;
2440 }
2441
2442 pStream->hFile = hFile;
2443 strcpy(pStream->lpszUrl, lpszUrlName);
2444 return (HANDLE)pStream;
2445 }
2446
2447 /***********************************************************************
2448 * RetrieveUrlCacheEntryStreamW (WININET.@)
2449 *
2450 */
2451 HANDLE WINAPI RetrieveUrlCacheEntryStreamW(
2452 IN LPCWSTR lpszUrlName,
2453 OUT LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
2454 IN OUT LPDWORD lpdwCacheEntryInfoBufferSize,
2455 IN BOOL fRandomRead,
2456 IN DWORD dwReserved
2457 )
2458 {
2459 FIXME( "(%s, %p, %p, %x, 0x%08lx)\n", debugstr_w(lpszUrlName), lpCacheEntryInfo,
2460 lpdwCacheEntryInfoBufferSize, fRandomRead, dwReserved );
2461 return NULL;
2462 }
2463
2464 /***********************************************************************
2465 * UnlockUrlCacheEntryStream (WININET.@)
2466 *
2467 */
2468 BOOL WINAPI UnlockUrlCacheEntryStream(
2469 IN HANDLE hUrlCacheStream,
2470 IN DWORD dwReserved
2471 )
2472 {
2473 STREAM_HANDLE * pStream = (STREAM_HANDLE *)hUrlCacheStream;
2474
2475 if (dwReserved != 0)
2476 {
2477 ERR("dwReserved != 0\n");
2478 SetLastError(ERROR_INVALID_PARAMETER);
2479 return FALSE;
2480 }
2481
2482 if (IsBadReadPtr(pStream, sizeof(*pStream)) || IsBadStringPtrA(pStream->lpszUrl, INTERNET_MAX_URL_LENGTH))
2483 {
2484 SetLastError(ERROR_INVALID_HANDLE);
2485 return FALSE;
2486 }
2487
2488 if (!UnlockUrlCacheEntryFileA(pStream->lpszUrl, 0))
2489 return FALSE;
2490
2491 /* close file handle */
2492 CloseHandle(pStream->hFile);
2493
2494 /* free allocated space */
2495 HeapFree(GetProcessHeap(), 0, pStream);
2496
2497 return TRUE;
2498 }
2499
2500
2501 /***********************************************************************
2502 * DeleteUrlCacheEntryA (WININET.@)
2503 *
2504 */
2505 BOOL WINAPI DeleteUrlCacheEntryA(LPCSTR lpszUrlName)
2506 {
2507 URLCACHECONTAINER * pContainer;
2508 LPURLCACHE_HEADER pHeader;
2509 CACHEFILE_ENTRY * pEntry;
2510
2511 TRACE("(%s)\n", debugstr_a(lpszUrlName));
2512
2513 if (!URLCacheContainers_FindContainerA(lpszUrlName, &pContainer))
2514 return FALSE;
2515
2516 if (!URLCacheContainer_OpenIndex(pContainer))
2517 return FALSE;
2518
2519 if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
2520 return FALSE;
2521
2522 if (!URLCache_FindEntryInHash(pHeader, lpszUrlName, &pEntry))
2523 {
2524 URLCacheContainer_UnlockIndex(pContainer, pHeader);
2525 TRACE("entry %s not found!\n", lpszUrlName);
2526 SetLastError(ERROR_FILE_NOT_FOUND);
2527 return FALSE;
2528 }
2529
2530 URLCache_DeleteEntry(pHeader, pEntry);
2531
2532 URLCache_DeleteEntryFromHash(pHeader, lpszUrlName);
2533
2534 URLCacheContainer_UnlockIndex(pContainer, pHeader);
2535
2536 return TRUE;
2537 }
2538
2539 /***********************************************************************
2540 * DeleteUrlCacheEntryW (WININET.@)
2541 *
2542 */
2543 BOOL WINAPI DeleteUrlCacheEntryW(LPCWSTR lpszUrlName)
2544 {
2545 FIXME("(%s) stub\n", debugstr_w(lpszUrlName));
2546 return TRUE;
2547 }
2548
2549 BOOL WINAPI DeleteUrlCacheContainerA(DWORD d1, DWORD d2)
2550 {
2551 FIXME("(0x%08lx, 0x%08lx) stub\n", d1, d2);
2552 return TRUE;
2553 }
2554
2555 BOOL WINAPI DeleteUrlCacheContainerW(DWORD d1, DWORD d2)
2556 {
2557 FIXME("(0x%08lx, 0x%08lx) stub\n", d1, d2);
2558 return TRUE;
2559 }
2560
2561 /***********************************************************************
2562 * CreateCacheContainerA (WININET.@)
2563 */
2564 BOOL WINAPI CreateUrlCacheContainerA(DWORD d1, DWORD d2, DWORD d3, DWORD d4,
2565 DWORD d5, DWORD d6, DWORD d7, DWORD d8)
2566 {
2567 FIXME("(0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx) stub\n",
2568 d1, d2, d3, d4, d5, d6, d7, d8);
2569 return TRUE;
2570 }
2571
2572 /***********************************************************************
2573 * CreateCacheContainerW (WININET.@)
2574 */
2575 BOOL WINAPI CreateUrlCacheContainerW(DWORD d1, DWORD d2, DWORD d3, DWORD d4,
2576 DWORD d5, DWORD d6, DWORD d7, DWORD d8)
2577 {
2578 FIXME("(0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx) stub\n",
2579 d1, d2, d3, d4, d5, d6, d7, d8);
2580 return TRUE;
2581 }
2582
2583 /***********************************************************************
2584 * FindCloseUrlCache (WININET.@)
2585 */
2586 BOOL WINAPI FindCloseUrlCache(HANDLE hEnumHandle)
2587 {
2588 FIXME("(%p) stub\n", hEnumHandle);
2589 return TRUE;
2590 }
2591
2592 /***********************************************************************
2593 * FindFirstUrlCacheContainerA (WININET.@)
2594 */
2595 HANDLE WINAPI FindFirstUrlCacheContainerA( LPVOID p1, LPVOID p2, LPVOID p3, DWORD d1 )
2596 {
2597 FIXME("(%p, %p, %p, 0x%08lx) stub\n", p1, p2, p3, d1 );
2598 return NULL;
2599 }
2600
2601 /***********************************************************************
2602 * FindFirstUrlCacheContainerW (WININET.@)
2603 */
2604 HANDLE WINAPI FindFirstUrlCacheContainerW( LPVOID p1, LPVOID p2, LPVOID p3, DWORD d1 )
2605 {
2606 FIXME("(%p, %p, %p, 0x%08lx) stub\n", p1, p2, p3, d1 );
2607 return NULL;
2608 }
2609
2610 /***********************************************************************
2611 * FindNextUrlCacheContainerA (WININET.@)
2612 */
2613 BOOL WINAPI FindNextUrlCacheContainerA( HANDLE handle, LPVOID p1, LPVOID p2 )
2614 {
2615 FIXME("(%p, %p, %p) stub\n", handle, p1, p2 );
2616 return FALSE;
2617 }
2618
2619 /***********************************************************************
2620 * FindNextUrlCacheContainerW (WININET.@)
2621 */
2622 BOOL WINAPI FindNextUrlCacheContainerW( HANDLE handle, LPVOID p1, LPVOID p2 )
2623 {
2624 FIXME("(%p, %p, %p) stub\n", handle, p1, p2 );
2625 return FALSE;
2626 }
2627
2628 HANDLE WINAPI FindFirstUrlCacheEntryExA(
2629 LPCSTR lpszUrlSearchPattern,
2630 DWORD dwFlags,
2631 DWORD dwFilter,
2632 GROUPID GroupId,
2633 LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo,
2634 LPDWORD lpdwFirstCacheEntryInfoBufferSize,
2635 LPVOID lpReserved,
2636 LPDWORD pcbReserved2,
2637 LPVOID lpReserved3
2638 )
2639 {
2640 FIXME("(%s, 0x%08lx, 0x%08lx, 0x%08lx%08lx, %p, %p, %p, %p, %p) stub\n", debugstr_a(lpszUrlSearchPattern),
2641 dwFlags, dwFilter, (ULONG)(GroupId >> 32), (ULONG)GroupId, lpFirstCacheEntryInfo,
2642 lpdwFirstCacheEntryInfoBufferSize, lpReserved, pcbReserved2,lpReserved3);
2643 SetLastError(ERROR_FILE_NOT_FOUND);
2644 return NULL;
2645 }
2646
2647 HANDLE WINAPI FindFirstUrlCacheEntryExW(
2648 LPCWSTR lpszUrlSearchPattern,
2649 DWORD dwFlags,
2650 DWORD dwFilter,
2651 GROUPID GroupId,
2652 LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo,
2653 LPDWORD lpdwFirstCacheEntryInfoBufferSize,
2654 LPVOID lpReserved,
2655 LPDWORD pcbReserved2,
2656 LPVOID lpReserved3
2657 )
2658 {
2659 FIXME("(%s, 0x%08lx, 0x%08lx, 0x%08lx%08lx, %p, %p, %p, %p, %p) stub\n", debugstr_w(lpszUrlSearchPattern),
2660 dwFlags, dwFilter, (ULONG)(GroupId >> 32), (ULONG)GroupId, lpFirstCacheEntryInfo,
2661 lpdwFirstCacheEntryInfoBufferSize, lpReserved, pcbReserved2,lpReserved3);
2662 SetLastError(ERROR_FILE_NOT_FOUND);
2663 return NULL;
2664 }
2665
2666 /***********************************************************************
2667 * FindFirstUrlCacheEntryA (WININET.@)
2668 *
2669 */
2670 INTERNETAPI HANDLE WINAPI FindFirstUrlCacheEntryA(LPCSTR lpszUrlSearchPattern,
2671 LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize)
2672 {
2673 FIXME("(%s, %p, %p): stub\n", debugstr_a(lpszUrlSearchPattern), lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize);
2674 SetLastError(ERROR_FILE_NOT_FOUND);
2675 return 0;
2676 }
2677
2678 /***********************************************************************
2679 * FindFirstUrlCacheEntryW (WININET.@)
2680 *
2681 */
2682 INTERNETAPI HANDLE WINAPI FindFirstUrlCacheEntryW(LPCWSTR lpszUrlSearchPattern,
2683 LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo, LPDWORD lpdwFirstCacheEntryInfoBufferSize)
2684 {
2685 FIXME("(%s, %p, %p): stub\n", debugstr_w(lpszUrlSearchPattern), lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize);
2686 return 0;
2687 }
2688
2689 HANDLE WINAPI FindFirstUrlCacheGroup( DWORD dwFlags, DWORD dwFilter, LPVOID lpSearchCondition,
2690 DWORD dwSearchCondition, GROUPID* lpGroupId, LPVOID lpReserved )
2691 {
2692 FIXME("(0x%08lx, 0x%08lx, %p, 0x%08lx, %p, %p) stub\n", dwFlags, dwFilter, lpSearchCondition,
2693 dwSearchCondition, lpGroupId, lpReserved);
2694 return NULL;
2695 }
2696
2697 BOOL WINAPI FindNextUrlCacheEntryA(
2698 HANDLE hEnumHandle,
2699 LPINTERNET_CACHE_ENTRY_INFOA lpNextCacheEntryInfo,
2700 LPDWORD lpdwNextCacheEntryInfoBufferSize
2701 )
2702 {
2703 FIXME("(%p, %p, %p) stub\n", hEnumHandle, lpNextCacheEntryInfo, lpdwNextCacheEntryInfoBufferSize);
2704 return FALSE;
2705 }
2706
2707 BOOL WINAPI FindNextUrlCacheEntryW(
2708 HANDLE hEnumHandle,
2709 LPINTERNET_CACHE_ENTRY_INFOW lpNextCacheEntryInfo,
2710 LPDWORD lpdwNextCacheEntryInfoBufferSize
2711 )
2712 {
2713 FIXME("(%p, %p, %p) stub\n", hEnumHandle, lpNextCacheEntryInfo, lpdwNextCacheEntryInfoBufferSize);
2714 return FALSE;
2715 }
2716
2717 BOOL WINAPI FindNextUrlCacheEntryExA(
2718 HANDLE hEnumHandle,
2719 LPINTERNET_CACHE_ENTRY_INFOA lpFirstCacheEntryInfo,
2720 LPDWORD lpdwFirstCacheEntryInfoBufferSize,
2721 LPVOID lpReserved,
2722 LPDWORD pcbReserved2,
2723 LPVOID lpReserved3
2724 )
2725 {
2726 FIXME("(%p, %p, %p, %p, %p, %p) stub\n", hEnumHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize,
2727 lpReserved, pcbReserved2, lpReserved3);
2728 return FALSE;
2729 }
2730
2731 BOOL WINAPI FindNextUrlCacheEntryExW(
2732 HANDLE hEnumHandle,
2733 LPINTERNET_CACHE_ENTRY_INFOW lpFirstCacheEntryInfo,
2734 LPDWORD lpdwFirstCacheEntryInfoBufferSize,
2735 LPVOID lpReserved,
2736 LPDWORD pcbReserved2,
2737 LPVOID lpReserved3
2738 )
2739 {
2740 FIXME("(%p, %p, %p, %p, %p, %p) stub\n", hEnumHandle, lpFirstCacheEntryInfo, lpdwFirstCacheEntryInfoBufferSize,
2741 lpReserved, pcbReserved2, lpReserved3);
2742 return FALSE;
2743 }
2744
2745 BOOL WINAPI FindNextUrlCacheGroup( HANDLE hFind, GROUPID* lpGroupId, LPVOID lpReserved )
2746 {
2747 FIXME("(%p, %p, %p) stub\n", hFind, lpGroupId, lpReserved);
2748 return FALSE;
2749 }
2750
2751 /***********************************************************************
2752 * CreateUrlCacheGroup (WININET.@)
2753 *
2754 */
2755 INTERNETAPI GROUPID WINAPI CreateUrlCacheGroup(DWORD dwFlags, LPVOID lpReserved)
2756 {
2757 FIXME("(0x%08lx, %p): stub\n", dwFlags, lpReserved);
2758 return FALSE;
2759 }
2760
2761 /***********************************************************************
2762 * DeleteUrlCacheGroup (WININET.@)
2763 *
2764 */
2765 BOOL WINAPI DeleteUrlCacheGroup(GROUPID GroupId, DWORD dwFlags, LPVOID lpReserved)
2766 {
2767 FIXME("(0x%08lx%08lx, 0x%08lx, %p) stub\n",
2768 (ULONG)(GroupId >> 32), (ULONG)GroupId, dwFlags, lpReserved);
2769 return FALSE;
2770 }
2771
2772 /***********************************************************************
2773 * SetUrlCacheEntryGroupA (WININET.@)
2774 *
2775 */
2776 BOOL WINAPI SetUrlCacheEntryGroupA(LPCSTR lpszUrlName, DWORD dwFlags,
2777 GROUPID GroupId, LPBYTE pbGroupAttributes, DWORD cbGroupAttributes,
2778 LPVOID lpReserved)
2779 {
2780 FIXME("(%s, 0x%08lx, 0x%08lx%08lx, %p, 0x%08lx, %p) stub\n",
2781 debugstr_a(lpszUrlName), dwFlags, (ULONG)(GroupId >> 32), (ULONG)GroupId,
2782 pbGroupAttributes, cbGroupAttributes, lpReserved);
2783 SetLastError(ERROR_FILE_NOT_FOUND);
2784 return FALSE;
2785 }
2786
2787 /***********************************************************************
2788 * SetUrlCacheEntryGroupW (WININET.@)
2789 *
2790 */
2791 BOOL WINAPI SetUrlCacheEntryGroupW(LPCWSTR lpszUrlName, DWORD dwFlags,
2792 GROUPID GroupId, LPBYTE pbGroupAttributes, DWORD cbGroupAttributes,
2793 LPVOID lpReserved)
2794 {
2795 FIXME("(%s, 0x%08lx, 0x%08lx%08lx, %p, 0x%08lx, %p) stub\n",
2796 debugstr_w(lpszUrlName), dwFlags, (ULONG)(GroupId >> 32), (ULONG)GroupId,
2797 pbGroupAttributes, cbGroupAttributes, lpReserved);
2798 SetLastError(ERROR_FILE_NOT_FOUND);
2799 return FALSE;
2800 }
2801
2802 /***********************************************************************
2803 * GetUrlCacheConfigInfoW (WININET.@)
2804 */
2805 BOOL WINAPI GetUrlCacheConfigInfoW(LPDWORD CacheInfo, LPDWORD size, DWORD bitmask)
2806 {
2807 FIXME("(%p, %p, %lx)\n", CacheInfo, size, bitmask);
2808 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2809 return FALSE;
2810 }
2811
2812 /***********************************************************************
2813 * GetUrlCacheConfigInfoA (WININET.@)
2814 *
2815 * CacheInfo is some CACHE_CONFIG_INFO structure, with no MS info found by google
2816 */
2817 BOOL WINAPI GetUrlCacheConfigInfoA(LPDWORD CacheInfo, LPDWORD size, DWORD bitmask)
2818 {
2819 FIXME("(%p, %p, %lx)\n", CacheInfo, size, bitmask);
2820 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
2821 return FALSE;
2822 }
2823
2824 BOOL WINAPI GetUrlCacheGroupAttributeA( GROUPID gid, DWORD dwFlags, DWORD dwAttributes,
2825 LPINTERNET_CACHE_GROUP_INFOA lpGroupInfo,
2826 LPDWORD lpdwGroupInfo, LPVOID lpReserved )
2827 {
2828 FIXME("(0x%08lx%08lx, 0x%08lx, 0x%08lx, %p, %p, %p) stub\n",
2829 (ULONG)(gid >> 32), (ULONG)gid, dwFlags, dwAttributes, lpGroupInfo,
2830 lpdwGroupInfo, lpReserved);
2831 return FALSE;
2832 }
2833
2834 BOOL WINAPI GetUrlCacheGroupAttributeW( GROUPID gid, DWORD dwFlags, DWORD dwAttributes,
2835 LPINTERNET_CACHE_GROUP_INFOW lpGroupInfo,
2836 LPDWORD lpdwGroupInfo, LPVOID lpReserved )
2837 {
2838 FIXME("(0x%08lx%08lx, 0x%08lx, 0x%08lx, %p, %p, %p) stub\n",
2839 (ULONG)(gid >> 32), (ULONG)gid, dwFlags, dwAttributes, lpGroupInfo,
2840 lpdwGroupInfo, lpReserved);
2841 return FALSE;
2842 }
2843
2844 BOOL WINAPI SetUrlCacheGroupAttributeA( GROUPID gid, DWORD dwFlags, DWORD dwAttributes,
2845 LPINTERNET_CACHE_GROUP_INFOA lpGroupInfo, LPVOID lpReserved )
2846 {
2847 FIXME("(0x%08lx%08lx, 0x%08lx, 0x%08lx, %p, %p) stub\n",
2848 (ULONG)(gid >> 32), (ULONG)gid, dwFlags, dwAttributes, lpGroupInfo, lpReserved);
2849 return TRUE;
2850 }
2851
2852 BOOL WINAPI SetUrlCacheGroupAttributeW( GROUPID gid, DWORD dwFlags, DWORD dwAttributes,
2853 LPINTERNET_CACHE_GROUP_INFOW lpGroupInfo, LPVOID lpReserved )
2854 {
2855 FIXME("(0x%08lx%08lx, 0x%08lx, 0x%08lx, %p, %p) stub\n",
2856 (ULONG)(gid >> 32), (ULONG)gid, dwFlags, dwAttributes, lpGroupInfo, lpReserved);
2857 return TRUE;
2858 }
2859
2860 BOOL WINAPI SetUrlCacheConfigInfoA( LPDWORD lpCacheConfigInfo, DWORD dwFieldControl )
2861 {
2862 FIXME("(%p, 0x%08lx) stub\n", lpCacheConfigInfo, dwFieldControl);
2863 return TRUE;
2864 }
2865
2866 BOOL WINAPI SetUrlCacheConfigInfoW( LPDWORD lpCacheConfigInfo, DWORD dwFieldControl )
2867 {
2868 FIXME("(%p, 0x%08lx) stub\n", lpCacheConfigInfo, dwFieldControl);
2869 return TRUE;
2870 }
2871
2872 /***********************************************************************
2873 * DeleteIE3Cache (WININET.@)
2874 *
2875 * Deletes the files used by the IE3 URL caching system.
2876 *
2877 * PARAMS
2878 * hWnd [I] A dummy window.
2879 * hInst [I] Instance of process calling the function.
2880 * lpszCmdLine [I] Options used by function.
2881 * nCmdShow [I] The nCmdShow value to use when showing windows created, if any.
2882 *
2883 * RETURNS
2884 * nothing
2885 */
2886 void WINAPI DeleteIE3Cache(HWND hWnd, HINSTANCE hInst, LPSTR lpszCmdLine, int nCmdShow)
2887 {
2888 FIXME("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_a(lpszCmdLine), nCmdShow);
2889 }
useful hacks and other patches not (yet) suitable for mainline