iOS ping - SimplePing 源码解读

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 常见的错误如下。

1. 传输线路或者节点故障导致无法到达目的地主机
2. 路由器封包重组失败
3. 封包存活时间（Time To Live,TTL）变成 0 (防止封包在网络中永无止境得绕圈)
4. 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 的使用还是非常简单的，

1. 利用 HostName 创建 SimplePing
2. 指定 IP 地址类型
3. 设置 delegate,用于接收回调信息
4. 开始 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 的实现并不负责，一共有以下几个步骤

1. 解析传入的 HostName，获取第一个可用 IP 地址
2. 创建传输/接收数据的 socket
3. 发送数据，封装一个 ICMP 包
4. 解析目标 IP 传回的 ICMP 包

HostName 的解析

关于 HostName 的解析，SimplePing 采用 CFHost 这个异步 API 方案，通过CFHost解析主机名主要有以下几个步骤：

1. 通过调用 CFHostCreateWithName 创建一个 CFHostRef 对象。
2. 调用 CFHostSetClient 并且提供一个上下文对象和回调函数，这个回调函数在解析结束的时候会被调用。
3. 调用 CFHostScheduleWithRunLoop 用于在 RunLoop 中执行具体的解析操作。
4. 调用 CFHostStartInfoResolution 来告诉解析器开始解析，把它的第二个参数设置为 kCFHostAddresses 表明你想要返回一个 IP 地址。
5. 等待解析器调用你的回调函数，通过你的回调函数，调用 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 。

1. 使用 CFSocketCreateWithNative 创建一个 CFSocket
2. 使用 CFSocketCreateRunLoopSource 为 CFSocket 创建一个 CFRunLoopSourceRef，
3. 使用 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 数据。由于个人水平有限，文章若有不对之处恳请指出，我稍作修改，大家共同进步。

参考

1. https://developer.apple.com/library/content/documentation/NetworkingInternet/Conceptual/NetworkingTopics/Articles/ResolvingDNSHostnames.html#//apple_ref/doc/uid/TP40012543-SW1
2. 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
3. https://www.cnblogs.com/cuihongyu3503319/archive/2012/07/09/2583129.html
4. http://blog.163.com/qhj4433210@126/blog/static/165975282201592251248584/
5. http://blog.csdn.net/inject2006/article/details/2139149
6. https://zhaoxinyu.me/2017-04-12-simple-ping/
7. https://en.wikipedia.org/wiki/IPv4_header_checksum