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 Direktes Zugreifen auf URLs).

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

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 den HINTERNET-Handle verwenden, der von der Funktion erstellt wurde, von der sie abhängig sind.

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
• Posten von Daten auf dem Server
• Abrufen von Informationen zu einer Anforderung
• Herunterladen von Ressourcen aus dem WWW

Die folgenden Funktionen werden während HTTP-Sitzungen verwendet, um auf das WWW zuzugreifen.

Initiieren einer Verbindung mit dem WWW

Um eine Verbindung mit dem WWW zu starten, muss die Anwendung die InternetConnect-Funktion auf dem von InternetOpen zurückgegebenenHINTERNET-Stamm aufrufen. InternetConnect muss eine HTTP-Sitzung durch Deklarieren des INTERNET_SERVICE_HTTP-Diensttyps einrichten. Weitere Informationen zur Verwendung von InternetConnect finden Sie unter Verwenden von 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 Aufruf nicht an das Internet. Die HttpSendRequest-Funktion sendet die Anforderung und stellt eine Verbindung über das Netzwerk her.

HttpOpenRequest verwendet ein von InternetConnect erstelltes HTTP-Sitzungshandle und ein HTTP-Verb, Objektname, Versionszeichenfolge, Referrer, Accept-Typen, Flags und Kontextwert.

Das HTTP-Verb ist eine Zeichenfolge, die in der Anforderung verwendet werden soll. Gängige 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 Verweis gibt die Adresse des Dokuments an, aus dem der Objektname abgerufen wurde. Wenn dieser Parameter NULL ist, wird kein Verweis angegeben.

Die null-beendete Zeichenfolge, die die Accept-Typen enthält, gibt die von der Anwendung akzeptierten Inhaltstypen an. 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 Zwischenspeicherung, Cookies und Sicherheitsprobleme. Legen Sie für Microsoft Network (MSN), NTLM und andere Authentifizierungstypen das flag INTERNET_FLAG_KEEP_CONNECTION fest.

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

Das folgende Beispiel ist ein Beispielaufruf von HttpOpenRequest.

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

Hinzufügen von Anforderungsheadern

Mit der HttpAddRequestHeaders-Funktion können Anwendungen der anfänglichen Anforderung mindestens einen Anforderungsheader hinzufügen. Mit dieser Funktion kann eine Anwendung zusätzliche Header im freien Format an das HTTP-Anforderungshandle anfügen. Es ist für die Verwendung durch anspruchsvolle Anwendungen vorgesehen, die eine präzise Kontrolle über die an den HTTP-Server gesendete Anforderung erfordern.

HttpAddRequestHeaders benötigt ein von HttpOpenRequest erstelltes HTTP-Anforderungshandle, 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. Diese Funktion erfordert ein von HttpOpenRequesterstelltes HINTERNET-Handle. HttpSendRequest kann 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 Funktionen InternetReadFile, InternetQueryDataAvailable und InternetSetFilePointer auf dem von HttpOpenRequest erstellten HINTERNET-Handle verwenden, um die Ressourcen des Servers herunterzuladen.

Posten von Daten auf dem Server

Um Daten auf einem Server zu posten, 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 InternetWriteFile-Funktion verwenden, um Daten auf einem HINTERNET-Handle zu posten, das mit HttpSendRequestEx gesendet wird.

Abrufen von Informationen zu einer Anforderung

HttpQueryInfo ermöglicht es einer Anwendung, Informationen zu einer HTTP-Anforderung abzurufen. Die Funktion erfordert ein HINTERNET-Handle , das von HttpOpenRequest oder InternetOpenUrl erstellt wurde, einen Wert auf Informationsebene und eine Pufferlänge. 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

Nachdem sie eine Anforderung mit HttpOpenRequest geöffnet und mit HttpSendRequest an den Server gesendet hat, kann die Anwendung die Funktionen InternetReadFile, InternetQueryDataAvailable und InternetSetFilePointer verwenden, um die Ressource vom HTTP-Server herunterzuladen.

Im folgenden Beispiel wird eine Ressource heruntergeladen. Die Funktion akzeptiert das Handle zum aktuellen Fenster, die Identifikationsnummer eines Bearbeitungsfelds und ein von HttpOpenRequest erstelltes und von HttpSendRequest gesendetes HINTERNET-Handle. Sie verwendet InternetQueryDataAvailable , um die Größe der Ressource zu bestimmen und sie dann mithilfe von 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;
}