使用FTP（IOS FTP客户端开发教程）

待我称王封你为后i 2022-08-04 14:58 824阅读 0赞

本文翻译自新近Wrox出版社出版的，由Peter van de Put所著的《Professional.iOS.Programming》。该书题材比较新颖，结构合理，是一本不错的IOS开发书籍。本文译自该书第八章《Using FTP》。本文开放使用，不局限于转载、修改、增删，引用，请保留出处说明。禁止任何商业用途。欢迎任何修改建议。

本章有哪些内容？

Ø  理解文件传输协议

Ø  开发一个简单FTP客户端

Ø  实现网络流（Network streams）

**WROX.COM CODE DOWNLOADS FOR THIS CHAPTER**

The wrox.com code downloads for thischapter are found at www.wrox.com/go/proiosprog on the Download Code tab. Thecode is in the Chapter 8 download and individually named according to the namesthroughout the chapter.

在第七章，你已经学习了网络部分，包括从web服务器下载文件，向RESTful和SOAP服务器发送post请求。在某些情况下，你可能还需要处理视频之类的大文件，下载到你的应用或者上传到服务器进行处理。

你可以将图片或者PDF文件编码成base64字符串，然后发送给服务器，但是这不是十分高效、迅速的方法。创建base64字符串需要花费很长时间，然后你仍然要传输这些数据。

文件传输协议FTP是一个用于FTP服务器和客户端之间进行通信的协议。

# 开发一个FTP客户端 #

为IOS应用开发一个FTP客户端的同时，你应当了解一些FTP协议的基本要素。客户端使用预先确定端口上的Internet连接来创建到服务器的连接。默认地，一个FTP系统配置使用以下端口：

Ø  端口20用于服务器创建到客户端的连接

Ø  端口21用于客户端创建到服务器的连接注

译注：控制连接以通常的客户服务器方式建立。服务器以被动方式打开众所周知的用于F T P 的端口(21),等待客户的连接。客户则以主动方式打开TCP端口21,来建立连接。控制连接始终等待客户与服务器之间的通信。该连接将命令从客户传给服务器, 并传回服务器的应答。

FTP服务器的配置可以有所不同，所以你同意FTP服务器管理员关于使用那个端口就很重要了。

除了对某个端口号用于建立网络流达成一致外，FTP协议预定义了交换的命令，因此客户端可以告诉服务器它需要什么，反过来也一样。最常用的命令包括：

Ø  open：打开一个连接

Ø  close：关闭一个连接

Ø  get：从服务器拷贝一个文件到客户端（下载）

Ø  mget：从服务器拷贝多份文件到客户端（下载）

Ø  put：从客户端拷贝一个文件到服务端（上传）

Ø  mput：从客户端拷贝多份文件到服务端（上传）

Ø  delete：从当前远端目录删除一个文件

Ø  cd：改变服务器上的目录（由客户端发起）

Ø  lcd：改变客户端上的目录

Ø  mkdir或者mkd：在服务端创建一个目录（由客户端发起）

如果你以前从来没用过FTP客户端，你可以从http://filezilla-project.org/下载FileZilla项目。FileZilla是一个开源的FTP客户端和服务端，可用于分析在客户端和服务端两者之间交换的特定的命令。

根据你应用的需求，你有两个基本的选项要考虑。如果你仅仅是从FTP服务端上传或者下载文件，你可以使用由CFNetwork提供的高层API。这个方案能力有限，确定地说不是一个完整的FTP客户端。

## 写一个简单的FTP客户端 ##

启动Xcode并创建一个使用Single View ApplicationProject模板的工程，命名为SimpleFTPClinet，使用表8-1所示选项。

![Center][]

将CFNetwork framework添加到你的工程。

创建一个继承自NSObject、命名为FTPManager的类。打开FTPManager.h

文件，使用“\#includes<CFNetwork/CFNetwork.h>”将CFNetworkframework包含进去。

接着定义FTPManagerDelegate协议，该协议包括一些将向delegate提供反馈的方法。

创建一个接受用于FTP连接的server, username, 以及password的初始化器。实现方面假定你总是需要一个username和password来建立FTP连接。因为打开一个公众的FTP服务端对于你应用的意图来说毫无意义。

接下去，声明四个方法用于与FTP命令相关的、受支持的操作。如表8—1所示。

![Center 1][]

最后，为该类的delegate创建一个共有property。

完整的代码如清单8-1所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-1: Chapter8/SimpleFTPClient/FTPManager.h   
2.  \#import <Foundation/Foundation.h>  
3.  \#include <CFNetwork/CFNetwork.h>   
4.    
5.  **enum** \{  
6.  kSendBufferSize = 32768   
7.  \};  
8.    
9.  **@protocol** FTPManagerDelegate <NSObject>   
10. \-(**void**)ftpUploadFinishedWithSuccess:(**BOOL**)success;  -(**void**)ftpDownloadFinishedWithSuccess:(**BOOL**)success;  
11. \- -(**void**)directoryListingFinishedWithSuccess:(**NSArray** \*)arr;   
12. \-(**void**)ftpError:(**NSString** \*)err;   
13.   
14. **@end**  
15.   
16.   
17. **@interface** FTPManager : NSObject<NSStreamDelegate>  
18.  - (**id**)initWithServer:(**NSString** \*)server user:(**NSString** \*)username  
19. password:(**NSString** \*)pass;  
20.  - (**void**)downloadRemoteFile:(**NSString** \*)filename localFileName:(**NSString** \*)localname;   
21. \- (**void**)uploadFileWithFilePath:(**NSString** \*)filePath;  
22. \- (**void**)createRemoteDirectory:(**NSString** \*)dirname;  
23.  - (**void**)listRemoteDirectory;  
24. **@property** (**nonatomic**, assign) **id**<FTPManagerDelegate>   
25. **@end**

打开FTPManager.m文件，在import头文件语句后写入私有接口。

因为你在为网络通信使用流（streams），所以你要用到两种不同的流：NSOutputStream和NSInputStream。

这时候，理解FTP的put和mkd是你发送给服务端的命令，因此要用到NSOutputStream是很重要的。List和get命令通过打开的socket传送，并且作为回应，将收到你请求的数据。你需要去读取这些数据，因此你将用到NSInputStream。

定义两个BOOL型properties（isReceiving 和isSending）用于跟踪流的状态，避免流操作间的数据混淆。

你可以在本章的下载中找到FTPManager的完整实现。

这里，TPManager.m的实现被分解开来，并且一步一步解释。第一步，用自定义初始化器初始化FTPManager对象，你可以向该初始化器传连接和认证所需的properties，如清单8-2所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-2: The initWithServer method  
2.  \-(**id**)initWithServer:(**NSString** \*)server user:(**NSString** \*)username password:(**NSString** \*)pass  
3.  \{   
4.  **if** ((**self** = \[**super** init\]))  
5.  \{  
6.      **self**.ftpServer = server;   
7.  **self**.ftpUsername=username;   
8.  **self**.ftpPassword=pass;  
9.   \}  
10. **return** **self**;  
11.  \}

流处理的一个潜在问题是锁住。一个正在从一个流里写入或者读取的线程也许不得不无限期等待直到流里有空间进行写入，或者流里有可用数据（bytes）进行读取。为了克服这个问题，你需要一个接受NSStream作为参数的方法，并将它加入到当前NSRunLoop中进行调度安排（schedule），那样delegate就能只收到流相关事件报告的信息，那时锁住就不会发生。为了这个目的，写一个如清单8-3所示的简单helper方法。

NSRunLoop类声明了面向管理输入资源的对象的编程接口。一个NSRunLoop对象处理输入资源，例如窗口系统的鼠标和键盘事件，NSPort和NSConnetion对象。一个NSRunLoop对象也处理NSTimer事件。

你的应用既不能创建，也不能显式地管理NSrunLoop对象。每个NSThread对象，包括应用的主线程，出于需要，都有一个自动创建的NSRunLoop对象。假如你要访问当前线程的runloop，你使用类方法currentRunLoop。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-3: The scheduleInCurrentThread method  
2.  \-   (**void**)scheduleInCurrentThread:(NSStream\*)aStream   
3.  \{  
4.  \[aStream scheduleInRunLoop:\[NSRunLoop currentRunLoop\]  
5.  forMode:NSRunLoopCommonModes\];  
6.  \}

smartURLForString:方法接受一个字符串并将它转化为一个有效的NSURL对象。假如你传入一个类似127.0.0.1这样的IP地址，它返回一个ftp://127.0.0.1这样的NSURL对象。

smartURLForString:如清单8-4所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-4: The smartURLForString method  
2.  \-(**NSURL** \*)smartURLForString:(**NSString** \*)str  
3.   \{  
4.  **NSURL** \* result;   
5.  **NSString** \* trimmedStr;  
6.  NSRange schemeMarkerRange;  
7.   **NSString** \* scheme;   
8.  result =** nil**;   
9.  trimmedStr = \[str stringByTrimmingCharactersInSet:  
10. \[NSCharacterSet whitespaceCharacterSet\]\];  
11.     **if** ( (trimmedStr !=** nil**) && (\[trimmedStr length\] != 0) ) \{  
12.         schemeMarkerRange = \[trimmedStr rangeOfString:@"://"\];  
13. **if** (schemeMarkerRange.location == NSNotFound) \{   
14. result = \[NSURL URLWithString:\[NSString stringWithFormat: @"ftp://%@", trimmedStr\]\];  
15. \} **else** \{   
16. scheme = \[trimmedStr substringWithRange:  
17. NSMakeRange(0, schemeMarkerRange.location)\];  
18.  **if** ( (\[scheme compare:@"http" options:  
19. NSCaseInsensitiveSearch\] == NSOrderedSame) ) \{  
20.  result = \[NSURL URLWithString:trimmedStr\];  
21. \} **else** \{  
22. //unsupported url schema  
23. \}   
24. \}  
25. \}  
26. **return** result;   
27. \}

isReceiving方法用来检查dataStream是否已初始化，isSending方法用来检查commandStream是否已初始化。这些方法用于网络通信中以避免在一条命令尚在处理中又执行另一条命令的情况。       这两个方法在清单8-5中。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  <span style="font-family:'AvenirLTStd';font-size: 8.000000pt; font-weight: 800">LISTING 8\-5: </span><span style="font-family:'AvenirLTStd';font-size: 10.000000pt; font-weight: 500">The isReceiving and isSending methods  
2.  </span>- (**BOOL**)isReceiving \{  
3.  **return** (\_dataStream !=** nil**);   
4.  \}  
5.  \- (**BOOL**)isSending \{  
6.  **return** (\_commandStream !=** nil**);   
7.  \}

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  <span style="font-family:'AvenirLTStd';font-size: 8.000000pt; font-weight: 800">LISTING 8\-6: </span><span style="font-family:'AvenirLTStd';font-size: 10.000000pt; font-weight: 500">The closeAll metho  
2.  </span>-(**void**)closeAll \{  
3.  **if** (\_commandStream !=** nil**) \{   
4.  \[\_commandStream removeFromRunLoop:  
5.  \[NSRunLoop currentRunLoop\] forMode:NSDefaultRunLoopMode\];   
6.  \_commandStream.delegate =** nil**;  
7.  \[\_commandStream close\];  
8.  \_commandStream =** nil**;  
9.  \}  
10. **if** (\_uploadStream !=** nil**) \{  
11. \[\_uploadStream close\];  
12. \_uploadStream =** nil**; \}  
13. **if** (\_downloadfileStream !=** nil**) \{   
14.     \[\_downloadfileStream close\];   
15.     \_downloadfileStream =** nil**;  
16. \}  
17. **if** (\_dataStream !=** nil**) \{  
18. \[\_dataStream removeFromRunLoop:  
19. \[NSRunLoop currentRunLoop\] forMode:NSDefaultRunLoopMode\];  
20. \_dataStream.delegate =** nil**;   
21. \[\_dataStream close\];   
22. \_dataStream =** nil**;  
23. \}  
24. \_currentOperation = @"";   
25. \}

## 下载一个远程文件 ##

你调用downloadRemoteFile:localFileName:方法，并传给它一个服务端文件的文件名，例如picture1.png，和一个本地文件名，来从FTP服务端下载一个文件。已下载的文件将会以传入的本地文件名命名，写入到你的应用的根目录下的临时目录。

该方法先用“FTP服务端地址/远程文件名”生成一个smartURLForString，返回NSURL对象，例如[ftp://127.0.0.1/picture1.png][ftp_127.0.0.1_picture1.png].假如isReceiving方法返回YES，代理方法ftpError被调用，并传入一个错误信息。否则，用已创建的路径初始化downloadStream。downloadStream被创建后，数据就可以从该流中读取，currentOperation property设置为GET。流代理（stream delegate）负责从不同的流中读取和写入数据，需要为GET命令（从流中读取数据，写入到一个文件）LIST命令（以流形式传送将要分析的目录列表）进行不同的操作。出于这个目的，你需要一个currentOperation的property。

注意：你应当使用FTP服务端地址代替127.0.0.1

使用CFBridgingRelease( CFReadStreamCreateWithFTPURL(NULL,

(\_\_bridge CFURLRef)url));传入一个早先创建的url，创建一个commandStream。因为在使用认证，你需要将传给FTPManager初始化器的用户名和密码设置给commandStream。最后将delegate设置为self。调用scheduleInCurrentThread:将commandStream调度安排到当前线程，并打开commandStream。

当commandStream被打开，连接被建立，用户名和密码被用于认证该流。服务端响应在stream:handleEvent:方法中被捕获，该方法将在后面讲解，因为当前你在学习的其他方法也同样使用该方法进行结果处理。

downloadRemoteFile:方法如清单8-7所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \-(**void**)downloadRemoteFile:(**NSString** \*)filename localFileName:(**NSString** \*)localname   
2.  \{  
3.  **BOOL** success;   
4.  **NSURL** \* url;  
5.   url = \[**self** smartURLForString:\[NSString stringWithFormat:  
6.  @"%@/%@",\_ftpServer,filename\]\];  
7.  success = (url !=** nil**);   
8.  **if** ( ! success) \{  
9.  \[**self**.delegate ftpError:@"invalid url for downloadRemoteFile method"\];   
10. \} **else** \{  
11. **if** (**self**.isReceiving)\{   
12. \[**self**.delegate ftpError:@"receiving in progress"\];   
13. **return** ;  
14.         \}   
15. **NSString** \*path = \[NSTemporaryDirectory()  
16. stringByAppendingPathComponent:localname\];  
17. \_downloadfileStream = \[NSOutputStream outputStreamToFileAtPath:  
18. path append:**NO**\];  
19.         \[\_downloadfileStream open\];  
20. \_currentOperation = @"GET";  
21. \_dataStream=CFBridgingRelease( CFReadStreamCreateWithFTPURL(**NULL**,(\_\_bridge CFURLRef) url));   
22. \[\_dataStream  setProperty:\_ftpUsername  
23. forKey:(**id**)kCFStreamPropertyFTPUserName\];  
24. \[\_dataStream  setProperty:\_ftpPassword   
25. forKey:(**id**)kCFStreamPropertyFTPPassword\];  
26. \_dataStream.delegate = **self**;   
27. \[**self** performSelector:**@selector**(scheduleInCurrentThread:)  
28. onThread:\[\[**self** class\] networkThread\]  
29.                     withObject:\_dataStream waitUntilDone:**YES**\];  
30. \[\_dataStream open\];  
31. \}  
32. \}

## 创建一个远程目录 ##

你可以使用createRemotedirectory:方法在服务端创建一个目录。当然你提供的用于建立连接的证书需要有权限创建目录。实现方法和刚才你学习的下载文件的例子很相似。使用CFURLCreateCopyAppendingPathComponent将请求创建的目录名拼接到已创建的URL后面，形成的新的URL类似ftp://127.0.0.1/newdirname。因为你在发送一个命令到FTP服务端，commandStream被创建而不是dataStream，认证信息被传递，流被打开。同样地，这里也由stream:handleEvent:方法负责处理响应。createRemotedirectory:方法如清单8-8所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \- (**void**)createRemoteDirectory:(**NSString** \*)dirname  
2.   \{  
3.  **BOOL** success; **NSURL** \* url;  
4.  url = \[**self** smartURLForString:\_ftpServer\];   
5.  success = (url !=** nil**);  
6.   **if** (success) \{  
7.  url=CFBridgingRelease( CFURLCreateCopyAppendingPathComponent(**NULL**,(\_\_bridge CFURLRef) url, (\_\_bridge CFStringRef) dirname, **true**) );  
8.  success = (url !=** nil**); \}  
9.  **if** ( ! success) \{   
10. \[**self**.delegate ftpError:@"invalid url for createRemoteDirectory method"\];  
11. \} **else** \{   
12. **if** (**self**.isSending)\{  
13.     \[**self**.delegate ftpError:@"sending in progress"\];  
14. **return** ;   
15. \}  
16. \_       commandStream=CFBridgingRelease(  
17. CFWriteStreamCreateWithFTPURL(**NULL**,  
18.  (\_\_bridge CFURLRef) url)  
19. );  
20. //set credentials  
21.  \[\_commandStream setProperty:\_ftpUsername  
22. forKey:(**id**)kCFStreamPropertyFTPUserName\];   
23.     \[\_commandStream setProperty:\_ftpPassword  
24. forKey:(**id**)kCFStreamPropertyFTPPassword\];   
25.     \_commandStream.delegate = **self**;  
26. \[**self** performSelector:**@selector**(scheduleInCurrentThread:)   
27. onThread:\[\[**self** class\]   
28. networkThread\] withObject:\_commandStream waitUntilDone:**YES**\];  
29. \[\_commandStream open\];  
30. \}   
31. \}

## 列出一个远程目录 ##

listRemoteDirectory方法等同于FTP的list命令，该方法列出服务端某个目录下的内容。尽管一些RFC适用于FTP程序，但是FTP list命令的结果正如你所希望的那样，不是100%标准化的，因此它可以很容易解析到一个数组里。

检查完你并没在dataStream上接收数据之后，你设置listDataproperty并初始化listEntries property。你将currentOperation property设置为LIST，以此区别GET和LIST正如前面解释的那样，调用CFReadStreamCreateWithFTPURL，使用创建的URL来初始化dataStream。

再次地，设置dataStream的认证信息并将它调度安排并打开。

为了能够解析LIST命令的结果，实现用于解析传入数据流并最终将结果写入listEntries property的三个helper方法。所有数据都被处理以后，directoryListingFinishedWithSuccess方法被调用，该方法返回一个数组，包含在FTP服务端上找到的文件。listRemoveDirectory方法如清单8-9所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \- (**void**)listRemoteDirectory \{  
2.  **BOOL** success;   
3.  **NSURL** \* url;   
4.  url = \[**self** smartURLForString:\_ftpServer\];  
5.  success = (url !=** nil**);  
6.  **if** ( ! success) \{  
7.  \[**self**.delegate ftpError:@"invalid url for listRemoteDirectory method"\];   
8.  \} **else** \{  
9.  **if** (**self**.isReceiving)\{   
10. \[**self**.delegate ftpError:@"receiving in progress"\];   
11. **return** ;  
12. \}   
13. **self**.listData = \[NSMutableData data\];  
14. **if** (**self**.listEntries) **self**.listEntries=**nil**;  
15. **self**.listEntries=\[\[NSMutableArray alloc\] init\]; \_  
16. currentOperation = @"LIST";   
17. **self**.dataStream = CFBridgingRelease(  
18. CFReadStreamCreateWithFTPURL(**NULL**,  
19. (\_\_bridge CFURLRef) url));   
20. //set credentials  
21. \[**self**.dataStream setProperty: **self**.ftpUsername  
22.                     forKey:(**id**)kCFStreamPropertyFTPUserName\];  
23. \[**self**.dataStream setProperty: **self**.ftpPassword   
24.                     forKey:(**id**)kCFStreamPropertyFTPPassword\];  
25. **self**.dataStream.delegate = **self**;  
26.     \[**self** performSelector:**@selector**(scheduleInCurrentThread:)  
27. onThread:\[\[**self** class\] networkThread\]   
28. withObject:\_dataStream   
29. waitUntilDone:**YES**\];  
30. \[**self**.dataStream open\];  
31.  \}  
32. \}

下面的方法来自苹果公司的例子，并且已经清理过。因为从FTP服务端得到的响应并不是100%标准化的，所以你可以使用苹果公司提供的解析示例，该示例在大多数服务端实现上能工作，并呈现给你一个包含返回的文件信息的数组。解析helper方法如清单8-10所示

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#pragma listing helpers  
2.          -  (**void**)addListEntries:(**NSArray** \*)newEntries   
3.  \{  \[ **self**.listEntries addObjectsFromArray:newEntries\];   
4.  \[**self** closeAll\];   
5.  \[**self**.delegate directoryListingFinishedWithSuccess: **self**.listEntries\];   
6.   \}   
7.  //this function is taken over from Apple samples   
8.          -  (**NSDictionary** \*)entryByReencodingNameInEntry:(**NSDictionary** \*)  
9.  entry encoding:(NSStringEncoding)newEncoding   
10. \{  
11. NSDictionary  \* result;  
12. NSString  \*name;  
13. **NSData** \* nameData;  
14. NSString  \*newName;  
15. newName =** nil**;  
16. // Try to get the name, convert it back to MacRoman, and then reconvert it  
17. // with the preferred encoding.   
18. name = \[entry objectForKey:(**id**) kCFFTPResourceName\];   
19. **if** (name !=** nil**) \{  
20. nameData = \[name   
21.             dataUsingEncoding:NSMacOSRomanStringEncoding\];  
22.  **if** (nameData !=** nil**) \{  
23. newName = \[\[NSString alloc\]   
24. initWithData:nameData encoding:newEncoding\];  
25. \}   
26. \}  
27. **if** (newName ==** nil**) \{   
28. result = (**NSDictionary** \*) entry;  
29. \} **else** \{   
30. **NSMutableDictionary** \* newEntry; newEntry = \[entry mutableCopy\];   
31. \[newEntry setObject:newName forKey:(**id**) kCFFTPResourceName\];  
32.  result = newEntry;  
33. \}  
34. **return** result;   
35. \}  
36.   
37. //also this function is taken over from Apple samples   
38. \- (**void**)parseListData   
39. \{  
40. **NSMutableArray** \* newEntries;   
41. NSUInteger offset;   
42. newEntries = \[NSMutableArray array\];  
43. offset = 0;  
44. **do** \{   
45. CFIndex bytesConsumed;   
46. CFDictionaryRef thisEntry;   
47. thisEntry = **NULL**;   
48. bytesConsumed = CFFTPCreateParsedResourceListing(**NULL**, &((**const** **uint8\_t** \*)**self**.listData.bytes)\[offset\], (CFIndex) (\[**self**.listData length\] - offset), &thisEntry);  
49. **if** (bytesConsumed > 0) \{   
50. **if** (thisEntry != **NULL**) \{  
51. **NSDictionary** \* entryToAdd;   
52. entryToAdd = \[**self** entryByReencodingNameInEntry:  
53. (\_\_bridge **NSDictionary** \*) thisEntry   
54. encoding:NSUTF8StringEncoding\];  
55. \[newEntries addObject:entryToAdd\]; \}  
56. // We consume the bytes regardless of whether we get an entry.   
57. offset += (NSUInteger) bytesConsumed;  
58. \}   
59. **if** (thisEntry != **NULL**) \{  
60. CFRelease(thisEntry);   
61. \}  
62. **if** (bytesConsumed == 0) \{  
63.  // We hven't yet got enough data to parse an entry.   
64. //Wait for more data to arrive  
65. **break**;   
66. \} **else** **if** (bytesConsumed < 0) \{  
67. // We totally failed to parse the listing. Fail.   
68. **break**;  
69. \}   
70. \} **while** (**YES**);  
71. **if** (\[newEntries count\] != 0) \{   
72. \[**self** addListEntries:newEntries\];  
73. \}   
74. **if** (offset != 0) \{  
75. \[**self**.listData replaceBytesInRange:NSMakeRange(0, offset)   
76.                                 withBytes:**NULL** length:0\];  
77. \}   
78. \}

结果数组会提供类似如下的信息：

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \{  
2.  kCFFTPResourceGroup = ftp;   
3.  kCFFTPResourceLink = "";  
4.  kCFFTPResourceModDate = "2013-03-22 14:34:00 +0000";   
5.  kCFFTPResourceMode = 420;   
6.  kCFFTPResourceName = "1.jpg";   
7.  kCFFTPResourceOwner = ftp;  
8.  kCFFTPResourceSize = 5855;   
9.  kCFFTPResourceType = 8;  
10. \}

数组中的每个实体包含一个字典，字典中元素含义解释如表8-2所示

![Center 2][]

## 上传一个文件 ##

为上传一个文件到FTP服务端，你可以使用uploadFileWithFilePath:方法，向其传送一个你想上传的文件的fileath。

你可以使用CFURLCreateCopyAppendingPathComponent在smartURLString后面拼接传入的filePath的lastPathComponent，以形成新的URL。

uploadStream使用filePathPath创建并打开，那样就能使用NSInputStream读取文件。接着调用CFWriteStreamCreateWithFTPURL函数，使用刚才创建的URL创建commandStream，并设置其认证信息。

commandStream调度安排到NSRunLoop并打开，再次地，stream:handleEvent:负责处理响应。uploadFileWithFilePath方法如清单8-11所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \- (**void**)uploadFileWithFilePath:(**NSString** \*)filePath   
2.  \{  
3.  **BOOL** success;   
4.  **NSURL** \* url;   
5.  url = \[**self** smartURLForString:\_ftpServer\];   
6.  success = (url !=** nil**);  
7.   **if** (success) \{  
8.  url=CFBridgingRelease( CFURLCreateCopyAppendingPathComponent(**NULL**,( CFURLRef) url, ( CFStringRef) \[filePath lastPathComponent\], **false**));  
9.  success = (url !=** nil**); \}  
10. **if** ( ! success) \{   
11. \[**self**.delegate ftpError:@"invalid url for uploadFileWithFilePath method"\];  
12. \} **else** \{   
13. **if** (**self**.isSending)\{  
14. \[**self**.delegate ftpError:@"sending in progress"\];  
15. **return** ;  
16.  \}  
17. **self**.uploadStream = \[NSInputStream   
18.                             inputStreamWithFileAtPath:filePath\];  
19. \[**self**.uploadStream open\];   
20. **self**.commandStream=CFBridgingRelease(CFWriteStreamCreateWithFTPURL(**NULL**,(\_\_bridge CFURLRef) url));  
21.  //set credentials  
22. \[**self**.commandStream setProperty:\_ftpUsername  
23.                                 forKey:(**id**)kCFStreamPropertyFTPUserName\];  
24. \[**self**.commandStream setProperty:\_ftpPassword  
25.                 forKey:(**id**)kCFStreamPropertyFTPPassword\];  
26. **self**.commandStream.delegate = **self**;   
27. \[**self** performSelector:**@selector**(scheduleInCurrentThread:)  
28. onThread:\[\[**self** class\]   
29. networkThread\]   
30. withObject:**self**.commandStream   
31. waitUntilDone:**YES**\];  
32. \[**self**.commandStream open\];   
33. \}  
34. \}

正如前面提到的，stream:handleWithEvent:正是流通信魔法发生的地方。该实现首先使用switch语句来为各种可能发生的NSStreamEvent提供不同的处理。

## 从NSStream中读取 ##

你可以从清单8-12所示的实现中发现，假如eventCode是NSStreamEventHasBytesAvailable时，意味着有可读取的比特，你可以创建一个缓冲区，并从流中读取比特到缓冲区中。一旦所有的比特全都从流中读取完毕，根据当前操作，假如你正在执行listRemoteDirectory，你可以调用parseListData方法来解析结果，或者你正在下载一个文件，你可以调用parseListData方法来将它写到一个文件并存储。

## 写入NSStream ##

当你想要写入一个NSStream，你需要检查事件是不是NSStreamEventHasSpaceAvailable，该事件仅在NSStream仍有可用空间用于写入时被调用。因为流被当前runloop所调度安排，所以当无可用写入空间时，线程不会锁住。现在你可以简单地从缓冲区向流写入比特。

为使用FTPManager，你要用FTP服务端的IP地址来初始化它，并且在viewDidLoad方法里提供可用的用户名和密码。

你实现你所要求的代理方法，创建你所需要的用户界面，在FTPManager实例中调用适当的函数，走你！

正如你已知的，你不应当在主线程运行网络操作。因此最好的方法是使用DISPATCH\_QUEUE\_PRIORITY\_BACKGROUND在dispatch\_queue里创建FTPManager，这样你的用户界面就不会被锁住。

一个实现例子如清单8-14所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-14: Chapter8/SimpleFTPClient/YDViewController.m   
2.  \#import "YDViewController.h"  
3.  **@interface** YDViewController ()  
4.  **@end**  
5.  **@implementation** YDViewController  
6.  \- (**void**)viewDidLoad \{  
7.  \[**super** viewDidLoad\];  
8.  dispatch\_queue\_t defQueue = dispatch\_get\_global\_queue (DISPATCH\_QUEUE\_PRIORITY\_BACKGROUND, 0);  
9.  dispatch\_async(defQueue, ^\{  
10. ftpmanager=\[\[FTPManager alloc\] initWithServer:@"YOUR\_SERVERNAME"  
11. user:@"YOUR\_USERNAME" password:@"YOUR\_PASSWORD!"\];  
12. ftpmanager.delegate=**self**;  
13. \});  
14. \}  
15.  -(IBAction)uploadFile:(**id**)sender \{  
16. \[ftpmanager listRemoteDirectory\];  
17. \}  
18. \- (**void**)ftpDownloadFinishedWithSuccess:(**BOOL**)success \{  
19. **if** (!success) \{  
20. //handle your error  
21. \}   
22. \}  
23.   
24. \-(**void**)ftpError:(**NSString** \*)err  
25. \{  
26. //handle your error  
27. \}  
28.   
29. \-(**void**)directoryListingFinishedWithSuccess:(**NSArray** \*)arr \{  
30. //use the array the way you need it   
31. \}  
32.   
33. \- (**void**)ftpUploadFinishedWithSuccess:(**BOOL**)success \{  
34. **if** (!success) \{  
35. //handle your error  
36. \}   
37. \}  
38.   
39. \- (**void**)didReceiveMemoryWarning \{  
40. \[**super** didReceiveMemoryWarning\];   
41. \}  
42. **@end**

你可以将创建的FTPManager类用于你第一章创建的应用框架，这样当你开发一个新应用时候它就可以用了。

## 写一个复杂的FTP客户端 ##

使用你创建的FTPManager，你可以进行基本的操作，例如下载上传一个文件，在远程服务端端创建一个目录，取回一个目录的清单，就这些。假如你想对FTP过程有更多控制或者想进行本地操作，那你就需要一个不同的方案，该方案在更低层实现FTP协议。在本例子中你将学到如何写一个复杂的FTP客户端，给你FTP操作和应答处理的完全控制。

启动Xcode并创建一个Single ViewApplication Project模板的工程，命名为ComplexFTPClient使用如图8-2所示的选项。

![Center 3][]

作为第一步，再次添加CFNetwork到你的工程。

创建一个继承自NSObject的新类，命名为YDFTPClient。创建YDFTPClientDelegate协议和公开方法如清单8-15所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-15: Chapter8/ComplexFTPClient/YDFTPClient.h  
2.  \#import <Foundation/Foundation.h>   
3.  **@protocol** YDFTPClientDelegate <NSObject>  
4.  \-(**void**)logginFailed;  
5.  \-(**void**)loggedOn;  
6.  \-(**void**)serverResponseReceived:(**NSString** \*)lastResponseCode  
7.  message:(**NSString** \*)lastResponseMessage; -(**void**)ftpError:(**NSString** \*)err;  
8.  **@end**  
9.  **@interface** YDFTPClient : NSObject<NSStreamDelegate>  
10. **@property** (**nonatomic**, **strong**) **id**<YDFTPClientDelegate> delegate;   
11. **@property** (**readonly**) UInt64 numberOfBytesSent;  
12. **@property** (**readonly**) UInt64 numberOfBytesReceived;  
13. \- (**id**)initClient;  
14. \-(**void**)sendRAWCommand:(**NSString** \*)command;  
15. \-(**void**)connect;  
16. \-(**void**)disconnect;  
17. **@end**

YDFTPClient.m包括由它的变量定义的私有接口和不同方法的实现。像前面工程那样，YDFTPClient中的关键逻辑是流。你可以在本章的下载中找到完整的YDFTPClient.m实现。这不是所有FTP命令和应答的100%实现，但是是一个你可以通过实现你需要的命令来扩展的骨骼类（skeleton class）。

在YDFTPClient私有接口中创建properties，如清单8-16所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-16: Private Interface of the YDFTPClient **class**  
2.  **@interface** YDFTPClient() \{  
3.  UInt64 numberOfBytesSent;  
4.  UInt64 numberOfBytesReceived;  
5.  **int** uploadbytesreadSoFar;  
6.  \}  
7.  **@property** (**readwrite**, assign) NSString\* dataIPAddress;  
8.  **@property** (**readwrite**, assign) UInt16 dataPort;  
9.  **@property** (**nonatomic**, assign, **readonly** ) **uint8\_t** \* buffer;  
10. **@property** (**nonatomic**, assign, **readwrite**) **size\_t** bufferOffset;  
11. **@property** (**nonatomic**, assign, **readwrite**) **size\_t** bufferLimit;  
12. **@property** (**nonatomic**,assign) **int** lastResponseInt;  
13. **@property** (**nonatomic**,assign) NSString\* lastResponseCode;   
14. **@property** (**nonatomic**,assign) NSString\* lastCommandSent;   
15. **@property** (**nonatomic**,assign) NSString\* lastResponseMessage;  
16. **@property** (**nonatomic**,**retain**, **strong**) **NSInputStream** \*inputStream;   
17. **@property** (**nonatomic**, **retain**,**strong**) **NSOutputStream** \*outputStream;  
18. **@property**(**nonatomic**, **retain**,**strong**) **NSInputStream** \*dataInStream;   
19. **@property** (**nonatomic**, **retain**,**strong**) **NSOutputStream** \*dataOutStream;  
20. **@property** (**nonatomic**,assign) **BOOL** isConnected;  
21. **@property** (**nonatomic**,assign) **BOOL** loggedOn;  
22. **@property** (**nonatomic**,assign) **BOOL** isDataStreamConfigured;   
23. **@property** (**nonatomic**,assign) **BOOL** isDataStreamAvailable;  
24.   
25. **@end**

让我们来一步步分解该实现，initClient方法是你的将用于初始化本地变量和properties的自定义初始化器。该方法如清单8-17所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-17: The initClient method  
2.  \-(**id**)initClient   
3.  \{  
4.    **if** ((**self** = \[**super** init\]))  
5.  \{  
6.  **self**.isConnected=**NO**;   
7.  **self**.dataIPAddress=0;   
8.  **self**.dataPort=0;   
9.  **self**.isConnected=**NO**;   
10. **self**.isDataStreamAvailable=**NO**;   
11. **self**.lastCommandSent=@"";   
12. **self**.lastResponseCode=@"";  
13.     **self**.lastResponseMessage=@"";   
14. \}  
15. **return** **self**;  
16.  \}

你定义connect和disconnect方法。connect方法仅仅调用initNet-workCommunication:方法，disconnect方法调用logoff:方法，如清单8-18所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-18: The connect and disconnect methods  
2.  \-(**void**)connect   
3.  \{  
4.  **if** (!**self**.isConnected)  
5.  \[**self** initNetworkCommunication\];  
6.  \}   
7.  \-(**void**)disconnect   
8.  \{  
9.  **if** (**self**.isConnected)   
10. \[**self** logoff\];  
11. \}

scheduleInCurrentThread:方法和你前面的例子中的完全一样。initNetworkCommunication:方法被connect:方法调用，用于创建inputStream和outputStream，将它们安排调度到当前NSRunLoop，并打开，你可以在清单8-19中看到。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-19: The initNetworkCommunication method  
2.  \- (**void**) initNetworkCommunication \{   
3.  CFReadStreamRef readStream;   
4.  CFWriteStreamRef writeStream;   
5.  CFStreamCreatePairWithSocketToHost(**NULL**,  
6.  (\_\_bridge CFStringRef)kFTPServer, kFTPPort, &readStream, &writeStream);  
7.  **self**.inputStream = (\_\_bridge\_transfer **NSInputStream** \*)readStream;   
8.  **self**.outputStream = (\_\_bridge\_transfer **NSOutputStream** \*)writeStream;   
9.  \[**self**.inputStream setDelegate:**self**\];  
10. \[**self**.outputStream setDelegate:**self**\];  
11. \[**self** performSelector:**@selector**(scheduleInCurrentThread:)  
12. onThread:\[\[**self** class\] networkThread\]  
13.     withObject:**self**.inputStream  
14. waitUntilDone:**YES**\];  
15. \[**self** performSelector:**@selector**(scheduleInCurrentThread:)  
16. onThread:\[\[**self** class\] networkThread\]   
17. withObject:**self**.outputStream  
18. waitUntilDone:**YES**\];   
19. \[**self**.inputStream open\];  
20. \[**self**.outputStream open\];   
21. **self**.isConnected=**YES**;   
22. **self**.isDataStreamConfigured=**NO**;  
23. \}

stream:handleEvent:方法也在该实现中，是一个关键方法，包含了从流对象读取和写入的控制逻辑，你可以在清单8-20中看到。在NSStreamEventHasBytesAvailable事件中，你在缓冲区中读取来自流的比特，增加用于网络统计的numberOfBytesReceived property的值，发送读取输出到负责处理的messageReceived:方法中。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-20: The stream: handleEvent: method  
2.  \- (**void**)stream:(**NSStream** \*)theStream  
3.   handleEvent:(NSStreamEvent)streamEvent \{  
4.  **switch** (streamEvent) \{  
5.  **case** NSStreamEventOpenCompleted:  
6.  **break**;  
7.  **case** NSStreamEventNone:  
8.  **break**;  
9.  **case** NSStreamEventHasBytesAvailable:  
10. **if** (theStream == **self**.inputStream) \{  
11. uint8\_t buffer\[1024\];  
12. **int** len;  
13. **while** (\[**self**.inputStream hasBytesAvailable\]) \{  
14. len = \[**self**.inputStream read:buffer maxLength:**sizeof**(buffer)\];  
15. numberOfBytesReceived+=len;   
16. **if** (len > 0) \{  
17. **NSString** \*output = \[\[NSString alloc\] initWithBytes:buffer  
18. length:len encoding:NSASCIIStringEncoding\];   
19. **if** (output) \{  
20. \[**self** messageReceived:output\];   
21. \}  
22. \}  
23. \}  
24. \}  
25. **else** **if** (theStream == **self**.dataInStream) \{  
26. uint8\_t buffer\[8192\];//8kB block   
27. **int** len;  
28. **while** (\[**self**.dataInStream hasBytesAvailable\]) \{   
29. len = \[**self**.dataInStream read:buffer  
30. maxLength:**sizeof**(buffer)\];   
31.                     numberOfBytesReceived+=len;  
32. **if** (len > 0) \{  
33. **NSString** \*output = \[\[NSString alloc\] initWithBytes:buffer  
34. length:len   
35. encoding:NSASCIIStringEncoding\];  
36. **if** (output) \{  
37. \[**self** messageReceived:output\];  
38. \}   
39. \}  
40. \}   
41. \}  
42. **break**;  
43. **case** NSStreamEventHasSpaceAvailable:  
44. **if** (theStream == **self**.dataOutStream) \{  
45. //write your custom code for upload and download  
46. \}   
47. **break**;  
48. **case** NSStreamEventErrorOccurred:  
49. \[**self**.delegate ftpError:@"Network stream error occured"\];   
50. **break**;  
51. **case** NSStreamEventEndEncountered:   
52. **break**;  
53. \}   
54. \}

messageReceived方法是一个简单的、用于追踪最近一次来自服务端的响应，使用一个整形或者一个代码和消息，你可以去RFC协议中查阅应答代码。messageReceived:方法如清单8-21所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-21: The messageReceived: method  
2.  \- (**void**) messageReceived:(**NSString** \*)message \{   
3.  **self**.lastResponseCode = \[message substringToIndex:3\];   
4.  **self**.lastResponseMessage=message;  
5.  **int** response = \[\_lastResponseCode intValue\];   
6.  **self**.lastResponseInt=response;  
7.  \[**self**.delegate serverResponseReceived:   
8.  **self**.lastResponseCode message:\_lastResponseMessage\];  
9.      **switch** (response) \{   
10. **case** 150:  
11. //connection accepted break;  
12. **case** 200:  
13. \[**self** sendCommand:@"PASV"\];  
14. **case** 220: //server welcome message so wait for username  
15. \[**self** sendUsername\];  
16. **break**;   
17. **case** 226:  
18. //transfer OK break;  
19. **case** 227:  
20. \[**self** acceptDataStreamConfiguration:message\];   
21. **break**;  
22. **case** 230: //server logged in   
23. **self**.loggedOn=**YES**;  
24. \[**self** sendCommand:@"PASV"\];  
25.     \[**self**.delegate loggedOn\]; **break**;  
26. **case** 331: //server waiting for password   
27. \[**self** sendPassword\];  
28. **break**;  
29. **case** 530: //Login or passwod incorrect  
30. \[**self**.delegate logginFailed\];   
31. **self**.loggedOn=**NO**;  
32. **break**;  
33. **default**:   
34. **break**;  
35. \}   
36. \}

代码中应注意到，出于安全目的，大多数客户端使用被动连接模式。因这个原因，当发送PASV命令到FTP服务端时，应答会包含将建立的、用于服务端和客户端数据交换的data socket的IP地址和端口号。

acceptDataStreamConfiguration方法负责使用正则表达式解析上述应答结果。前四组数字代表IP地址，后两组用于创建端口号。所以，例如应答是a.b.c.d.x.y，端口号用如下公式计算：(x \* 256) + y。acceptDataStreamconfiguration方法如清单8-22所示。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-22: acceptDataStreamConfiguration method  
2.  \-(**void**)acceptDataStreamConfiguration:(NSString\*)serverResponse   
3.  \{   **NSString** \*pattern=  
4.  @"(\[-\\\\d\]+),(\[-\\\\d\]+),(\[-\\\\d\]+),(\[-\\\\d\]+),(\[-\\\\d\]+),(\[-\\\\d\]+)";   
5.  **NSError** \*error =** nil**;  
6.  **NSRegularExpression** \*regex = \[NSRegularExpression  
7.  regularExpressionWithPattern:pattern options:0  
8.  error:&error\];  
9.  **NSTextCheckingResult** \*match = \[regex firstMatchInString: serverResponse  
10. options:0 range:NSMakeRange(0, \[serverResponse length\])\];  
11. **self**.dataIPAddress = \[NSString stringWithFormat:@"%@.%@.%@.%@",   
12. \[serverResponse substringWithRange:\[match rangeAtIndex:1\]\],  
13.             \[serverResponse substringWithRange:\[match rangeAtIndex:2\]\],   
14. \[serverResponse substringWithRange:\[match rangeAtIndex:3\]\],  
15.    \[serverResponse substringWithRange:\[match rangeAtIndex:4\]\]\];  
16.  **self**.dataPort = (\[\[serverResponse substringWithRange:  
17. \[match rangeAtIndex:5\]\] intValue\] \* 256)+   
18. \[\[serverResponse substringWithRange:\[match rangeAtIndex:6\]\] intValue\];  
19.     **self**.isDataStreamConfigured=**YES**;  
20. \[**self** openDataStream\];  
21. \}

最后，你需要一些生命周期管理的代码在你的实现里，如清单8-23所示。openDataStream创建一个inputStream和outputStream并且使用scheduleInCurrentThread:方法将他们调度安排到当前runLoop。closeDataStream方法恰当地关闭并且移除数据流。

**\[objc\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  LISTING 8\-23: openDataStream, closeDataStream, and logoff methods  
2.  \-(**void**)openDataStream   
3.  \{  
4.  **if** (**self**.isDataStreamConfigured && !**self**.isDataStreamAvailable)\{   
5.  CFReadStreamRef readStream;  
6.  CFWriteStreamRef writeStream;  
7.  CFStreamCreatePairWithSocketToHost(**NULL**,  
8.  (\_\_bridge CFStringRef)**self**.dataIPAddress,   
9.  **self**.dataPort, &readStream, &writeStream);  
10. **self**.dataInStream = (\_\_bridge\_transfer **NSInputStream** \*)readStream;  
11. **self**.dataOutStream = (\_\_bridge\_transfer **NSOutputStream** \*)writeStream;  
12. \[**self**.dataInStream setDelegate:**self**\];  
13. \[**self**.dataOutStream setDelegate:**self**\];  
14. \[**self** performSelector:**@selector**(scheduleInCurrentThread:)   
15. onThread:\[\[**self** class\] networkThread\]  
16. withObject:**self**.dataInStream waitUntilDone:**YES**\];  
17. \[**self** performSelector:**@selector**(scheduleInCurrentThread:)   
18. onThread:\[\[**self** class\] networkThread\]  
19. withObject:**self**.dataOutStream waitUntilDone:**YES**\];  
20. \[**self**.dataInStream open\];   
21. \[**self**.dataOutStream open\];   
22. **self**.isDataStreamAvailable=**YES**;  
23. \}  
24. \}   
25.   
26. \-(**void**)closeDataStream  
27.  \{  
28.     **if** (**self**.dataInStream.streamStatus != NSStreamStatusClosed) \{  
29. \[**self**.dataInStream removeFromRunLoop:   
30. \[NSRunLoop currentRunLoop\]  
31. forMode:NSDefaultRunLoopMode\];   
32. **self**.dataInStream.delegate =** nil**;   
33. \[**self**.dataInStream close\];  
34. \}  
35. **if** (**self**.dataOutStream.streamStatus != NSStreamStatusClosed) \{  
36. \[**self**.dataOutStream removeFromRunLoop:   
37. \[NSRunLoop currentRunLoop\]  
38. forMode:NSDefaultRunLoopMode\];  
39.             **self**.dataOutStream.delegate =** nil**;   
40. \[**self**.dataOutStream close\];  
41. \}  
42. \}  
43.   
44.   
45.  -(**void**)logoff \{  
46. \[**self** sendCommand:@"QUIT"\];  
47. \[**self** closeDataStream\];  
48. **if** (**self**.inputStream.streamStatus != NSStreamStatusClosed)  
49. \{  
50. \[**self**.inputStream removeFromRunLoop:  
51. \[NSRunLoop currentRunLoop\]  
52. forMode:NSDefaultRunLoopMode\];  
53. **self**.inputStream.delegate =** nil**;   
54. \[**self**.inputStream close\];  
55. \}  
56. **if** (\_outputStream.streamStatus != NSStreamStatusClosed)   
57. \{  
58. \[**self**.outputStream removeFromRunLoop:   
59. \[NSRunLoop currentRunLoop\] forMode:NSDefaultRunLoopMode\];  
60. **self**.outputStream.delegate =** nil**;   
61. \[**self**.outputStream close\];  
62. \}  
63. **self**.isConnected=**NO**;   
64. **self**.isDataStreamAvailable=**NO**;   
65. **self**.isDataStreamConfigured=**NO**;  
66. \}

# 运行FTP客户端 #

为使用你开发的FTP客户端，了解一系列发送的FTP命令和处理相关FTP回应是非常重要的。

你可以在http://www.w3.org/Protocols/rfc959找到完整的RFC说明文档。

当流打开，服务端会回应以220应答（220 response）和某种欢迎消息。假定你的FTP服务端不允许匿名连接，第一个期望的命令是USER命令后加用户名。假如用户名是正确的，服务端会回应331，表示等待回应一个密码。你使用PASS命令后加密码来发送密码。

YDFTPClinet类中的sendUsername和sendPassword方法仅仅是说明发送用户名和密码的简单包装。服务端或回应230登陆成功，或530登录失败。

在登陆之后，直接向服务端发送一个PASV命令是个好习惯，该命令告诉FTP服务端使用一个被动连接，被动连接比主动连接（一直是同样的IP端口）更安全。一个被动连接从服务端配置的可用端口范围中，为数据流选择和使用一个随机端口。

你可以将这个YDFTPClient类添加到你第一章创建的应用框架中。

# 总结 #

在本章，你学到两种实现使用流实现FTP客户端的不同方法，使用你所学的技术，你可以：

Ø  创建到FTP客户端的流连接

Ø  从FTP服务端下载或向其上传文件

Ø  发送原生FTP命令到FTP服务端并处理响应

[Center]: /images/20220731/c4e77e8d326d4e1d8b0ccb38d1bbbe14.png
[Center 1]: /images/20220731/404318e6483748dc83523e055e2ed944.png
[view plain]: http://blog.csdn.net/mamong/article/details/19364323#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/192245
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/192245/fork
[ftp_127.0.0.1_picture1.png]: ftp://127.0.0.1/picture1.png
[Center 2]: /images/20220731/eb152473dbd8449687173f6de3aee684.png
[Center 3]: /images/20220731/3a96bfa15a374a9683681e6875646c55.png