HTTP-Sitzungen

Mit WinINet können Sie auf Ressourcen im World Wide Web (WWW) zugreifen. Auf diese Ressourcen kann direkt über InternetOpenUrl- zugegriffen werden (weitere Informationen finden Sie unter Zugreifen auf URLs direkt).

Auf Ressourcen im WWW wird über http zugegriffen. Die HTTP-Funktionen behandeln die zugrunde liegenden Protokolle, während Ihre Anwendung auf Informationen über das WWW zugreifen kann. Während sich das HTTP-Protokoll weiterentwickelt, werden die zugrunde liegenden Protokolle aktualisiert, um das Funktionsverhalten aufrechtzuerhalten.

Das folgende Diagramm zeigt die Beziehungen der Funktionen, die mit dem HTTP-Protokoll verwendet werden. Die schattierten Felder stellen Funktionen dar, die HINTERNET- Handles zurückgeben, während die einfachen Felder Funktionen darstellen, die das HINTERNET- Handle verwenden, das von der Funktion erstellt wird, von der sie abhängen.

verwendet werden

Weitere Informationen finden Sie unter HINTERNET Handles.

Verwenden der WinINet-Funktionen für den Zugriff auf das WWW

• Initiieren einer Verbindung mit dem WWW-
• Öffnen einer Anforderung
• Hinzufügen von Anforderungsheadern
• Senden einer Anforderung
• Bereitstellen von Daten an den Server
• Abrufen von Informationen zu einer Anforderung
• Herunterladen von Ressourcen aus der WWW-

Die folgenden Funktionen werden während HTTP-Sitzungen für den Zugriff auf das WWW verwendet.

Initiieren einer Verbindung mit dem WWW

Um eine Verbindung mit www zu starten, muss die Anwendung die InternetConnect--Funktion im Stamm-HINTERNET aufrufen, von InternetOpenzurückgegeben wird. InternetConnect- muss eine HTTP-Sitzung einrichten, indem der INTERNET_SERVICE_HTTP-Diensttyp deklariert wird. Weitere Informationen zur Verwendung InternetConnect-finden Sie unter Using InternetConnect.

Öffnen einer Anforderung

Die HttpOpenRequest-Funktion öffnet eine HTTP-Anforderung und gibt ein HINTERNET- Handle zurück, das von den anderen HTTP-Funktionen verwendet werden kann. Im Gegensatz zu den anderen geöffneten Funktionen (z. B. FtpOpenFile- und InternetOpenUrl), sendet HttpOpenRequest die Anforderung beim Aufrufen nicht an das Internet. Die HttpSendRequest--Funktion sendet die Anforderung und stellt eine Verbindung über das Netzwerk her.

HttpOpenRequest- übernimmt ein HTTP-Sitzungshandle, das von InternetConnect erstellt wurde, sowie einen HTTP-Verb, Objektname, Versionszeichenfolge, Referrer, Akzeptieren von Typen, Flags und Kontextwert.

Das HTTP-Verb ist eine Zeichenfolge, die in der Anforderung verwendet werden soll. Allgemeine HTTP-Verben, die in Anforderungen verwendet werden, sind GET, PUT und POST. Wenn dieser Wert auf NULL-festgelegt ist, verwendet HttpOpenRequest den Standardwert GET.

Der Objektname ist eine Zeichenfolge, die den Namen des Zielobjekts des angegebenen HTTP-Verbs enthält. Dies ist in der Regel ein Dateiname, ein ausführbares Modul oder ein Suchbezeichner. Wenn der angegebene Objektname eine leere Zeichenfolge ist, sucht HttpOpenRequest- nach der Standardseite.

Die Versionszeichenfolge sollte die HTTP-Version enthalten. Wenn dieser Parameter NULL-ist, verwendet die Funktion ""HTTP/1.1".

Der Verweiser gibt die Adresse des Dokuments an, aus dem der Objektname abgerufen wurde. Wenn dieser Parameter NULL-ist, wird kein Verweiser angegeben.

Die null-terminated string, die die Accept-Typen enthält, gibt die inhaltstypen an, die von der Anwendung akzeptiert werden. Wenn Sie diesen Parameter auf NULL- festlegen, wird angegeben, dass keine Inhaltstypen von der Anwendung akzeptiert werden. Wenn eine leere Zeichenfolge angegeben wird, gibt die Anwendung an, dass sie nur Dokumente vom Typ ""text/*" akzeptiert. Der Wert ""text/*"" gibt nur Textdokumente an , nicht Bilder oder andere Binärdateien.

Die Flagwerte steuern das Zwischenspeichern, Cookies und Sicherheitsprobleme. Legen Sie für Microsoft Network (MSN), NTLM und andere Authentifizierungstypen das INTERNET_FLAG_KEEP_CONNECTION Flag fest.

Wenn das INTERNET_FLAG_ASYNC-Flag im Aufruf von InternetOpenfestgelegt wurde, sollte für einen ordnungsgemäßen asynchronen Vorgang ein Nichtzerokontextwert festgelegt werden.

Das folgende Beispiel ist ein Beispielaufruf für HttpOpenRequest.

hHttpRequest = HttpOpenRequest( hHttpSession, "GET", "", NULL, "", NULL, 0, 0);

Hinzufügen von Anforderungsheadern

Mit der HttpAddRequestHeaders--Funktion können Anwendungen eine oder mehrere Anforderungsheader zur ursprünglichen Anforderung hinzufügen. Mit dieser Funktion kann eine Anwendung zusätzliche Freiformatheader an das HTTP-Anforderungshandle anfügen. sie ist für die Verwendung durch anspruchsvolle Anwendungen vorgesehen, die eine genaue Kontrolle über die anforderung erfordern, die an den HTTP-Server gesendet wird.

HttpAddRequestHeaders benötigt ein HTTP-Anforderungshandle, das von HttpOpenRequesterstellt wird, eine Zeichenfolge, die die Header, die Länge der Header und Modifizierer enthält.

Senden einer Anforderung

HttpSendRequest stellt eine Verbindung mit dem Internet her und sendet die Anforderung an die angegebene Website. Für diese Funktion ist ein HINTERNET- Handle erforderlich, das von HttpOpenRequesterstellt wurde. HttpSendRequest- können auch zusätzliche Header oder optionale Informationen senden. Die optionalen Informationen werden in der Regel für Vorgänge verwendet, die Informationen auf den Server schreiben, z. B. PUT und POST.

Nachdem HttpSendRequest die Anforderung gesendet hat, kann die Anwendung die InternetReadFile-, InternetQueryDataAvailable-und InternetSetFilePointer-funktionen auf dem HINTERNET Handle verwenden, das von HttpOpenRequest erstellt wurde, um die Ressourcen des Servers herunterzuladen.

Veröffentlichen von Daten auf dem Server

Um Daten auf einem Server zu veröffentlichen, muss das HTTP-Verb im Aufruf von HttpOpenRequest- ENTWEDER POST oder PUT sein. Die Adresse des Puffers, der die POST-Daten enthält, sollte dann an den parameter lpOptional in HttpSendRequestübergeben werden. Der dwOptionalLength Parameter sollte auf die Größe der Daten festgelegt werden.

Sie können auch die funktion InternetWriteFile verwenden, um Daten in einem HINTERNET Handle zu posten, das mithilfe von HttpSendRequestExgesendet wird.

Abrufen von Informationen zu einer Anforderung

HttpQueryInfo- ermöglicht einer Anwendung das Abrufen von Informationen zu einer HTTP-Anforderung. Für die Funktion ist ein HINTERNET- Handle erforderlich, das von HttpOpenRequest oder InternetOpenUrl-, einem Wert auf Informationsebene und einer Pufferlänge erstellt wurde. HttpQueryInfo akzeptiert auch einen Puffer, der die Informationen speichert, und einen nullbasierten Headerindex, der mehrere Header mit demselben Namen aufzählt.

Herunterladen von Ressourcen aus dem WWW

Nach dem Öffnen einer Anforderung mit HttpOpenRequest- und dem Senden an den Server mit HttpSendRequest-kann die Anwendung die InternetReadFile-, InternetQueryDataAvailable-und InternetSetFilePointer-Funktionen verwenden, um die Ressource vom HTTP-Server herunterzuladen.

Im folgenden Beispiel wird eine Ressource heruntergeladen. Die Funktion akzeptiert das Handle für das aktuelle Fenster, die Identifikationsnummer eines Bearbeitungsfelds und ein HINTERNET- Handle, das von HttpOpenRequest erstellt und von HttpSendRequestgesendet wird. Es verwendet InternetQueryDataAvailable-, um die Größe der Ressource zu bestimmen und dann mit InternetReadFile-herunterzuladen. Der Inhalt wird dann im Bearbeitungsfeld angezeigt.

int WINAPI Dumper(HWND hX, int intCtrlID, HINTERNET hResource)
{
    LPTSTR lpszData;    // buffer for the data
    DWORD  dwSize;       // size of the data available
    DWORD  dwDownloaded; // size of the downloaded data
    DWORD  dwSizeSum=0;  // size of the data in the textbox
    LPTSTR lpszHolding;  // buffer to merge the textbox data and buffer

    // Set the cursor to an hourglass.
    SetCursor(LoadCursor(NULL,IDC_WAIT));

    // This loop handles reading the data.
    do
    {
        // The call to InternetQueryDataAvailable determines the
        // amount of data available to download.
        if (!InternetQueryDataAvailable(hResource,&dwSize,0,0))
        {
            printf("InternetQueryDataAvailable failed (%d)\n", GetLastError());
            SetCursor(LoadCursor(NULL,IDC_ARROW));
            return FALSE;
        }
        else
        {
            // Allocate a buffer of the size returned by
            // InternetQueryDataAvailable.
            lpszData = new TCHAR[dwSize+1];

            // Read the data from the HINTERNET handle.
            if(!InternetReadFile(hResource,
                                 (LPVOID)lpszData,
                                 dwSize,
                                 &dwDownloaded))
            {
                printf("InternetReadFile failed (%d)\n", GetLastError());
                delete[] lpszData;
                break;
            }
            else
            {
                // Add a null terminator to the end of the data buffer
                lpszData[dwDownloaded]='\0';

                // Allocate the holding buffer.
                lpszHolding = new TCHAR[dwSizeSum + dwDownloaded + 1];

                // Check if there has been any data written
                // to the textbox.
                if (dwSizeSum != 0)
                {
                    // Retrieve the data stored in the textbox if any
                    GetDlgItemText(hX,intCtrlID,
                                   (LPTSTR)lpszHolding,
                                   dwSizeSum);

                    // Add a null terminator at the end of the
                    // textbox data.
                    lpszHolding[dwSizeSum]='\0';
                }
                else
                {
                    // Make the holding buffer an empty string.
                    lpszHolding[0]='\0';
                }

                size_t cchDest = dwSizeSum + dwDownloaded + dwDownloaded + 1;
                LPTSTR* ppszDestEnd = 0;
                size_t* pcchRemaining = 0;

                // Add the new data to the holding buffer
                HRESULT hr = StringCchCatEx(lpszHolding,
                                            cchDest,
                                            lpszData,
                                            ppszDestEnd,
                                            pcchRemaining,
                                            STRSAFE_NO_TRUNCATION);

                if(SUCCEEDED(hr))
                {
                    // Write the holding buffer to the textbox.
                    SetDlgItemText(hX,intCtrlID,(LPTSTR)lpszHolding);

                    // Delete the two buffers.
                    delete[] lpszHolding;
                    delete[] lpszData;

                    // Add the size of the downloaded data to the
                    // textbox data size.
                    dwSizeSum = dwSizeSum + dwDownloaded + 1;

                    // Check the size of the remaining data.
                    // If it is zero, break.
                    if (dwDownloaded == 0)
                        break;
                    else
                    {
                    //  TODO: Insert error handling code here.
                    }
                }
            }
        }
    }
    while(TRUE);

    // Close the HINTERNET handle.
    InternetCloseHandle(hResource);

    // Set the cursor back to an arrow.
    SetCursor(LoadCursor(NULL,IDC_ARROW));

    return TRUE;
}