Buforowanie (Internet systemu Windows)

Funkcje WinINet mają prostą, ale elastyczną, wbudowaną obsługę buforowania. Wszystkie dane pobrane z sieci są buforowane na dysku twardym i pobierane dla kolejnych żądań. Aplikacja może kontrolować buforowanie na każdym żądaniu. W przypadku żądań HTTP z serwera większość otrzymanych nagłówków jest również buforowana. Gdy żądanie HTTP jest spełnione z pamięci podręcznej, buforowane nagłówki są również zwracane do obiektu wywołującego. Dzięki temu pobieranie danych jest bezproblemowe, niezależnie od tego, czy dane pochodzą z pamięci podręcznej, czy z sieci.

Aplikacje muszą prawidłowo przydzielić bufor w celu uzyskania żądanych wyników podczas korzystania z funkcji trwałego buforowania adresów URL. Aby uzyskać więcej informacji, zobacz Korzystanie z buforów.

Zachowanie pamięci podręcznej podczas przetwarzania odpowiedzi

Pamięć podręczna WinINet jest zgodna z dyrektywami kontroli pamięci podręcznej HTTP opisanymi w specyfikacji RFC 2616. Dyrektywy kontroli pamięci podręcznej i flagi zestawu aplikacji określają, co może być buforowane; Jednak winINet określa, co jest rzeczywiście buforowane na podstawie następującego kryterium:

• Usługa WinINet buforuje tylko odpowiedzi HTTP i FTP.
• Tylko odpowiedzi spełniające określone kryteria mogą być przechowywane przez pamięć podręczną i używane w odpowiedzi na kolejne żądanie. Poprawnie działające odpowiedzi są definiowane jako odpowiedzi, które zwracają się pomyślnie.
• Domyślnie usługa WinINet buforuje pomyślne odpowiedzi, chyba że dyrektywa kontroli pamięci podręcznej z serwera lub flaga zdefiniowana przez aplikację wskazuje, że odpowiedź może nie być buforowana.
• Ogólnie rzecz biorąc, odpowiedzi na czasownik GET są buforowane, jeśli zostały spełnione wymagania wymienione powyżej. Odpowiedzi na czasowniki PUT i POST nie są buforowane w żadnych okolicznościach.
• Elementy będą buforowane nawet wtedy, gdy pamięć podręczna jest pełna. Jeśli dodany element powoduje przekroczenie limitu rozmiaru pamięci podręcznej, zaplanowano mechanizm oczyszczania pamięci podręcznej. Domyślnie elementy nie mają gwarancji, że pozostanie więcej niż 10 minut w pamięci podręcznej. Aby uzyskać więcej informacji, zobacz sekcję Cache Scavenger poniżej.
• Protokół HTTPS jest domyślnie buforowany. Jest to zarządzane przez ustawienie globalne, które nie może być zastępowane przez dyrektywy pamięci podręcznej zdefiniowanej przez aplikację. Aby zastąpić ustawienie globalne, wybierz aplet Opcje internetowe w panelu sterowania i przejdź do karty zaawansowanej. Zaznacz pole "Nie zapisuj zaszyfrowanych stron na dysku" w sekcji "Zabezpieczenia".

Buforowanie programu Scavenger

Bufor buforowania okresowo czyści elementy z pamięci podręcznej. Jeśli element jest dodawany do pamięci podręcznej i pamięć podręczna jest pełna, element zostaje dodany, a uruchamiany jest mechanizm czyszczący pamięć podręczną. Jeśli oczyszczacz pamięci podręcznej zakończy rundę oczyszczania i pamięć podręczna nie osiągnęła swojego limitu, oczyszczacz jest zaplanowany na kolejną rundę, gdy do pamięci podręcznej zostanie dodany inny element. Ogólnie rzecz biorąc, moduł czyszczenia jest uruchamiany, gdy dodany element przekracza limit rozmiaru pamięci podręcznej. Domyślnie minimalny czas życia w pamięci podręcznej jest ustawiony na 10 minut, chyba że określono inaczej w dyrektywie sterowania pamięcią podręczną. Po rozpoczęciu działania szperacza pamięci podręcznej nie ma gwarancji, że najstarsze elementy zostaną usunięte z pamięci jako pierwsze.

Pamięć podręczna jest współdzielona we wszystkich aplikacjach WinINet na komputerze dla tego samego użytkownika. Począwszy od systemu Windows Vista i Windows Server 2008 rozmiar pamięci podręcznej jest ustawiony na 1/32 rozmiar dysku, z minimalnym rozmiarem 8 MB i maksymalnym rozmiarem 50 MB.

Używanie flag do kontrolowania buforowania

Flagi buforowania umożliwiają aplikacji kontrolowanie, kiedy i jak używa pamięci podręcznej. Te flagi mogą być używane samodzielnie lub w połączeniu z parametrem dwFlags w funkcjach, które uzyskują dostęp do informacji lub zasobów w Internecie. Domyślnie funkcje przechowują wszystkie dane pobrane z Internetu.

Następujące flagi mogą służyć do kontrolowania buforowania.

Funkcje trwałego buforowania

Klienci, którzy potrzebują trwałych usług buforowania, używają funkcji trwałego buforowania, aby umożliwić aplikacjom zapisywanie danych w lokalnym systemie plików do późniejszego użycia, takich jak w sytuacjach, gdy łącze o niskiej przepustowości ogranicza dostęp do danych lub dostęp nie jest w ogóle dostępny.

Funkcje pamięci podręcznej zapewniają trwałe buforowanie i przeglądanie w trybie offline. Chyba że flaga INTERNET_FLAG_NO_CACHE_WRITE jawnie określa brak buforowania, funkcje buforuje wszystkie dane pobrane z sieci. Odpowiedzi na dane POST nie są buforowane.

Używanie funkcji persistentnej pamięci podręcznej adresów URL

Następujące trwałe funkcje pamięci podręcznej adresów URL umożliwiają aplikacji uzyskiwanie dostępu do informacji przechowywanych w pamięci podręcznej i manipulowanie nimi.

Wyliczanie pamięci podręcznej

Funkcje FindFirstUrlCacheEntry i FindNextUrlCacheEntry wyliczają informacje przechowywane w pamięci podręcznej. FindFirstUrlCacheEntry rozpoczyna wyliczanie, przyjmując jako parametry wzorzec wyszukiwania, bufor i rozmiar buforu, aby utworzyć uchwyt i zwrócić pierwszy wpis pamięci podręcznej. FindNextUrlCacheEntry wykorzystuje uchwyt utworzony przez FindFirstUrlCacheEntry, bufor oraz rozmiar buforu, aby zwrócić kolejny wpis pamięci podręcznej.

Obie funkcje przechowują strukturę INTERNET_CACHE_ENTRY_INFO w buforze. Rozmiar tej struktury zależy od każdego wpisu. Jeśli rozmiar buforu przekazany do jednej z funkcji jest niewystarczający, funkcja zakończy się niepowodzeniem, a GetLastError zwróci ERROR_INSUFFICIENT_BUFFER. Zmienna rozmiaru buforu zawiera rozmiar buforu potrzebnego do uzyskania tego wpisu w pamięci podręcznej. Należy przydzielić bufor rozmiaru wskazanego przez zmienną rozmiaru buforu, a funkcja powinna zostać wywołana ponownie przy użyciu nowego buforu.

Struktura INTERNET_CACHE_ENTRY_INFO zawiera rozmiar struktury, adres URL buforowanych informacji, nazwę pliku lokalnego, typ wpisu pamięci podręcznej, liczbę użycia, szybkość trafień, rozmiar, czas ostatniej modyfikacji, wygaśnięcie, ostatni dostęp, czas ostatniej synchronizacji, informacje nagłówka, rozmiar informacji nagłówka i rozszerzenie nazwy pliku.

Funkcja FindFirstUrlCacheEntry przyjmuje wzorzec wyszukiwania, bufor, który przechowuje strukturę INTERNET_CACHE_ENTRY_INFO i rozmiar buforu. Obecnie zaimplementowany jest tylko domyślny wzorzec wyszukiwania, który zwraca wszystkie wpisy pamięci podręcznej.

Po wyliczenie pamięci podręcznej aplikacja powinna wywołać FindCloseUrlCache, aby zamknąć uchwyt wyliczania pamięci podręcznej.

Poniższy przykład przedstawia w polu listy adres URL każdego wpisu pamięci podręcznej, IDC_CacheList. Używa MAX_CACHE_ENTRY_INFO_SIZE do początkowego przydzielenia buforu, ponieważ wczesne wersje interfejsu API WinINet nie wyliczają pamięci podręcznej prawidłowo. Nowsze wersje poprawnie wyliczają pamięć podręczną i nie ma limitu rozmiaru pamięci podręcznej. Wszystkie aplikacje uruchamiane na komputerach z wersją interfejsu API WinINet z programu Internet Explorer 4.0 muszą przydzielić bufor wymaganego rozmiaru. Aby uzyskać więcej informacji, zobacz Korzystanie z buforów.

int WINAPI EnumerateCacheOld(HWND hX)
{
    DWORD dwEntrySize;
    LPINTERNET_CACHE_ENTRY_INFO lpCacheEntry;
    DWORD MAX_CACHE_ENTRY_INFO_SIZE = 4096;
    HANDLE hCacheDir;
    int nCount=0;

    SendDlgItemMessage(hX,IDC_CacheList,LB_RESETCONTENT,0,0);
    
    SetCursor(LoadCursor(NULL,IDC_WAIT));

    dwEntrySize = MAX_CACHE_ENTRY_INFO_SIZE;
    lpCacheEntry = (LPINTERNET_CACHE_ENTRY_INFO) new char[dwEntrySize];
    lpCacheEntry->dwStructSize = dwEntrySize;

again:

    hCacheDir = FindFirstUrlCacheEntry(NULL,
                                       lpCacheEntry,
                                       &dwEntrySize);
    if (!hCacheDir)                                             
    {
        delete[]lpCacheEntry;
        switch(GetLastError())
        {
            case ERROR_NO_MORE_ITEMS: 
                TCHAR tempout[80];
                _stprintf_s(tempout, 
                            80,   
                            TEXT("The number of cache entries = %d \n"),
                            nCount);
                MessageBox(hX,tempout,TEXT("Cache Enumeration"),MB_OK);
                FindCloseUrlCache(hCacheDir);
                SetCursor(LoadCursor(NULL,IDC_ARROW));
                return TRUE;
                break;
            case ERROR_INSUFFICIENT_BUFFER:
                lpCacheEntry = (LPINTERNET_CACHE_ENTRY_INFO) 
                                new char[dwEntrySize];
                lpCacheEntry->dwStructSize = dwEntrySize;
                goto again;
                break;
            default:
                ErrorOut( hX,GetLastError(),
                          TEXT("FindNextUrlCacheEntry Init"));
                FindCloseUrlCache(hCacheDir);
                SetCursor(LoadCursor(NULL,IDC_ARROW));
                return FALSE;
        }
    }

    SendDlgItemMessage(hX,IDC_CacheList,LB_ADDSTRING,
                       0,(LPARAM)(lpCacheEntry->lpszSourceUrlName));
    nCount++;
    delete (lpCacheEntry);

    do 
    {
        dwEntrySize = MAX_CACHE_ENTRY_INFO_SIZE;
        lpCacheEntry = (LPINTERNET_CACHE_ENTRY_INFO) new char[dwEntrySize];
        lpCacheEntry->dwStructSize = dwEntrySize;

retry:
        if (!FindNextUrlCacheEntry(hCacheDir,
                                   lpCacheEntry, 
                                   &dwEntrySize))
        {
            delete[]lpCacheEntry;
            switch(GetLastError())
            {
                case ERROR_NO_MORE_ITEMS: 
                    TCHAR tempout[80];
                    _stprintf_s(tempout,
                                80,
                                TEXT("The number of cache entries = %d \n"),nCount);
                    MessageBox(hX,
                               tempout,
                               TEXT("Cache Enumeration"),MB_OK);
                    FindCloseUrlCache(hCacheDir);
                    return TRUE;
                    break;
                case ERROR_INSUFFICIENT_BUFFER:
                    lpCacheEntry = 
                             (LPINTERNET_CACHE_ENTRY_INFO) 
                              new char[dwEntrySize];
                    lpCacheEntry->dwStructSize = dwEntrySize;
                    goto retry;
                    break;
                default:
                    ErrorOut(hX,
                             GetLastError(),
                             TEXT("FindNextUrlCacheEntry Init"));
                    FindCloseUrlCache(hCacheDir);
                    return FALSE;
            }
        }

        SendDlgItemMessage(hX,
                           IDC_CacheList,LB_ADDSTRING,
                           0,
                          (LPARAM)(lpCacheEntry->lpszSourceUrlName));
        nCount++;
        delete[] lpCacheEntry;        
    }  while (TRUE);

    SetCursor(LoadCursor(NULL,IDC_ARROW));
    return TRUE;        
}

Pobieranie informacji o wpisie pamięci podręcznej

Funkcja GetUrlCacheEntryInfo umożliwia pobranie struktury INTERNET_CACHE_ENTRY_INFO dla określonego adresu URL. Ta struktura zawiera rozmiar struktury, adres URL buforowanych informacji, nazwę pliku lokalnego, typ wpisu pamięci podręcznej, liczbę trafień, szybkość trafień, rozmiar, czas ostatniej modyfikacji, wygaśnięcie, ostatni dostęp, czas ostatniej synchronizacji, informacje nagłówka, rozmiar informacji nagłówka i rozszerzenie nazwy pliku.

GetUrlCacheEntryInfo akceptuje adres URL, bufor dla struktury INTERNET_CACHE_ENTRY_INFO i rozmiar buforu. Jeśli adres URL zostanie znaleziony, informacje są kopiowane do buforu. W przeciwnym razie funkcja kończy się niepowodzeniem i GetLastError zwraca ERROR_FILE_NOT_FOUND. Jeśli rozmiar buforu jest niewystarczający do przechowywania informacji o wpisie pamięci podręcznej, funkcja kończy się niepowodzeniem, a GetLastError zwraca ERROR_INSUFFICIENT_BUFFER. Rozmiar wymagany do pobrania informacji jest przechowywany w zmiennej rozmiaru buforu.

GetUrlCacheEntryInfo nie wykonuje analizy adresów URL, dlatego adres URL zawierający kotwicę (#) nie zostanie znaleziony w pamięci podręcznej, nawet jeśli zasób jest buforowany. Jeśli na przykład jest przekazany adres URL "https://example.com/example.htm#sample"", funkcja zwraca ERROR_FILE_NOT_FOUND, nawet jeśli "https://example.com/example.htm"" znajduje się w pamięci podręcznej.

Poniższy przykład pobiera informacje o wpisie pamięci podręcznej dla określonego adresu URL. Funkcja wyświetla następnie informacje nagłówka w polu edycji IDC_CacheDump.

int WINAPI GetCacheEntryInfo(HWND hX,LPTSTR lpszUrl)
{
    DWORD dwEntrySize=0;
    LPINTERNET_CACHE_ENTRY_INFO lpCacheEntry;

    SetCursor(LoadCursor(NULL,IDC_WAIT));
    if (!GetUrlCacheEntryInfo(lpszUrl,NULL,&dwEntrySize))
    {
        if (GetLastError()!=ERROR_INSUFFICIENT_BUFFER)
        {
            ErrorOut(hX,GetLastError(),TEXT("GetUrlCacheEntryInfo"));
            SetCursor(LoadCursor(NULL,IDC_ARROW));
            return FALSE;
        }
        else
            lpCacheEntry = (LPINTERNET_CACHE_ENTRY_INFO) 
                            new char[dwEntrySize];
    }
    else
        return FALSE; // should not be successful w/ NULL buffer
                      // and 0 size

    if (!GetUrlCacheEntryInfo(lpszUrl,lpCacheEntry,&dwEntrySize))
    {
        ErrorOut(hX,GetLastError(),TEXT("GetUrlCacheEntryInfo"));
        SetCursor(LoadCursor(NULL,IDC_ARROW));
        return FALSE;
    }
    else
    {
        if ((lpCacheEntry->dwHeaderInfoSize)!=0)
        {
            LPSTR(lpCacheEntry->lpHeaderInfo)
                                [lpCacheEntry->dwHeaderInfoSize]=TEXT('\0');
            SetDlgItemText(hX,IDC_Headers,
                           lpCacheEntry->lpHeaderInfo);
        }
        else
        {
            SetDlgItemText(hX,IDC_Headers,TEXT("None"));
        }

        SetCursor(LoadCursor(NULL,IDC_ARROW));
        return TRUE;
    }
        
}

Tworzenie wpisu pamięci podręcznej

Aplikacja używa funkcji CreateUrlCacheEntry i CommitUrlCacheEntry w celu utworzenia wpisu pamięci podręcznej.

CreateUrlCacheEntry akceptuje adres URL, oczekiwany rozmiar pliku i rozszerzenie nazwy pliku. Następnie funkcja tworzy lokalną nazwę pliku na potrzeby zapisywania wpisu pamięci podręcznej odpowiadającego adresowi URL i rozszerzeniu nazwy pliku.

Używając lokalnej nazwy pliku, zapisz dane w pliku lokalnym. Po zapisaniu danych w pliku lokalnym aplikacja powinna wywołać CommitUrlCacheEntry.

CommitUrlCacheEntry akceptuje adres URL, nazwę pliku lokalnego, wygaśnięcie, czas ostatniej modyfikacji, typ wpisu pamięci podręcznej, informacje nagłówka, rozmiar informacji nagłówka i rozszerzenie nazwy pliku. Następnie funkcja buforuje dane w pliku określonym w magazynie pamięci podręcznej i kojarzy je z danym adresem URL.

W poniższym przykładzie użyto nazwy pliku lokalnego utworzonego przez poprzednie wywołanie metody CreateUrlCacheEntry, przechowywanej w polu tekstowym, IDC_LocalFile, do przechowywania tekstu z pola tekstowego IDC_CacheDumpw wpisie pamięci podręcznej. Po zapisaniu danych do pliku przy użyciu fopenfprintfi fclosewpis zostanie zatwierdzony przy użyciu CommitUrlCacheEntry.

int WINAPI CommitEntry(HWND hX)
{
    LPTSTR lpszUrl, lpszExt, lpszFileName;
    LPTSTR lpszData,lpszSize;
    DWORD dwSize;
    DWORD dwEntryType=0;
    FILE *lpfCacheEntry;
    LPFILETIME lpdtmExpire, lpdtmLastModified;
    LPSYSTEMTIME lpdtmSysTime;
    errno_t err;

    if( SendDlgItemMessage(hX,IDC_RBNormal,BM_GETCHECK,0,0) )
    {
        dwEntryType = dwEntryType + NORMAL_CACHE_ENTRY;
    }
    else if( SendDlgItemMessage(hX,IDC_RBSticky, BM_GETCHECK,0,0) )
    {
        dwEntryType = dwEntryType + STICKY_CACHE_ENTRY;
    }
    else if(SendDlgItemMessage( hX,IDC_RBSparse, BM_GETCHECK,0,0) )
    {
        dwEntryType = dwEntryType + SPARSE_CACHE_ENTRY;
    }
 

    if( SendDlgItemMessage(hX,IDC_RBCookie, BM_GETCHECK,0,0))
    {
            dwEntryType = dwEntryType + COOKIE_CACHE_ENTRY;
    }
    else if( SendDlgItemMessage(hX,IDC_RBUrl, BM_GETCHECK,0,0) )
    {
        dwEntryType = dwEntryType + URLHISTORY_CACHE_ENTRY;
    }


    if( SendDlgItemMessage(hX,IDC_RBNone, BM_GETCHECK,0,0) )
    {
        dwEntryType=0;
    }
        
    lpdtmSysTime = new SYSTEMTIME;
    lpdtmExpire = new FILETIME;
    lpdtmLastModified = new FILETIME;

    GetLocalTime(lpdtmSysTime);
    SystemTimeToFileTime(lpdtmSysTime,lpdtmExpire);
    SystemTimeToFileTime(lpdtmSysTime,lpdtmLastModified);
    delete(lpdtmSysTime);

    lpszUrl = new TCHAR[MAX_PATH];
    lpszFileName = new TCHAR[MAX_PATH];
    lpszExt = new TCHAR[5];
    lpszSize = new TCHAR[10];

    GetDlgItemText(hX,IDC_SourceURL,lpszUrl,MAX_PATH);
    GetDlgItemText(hX,IDC_LocalFile,lpszFileName,MAX_PATH);
    GetDlgItemText(hX,IDC_FileExt,lpszExt,5);

    GetDlgItemText(hX,IDC_SizeLow,lpszSize,10);
    dwSize = (DWORD)_ttol(lpszSize);
    delete(lpszSize);

    if (dwSize==0)
    {
        if((MessageBox(hX,
                       TEXT("Incorrect File Size.\nUsing 8000 characters, Okay?\n"),
                       TEXT("Commit Entry"),MB_YESNO))
                        ==IDYES)
        {
            dwSize = 8000;
        }
        else
        {
            return FALSE;
        }
    }

    lpszData = new TCHAR[dwSize];
    GetDlgItemText(hX,IDC_CacheDump,lpszData,dwSize);
        
     err = _tfopen_s(&lpfCacheEntry,lpszFileName,_T("w"));
     if (err)
        return FALSE;
    fprintf(lpfCacheEntry,"%s",lpszData);
    fclose(lpfCacheEntry);
    delete(lpszData);

    if ( !CommitUrlCacheEntry( lpszUrl, 
                               lpszFileName, 
                               *lpdtmExpire,
                               *lpdtmLastModified, 
                               dwEntryType,
                               NULL,
                               0,
                               lpszExt,
                               0) )
    {
        ErrorOut(hX,GetLastError(),TEXT("Commit Cache Entry"));
        delete(lpszUrl);
        delete(lpszFileName);
        delete(lpszExt);
        delete(lpdtmExpire);
        delete(lpdtmLastModified);
        return FALSE;
    }
    else
    {
        delete(lpszUrl);
        delete(lpszFileName);
        delete(lpszExt);
        delete(lpdtmExpire);
        delete(lpdtmLastModified);
        return TRUE;
    }
}

Usuwanie wpisu pamięci podręcznej

Funkcja DeleteUrlCacheEntry przyjmuje adres URL i usuwa skojarzony z nim plik pamięci podręcznej. Jeśli plik pamięci podręcznej nie istnieje, funkcja zakończy się niepowodzeniem i GetLastError zwróci ERROR_FILE_NOT_FOUND. Jeśli plik pamięci podręcznej jest obecnie zablokowany lub używany, funkcja kończy się niepowodzeniem, a getLastError zwraca ERROR_ACCESS_DENIED. Plik jest usuwany po odblokowaniu.

Pobieranie plików wejściowych pamięci podręcznej

W przypadku aplikacji, które wymagają nazwy pliku zasobu, użyj funkcji RetrieveUrlCacheEntryFile i UnlockUrlCacheEntryFile. Aplikacje, które nie wymagają nazwy pliku, powinny używać funkcji RetrieveUrlCacheEntryStream, ReadUrlCacheEntryStreami UnlockUrlCacheEntryStream, aby pobrać informacje w pamięci podręcznej.

RetrieveUrlCacheEntryStream nie wykonuje analizy adresów URL, dlatego adres URL zawierający kotwicę (#) nie zostanie znaleziony w pamięci podręcznej, nawet jeśli zasób jest buforowany. Na przykład, jeśli zostanie przekazany adres URL "https://example.com/example.htm#sample"", funkcja zwróci ERROR_FILE_NOT_FOUND nawet jeśli "https://example.com/example.htm"" znajduje się w pamięci podręcznej.

RetrieveUrlCacheEntryFile akceptuje adres URL, bufor, który przechowuje strukturę INTERNET_CACHE_ENTRY_INFO i rozmiar buforu. Funkcja jest pobierana i blokowana dla wywołującego.

Po użyciu informacji w pliku aplikacja powinna wywołać UnlockUrlCacheEntryFile, aby odblokować plik.

Grupy pamięci podręcznej

Aby utworzyć grupę pamięci podręcznej, należy wywołać funkcjęCreateUrlCacheGroup, aby wygenerować GROUPID dla grupy pamięci podręcznej. Wpisy można dodać do grupy pamięci podręcznej, podając adres URL wpisu pamięci podręcznej i flagę INTERNET_CACHE_GROUP_ADD do funkcji SetUrlCacheEntryGroup. Aby usunąć wpis pamięci podręcznej z grupy, prześlij adres URL wpisu pamięci podręcznej oraz flagę INTERNET_CACHE_GROUP_REMOVE do SetUrlCacheEntryGroup.

Funkcje FindFirstUrlCacheEntryEx i FindNextUrlCacheEntryEx mogą służyć do wyliczania wpisów w określonej grupie pamięci podręcznej. Po zakończeniu wyliczania funkcja powinna wywołać FindCloseUrlCache.

Obsługa struktur za pomocą informacji o zmiennym rozmiarze

Pamięć podręczna może zawierać informacje o zmiennym rozmiarze dla każdego przechowywanego adresu URL. Jest to odzwierciedlone w strukturze INTERNET_CACHE_ENTRY_INFO. Gdy funkcje pamięci podręcznej zwracają tę strukturę, tworząc bufor, który ma zawsze rozmiar INTERNET_CACHE_ENTRY_INFO plus wszelkie informacje o zmiennym rozmiarze. Jeśli członek wskaźnikowy nie jest NULL, wskazuje na obszar pamięci bezpośrednio po strukturze. Podczas kopiowania buforu zwróconego przez funkcję do innego buforu należy poprawić wskaźniki, aby wskazywały odpowiednie miejsce w nowym buforze, jak pokazano w poniższym przykładzie.

lpDstCEInfo->lpszSourceUrlName = 
    (LPINTERNET_CACHE_ENTRY_INFO) ((LPBYTE) lpSrcCEInfo + 
       ((DWORD)(lpOldCEInfo->lpszSourceUrlName) - (DWORD)lpOldCEInfo));

Niektóre funkcje pamięci podręcznej kończą się niepowodzeniem z komunikatem o błędzie ERROR_INSUFFICIENT_BUFFER, jeśli określisz bufor, który jest zbyt mały, aby zawierał informacje o wpisie pamięci podręcznej pobrane przez funkcję. W takim przypadku funkcja zwraca również wymagany rozmiar buforu. Następnie można przydzielić bufor o odpowiednim rozmiarze i ponownie wywołać funkcję.