Sessioni FTP

Articolo
06/13/2023

WinINet consente alle applicazioni di spostarsi e modificare directory e file in un server FTP. Poiché i proxy CERN non supportano FTP, le applicazioni che usano esclusivamente un proxy CERN devono usare la funzione InternetOpenUrl . Per altre informazioni su come usare InternetOpenUrl, vedere Accesso diretto agli URL.

Per avviare una sessione FTP, usare InternetConnect per creare l'handle di sessione.

WinINet consente di eseguire le azioni seguenti in un server FTP:

Spostarsi tra directory.
Enumerare, creare, rimuovere e rinominare le directory.
Rinominare, caricare, scaricare ed eliminare file.

La navigazione viene fornita dalle funzioni FtpGetCurrentDirectory e FtpSetCurrentDirectory . Queste funzioni utilizzano l'handle di sessione creato da una chiamata precedente a InternetConnect per determinare la directory in cui si trova l'applicazione o per passare a una sottodirectory diversa.

L'enumerazione directory viene eseguita usando le funzioni FtpFindFirstFile e InternetFindNextFile . FtpFindFirstFile usa l'handle di sessione creato da InternetConnect per trovare il primo file che corrisponde ai criteri di ricerca specificati e restituisce un handle per continuare l'enumerazione della directory. InternetFindNextFile usa l'handle restituito da FtpFindFirstFile per restituire il file successivo che corrisponde ai criteri di ricerca originali. L'applicazione deve continuare a chiamare InternetFindNextFile fino a quando non sono stati lasciati altri file nella directory.

Usare la funzione FtpCreateDirectory per creare nuove directory. Questa funzione usa l'handle di sessione creato da InternetConnect e crea la directory specificata dalla stringa passata alla funzione. La stringa può contenere un nome di directory relativo alla directory corrente o un percorso di directory completo.

Per rinominare file o directory, l'applicazione può chiamare FtpRenameFile. Questa funzione sostituisce il nome originale con il nuovo nome passato alla funzione. Il nome del file o della directory può essere relativo alla directory corrente o a un nome completo.

Per caricare o inserire file in un server FTP, l'applicazione può usare FtpPutFile o FtpOpenFile (insieme a InternetWriteFile). FtpPutFile può essere usato se il file esiste già in locale, mentre FtpOpenFile e InternetWriteFile possono essere usati se i dati devono essere scritti in un file nel server FTP.

Per scaricare o ottenere file, l'applicazione può usare FtpGetFile o FtpOpenFile (con InternetReadFile). FtpGetFile viene usato per recuperare un file da un server FTP e archiviarlo in locale, mentre FtpOpenFile e InternetReadFile possono essere usati per controllare dove stanno andando le informazioni scaricate( ad esempio, l'applicazione potrebbe visualizzare le informazioni in una casella di modifica).

Eliminare i file in un server FTP usando la funzione FtpDeleteFile . Questa funzione rimuove un nome file relativo alla directory corrente o a un nome di file completo dal server FTP. FtpDeleteFile richiede un handle di sessione restituito da InternetConnect.

Handle di funzione FTP

Per funzionare correttamente, le funzioni FTP richiedono determinati tipi di handle DELLA RETE. Questi handle devono essere creati in un ordine specifico, a partire dall'handle radice creato da InternetOpen. InternetConnect può quindi creare un handle di sessione FTP.

Il diagramma seguente illustra le funzioni che dipendono dall'handle di sessione FTP restituito da InternetConnect. Le caselle ombreggiate rappresentano le funzioni che restituiscono handle DELL'INTERFACCIA UTENTE , mentre le caselle semplici rappresentano le funzioni che usano l'handle DELLANET CREATO dalla funzione da cui dipendono.

Funzioni ftp dipendenti dall'handle di sessione ftp restituito da Internetconnect

Il diagramma seguente illustra le due funzioni che restituiscono handle DELL'interfaccia UTENTE E le funzioni che dipendono da esse. Le caselle ombreggiate rappresentano le funzioni che restituiscono handle DELL'INTERFACCIA UTENTE , mentre le caselle semplici rappresentano le funzioni che usano l'handle DELLANET CREATO dalla funzione da cui dipendono.

funzioni ftp che restituiscono handle di subnetnet

Per altre informazioni, vedere HANDLE DELLA RETE GESTITA.

Uso delle funzioni WinINet per le sessioni FTP

Le funzioni seguenti vengono usate durante le sessioni FTP. Queste funzioni non vengono riconosciute dai proxy CERN. Le applicazioni che devono funzionare tramite proxy CERN devono usare InternetOpenUrl e accedere direttamente alle risorse. Per altre informazioni sull'accesso diretto alle risorse, vedere Accesso diretto agli URL.

Funzione	Descrizione
FtpCreateDirectory	Crea una nuova directory nel server. Questa funzione richiede un handle creato da InternetConnect.
FtpDeleteFile	Elimina un file dal server. Questa funzione richiede un handle creato da InternetConnect.
FtpFindFirstFile	Avvia l'enumerazione o la ricerca di file nella directory corrente. Questa funzione richiede un handle creato da InternetConnect.
FtpGetCurrentDirectory	Restituisce la directory corrente del client nel server. Questa funzione richiede un handle creato da InternetConnect.
Ftpgetfile	Recupera un file dal server. Questa funzione richiede un handle creato da InternetConnect.
FtpOpenFile	Avvia l'accesso a un file nel server per la lettura o la scrittura. Questa funzione richiede un handle creato da InternetConnect.
FtpPutFile	Scrive un file nel server. Questa funzione richiede un handle creato da InternetConnect.
FtpRemoveDirectory	Elimina una directory nel server. Questa funzione richiede un handle creato da InternetConnect.
FtpRenameFile	Rinomina un file nel server. Questa funzione richiede un handle creato da InternetConnect.
FtpSetCurrentDirectory	Modifica la directory corrente del client nel server. Questa funzione richiede un handle creato da InternetConnect.
InternetWriteFile	Scrive i dati in un file aperto nel server. Questa funzione richiede un handle creato da FtpOpenFile.

Avvio di una sessione FTP

L'applicazione stabilisce una sessione FTP chiamando InternetConnect su un handle creato da InternetOpen. InternetConnect richiede il nome del server, il numero di porta, il nome utente, la password e il tipo di servizio ( che deve essere impostato su INTERNET_SERVICE_FTP). Per la semantica FTP passiva, l'applicazione deve anche impostare il flag INTERNET_FLAG_PASSIVE .

I valori INTERNET_DEFAULT_FTP_PORT e INTERNET_INVALID_PORT_NUMBER possono essere usati per il numero di porta. INTERNET_DEFAULT_FTP_PORT usa la porta FTP predefinita, ma il tipo di servizio deve essere ancora impostato. INTERNET_INVALID_PORT_NUMBER usa il valore predefinito per il tipo di servizio indicato.

I valori per il nome utente e la password possono essere impostati su NULL. Se entrambi i valori sono impostati su NULL, InternetConnect usa "anonimo" per il nome utente e l'indirizzo di posta elettronica dell'utente per la password. Se solo la password è impostata su NULL, il nome utente passato a InternetConnect viene usato per il nome utente e viene usata una stringa vuota per la password. Se nessuno dei due valori è NULL, vengono usati il nome utente e la password specificati in InternetConnect .

Enumerazione delle directory

L'enumerazione di una directory in un server FTP richiede la creazione di un handle da FtpFindFirstFile. Questo handle è un ramo dell'handle di sessione creato da InternetConnect. FtpFindFirstFile individua il primo file o la prima directory nel server e la restituisce in una struttura WIN32_FIND_DATA . Usare InternetFindNextFile fino a quando non restituisce ERROR_NO_MORE_FILES. Questo metodo trova tutti i file e le directory successivi nel server. Per altre informazioni su InternetFindNextFile, vedere Ricerca del file successivo.

Per determinare se il file recuperato da FtpFindFirstFile o InternetFindNextFile è una directory, controllare il membro dwFileAttributes della struttura WIN32_FIND_DATA per verificare se è uguale a FILE_ATTRIBUTE_DIRECTORY .

Se l'applicazione apporta modifiche al server FTP o se il server FTP cambia spesso, i flag di INTERNET_FLAG_NO_CACHE_WRITE e INTERNET_FLAG_RELOAD devono essere impostati in FtpFindFirstFile. Questi flag garantiscono che le informazioni sulla directory recuperate dal server FTP siano correnti.

Al termine dell'enumerazione della directory, l'applicazione deve effettuare una chiamata a InternetCloseHandle nell'handle creato da FtpFindFirstFile. Fino a quando tale handle non è chiuso, l'applicazione non può chiamare di nuovo FtpFindFirstFile nell'handle di sessione creato da InternetConnect. Se viene eseguita una chiamata a FtpFindFirstFile nello stesso handle di sessione prima della chiamata precedente alla stessa funzione, la funzione ha esito negativo, restituendo ERROR_FTP_TRANSFER_IN_PROGRESS.

L'esempio seguente enumera il contenuto di una directory FTP in un controllo casella di riepilogo. Il parametro hConnection è un handle restituito dalla funzione InternetConnect dopo aver stabilito una sessione FTP. Il codice sorgente di esempio per la funzione InternetErrorOut a cui fa riferimento in questo esempio è disponibile nell'argomento Gestione degli errori.

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

Spostamento di directory

Le funzioni FtpGetCurrentDirectory e FtpSetCurrentDirectory gestiscono lo spostamento della directory.

FtpGetCurrentDirectory restituisce la directory corrente dell'applicazione nel server FTP. Il percorso della directory dalla directory radice nel server FTP è incluso.

FtpSetCurrentDirectory modifica la directory di lavoro nel server. Le informazioni sulla directory passate a FtpSetCurrentDirectory possono essere un nome di percorso parzialmente o completo rispetto alla directory corrente. Ad esempio, se l'applicazione è attualmente nella directory "public/info" e il percorso è "ftp/example", FtpSetCurrentDirectory modifica la directory corrente in "public/info/ftp/example".

Nell'esempio seguente viene usato l'handle di sessione FTP hConnection, restituito da InternetConnect. Il nuovo nome della directory viene tratto dalla casella di modifica della finestra di dialogo padre il cui IDC viene passato nel parametro nDirNameId . Prima di apportare la modifica della directory, la funzione recupera la directory corrente e la archivia nella stessa casella di modifica. Il codice souce per la funzione DisplayFtpDir chiamato alla fine è elencato sopra.

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

Modifica di directory in un server FTP

WinINet offre la possibilità di creare e rimuovere directory in un server FTP in cui l'applicazione dispone dei privilegi necessari. Se l'applicazione deve accedere a un server con un nome utente e una password specifici, i valori possono essere usati in InternetConnect durante la creazione dell'handle di sessione FTP.

La funzione FtpCreateDirectory accetta un handle di sessione FTP valido e una stringa con terminazione null contenente un percorso completo o un nome relativo alla directory corrente e crea una directory nel server FTP.

Nell'esempio seguente vengono illustrate due chiamate separate a FtpCreateDirectory. In entrambi gli esempi hFtpSession è l'handle di sessione creato dalla funzione InternetConnect e la directory radice è la directory corrente.

/* 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 funzione FtpRemoveDirectory accetta un handle di sessione e una stringa con terminazione null contenente un percorso completo o un nome relativo alla directory corrente e rimuove tale directory dal server FTP.

Nell'esempio seguente vengono illustrate due chiamate di esempio a FtpRemoveDirectory. In entrambe le chiamate hFtpSession è l'handle di sessione creato dalla funzione InternetConnect e la directory radice è la directory corrente. Nella directory radice è presente una directory denominata "test" e una directory denominata "example" nella directory "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. */

Nell'esempio seguente viene creata una nuova directory nel server FTP. Il nuovo nome della directory viene tratto dalla casella di modifica della finestra di dialogo padre il cui IDC viene passato nel parametro nDirNameId . L'handle hConnection è stato creato da InternetConnect dopo aver stabilito una sessione FTP. Il codice sorgente per la funzione DisplayFtpDir chiamato alla fine è elencato sopra.

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

Nell'esempio seguente viene eliminata una directory dal server FTP. Il nome della directory da eliminare viene tratto dalla casella di modifica nella finestra di dialogo padre il cui IDC viene passato al parametro nDirNameId . L'handle hConnection è stato creato da InternetConnect dopo aver stabilito una sessione FTP. Il codice sorgente per la funzione DisplayFtpDir chiamato alla fine è elencato sopra.

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

Recupero di file in un server FTP

Esistono tre metodi per il recupero di file da un server FTP:

Usare InternetOpenUrl e InternetReadFile.
Usare FtpOpenFile e InternetReadFile.
Usare FtpGetFile.

Per altre informazioni sull'uso della funzione InternetReadFile , vedere Lettura di file.

Se l'URL del file è disponibile, l'applicazione può chiamare InternetOpenUrl per connettersi a tale URL, quindi usare InternetReadFile per controllare il download del file. Ciò consente all'applicazione di controllare più strettamente il download ed è ideale per situazioni in cui non è necessario eseguire altre operazioni nel server FTP. Per altre informazioni su come accedere direttamente alle risorse, vedere Accesso diretto agli URL.

Se l'applicazione ha stabilito un handle di sessione FTP nel server con InternetConnect, l'applicazione può chiamare FtpOpenFile con il nome del file esistente e con un nuovo nome per il file archiviato in locale. L'applicazione può quindi usare InternetReadFile per scaricare il file. Ciò consente all'applicazione di controllare più strettamente il download e mantiene la connessione al server FTP, in modo che sia possibile eseguire più comandi.

Se l'applicazione non ha bisogno di un controllo stretto sul download, l'applicazione può usare FtpGetFile con l'handle di sessione FTP, il nome del file remoto e il nome del file locale per recuperare il file. FtpGetFile esegue tutte le operazioni di conservazione e sovraccarico associate alla lettura di un file da un server FTP e l'archiviazione in locale.

L'esempio seguente recupera un file da un server FTP e lo salva in locale. Il nome del file nel server FTP viene tratto dalla casella di modifica nella finestra di dialogo padre il cui IDC viene passato nel parametro nFtpFileNameId e il nome locale in cui viene salvato il file viene tratto dalla casella di modifica il cui IDC viene passato nel parametro nLocalFileNameId . L'handle hConnection è stato creato da InternetConnect dopo aver stabilito una sessione 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 );
}

Inserimento di file in un server FTP

Esistono due metodi per inserire un file in un server FTP:

Usare FtpOpenFile con InternetWriteFile.
Usare FtpPutFile.

Un'applicazione che deve inviare dati a un server FTP, ma non dispone di un file locale contenente tutti i dati, deve usare FtpOpenFile per creare e aprire un file nel server ftp. L'applicazione può quindi usare InternetWriteFile per caricare le informazioni nel file.

Se il file esiste già in locale, l'applicazione può usare FtpPutFile per caricare il file nel server FTP. FtpPutFile esegue tutto il sovraccarico che passa con il caricamento di un file locale in un server FTP remoto.

Nell'esempio seguente viene copiato un file locale nel server FTP. Il nome locale del file viene tratto dalla casella di modifica nella finestra di dialogo padre il cui IDC viene passato nel parametro nLocalFileNameId e il nome in cui il file viene salvato nel server FTP viene tratto dalla casella di modifica il cui IDC viene passato nel parametro nFtpFileNameId . L'handle hConnection è stato creato da InternetConnect dopo aver stabilito una sessione 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
}

Eliminazione di file da un server FTP

Per eliminare un file da un server FTP, usare la funzione FtpDeleteFile . L'applicazione chiamante deve disporre dei privilegi necessari per eliminare un file dal server FTP.

Nell'esempio seguente viene eliminato un file dal server FTP. Il nome del file da eliminare viene tratto dalla casella di modifica nella finestra di dialogo padre il cui IDC viene passato al parametro nFtpFileNameId . L'handle hConnection è stato creato da InternetConnect dopo aver stabilito una sessione FTP. Poiché questa funzione non aggiorna gli elenchi di file o la visualizzazione della directory, il processo chiamante deve eseguire questa operazione al termine dell'eliminazione.

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
}

Ridenominazione di file e directory in un server FTP

I file e le directory in un server FTP possono essere rinominati usando la funzione FtpRenameFile . FtpRenameFile accetta due stringhe con terminazione null che contengono nomi parzialmente o completi relativi alla directory corrente. La funzione modifica il nome del file designato dalla prima stringa al nome designato dalla seconda stringa.

Nell'esempio seguente viene rinominato un file o una directory nel server FTP. Il nome corrente del file o della directory viene tratto dalla casella di modifica nella finestra di dialogo padre il cui IDC viene passato nel parametro nOldFileNameId e il nuovo nome viene preso dalla casella di modifica il cui IDC viene passato nel parametro nNewFileNameId . L'handle hConnection è stato creato da InternetConnect dopo aver stabilito una sessione FTP. Poiché questa funzione non aggiorna gli elenchi di file o la visualizzazione della directory, il processo chiamante deve eseguire questa operazione al momento della ridenominazione corretta.

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
}

Nota

WinINet non supporta le implementazioni del server. Inoltre, non deve essere usato da un servizio. Per le implementazioni o i servizi server usano Microsoft Windows HTTP Services (WinHTTP).