git.oblomov.eu Git - wine/blob - dlls/wininet/urlcache.c

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
 564         strcpyW(wszMutexName, wszCachePath);
 565
 566         if (suffix_len)
 567         {
 568             memcpy(wszCachePath + path_len + 1, DefaultContainerData[i].shpath_suffix, (suffix_len + 1) * sizeof(WCHAR));
 569             wszCachePath[path_len + suffix_len + 1] = '\\';
 570             wszCachePath[path_len + suffix_len + 2] = '\0';
 571         }
 572
 573         URLCacheContainers_AddContainer(DefaultContainerData[i].cache_prefix, wszCachePath, wszMutexName);
 574     }
 575 }
 576
 577 void URLCacheContainers_DeleteAll(void)
 578 {
 579     while(!list_empty(&UrlContainers))
 580         URLCacheContainer_DeleteContainer(
 581             LIST_ENTRY(list_head(&UrlContainers), URLCACHECONTAINER, entry)
 582         );
 583 }
 584
 585 static BOOL URLCacheContainers_FindContainerW(LPCWSTR lpwszUrl, URLCACHECONTAINER ** ppContainer)
 586 {
 587     struct list * cursor;
 588
 589     TRACE("searching for prefix for URL: %s\n", debugstr_w(lpwszUrl));
 590
 591     LIST_FOR_EACH(cursor, &UrlContainers)
 592     {
 593         URLCACHECONTAINER * pContainer = LIST_ENTRY(cursor, URLCACHECONTAINER, entry);
 594         int prefix_len = strlenW(pContainer->cache_prefix);
 595         if (!strncmpW(pContainer->cache_prefix, lpwszUrl, prefix_len))
 596         {
 597             TRACE("found container with prefx %s for URL %s\n", debugstr_w(pContainer->cache_prefix), debugstr_w(lpwszUrl));
 598             *ppContainer = pContainer;
 599             return TRUE;
 600         }
 601     }
 602     ERR("no container found\n");
 603     SetLastError(ERROR_FILE_NOT_FOUND);
 604     return FALSE;
 605 }
 606
 607 static BOOL URLCacheContainers_FindContainerA(LPCSTR lpszUrl, URLCACHECONTAINER ** ppContainer)
 608 {
 609     BOOL ret;
 610     LPWSTR lpwszUrl;
 611     int url_len = MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, NULL, 0);
 612     if (url_len && (lpwszUrl = HeapAlloc(GetProcessHeap(), 0, url_len * sizeof(WCHAR))))
 613     {
 614         MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, lpwszUrl, url_len);
 615         ret = URLCacheContainers_FindContainerW(lpwszUrl, ppContainer);
 616         HeapFree(GetProcessHeap(), 0, lpwszUrl);
 617         return ret;
 618     }
 619     return FALSE;
 620 }
 621
 622 /***********************************************************************
 623  *           URLCacheContainer_LockIndex (Internal)
 624  *
 625  */
 626 static LPURLCACHE_HEADER URLCacheContainer_LockIndex(URLCACHECONTAINER * pContainer)
 627 {
 628     BYTE index;
 629     LPVOID pIndexData;
 630     URLCACHE_HEADER * pHeader;
 631
 632     /* acquire mutex */
 633     WaitForSingleObject(pContainer->hMutex, INFINITE);
 634
 635     pIndexData = MapViewOfFile(pContainer->hMapping, FILE_MAP_WRITE, 0, 0, 0);
 636
 637     if (!pIndexData)
 638     {
 639         ReleaseMutex(pContainer->hMutex);
 640         ERR("Couldn't MapViewOfFile. Error: %ld\n", GetLastError());
 641         return FALSE;
 642     }
 643     pHeader = (URLCACHE_HEADER *)pIndexData;
 644
 645     /* file has grown - we need to remap to prevent us getting
 646      * access violations when we try and access beyond the end
 647      * of the memory mapped file */
 648     if (pHeader->dwFileSize != pContainer->file_size)
 649     {
 650         URLCacheContainer_CloseIndex(pContainer);
 651         if (!URLCacheContainer_OpenIndex(pContainer))
 652         {
 653             ReleaseMutex(pContainer->hMutex);
 654             return FALSE;
 655         }
 656         pIndexData = MapViewOfFile(pContainer->hMapping, FILE_MAP_WRITE, 0, 0, 0);
 657
 658         if (!pIndexData)
 659         {
 660             ReleaseMutex(pContainer->hMutex);
 661             ERR("Couldn't MapViewOfFile. Error: %ld\n", GetLastError());
 662             return FALSE;
 663         }
 664         pHeader = (URLCACHE_HEADER *)pIndexData;
 665     }
 666
 667     TRACE("Signature: %s, file size: %ld bytes\n", pHeader->szSignature, pHeader->dwFileSize);
 668
 669     for (index = 0; index < pHeader->DirectoryCount; index++)
 670     {
 671         TRACE("Directory[%d] = \"%.8s\"\n", index, pHeader->directory_data[index].filename);
 672     }
 673
 674     return pHeader;
 675 }
 676
 677 /***********************************************************************
 678  *           URLCacheContainer_UnlockIndex (Internal)
 679  *
 680  */
 681 static BOOL URLCacheContainer_UnlockIndex(URLCACHECONTAINER * pContainer, LPURLCACHE_HEADER pHeader)
 682 {
 683     /* release mutex */
 684     ReleaseMutex(pContainer->hMutex);
 685     return UnmapViewOfFile(pHeader);
 686 }
 687
 688
 689 #ifndef CHAR_BIT
 690 #define CHAR_BIT    (8 * sizeof(CHAR))
 691 #endif
 692
 693 /***********************************************************************
 694  *           URLCache_Allocation_BlockIsFree (Internal)
 695  *
 696  *  Is the specified block number free?
 697  *
 698  * RETURNS
 699  *    zero if free
 700  *    non-zero otherwise
 701  *
 702  */
 703 static inline BYTE URLCache_Allocation_BlockIsFree(BYTE * AllocationTable, DWORD dwBlockNumber)
 704 {
 705     BYTE mask = 1 << (dwBlockNumber % CHAR_BIT);
 706     return (AllocationTable[dwBlockNumber / CHAR_BIT] & mask) == 0;
 707 }
 708
 709 /***********************************************************************
 710  *           URLCache_Allocation_BlockFree (Internal)
 711  *
 712  *  Marks the specified block as free
 713  *
 714  * RETURNS
 715  *    nothing
 716  *
 717  */
 718 static inline void URLCache_Allocation_BlockFree(BYTE * AllocationTable, DWORD dwBlockNumber)
 719 {
 720     BYTE mask = ~(1 << (dwBlockNumber % CHAR_BIT));
 721     AllocationTable[dwBlockNumber / CHAR_BIT] &= mask;
 722 }
 723
 724 /***********************************************************************
 725  *           URLCache_Allocation_BlockAllocate (Internal)
 726  *
 727  *  Marks the specified block as allocated
 728  *
 729  * RETURNS
 730  *    nothing
 731  *
 732  */
 733 static inline void URLCache_Allocation_BlockAllocate(BYTE * AllocationTable, DWORD dwBlockNumber)
 734 {
 735     BYTE mask = 1 << (dwBlockNumber % CHAR_BIT);
 736     AllocationTable[dwBlockNumber / CHAR_BIT] |= mask;
 737 }
 738
 739 /***********************************************************************
 740  *           URLCache_FindFirstFreeEntry (Internal)
 741  *
 742  *  Finds and allocates the first block of free space big enough and
 743  * sets ppEntry to point to it.
 744  *
 745  * RETURNS
 746  *    TRUE if it had enough space
 747  *    FALSE if it couldn't find enough space
 748  *
 749  */
 750 static BOOL URLCache_FindFirstFreeEntry(URLCACHE_HEADER * pHeader, DWORD dwBlocksNeeded, CACHEFILE_ENTRY ** ppEntry)
 751 {
 752     LPBYTE AllocationTable = (LPBYTE)pHeader + ALLOCATION_TABLE_OFFSET;
 753     DWORD dwBlockNumber;
 754     DWORD dwFreeCounter;
 755     for (dwBlockNumber = 0; dwBlockNumber < pHeader->dwIndexCapacityInBlocks; dwBlockNumber++)
 756     {
 757         for (dwFreeCounter = 0;
 758             dwFreeCounter < dwBlocksNeeded &&
 759               dwFreeCounter + dwBlockNumber < pHeader->dwIndexCapacityInBlocks &&
 760               URLCache_Allocation_BlockIsFree(AllocationTable, dwBlockNumber + dwFreeCounter);
 761             dwFreeCounter++)
 762                 TRACE("Found free block at no. %ld (0x%lx)\n", dwBlockNumber, ENTRY_START_OFFSET + dwBlockNumber * BLOCKSIZE);
 763
 764         if (dwFreeCounter == dwBlocksNeeded)
 765         {
 766             DWORD index;
 767             TRACE("Found free blocks starting at no. %ld (0x%lx)\n", dwBlockNumber, ENTRY_START_OFFSET + dwBlockNumber * BLOCKSIZE);
 768             for (index = 0; index < dwBlocksNeeded; index++)
 769                 URLCache_Allocation_BlockAllocate(AllocationTable, dwBlockNumber + index);
 770             *ppEntry = (CACHEFILE_ENTRY *)((LPBYTE)pHeader + ENTRY_START_OFFSET + dwBlockNumber * BLOCKSIZE);
 771             (*ppEntry)->dwBlocksUsed = dwBlocksNeeded;
 772             return TRUE;
 773         }
 774     }
 775     FIXME("Grow file\n");
 776     return FALSE;
 777 }
 778
 779 /***********************************************************************
 780  *           URLCache_DeleteEntry (Internal)
 781  *
 782  *  Deletes the specified entry and frees the space allocated to it
 783  *
 784  * RETURNS
 785  *    TRUE if it succeeded
 786  *    FALSE if it failed
 787  *
 788  */
 789 static BOOL URLCache_DeleteEntry(LPURLCACHE_HEADER pHeader, CACHEFILE_ENTRY * pEntry)
 790 {
 791     DWORD dwStartBlock;
 792     DWORD dwBlock;
 793     BYTE * AllocationTable = (LPBYTE)pHeader + ALLOCATION_TABLE_OFFSET;
 794
 795     /* update allocation table */
 796     dwStartBlock = ((DWORD)((BYTE *)pEntry - (BYTE *)pHeader)) / BLOCKSIZE;
 797     for (dwBlock = dwStartBlock; dwBlock < dwStartBlock + pEntry->dwBlocksUsed; dwBlock++)
 798         URLCache_Allocation_BlockFree(AllocationTable, dwBlock);
 799
 800     ZeroMemory(pEntry, pEntry->dwBlocksUsed * BLOCKSIZE);
 801     return TRUE;
 802 }
 803
 804 /***********************************************************************
 805  *           URLCache_LocalFileNameToPathW (Internal)
 806  *
 807  *  Copies the full path to the specified buffer given the local file
 808  * name and the index of the directory it is in. Always sets value in
 809  * lpBufferSize to the required buffer size (in bytes).
 810  *
 811  * RETURNS
 812  *    TRUE if the buffer was big enough
 813  *    FALSE if the buffer was too small
 814  *
 815  */
 816 static BOOL URLCache_LocalFileNameToPathW(
 817     const URLCACHECONTAINER * pContainer,
 818     LPCURLCACHE_HEADER pHeader,
 819     LPCSTR szLocalFileName,
 820     BYTE Directory,
 821     LPWSTR wszPath,
 822     LPLONG lpBufferSize)
 823 {
 824     LONG nRequired;
 825     int path_len = strlenW(pContainer->path);
 826     int file_name_len = MultiByteToWideChar(CP_ACP, 0, szLocalFileName, -1, NULL, 0);
 827     if (Directory >= pHeader->DirectoryCount)
 828     {
 829         *lpBufferSize = 0;
 830         return FALSE;
 831     }
 832
 833     nRequired = (path_len + DIR_LENGTH + file_name_len + 1) * sizeof(WCHAR);
 834     if (nRequired < *lpBufferSize)
 835     {
 836         int dir_len;
 837
 838         memcpy(wszPath, pContainer->path, path_len * sizeof(WCHAR));
 839         dir_len = MultiByteToWideChar(CP_ACP, 0, pHeader->directory_data[Directory].filename, DIR_LENGTH, wszPath + path_len, DIR_LENGTH);
 840         wszPath[dir_len + path_len] = '\\';
 841         MultiByteToWideChar(CP_ACP, 0, szLocalFileName, -1, wszPath + dir_len + path_len + 1, file_name_len);
 842         *lpBufferSize = nRequired;
 843         return TRUE;
 844     }
 845     *lpBufferSize = nRequired;
 846     return FALSE;
 847 }
 848
 849 /***********************************************************************
 850  *           URLCache_LocalFileNameToPathA (Internal)
 851  *
 852  *  Copies the full path to the specified buffer given the local file
 853  * name and the index of the directory it is in. Always sets value in
 854  * lpBufferSize to the required buffer size.
 855  *
 856  * RETURNS
 857  *    TRUE if the buffer was big enough
 858  *    FALSE if the buffer was too small
 859  *
 860  */
 861 static BOOL URLCache_LocalFileNameToPathA(
 862     const URLCACHECONTAINER * pContainer,
 863     LPCURLCACHE_HEADER pHeader,
 864     LPCSTR szLocalFileName,
 865     BYTE Directory,
 866     LPSTR szPath,
 867     LPLONG lpBufferSize)
 868 {
 869     LONG nRequired;
 870     int path_len, file_name_len, dir_len;
 871
 872     if (Directory >= pHeader->DirectoryCount)
 873     {
 874         *lpBufferSize = 0;
 875         return FALSE;
 876     }
 877
 878     path_len = WideCharToMultiByte(CP_ACP, 0, pContainer->path, -1, NULL, 0, NULL, NULL);
 879     file_name_len = strlen(szLocalFileName);
 880     dir_len = DIR_LENGTH;
 881
 882     nRequired = (path_len + dir_len + 1 + file_name_len) * sizeof(WCHAR);
 883     if (nRequired < *lpBufferSize)
 884     {
 885         WideCharToMultiByte(CP_ACP, 0, pContainer->path, -1, szPath, -1, NULL, NULL);
 886         memcpy(szPath+path_len, pHeader->directory_data[Directory].filename, dir_len);
 887         szPath[path_len + dir_len] = '\\';
 888         memcpy(szPath + path_len + dir_len + 1, szLocalFileName, file_name_len);
 889         *lpBufferSize = nRequired;
 890         return TRUE;
 891     }
 892     *lpBufferSize = nRequired;
 893     return FALSE;
 894 }
 895
 896 /***********************************************************************
 897  *           URLCache_CopyEntry (Internal)
 898  *
 899  *  Copies an entry from the cache index file to the Win32 structure
 900  *
 901  * RETURNS
 902  *    TRUE if the buffer was big enough
 903  *    FALSE if the buffer was too small
 904  *
 905  */
 906 static BOOL URLCache_CopyEntry(
 907     URLCACHECONTAINER * pContainer,
 908     LPCURLCACHE_HEADER pHeader,
 909     LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
 910     LPDWORD lpdwBufferSize,
 911     URL_CACHEFILE_ENTRY * pUrlEntry,
 912     BOOL bUnicode)
 913 {
 914     int lenUrl;
 915     DWORD dwRequiredSize = sizeof(*lpCacheEntryInfo);
 916
 917     if (*lpdwBufferSize >= dwRequiredSize)
 918     {
 919         lpCacheEntryInfo->lpHeaderInfo = NULL;
 920         lpCacheEntryInfo->lpszFileExtension = NULL;
 921         lpCacheEntryInfo->lpszLocalFileName = NULL;
 922         lpCacheEntryInfo->lpszSourceUrlName = NULL;
 923         lpCacheEntryInfo->CacheEntryType = pUrlEntry->CacheEntryType;
 924         lpCacheEntryInfo->u.dwExemptDelta = pUrlEntry->dwExemptDelta;
 925         lpCacheEntryInfo->dwHeaderInfoSize = pUrlEntry->dwHeaderInfoSize;
 926         lpCacheEntryInfo->dwHitRate = pUrlEntry->dwHitRate;
 927         lpCacheEntryInfo->dwSizeHigh = pUrlEntry->dwSizeHigh;
 928         lpCacheEntryInfo->dwSizeLow = pUrlEntry->dwSizeLow;
 929         lpCacheEntryInfo->dwStructSize = sizeof(*lpCacheEntryInfo);
 930         lpCacheEntryInfo->dwUseCount = pUrlEntry->dwUseCount;
 931         DosDateTimeToFileTime(pUrlEntry->wExpiredDate, pUrlEntry->wExpiredTime, &lpCacheEntryInfo->ExpireTime);
 932         lpCacheEntryInfo->LastAccessTime.dwHighDateTime = pUrlEntry->LastAccessTime.dwHighDateTime;
 933         lpCacheEntryInfo->LastAccessTime.dwLowDateTime = pUrlEntry->LastAccessTime.dwLowDateTime;
 934         lpCacheEntryInfo->LastModifiedTime.dwHighDateTime = pUrlEntry->LastModifiedTime.dwHighDateTime;
 935         lpCacheEntryInfo->LastModifiedTime.dwLowDateTime = pUrlEntry->LastModifiedTime.dwLowDateTime;
 936         DosDateTimeToFileTime(pUrlEntry->wLastSyncDate, pUrlEntry->wLastSyncTime, &lpCacheEntryInfo->LastSyncTime);
 937     }
 938
 939     if ((dwRequiredSize % 4) && (dwRequiredSize < *lpdwBufferSize))
 940         ZeroMemory((LPBYTE)lpCacheEntryInfo + dwRequiredSize, 4 - (dwRequiredSize % 4));
 941     dwRequiredSize = DWORD_ALIGN(dwRequiredSize);
 942     if (bUnicode)
 943         lenUrl = MultiByteToWideChar(CP_ACP, 0, (LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl, -1, NULL, 0);
 944     else
 945         lenUrl = strlen((LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl);
 946     dwRequiredSize += (lenUrl + 1) * (bUnicode ? sizeof(WCHAR) : sizeof(CHAR));
 947
 948     /* FIXME: is source url optional? */
 949     if (*lpdwBufferSize >= dwRequiredSize)
 950     {
 951         lpCacheEntryInfo->lpszSourceUrlName = (LPSTR)lpCacheEntryInfo + dwRequiredSize - lenUrl - 1;
 952         if (bUnicode)
 953             MultiByteToWideChar(CP_ACP, 0, (LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl, -1, (LPWSTR)lpCacheEntryInfo->lpszSourceUrlName, lenUrl + 1);
 954         else
 955             memcpy(lpCacheEntryInfo->lpszSourceUrlName, (LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl, (lenUrl + 1) * sizeof(CHAR));
 956     }
 957
 958     if ((dwRequiredSize % 4) && (dwRequiredSize < *lpdwBufferSize))
 959         ZeroMemory((LPBYTE)lpCacheEntryInfo + dwRequiredSize, 4 - (dwRequiredSize % 4));
 960     dwRequiredSize = DWORD_ALIGN(dwRequiredSize);
 961
 962     if (pUrlEntry->dwOffsetLocalName)
 963     {
 964         LONG nLocalFilePathSize;
 965         LPSTR lpszLocalFileName;
 966         lpszLocalFileName = (LPSTR)lpCacheEntryInfo + dwRequiredSize;
 967         nLocalFilePathSize = *lpdwBufferSize - dwRequiredSize;
 968         if ((bUnicode && URLCache_LocalFileNameToPathW(pContainer, pHeader, (LPCSTR)pUrlEntry + pUrlEntry->dwOffsetLocalName, pUrlEntry->CacheDir, (LPWSTR)lpszLocalFileName, &nLocalFilePathSize)) ||
 969             URLCache_LocalFileNameToPathA(pContainer, pHeader, (LPCSTR)pUrlEntry + pUrlEntry->dwOffsetLocalName, pUrlEntry->CacheDir, lpszLocalFileName, &nLocalFilePathSize))
 970         {
 971             lpCacheEntryInfo->lpszLocalFileName = lpszLocalFileName;
 972         }
 973         dwRequiredSize += nLocalFilePathSize * (bUnicode ? sizeof(WCHAR) : sizeof(CHAR)) ;
 974
 975         if ((dwRequiredSize % 4) && (dwRequiredSize < *lpdwBufferSize))
 976             ZeroMemory((LPBYTE)lpCacheEntryInfo + dwRequiredSize, 4 - (dwRequiredSize % 4));
 977         dwRequiredSize = DWORD_ALIGN(dwRequiredSize);
 978     }
 979     dwRequiredSize += pUrlEntry->dwHeaderInfoSize + 1;
 980
 981     if (*lpdwBufferSize >= dwRequiredSize)
 982     {
 983         lpCacheEntryInfo->lpHeaderInfo = (LPBYTE)lpCacheEntryInfo + dwRequiredSize - pUrlEntry->dwHeaderInfoSize - 1;
 984         memcpy(lpCacheEntryInfo->lpHeaderInfo, (LPSTR)pUrlEntry + pUrlEntry->dwOffsetHeaderInfo, pUrlEntry->dwHeaderInfoSize);
 985         ((LPBYTE)lpCacheEntryInfo)[dwRequiredSize - 1] = '\0';
 986     }
 987     if ((dwRequiredSize % 4) && (dwRequiredSize < *lpdwBufferSize))
 988         ZeroMemory((LPBYTE)lpCacheEntryInfo + dwRequiredSize, 4 - (dwRequiredSize % 4));
 989     dwRequiredSize = DWORD_ALIGN(dwRequiredSize);
 990
 991     if (dwRequiredSize > *lpdwBufferSize)
 992     {
 993         *lpdwBufferSize = dwRequiredSize;
 994         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 995         return FALSE;
 996     }
 997     *lpdwBufferSize = dwRequiredSize;
 998     return TRUE;
 999 }
1000
1001
1002 /***********************************************************************
1003  *           URLCache_SetEntryInfo (Internal)
1004  *
1005  *  Helper for SetUrlCacheEntryInfo{A,W}. Sets fields in URL entry
1006  * according the the flags set by dwFieldControl.
1007  *
1008  * RETURNS
1009  *    TRUE if the buffer was big enough
1010  *    FALSE if the buffer was too small
1011  *
1012  */
1013 static BOOL URLCache_SetEntryInfo(URL_CACHEFILE_ENTRY * pUrlEntry, const INTERNET_CACHE_ENTRY_INFOW * lpCacheEntryInfo, DWORD dwFieldControl)
1014 {
1015     if (dwFieldControl & CACHE_ENTRY_ACCTIME_FC)
1016         pUrlEntry->LastAccessTime = lpCacheEntryInfo->LastAccessTime;
1017     if (dwFieldControl & CACHE_ENTRY_ATTRIBUTE_FC)
1018         pUrlEntry->CacheEntryType = lpCacheEntryInfo->CacheEntryType;
1019     if (dwFieldControl & CACHE_ENTRY_EXEMPT_DELTA_FC)
1020         pUrlEntry->dwExemptDelta = lpCacheEntryInfo->u.dwExemptDelta;
1021     if (dwFieldControl & CACHE_ENTRY_EXPTIME_FC)
1022         FIXME("CACHE_ENTRY_EXPTIME_FC unimplemented\n");
1023     if (dwFieldControl & CACHE_ENTRY_HEADERINFO_FC)
1024         FIXME("CACHE_ENTRY_HEADERINFO_FC unimplemented\n");
1025     if (dwFieldControl & CACHE_ENTRY_HITRATE_FC)
1026         pUrlEntry->dwHitRate = lpCacheEntryInfo->dwHitRate;
1027     if (dwFieldControl & CACHE_ENTRY_MODTIME_FC)
1028         pUrlEntry->LastModifiedTime = lpCacheEntryInfo->LastModifiedTime;
1029     if (dwFieldControl & CACHE_ENTRY_SYNCTIME_FC)
1030         FileTimeToDosDateTime(&lpCacheEntryInfo->LastAccessTime, &pUrlEntry->wLastSyncDate, &pUrlEntry->wLastSyncTime);
1031
1032     return TRUE;
1033 }
1034
1035 /***********************************************************************
1036  *           URLCache_HashKey (Internal)
1037  *
1038  *  Returns the hash key for a given string
1039  *
1040  * RETURNS
1041  *    hash key for the string
1042  *
1043  */
1044 static DWORD URLCache_HashKey(LPCSTR lpszKey)
1045 {
1046     /* NOTE: this uses the same lookup table as SHLWAPI.UrlHash{A,W}
1047      * but the algorithm and result are not the same!
1048      */
1049     static const unsigned char lookupTable[256] =
1050     {
1051         0x01, 0x0E, 0x6E, 0x19, 0x61, 0xAE, 0x84, 0x77,
1052         0x8A, 0xAA, 0x7D, 0x76, 0x1B, 0xE9, 0x8C, 0x33,
1053         0x57, 0xC5, 0xB1, 0x6B, 0xEA, 0xA9, 0x38, 0x44,
1054         0x1E, 0x07, 0xAD, 0x49, 0xBC, 0x28, 0x24, 0x41,
1055         0x31, 0xD5, 0x68, 0xBE, 0x39, 0xD3, 0x94, 0xDF,
1056         0x30, 0x73, 0x0F, 0x02, 0x43, 0xBA, 0xD2, 0x1C,
1057         0x0C, 0xB5, 0x67, 0x46, 0x16, 0x3A, 0x4B, 0x4E,
1058         0xB7, 0xA7, 0xEE, 0x9D, 0x7C, 0x93, 0xAC, 0x90,
1059         0xB0, 0xA1, 0x8D, 0x56, 0x3C, 0x42, 0x80, 0x53,
1060         0x9C, 0xF1, 0x4F, 0x2E, 0xA8, 0xC6, 0x29, 0xFE,
1061         0xB2, 0x55, 0xFD, 0xED, 0xFA, 0x9A, 0x85, 0x58,
1062         0x23, 0xCE, 0x5F, 0x74, 0xFC, 0xC0, 0x36, 0xDD,
1063         0x66, 0xDA, 0xFF, 0xF0, 0x52, 0x6A, 0x9E, 0xC9,
1064         0x3D, 0x03, 0x59, 0x09, 0x2A, 0x9B, 0x9F, 0x5D,
1065         0xA6, 0x50, 0x32, 0x22, 0xAF, 0xC3, 0x64, 0x63,
1066         0x1A, 0x96, 0x10, 0x91, 0x04, 0x21, 0x08, 0xBD,
1067         0x79, 0x40, 0x4D, 0x48, 0xD0, 0xF5, 0x82, 0x7A,
1068         0x8F, 0x37, 0x69, 0x86, 0x1D, 0xA4, 0xB9, 0xC2,
1069         0xC1, 0xEF, 0x65, 0xF2, 0x05, 0xAB, 0x7E, 0x0B,
1070         0x4A, 0x3B, 0x89, 0xE4, 0x6C, 0xBF, 0xE8, 0x8B,
1071         0x06, 0x18, 0x51, 0x14, 0x7F, 0x11, 0x5B, 0x5C,
1072         0xFB, 0x97, 0xE1, 0xCF, 0x15, 0x62, 0x71, 0x70,
1073         0x54, 0xE2, 0x12, 0xD6, 0xC7, 0xBB, 0x0D, 0x20,
1074         0x5E, 0xDC, 0xE0, 0xD4, 0xF7, 0xCC, 0xC4, 0x2B,
1075         0xF9, 0xEC, 0x2D, 0xF4, 0x6F, 0xB6, 0x99, 0x88,
1076         0x81, 0x5A, 0xD9, 0xCA, 0x13, 0xA5, 0xE7, 0x47,
1077         0xE6, 0x8E, 0x60, 0xE3, 0x3E, 0xB3, 0xF6, 0x72,
1078         0xA2, 0x35, 0xA0, 0xD7, 0xCD, 0xB4, 0x2F, 0x6D,
1079         0x2C, 0x26, 0x1F, 0x95, 0x87, 0x00, 0xD8, 0x34,
1080         0x3F, 0x17, 0x25, 0x45, 0x27, 0x75, 0x92, 0xB8,
1081         0xA3, 0xC8, 0xDE, 0xEB, 0xF8, 0xF3, 0xDB, 0x0A,
1082         0x98, 0x83, 0x7B, 0xE5, 0xCB, 0x4C, 0x78, 0xD1
1083     };
1084     BYTE key[4];
1085     DWORD i;
1086     int subscript[sizeof(key) / sizeof(key[0])];
1087
1088     subscript[0] = *lpszKey;
1089     subscript[1] = (char)(*lpszKey + 1);
1090     subscript[2] = (char)(*lpszKey + 2);
1091     subscript[3] = (char)(*lpszKey + 3);
1092
1093     for (i = 0; i < sizeof(key) / sizeof(key[0]); i++)
1094         key[i] = lookupTable[i];
1095
1096     for (lpszKey++; *lpszKey && ((lpszKey[0] != '/') || (lpszKey[1] != 0)); lpszKey++)
1097     {
1098         for (i = 0; i < sizeof(key) / sizeof(key[0]); i++)
1099             key[i] = lookupTable[*lpszKey ^ key[i]];
1100     }
1101
1102     return *(DWORD *)key;
1103 }
1104
1105 static inline HASH_CACHEFILE_ENTRY * URLCache_HashEntryFromOffset(LPCURLCACHE_HEADER pHeader, DWORD dwOffset)
1106 {
1107     return (HASH_CACHEFILE_ENTRY *)((LPBYTE)pHeader + dwOffset);
1108 }
1109
1110 static BOOL URLCache_FindHash(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl, struct _HASH_ENTRY ** ppHashEntry)
1111 {
1112     /* structure of hash table:
1113      *  448 entries divided into 64 blocks
1114      *  each block therefore contains a chain of 7 key/offset pairs
1115      * how position in table is calculated:
1116      *  1. the url is hashed in helper function
1117      *  2. the key % 64 * 8 is the offset
1118      *  3. the key in the hash table is the hash key aligned to 64
1119      *
1120      * note:
1121      *  there can be multiple hash tables in the file and the offset to
1122      *  the next one is stored in the header of the hash table
1123      */
1124     DWORD key = URLCache_HashKey(lpszUrl);
1125     DWORD offset = (key % HASHTABLE_NUM_ENTRIES) * sizeof(struct _HASH_ENTRY);
1126     HASH_CACHEFILE_ENTRY * pHashEntry;
1127     DWORD dwHashTableNumber = 0;
1128
1129     key = (DWORD)(key / HASHTABLE_NUM_ENTRIES) * HASHTABLE_NUM_ENTRIES;
1130
1131     for (pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->dwOffsetFirstHashTable);
1132          ((DWORD)((LPBYTE)pHashEntry - (LPBYTE)pHeader) >= ENTRY_START_OFFSET) && ((DWORD)((LPBYTE)pHashEntry - (LPBYTE)pHeader) < pHeader->dwFileSize);
1133          pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHashEntry->dwAddressNext))
1134     {
1135         int i;
1136         if (pHashEntry->dwHashTableNumber != dwHashTableNumber++)
1137         {
1138             ERR("Error: not right hash table number (%ld) expected %ld\n", pHashEntry->dwHashTableNumber, dwHashTableNumber);
1139             continue;
1140         }
1141         /* make sure that it is in fact a hash entry */
1142         if (pHashEntry->CacheFileEntry.dwSignature != HASH_SIGNATURE)
1143         {
1144             ERR("Error: not right signature (\"%.4s\") - expected \"HASH\"\n", (LPCSTR)&pHashEntry->CacheFileEntry.dwSignature);
1145             continue;
1146         }
1147
1148         for (i = 0; i < HASHTABLE_BLOCKSIZE; i++)
1149         {
1150             struct _HASH_ENTRY * pHashElement = &pHashEntry->HashTable[offset + i];
1151             if (key == (DWORD)(pHashElement->dwHashKey / HASHTABLE_NUM_ENTRIES) * HASHTABLE_NUM_ENTRIES)
1152             {
1153                 /* FIXME: we should make sure that this is the right element
1154                  * before returning and claiming that it is. We can do this
1155                  * by doing a simple compare between the URL we were given
1156                  * and the URL stored in the entry. However, this assumes
1157                  * we know the format of all the entries stored in the
1158                  * hash table */
1159                 *ppHashEntry = pHashElement;
1160                 return TRUE;
1161             }
1162         }
1163     }
1164     return FALSE;
1165 }
1166
1167 /***********************************************************************
1168  *           URLCache_FindEntryInHash (Internal)
1169  *
1170  *  Searches all the hash tables in the index for the given URL and
1171  * returns the entry, if it was found, in ppEntry
1172  *
1173  * RETURNS
1174  *    TRUE if the entry was found
1175  *    FALSE if the entry could not be found
1176  *
1177  */
1178 static BOOL URLCache_FindEntryInHash(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl, CACHEFILE_ENTRY ** ppEntry)
1179 {
1180     struct _HASH_ENTRY * pHashEntry;
1181     if (URLCache_FindHash(pHeader, lpszUrl, &pHashEntry))
1182     {
1183         *ppEntry = (CACHEFILE_ENTRY *)((LPBYTE)pHeader + pHashEntry->dwOffsetEntry);
1184         return TRUE;
1185     }
1186     return FALSE;
1187 }
1188
1189 /***********************************************************************
1190  *           URLCache_HashEntrySetUse (Internal)
1191  *
1192  *  Searches all the hash tables in the index for the given URL and
1193  * sets the use count (stored or'ed with key)
1194  *
1195  * RETURNS
1196  *    TRUE if the entry was found
1197  *    FALSE if the entry could not be found
1198  *
1199  */
1200 static BOOL URLCache_HashEntrySetUse(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl, DWORD dwUseCount)
1201 {
1202     struct _HASH_ENTRY * pHashEntry;
1203     if (URLCache_FindHash(pHeader, lpszUrl, &pHashEntry))
1204     {
1205         pHashEntry->dwHashKey = dwUseCount | (DWORD)(pHashEntry->dwHashKey / HASHTABLE_NUM_ENTRIES) * HASHTABLE_NUM_ENTRIES;
1206         return TRUE;
1207     }
1208     return FALSE;
1209 }
1210
1211 /***********************************************************************
1212  *           URLCache_DeleteEntryFromHash (Internal)
1213  *
1214  *  Searches all the hash tables in the index for the given URL and
1215  * then if found deletes the entry.
1216  *
1217  * RETURNS
1218  *    TRUE if the entry was found
1219  *    FALSE if the entry could not be found
1220  *
1221  */
1222 static BOOL URLCache_DeleteEntryFromHash(LPCURLCACHE_HEADER pHeader, LPCSTR lpszUrl)
1223 {
1224     struct _HASH_ENTRY * pHashEntry;
1225     if (URLCache_FindHash(pHeader, lpszUrl, &pHashEntry))
1226     {
1227         pHashEntry->dwHashKey = HASHTABLE_FREE;
1228         pHashEntry->dwOffsetEntry = HASHTABLE_FREE;
1229         return TRUE;
1230     }
1231     return FALSE;
1232 }
1233
1234 /***********************************************************************
1235  *           URLCache_AddEntryToHash (Internal)
1236  *
1237  *  Searches all the hash tables for a free slot based on the offset
1238  * generated from the hash key. If a free slot is found, the offset and
1239  * key are entered into the hash table.
1240  *
1241  * RETURNS
1242  *    TRUE if the entry was added
1243  *    FALSE if the entry could not be added
1244  *
1245  */
1246 static BOOL URLCache_AddEntryToHash(LPURLCACHE_HEADER pHeader, LPCSTR lpszUrl, DWORD dwOffsetEntry)
1247 {
1248     /* see URLCache_FindEntryInHash for structure of hash tables */
1249
1250     DWORD key = URLCache_HashKey(lpszUrl);
1251     DWORD offset = (key % HASHTABLE_NUM_ENTRIES) * sizeof(struct _HASH_ENTRY);
1252     HASH_CACHEFILE_ENTRY * pHashEntry;
1253     DWORD dwHashTableNumber = 0;
1254
1255     key = (DWORD)(key / HASHTABLE_NUM_ENTRIES) * HASHTABLE_NUM_ENTRIES;
1256
1257     for (pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHeader->dwOffsetFirstHashTable);
1258          ((DWORD)((LPBYTE)pHashEntry - (LPBYTE)pHeader) >= ENTRY_START_OFFSET) && ((DWORD)((LPBYTE)pHashEntry - (LPBYTE)pHeader) < pHeader->dwFileSize);
1259          pHashEntry = URLCache_HashEntryFromOffset(pHeader, pHashEntry->dwAddressNext))
1260     {
1261         int i;
1262         if (pHashEntry->dwHashTableNumber != dwHashTableNumber++)
1263         {
1264             ERR("not right hash table number (%ld) expected %ld\n", pHashEntry->dwHashTableNumber, dwHashTableNumber);
1265             break;
1266         }
1267         /* make sure that it is in fact a hash entry */
1268         if (pHashEntry->CacheFileEntry.dwSignature != HASH_SIGNATURE)
1269         {
1270             ERR("not right signature (\"%.4s\") - expected \"HASH\"\n", (LPCSTR)&pHashEntry->CacheFileEntry.dwSignature);
1271             break;
1272         }
1273
1274         for (i = 0; i < HASHTABLE_BLOCKSIZE; i++)
1275         {
1276             struct _HASH_ENTRY * pHashElement = &pHashEntry->HashTable[offset + i];
1277             if (pHashElement->dwHashKey == HASHTABLE_FREE) /* if the slot is free */
1278             {
1279                 pHashElement->dwHashKey = key;
1280                 pHashElement->dwOffsetEntry = dwOffsetEntry;
1281                 return TRUE;
1282             }
1283         }
1284     }
1285     pHashEntry = URLCache_CreateHashTable(pHeader, pHashEntry);
1286     if (!pHashEntry)
1287         return FALSE;
1288
1289     pHashEntry->HashTable[offset].dwHashKey = key;
1290     pHashEntry->HashTable[offset].dwOffsetEntry = dwOffsetEntry;
1291     return TRUE;
1292 }
1293
1294 static HASH_CACHEFILE_ENTRY *URLCache_CreateHashTable(LPURLCACHE_HEADER pHeader, HASH_CACHEFILE_ENTRY *pPrevHash)
1295 {
1296     HASH_CACHEFILE_ENTRY *pHash;
1297     DWORD dwOffset;
1298     int i;
1299
1300     if (!URLCache_FindFirstFreeEntry(pHeader, 0x20, (CACHEFILE_ENTRY **)&pHash))
1301     {
1302         FIXME("no free space for hash table\n");
1303         SetLastError(ERROR_DISK_FULL);
1304         return NULL;
1305     }
1306
1307     dwOffset = (BYTE *)pHash - (BYTE *)pHeader;
1308
1309     if (pPrevHash)
1310         pPrevHash->dwAddressNext = dwOffset;
1311     else
1312         pHeader->dwOffsetFirstHashTable = dwOffset;
1313     pHash->CacheFileEntry.dwSignature = HASH_SIGNATURE;
1314     pHash->CacheFileEntry.dwBlocksUsed = 0x20;
1315     pHash->dwHashTableNumber = pPrevHash ? pPrevHash->dwHashTableNumber + 1 : 0;
1316     for (i = 0; i < HASHTABLE_SIZE; i++)
1317     {
1318         pHash->HashTable[i].dwOffsetEntry = 0;
1319         pHash->HashTable[i].dwHashKey = HASHTABLE_FREE;
1320     }
1321     return pHash;
1322 }
1323
1324 /***********************************************************************
1325  *           GetUrlCacheEntryInfoExA (WININET.@)
1326  *
1327  */
1328 BOOL WINAPI GetUrlCacheEntryInfoExA(
1329     LPCSTR lpszUrl,
1330     LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1331     LPDWORD lpdwCacheEntryInfoBufSize,
1332     LPSTR lpszReserved,
1333     LPDWORD lpdwReserved,
1334     LPVOID lpReserved,
1335     DWORD dwFlags)
1336 {
1337     TRACE("(%s, %p, %p, %p, %p, %p, %lx)\n",
1338         debugstr_a(lpszUrl),
1339         lpCacheEntryInfo,
1340         lpdwCacheEntryInfoBufSize,
1341         lpszReserved,
1342         lpdwReserved,
1343         lpReserved,
1344         dwFlags);
1345
1346     if ((lpszReserved != NULL) ||
1347         (lpdwReserved != NULL) ||
1348         (lpReserved != NULL))
1349     {
1350         ERR("Reserved value was not 0\n");
1351         SetLastError(ERROR_INVALID_PARAMETER);
1352         return FALSE;
1353     }
1354     if (dwFlags != 0)
1355         FIXME("Undocumented flag(s): %lx\n", dwFlags);
1356     return GetUrlCacheEntryInfoA(lpszUrl, lpCacheEntryInfo, lpdwCacheEntryInfoBufSize);
1357 }
1358
1359 /***********************************************************************
1360  *           GetUrlCacheEntryInfoA (WININET.@)
1361  *
1362  */
1363 BOOL WINAPI GetUrlCacheEntryInfoA(
1364     IN LPCSTR lpszUrlName,
1365     IN LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1366     IN OUT LPDWORD lpdwCacheEntryInfoBufferSize
1367 )
1368 {
1369     LPURLCACHE_HEADER pHeader;
1370     CACHEFILE_ENTRY * pEntry;
1371     URL_CACHEFILE_ENTRY * pUrlEntry;
1372     URLCACHECONTAINER * pContainer;
1373
1374     TRACE("(%s, %p, %p)\n", debugstr_a(lpszUrlName), lpCacheEntryInfo, lpdwCacheEntryInfoBufferSize);
1375
1376     if (!URLCacheContainers_FindContainerA(lpszUrlName, &pContainer))
1377         return FALSE;
1378
1379     if (!URLCacheContainer_OpenIndex(pContainer))
1380         return FALSE;
1381
1382     if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1383         return FALSE;
1384
1385     if (!URLCache_FindEntryInHash(pHeader, lpszUrlName, &pEntry))
1386     {
1387         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1388         WARN("entry %s not found!\n", debugstr_a(lpszUrlName));
1389         SetLastError(ERROR_FILE_NOT_FOUND);
1390         return FALSE;
1391     }
1392
1393     if (pEntry->dwSignature != URL_SIGNATURE)
1394     {
1395         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1396         FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1397         SetLastError(ERROR_FILE_NOT_FOUND);
1398         return FALSE;
1399     }
1400
1401     pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
1402     TRACE("Found URL: %s\n", debugstr_a((LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl));
1403     if (pUrlEntry->dwOffsetHeaderInfo)
1404         TRACE("Header info: %s\n", debugstr_a((LPSTR)pUrlEntry + pUrlEntry->dwOffsetHeaderInfo));
1405
1406     if (!URLCache_CopyEntry(
1407         pContainer,
1408         pHeader,
1409         lpCacheEntryInfo,
1410         lpdwCacheEntryInfoBufferSize,
1411         pUrlEntry,
1412         FALSE /* ANSI */))
1413     {
1414         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1415         return FALSE;
1416     }
1417     TRACE("Local File Name: %s\n", debugstr_a(lpCacheEntryInfo->lpszLocalFileName));
1418
1419     URLCacheContainer_UnlockIndex(pContainer, pHeader);
1420
1421     return TRUE;
1422 }
1423
1424 /***********************************************************************
1425  *           GetUrlCacheEntryInfoW (WININET.@)
1426  *
1427  */
1428 BOOL WINAPI GetUrlCacheEntryInfoW(LPCWSTR lpszUrl,
1429   LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
1430   LPDWORD lpdwCacheEntryInfoBufferSize)
1431 {
1432     LPURLCACHE_HEADER pHeader;
1433     CACHEFILE_ENTRY * pEntry;
1434     URL_CACHEFILE_ENTRY * pUrlEntry;
1435     URLCACHECONTAINER * pContainer;
1436     LPSTR lpszUrlA;
1437     int url_len;
1438
1439     TRACE("(%s, %p, %p)\n", debugstr_w(lpszUrl), lpCacheEntryInfo, lpdwCacheEntryInfoBufferSize);
1440
1441     url_len = WideCharToMultiByte(CP_ACP, 0, lpszUrl, -1, NULL, 0, NULL, NULL);
1442     lpszUrlA = HeapAlloc(GetProcessHeap(), 0, url_len * sizeof(CHAR));
1443     if (!lpszUrlA)
1444     {
1445         SetLastError(ERROR_OUTOFMEMORY);
1446         return FALSE;
1447     }
1448     WideCharToMultiByte(CP_ACP, 0, lpszUrl, -1, lpszUrlA, url_len, NULL, NULL);
1449
1450     if (!URLCacheContainers_FindContainerW(lpszUrl, &pContainer))
1451     {
1452         HeapFree(GetProcessHeap(), 0, lpszUrlA);
1453         return FALSE;
1454     }
1455
1456     if (!URLCacheContainer_OpenIndex(pContainer))
1457     {
1458         HeapFree(GetProcessHeap(), 0, lpszUrlA);
1459         return FALSE;
1460     }
1461
1462     if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1463     {
1464         HeapFree(GetProcessHeap(), 0, lpszUrlA);
1465         return FALSE;
1466     }
1467
1468     if (!URLCache_FindEntryInHash(pHeader, lpszUrlA, &pEntry))
1469     {
1470         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1471         WARN("entry %s not found!\n", debugstr_a(lpszUrlA));
1472         HeapFree(GetProcessHeap(), 0, lpszUrlA);
1473         SetLastError(ERROR_FILE_NOT_FOUND);
1474         return FALSE;
1475     }
1476     HeapFree(GetProcessHeap(), 0, lpszUrlA);
1477
1478     if (pEntry->dwSignature != URL_SIGNATURE)
1479     {
1480         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1481         FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1482         SetLastError(ERROR_FILE_NOT_FOUND);
1483         return FALSE;
1484     }
1485
1486     pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
1487     TRACE("Found URL: %s\n", debugstr_a((LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl));
1488     TRACE("Header info: %s\n", debugstr_a((LPSTR)pUrlEntry + pUrlEntry->dwOffsetHeaderInfo));
1489
1490     if (!URLCache_CopyEntry(
1491         pContainer,
1492         pHeader,
1493         (LPINTERNET_CACHE_ENTRY_INFOA)lpCacheEntryInfo,
1494         lpdwCacheEntryInfoBufferSize,
1495         pUrlEntry,
1496         TRUE /* UNICODE */))
1497     {
1498         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1499         return FALSE;
1500     }
1501     TRACE("Local File Name: %s\n", debugstr_w(lpCacheEntryInfo->lpszLocalFileName));
1502
1503     URLCacheContainer_UnlockIndex(pContainer, pHeader);
1504
1505     return TRUE;
1506 }
1507
1508 /***********************************************************************
1509  *           GetUrlCacheEntryInfoExW (WININET.@)
1510  *
1511  */
1512 BOOL WINAPI GetUrlCacheEntryInfoExW(
1513     LPCWSTR lpszUrl,
1514     LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
1515     LPDWORD lpdwCacheEntryInfoBufSize,
1516     LPWSTR lpszReserved,
1517     LPDWORD lpdwReserved,
1518     LPVOID lpReserved,
1519     DWORD dwFlags)
1520 {
1521     TRACE("(%s, %p, %p, %p, %p, %p, %lx)\n",
1522         debugstr_w(lpszUrl),
1523         lpCacheEntryInfo,
1524         lpdwCacheEntryInfoBufSize,
1525         lpszReserved,
1526         lpdwReserved,
1527         lpReserved,
1528         dwFlags);
1529
1530     if ((lpszReserved != NULL) ||
1531         (lpdwReserved != NULL) ||
1532         (lpReserved != NULL))
1533     {
1534         ERR("Reserved value was not 0\n");
1535         SetLastError(ERROR_INVALID_PARAMETER);
1536         return FALSE;
1537     }
1538     if (dwFlags != 0)
1539         FIXME("Undocumented flag(s): %lx\n", dwFlags);
1540     return GetUrlCacheEntryInfoW(lpszUrl, lpCacheEntryInfo, lpdwCacheEntryInfoBufSize);
1541 }
1542
1543 /***********************************************************************
1544  *           SetUrlCacheEntryInfoA (WININET.@)
1545  */
1546 BOOL WINAPI SetUrlCacheEntryInfoA(
1547     LPCSTR lpszUrlName,
1548     LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1549     DWORD dwFieldControl)
1550 {
1551     LPURLCACHE_HEADER pHeader;
1552     CACHEFILE_ENTRY * pEntry;
1553     URLCACHECONTAINER * pContainer;
1554
1555     TRACE("(%s, %p, 0x%08lx)\n", debugstr_a(lpszUrlName), lpCacheEntryInfo, dwFieldControl);
1556
1557     if (!URLCacheContainers_FindContainerA(lpszUrlName, &pContainer))
1558         return FALSE;
1559
1560     if (!URLCacheContainer_OpenIndex(pContainer))
1561         return FALSE;
1562
1563     if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1564         return FALSE;
1565
1566     if (!URLCache_FindEntryInHash(pHeader, lpszUrlName, &pEntry))
1567     {
1568         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1569         WARN("entry %s not found!\n", debugstr_a(lpszUrlName));
1570         SetLastError(ERROR_FILE_NOT_FOUND);
1571         return FALSE;
1572     }
1573
1574     if (pEntry->dwSignature != URL_SIGNATURE)
1575     {
1576         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1577         FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1578         SetLastError(ERROR_FILE_NOT_FOUND);
1579         return FALSE;
1580     }
1581
1582     URLCache_SetEntryInfo(
1583         (URL_CACHEFILE_ENTRY *)pEntry,
1584         (const INTERNET_CACHE_ENTRY_INFOW *)lpCacheEntryInfo,
1585         dwFieldControl);
1586
1587     URLCacheContainer_UnlockIndex(pContainer, pHeader);
1588
1589     return TRUE;
1590 }
1591
1592 /***********************************************************************
1593  *           SetUrlCacheEntryInfoW (WININET.@)
1594  */
1595 BOOL WINAPI SetUrlCacheEntryInfoW(LPCWSTR lpszUrl, LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo, DWORD dwFieldControl)
1596 {
1597     LPURLCACHE_HEADER pHeader;
1598     CACHEFILE_ENTRY * pEntry;
1599     URLCACHECONTAINER * pContainer;
1600     LPSTR lpszUrlA;
1601     int url_len;
1602
1603     TRACE("(%s, %p, 0x%08lx)\n", debugstr_w(lpszUrl), lpCacheEntryInfo, dwFieldControl);
1604
1605     url_len = WideCharToMultiByte(CP_ACP, 0, lpszUrl, -1, NULL, 0, NULL, NULL);
1606     lpszUrlA = HeapAlloc(GetProcessHeap(), 0, url_len * sizeof(CHAR));
1607     if (!lpszUrlA)
1608     {
1609         SetLastError(ERROR_OUTOFMEMORY);
1610         return FALSE;
1611     }
1612     WideCharToMultiByte(CP_ACP, 0, lpszUrl, -1, lpszUrlA, url_len, NULL, NULL);
1613
1614     if (!URLCacheContainers_FindContainerW(lpszUrl, &pContainer))
1615     {
1616         HeapFree(GetProcessHeap(), 0, lpszUrlA);
1617         return FALSE;
1618     }
1619
1620     if (!URLCacheContainer_OpenIndex(pContainer))
1621     {
1622         HeapFree(GetProcessHeap(), 0, lpszUrlA);
1623         return FALSE;
1624     }
1625
1626     if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1627     {
1628         HeapFree(GetProcessHeap(), 0, lpszUrlA);
1629         return FALSE;
1630     }
1631
1632     if (!URLCache_FindEntryInHash(pHeader, lpszUrlA, &pEntry))
1633     {
1634         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1635         HeapFree(GetProcessHeap(), 0, lpszUrlA);
1636         WARN("entry %s not found!\n", debugstr_a(lpszUrlA));
1637         SetLastError(ERROR_FILE_NOT_FOUND);
1638         return FALSE;
1639     }
1640     HeapFree(GetProcessHeap(), 0, lpszUrlA);
1641
1642     if (pEntry->dwSignature != URL_SIGNATURE)
1643     {
1644         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1645         FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1646         SetLastError(ERROR_FILE_NOT_FOUND);
1647         return FALSE;
1648     }
1649
1650     URLCache_SetEntryInfo(
1651         (URL_CACHEFILE_ENTRY *)pEntry,
1652         lpCacheEntryInfo,
1653         dwFieldControl);
1654
1655     URLCacheContainer_UnlockIndex(pContainer, pHeader);
1656
1657     return TRUE;
1658 }
1659
1660 /***********************************************************************
1661  *           RetrieveUrlCacheEntryFileA (WININET.@)
1662  *
1663  */
1664 BOOL WINAPI RetrieveUrlCacheEntryFileA(
1665     IN LPCSTR lpszUrlName,
1666     OUT LPINTERNET_CACHE_ENTRY_INFOA lpCacheEntryInfo,
1667     IN OUT LPDWORD lpdwCacheEntryInfoBufferSize,
1668     IN DWORD dwReserved
1669     )
1670 {
1671     LPURLCACHE_HEADER pHeader;
1672     CACHEFILE_ENTRY * pEntry;
1673     URL_CACHEFILE_ENTRY * pUrlEntry;
1674     URLCACHECONTAINER * pContainer;
1675
1676     TRACE("(%s, %p, %p, 0x%08lx)\n",
1677         debugstr_a(lpszUrlName),
1678         lpCacheEntryInfo,
1679         lpdwCacheEntryInfoBufferSize,
1680         dwReserved);
1681
1682     if (!URLCacheContainers_FindContainerA(lpszUrlName, &pContainer))
1683         return FALSE;
1684
1685     if (!URLCacheContainer_OpenIndex(pContainer))
1686         return FALSE;
1687
1688     if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1689         return FALSE;
1690
1691     if (!URLCache_FindEntryInHash(pHeader, lpszUrlName, &pEntry))
1692     {
1693         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1694         TRACE("entry %s not found!\n", lpszUrlName);
1695         SetLastError(ERROR_FILE_NOT_FOUND);
1696         return FALSE;
1697     }
1698
1699     if (pEntry->dwSignature != URL_SIGNATURE)
1700     {
1701         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1702         FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1703         SetLastError(ERROR_FILE_NOT_FOUND);
1704         return FALSE;
1705     }
1706
1707     pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
1708     TRACE("Found URL: %s\n", (LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl);
1709     TRACE("Header info: %s\n", (LPBYTE)pUrlEntry + pUrlEntry->dwOffsetHeaderInfo);
1710
1711     pUrlEntry->dwHitRate++;
1712     pUrlEntry->dwUseCount++;
1713     URLCache_HashEntrySetUse(pHeader, lpszUrlName, pUrlEntry->dwUseCount);
1714
1715     if (!URLCache_CopyEntry(pContainer, pHeader, lpCacheEntryInfo, lpdwCacheEntryInfoBufferSize, pUrlEntry, FALSE))
1716     {
1717         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1718         return FALSE;
1719     }
1720     TRACE("Local File Name: %s\n", lpCacheEntryInfo->lpszLocalFileName);
1721
1722     URLCacheContainer_UnlockIndex(pContainer, pHeader);
1723
1724     return TRUE;
1725 }
1726
1727 /***********************************************************************
1728  *           RetrieveUrlCacheEntryFileW (WININET.@)
1729  *
1730  */
1731 BOOL WINAPI RetrieveUrlCacheEntryFileW(
1732     IN LPCWSTR lpszUrlName,
1733     OUT LPINTERNET_CACHE_ENTRY_INFOW lpCacheEntryInfo,
1734     IN OUT LPDWORD lpdwCacheEntryInfoBufferSize,
1735     IN DWORD dwReserved
1736     )
1737 {
1738     TRACE("(%s, %p, %p, 0x%08lx)\n",
1739         debugstr_w(lpszUrlName),
1740         lpCacheEntryInfo,
1741         lpdwCacheEntryInfoBufferSize,
1742         dwReserved);
1743
1744     return FALSE;
1745 }
1746
1747 /***********************************************************************
1748  *           UnlockUrlCacheEntryFileA (WININET.@)
1749  *
1750  */
1751 BOOL WINAPI UnlockUrlCacheEntryFileA(
1752     IN LPCSTR lpszUrlName,
1753     IN DWORD dwReserved
1754     )
1755 {
1756     LPURLCACHE_HEADER pHeader;
1757     CACHEFILE_ENTRY * pEntry;
1758     URL_CACHEFILE_ENTRY * pUrlEntry;
1759     URLCACHECONTAINER * pContainer;
1760
1761     TRACE("(%s, 0x%08lx)\n", debugstr_a(lpszUrlName), dwReserved);
1762
1763     if (dwReserved)
1764     {
1765         ERR("dwReserved != 0\n");
1766         SetLastError(ERROR_INVALID_PARAMETER);
1767         return FALSE;
1768     }
1769
1770     if (!URLCacheContainers_FindContainerA(lpszUrlName, &pContainer))
1771        return FALSE;
1772
1773     if (!URLCacheContainer_OpenIndex(pContainer))
1774         return FALSE;
1775
1776     if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1777         return FALSE;
1778
1779     if (!URLCache_FindEntryInHash(pHeader, lpszUrlName, &pEntry))
1780     {
1781         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1782         TRACE("entry %s not found!\n", lpszUrlName);
1783         SetLastError(ERROR_FILE_NOT_FOUND);
1784         return FALSE;
1785     }
1786
1787     if (pEntry->dwSignature != URL_SIGNATURE)
1788     {
1789         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1790         FIXME("Trying to retrieve entry of unknown format %s\n", debugstr_an((LPSTR)&pEntry->dwSignature, sizeof(DWORD)));
1791         SetLastError(ERROR_FILE_NOT_FOUND);
1792         return FALSE;
1793     }
1794
1795     pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
1796
1797     if (pUrlEntry->dwUseCount == 0)
1798     {
1799         URLCacheContainer_UnlockIndex(pContainer, pHeader);
1800         return FALSE;
1801     }
1802     pUrlEntry->dwUseCount--;
1803     URLCache_HashEntrySetUse(pHeader, lpszUrlName, pUrlEntry->dwUseCount);
1804
1805     URLCacheContainer_UnlockIndex(pContainer, pHeader);
1806
1807     return TRUE;
1808 }
1809
1810 /***********************************************************************
1811  *           UnlockUrlCacheEntryFileW (WININET.@)
1812  *
1813  */
1814 BOOL WINAPI UnlockUrlCacheEntryFileW( LPCWSTR lpszUrlName, DWORD dwReserved )
1815 {
1816     FIXME("(%s, 0x%08lx)\n", debugstr_w(lpszUrlName), dwReserved);
1817     return TRUE;
1818 }
1819
1820 /***********************************************************************
1821  *           CreateUrlCacheEntryA (WININET.@)
1822  *
1823  */
1824 BOOL WINAPI CreateUrlCacheEntryA(
1825     IN LPCSTR lpszUrlName,
1826     IN DWORD dwExpectedFileSize,
1827     IN LPCSTR lpszFileExtension,
1828     OUT LPSTR lpszFileName,
1829     IN DWORD dwReserved
1830 )
1831 {
1832     DWORD len;
1833     WCHAR *url_name;
1834     WCHAR *file_extension;
1835     WCHAR file_name[MAX_PATH];
1836     BOOL bSuccess = FALSE;
1837     DWORD dwError = 0;
1838
1839     if ((len = MultiByteToWideChar(CP_ACP, 0, lpszUrlName, -1, NULL, 0)) != 0 &&
1840         (url_name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0)
1841     {
1842         MultiByteToWideChar(CP_ACP, 0, lpszUrlName, -1, url_name, len);
1843         if ((len = MultiByteToWideChar(CP_ACP, 0, lpszFileExtension, -1, NULL, 0)) != 0 &&
1844             (file_extension = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0)
1845         {
1846             MultiByteToWideChar(CP_ACP, 0, lpszFileExtension, -1, file_extension, len);
1847             if (CreateUrlCacheEntryW(url_name, dwExpectedFileSize, file_extension, file_name, dwReserved))
1848             {
1849                 if (WideCharToMultiByte(CP_ACP, 0, file_name, -1, lpszFileName, MAX_PATH, NULL, NULL) < MAX_PATH)
1850                 {
1851                     bSuccess = TRUE;
1852                 }
1853                 else
1854                 {
1855                     dwError = GetLastError();
1856                 }
1857             }
1858             else
1859             {
1860                 dwError = GetLastError();
1861             }
1862             HeapFree(GetProcessHeap(), 0, file_extension);
1863         }
1864         else
1865         {
1866             dwError = GetLastError();
1867         }
1868         HeapFree(GetProcessHeap(), 0, url_name);
1869         if (!bSuccess)
1870             SetLastError(dwError);
1871     }
1872     return bSuccess;
1873 }
1874 /***********************************************************************
1875  *           CreateUrlCacheEntryW (WININET.@)
1876  *
1877  */
1878 BOOL WINAPI CreateUrlCacheEntryW(
1879     IN LPCWSTR lpszUrlName,
1880     IN DWORD dwExpectedFileSize,
1881     IN LPCWSTR lpszFileExtension,
1882     OUT LPWSTR lpszFileName,
1883     IN DWORD dwReserved
1884 )
1885 {
1886     URLCACHECONTAINER * pContainer;
1887     LPURLCACHE_HEADER pHeader;
1888     CHAR szFile[MAX_PATH];
1889     WCHAR szExtension[MAX_PATH];
1890     LPCWSTR lpszUrlPart;
1891     LPCWSTR lpszUrlEnd;
1892     LPCWSTR lpszFileNameExtension;
1893     LPWSTR lpszFileNameNoPath;
1894     int i;
1895     int countnoextension;
1896     BYTE CacheDir;
1897     LONG lBufferSize;
1898     BOOL bFound = FALSE;
1899     int count;
1900     static WCHAR szWWW[] = {'w','w','w',0};
1901
1902     TRACE("(%s, 0x%08lx, %s, %p, 0x%08lx)\n",
1903         debugstr_w(lpszUrlName),
1904         dwExpectedFileSize,
1905         debugstr_w(lpszFileExtension),
1906         lpszFileName,
1907         dwReserved);
1908
1909     if (dwReserved)
1910     {
1911         ERR("dwReserved != 0\n");
1912         SetLastError(ERROR_INVALID_PARAMETER);
1913         return FALSE;
1914     }
1915
1916     for (lpszUrlEnd = lpszUrlName; *lpszUrlEnd; lpszUrlEnd++)
1917         ;
1918
1919     if (((lpszUrlEnd - lpszUrlName) > 1) && (*(lpszUrlEnd - 1) == '/' || *(lpszUrlEnd - 1) == '\\'))
1920         lpszUrlEnd--;
1921
1922     for (lpszUrlPart = lpszUrlEnd;
1923         (lpszUrlPart >= lpszUrlName);
1924         lpszUrlPart--)
1925     {
1926         if ((*lpszUrlPart == '/' || *lpszUrlPart == '\\') && ((lpszUrlEnd - lpszUrlPart) > 1))
1927         {
1928             bFound = TRUE;
1929             lpszUrlPart++;
1930             break;
1931         }
1932     }
1933     if (!lstrcmpW(lpszUrlPart, szWWW))
1934     {
1935         lpszUrlPart += lstrlenW(szWWW);
1936     }
1937
1938     count = lpszUrlEnd - lpszUrlPart;
1939
1940     if (bFound && (count < MAX_PATH))
1941     {
1942         int len = WideCharToMultiByte(CP_ACP, 0, lpszUrlPart, count, szFile, sizeof(szFile) - 1, NULL, NULL);
1943         if (!len)
1944             return FALSE;
1945         szFile[len] = '\0';
1946         /* FIXME: get rid of illegal characters like \, / and : */
1947     }
1948     else
1949     {
1950         FIXME("need to generate a random filename\n");
1951     }
1952
1953     TRACE("File name: %s\n", debugstr_a(szFile));
1954
1955     if (!URLCacheContainers_FindContainerW(lpszUrlName, &pContainer))
1956         return FALSE;
1957
1958     if (!URLCacheContainer_OpenIndex(pContainer))
1959         return FALSE;
1960
1961     if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
1962         return FALSE;
1963
1964     CacheDir = (BYTE)(rand() % pHeader->DirectoryCount);
1965
1966     lBufferSize = MAX_PATH * sizeof(WCHAR);
1967     URLCache_LocalFileNameToPathW(pContainer, pHeader, szFile, CacheDir, lpszFileName, &lBufferSize);
1968
1969     URLCacheContainer_UnlockIndex(pContainer, pHeader);
1970
1971     for (lpszFileNameNoPath = lpszFileName + lBufferSize / sizeof(WCHAR) - 2;
1972         lpszFileNameNoPath >= lpszFileName;
1973         --lpszFileNameNoPath)
1974     {
1975         if (*lpszFileNameNoPath == '/' || *lpszFileNameNoPath == '\\')
1976             break;
1977     }
1978
1979     countnoextension = lstrlenW(lpszFileNameNoPath);
1980     lpszFileNameExtension = PathFindExtensionW(lpszFileNameNoPath);
1981     if (lpszFileNameExtension)
1982         countnoextension -= lstrlenW(lpszFileNameExtension);
1983     *szExtension = '\0';
1984
1985     if (lpszFileExtension)
1986     {
1987         szExtension[0] = '.';
1988         lstrcpyW(szExtension+1, lpszFileExtension);
1989     }
1990
1991     for (i = 0; i < 255; i++)
1992     {
1993         static WCHAR szFormat[] = {'[','%','u',']','%','s',0};
1994         HANDLE hFile;
1995         wsprintfW(lpszFileNameNoPath + countnoextension, szFormat, i, szExtension);
1996         TRACE("Trying: %s\n", debugstr_w(lpszFileName));
1997         hFile = CreateFileW(lpszFileName, GENERIC_READ, 0, NULL, CREATE_NEW, 0, NULL);
1998         if (hFile != INVALID_HANDLE_VALUE)
1999         {
2000             CloseHandle(hFile);
2001             return TRUE;
2002         }
2003     }
2004
2005     return FALSE;
2006 }
2007
2008
2009 /***********************************************************************
2010  *           CommitUrlCacheEntryInternal (Compensates for an MS bug)
2011  *
2012  *   The bug we are compensating for is that some drongo at Microsoft
2013  *   used lpHeaderInfo to pass binary data to CommitUrlCacheEntryA.
2014  *   As a consequence, CommitUrlCacheEntryA has been effectively
2015  *   redefined as LPBYTE rather than LPCSTR. But CommitUrlCacheEntryW
2016  *   is still defined as LPCWSTR. The result (other than madness) is
2017  *   that we always need to store lpHeaderInfo in CP_ACP rather than
2018  *   in UTF16, and we need to avoid converting lpHeaderInfo in
2019  *   CommitUrlCacheEntryA to UTF16 and then back to CP_ACP, since the
2020  *   result will lose data for arbitrary binary data.
2021  *
2022  */
2023 static BOOL WINAPI CommitUrlCacheEntryInternal(
2024     IN LPCWSTR lpszUrlName,
2025     IN LPCWSTR lpszLocalFileName,
2026     IN FILETIME ExpireTime,
2027     IN FILETIME LastModifiedTime,
2028     IN DWORD CacheEntryType,
2029     IN LPBYTE lpHeaderInfo,
2030     IN DWORD dwHeaderSize,
2031     IN LPCWSTR lpszFileExtension,
2032     IN LPCWSTR lpszOriginalUrl
2033     )
2034 {
2035     URLCACHECONTAINER * pContainer;
2036     LPURLCACHE_HEADER pHeader;
2037     CACHEFILE_ENTRY * pEntry;
2038     URL_CACHEFILE_ENTRY * pUrlEntry;
2039     DWORD dwBytesNeeded = DWORD_ALIGN(sizeof(*pUrlEntry));
2040     DWORD dwOffsetLocalFileName = 0;
2041     DWORD dwOffsetHeader = 0;
2042     DWORD dwFileSizeLow = 0;
2043     DWORD dwFileSizeHigh = 0;
2044     BYTE cDirectory = 0;
2045     char achFile[MAX_PATH];
2046     char achUrl[MAX_PATH];
2047     char *pchLocalFileName = 0;
2048
2049     TRACE("(%s, %s, ..., ..., %lx, %p, %ld, %s, %s)\n",
2050         debugstr_w(lpszUrlName),
2051         debugstr_w(lpszLocalFileName),
2052         CacheEntryType,
2053         lpHeaderInfo,
2054         dwHeaderSize,
2055         debugstr_w(lpszFileExtension),
2056         debugstr_w(lpszOriginalUrl));
2057
2058     if (lpszOriginalUrl)
2059         WARN(": lpszOriginalUrl ignored\n");
2060
2061     if (lpszLocalFileName)
2062     {
2063         HANDLE hFile;
2064
2065         hFile = CreateFileW(lpszLocalFileName, FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL);
2066         if (hFile == INVALID_HANDLE_VALUE)
2067         {
2068             ERR("couldn't open file %s (error is %ld)\n", debugstr_w(lpszLocalFileName), GetLastError());
2069             return FALSE;
2070         }
2071
2072         /* Get file size */
2073         dwFileSizeLow = GetFileSize(hFile, &dwFileSizeHigh);
2074         if ((dwFileSizeLow == INVALID_FILE_SIZE) && (GetLastError() != NO_ERROR))
2075         {
2076             ERR("couldn't get file size (error is %ld)\n", GetLastError());
2077             CloseHandle(hFile);
2078             return FALSE;
2079         }
2080
2081         CloseHandle(hFile);
2082     }
2083
2084     if (!URLCacheContainers_FindContainerW(lpszUrlName, &pContainer))
2085         return FALSE;
2086
2087     if (!URLCacheContainer_OpenIndex(pContainer))
2088         return FALSE;
2089
2090     if (!(pHeader = URLCacheContainer_LockIndex(pContainer)))
2091         return FALSE;
2092
2093     WideCharToMultiByte(CP_ACP, 0, lpszUrlName, -1, achUrl, -1, NULL, NULL);
2094
2095     if (URLCache_FindEntryInHash(pHeader, achUrl, &pEntry))
2096     {
2097         URLCacheContainer_UnlockIndex(pContainer, pHeader);
2098         FIXME("entry already in cache - don't know what to do!\n");
2099 /*
2100  *        SetLastError(ERROR_FILE_NOT_FOUND);
2101  *        return FALSE;
2102  */
2103         return TRUE;
2104     }
2105
2106     if (lpszLocalFileName)
2107     {
2108         BOOL bFound = FALSE;
2109
2110         if (strncmpW(lpszLocalFileName, pContainer->path, lstrlenW(pContainer->path)))
2111         {
2112             URLCacheContainer_UnlockIndex(pContainer, pHeader);
2113             ERR("path %s must begin with cache content path %s\n", debugstr_w(lpszLocalFileName), debugstr_w(pContainer->path));
2114             SetLastError(ERROR_INVALID_PARAMETER);
2115             return FALSE;
2116         }
2117
2118         /* skip container path prefix */
2119         lpszLocalFileName += lstrlenW(pContainer->path);
2120
2121         WideCharToMultiByte(CP_ACP, 0, lpszLocalFileName, -1, achFile, -1, NULL, NULL);
2122         pchLocalFileName = achFile;
2123
2124         for (cDirectory = 0; cDirectory < pHeader->DirectoryCount; cDirectory++)
2125         {
2126             if (!strncmp(pHeader->directory_data[cDirectory].filename, pchLocalFileName, DIR_LENGTH))
2127             {
2128                 bFound = TRUE;
2129                 break;
2130             }
2131         }
2132
2133         if (!bFound)
2134         {
2135             URLCacheContainer_UnlockIndex(pContainer, pHeader);
2136             ERR("cache directory not found in path %s\n", debugstr_w(lpszLocalFileName));
2137             SetLastError(ERROR_INVALID_PARAMETER);
2138             return FALSE;
2139         }
2140
2141         lpszLocalFileName += (DIR_LENGTH + 1); /* "1234WXYZ\" */
2142     }
2143
2144     dwBytesNeeded = DWORD_ALIGN(dwBytesNeeded + strlen(achUrl) + 1);
2145     if (lpszLocalFileName)
2146     {
2147         dwOffsetLocalFileName = dwBytesNeeded;
2148         dwBytesNeeded = DWORD_ALIGN(dwBytesNeeded + strlen(pchLocalFileName) + 1);
2149     }
2150     if (lpHeaderInfo)
2151     {
2152         dwOffsetHeader = dwBytesNeeded;
2153         dwBytesNeeded = DWORD_ALIGN(dwBytesNeeded + dwHeaderSize);
2154     }
2155
2156     /* round up to next block */
2157     if (dwBytesNeeded % BLOCKSIZE)
2158     {
2159         dwBytesNeeded -= dwBytesNeeded % BLOCKSIZE;
2160         dwBytesNeeded += BLOCKSIZE;
2161     }
2162
2163     if (!URLCache_FindFirstFreeEntry(pHeader, dwBytesNeeded / BLOCKSIZE, &pEntry))
2164     {
2165         URLCacheContainer_UnlockIndex(pContainer, pHeader);
2166         ERR("no free entries\n");
2167         SetLastError(ERROR_DISK_FULL);
2168         return FALSE;
2169     }
2170
2171     /* FindFirstFreeEntry fills in blocks used */
2172     pUrlEntry = (URL_CACHEFILE_ENTRY *)pEntry;
2173     pUrlEntry->CacheFileEntry.dwSignature = URL_SIGNATURE;
2174     pUrlEntry->CacheDir = cDirectory;
2175     pUrlEntry->CacheEntryType = CacheEntryType;
2176     pUrlEntry->dwHeaderInfoSize = dwHeaderSize;
2177     pUrlEntry->dwExemptDelta = 0;
2178     pUrlEntry->dwHitRate = 0;
2179     pUrlEntry->dwOffsetHeaderInfo = dwOffsetHeader;
2180     pUrlEntry->dwOffsetLocalName = dwOffsetLocalFileName;
2181     pUrlEntry->dwOffsetUrl = DWORD_ALIGN(sizeof(*pUrlEntry));
2182     pUrlEntry->dwSizeHigh = 0;
2183     pUrlEntry->dwSizeLow = dwFileSizeLow;
2184     pUrlEntry->dwSizeHigh = dwFileSizeHigh;
2185     pUrlEntry->dwUseCount = 0;
2186     GetSystemTimeAsFileTime(&pUrlEntry->LastAccessTime);
2187     pUrlEntry->LastModifiedTime = LastModifiedTime;
2188     FileTimeToDosDateTime(&pUrlEntry->LastAccessTime, &pUrlEntry->wLastSyncDate, &pUrlEntry->wLastSyncTime);
2189     FileTimeToDosDateTime(&ExpireTime, &pUrlEntry->wExpiredDate, &pUrlEntry->wExpiredTime);
2190     pUrlEntry->wUnknownDate = pUrlEntry->wLastSyncDate;
2191     pUrlEntry->wUnknownTime = pUrlEntry->wLastSyncTime;
2192
2193     /*** Unknowns ***/
2194     pUrlEntry->dwUnknown1 = 0;
2195     pUrlEntry->dwUnknown2 = 0;
2196     pUrlEntry->dwUnknown3 = 0x60;
2197     pUrlEntry->Unknown4 = 0;
2198     pUrlEntry->wUnknown5 = 0x1010;
2199     pUrlEntry->dwUnknown6 = 0;
2200     pUrlEntry->dwUnknown7 = 0;
2201     pUrlEntry->dwUnknown8 = 0;
2202
2203
2204     strcpy((LPSTR)pUrlEntry + pUrlEntry->dwOffsetUrl, achUrl);
2205     if (dwOffsetLocalFileName)
2206         strcpy((LPSTR)((LPBYTE)pUrlEntry + dwOffsetLocalFileName), pchLocalFileName);
2207     if (dwOffsetHeader)
2208         memcpy((LPBYTE)pUrlEntry + dwOffsetHeader, lpHeaderInfo, dwHeaderSize);
2209
2210     if (!URLCache_AddEntryToHash(pHeader, achUrl, (DWORD)((LPBYTE)pUrlEntry - (LPBYTE)pHeader)))
2211     {
2212         URLCache_DeleteEntry(pHeader, &pUrlEntry->CacheFileEntry);
2213         URLCacheContainer_UnlockIndex(pContainer, pHeader);
2214         return FALSE;
2215     }
2216
2217     URLCacheContainer_UnlockIndex(pContainer, pHeader);
2218
2219     return TRUE;
2220 }
2221
2222 /***********************************************************************
2223  *           CommitUrlCacheEntryA (WININET.@)
2224  *
2225  */
2226 BOOL WINAPI CommitUrlCacheEntryA(
2227     IN LPCSTR lpszUrlName,
2228     IN LPCSTR lpszLocalFileName,
2229     IN FILETIME ExpireTime,
2230     IN FILETIME LastModifiedTime,
2231     IN DWORD CacheEntryType,
2232     IN LPBYTE lpHeaderInfo,
2233     IN DWORD dwHeaderSize,
2234     IN LPCSTR lpszFileExtension,
2235     IN LPCSTR lpszOriginalUrl
2236     )
2237 {
2238     DWORD len;
2239     WCHAR *url_name;
2240     WCHAR *local_file_name;
2241     WCHAR *original_url = NULL;
2242     BOOL bSuccess = FALSE;
2243     DWORD dwError = 0;
2244
2245     TRACE("(%s, %s, ..., ..., %lx, %p, %ld, %s, %s)\n",
2246         debugstr_a(lpszUrlName),
2247         debugstr_a(lpszLocalFileName),
2248         CacheEntryType,
2249         lpHeaderInfo,
2250         dwHeaderSize,
2251         debugstr_a(lpszFileExtension),
2252         debugstr_a(lpszOriginalUrl));
2253
2254     if (lpszFileExtension != 0)
2255     {
2256         SetLastError(ERROR_INVALID_PARAMETER);
2257         return FALSE;
2258     }
2259     if ((len = MultiByteToWideChar(CP_ACP, 0, lpszUrlName, -1, NULL, 0)) != 0 &&
2260         (url_name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0)
2261     {
2262         MultiByteToWideChar(CP_ACP, 0, lpszUrlName, -1, url_name, len);
2263         if ((len = MultiByteToWideChar(CP_ACP, 0, lpszLocalFileName, -1, NULL, 0)) != 0 &&
2264             (local_file_name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0)
2265         {
2266             MultiByteToWideChar(CP_ACP, 0, lpszLocalFileName, -1, local_file_name, len);
2267             if (!lpszOriginalUrl ||
2268                 ((len = MultiByteToWideChar(CP_ACP, 0, lpszOriginalUrl, -1, NULL, 0)) != 0 &&
2269                   (original_url = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))) != 0))
2270             {
2271                 if (original_url)
2272                     MultiByteToWideChar(CP_ACP, 0, lpszOriginalUrl, -1, original_url, len);
2273                 if (CommitUrlCacheEntryInternal(url_name, local_file_name, ExpireTime, LastModifiedTime,
2274                                         CacheEntryType, lpHeaderInfo, dwHeaderSize,
2275                                         NULL, original_url))
2276                 {
2277                     bSuccess = TRUE;
2278                 }
2279                 else
2280                 {
2281                 dwError = GetLastError();
2282                 }
2283                 if (original_url)
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 }