FTP Sessions

2025-05-08

WinINet permet aux applications de naviguer et de manipuler des répertoires et des fichiers sur un serveur ftp. Étant donné que les proxys du CERN ne prennent pas en charge FTP, les applications qui utilisent exclusivement un proxy du CERN doivent utiliser la fonction InternetOpenUrl . Pour plus d’informations sur l’utilisation d’InternetOpenUrl, consultez Accès direct aux URL.

Pour démarrer une session FTP, utilisez InternetConnect pour créer le descripteur de session.

WinINet vous permet d’effectuer les actions suivantes sur un serveur FTP :

Naviguez entre les répertoires.
Énumérez, créez, supprimez et renommez des annuaires.
Renommez, chargez, téléchargez et supprimez des fichiers.

La navigation est assurée par les fonctions FtpGetCurrentDirectory et FtpSetCurrentDirectory . Ces fonctions utilisent le descripteur de session créé par un appel précédent à InternetConnect pour déterminer dans quel répertoire se trouve l’application ou pour passer à un autre sous-répertoire.

L’énumération de répertoires s’effectue à l’aide des fonctions FtpFindFirstFile et InternetFindNextFile . FtpFindFirstFile utilise le descripteur de session créé par InternetConnect pour trouver le premier fichier correspondant aux critères de recherche donnés et renvoie un descripteur pour poursuivre l’énumération du répertoire. InternetFindNextFile utilise le descripteur renvoyé par FtpFindFirstFile pour renvoyer le fichier suivant qui correspond aux critères de recherche d’origine. L’application doit continuer à appeler InternetFindNextFile jusqu’à ce qu’il n’y ait plus de fichiers dans le répertoire.

Utilisez la fonction FtpCreateDirectory pour créer de nouveaux répertoires. Cette fonction utilise le descripteur de session créé par InternetConnect et crée le répertoire spécifié par la chaîne passée à la fonction. La chaîne peut contenir un nom de répertoire relatif au répertoire actuel ou un chemin d’accès de répertoire complet.

Pour renommer des fichiers ou des répertoires, l’application peut appeler FtpRenameFile. Cette fonction remplace le nom d’origine par le nouveau nom passé à la fonction. Le nom du fichier ou du répertoire peut être relatif au répertoire actuel ou à un nom complet.

Pour télécharger ou placer des fichiers sur un serveur FTP, l’application peut utiliser FtpPutFile ou FtpOpenFile (avec InternetWriteFile). FtpPutFile peut être utilisé si le fichier existe déjà localement, tandis que FtpOpenFile et InternetWriteFile peuvent être utilisés si des données doivent être écrites dans un fichier sur le serveur FTP.

Pour télécharger ou obtenir des fichiers, l’application peut utiliser FtpGetFile ou FtpOpenFile (avec InternetReadFile). FtpGetFile est utilisé pour récupérer un fichier à partir d’un serveur FTP et le stocker localement, tandis que FtpOpenFile et InternetReadFile peuvent être utilisés pour contrôler l’emplacement des informations téléchargées (par exemple, l’application peut afficher les informations dans une boîte d’édition).

Supprimez des fichiers sur un serveur FTP à l’aide de la fonction FtpDeleteFile . Cette fonction supprime du serveur FTP un nom de fichier relatif soit au répertoire courant, soit à un nom de fichier complet. FtpDeleteFile nécessite un descripteur de session renvoyé par InternetConnect.

Poignées de fonction FTP

Pour fonctionner correctement, les fonctions FTP nécessitent certains types de descripteurs HINTERNET . Ces descripteurs doivent être créés dans un ordre spécifique, en commençant par le descripteur racine créé par InternetOpen. InternetConnect peut alors créer un descripteur de session FTP.

Le diagramme suivant présente les fonctions qui dépendent du descripteur de session FTP renvoyé par InternetConnect. Les zones ombrées représentent les fonctions qui renvoient des descripteurs HINTERNET , tandis que les zones simples représentent les fonctions qui utilisent le descripteur HINTERNET créé par la fonction dont elles dépendent.

Fonctions FTP dépendant du handle de session FTP renvoyé par InternetConnect

Le schéma suivant montre les deux fonctions qui renvoient les descripteurs HINTERNET et les fonctions qui en dépendent. Les zones ombrées représentent les fonctions qui renvoient des descripteurs HINTERNET , tandis que les zones simples représentent les fonctions qui utilisent le descripteur HINTERNET créé par la fonction dont elles dépendent.

Fonctions FTP qui renvoient les poignées hInternet

Pour plus d’informations, consultez handles HINTERNET.

Utilisation des fonctions WinINet pour les sessions FTP

Les fonctions suivantes sont utilisées pendant les sessions FTP. Ces fonctions ne sont pas reconnues par les mandataires du CERN. Les applications qui doivent fonctionner via des proxys du CERN doivent utiliser InternetOpenUrl et accéder directement aux ressources. Pour plus d’informations sur l’accès direct aux ressources, consultez Accès direct aux URL.

Fonction	Descriptif
ftpCreateDirectory	Crée un répertoire sur le serveur. Cette fonction nécessite un handle créé par internetConnect.
ftpDeleteFile	Supprime un fichier du serveur. Cette fonction nécessite un handle créé par internetConnect.
FtpFindFirstFile	Démarre l’énumération ou la recherche de fichiers dans le répertoire courant. Cette fonction nécessite un handle créé par internetConnect.
ftpGetCurrentDirectory	Renvoie le répertoire actuel du client sur le serveur. Cette fonction nécessite un handle créé par internetConnect.
ftpGetFile	Récupère un fichier à partir du serveur. Cette fonction nécessite un handle créé par internetConnect.
FtpOpenFile	Permet d’accéder à un fichier sur le serveur pour la lecture ou l’écriture. Cette fonction nécessite un handle créé par internetConnect.
ftpPutFile	Écrit un fichier sur le serveur. Cette fonction nécessite un handle créé par internetConnect.
ftpRemoveDirectory	Supprime un répertoire sur le serveur. Cette fonction nécessite un handle créé par internetConnect.
ftpRenameFile	Renomme un fichier sur le serveur. Cette fonction nécessite un handle créé par internetConnect.
ftpSetCurrentDirectory	Modifie le répertoire actuel du client sur le serveur. Cette fonction nécessite un handle créé par internetConnect.
FichierÉcriture Internet	Écrit les données dans un fichier ouvert sur le serveur. Cette fonction nécessite un handle créé par FtpOpenFile.

Démarrage d’une session FTP

L’application établit une session FTP en appelant InternetConnect sur un descripteur créé par InternetOpen. InternetConnect a besoin du nom du serveur, du numéro de port, du nom d’utilisateur, du mot de passe et du type de service (qui doit être défini sur INTERNET_SERVICE_FTP). Pour la sémantique FTP passive, l’application doit également définir l’indicateur INTERNET_FLAG_PASSIVE .

Les valeurs INTERNET_DEFAULT_FTP_PORT et INTERNET_INVALID_PORT_NUMBER peuvent être utilisées pour le numéro de port. INTERNET_DEFAULT_FTP_PORT utilise le port FTP par défaut, mais le type de service doit toujours être défini. INTERNET_INVALID_PORT_NUMBER utilise la valeur par défaut du type de service indiqué.

Les valeurs du nom d’utilisateur et du mot de passe peuvent être définies sur NULL. Si les deux valeurs sont définies sur NULL,InternetConnect utilise « anonymous » pour le nom d’utilisateur et l’adresse e-mail de l’utilisateur pour le mot de passe. Si seul le mot de passe est défini sur NULL, le nom d’utilisateur transmis à InternetConnect est utilisé pour le nom d’utilisateur et une chaîne vide est utilisée pour le mot de passe. Si aucune des valeurs n’est NULL, le nom d’utilisateur et le mot de passe donnés à InternetConnect sont utilisés.

Énumération des répertoires

L’énumération d’un répertoire sur un serveur FTP nécessite la création d’un handle par FtpFindFirstFile. Ce descripteur est une branche du descripteur de session créé par InternetConnect. FtpFindFirstFile localise le premier fichier ou répertoire sur le serveur et le renvoie dans une structure WIN32_FIND_DATA . Utilisez InternetFindNextFile jusqu’à ce qu’il renvoie ERROR_NO_MORE_FILES. Cette méthode recherche tous les fichiers et répertoires suivants sur le serveur. Pour plus d’informations sur InternetFindNextFile, consultez Recherche du fichier suivant.

Pour déterminer si le fichier récupéré par FtpFindFirstFile ou InternetFindNextFile est un répertoire, vérifiez le membre dwFileAttributes de la structure WIN32_FIND_DATA pour voir s’il est égal à FILE_ATTRIBUTE_DIRECTORY.

Si l’application apporte des modifications sur le serveur FTP ou si le serveur FTP change fréquemment, les indicateurs INTERNET_FLAG_NO_CACHE_WRITE et INTERNET_FLAG_RELOAD doivent être définis dans FtpFindFirstFile. Ces indicateurs garantissent que les informations de répertoire récupérées à partir du serveur FTP sont à jour.

Une fois que l’application a terminé l’énumération de répertoires, elle doit effectuer un appel à InternetCloseHandle sur le descripteur créé par FtpFindFirstFile. Tant que ce descripteur n’est pas fermé, l’application ne peut pas appeler à nouveau FtpFindFirstFile sur le descripteur de session créé par InternetConnect. Si un appel à FtpFindFirstFile est effectué sur le même descripteur de session avant la fermeture de l’appel précédent à la même fonction, la fonction échoue et renvoie ERROR_FTP_TRANSFER_IN_PROGRESS.

L’exemple suivant énumère le contenu d’un répertoire FTP dans un contrôle de zone de liste. Le paramètre hConnection est un descripteur renvoyé par la fonction InternetConnect après l’établissement d’une session FTP. Vous trouverez un exemple de code source pour la fonction InternetErrorOut référencée dans cet exemple dans la rubrique Gestion des erreurs.

#include <windows.h>
#include <strsafe.h>
#include <wininet.h>

#pragma comment(lib, "wininet.lib")
#pragma comment(lib, "user32.lib")

#define  FTP_FUNCTIONS_BUFFER_SIZE          MAX_PATH+8

BOOL WINAPI DisplayFtpDir(
                           HWND hDlg,
                           HINTERNET hConnection,
                           DWORD dwFindFlags,
                           int nListBoxId )
{
  WIN32_FIND_DATA dirInfo;
  HINTERNET       hFind;
  DWORD           dwError;
  BOOL            retVal = FALSE;
  TCHAR           szMsgBuffer[FTP_FUNCTIONS_BUFFER_SIZE];
  TCHAR           szFName[FTP_FUNCTIONS_BUFFER_SIZE];
  
  SendDlgItemMessage( hDlg, nListBoxId, LB_RESETCONTENT, 0, 0 );
  hFind = FtpFindFirstFile( hConnection, TEXT( "*.*" ), 
                            &dirInfo, dwFindFlags, 0 );
  if ( hFind == NULL )
  {
    dwError = GetLastError( );
    if( dwError == ERROR_NO_MORE_FILES )
    {
      StringCchCopy( szMsgBuffer, FTP_FUNCTIONS_BUFFER_SIZE,
        TEXT( "No files found at FTP location specified." ) );
      retVal = TRUE;
      goto DisplayDirError_1;
    }
    StringCchCopy( szMsgBuffer, FTP_FUNCTIONS_BUFFER_SIZE,
      TEXT( "FtpFindFirstFile failed." ) );
    goto DisplayDirError_1;
  }

  do
  {
    if( FAILED( StringCchCopy( szFName, FTP_FUNCTIONS_BUFFER_SIZE,
                  dirInfo.cFileName ) ) ||
        ( ( dirInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) &&
        ( FAILED( StringCchCat( szFName, FTP_FUNCTIONS_BUFFER_SIZE,
         TEXT( " <DIR> " ) ) ) ) ) )
    {
      StringCchCopy( szMsgBuffer, FTP_FUNCTIONS_BUFFER_SIZE,
        TEXT( "Failed to copy a file or directory name." ) );
      retVal = FALSE;
      goto DisplayDirError_2;
    }
    SendDlgItemMessage( hDlg, nListBoxId, LB_ADDSTRING, 
                        0, (LPARAM) szFName );
  } while( InternetFindNextFile( hFind, (LPVOID) &dirInfo ) );

  if( ( dwError = GetLastError( ) ) == ERROR_NO_MORE_FILES )
  {
    InternetCloseHandle(hFind);
    return( TRUE );
  }
  StringCchCopy( szMsgBuffer, FTP_FUNCTIONS_BUFFER_SIZE,
    TEXT( "FtpFindNextFile failed." ) );

DisplayDirError_2:
  InternetCloseHandle( hFind );
DisplayDirError_1:
  MessageBox( hDlg,
    (LPCTSTR) szMsgBuffer,
    TEXT( "DisplayFtpDir( ) Problem" ),
    MB_OK | MB_ICONERROR );
  return( retVal );
}

Navigation dans les annuaires

Les fonctions FtpGetCurrentDirectory et FtpSetCurrentDirectory gèrent la navigation dans les annuaires.

FtpGetCurrentDirectory renvoie le répertoire actuel de l’application sur le serveur FTP. Le chemin d’accès au répertoire du répertoire racine sur le serveur FTP est inclus.

FtpSetCurrentDirectory modifie le répertoire de travail sur le serveur. Les informations de répertoire transmises à FtpSetCurrentDirectory peuvent être un nom de chemin d’accès partiellement ou entièrement qualifié par rapport au répertoire actuel. Par exemple, si l’application se trouve actuellement dans le répertoire « public/info » et que le chemin d’accès est « ftp/example », FtpSetCurrentDirectory remplace le répertoire actuel par « public/info/ftp/example ».

L’exemple suivant utilise le descripteur de session FTP hConnection, qui est renvoyé par InternetConnect. Le nouveau nom de répertoire est extrait de la boîte d’édition de la boîte de dialogue parente dont l’IDC est passé dans le paramètre nDirNameId . Avant que le changement de répertoire ne soit effectué, la fonction récupère le répertoire actuel et le stocke dans la même boîte d’édition. Le code source de la fonction DisplayFtpDir appelée à la fin est répertorié ci-dessus.

BOOL WINAPI ChangeFtpDir( HWND hDlg, 
                          HINTERNET hConnection,
                          int nDirNameId, 
                          int nListBoxId )
{
  DWORD dwSize;
  TCHAR szNewDirName[FTP_FUNCTIONS_BUFFER_SIZE];
  TCHAR szOldDirName[FTP_FUNCTIONS_BUFFER_SIZE];
  TCHAR* szFailedFunctionName;

  dwSize = FTP_FUNCTIONS_BUFFER_SIZE;

  if( !GetDlgItemText( hDlg, nDirNameId, szNewDirName, dwSize ) )
  {
    szFailedFunctionName = TEXT( "GetDlgItemText" );
    goto ChangeFtpDirError;
  }

  if ( !FtpGetCurrentDirectory( hConnection, szOldDirName, &dwSize ))
  {
    szFailedFunctionName = TEXT( "FtpGetCurrentDirectory" );
    goto ChangeFtpDirError;
  }

  if( !SetDlgItemText( hDlg, nDirNameId, szOldDirName ) )
  {
    szFailedFunctionName = TEXT( "SetDlgItemText" );
    goto ChangeFtpDirError;
  }

  if( !FtpSetCurrentDirectory( hConnection, szNewDirName ) )
  {
    szFailedFunctionName = TEXT( "FtpSetCurrentDirectory" );
    goto ChangeFtpDirError;
  }
  return( DisplayFtpDir( hDlg, hConnection, 0, nListBoxId ) );

ChangeFtpDirError:
  InternetErrorOut( hDlg, GetLastError( ), szFailedFunctionName );
  DisplayFtpDir( hDlg, hConnection, INTERNET_FLAG_RELOAD, nListBoxId);
  return( FALSE );
}

Manipulation de répertoires sur un serveur FTP

WinINet offre la possibilité de créer et de supprimer des répertoires sur un serveur FTP pour lesquels l’application dispose des privilèges nécessaires. Si l’application doit se connecter à un serveur avec un nom d’utilisateur et un mot de passe spécifiques, les valeurs peuvent être utilisées dans InternetConnect lors de la création du descripteur de session FTP.

La fonction FtpCreateDirectory prend un descripteur de session FTP valide et une chaîne terminée par un caractère nul qui contient soit un chemin d’accès complet, soit un nom relatif au répertoire actuel, et crée un répertoire sur le serveur FTP.

L’exemple suivant montre deux appels distincts à FtpCreateDirectory. Dans les deux exemples, hFtpSession est le descripteur de session créé par la fonction InternetConnect et le répertoire racine est le répertoire courant.

/* Creates the directory "test" in the current (root) directory. */
FtpCreateDirectory( hFtpSession, "test" );

/* Creates the directory "example" in the test directory. */
FtpCreateDirectory( hFtpSession, "\\test\\example" );

La fonction FtpRemoveDirectory prend un descripteur de session et une chaîne terminée par un caractère NULL qui contient soit un chemin d’accès complet, soit un nom relatif au répertoire actuel, et supprime ce répertoire du serveur FTP.

L’exemple suivant montre deux exemples d’appels à FtpRemoveDirectory. Dans les deux appels, hFtpSession est le descripteur de session créé par la fonction InternetConnect et le répertoire racine est le répertoire actif. Il y a un répertoire appelé « test » dans le répertoire racine et un répertoire appelé « example » dans le répertoire « test ».

/* Removes the "example" directory (plus any files/directories it contains) from the "test" directory. */
FtpRemoveDirectory(hFtpSession,"\\test\\example");

/* Removes the "test" directory (plus any files/directories it contains) from the root directory. */
FtpRemoveDirectory(hFtpSession, "test");

FtpRemoveDirectory(hFtpSession,TEXT("\\test\\example"));
/* Removes the "example" directory and any files or 
directories contained in it from the "test" directory. */

FtpRemoveDirectory(hFtpSession, TEXT("test"));
/* Removes the "test" directory and any files or 
directories contained in it from the root directory. */

L’exemple suivant crée un répertoire sur le serveur FTP. Le nouveau nom de répertoire est extrait de la boîte d’édition de la boîte de dialogue parente dont l’IDC est passé dans le paramètre nDirNameId . Le descripteur hConnection a été créé par InternetConnect après l’établissement d’une session FTP. Le code source de la fonction DisplayFtpDir appelée à la fin est répertorié ci-dessus.

BOOL WINAPI CreateFtpDir( HWND hDlg, HINTERNET hConnection,
                          int nDirNameId, int nListBoxId )
{
  TCHAR szNewDirName[FTP_FUNCTIONS_BUFFER_SIZE];

  if( !GetDlgItemText( hDlg, nDirNameId, 
                       szNewDirName, 
                       FTP_FUNCTIONS_BUFFER_SIZE ) )
  {
    MessageBox( hDlg, 
                TEXT( "Error: Directory Name Must Be Specified" ),
                TEXT( "Create FTP Directory" ), 
                MB_OK | MB_ICONERROR );
    return( FALSE );
  }

  if( !FtpCreateDirectory( hConnection, szNewDirName ) )
  {
    InternetErrorOut( hDlg, GetLastError( ), 
                      TEXT( "FtpCreateDirectory" ) );
    return( FALSE );
  }

  return( DisplayFtpDir( hDlg, hConnection, 
                         INTERNET_FLAG_RELOAD, 
                         nListBoxId ) );
}

L’exemple suivant supprime un répertoire du serveur FTP. Le nom du répertoire à supprimer est extrait de la boîte d’édition de la boîte de dialogue parente dont l’IDC est passé dans le paramètre nDirNameId . Le descripteur hConnection a été créé par InternetConnect après l’établissement d’une session FTP. Le code source de la fonction DisplayFtpDir appelée à la fin est répertorié ci-dessus.

BOOL WINAPI RemoveFtpDir( HWND hDlg, HINTERNET hConnection,
                          int nDirNameId, int nListBoxId )
{
  TCHAR szDelDirName[FTP_FUNCTIONS_BUFFER_SIZE];

  if( !GetDlgItemText( hDlg, nDirNameId, szDelDirName, 
                       FTP_FUNCTIONS_BUFFER_SIZE ) )
  {
    MessageBox( hDlg, 
                TEXT( "Error: Directory Name Must Be Specified" ),
                TEXT( "Remove FTP Directory" ), 
                MB_OK | MB_ICONERROR );
    return( FALSE );
  }

  if( !FtpRemoveDirectory( hConnection, szDelDirName ) )
  {
    InternetErrorOut( hDlg, GetLastError( ), 
                      TEXT( "FtpRemoveDirectory" ) );
    return( FALSE );
  }

  return( DisplayFtpDir( hDlg, hConnection, 
                         INTERNET_FLAG_RELOAD, nListBoxId ) );
}

Obtention de fichiers sur un serveur FTP

Il existe trois méthodes pour récupérer des fichiers à partir d’un serveur FTP :

Utilisez InternetOpenUrl et InternetReadFile.
Utilisez FtpOpenFile et InternetReadFile.
Utilisez FtpGetFile.

Pour plus d’informations sur l’utilisation de la fonction InternetReadFile , voir Lecture de fichiers.

Si l’URL du fichier est disponible, l’application peut appeler InternetOpenUrl pour se connecter à cette URL, puis utiliser InternetReadFile pour contrôler le téléchargement du fichier. Cela permet à l’application de mieux contrôler le téléchargement et est idéal pour les situations où aucune autre opération n’a besoin d’être effectuée sur le serveur FTP. Pour plus d’informations sur l’accès direct aux ressources, consultez Accès direct aux URL.

Si l’application a établi un descripteur de session FTP sur le serveur avec InternetConnect, l’application peut appeler FtpOpenFile avec le nom de fichier existant et avec un nouveau nom pour le fichier stocké localement. L’application peut ensuite utiliser InternetReadFile pour télécharger le fichier. Cela permet à l’application de contrôler plus étroitement le téléchargement et de maintenir la connexion au serveur FTP, de sorte que davantage de commandes peuvent être exécutées.

Si l’application n’a pas besoin d’un contrôle strict sur le téléchargement, elle peut utiliser FtpGetFile avec le descripteur de session FTP, le nom du fichier distant et le nom du fichier local pour récupérer le fichier. FtpGetFile effectue toute la comptabilité et les frais généraux associés à la lecture d’un fichier à partir d’un serveur FTP et à son stockage local.

L’exemple suivant récupère un fichier à partir d’un serveur FTP et l’enregistre localement. Le nom du fichier sur le serveur FTP est extrait de la zone d’édition de la boîte de dialogue parente dont l’IDC est passé dans le paramètre nFtpFileNameId , et le nom local sous lequel le fichier est enregistré est extrait de la zone d’édition dont l’IDC est passé dans le paramètre nLocalFileNameId . Le descripteur hConnection a été créé par InternetConnect après l’établissement d’une session FTP.

BOOL WINAPI GetFtpFile( HWND hDlg, HINTERNET hConnection,
                        int nFtpFileNameId, int nLocalFileNameId )
{
  TCHAR szFtpFileName[FTP_FUNCTIONS_BUFFER_SIZE];
  TCHAR szLocalFileName[FTP_FUNCTIONS_BUFFER_SIZE];
  DWORD dwTransferType;
  TCHAR szBoxTitle[] = TEXT( "Download FTP File" );
  TCHAR szAsciiQuery[] =
    TEXT("Do you want to download as ASCII text?(Default is binary)");
  TCHAR szAsciiDone[] = 
    TEXT( "ASCII Transfer completed successfully..." );
  TCHAR szBinaryDone[] = 
    TEXT( "Binary Transfer completed successfully..." );

  if( !GetDlgItemText( hDlg, nFtpFileNameId, szFtpFileName,
                       FTP_FUNCTIONS_BUFFER_SIZE ) ||
      !GetDlgItemText( hDlg, nLocalFileNameId, szLocalFileName,
                       FTP_FUNCTIONS_BUFFER_SIZE ) )
  {
    MessageBox( hDlg, 
                TEXT( "Target File or Destination File Missing" ),
                szBoxTitle, 
                MB_OK | MB_ICONERROR );
    return( FALSE );
  }

  dwTransferType = ( MessageBox( hDlg, 
                                 szAsciiQuery, 
                                 szBoxTitle, 
                                 MB_YESNO ) == IDYES ) ?
                   FTP_TRANSFER_TYPE_ASCII : FTP_TRANSFER_TYPE_BINARY;
  dwTransferType |= INTERNET_FLAG_RELOAD;

  if( !FtpGetFile( hConnection, szFtpFileName, szLocalFileName, FALSE,
                   FILE_ATTRIBUTE_NORMAL, dwTransferType, 0 ) )
  {
    InternetErrorOut( hDlg, GetLastError( ), TEXT( "FtpGetFile" ) );
    return( FALSE );
  }

  MessageBox( hDlg,( dwTransferType == 
                      (FTP_TRANSFER_TYPE_ASCII | INTERNET_FLAG_RELOAD)) ?
                      szAsciiDone : szBinaryDone, szBoxTitle, MB_OK );
  return( TRUE );
}

Placement de fichiers sur un serveur FTP

Il existe deux méthodes pour placer un fichier sur un serveur FTP :

Utilisez FtpOpenFile avec InternetWriteFile.
Utilisez FtpPutFile.

Une application qui doit envoyer des données à un serveur FTP, mais qui ne dispose pas d’un fichier local contenant toutes les données, doit utiliser FtpOpenFile pour créer et ouvrir un fichier sur le serveur ftp. L’application peut ensuite utiliser InternetWriteFile pour télécharger les informations dans le fichier.

Si le fichier existe déjà localement, l’application peut utiliser FtpPutFile pour télécharger le fichier sur le serveur FTP. FtpPutFile effectue toute la surcharge liée au téléchargement d’un fichier local sur un serveur FTP distant.

L’exemple suivant copie un fichier local sur le serveur FTP. Le nom local du fichier est extrait de la zone d’édition de la boîte de dialogue parent dont l’IDC est passé dans le paramètre nLocalFileNameId , et le nom sous lequel le fichier est enregistré sur le serveur FTP est extrait de la zone d’édition dont l’IDC est passé dans le paramètre nFtpFileNameId . Le descripteur hConnection a été créé par InternetConnect après l’établissement d’une session FTP.

BOOL WINAPI PutFtpFile( HWND hDlg, HINTERNET hConnection,
                        int nFtpFileNameId, int nLocalFileNameId )
{
  TCHAR szFtpFileName[FTP_FUNCTIONS_BUFFER_SIZE];
  TCHAR szLocalFileName[FTP_FUNCTIONS_BUFFER_SIZE];
  DWORD dwTransferType;
  TCHAR szBoxTitle[] = TEXT( "Upload FTP File" );
  TCHAR szASCIIQuery[] =
    TEXT("Do you want to upload as ASCII text? (Default is binary)");
  TCHAR szAsciiDone[] = 
    TEXT( "ASCII Transfer completed successfully..." );
  TCHAR szBinaryDone[] = 
    TEXT( "Binary Transfer completed successfully..." );

  if( !GetDlgItemText( hDlg, nFtpFileNameId, szFtpFileName,
                       FTP_FUNCTIONS_BUFFER_SIZE ) ||
      !GetDlgItemText( hDlg, nLocalFileNameId, szLocalFileName,
                       FTP_FUNCTIONS_BUFFER_SIZE ) )
  {
    MessageBox( hDlg, 
                TEXT("Target File or Destination File Missing"),
                szBoxTitle, 
                MB_OK | MB_ICONERROR );
    return( FALSE );
  }

  dwTransferType =
    ( MessageBox( hDlg, 
                  szASCIIQuery, 
                  szBoxTitle, 
                  MB_YESNO ) == IDYES ) ?
    FTP_TRANSFER_TYPE_ASCII : FTP_TRANSFER_TYPE_BINARY;

  if( !FtpPutFile( hConnection, 
                   szLocalFileName, 
                   szFtpFileName, 
                   dwTransferType, 
                   0 ) )
  {
    InternetErrorOut( hDlg, GetLastError( ), TEXT( "FtpGetFile" ) );
    return( FALSE );
  }

  MessageBox( hDlg,
              ( dwTransferType == FTP_TRANSFER_TYPE_ASCII ) ?
                szAsciiDone : szBinaryDone, szBoxTitle, MB_OK );
  return( TRUE );  // Remember to refresh directory listing
}

Suppression de fichiers d’un serveur FTP

Pour supprimer un fichier d’un serveur FTP, utilisez la fonction FtpDeleteFile . L’application appelante doit disposer des privilèges nécessaires pour supprimer un fichier du serveur FTP.

L’exemple suivant supprime un fichier du serveur FTP. Le nom du fichier à supprimer est extrait de la boîte d’édition de la boîte de dialogue parent dont l’IDC est passé dans le paramètre nFtpFileNameId . Le descripteur hConnection a été créé par InternetConnect après l’établissement d’une session FTP. Étant donné que cette fonction n’actualise pas les listes de fichiers ou l’affichage des répertoires, le processus d’appel doit le faire en cas de suppression réussie.

BOOL WINAPI DeleteFtpFile( HWND hDlg, HINTERNET hConnection,
                           int nFtpFileNameId )
{
  TCHAR szFtpFileName[FTP_FUNCTIONS_BUFFER_SIZE];
  TCHAR szBoxTitle[] = TEXT( "Delete FTP File" );

  if( !GetDlgItemText( hDlg, nFtpFileNameId, szFtpFileName,
                       FTP_FUNCTIONS_BUFFER_SIZE ) )
  {
    MessageBox( hDlg, TEXT( "File Name Must Be Specified!" ),
                szBoxTitle, MB_OK | MB_ICONERROR );
    return( FALSE );
  }

  if( !FtpDeleteFile( hConnection, szFtpFileName ) )
  {
    InternetErrorOut( hDlg, 
                      GetLastError( ), 
                      TEXT( "FtpDeleteFile" ) );
    return( FALSE );
  }

  MessageBox( hDlg, 
              TEXT( "File has been deleted" ), 
              szBoxTitle, 
              MB_OK );
  return( TRUE );  // Remember to refresh directory listing
}

Renommage de fichiers et de répertoires sur un serveur FTP

Les fichiers et les répertoires d’un serveur FTP peuvent être renommés à l’aide de la fonction FtpRenameFile . FtpRenameFile accepte deux chaînes terminées par des valeurs nulles qui contiennent des noms partiellement ou entièrement qualifiés relatifs au répertoire courant. La fonction remplace le nom du fichier désigné par la première chaîne par le nom désigné par la deuxième chaîne.

L’exemple suivant renomme un fichier ou un répertoire sur le serveur FTP. Le nom actuel du fichier ou du répertoire est extrait de la zone d’édition de la boîte de dialogue parente dont l’IDC est passé dans le paramètre nOldFileNameId , et le nouveau nom est extrait de la zone d’édition dont l’IDC est passé dans le paramètre nNewFileNameId . Le descripteur hConnection a été créé par InternetConnect après l’établissement d’une session FTP. Étant donné que cette fonction n’actualise pas les listes de fichiers ou l’affichage des répertoires, le processus d’appel doit le faire une fois le changement de nom réussi.

BOOL WINAPI RenameFtpFile( HWND hDlg, HINTERNET hConnection,
                           int nOldFileNameId, int nNewFileNameId )
{
  TCHAR szOldFileName[FTP_FUNCTIONS_BUFFER_SIZE];
  TCHAR szNewFileName[FTP_FUNCTIONS_BUFFER_SIZE];
  TCHAR szBoxTitle[] = TEXT( "Rename FTP File" );

  if( !GetDlgItemText( hDlg, nOldFileNameId, szOldFileName,
                       FTP_FUNCTIONS_BUFFER_SIZE ) ||
      !GetDlgItemText( hDlg, nNewFileNameId, szNewFileName,
                       FTP_FUNCTIONS_BUFFER_SIZE ) )
  {
    MessageBox( hDlg,
        TEXT( "Both the current and new file names must be supplied" ),
        szBoxTitle, 
        MB_OK | MB_ICONERROR );
    return( FALSE );
  }

  if( !FtpRenameFile( hConnection, szOldFileName, szNewFileName ) )
  {
    MessageBox( hDlg,
        TEXT( "FtpRenameFile failed" ),
        szBoxTitle, 
        MB_OK | MB_ICONERROR );
    return( FALSE );
  }
  return( TRUE );  // Remember to refresh directory listing
}

Remarque

WinINet ne prend pas en charge les implémentations de serveur. En outre, il ne doit pas être utilisé à partir d’un service. Pour les implémentations de serveur ou les services, utilisez Microsoft Windows HTTP Services (WinHTTP).