FTP Overview: Understanding the File Transfer Protocol

Every FTP session is a conversation between client and server, conducted in a language of simple text commands and numeric responses. This command language, defined in RFC 959 and extended by subsequent RFCs, provides a complete vocabulary for authentication, file management, data transfer, and session control.

Understanding FTP commands goes beyond rote memorization. Each command represents a design decision about what operations are essential for file transfer. Studying these commands reveals how protocol designers thought about user workflows, security boundaries, and system interoperability.

This page serves as both a learning resource and a reference. We'll explore commands grouped by function, with complete syntax, expected responses, and practical usage examples.

Before diving into specific commands, let's establish the universal rules that govern all FTP command interactions.

Command Format

COMMAND<SP>argument<CRLF>

• COMMAND: 3-4 uppercase ASCII letters (commands are case-insensitive, but conventionally uppercase)
• <SP>: Single space character (ASCII 0x20), required only if argument is present
• argument: Command-specific parameter (format varies by command)
• <CRLF>: Carriage Return + Line Feed (\r , ASCII 0x0D 0x0A), required terminator

Response Format

XYZ<SP>text message<CRLF>

• XYZ: Three-digit numeric status code
• <SP>: Space (response not yet complete) or hyphen (more lines follow)
• text message: Human-readable explanation (for logging/debugging, not parsing)

Before any file operations, clients must authenticate. FTP's authentication model is straightforward (some would say too simple for modern security requirements), but understanding it is essential.

USER Command

USER username\r

Identifies the user account for authentication. The server typically responds:

• 230 — User logged in (no password needed—anonymous access or trusted network)
• 331 — Username OK, password required
• 332 — Need account for login (rare, used with ACCT)
• 530 — Not logged in (username rejected outright—rare, as this reveals valid usernames)

Security Note: Most servers respond 331 regardless of whether the username exists, preventing username enumeration attacks.

PASS Command

PASS password\r

Provides the password for the user specified in USER. The password is sent in cleartext—one of FTP's major security weaknesses.

Responses:

• 230 — User logged in, proceed
• 202 — Command not implemented, superfluous at this site
• 332 — Need account for login
• 530 — Not logged in (authentication failed)

Anonymous FTP Convention: For anonymous access, use anonymous as username and conventionally an email address as password (purely informational, not validated).

Before transferring data, clients configure how that data will be transmitted. These commands set up the data connection and specify data representation.

TYPE Command — Representation Type

TYPE type-code [format-control]\r

Sets how data is represented during transfer:

ASCII mode has optional format control (N=Non-print, T=Telnet, C=Carriage Control), but these are rarely used.

Practical Usage:

--> TYPE A
<-- 200 Type set to A.

--> TYPE I
<-- 200 Type set to I.

Critical: Set TYPE before every transfer to ensure correct handling. Transferring binary files in ASCII mode corrupts them; transferring text files in binary mode may leave line endings unconverted.

STRU Command — File Structure

STRU structure-code\r

Modern usage almost exclusively uses STRU F (the default). Record and page structures were for mainframe systems with structured file concepts that don't map to modern file systems.

MODE Command — Transfer Mode

MODE mode-code\r

Stream mode is the universal default. Block mode provides restart capability but adds complexity. Compressed mode is obsolete—modern files are already compressed, and network-level compression is more efficient.

The core purpose of FTP: transferring files between client and server. These commands handle downloading, uploading, appending, and managing file content.

RETR — Retrieve (Download)

RETR pathname\r

Transfers a file from server to client. Requires prior PORT/PASV for data connection.

Sequence:

--> PASV
<-- 227 Entering Passive Mode (192,168,1,100,195,80)
[Client connects to 192.168.1.100:50000]
--> RETR /path/to/file.zip
<-- 150 Opening BINARY mode data connection for file.zip (1048576 bytes).
[File data flows on data connection]
[Data connection closed by server]
<-- 226 Transfer complete.

Response codes:

• 125 — Data connection already open; transfer starting
• 150 — File status okay; about to open data connection
• 226 — Closing data connection; transfer complete
• 425 — Can't open data connection
• 426 — Connection closed; transfer aborted
• 550 — File not found or permission denied

STOR — Store (Upload)

STOR pathname\r

Transfers a file from client to server. Overwrites if file exists.

Sequence:

--> PASV
<-- 227 Entering Passive Mode (192,168,1,100,195,88)
[Client connects to data port]
--> STOR /uploads/newfile.dat
<-- 150 Opening BINARY mode data connection for newfile.dat.
[Client sends file data]
[Client closes data connection to signal EOF]
<-- 226 Transfer complete.

STOU — Store Unique

STOU\r

Like STOR, but server generates a unique filename. The server includes the created filename in its response—useful for avoiding overwrites.

APPE — Append

APPE pathname\r

Appends data to an existing file. If file doesn't exist, it's created. Useful for log aggregation or incremental uploads.

REST — Restart (Resume)

REST byte-offset\r

Sets the restart point for the next RETR or STOR command. Enables resumption of interrupted transfers.

Resumed Download Sequence:

[Previous download interrupted at 524288 bytes]
--> REST 524288
<-- 350 Restarting at 524288. Send STORE or RETRIEVE.
--> RETR largefile.iso
<-- 150 Opening BINARY mode data connection.
[Server sends bytes starting at offset 524288]
<-- 226 Transfer complete.

Important: REST only works reliably with TYPE I (binary). ASCII mode transfers may have different byte counts due to line ending transformation.

FTP provides a complete set of commands for navigating and managing directory structures on the remote server.

PWD — Print Working Directory

--> PWD
<-- 257 "/home/alice/documents" is the current directory.

The quoted pathname in the response is the canonical current directory. The quotes allow paths with spaces to be unambiguous.

CWD — Change Working Directory

--> CWD /var/www/html
<-- 250 Directory successfully changed.

--> CWD nonexistent
<-- 550 Failed to change directory.

Absolute paths start with /. Relative paths navigate from current directory.

MKD — Make Directory

--> MKD newdir
<-- 257 "/home/alice/newdir" directory created.

--> MKD existing
<-- 550 existing: File exists.

The 257 response includes the full path of the created directory.

LIST vs NLST vs MLSD

Three commands retrieve directory contents, with different formats:

LIST — Detailed listing (human-readable)

--> LIST
<-- 150 Here comes the directory listing.
[Data connection receives:]
drwxr-xr-x    2 alice    users        4096 Jan 15 10:30 subdir
-rw-r--r--    1 alice    users       12345 Jan 14 09:15 file.txt
[Data connection closes]
<-- 226 Directory send OK.

LIST format varies by server (Unix-style ls output is common but not standardized).

NLST — Name list (simple)

--> NLST
<-- 150 Here comes the directory listing.
[Data connection receives:]
subdir
file.txt
[Data connection closes]
<-- 226 Directory send OK.

NLST returns filenames only—easier to parse but less information.

MLSD — Machine-parseable listing (RFC 3659)

--> MLSD
<-- 150 Here comes the directory listing.
[Data connection receives:]
type=dir;modify=20240115103000;perm=el; subdir
type=file;size=12345;modify=20240114091500;perm=r; file.txt
[Data connection closes]
<-- 226 Directory send OK.

MLSD provides structured, machine-parseable output with standardized fields. Modern clients should prefer MLSD when available.

Beyond file and directory operations, FTP provides commands for system information, capability discovery, and session control.

SYST — System Identification

--> SYST
<-- 215 UNIX Type: L8

Identifies the server's operating system and file system characteristics. Common responses:

• UNIX Type: L8 — Unix-like system with 8-bit bytes
• Windows_NT — Windows system
• VMS — OpenVMS system

Clients use SYST to adjust behavior (e.g., line ending expectations).

FEAT — Feature Discovery

--> FEAT
<-- 211-Features:
     UTF8
     MLST Type*;Size*;Modify*;Perm*;
     PASV
     EPSV
     EPRT
     REST STREAM
     SIZE
     MDTM
<-- 211 End

FEAT lists server-supported extensions beyond RFC 959. Critical for clients to know what capabilities are available (EPSV, MLSD, UTF8, etc.).

SIZE and MDTM — File Metadata

--> SIZE largefile.iso
<-- 213 4700000000

--> MDTM document.pdf
<-- 213 20240115093045

SIZE returns file size in bytes. MDTM returns modification time in YYYYMMDDHHMMSS format (UTC). Both are essential for sync tools that need to compare files without downloading.

NOOP — Keep-Alive

--> NOOP
<-- 200 NOOP ok.

Does nothing except reset the server's idle timeout. Clients performing long local operations should periodically send NOOP to prevent session timeout.

SITE — Server-Specific Commands

--> SITE CHMOD 755 script.sh
<-- 200 SITE CHMOD command successful.

SITE provides a mechanism for server-specific functionality without standardization. Common SITE commands:

• SITE CHMOD mode file — Change permissions (Unix servers)
• SITE UMASK mask — Set default permissions
• SITE HELP — List available SITE commands

Real FTP operations require specific command sequences. Here are the complete sequences for common tasks:

We've covered the complete FTP command vocabulary. Let's consolidate with a quick reference and key takeaways:

Module Complete:

You've now completed a comprehensive study of FTP Overview. You understand:

• FTP's purpose and historical significance
• The dual-connection architecture (control and data)
• Active Mode and its firewall challenges
• Passive Mode and its solutions
• The complete FTP command vocabulary

This knowledge provides a solid foundation for working with FTP in any context—whether debugging connection issues, implementing FTP clients, configuring servers, or simply understanding how file transfer works at a fundamental level.