FTP Endeavor in WinRT – I

FTP client begins by settings up a socket to the FTP server, authorize itself and then continues by sending instructions. All communication is done in plain text which makes the protocol both easy to understand and use.

To save you the time, the completed client and channel are at Windows 8.1 Sockets: Ftp Client Sample with Sockets in C#/Xaml

Many FTP clients were written in .NET used active and passive sockets to connect to ftp servers. Most of these are open source and easily accessible for .NET developers.

However, in Windows Runtime, things have been revised for sockets namespace and the only example I could find that interacts with an FTP server was actually using web requests to execute commands. While it actually provides a viable solution, I couldn’t use concepts like progress, cancellation, passive connections etc. So that’s how the ftp endeavor started.

Setting-up Development Environment

Instead of using one of the company servers, I wanted use a local ftp server for development and testing. So I found the open source solution FileZilla to run an ftp server locally and follow the execution of commands.

However, in my initial attempts to open a socket connection to my local server, I had some issues with remote (not really remote in this case) host not being found. I could connect to my home media server without problems, but each time I tried to open a connection to ftp://127.0.0.1, it was throwing and exception.

“A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond. (Exception from HRESULT: 0x8007274C)”

First thing I checked was the application capabilities. (i.e. Package Manifest). Even though I was using a test project, you have to set the proper capabilities in the unit test project.

However, this was not the issue; the capabilities were set correctly and I still could not connect to the localhost.

As it turns out, the problem was the loopback check that is part of the Network Isolation that is applied to the Windows Store Application. (Following the steps from Troubleshooting and debugging network connections (Windows Store apps) ). So basically, unless the local connection is to the application itself, the connection is blocked by the network isolation loopback check.

At this point, I remembered when I was installing Fiddler (i.e. for people who are not familiar, this is a network monitor/sniffer that sets up a local proxy to your applications to follow the request/responses.), it was asking if I wanted to disable the loopback check for my applications. Using the inbuilt Enable Loopback Utility I was able to add my test project to exemptions list and continue the implementation.

FTP Socket Connection

Setting up the FTP socket connection was pretty straight forward. We simply use a StreamSocket to establish the connection. All we need is the host name and use “21” as the service name. Since my local server did not require any secure connection, I am also going to be using a plain socket.

await m_StreamSocket.ConnectAsync(host, service, SocketProtectionLevel.PlainSocket);

Here if there is a problem with the socket connection, you can use the SocketError utility class to get the socket error status for error handling. I am just going to be writing the error to the debug console.

catch (Exception ex)
{
    var socketError = SocketError.GetStatus(ex.HResult);

    System.Diagnostics.Debug.WriteLine("There was a connection problem: {0}", ex.Message);

    System.Diagnostics.Debug.WriteLine("Socket Error: {0}", socketError);

    return false;
}

Executing Commands

Once the connection is set up, we can start executing commands on this stream socket in plain text. For executing the command we just need a method that will send the plain text with the proper encoding.

/// <summary>
/// Writes a line to the stream using the specified encoding
/// </summary>
/// <param name="encoding">Encoding used for writing the line</param>
/// <param name="buf">The data to write</param>
public IAsyncOperationWithProgress<uint, uint> WriteLineAsync(Encoding encoding, string buf)
{
    byte[] data = encoding.GetBytes(string.Format("{0}\r\n", buf));

    return WriteAsync(data.AsBuffer());
}

And execute method would look something like:

/// <summary>
/// Executes a request on the ftp server
/// </summary>
/// <typeparam name="T">Type of the expected response</typeparam>
/// <param name="request">Request to execute</param>
/// <returns></returns>
public async Task<T> ExecuteAsync<T>(FtpRequest request) where T:FtpResponse
{
    if(!IsConnected) throw new FtpException("Not Connected");

    await WriteLineAsync(Encoding, request.Command);
    await FlushAsync();

    return await GetReplyAsync<T>();
}

Here I am using an FtpRequest base class to create the commands that I want to send to the FTP server. The reason for this is to strongly type different commands with appropriate parameters.

public class FtpRequest
{
    public string CommandName { get; set; }

    public string[] Arguments { get; set; }

    public string Command 
    {
        get
        {
            if (Arguments != null && Arguments.Length > 0)
                return string.Format("{0} {1}", CommandName, Arguments.Aggregate((item1,item2)=>item1 + " " + item2));

            return CommandName;
        }
    }

    public FtpRequest() { }

    public FtpRequest(string commandName, params string[] arguments)
    {
        CommandName = commandName;

        if (arguments != null) Arguments = arguments;
    }
}

You notice that the execute command function immediately calls the GetReply method. This method reads the response from the FTP server (e.g. in the initial connection, you would receive the 220 status code and the welcome message).

For the GetReply method, all we need is a ReadLine statement, and a way to parse the status code that is sent and the additional messages from the FTP server.

/// <summary>
/// Retrieves a reply from the server. Do not execute this method
/// unless you are sure that a reply has been sent, i.e., you
/// executed a command. Doing so will cause the code to hang
/// indefinitely waiting for a server reply that is never coming.
/// </summary>
/// <returns>FtpReply representing the response from the server</returns>
internal async Task<T> GetReplyAsync<T>() where T:FtpResponse
{
    var reply = Activator.CreateInstance<T>();

    if (!IsConnected)
        throw new InvalidOperationException("No connection to the server has been established.");

    string buf;

    while ((buf = await ReadLineAsync(Encoding)) != null)
    {
        Match m;

        if ((m = Regex.Match(buf, "^(?<code>[0-9]{3}) (?<message>.*)$")).Success)
        {
            reply.Code = m.Groups["code"].Value;
            reply.Message = m.Groups["message"].Value;
            break;
        }

        reply.InfoMessages += string.Format("{0}\n", buf);
    }

    return reply;
}

With the implementation of this method, we prepared the foundation for the basic command calls to the FTP server. (i.e. commands that do not require a duplex or passive channel such as USER, PASS, CWD, PWD… etc.)

Authenticating with the FTP Server

For authenticating with the server, we would need to send two commands. One is the USER and the second one is PASS. (i.e. command name and one argument for the value)

For instance the USER request would look something like:

public class FtpUserRequest : FtpRequest
{
    public FtpUserRequest(string userName) : base("USER", userName)
    {
    }
}

And we can send this request using the Execute method we previously implemented:

        
public Task<FtpResponse> SetUserAsync(FtpUserRequest request)
{
    return ExecuteAsync<FtpResponse>(request);
}

After connecting to the ftp server and executing the user and pass requests, the requests and responses would look something like:

220-FileZilla Server version 0.9.43 beta
220-written by Tim Kosse (tim.kosse@filezilla-project.org)
220 Please visit http://sourceforge.net/projects/filezilla/
EXEC :USER can
REPLY :331 Password required for can
EXEC :PASS
REPLY :230 Logged on

And my ftp server shows the console output as:

Hope this post was helpful to those of you who are trying to integrate an FTP server in their windows store applications.

In the next posts I will try to talk about my experience with more complex commands and the passive channels.

Happy coding everyone!