EldoS | Feel safer!

Software components for data protection, secure storage and transfer

Use FTPSBlackbox from C# .NET to upload and download files via FTP/FTPS (File Transfer Protocol)

FTPSBlackbox makes file operations via FTP/FTPS on .NET platform as easy as 1-2-3. The code below is the complete console application, which can be used to upload and download files and list the directories. As you can see, the FTP/FTPS calls fit into just about a dozen of lines of code. The rest of code parses command-line parameters.

To see what outstanding features make FTPSBlackbox an optimal choice, see Description of FTPSBlackbox.NET.

Download SecureBlackbox from the Download page.

Before you start

  • Check that you have an FTP/FTPS server to test.
  • Install SecureBlackbox .NET (you can download it from the Download page). If you plan to run the sample on the server, please read the deployment instructions in SecureBlackbox help file.

Source code

  1. using System;
  2. using System.IO;
  3. using System.Collections;
  4. using SBSimpleFTPS;
  5. using SBX509;
  6.  
  7. namespace ConsoleFTPS
  8. {
  9.     /// <summary>
  10.     /// Summary description for ConsoleFTPSClient.
  11.     /// </summary>
  12.     class ConsoleFTPSClient
  13.     {
  14.  
  15.         static SBSimpleFTPS.TElSimpleFTPSClient Client = null;
  16.  
  17.         // command line parameters
  18.         const int OP_LIST    = 1;
  19.         const int OP_DOWNLOAD = 2;
  20.         const int OP_UPLOAD  = 3;
  21.        
  22.         static long parOperation = 0;
  23.         static string parRemoteName = "/";
  24.         static string parLocalName;
  25.         static string parUsername;
  26.         static string parPassword;
  27.         static string parAddress;
  28.         static int parPort;
  29.    
  30.         static bool ParseCommandLine(string[] args)
  31.         {
  32.             int i = 0;
  33.             string arg;
  34.  
  35.             if (args.Length == 0)
  36.             {
  37.                 System.Console.WriteLine("usage:");
  38.                 System.Console.WriteLine("FTPSClient {-download|-upload} -addr[ess] <address> [-port <port>] -user[name] <user> -pass[word] <password> -remote <remote file name> -local <local file name>");
  39.                 return false;
  40.             }
  41.             else
  42.             {
  43.                 while (i < args.Length)
  44.                 {
  45.                     arg = args[i];
  46.                     if ((String.Compare(arg, "-down", true) == 0) ||
  47.                         (String.Compare(arg, "-download", true) == 0))
  48.                     {
  49.                         parOperation = OP_DOWNLOAD;
  50.                     }
  51.                     else
  52.                         if ((String.Compare(arg, "-up", true) == 0) ||
  53.                         (String.Compare(arg, "-upload", true) == 0))
  54.                     {
  55.                         parOperation = OP_UPLOAD;
  56.                     }
  57.                     else
  58.                         if ((String.Compare(arg, "-list", true) == 0) ||
  59.                         (String.Compare(arg, "-ls", true) == 0))
  60.                     {
  61.                         parOperation = OP_LIST;
  62.                     }
  63.                     else
  64.                         if ((String.Compare(arg, "-addr", true) == 0) ||
  65.                         (String.Compare(arg, "-address", true) == 0))
  66.                     {
  67.                         i++;
  68.                         parAddress = args[i];
  69.                     }
  70.                     else
  71.                         if (String.Compare(arg, "-port", true) == 0)
  72.                     {
  73.                         i++;
  74.                         try
  75.                         {
  76.                             parPort = Int32.Parse(args[i]);
  77.                         }
  78.                         catch (Exception)
  79.                         {
  80.                             parPort = 21;
  81.                         }
  82.                     }
  83.                     else
  84.                         if ((String.Compare(arg, "-user", true) == 0) ||
  85.                         (String.Compare(arg, "-username", true) == 0))
  86.                     {
  87.                         i++;
  88.                         parUsername = args[i];
  89.                     }
  90.                     else
  91.                         if ((String.Compare(arg, "-pass", true) == 0) ||
  92.                         (String.Compare(arg, "-password", true) == 0))
  93.                     {
  94.                         i++;
  95.                         parPassword = args[i];
  96.                     }
  97.                     else                   
  98.                         if (String.Compare(arg, "-local", true) == 0)
  99.                     {
  100.                         i++;
  101.                         parLocalName = args[i];
  102.                     }
  103.                     else                   
  104.                         if (String.Compare(arg, "-remote", true) == 0)
  105.                     {
  106.                         i++;
  107.                         parRemoteName = args[i];
  108.                     }
  109.                     i = i + 1;
  110.                 }
  111.                 return (parOperation != 0);
  112.             }
  113.         }
  114.  
  115.         static void Download()
  116.         {
  117.             FileStream stream = new FileStream(parLocalName, FileMode.Create);
  118.             try
  119.             {
  120.                 Client.Receive(parRemoteName, stream);
  121.             }
  122.             finally
  123.             {
  124.                 stream.Close();
  125.             }
  126.         }
  127.  
  128.         static void Upload()
  129.         {
  130.             FileStream stream = new FileStream(parLocalName, FileMode.Open);
  131.             try
  132.             {
  133.                 Client.Send(stream, parRemoteName);
  134.             }
  135.             finally
  136.             {
  137.                 stream.Close();
  138.             }
  139.         }
  140.  
  141.         static void List()
  142.         {
  143.             if (Client.ExtMLSTSupported)
  144.                 Client.MLSD();
  145.             else
  146.                 Client.GetFileList();          
  147.         }
  148.  
  149.         static private void Client_OnCertificateValidate(object Sender, TElX509Certificate Certificate, ref bool Validate)
  150.         {
  151.             System.Console.WriteLine("Server certificate received");
  152.             Validate = true; // NEVER do this. You MUST check the key validity somehow
  153.         }
  154.  
  155.         static private void Client_OnTextDataLine(object Sender, byte[] TextLine)
  156.         {
  157.             string response = System.Text.UTF8Encoding.UTF8.GetString(TextLine);
  158.             TSBFTPFileInfo FileInfo = new TSBFTPFileInfo();
  159.  
  160.             try
  161.             {
  162.                 if (Client.ExtMLSTSupported)
  163.                 {
  164.                     TElSimpleFTPSClient.ParseMLSDEntry(response, ref FileInfo);
  165.                 }
  166.                 else
  167.                 {
  168.                     TElSimpleFTPSClient.ParseFileListEntry(response, ref FileInfo);
  169.                 }
  170.                 System.Console.WriteLine(FileInfo.FileName);
  171.             }
  172.             catch (Exception)
  173.             {
  174.                 // Couldn't parse the entry, so just write what we've received
  175.                 System.Console.WriteLine(response);
  176.             }
  177.         }      
  178.  
  179.         /// <summary>
  180.         /// The main entry point for the application.
  181.         /// </summary>
  182.         [STAThread]
  183.         static void Main(string[] args)
  184.         {
  185.  
  186.             SBUtils.Unit.SetLicenseKey("your license key here");
  187.  
  188.             if (!ParseCommandLine(args))
  189.                 return;
  190.  
  191.             Client = new TElSimpleFTPSClient();
  192.             Client.Address = parAddress;
  193.             Client.Port = parPort;
  194.  
  195.             Client.Username = parUsername;
  196.             Client.Password = parPassword;
  197.  
  198.             Client.OnCertificateValidate += new SBSSLCommon.TSBCertificateValidateEvent(Client_OnCertificateValidate);
  199.             Client.OnTextDataLine += new SBSimpleFTPS.TSBFTPSTextDataEvent(Client_OnTextDataLine);
  200.  
  201.             try
  202.             {
  203.                 try
  204.                 {
  205.                     Client.Open();
  206.                     Client.Login();
  207.                 }
  208.                 catch (Exception e)
  209.                 {
  210.                     System.Console.WriteLine("Connection failed due to exception: " + e.Message);
  211.                     System.Console.WriteLine("If you have ensured that all connection parameters are correct and you still can't connect,");
  212.                     System.Console.WriteLine("please contact EldoS support as described on https://www.eldos.com/sbb/support-tech.php");
  213.                     System.Console.WriteLine("Remember to provide details about the error that happened.");
  214.                     try
  215.                     {
  216.                         Client.Close(true);
  217.                     }
  218.                     catch
  219.                     {
  220.                     }
  221.                     return;
  222.                 }
  223.  
  224.  
  225.                 try
  226.                 {
  227.                     switch (parOperation)
  228.                     {
  229.                         case OP_DOWNLOAD:
  230.                             Download();
  231.                             break;
  232.                         case OP_UPLOAD:
  233.                             Upload();
  234.                             break;
  235.                         case OP_LIST:
  236.                             List();
  237.                             break;
  238.                     }
  239.                 }
  240.                 finally
  241.                 {
  242.                     Client.Close(false);
  243.                 }
  244.             }
  245.             catch (Exception e)
  246.             {
  247.                 System.Console.WriteLine("Exception: " + e.Message);
  248.             }
  249.         }
  250.     }
  251. }
  252.  

Feel free to use this sample in your C# or VB.NET applications, that use FTP/FTPS. The console FTP/FTPS sample is available for C# and VB.NET. It's included into SecureBlackbox downloadable package.

FTPSBlackbox can be used separately or in one cost-saving SecureBlackbox package.

You can use SecureBlackbox with any .NET development tool that supports .NET Framework (4.6, 4.5.1, 4.5, 4.0, 3.5, 3.0, 2.0), .NET for Windows RT, .NET CF (Compact Framework) (3.5, 2.0), Mono 4.0 or 2.0, Silverlight (5 or 4) and Xamarin.Android including Visual Studio 2015, 2013, 2012, 2010, 2008, 2005, MonoDevelop, Delphi Prism.

Read more about FTPSBlackbox .NET.

Download SecureBlackbox.NET from the Download page.

|

Back to top

As of July 15, 2016 EldoS Corporation will operate as a division of /n software inc. For more information, please read the announcement.

Got it!