概述

FTP 是File Transfer Protocol（文件传输协议）的英文简称，用于Internet上文件的双向传输。FTP的主要作用就是让客户端连接上一个远程计算机（这些计算机上运行着FTP服务器程序）从而察看远程计算机上的文件，然后把文件从远程计算机上拷到本地计算机，或把本地的文件上传到远程计算机。

FTP是仅基于TCP的服务，不支持UDP。FTP协议使用2个连接，一个数据连接和一个控制连接（用来传输客户端向FTP服务器发送的命令、传输FTP服务器向客户端命令的响应）。通常来说控制连接的端口号是21，数据连接的端口号是20，但由于FTP协议工作方式的不同，数据连接的端口号并不总是20，这也是FTP的主动与被动模式的最大不同之处。

FTP协议的两种工作模式

1. 主动模式（Port模式）

1> 客户端发起从一个任意的非特权端口N（N大于等于1024）连接到FTP服务器的控制端口21，从而建立控制连接。
2> 客户端开始监听客户端的端口N+1，并发送FTP命令“port N+1”到FTP服务器。
3> 服务器从自己的数据端口20连接到客户端指定的数据端口N+1，从而建立数据连接。

2. 被动模式（Pasv模式）

1> 客户端发起从一个任意的非特权端口N（N大于等于1024）连接到FTP服务器的控制端口21，从而建立控制连接。
2> 与主动模式不同，客户端不会发送PORT命令要求服务器来回连它的数据端口，而是发送PASV命令。
3> 服务器接收到会PASV命令后会开启一个任意的非特权端口P（大于等于1024），并发送PORT P命令给客户端。
4> 客户端接收到PORT P命令后会发起从非特权端口N+1连接到服务器的端口P，从而建立数据连接。

注意：
1> 由于控制连接和数据连接都由客户端发起，可以解决从FTP服务器到客户端的数据端口的入方连接被防火墙过滤掉的问题。

FTP协议命令与响应信息

在FTP服务的执行过程中，FTP客户端与FTP服务器之间需要传输控制信息，这些信息用于完成某个具体的FTP操作，它们可以分为两种类型：FTP命令与FTP响应信息。其中，FTP命令是FTP客户端向FTP服务器发送的操作请求，FTP响应信息是FTP服务器根据操作结果向FTP客户端返回的响应信息。FTP协议详细规定了每种协议命令的顺序--首先需要顺序发送USER与PASS命令，最后需要发送QUIT命令，其他命令的顺序没有特殊要求。

1. FTP协议命令

FTP 每个命令都有 3 到 4 个字母组成，命令后面跟参数，用空格分开。每个命令都以 "\r\n"结束。FTP命令的标准格式为：

命令名 <参数>

常用的FTP命令如下表所示：

2. FTP协议响应信息

FTP响应信息由两部分组成：响应码与描述信息（中间以空格隔开）。其中，响应码是由3位数字组成的字符串，它是对响应信息的数字标识，例如200表示用户登录成功；描述信息是对响应码的文字描述，例如200的描述信息是"Command okay."。FTP响应的标准格式为：

响应码  描述信息

常见的FTP响应如下表所示:

在Android上的应用（实现一个FTP服务器）

1. 首先通过启动一个Service来实现在后台守护ServerScoket模拟的FTP服务器线程（下面称为服务器线程），由于Service是在主线程中执行的，所以守护服务器线程的工作是在新建的线程中（下面称为守护线程）完成的，代码如下所示：

@Override
public void run() {
    Log.d(TAG, "Server thread running");

    if (isConnectedToLocalNetwork() == false) {
        Log.w(TAG, "run: There is no local network, bailing out");
        stopSelf();
        sendBroadcast(new Intent(ACTION_FAILEDTOSTART));
        return;
    }

    // Initialization of wifi, set up the socket
    try {
        setupListener();
    } catch (IOException e) {
        Log.w(TAG, "run: Unable to open port, bailing out.");
        stopSelf();
        sendBroadcast(new Intent(ACTION_FAILEDTOSTART));
        return;
    }

    // @TODO: when using ethernet, is it needed to take wifi lock?
    WifiUtil.takeWifiLock(getApplicationContext(), wifiLock);
    PowerUtil.takeWakeLock(getApplicationContext(), wakeLock);

    // A socket is open now, so the FTP server is started, notify rest of world
    Log.i(TAG, "Ftp Server up and running, broadcasting ACTION_STARTED");
    sendBroadcast(new Intent(ACTION_STARTED));

    while (!shouldExit) {
        if (wifiListener != null) {
            if (!wifiListener.isAlive()) {
                Log.d(TAG, "Joining crashed wifiListener thread");
                try {
                    wifiListener.join();
                } catch (InterruptedException e) {
                }
                wifiListener = null;
            }
        }
        if (wifiListener == null) {
            // Either our wifi listener hasn't been created yet, or has crashed,
            // so spawn it
            wifiListener = new TcpListener(serverSocket, this);
            wifiListener.start();
        }
        try {
            // TODO: think about using ServerSocket, and just closing
            // the main socket to send an exit signal
            Thread.sleep(WAKE_INTERVAL_MS);
        } catch (InterruptedException e) {
            Log.d(TAG, "Thread interrupted");
        }
    }

    terminateAllSessions();

    if (wifiListener != null) {
        wifiListener.quit();
        wifiListener = null;
    }
    shouldExit = false; // we handled the exit flag, so reset it to acknowledge
    Log.d(TAG, "Exiting cleanly, returning from run()");

    stopSelf();
    sendBroadcast(new Intent(ACTION_STOPPED));
}
// This opens a listening socket on all interfaces.
void setupListener() throws IOException {
    serverSocket = new ServerSocket();
    serverSocket.setReuseAddress(true);
    serverSocket.bind(new InetSocketAddress(FtpServerSettings.getPortNumber()));
}

上面setupListener方法就是用来为serverScoket绑定端口用的，由于FtpServerSettings.getPortNumber()得到的返回值就是2121，因此serverScoket绑定了2121端口；由于shouldExit的值是false，因此守护线程会每间隔WAKE_INTERVAL_MS时长就会检查wifiListener线程是否存活，如果不存活就会重新建立wifiListener线程，从而完成了守护wifiListener线程的工作。
wifiListener线程就是serverScoket监听2121端口的工作线程，即上面提到的ServerScoket模拟的FTP服务器线程。

2. wifiListener对应的TcpListener类（坚持Thread类）中实现监听2121端口的过程如下：

@Override
public void run() {
    try {
        while (true) {
            Socket clientSocket = listenSocket.accept();
            Log.i(TAG, "New connection, spawned thread");
            SessionThread newSession = new SessionThread(clientSocket,
                    new LocalDataSocket());
            newSession.start();
            ftpServerService.registerSessionThread(newSession);
        }
    } catch (Exception e) {
        Log.d(TAG, "Exception in TcpListener");
    }
}

可以看到是通过调用serverSocket的accept方法实现的，当执行accept方法后，FTP服务器线程就会进入等待的状态，只要有客户端发起连接FTP服务器线程，FTP服务器线程才会继续向下执行，现在在windows操作系统的“计算机”上的地址栏上输入上输入ftp://192.168.10.52:2121/，然后回车，连接FTP服务器线程成功后的效果图如下所示：

然后你就可以像在本地操作文件夹一样操作android中的文件目录。
在mac系统中通过finder或者通过浏览器的地址栏中输入ftp://192.168.10.52:2121/也可以连接FTP服务器线程，效果图如下：

注意：
我现在实现的是在同一个局域网上才可以，上面的IP地址192.168.10.52就是手机的wifi的IP。

3. 当第2步中发起连接（就是上面FTP协议中提到的控制连接）后，就会创建SessionThread类（继承自Thread类）的实例sessionThread，就相当为这个控制连接创建一个会话线程，该会话线程用来专门处理客户端向ServerScoket模拟的FTP服务器发送的命令并且对客户端的命令做出响应。代码如下所示：

@Override
public void run() {
    Log.i(TAG, "SessionThread started");

    if (sendWelcomeBanner) {
        writeString("220 SwiFTP " + MyApplication.getVersion() + " ready\r\n");
    }
    // Main loop: read an incoming line and process it
    try {
        BufferedReader in = new BufferedReader(new InputStreamReader(
                cmdSocket.getInputStream()), 8192); // use 8k buffer
        while (true) {
            String line;
            line = in.readLine(); // will accept \r\n or \n for terminator
            if (line != null) {
                FTPServerService.writeMonitor(true, line);
                Log.d(TAG, "Received line from client: " + line);
                FtpCmd.dispatchCommand(this, line);
            } else {
                Log.i(TAG, "readLine gave null, quitting");
                break;
            }
        }
    } catch (IOException e) {
        Log.i(TAG, "Connection was dropped");
    }
    closeSocket();
}

可以看到，会话线程会先解析出FTP客户端请求的命令，然后通过FtpCmd.dispatchCommand方法处理命令，处理命令的代码如下：

protected static CmdMap[] cmdClasses = { new CmdMap("SYST", CmdSYST.class),
      new CmdMap("USER", CmdUSER.class), new CmdMap("PASS", CmdPASS.class),
      new CmdMap("TYPE", CmdTYPE.class), new CmdMap("CWD", CmdCWD.class),
      new CmdMap("PWD", CmdPWD.class), new CmdMap("LIST", CmdLIST.class),
      new CmdMap("PASV", CmdPASV.class), new CmdMap("RETR", CmdRETR.class),
      new CmdMap("NLST", CmdNLST.class), new CmdMap("NOOP", CmdNOOP.class),
      new CmdMap("STOR", CmdSTOR.class), new CmdMap("DELE", CmdDELE.class),
      new CmdMap("RNFR", CmdRNFR.class), new CmdMap("RNTO", CmdRNTO.class),
      new CmdMap("RMD", CmdRMD.class), new CmdMap("MKD", CmdMKD.class),
      new CmdMap("OPTS", CmdOPTS.class), new CmdMap("PORT", CmdPORT.class),
      new CmdMap("QUIT", CmdQUIT.class), new CmdMap("FEAT", CmdFEAT.class),
      new CmdMap("SIZE", CmdSIZE.class), new CmdMap("CDUP", CmdCDUP.class),
      new CmdMap("APPE", CmdAPPE.class), new CmdMap("XCUP", CmdCDUP.class), // synonym
      new CmdMap("XPWD", CmdPWD.class), // synonym
      new CmdMap("XMKD", CmdMKD.class), // synonym
      new CmdMap("XRMD", CmdRMD.class), // synonym
      new CmdMap("MDTM", CmdMDTM.class), //
      new CmdMap("MFMT", CmdMFMT.class), //
      new CmdMap("REST", CmdREST.class), //
      new CmdMap("SITE", CmdSITE.class), //
};
protected static void dispatchCommand(SessionThread session, String inputString) {
    String[] strings = inputString.split(" ");
    String unrecognizedCmdMsg = "502 Command not recognized\r\n";
    if (strings == null) {
        // There was some egregious sort of parsing error
        String errString = "502 Command parse error\r\n";
        Log.d(TAG, errString);
        session.writeString(errString);
        return;
    }
    if (strings.length < 1) {
        Log.d(TAG, "No strings parsed");
        session.writeString(unrecognizedCmdMsg);
        return;
    }
    String verb = strings[0];
    if (verb.length() < 1) {
        Log.i(TAG, "Invalid command verb");
        session.writeString(unrecognizedCmdMsg);
        return;
    }
    FtpCmd cmdInstance = null;
    verb = verb.trim();
    verb = verb.toUpperCase();
    for (int i = 0; i < cmdClasses.length; i++) {

        if (cmdClasses[i].getName().equals(verb)) {
            // We found the correct command. We retrieve the corresponding
            // Class object, get the Constructor object for that Class, and
            // and use that Constructor to instantiate the correct FtpCmd
            // subclass. Yes, I'm serious.
            Constructor<? extends FtpCmd> constructor;
            try {
                constructor = cmdClasses[i].getCommand().getConstructor(
                        new Class[] { SessionThread.class, String.class });
            } catch (NoSuchMethodException e) {
                Log.e(TAG, "FtpCmd subclass lacks expected " + "constructor ");
                return;
            }
            try {
                cmdInstance = constructor.newInstance(new Object[] { session,
                        inputString });
            } catch (Exception e) {
                Log.e(TAG, "Instance creation error on FtpCmd");
                return;
            }
        }
    }
    if (cmdInstance == null) {
        // If we couldn't find a matching command,
        Log.d(TAG, "Ignoring unrecognized FTP verb: " + verb);
        session.writeString(unrecognizedCmdMsg);
        return;
    }

    if (session.isUserLoggedIn()) {
        cmdInstance.run();
    } else if (session.isAnonymouslyLoggedIn() == true) {
        boolean validCmd = false;
        for (Class<?> cl : allowedCmdsWhileAnonymous) {
            if (cmdInstance.getClass().equals(cl)) {
                validCmd = true;
                break;
            }
        }
        if (validCmd == true) {
            cmdInstance.run();
        } else {
            session.writeString("530 Guest user is not allowed to use that command\r\n");
        }
    } else if (cmdInstance.getClass().equals(CmdUSER.class)
            || cmdInstance.getClass().equals(CmdPASS.class)
            || cmdInstance.getClass().equals(CmdQUIT.class)) {
        cmdInstance.run();
    } else {
        session.writeString("530 Login first with USER and PASS, or QUIT\r\n");
    }
}

上面的代码很简单，首先是对格式不正确的命令做出响应（响应码事502，表示命令未执行）；接着根据命令名称找到对应的处理这个命令的类（例如CmdUSER.class就是用来处理USER命令），然后通过反射创建创建该类的实例，然后执行实例的run方法，继而完成命令的处理，处理完成后，一般都会返回给FTP客户端响应信息，具体可以参考上面 常见的FTP响应表。

上面的源码是参考SwiFTP开源软件，源码地址：
FTP Server (swiftp)
有兴趣的同学可以自己研究一下。