FTP-sessioner

WinINet gör det möjligt för program att navigera och manipulera kataloger och filer på en ftp-server. Eftersom CERN-proxyservrar inte stöder FTP måste program som använder en CERN-proxy uteslutande använda funktionen InternetOpenUrl. Mer information om hur du använder InternetOpenUrlfinns i Åtkomst till URL:er direkt.

Om du vill starta en FTP-session använder du InternetConnect för att skapa sessionshandtaget.

Med WinINet kan du utföra följande åtgärder på en FTP-server:

• Navigera mellan kataloger.
• Räkna upp, skapa, ta bort och byt namn på kataloger.
• Byt namn på, ladda upp, ladda ned och ta bort filer.

Navigering tillhandahålls av funktionerna FtpGetCurrentDirectory och FtpSetCurrentDirectory. Dessa funktioner använder sessionshandtaget som skapades av ett tidigare anrop till InternetConnect för att avgöra vilken katalog programmet för närvarande finns i eller för att ändra till en annan underkatalog.

Kataloguppräkning utförs med hjälp av funktionerna FtpFindFirstFile och InternetFindNextFile. FtpFindFirstFile använder sessionshandtaget som skapats av InternetConnect för att hitta den första filen som matchar de angivna sökvillkoren och returnerar ett handtag för att fortsätta kataloguppräkningen. InternetFindNextFile använder referensen som returneras av FtpFindFirstFile för att returnera nästa fil som matchar det ursprungliga sökvillkoren. Programmet bör fortsätta att anropa InternetFindNextFile tills det inte finns fler filer kvar i katalogen.

Använd funktionen FtpCreateDirectory för att skapa nya kataloger. Den här funktionen använder sessionshandtaget som skapats av InternetConnect och skapar katalogen som anges av strängen som skickas till funktionen. Strängen kan innehålla ett katalognamn i förhållande till den aktuella katalogen eller en fullständigt kvalificerad katalogsökväg.

Om du vill byta namn på filer eller kataloger kan programmet anropa FtpRenameFile. Den här funktionen ersätter det ursprungliga namnet med det nya namnet som skickas till funktionen. Namnet på filen eller katalogen kan vara relativt till den aktuella katalogen eller ett fullständigt kvalificerat namn.

Om du vill ladda upp eller placera filer på en FTP-server kan programmet använda antingen FtpPutFile eller FtpOpenFile (tillsammans med InternetWriteFile). FtpPutFile kan användas om filen redan finns lokalt, medan FtpOpenFile och InternetWriteFile kan användas om data behöver skrivas till en fil på FTP-servern.

Om du vill ladda ned eller hämta filer kan programmet använda antingen FtpGetFile eller FtpOpenFile (med InternetReadFile). FtpGetFile- används för att hämta en fil från en FTP-server och lagra den lokalt, medan FtpOpenFile och InternetReadFile kan användas för att styra vart den nedladdade informationen är på väg (till exempel kan programmet visa informationen i en redigeringsruta).

Ta bort filer på en FTP-server med hjälp av funktionen FtpDeleteFile. Den här funktionen tar bort ett filnamn som är relativt antingen till den aktuella katalogen eller till ett fullständigt kvalificerat filnamn från FTP-servern. FtpDeleteFile kräver en sessionsreferens som returneras av InternetConnect.

FTP-funktionshandtag

För att fungera korrekt kräver FTP-funktionerna vissa typer av HINTERNET- referenser. Dessa referenser måste skapas i en viss ordning, med början i rotreferensen som skapats av InternetOpen. InternetConnect kan sedan skapa en FTP-sessionsreferens.

Följande diagram visar de funktioner som är beroende av FTP-sessionshandtaget som returneras av InternetConnect. De skuggade rutorna representerar funktioner som returnerar HINTERNET- referenser, medan de oformaterade rutorna representerar funktioner som använder HINTERNET-referensen som skapats av den funktion som de är beroende av.

Följande diagram visar de två funktioner som returnerar HINTERNET- referenser och de funktioner som är beroende av dem. De skuggade rutorna representerar funktioner som returnerar HINTERNET- referenser, medan de oformaterade rutorna representerar funktioner som använder HINTERNET- handtag som skapats av den funktion som de är beroende av.

Mer information finns i HINTERNET-handtag.

Använda WinINet Functions för FTP-sessioner

Följande funktioner används under FTP-sessioner. Dessa funktioner identifieras inte av CERN-proxyservrar. Program som måste fungera via CERN-proxyservrar bör använda InternetOpenUrl och komma åt resurserna direkt. Mer information om direkt resursåtkomst finns i Åtkomst till URL:er direkt.

Starta en FTP-session

Programmet upprättar en FTP-session genom att anropa InternetConnect på ett handtag som skapats av InternetOpen. InternetConnect behöver servernamn, portnummer, användarnamn, lösenord och tjänsttyp (som måste anges till INTERNET_SERVICE_FTP). För passiv FTP-semantik måste programmet också ange flaggan INTERNET_FLAG_PASSIVE.

Värdena INTERNET_DEFAULT_FTP_PORT och INTERNET_INVALID_PORT_NUMBER kan användas för portnumret. INTERNET_DEFAULT_FTP_PORT använder ftp-standardporten, men tjänsttypen måste fortfarande anges. INTERNET_INVALID_PORT_NUMBER använder standardvärdet för den angivna tjänsttypen.

Värdena för användarnamnet och lösenordet kan anges till NULL-. Om båda värdena är inställda på NULL-använder InternetConnect "anonym" för användarnamnet och användarens e-postadress för lösenordet. Om endast lösenordet är inställt på NULL-används användarnamnet som skickas till InternetConnect för användarnamnet och en tom sträng används för lösenordet. Om inget av värdena NULL-används användarnamnet och lösenordet som ges till InternetConnect-.

Räkna upp kataloger

Uppräkning av en katalog på en FTP-server kräver att en referens skapas av FtpFindFirstFile. Det här handtaget är en gren av sessionshandtaget som skapats av InternetConnect. FtpFindFirstFile letar upp den första filen eller katalogen på servern och returnerar den i en WIN32_FIND_DATA struktur. Använd InternetFindNextFile tills den returnerar ERROR_NO_MORE_FILES. Den här metoden hittar alla efterföljande filer och kataloger på servern. Mer information om InternetFindNextFilefinns i Hitta nästa fil.

Om du vill ta reda på om filen som hämtats av FtpFindFirstFile eller InternetFindNextFile är en katalog kontrollerar du dwFileAttributes medlem i WIN32_FIND_DATA-strukturen för att se om den är lika med FILE_ATTRIBUTE_DIRECTORY.

Om programmet gör ändringar på FTP-servern eller om FTP-servern ändras ofta ska flaggorna INTERNET_FLAG_NO_CACHE_WRITE och INTERNET_FLAG_RELOAD anges i FtpFindFirstFile. Dessa flaggor säkerställer att kataloginformationen som hämtas från FTP-servern är aktuell.

När programmet har slutfört kataloguppräkningen måste programmet anropa InternetCloseHandle på handtaget som skapats av FtpFindFirstFile. Innan handtaget har stängts kan programmet inte anropa FtpFindFirstFile igen på sessionshandtaget som skapats av InternetConnect. Om ett anrop till FtpFindFirstFile görs på samma sessionsreferens innan föregående anrop till samma funktion stängs, misslyckas funktionen och returnerar ERROR_FTP_TRANSFER_IN_PROGRESS.

I följande exempel räknas innehållet i en FTP-katalog upp i en listrutekontroll. Parametern hConnection är en referens som returneras av funktionen InternetConnect när en FTP-session har upprättats. Exempel på källkod för funktionen InternetErrorOut som refereras i det här exemplet finns i avsnittet Hanteringsfel.

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

Navigera i kataloger

Funktionerna FtpGetCurrentDirectory och FtpSetCurrentDirectory hanterar katalognavigering.

FtpGetCurrentDirectory- returnerar programmets aktuella katalog på FTP-servern. Katalogsökvägen från rotkatalogen på FTP-servern ingår.

FtpSetCurrentDirectory ändrar arbetskatalogen på servern. Kataloginformationen som skickas till FtpSetCurrentDirectory kan vara antingen ett delvis eller fullständigt kvalificerat sökvägsnamn i förhållande till den aktuella katalogen. Om programmet till exempel för närvarande finns i katalogen "public/info" och sökvägen är "ftp/example" FtpSetCurrentDirectory ändrar den aktuella katalogen till "public/info/ftp/example".

I följande exempel används FTP-sessionshandtaget hConnection, som returneras av InternetConnect. Det nya katalognamnet hämtas från redigeringsrutan i den överordnade dialogrutan vars IDC skickas i parametern nDirNameId. Innan katalogändringen görs hämtar funktionen den aktuella katalogen och lagrar den i samma redigeringsruta. Souce-koden för funktionen DisplayFtpDir som anropas i slutet visas ovan.

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

Manipulera kataloger på en FTP-server

WinINet ger möjlighet att skapa och ta bort kataloger på en FTP-server som programmet har nödvändiga behörigheter till. Om programmet måste logga in på en server med ett specifikt användarnamn och lösenord kan värdena användas i InternetConnect när du skapar FTP-sessionshandtaget.

Funktionen FtpCreateDirectory tar ett giltigt FTP-sessionshandtag och en null-- avslutad sträng som innehåller antingen en fullständigt kvalificerad sökväg eller ett namn i förhållande till den aktuella katalogen och skapar en katalog på FTP-servern.

I följande exempel visas två separata anrop till FtpCreateDirectory. I båda exemplen är hFtpSession sessionshandtaget som skapats av funktionen InternetConnect och rotkatalogen är den aktuella katalogen.

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

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

Funktionen FtpRemoveDirectory tar ett sessionshandtag och en null--avslutad sträng som innehåller antingen en fullständigt kvalificerad sökväg eller ett namn i förhållande till den aktuella katalogen och tar bort katalogen från FTP-servern.

I följande exempel visas två exempelanrop till FtpRemoveDirectory. I båda anropen är hFtpSession sessionshandtaget som skapats av funktionen InternetConnect och rotkatalogen är den aktuella katalogen. Det finns en katalog med namnet "test" i rotkatalogen och en katalog med namnet "example" i katalogen "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. */

I följande exempel skapas en ny katalog på FTP-servern. Det nya katalognamnet hämtas från redigeringsrutan i den överordnade dialogrutan vars IDC skickas i parametern nDirNameId. Handtaget hConnection skapades av InternetConnect efter att en FTP-session har upprättats. Källkoden för funktionen DisplayFtpDir som anropas i slutet visas ovan.

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

I följande exempel tas en katalog bort från FTP-servern. Namnet på katalogen som ska tas bort hämtas från redigeringsrutan i den överordnade dialogrutan vars IDC skickas till parametern nDirNameId. Handtaget hConnection skapades av InternetConnect efter att en FTP-session har upprättats. Källkoden för funktionen DisplayFtpDir som anropas i slutet visas ovan.

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

Hämta filer på en FTP-server

Det finns tre metoder för att hämta filer från en FTP-server:

• Använd InternetOpenUrl och InternetReadFile.
• Använd FtpOpenFile och InternetReadFile.
• Använd FtpGetFile.

Mer information om hur du använder funktionen InternetReadFile finns i Läsa filer.

Om filens URL är tillgänglig kan programmet anropa InternetOpenUrl för att ansluta till den URL:en och sedan använda InternetReadFile för att styra nedladdningen av filen. På så sätt kan programmet få hårdare kontroll över nedladdningen och passar perfekt för situationer där inga andra åtgärder behöver utföras på FTP-servern. Mer information om hur du får direkt åtkomst till resurser finns i Åtkomst till URL:er direkt.

Om programmet har upprättat en FTP-sessionsreferens till servern med InternetConnectkan programmet anropa FtpOpenFile med det befintliga filnamnet och med ett nytt namn för den lokalt lagrade filen. Programmet kan sedan använda InternetReadFile för att ladda ned filen. Detta gör att programmet får bättre kontroll över nedladdningen och behåller anslutningen till FTP-servern, så att fler kommandon kan köras.

Om programmet inte behöver noggrann kontroll över nedladdningen kan programmet använda FtpGetFile- med FTP-sessionshandtaget, fjärrfilnamnet och det lokala filnamnet för att hämta filen. FtpGetFile utför all bokföring och alla kostnader som är associerade med att läsa en fil från en FTP-server och lagra den lokalt.

I följande exempel hämtas en fil från en FTP-server och sparas lokalt. Namnet på filen på FTP-servern hämtas från redigeringsrutan i den överordnade dialogrutan vars IDC skickas i parametern nFtpFileNameId och det lokala namn som filen sparas under hämtas från redigeringsrutan vars IDC skickas i parametern nLocalFileNameId. Handtaget hConnection skapades av InternetConnect efter att en FTP-session har upprättats.

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

Placera filer på en FTP-server

Det finns två metoder för att placera en fil på en FTP-server:

• Använd FtpOpenFile med InternetWriteFile.
• Använd FtpPutFile.

Ett program som måste skicka data till en FTP-server, men som inte har en lokal fil som innehåller alla data, bör använda FtpOpenFile- för att skapa och öppna en fil på ftp-servern. Programmet kan sedan använda InternetWriteFile för att ladda upp informationen till filen.

Om filen redan finns lokalt kan programmet använda FtpPutFile för att ladda upp filen till FTP-servern. FtpPutFile utför alla kostnader som följer med att ladda upp en lokal fil till en fjärr-FTP-server.

I följande exempel kopieras en lokal fil till FTP-servern. Det lokala namnet på filen hämtas från redigeringsrutan i den överordnade dialogrutan vars IDC skickas i parametern nLocalFileNameId och namnet som filen sparas under på FTP-servern hämtas från redigeringsrutan vars IDC skickas i parametern nFtpFileNameId. Handtaget hConnection skapades av InternetConnect efter att en FTP-session har upprättats.

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
}

Ta bort filer från en FTP-server

Om du vill ta bort en fil från en FTP-server använder du funktionen FtpDeleteFile. Det anropande programmet måste ha de behörigheter som krävs för att ta bort en fil från FTP-servern.

I följande exempel tas en fil bort från FTP-servern. Namnet på filen som ska tas bort tas från redigeringsrutan i den överordnade dialogrutan vars IDC skickas i parametern nFtpFileNameId. Handtaget hConnection skapades av InternetConnect efter att en FTP-session har upprättats. Eftersom den här funktionen inte uppdaterar fillistor eller katalogvisning bör anropsprocessen göra det när borttagningen har slutförts.

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
}

Byta namn på filer och kataloger på en FTP-server

Filer och kataloger på en FTP-server kan byta namn med hjälp av funktionen FtpRenameFile. FtpRenameFile accepterar två null--avslutade strängar som innehåller antingen delvis eller fullständigt kvalificerade namn i förhållande till den aktuella katalogen. Funktionen ändrar namnet på filen som anges av den första strängen till det namn som anges av den andra strängen.

I följande exempel byter du namn på en fil eller katalog på FTP-servern. Det aktuella namnet på filen eller katalogen hämtas från redigeringsrutan i den överordnade dialogrutan vars IDC skickas i parametern nOldFileNameId och det nya namnet hämtas från redigeringsrutan vars IDC skickas i parametern nNewFileNameId. Handtaget hConnection skapades av InternetConnect efter att en FTP-session har upprättats. Eftersom den här funktionen inte uppdaterar fillistor eller katalogvisning bör anropsprocessen göra det vid lyckat namnbyte.

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
}