HTTP Sessions

WinINet vous permet d’accéder aux ressources sur le World Wide Web (WWW). Ces ressources sont accessibles directement à l’aide d’InternetOpenUrl (pour plus d’informations, consultez Accès direct aux URL).

Les ressources du WWW sont accessibles à l’aide de http. Les fonctions HTTP gèrent les protocoles sous-jacents, tout en permettant à votre application d’accéder aux informations sur www. À mesure que le protocole HTTP évolue, les protocoles sous-jacents sont mis à jour pour maintenir le comportement de la fonction.

Le diagramme suivant montre les relations entre les fonctions utilisées avec le protocole HTTP. Les zones ombrées représentent des fonctions qui retournent des handles HINTERNET , tandis que les zones simples représentent des fonctions qui utilisent le handle HINTERNET créé par la fonction dont elles dépendent.

Pour plus d’informations, consultez Handles HINTERNET.

Utilisation des fonctions WinINet pour accéder au www

• Lancement d’une connexion au WWW
• Ouverture d’une demande
• Ajout d’en-têtes de requête
• Envoi d’une demande
• Publication de données sur le serveur
• Obtention d’informations sur une demande
• Téléchargement de ressources à partir du WWW

Les fonctions suivantes sont utilisées pendant les sessions HTTP pour accéder au site WWW.

Lancement d’une connexion au WWW

Pour démarrer une connexion au WWW, l’application doit appeler la fonction InternetConnect sur le HINTERNET racine retourné par InternetOpen. InternetConnect doit établir une session HTTP en déclarant le type de service INTERNET_SERVICE_HTTP. Pour plus d’informations sur l’utilisation d’InternetConnect, consultez Utilisation d’InternetConnect.

Ouverture d’une demande

La fonction HttpOpenRequest ouvre une requête HTTP et retourne un handle HINTERNET qui peut être utilisé par les autres fonctions HTTP. Contrairement aux autres fonctions ouvertes (telles que FtpOpenFile et InternetOpenUrl), HttpOpenRequest n’envoie pas la requête à Internet lorsqu’elle est appelée. La fonction HttpSendRequest envoie la requête et établit une connexion sur le réseau.

HttpOpenRequest prend un handle de session HTTP créé par InternetConnect et un verbe HTTP, un nom d’objet, une chaîne de version, un référent, des types d’acceptation, des indicateurs et une valeur de contexte.

Le verbe HTTP est une chaîne à utiliser dans la requête. Les verbes HTTP courants utilisés dans les requêtes incluent GET, PUT et POST. Si cette valeur est définie sur NULL, HttpOpenRequest utilise la valeur par défaut GET.

Le nom de l’objet est une chaîne qui contient le nom de l’objet cible du verbe HTTP spécifié. Il s’agit généralement d’un nom de fichier, d’un module exécutable ou d’un spécificateur de recherche. Si le nom de l’objet fourni est une chaîne vide, HttpOpenRequest recherche la page par défaut.

La chaîne de version doit contenir la version HTTP. Si ce paramètre a la valeur NULL, la fonction utilise « « HTTP/1.1 » ».

Le référent spécifie l’adresse du document à partir duquel le nom de l’objet a été obtenu. Si ce paramètre a la valeur NULL, aucun référent n’est spécifié.

La chaîne terminée par null qui contient les types accept indique les types de contenu acceptés par l’application. La définition de ce paramètre sur NULL indique qu’aucun type de contenu n’est accepté par l’application. Si une chaîne vide est fournie, l’application indique qu’elle accepte uniquement les documents de type « "text/*" ». La valeur « « "text/* » » indique des documents texte uniquement, et non des images ou d’autres fichiers binaires.

Les valeurs d’indicateur contrôlent la mise en cache, les cookies et les problèmes de sécurité. Pour Microsoft Network (MSN), NTLM et d’autres types d’authentification, définissez l’indicateur INTERNET_FLAG_KEEP_CONNECTION .

Si l’indicateur INTERNET_FLAG_ASYNC a été défini dans l’appel à InternetOpen, une valeur de contexte différente de zéro doit être définie pour une opération asynchrone appropriée.

L’exemple suivant est un exemple d’appel à HttpOpenRequest.

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

Ajout d’en-têtes de requête

La fonction HttpAddRequestHeaders permet aux applications d’ajouter un ou plusieurs en-têtes de requête à la requête initiale. Cette fonction permet à une application d’ajouter des en-têtes de format libre supplémentaires au handle de requête HTTP ; il est destiné à être utilisé par des applications sophistiquées qui nécessitent un contrôle précis sur la requête envoyée au serveur HTTP.

HttpAddRequestHeaders a besoin d’un handle de requête HTTP créé par HttpOpenRequest, chaîne qui contient les en-têtes, la longueur des en-têtes et les modificateurs.

Envoi d’une demande

HttpSendRequest établit une connexion à Internet et envoie la demande au site spécifié. Cette fonction nécessite un handle HINTERNET créé par HttpOpenRequest. HttpSendRequest peut également envoyer des en-têtes supplémentaires ou des informations facultatives. Les informations facultatives sont généralement utilisées pour les opérations qui écrivent des informations sur le serveur, telles que PUT et POST.

Une fois que HttpSendRequest a envoyé la demande, l’application peut utiliser les fonctions InternetReadFile, InternetQueryDataAvailable et InternetSetFilePointer sur le handle HINTERNET créé par HttpOpenRequest pour télécharger les ressources du serveur.

Publication de données sur le serveur

Pour publier des données sur un serveur, le verbe HTTP dans l’appel à HttpOpenRequest doit être POST ou PUT. L’adresse de la mémoire tampon qui contient les données POST doit ensuite être passée au paramètre lpOptional dans HttpSendRequest. Le paramètre dwOptionalLength doit être défini sur la taille des données.

Vous pouvez également utiliser la fonction InternetWriteFile pour publier des données sur un handle HINTERNET envoyé à l’aide de HttpSendRequestEx.

Obtention d’informations sur une demande

HttpQueryInfo permet à une application de récupérer des informations sur une requête HTTP. La fonction nécessite un handle HINTERNET créé par HttpOpenRequest ou InternetOpenUrl, une valeur au niveau des informations et une longueur de mémoire tampon. HttpQueryInfo accepte également une mémoire tampon qui stocke les informations et un index d’en-tête de base zéro qui énumère plusieurs en-têtes portant le même nom.

Téléchargement de ressources à partir du WWW

Après avoir ouvert une requête avec HttpOpenRequest et l’avoir envoyée au serveur avec HttpSendRequest, l’application peut utiliser les fonctions InternetReadFile, InternetQueryDataAvailable et InternetSetFilePointer pour télécharger la ressource à partir du serveur HTTP.

L’exemple suivant télécharge une ressource. La fonction accepte le handle de la fenêtre active, le numéro d’identification d’une zone d’édition et un handle HINTERNET créé par HttpOpenRequest et envoyé par HttpSendRequest. Il utilise InternetQueryDataAvailable pour déterminer la taille de la ressource, puis la télécharge à l’aide d’InternetReadFile. Le contenu est ensuite affiché dans la zone d’édition.

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;
}