Partager via

FTP Sessions

  • Article

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

Pour commencer une session FTP, utilisez InternetConnect pour créer le handle 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 répertoires.
  • Renommez, chargez, téléchargez et supprimez des fichiers.

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

L’énumération de répertoires est effectuée à l’aide des fonctions FtpFindFirstFile et InternetFindNextFile . FtpFindFirstFile utilise le handle de session créé par InternetConnect pour rechercher le premier fichier qui correspond aux critères de recherche donnés et retourne un handle pour continuer l’énumération du répertoire. InternetFindNextFile utilise le handle retourné 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 ne reste plus de fichiers dans le répertoire.

Utilisez la fonction FtpCreateDirectory pour créer de nouveaux répertoires. Cette fonction utilise le handle 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 actif ou un chemin d’accès complet au 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 actif ou à un nom complet.

Pour 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 zone d’édition).

Supprimez des fichiers sur un serveur FTP à l’aide de la fonction FtpDeleteFile . Cette fonction supprime un nom de fichier relatif au répertoire actif ou à un nom de fichier complet du serveur FTP. FtpDeleteFile nécessite un handle de session retourné par InternetConnect.

Handles de fonction FTP

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

Le diagramme suivant montre les fonctions qui dépendent du handle de session FTP retourné par InternetConnect. 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.

Fonctions ftp dépendantes du handle de session ftp retourné par internetconnect

Le diagramme suivant montre les deux fonctions qui retournent les handles HINTERNET et les fonctions qui en dépendent. 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.

Fonctions ftp qui retournent des handles 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 proxys 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 Description
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 de fichiers ou la recherche de fichiers dans le répertoire actif. Cette fonction nécessite un handle créé par InternetConnect.
FtpGetCurrentDirectory Retourne 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 Lance l’accès à un fichier sur le serveur à des fins de lecture ou d’é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.
InternetWriteFile Écrit des 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 handle 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 pour le 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 « anonyme » 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 passé à 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’a la valeur 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 handle est une branche du handle de session créé par InternetConnect. FtpFindFirstFile localise le premier fichier ou répertoire sur le serveur et le retourne dans une structure WIN32_FIND_DATA . Utilisez InternetFindNextFile jusqu’à ce qu’il retourne 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, case activée 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 actuelles.

Une fois l’énumération de répertoire terminée, l’application doit appeler InternetCloseHandle sur le handle créé par FtpFindFirstFile. Tant que ce handle n’est pas fermé, l’application ne peut pas appeler FtpFindFirstFile à nouveau sur le handle de session créé par InternetConnect. Si un appel à FtpFindFirstFile est effectué sur le même handle de session avant la fermeture de l’appel précédent à la même fonction, la fonction échoue, renvoyant 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 handle retourné par la fonction InternetConnect après avoir établi 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 );
}

Les fonctions FtpGetCurrentDirectory et FtpSetCurrentDirectory gèrent la navigation dans les répertoires.

FtpGetCurrentDirectory retourne le répertoire actif de l’application sur le serveur FTP. Le chemin du répertoire à partir 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 complet par rapport au répertoire actif. 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 actif par « public/info/ftp/example ».

L’exemple suivant utilise le handle de session FTP hConnection, qui est retourné par InternetConnect. Le nouveau nom de 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 nDirNameId . Avant la modification du répertoire, la fonction récupère le répertoire actif et le stocke dans la même zone d’édition. Le code de souce pour 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 permet de créer et de supprimer des répertoires sur un serveur FTP sur lequel 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 handle de session FTP.

La fonction FtpCreateDirectory prend un handle de session FTP valide et une chaîne null terminée qui contient un chemin complet ou un nom relatif au répertoire actif 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 handle de session créé par la fonction InternetConnect , et le répertoire racine est le répertoire actif.

/* 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 handle de session et une chaîne null terminée qui contient un chemin complet ou un nom relatif au répertoire actif et supprime ce répertoire du serveur FTP.

L’exemple suivant montre deux exemples d’appels à FtpRemoveDirectory. Dans les deux appels, hFtpSession est le handle de session créé par la fonction InternetConnect , et le répertoire racine est le répertoire actif. Il existe un répertoire appelé « test » dans le répertoire racine et un répertoire appelé « exemple » 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 zone d’édition de la boîte de dialogue parente dont l’IDC est passé dans le paramètre nDirNameId . Le handle hConnection a été créé par InternetConnect après avoir établi 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 zone d’édition de la boîte de dialogue parente dont l’IDC est passé dans le paramètre nDirNameId . Le handle hConnection a été créé par InternetConnect après avoir établi 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 :

Pour plus d’informations sur l’utilisation de la fonction InternetReadFile , consultez 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 contrôler plus étroitement 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 handle de session FTP pour 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 conserver la connexion au serveur FTP, ce qui permet d’exécuter davantage de commandes.

Si l’application n’a pas besoin d’un contrôle strict sur le téléchargement, l’application peut utiliser FtpGetFile avec le handle de session FTP, le nom de fichier distant et le nom de fichier local pour récupérer le fichier. FtpGetFile effectue toute la comptabilité et la surcharge associées à la lecture d’un fichier à partir d’un serveur FTP et à son stockage localement.

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 transmis dans le paramètre nFtpFileNameId , et le nom local sous lequel le fichier est enregistré est extrait de la zone d’édition dont IDC est passé dans le paramètre nLocalFileNameId . Le handle hConnection a été créé par InternetConnect après avoir établi 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 :

Une application qui doit envoyer des données à un serveur FTP, mais qui n’a pas de 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 charger les informations dans le fichier.

Si le fichier existe déjà localement, l’application peut utiliser FtpPutFile pour charger le fichier sur le serveur FTP. FtpPutFile effectue toute la surcharge associée au 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 parente dont l’IDC est transmis 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 IDC est passé dans le paramètre nFtpFileNameId . Le handle hConnection a été créé par InternetConnect après avoir établi 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 zone d’édition de la boîte de dialogue parente dont IDC est passé dans le paramètre nFtpFileNameId . Le handle hConnection a été créé par InternetConnect après avoir établi 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
}

Renommer des fichiers et des répertoires sur un serveur FTP

Les fichiers et les répertoires sur un serveur FTP peuvent être renommés à l’aide de la fonction FtpRenameFile . FtpRenameFile accepte deux chaînes terminées par null qui contiennent des noms partiellement qualifiés ou complets par rapport au répertoire actif. 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 provient 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 transmis dans le paramètre nNewFileNameId . Le handle hConnection a été créé par InternetConnect après avoir établi 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 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
}

Notes

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).