Managed File Transfer and Security Solutions

Java FTP

Overview

The ability to transfer files from one machine to another is often accomplished using an FTP client. Using the Java FTP component included in both Secure FTP Factory and Secure iNet Factory this article will demonstrate how you can easily embed FTP capabilities into your own Java applications.

In addition to support for the FTP protocol, Secure FTP Factory also has components for secure file transfer protocols including FTPS (FTP over SSL both implicit and explicit modes), SFTP (FTP over SSH) and SCP (Secure Copy via SSH).

Related Products

Secure FTP Factory
JSCAPE Secure FTP Server
Secure FTP Applet

FTP (File Transfer Protocol)

The FTP protocol is in wide use for transferring files from one computer to another. The FTP protocol is published under RFC 959. Details of this protocol are beyond the scope of this article however if you are interested in learning more on the details of the FTP protocol go to http://www.faqs.org/rfcs/rfc959.html

Importing the necessary components

In order to use FTP you must ensure that the following import statements are included in your Java code. The com.jscape.inet.ftp package contains the necessary classes for communicating with an FTP server.

import com.jscape.inet.ftp.*;

Establishing a connection

In order to communicate with an FTP server you must first establish a network connection to the FTP server.

// create Ftp instance with FTP hostname, username and password as arguments
Ftp ftp = new Ftp("ftp.myserver.com","jsmith","secret");

// establish connection
ftp.connect();

Perform a directory listing

Once connected you may wish to perform a directory listing on the FTP server. The directory listing will return a relative listing of files and directories that are on the FTP server.

// perform directory listing
String listing = ftp.getDirListingAsString();

// print directory listing to console
System.out.println(listing);

Alternatively you may use the Ftp.getDirListing method. This method parses the results and returns a java.util.Enumeration of FtpFile. Using this method you may then iterate through the Enumeration and evaluate the contents of each file or directory programmatically.

Note: This method is only for use by FTP servers which display directory listing using the UNIX or MS-DOS mode. For more information see the Ftp.getDirListing method in the JavaDoc.

// Perform directory listing

Enumeration files = ftp.getDirListing();
// iterate through listing
while(files.hasMoreElements()) {
   FtpFile file = (FtpFile)files.nextElement();

   // only print files that are directories;
   if(file.isDirectory()) {
      System.out.println(file.getName());
   }
}

Changing your local directory

Your local directory is the directory that you wish to use when transferring files to / from the FTP server. By default this is the directory that the Java executable was invoked from. To change this setting simply invoke the Ftp.setLocalDir method.

// change local directory
ftp.setLocalDir(new File("C:/tmp");

Changing your remote directory

Your remote directory represents your current directory on the FTP server. By default this is the directory that is assigned when first logging into the FTP server. To change this setting simply invoke the Ftp.setDir method.

// Change remote directory
ftp.setDir("temp");

Setting the transfer mode

Files transferred to / from an FTP server may be transmitted using binary or ASCII modes. The binary transfer mode transfers files without performing any conversion. Binary transfer is generally used for files that are binary in nature such as images, executables etc. The ASCII transfer mode transfers files converting new line characters to the system dependent new line character used by the operating system performing the transfer request. ASCII transfer mode is generally used when downloading text only files. The default transfer mode is binary.

// change transfer mode to ASCII
ftp.setAscii();

// change transfer mode to binary
ftp.setBinary();

Downloading files

To download a file simple invoke the Ftp.download method. File will be transferred using the current transfer mode and saved in your local directory. See Setting the transfer mode and Changing your local directory for more information. There are other methods that you may use for downloading files. These include methods for downloading entire directories and downloading files matching a regular expression. For more information see the JavaDoc.

// download a file named test.txt in remote directory
ftp.download("test.txt");

Uploading files

To upload a file simply invoke the Ftp.upload method. File will be transferred using the current transfer mode and saved in your remote directory. See Setting the transfer mode and Changing your remote directory for more information. There are other methods that you may use for uploading files. These include methods for uploading entire directories and uploading files matching a regular expression. For more information see the JavaDoc.

// upload a file named test.txt in c:/tmp directory
ftp.upload(new File("c:/tmp/test.txt"));

Releasing the connection

Once you have finished sending your email message(s) it is important that you disconnect from the FTP server. This is easily accomplished using the code below.

// release the FTP server connection
ftp.disconnect();

Summary

In this article you have learned the very basics needed to communicate with an FTP server using Java. The FTP component provided in Secure FTP Factory makes this easy removing the need to understand all the complexities of the FTP protocol.

References

Ftp Class Overview
Ftp Class Javadoc
FTP Wiki

Sending Email using Java

Overview

A common need across many software applications is the ability to send email messages. Fortunately, virtually every email sent today are sent using two popular protocols known as SMTP (Simple Mail Transfer Protocol) and MIME (Multipurpose Internet Mail Extensions). Using the Java based SMTP and MIME components provided in Secure iNet Factory this article will demonstrate how you can easily embed email capabilities into your own Java applications. Download a FREE 30 day Secure iNet Factory Evaluation

SMTP (Simple Mail Transfer Protocol)

The SMTP protocol is the standard used by mail servers for sending and receiving email. The SMTP protocol is published under RFC 821. Details of this protocol are beyond the scope of this article. For more information on the SMTP protocol go to http://www.faqs.org/rfcs/rfc821.html

MIME (Multipurpose Internet Mail Extensions)

The MIME protocol is the standard used when composing email messages. The MIME protocol is published under RFC 1521. Details of this protocol are beyond the scope of this article. For more information on the MIME protocol go to http://www.faqs.org/rfcs/rfc1521.html

Importing the necessary components

In order to send electronic mail you must ensure that the following import statements are included in your Java code. The com.jscape.inet.smtp package contains the necessary classes for communicating with an SMTP server. The com.jscape.inet.email package contains the necessary classes for generating a MIME compliant email message.

import com.jscape.inet.smtp.*;
import com.jscape.inet.email.*;

Establishing a Connection

In order to send email you must first establish a network connection to your SMTP server. If you are unsure of the hostname of your SMTP server please contact your system administrator.

// create a new Smtp instance using SMTP hostname as argument
Smtp smtp = new Smtp("smtp.here.com");

// establish connection
smtp.connect();

Composing the Email

Next is to compose the MIME compliant email message you wish to send.

// Create a new EmailMessage instance
EmailMessage message = new EmailMessage();

// set From address
message.setFrom("me@here.com");

// set To address
message.setTo("someone@somewhere.com");

// set subject of message
message.setSubject("Hello!");

// set body of message
message.setBody("Have a nice day");

In the event you wish to have multiple recipients you may use the setCc method. The following will carbon-copy the message to any recipients you define here.

// set carbon-copy recipients
message.setCc("someoneelse@somewhere.com");

Sending the Email

Once you have successfully established a connection and composed the email message sending the email is simple.

// send the email message
 smtp.send(message);

Releasing the Connection

Once you have finished sending your email message(s) it is important that you disconnect from the SMTP server. This is easily accomplished using the code below.

// release SMTP server connection
smtp.disconnect();

Summary

In this article you have learned the very basics needed to send email using Java. The SMTP and MIME components provided in iNet Factory make this easy removing the need to understand all the complexities of SMTP and MIME protocols. To see what else Secure iNet Factory has to offer Download a FREE 30 day Secure iNet Factory Evaluation.

References

Smtp Class Overview
Smtp Class Javadoc
SMTP WIki

Secure iNet Factory 8.6 Released

JSCAPE is pleased to announce the release of Secure iNet Factory 8.6. For a version history please visit:

http://www.jscape.com/secureinetfactory/docs/html/introhistory.html

To download the latest version please visit:

http://www.jscape.com/secureinetfactory/

If you are a current registered user of Secure iNet Factory and would like to upgrade please contact the Help Desk for assistance.

JSCAPE is pleased to announce the release of Secure iNet Factory 8.6. For a version history please visit:

http://www.jscape.com/secureinetfactory/docs/html/introhistory.html

To download the latest version please visit:

http://www.jscape.com/secureinetfactory/

If you are a current registered user of Secure iNet Factory and would like to upgrade please contact the Help Desk for assistance.

Secure FTP Factory 8.4 Released

JSCAPE is pleased to announce the release of Secure FTP Factory 8.4. 

For a version history please visit:

http://www.jscape.com/sftp/docs/html/introhistory.html

If you are a registered user of Secure FTP Factory please contact the Help Desk for details on how to upgrade to the latest version.

Secure iNet Factory 8.4 Released

JSCAPE is pleased to announce the release of Secure iNet Factory 8.4. 

For a version history please visit:

http://www.jscape.com/secureinetfactory/docs/html/index.html

If you are a current registered user of Secure iNet Factory please contact the Help Desk for information on how to upgrade to the latest version.

Secure iNet Factory 8.3.1 Released

JSCAPE is pleased to release Secure iNet Factory 8.3.1.  For details on this release please see version history at:

http://www.jscape.com/secureinetfactory/docs/html/introhistory.html

SSH Factory 3.5 Released

JSCAPE is pleased to announce the release of SSH Factory 3.5. 

For more information or to download please visit:

http://www.jscape.com/sshfactory/

For version history information please visit:

http://www.jscape.com/sshfactory/docs/html/introhistory.html

Secure iNet Factory 8.3 Released

JSCAPE is pleased to announce the release of Secure iNet Factory 8.3

For more information or to download the latest release please visit:

http://www.jscape.com/secureinetfactory/

For version history information please visit:

http://www.jscape.com/secureinetfactory/docs/html/introhistory.html

Secure FTP Factory 8.3 Released

JSCAPE is pleased to announce the release of Secure FTP Factory 8.3.

For more information or to download please visit:

http://www.jscape.com/sftp/

For a version history please visit:

http://www.jscape.com/sftp/docs/html/introhistory.html

 

Using regular expressions in complex trigger conditions

Introduction

       The purpose of this article is to demonstrate how one can use regular expressions to create complex trigger conditions in JSCAPE Secure FTP Server. Regular expressions provide a concise means for identifying strings of interest e.g. words or pattern of characters. JSCAPE Secure FTP Server follows the regular expression rules as defined by the Java programming language, a complete guide to Java regular expressions can be found here.

Demonstration & Examples

       This feature is best illustrated by providing concrete examples demonstrating what can be achieved with this feature. Starting with a timed trigger example, we will upload all text files from a specific directory starting with "John" every 15 minutes to a server location.

1) Start JSCAPE Secure FTP Server Manager.

2) Create a trigger as follows :

    Select "CurrentTime" from the Event Type dropdown. Type in an appropriate name and click 'Next'. The next screen is demonstrated below :

   

    Look at the condition specified : Minute MATCHES REGEX 0|15|30|45

    What does this mean? This means that the trigger action will occur every 15 minutes. What if I wanted to execute the trigger action every half hour, for this latter requirement one would use the following regular expression : 0|30

   Click on 'Next' button and setup a 'Ftps Regex File Upload' trigger action, for this to work you would have to setup Ftp Implicit or Explicit SSL service, this latter step can be done through the Server Manager. The important property of the trigger condition is the 'Regular Expression' field, fill it in with "John.*.txt" (without the quotation marks).

    The expression is : John.*\.txt

    This means : "John" followed by any number of any characters including the space char. Filename must end with ".txt". Therefore "John Lenon.txt" is valid, "John Abraham.txt" is valid, "John.txt" is valid but "Simon Lenon.txt" is not valid.

    Apply the condition triggers so the server can begin uploading the files every 15 minutes. For verification go to the local directory where the server is installed and verify that files are uploaded, verification can also be done by looking at the server logs as it will record all files uploaded and the fact that the trigger action was executed.

    For all Johns with second name starting with either with A or a B and absolutely no other letters. For this I would use the regular expression :   John [AB].*\.txt 

    For all names ending with "Roland" I would use the following regular expression :    .*\ Roland.txt

    A more complex example :  John [AB].*\(Lennon){1}.txt   

   John followed by a space character, second name starting with either A or B, followed by any number of characters, followed by 1 "Lennon", ending with ".txt". Therefore "John Abraham Lennon.txt" is valid, "John Abraham Lennon Lennon.txt" is also valid. Why is the second name valid? - because there is one "Lennon" in the whole name, however "John Abraham.txt" is not valid since it does not contain a "Lennon".

    As you can probably see that any regular expression which can be used in Java can be used in JSCAPE Secure FTP Server trigger / action mechanism. Where is this example useful? One common scenario could be database backups where you could set the trigger to fire every 24 hours and filter which database files to upload to a remote server location based on the regular expression used in the Ftps Regex File Upload 'Regular Expression' field. You could have multiple triggers for different name groups backing them up to a different server location, E.g. one trigger / FTPS regex upload action which could handle all files starting with A, another trigger / FTPS regex upload action which could handle all files starting with B to a different location.

   The business functionality which can be constructed around these trigger / action / regular expression combo can be quite significant, consider doing this in a traditional coding application route : you would have to write significant code to handle all this, on top of that if you are adamant about using a tier architecture for coding as is the norm in large web / commercial applications it could mean a lot of work. Instead JSCAPE Secure FTP Server can really come in handy here for these data handling jobs. Once the triggers / actions are setup the user can just leave it running and it continue to perform it's work, meaning there is little work for the server administrator in such a scenario.

   It should come as no surprise that regular expressions can be used in other scenarios such as File Downloads / File Uploads. For example the following screen shows how a multiple condition for File Uploads can be setup in JSCAPE Secure FTP Server :

 

    We can see here that there are two conditions :

1) The file must be successfully uploaded.

2) The file name must satisfy the regular expression : John [AB].+\(Lennon){1}.txt

    The regular expression has the following meaning :

    John followed by a space character, followed by either A or B, followed by atleast one other character,
followed by one "Lennon" word group, followed by ".txt". E.g. John ArLennon.txt is valid according to this expression but John ALennon.txt is not valid since there are no characters after "A".

    A similar setup can also be done for File Download scenarios :

    

  We can see here that there is the condition :

*) The file name must satisfy the regular expression : [ABC].*\

    The regular expression has the following meaning :

    The username must begin with A, B or C followed by any number of any characters.

    Where can one use this? If the business functionality requires that a confirmation of the download is sent to the user once he / she downloads a file this trigger can be used together with a "Send Email" action to send a confirmation of the download to the user which has a username satisfying the regular expression. Thus a email will be sent to the user with a username of "Abacus" but it will not be sent to a user with a username of "Zeus".

    Another scenario where this process can be useful is the "Directory Monitor File Changed" where the action which could possibly be a File Regex Upload  can filter files by a providing regular expression. Directory Monitor File Changed trigger is fired when a file in a monitored directory is changed.

    Thus we can see that the business functionality that can be constructed is virtually limitless, a knowledge of Java regular expressions is perhaps the only limiting factor here. The link provided in the "Introduction" should help in this regard. Also note that JSCAPE Secure FTP Server has a built in "Test Expression" feature which allows you to confirm whether the expression is correct or not, this on the fly feature can make life very easy and greatly help in expediting the process of setting up this functionality.