ping 的功能
ping 程序对于开发人员来说应该是不会陌生的, ping 通常用来探测主机到主机之间是否可以通信。如果可以 ping 通，意味着可以和该主机建立网络连接，就像这样的。
➜ ~ ping www.qq.com
PING www.qq.com (182.254.34.74): 56 data bytes
64 bytes from 182.254.34.74: icmp_seq=0 ttl=53 time=22.996 ms
64 bytes from 182.254.34.74: icmp_seq=1 ttl=53 time=36.688 ms
64 bytes from 182.254.34.74: icmp_seq=2 ttl=53 time=25.390 ms
64 bytes from 182.254.34.74: icmp_seq=3 ttl=53 time=25.516 ms
如果不能 ping 通，那就意味着无法和该主机建立网络连接，就像下面这样的。
➜ ~ ping www.google.com
PING www.google.com (66.220.147.47): 56 data bytes
Request timeout for icmp_seq 0
Request timeout for icmp_seq 1
Request timeout for icmp_seq 2
Request timeout for icmp_seq 3
Request timeout for icmp_seq 4
Apple 的 SimplePing 封装了 ping 的功能，它利用 resolve host，create socket(send & recv data), 解析 ICMP 包验证 checksum 等实现了 ping 功能。并且支持 iPv4 和 iPv6。
ICMP 协议
ping 功能使用是 ICMP 协议（Internet Control Message Protocol），ICMP 协议定义了一组错误信息，当路由器或者主机无法成功处理一个IP 封包的时候，能够将错误信息回送给来源主机，ICMP 常见的错误如下。
- 传输线路或者节点故障导致无法到达目的地主机
- 路由器封包重组失败
- 封包存活时间（Time To Live,TTL）变成 0 (防止封包在网络中永无止境得绕圈)
- IP 首部的错误检查码发现错误
iOS SimplePing 的使用
// 1. 利用 HostName 创建 SimplePing
SimplePing *pinger = [[SimplePing alloc] initWithHostName:@"www.apple.com"];
self.pinger = pinger;
// 2. 指定 IP 地址类型
if (isIpv4 && !isIpv6) {
pinger.addressStyle = SimplePingAddressStyleICMPv4;
}else if (isIpv6 && !isIpv4) {
pinger.addressStyle = SimplePingAddressStyleICMPv6;
}
// 3. 设置 delegate,用于接收回调信息
pinger.delegate = self;
// 4. 开始 ping
[pinger start];
SimplePing 的使用还是非常简单的，
- 利用 HostName 创建 SimplePing
- 指定 IP 地址类型
- 设置 delegate,用于接收回调信息
- 开始 ping
delegate 的回调方法体现了 ping 的过程。
// 解析 HostName 拿到 ip 地址之后，发送封包
- (void)simplePing:(SimplePing *)pinger didStartWithAddress:(NSData *)address
{
NSLog(@"pinging %@", displayAddressForAddress(address));
[self sendPing];
}
// ping 功能启动失败
- (void)simplePing:(SimplePing *)pinger didFailWithError:(NSError *)error
{
NSLog(@"failed: %@", shortErrorFromError(error));
[self stop];
}
// ping 成功发送封包
- (void)simplePing:(SimplePing *)pinger didSendPacket:(NSData *)packet sequenceNumber:(uint16_t)sequenceNumber
{
NSLog(@"#%u sent", sequenceNumber);
}
// ping 发送封包失败
- (void)simplePing:(SimplePing *)pinger didFailToSendPacket:(NSData *)packet sequenceNumber:(uint16_t)sequenceNumber error:(NSError *)error
{
NSLog(@"#%u send failed: %@", sequenceNumber,shortErrorFromError(error));
}
// ping 发送封包之后收到响应
- (void)simplePing:(SimplePing *)pinger didReceivePingResponsePacket:(NSData *)packet sequenceNumber:(uint16_t)sequenceNumber
{
NSLog(@"#%u received, size=%zu", sequenceNumber, packet.length);
}
// ping 接收响应封包发生异常
- (void)simplePing:(SimplePing *)pinger didReceiveUnexpectedPacket:(NSData *)packet
{
NSLog(@"unexpected packet, size=%zu", packet.length);
}
SimplePing 的流程
上图是 SimplePing 执行一次 ping IPv4 地址的流程图，
ping 的实现并不负责，一共有以下几个步骤
- 解析传入的 HostName，获取第一个可用 IP 地址
- 创建传输/接收数据的 socket
- 发送数据，封装一个 ICMP 包
- 解析目标 IP 传回的 ICMP 包
HostName 的解析
关于 HostName 的解析，SimplePing 采用 CFHost 这个异步 API 方案，通过CFHost解析主机名主要有以下几个步骤：
- 通过调用 CFHostCreateWithName 创建一个 CFHostRef 对象。
- 调用 CFHostSetClient 并且提供一个上下文对象和回调函数，这个回调函数在解析结束的时候会被调用。
- 调用 CFHostScheduleWithRunLoop 用于在 RunLoop 中执行具体的解析操作。
- 调用 CFHostStartInfoResolution 来告诉解析器开始解析，把它的第二个参数设置为 kCFHostAddresses 表明你想要返回一个 IP 地址。
- 等待解析器调用你的回调函数，通过你的回调函数，调用 CFHostGetAddressing 函数来获取解析结果。这个函数返回 CFDataRef 对象的一个数组，其中的每一个都包含一个 POSIX 的 sockaddr 结构体。
下面的这段代码执行的是 1 - 4 过程
- (void)start {
Boolean success;
CFHostClientContext context = {0, (__bridge void *)(self), NULL, NULL, NULL};
CFStreamError streamError;
assert(self.host == NULL);
assert(self.hostAddress == nil);
self.host = (CFHostRef) CFAutorelease( CFHostCreateWithName(NULL, (__bridge CFStringRef) self.hostName) );
assert(self.host != NULL);
CFHostSetClient(self.host, HostResolveCallback, &context);
CFHostScheduleWithRunLoop(self.host, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
success = CFHostStartInfoResolution(self.host, kCFHostAddresses, &streamError);
if ( ! success ) {
[self didFailWithHostStreamError:streamError];
}
}
在系统解析 HostName 成功之后会调用 HostResolveCallback 这个回调，这个回调的作用相当于重定向，将内容从 c 转成适当的 Objective-C 内容。
static void HostResolveCallback(CFHostRef theHost, CFHostInfoType typeInfo, const CFStreamError *error, void *info) {
// This C routine is called by CFHost when the host resolution is complete.
// It just redirects the call to the appropriate Objective-C method.
SimplePing * obj;
obj = (__bridge SimplePing *) info;
assert([obj isKindOfClass:[SimplePing class]]);
// 省略代码 ......
if ( (error != NULL) && (error->domain != 0) ) {
[obj didFailWithHostStreamError:*error];
} else {
// 在这个方法获取 HostName 对应的地址
[obj hostResolutionDone];
}
}
调用 CFHostGetAddressing 函数来获取解析结果，这个函数返回一个数组，从这个数组中取得 HostName 对应的 IP。从服务端的角度来说，为了实现负载均衡，一个域名是可以对应多个 IP 的，但是从客户端的角度来说，一个域名就是对应一个 IP。
- (void)hostResolutionDone {
Boolean resolved;
NSArray * addresses;
// Find the first appropriate address.
addresses = (__bridge NSArray *) CFHostGetAddressing(self.host, &resolved);
if ( resolved && (addresses != nil) ) {
resolved = false;
for (NSData * address in addresses) {
const struct sockaddr * addrPtr;
addrPtr = (const struct sockaddr *) address.bytes;
if ( address.length >= sizeof(struct sockaddr) ) {
switch (addrPtr->sa_family) {
case AF_INET: {
if (self.addressStyle != SimplePingAddressStyleICMPv6) {
self.hostAddress = address;
resolved = true;
}
} break;
case AF_INET6: {
if (self.addressStyle != SimplePingAddressStyleICMPv4) {
self.hostAddress = address;
resolved = true;
}
} break;
}
}
if (resolved) {
break;
}
}
}
// We're done resolving, so shut that down.
[self stopHostResolution];
// If all is OK, start the send and receive infrastructure, otherwise stop.
if (resolved) {
[self startWithHostAddress];
} else {
[self didFailWithError:[NSError errorWithDomain:(NSString *)kCFErrorDomainCFNetwork code:kCFHostErrorHostNotFound userInfo:nil]];
}
}
Socket 操作
HostName 解析成功拿到对应的 IP 之后，SimplePing 调用startWithHostAddress 创建 socket 。
- 使用 CFSocketCreateWithNative 创建一个 CFSocket
- 使用 CFSocketCreateRunLoopSource 为 CFSocket 创建一个 CFRunLoopSourceRef，
- 使用 CFRunLoopAddSource 将 CFRunLoopSourceRef 添加到 RunLoop 的 kCFRunLoopDefaultMode 模式中。
- (void)startWithHostAddress {
// 省略代码 ......
CFSocketContext context = {0, (__bridge void *)(self), NULL, NULL, NULL};
CFRunLoopSourceRef rls;
id<SimplePingDelegate> strongDelegate;
// Wrap it in a CFSocket and schedule it on the runloop.
self.socket = (CFSocketRef) CFAutorelease( CFSocketCreateWithNative(NULL, fd, kCFSocketReadCallBack, SocketReadCallback, &context) );
assert(self.socket != NULL);
// The socket will now take care of cleaning up our file descriptor.
assert( CFSocketGetSocketFlags(self.socket) & kCFSocketCloseOnInvalidate );
fd = -1;
rls = CFSocketCreateRunLoopSource(NULL, self.socket, 0);
assert(rls != NULL);
CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);
CFRelease(rls)；
// 省略代码 ......
}
在 CFSocketCreateWithNative 的官方文档描述中有提到，CFSocketCreateWithNative 在创建 socket 的时候是有一个复用机制的。
The new CFSocket object, or `NULL` if an error occurred.
If a CFSocket object already exists for `sock`,
the function returns the pre-existing object instead of creating a new object;
封装 ICMP 包
在 socket 创建完成之后，接下来就要开始组装 IP 封包并发送了。组装 IP 封包并发送的过程需要我们手动在这个回调方法触发。
- (void)simplePing:(SimplePing *)pinger didStartWithAddress:(NSData *)address
{
// 调用 - (void)sendPingWithData:(NSData *)data
}
sendPingWithData 这个方法做的操作是组装 IP 封包然后发送封包，调用这个过程对应的回调方法。发送封包的过程是调用 sendto 方法
- (void)sendPingWithData:(NSData *)data {
// 省略代码 ......
// Send the packet.
if (self.socket == NULL) {
bytesSent = -1;
err = EBADF;
} else {
bytesSent = sendto(
CFSocketGetNative(self.socket),
packet.bytes,
packet.length,
0,
self.hostAddress.bytes,
(socklen_t) self.hostAddress.length
);
err = 0;
if (bytesSent < 0) {
err = errno;
}
}
// 省略代码 ......
组装 IP 封包是调用下面这个方法来完成，这个方法把数据按照 ICMPHeader 结构体的格式进行初始化并返回 IP 封包，关于 ICMPHeader 的结构这里就不再累赘，通过 ICMPHeader 结构体的定义就可以明白。
- (NSData *)pingPacketWithType:(uint8_t)type
payload:(NSData *)payload
requiresChecksum:(BOOL)requiresChecksum ；
解析 ICMP 包
完成了发送操作之后，接下来就是等待 ping 的响应了。当 socket 收到 ping 响应的时候回调 SocketReadCallback ，这个回调的作用相当于重定向，将内容从 c 转成适当的 Objective-C 内容，SocketReadCallback 里面调用了 readData 方法。
static void SocketReadCallback(CFSocketRef s, CFSocketCallBackType type, CFDataRef address, const void *data, void *info)
在 readData 方法里面做的工作就是读取响应数据，验证响应的数据正确性，执行相应的回调方法。与sendto对应，读取数据使用的是 recvfrom 方法。验证响应数据调用的是下面的方法。
- (BOOL)validatePing4ResponsePacket:(NSMutableData *)packet sequenceNumber:(uint16_t *)sequenceNumberPtr
这个方法接收 ping 响应数据的时候，会对 ICMP 包进行校验，会跳过 IP 头，毕竟 IP 首部对于 ping 功能来说并不重要，重要的是 ICMP 协议的内容，其中主要验证的字段是 checksum 和 sequenceNumber（iPv6 只需要验证 sequenceNumber）。
停止 ping 的时候需要做一些清理工作，包括 socket 和 CFHost 对应的销毁。
到这里，整个 ping 的基本流程就结束了。
总结
ICMP 协议规定，目的主机必须返回 ICMP 回送应答消息给源主机，如果源主机在一定时间内收到应答，则认为主机可达，而 ping 功能使用的是 ICMP 协议。
SimplePing 实现 ping 操作的原理步骤是这样的，先解析出 HostName 对应的 IP 地址，这个才知道数据包要发送给哪个目的主机，接着构造符合 ICMP 协议格式的数据包并发送，等待目的主机响应。一段时间过后，目的主机响应数据到达源主机，源主机接收响应数据包，验证数据包，然后去掉数据包的 IP 首部，拿到 ICMP 数据。由于个人水平有限，文章若有不对之处恳请指出，我稍作修改，大家共同进步。
参考
- https://developer.apple.com/library/content/documentation/NetworkingInternet/Conceptual/NetworkingTopics/Articles/ResolvingDNSHostnames.html#//apple_ref/doc/uid/TP40012543-SW1
- https://github.com/iOS-Developer-Documents-Chinese/iOS-Developer-Documents-Chinese/blob/master/Socket/DNS%E4%B8%BB%E6%9C%BA%E5%90%8D%E7%9A%84%E8%A7%A3%E6%9E%90.md
- https://www.cnblogs.com/cuihongyu3503319/archive/2012/07/09/2583129.html
- http://blog.163.com/qhj4433210@126/blog/static/165975282201592251248584/
- http://blog.csdn.net/inject2006/article/details/2139149
- https://zhaoxinyu.me/2017-04-12-simple-ping/
- https://en.wikipedia.org/wiki/IPv4_header_checksum
