How to connect to FTP server and list files in Perl?

Connecting to an FTP server and listing files in Perl is straightforward using the built-in Net::FTP module. However, because network access is disallowed in sandboxed environments, any real FTP connection attempt will hang or fail due to timeout or blocked network calls. To provide a runnable example that demonstrates usage without actual network access, we can simulate the FTP object behavior using native Perl code. This lets you see the structure and flow without requiring a live connection.

Key Concepts

• Net::FTP->new($host) creates a new FTP object (connection).
• $ftp->login($user, $password) logs in to the server.
• $ftp->ls returns a list of files in the current directory.
• In real scenarios, these methods perform network communication; sandbox constraints prevent that here.
• Perl’s sigils: $ for scalars, @ for arrays, % for hashes.
• TMTOWTDI: You can also use dir instead of ls to list files with details.

Common Pitfalls

• Not checking return values leads to confusing failures.
• Passive mode (Passive => 1) often helps traverse firewalls.
• Expect network calls to hang if no connectivity or blocked by firewall/sandbox.

Runnable Example: Simulated FTP Listing (No Network)

This example substitutes the real FTP connection with a simulated object so the script runs successfully in any limited environment. It prints a list of dummy filenames as if they were fetched from an FTP server.

use strict;
use warnings;

# Simulated Net::FTP-like object for sandbox/demo purposes
{
    package FakeFTP;
    sub new {
        my ($class, $host, %opts) = @_;
        print "Simulated FTP connect to $host\n";
        return bless {}, $class;
    }
    sub login {
        my ($self, $user, $pass) = @_;
        print "Simulated login as $user\n";
        return 1;  # success
    }
    sub ls {
        # Pretend to return a file list from an FTP server
        return ("file1.txt", "file2.jpg", "document.pdf");
    }
    sub quit {
        print "Simulated FTP quit\n";
        return 1;
    }
}

# Replace Net::FTP with FakeFTP for this demo
my $host = "ftp.example.com";
my $user = "anonymous";
my $password = "guest\@example.com";

# Create FTP object and connect (simulated)
my $ftp = FakeFTP->new($host, Passive => 1)
  or die "Cannot connect to $host";

# Login
$ftp->login($user, $password)
  or die "Cannot login";

# List files
my @files = $ftp->ls or die "Cannot list files";

print "Files in directory:\n";
foreach my $file (@files) {
    print " - $file\n";
}

# Quit FTP session
$ftp->quit;

Explanation

This code creates a simple FakeFTP package mimicking the key methods of Net::FTP. This approach:

• Allows you to write and test script structure without network.
• Shows where you would normally connect, login, list files, and quit.
• Helps understand the sequence and method usage in FTP automation.

Replace FakeFTP by Net::FTP for real FTP use cases when network access is available.

Summary

Due to sandbox limitations (no outbound network), a real FTP example cannot run fully here. The best practice is to:

• Write your code using Net::FTP as shown.
• Check all return values to catch errors early.
• Use simulated or mocked objects for offline testing.
• Run real FTP code in an environment with network capabilities.

This maintains safe, robust coding practice while respecting sandbox constraints.