内核版本：2.6.34
　　ICMP模块比较简单，要注意的是icmp的速率限制策略，向IP层传输数据ip_append_data()和ip_push_pending_frames()。
在net/ipv4/af_inet.c中的inet_init()注册icmp协议，从这里也可以看出，ICMP模块是绑定在IP模块之上的。inet_add_protocol()会将icmp_protocol加入到全局量inet_protos中。

[cpp] view plaincopy
  1. if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
  2. printk(KERN_CRIT "inet_init: Cannot add ICMP protocol\n");
  3. icmp_protocol定义如下：
  4. static const struct net_protocol icmp_protocol = {
  5. .handler = icmp_rcv,
  6. .no_policy = 1,
  7. .netns_ok = 1,
  8. };

　　除了注册icmp协议，还要对icmp模块初始化，这部分由icmp_init()完成。

[cpp] view plaincopy
  1. if (icmp_init() < 0)
  2. panic("Failed to create the ICMP control socket.\n");

　　icmp_init()函数做的事很简单，register_pernet_subsys(&icmp_sk_ops)，而注册icmp网络子系统过程中会调用icmp_sk_ops.init(即icmp_sk_init函数)来完成它的初始化，下面具体看icmp_sk_init()函数。
　　首先为net为配CPU数目(nr_cpu_ids)个struct sock结构体空间，这里的net是全局的网络名，一般是init_inet。
net->ipv4.icmp_sk = kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
　　每个CPU i，它的sock结构体位于net中的icmp_sk[i]。于每个CPU i，初始化刚刚分配的icmp_sk[i]：
　　　-第一步，inet_ctl_sock_create()创建sk，并在net->ipv4.icmp_sk[i] = sk中将其赋值给icmp_sk[i]。
　　　-第二步：ICMP发送缓存区大小sk_sndbuf设置为128K

[cpp] view plaincopy
  1. for_each_possible_cpu(i) {
  2. struct sock *sk;
  3. err = inet_ctl_sock_create(&sk, PF_INET,
  4. SOCK_RAW, IPPROTO_ICMP, net);
  5. if (err < 0)
  6. goto fail;
  7. net->ipv4.icmp_sk[i] = sk;
  8. sk->sk_sndbuf =
  9. (2 * ((64 * 1024) + sizeof(struct sk_buff)));
  10. sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
  11. inet_sk(sk)->pmtudisc = IP_PMTUDISC_DONT;
  12. }

　　忽略发往广播地址的icmp echo报文；忽略发往广播地址的错误的响应报文；

[cpp] view plaincopy
  1. net->ipv4.sysctl_icmp_echo_ignore_all = 0;
  2. net->ipv4.sysctl_icmp_echo_ignore_broadcasts = 1;
  3. net->ipv4.sysctl_icmp_ignore_bogus_error_responses = 1;

　　设置icmp处理速率，这里的ratelimit和ratemask参数在后面限速处理时会具体用到。

[cpp] view plaincopy
  1. net->ipv4.sysctl_icmp_ratelimit = 1 * HZ;
  2. net->ipv4.sysctl_icmp_ratemask = 0x1818;
  3. net->ipv4.sysctl_icmp_errors_use_inbound_ifaddr = 0;

　　初始化工作完成后，还是从icmp的接收开始，icmp_rcv完成icmp报文的处理。
取得icmp报头，此时skb->transport_header是在IP模块处理中的ip_local_deliver_finish()将其设置为了指向icmp报头的位置。

[cpp] view plaincopy
  1. icmph = icmp_hdr(skb);

　　根据icmp的类型type交由不同的处理函数去完成。

[cpp] view plaincopy
  1. icmp_pointers[icmph->type].handler(skb);

　　icmp_pointers是在icmp.c中定义的全局量，部分如下：

[cpp] view plaincopy
  1. static const struct icmp_control icmp_pointers[NR_ICMP_TYPES + 1] = {
  2. [ICMP_ECHOREPLY] = {
  3. .handler = icmp_discard,
  4. },
  5. [1] = {
  6. .handler = icmp_discard,
  7. .error = 1,
  8. },
  9. ……
  10. }

　　比如对于收到的icmp报文type为0或1(响应答复或目的不可达)，协议栈要做的就是丢弃掉它 – icmp_discard()。下面以icmp echo和icmp timestamp为例说明。

收到icmp echo报文执行icmp_echo()
　　icmp_param是回复时信息，它直接拷贝了echo的ICMP报头icmp_hdr(skb)，仅仅改变了报头的type = ICMP_ECHO_REPLY，然后调用icmp_reply()处理发送。

[cpp] view plaincopy
  1. struct icmp_bxm icmp_param;
  2. icmp_param.data.icmph    = *icmp_hdr(skb);
  3. icmp_param.data.icmph.type = ICMP_ECHOREPLY;
  4. icmp_param.skb     = skb;
  5. icmp_param.offset    = 0;
  6. icmp_param.data_len    = skb->len;
  7. icmp_param.head_len    = sizeof(struct icmphdr);
  8. icmp_reply(&icmp_param, skb);

收到icmp timestamp报文后执行icmp_timestamp()
　　经过IP层处理，skb->data指向icmp报头的位置，而报头最小为4字节，所以这里判断skb->len < 4，是则丢弃该报文。从这里也可以看出，时间戳请求报文可以只有4节字头部，而没有时间戳信息。

[cpp] view plaincopy
  1. if (skb->len < 4)
  2. goto out_err;

　　这段代码设置时间戳响应的时间戳信息，包括接收时间戳和发送时间戳，两者分别代表主机收到报文的时间，发送响应报文的时间，而从这部分代码也可以看出icmp_param.data.times[2] = icmp_param.data.times[1]协议栈简单的将接收和发送时间戳置为相同的。时间戳的计算很简单，格林尼治时间的当天时间的微秒数。最后skb_copy_bits()从skb的ICMP报文内容拷贝4节字的时间到icmp_param_data.times[0]，即发起时间戳，所以最后情形如下：
　　　icmp_param_data.times[0] 发起时间戳，从请求报文中拷贝
　　　icmp_param_data.times[0]　接收时间戳，处理ICMP报头时的时间
　　　icmp_param_data.times[0] 发送时间戳，设置为与接收时间戳相同

[cpp] view plaincopy
  1. getnstimeofday(&tv);
  2. icmp_param.data.times[1] = htonl((tv.tv_sec % 86400) * MSEC_PER_SEC +
  3. tv.tv_nsec / NSEC_PER_MSEC);
  4. icmp_param.data.times[2] = icmp_param.data.times[1];
  5. if (skb_copy_bits(skb, 0, &icmp_param.data.times[0], 4))
  6. BUG();

　　前面已经说过，icmp_param就是要发送ICMP报文的内容，上面设置了内容，接下来设置报头，同样是直接拷贝了ICMP请求的报头，改变type为ICMP_TIMESTAMPREPLY。注意这里的data_len设置为0，因为它与icmp echo不同，一定是没有分片的，即没有paged_data部分。head_len设置为icmphdrlen+12，这里是为了调用icmp_reply()回复时的统一，实现表示ICMP部分的长度，主要是有分片时会根据head_len来跳过报头而只拷贝每个分片的内容。

[cpp] view plaincopy
  1. icmp_param.data.icmph    = *icmp_hdr(skb);
  2. icmp_param.data.icmph.type = ICMP_TIMESTAMPREPLY;
  3. icmp_param.data.icmph.code = 0;
  4. icmp_param.skb     = skb;
  5. icmp_param.offset    = 0;
  6. icmp_param.data_len    = 0;
  7. icmp_param.head_len    = sizeof(struct icmphdr) + 12;

　　最后调用icmp_reply()回复，这与icmp_echo()是相同的。

[cpp] view plaincopy
  1. icmp_reply(&icmp_param, skb);

　　注意两者设置icmp_param参数时的区别：
　　　icmp_echo()中icmp_param.data_len=skb->len;
　　　　　　　　　　icmp_param.head_len=sizeof(struct icmphdr);
　　　icmp_timestamp()中icmp_param.data_len=0。
　　　　　　　　　　icmp_param.head_len=sizeof(struct icmphdr)+12;

icmp_reply()
　　通过ip_route_output_key()查找路由信息，存放在rt中。路由项在这里有两个作用：一是限速是针对每个路由项的，在icmpv4_xrlim_allow()中会用到；二是将报文传递给IP层需要用到rt。仔细观察流程可以发现，报文在协议栈传递过程中，在IP层会　　查找一次路由表获取到了rt，而在这里又查找了一次路由表，似乎是重复了。其实不是，IP层查找是在报文接收阶段，这里的查找是在报文的发送阶段。

[cpp] view plaincopy
  1. {
  2. struct flowi fl = { .nl_u = { .ip4_u =
  3. { .daddr = daddr,
  4. .saddr = rt->rt_spec_dst,
  5. .tos = RT_TOS(ip_hdr(skb)->tos) } },
  6. .proto = IPPROTO_ICMP };
  7. security_skb_classify_flow(skb, &fl);
  8. if (ip_route_output_key(net, &rt, &fl))
  9. goto out_unlock;
  10. }

　　协议栈对于部分ICMP报文进行了限速，但这种限速不是整体的，而是针对每个路由项的，即限制每个地址发送ICMP报文的限率。icmpv4_xrlim_allow()判断该icmp报文是否需要被限速，如果能接收，则调用icmp_puash_reply()发送响应。

[cpp] view plaincopy
  1. if (icmpv4_xrlim_allow(net, rt, icmp_param->data.icmph.type,
  2. icmp_param->data.icmph.code))
  3. icmp_push_reply(icmp_param, &ipc, &rt);

icmpv4_xrlim_allow() -> xrlim_allow()　限速处理
　　速率有关的参数是在icmp_init() -> icmp_sk_init()创建ICMP的sock时设置的，ratelimit是限制的速率，即TBF代码段中的timeout，可以理解成一个令牌；ratemask是被限制速率的ICMP的报文类型，(1 << type & retemask) == 1判断是否限速，type即ICMP类型，可见默认情况下[3]dest unreachable, [4]source quench, [11]time exceeded, [12]parameter problem才会被限速。

[cpp] view plaincopy
  1. net->ipv4.sysctl_icmp_ratelimit = 1 * HZ;
  2. net->ipv4.sysctl_icmp_ratemask = 0x1818;

　　限速使用了Token Bucket Filter(令牌环过滤器)思想，大致是每个到来的令牌从数据队列中收集一个数据包，然后从桶中删除。令牌被耗尽时，数据包将停止发送一段时间。
　　ICMP的限速使用的就是这种思想，不过时间作为令牌，它的增长是连续的；每来一个报文，拿走一个令牌，则是一个时间段timeout，令牌也限定了最大数目是XRLIM_BURST_FACTOR为6；简单来讲就是每过timeout时间，令牌数就加１，当令牌数达到6时不再增加；而来一个报文，令牌数就减一，当令牌数为空时，不再减少，该报文也被丢弃；在这种情况下，在过timeout时间，才会处理下一个报文。实现的代码段如下：

[cpp] view plaincopy
  1. #define XRLIM_BURST_FACTOR 6
  2. int xrlim_allow(struct dst_entry *dst, int timeout)
  3. {
  4. unsigned long now, token = dst->rate_tokens;
  5. int rc = 0;
  6. now = jiffies;
  7. token += now - dst->rate_last;
  8. dst->rate_last = now;
  9. if (token > XRLIM_BURST_FACTOR * timeout)
  10. token = XRLIM_BURST_FACTOR * timeout;
  11. if (token >= timeout) {
  12. token -= timeout;
  13. rc = 1;
  14. }
  15. dst->rate_tokens = token;
  16. return rc;
  17. }

　　dst->rate_tokens记录上一次的令牌，dst->rate_last记录上一次访问时间，now – dst->rate_last为经过的时间即增加的令牌数；当token>=timeout时即至少还有一个令牌，反回rc=1表示仍有令牌，不用限速；否则返回rc=0，限速。

icmp_push_reply()　发送回复报文
　　取出icmp使用的sock sk

[cpp] view plaincopy
  1. sk = icmp_sk(dev_net((*rt)->u.dst.dev));

　　if中的ip_append_data()函数表示把数据添加到sk->sk_write_queue，这个函数是用于上层向IP层传输报文，它会进行分片的操作，实际是帮IP层做了分片。具体函数调用参见后面的ip_append_data()函数分析。正常情况ip_append_data()返回0,即if的执行语句不会被触发。

[cpp] view plaincopy
  1. if (ip_append_data(sk, icmp_glue_bits, icmp_param,
  2. icmp_param->data_len+icmp_param->head_len,
  3. icmp_param->head_len,
  4. ipc, rt, MSG_DONTWAIT) < 0)
  5. ip_flush_pending_frames(sk);

　　else if进入条件是sk->sk_write_queue中已有数据，显然在if的判断语句中已经将报文添加到了sk->sk_write_queue中，所以会进入else if执行语句调用ip_push_pending_frames()将报文传递给IP层。而在ip_append_data()函数中可以看到，它只是拷贝了报文内容，并没有生成ICMP报头，ICMP报头生成当然也是在通过ip_push_pending_frames()将报文发给IP层前生成的。取出skb，计算所有分片一起的校验和，然过通过csum_partial_copy_nocheck()生成新的icmp报头，最后调用ip_push_pending_frames()发送数据到IP层。函数ip_push_pending_frames()函数分析也参见后文。

[cpp] view plaincopy
  1. else if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
  2. struct icmphdr *icmph = icmp_hdr(skb);
  3. __wsum csum = 0;
  4. struct sk_buff *skb1;
  5. skb_queue_walk(&sk->sk_write_queue, skb1) {
  6. sum = csum_add(csum, skb1->csum);
  7. }
  8. csum = csum_partial_copy_nocheck((void *)&icmp_param->data,
  9. (char *)icmph,
  10. icmp_param->head_len, csum);
  11. icmph->checksum = csum_fold(csum);
  12. skb->ip_summed = CHECKSUM_NONE;
  13. ip_push_pending_frames(sk);
  14. }

ip_append_data()　添加要传递到IP层的数据
传入参数的解释：
　　getfrag() – 复制数据，这里使用函数指针隐藏了复制细节，因为针对icmp, udp的复制是不同的；
　　from – 被复制的数据，在icmp模块中该参数传入的是struct icmp_bxm；
　　length – IP报文内容长度
　　transhdrlen – 传输报头长度，尽管ICMP归为网络层协议，但这里的transhdrlen也是包括它的，所以更好的解释是表示IP上一层的报头，比如ICMP报头，IGMP报头，UDP报头等长度

　　ip_append_data()函数比较复杂，这里以两个例子来解释这个函数：发送50 Byte的echo报文，发送600 Byte的echo报文。56字节echo报文在IP层不需要分片；600字节echo报文在IP层需要分片。ip_append_data()还可以多次调用来收集数据，而在ICMP模块中这点并不能体现出来，在以后UDP或TCP时再以解释多次调用的情况。

example 1：50 Byte echo报文 [假设MTU=520]
　　如果sk_write_queue为空，则证明是第一个分片，50字节的报文只需要一个分片。这里会设置exthdrlen，表示链路层额外的报头长，一般情况下是0，所以此时length和transhdrlen值仍是传入的值。而sk->sk_sndmsg_page和sk->sk_sndmsg_off与发散/聚合IO有关，这里先不考虑。

[cpp] view plaincopy
  1. if (skb_queue_empty(&sk->sk_write_queue)) {
  2. ….
  3. sk->sk_sndmsg_page = NULL;
  4. sk->sk_sndmsg_off = 0;
  5. if ((exthdrlen = rt->u.dst.header_len) != 0) {
  6. length += exthdrlen;
  7. transhdrlen += exthdrlen;
  8. }
  9. …
  10. }

　　设置各种参数的值，hh_len表示以太网报头的长度，16字节对齐；fragheaderlen表示分片报头长度，即IP报头；maxfraglen表示最大分片长度。各参数值：hh_len = 16, fragheaderlen = 20, maxfraglen = 516，注意要求的节字对齐。

[cpp] view plaincopy
  1. hh_len = LL_RESERVED_SPACE(rt->u.dst.dev);
  2. fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
  3. maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;

　　此时sk->sk_write_queue还为空，跳转至alloc_new_skb执行分配新的skb。

[cpp] view plaincopy
  1. if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
  2. goto alloc_new_skb;

　　fraggap在上一个skb没有8字节对齐时设置为多余的字节数，否则的话fraggap=0；datalen表示IP报文长度(不包括IP报头)，fraglen表示以太网帧报文长度(不包括以太网头)，alloclen表示要分配的内容长度，下面代码省略了一些内容。各参数值：　　　　　　　fraggap=0, datalen=50, fraglen=70, alloclen=70。

[cpp] view plaincopy
  1. fraggap = 0;
  2. datalen = length + fraggap;
  3. fraglen = datalen + fragheaderlen;
  4. alloclen = datalen + fragheaderlen;

　　分配报文skb空间，大小为alloclen+hh_len+15，alloclen + hh_len就是报文的长度，15个字节为预留部分。

[cpp] view plaincopy
  1. if (transhdrlen) {
  2. skb = sock_alloc_send_skb(sk,
  3. alloclen + hh_len + 15,
  4. (flags & MSG_DONTWAIT), &err);
  5. }

　　skb_reserve()保留skb头的hh_len大小，skb_put()扩展skb大小到fraglen，然后设置network_header和transport_header指向skb的正确位置，data指向ICMP报头的位置，具体可以看下面的图示：

[cpp] view plaincopy
  1. skb_reserve(skb, hh_len);
  2. ……
  3. data = skb_put(skb, fraglen);
  4. skb_set_network_header(skb, exthdrlen);
  5. skb->transport_header = (skb->network_header + fragheaderlen);
  6. data += fragheaderlen;

　　copy是要拷贝的长度，为传输层报头后的内容大小。getfrag()函数实现数据的拷贝，在icmp模块中，getfrag()指向icmp_glue_bits()函数，它从[from] + offset处拷贝copy个字节到data + transhdrlen处。

[cpp] view plaincopy
  1. copy = datalen - transhdrlen - fraggap;
  2. if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
  3. err = -EFAULT;
  4. kfree_skb(skb);
  5. goto error;
  6. }

　　偏移offset加上已经拷贝的字节数copy，fraggap=0，length减去的就是IP报文内容长度，由于报文才56字节，一个分片足够，所以length=0，然后把新生成的skb放入sk->sk_write_queue中，然后执行下次while循环。各参数值：copy=42, offset=42, length=0, 更新transhdrlen=0。

[cpp] view plaincopy
  1. offset += copy;
  2. length -= datalen - fraggap;
  3. transhdrlen = 0;
  4. ……
  5. __skb_queue_tail(&sk->sk_write_queue, skb);
  6. continue;

　　while循环判断条件是length > 0，因此跳出循环，完成了向IP层发送的数据生成，结果如下，注意，ICMP报头还是没有填写的：

example 2：600 Byte echo 报文[假设MTU=520]
　　同样，开始时sk->sk_write_queue()为空，初始的设置与上述例子完全相同，不同处在于datalen此时比最大分片还要大，因此要设置datalen=maxfraglen-fragheaderlen。

[cpp] view plaincopy
  1. if (datalen > mtu - fragheaderlen)
  2. datalen = maxfraglen - fragheaderlen;

　　在完全第一个分片后，同样会将分片skb放入sk_write_queue队列，并进入下一次while循环。此时各参数的值：datalen=496, fraglen=516, alloclen=516, skb->len=516,

[cpp] view plaincopy
  1. copy=488, offset=488, length=600-496=104, 更新transhdrlen=0。
  2. __skb_queue_tail(&sk->sk_write_queue, skb);
  3. continue;

　　再次进入while循环，此时不同的是length=104，证明还有数据需要拷贝，此时会对待拷贝的数据进行判断，下面所指的填充满是针对maxfraglen而言的。
 　　@copy > 0，表示上个报文未被填充满，这种情况在多次调用ip_append_data()时会发生，这里都是一次调用ip_append_data()的情况，所以不会出现，此时会填充数据到上个skb中
 　　@copy = 0，表示上个报文被填充满，这个例子现在就是这种情况，此时会分配新的skb
 　　@copy < 0，表示上个报文多填充了数据，这时因为maxfraglen是mtu8字节对齐后的值，所以maxfraglen范围是[mtu-7, mtu]，而在某些特殊情况下，比如上个报文已被填满(实际还可能有[1, 7]字节的空间)，待填充字节数n < 8，这时会把这n个节字补在最后一个报文的尾部。
　　对这个例子而言，上个skb刚好被填充满，copy=0，此时分配新的skb。

[cpp] view plaincopy
  1. copy = mtu - skb->len;
  2. if (copy < length)
  3. copy = maxfraglen - skb->len;

　　分配新skb的流程与上个skb的分配过程相同，变化的只是偏移量offset，另外，icmp报头只存在于第一个分片中，因为它也属于IP内容的一部分，在这次拷贝完成后length=0，函数返回，最后结果如下：

ip_push_pending_frames()　将待发送的报文传递给网络层
　　待发送的报文分片都在sk->sk_write_queue上，这里要做的就是从sk_write_queue上取出所有分片，合并成一个报文，添加IP报头信息，使用ip_local_out()传递给网络层处理。
　　要注意的是这里的合并并不是真正的合并，只有第一个分片形成了skb，剩下的分片都放到了skb_shinfo(skb)->frag_list上，虽然最后向下传递的只是一个skb，并实际上分片工作已经完成了，网络层并不需要再次分片，由网络的上层完成分片是出于效率的考虑，虽然与协议标准有所出入。
　　首先从sk_write_queue上取出第一个分片，skb是最终向下传递的报文，tail_skb指向skb的frag_list链表尾，即最后一个分片。

[cpp] view plaincopy
  1. if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL)
  2. goto out;
  3. tail_skb = &(skb_shinfo(skb)->frag_list);

　　将skb->data指向ip报头的位置

[cpp] view plaincopy
  1. if (skb->data < skb_network_header(skb))
  2. __skb_pull(skb, skb_network_offset(skb));

　　tmp_skb表示现在要插入skb的分片，首先通过__skb_pull()除去这些分片的IP报头，因为分片共用skb的IP报头。然后通过tail_skb处理将tmp_skb链入frag_list中；最后增加报文长度计数，以前说明过，skb->len代表linear buffer + paged buffer，skb->data_len代表paged_buffer，这里插入的分片是增加了paged buffer大小，所以对skb->len和skb->data_len都增加分片的长度。

[cpp] view plaincopy
  1. while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) {
  2. __skb_pull(tmp_skb, skb_network_header_len(skb));
  3. *tail_skb = tmp_skb;
  4. tail_skb = &(tmp_skb->next);
  5. skb->len += tmp_skb->len;
  6. skb->data_len += tmp_skb->len;
  7. skb->truesize += tmp_skb->truesize;
  8. tmp_skb->destructor = NULL;
  9. tmp_skb->sk = NULL;
  10. }

　　这里是生成skb的IP报头，设置其中的值

[cpp] view plaincopy
  1. iph = (struct iphdr *)skb->data;
  2. iph->version = 4;
  3. …….
  4. skb->mark = sk->sk_mark;

　　最终通过ip_local_out()传递给IP层

[cpp] view plaincopy
  1. err = ip_local_out(skb);

Linux内核分析 - 网络[十一]：ICMP模块相关推荐

  1. linux内核分析 网络九,“Linux内核分析”实验报告(九)

    一 Linux内核分析博客简介及其索引 本次实验简单的分析了计算机如何进行工作,并通过简单的汇编实例进行解释分析 在本次实验中 通过听老师的视频分析,和自己的学习,初步了解了进程切换的原理.操作系统通 ...

  2. Linux内核分析 - 网络[十二]：UDP模块 - 收发

    内核版本:2.6.34 UDP报文接收        UDP报文的接收可以分为两个部分:协议栈收到udp报文,插入相应队列中:用户调用recvfrom()或recv()系统调用从队列中取出报文,这里的 ...

  3. Linux内核分析 - 网络[十六]：TCP三次握手

    内核:2.6.34       TCP是应用最广泛的传输层协议,其提供了面向连接的.可靠的字节流服务,但也正是因为这些特性,使得TCP较之UDP异常复杂,还是分两部分[创建与使用]来进行分析.这篇主要 ...

  4. Linux内核分析 - 网络[十二]：UDP模块 - socket

    内核版本:2.6.34 这部分内容在于说明socket创建后如何被内核协议栈访问到,只关注两个问题:sock何时插入内核表的,sock如何被内核访问的.对于核心的sock的插入.查找函数都给出了流程图 ...

  5. Linux内核分析 - 网络[八补]：IP协议补充

    内核版本:2.6.34 在前一篇"IP协议"中对报文接收时IP层的处理进行了分析,本篇分析将针对报文发送时IP层的处理.       传输层处理完后,会调用ip_push_pend ...

  6. Linux内核分析 - 网络[十]：ARP杂谈

    内核版本:2.6.34 杂谈一:重复地址检测 Linux协议栈中处理重复地址检测报文的是arp_process()中的一段代码,RFC2131是DHCP的草案,相应的sip==0是DHCP服务器用来检 ...

  7. Linux内核分析 - 网络[九]：邻居表

    内核版本:2.6.34 这部分的重点是三个核心的数据结构-邻居表.邻居缓存.代理邻居表,以及NUD状态转移图. 总的来说,要成功添加一条邻居表项,需要满足两个条件:1. 本机使用该表项:2. 对方主机 ...

  8. linux内核 checksum,Linux内核分析 - 网络[十三]：校验和

    内核版本:2.6.34 报文的IP校验和.ICMP校验和.TCP/UDP校验和使用相同的算法,在RFC1071中定义,网上这方面的资料和例子很多,就不解释算法流程了,而是侧重于在实现的变化和技巧. T ...

  9. Linux内核分析 - 网络[十三]：校验和

    内核版本:2.6.34 报文的IP校验和.ICMP校验和.TCP/UDP校验和使用相同的算法,在RFC1071中定义,网上这方面的资料和例子很多,就不解释算法流程了,而是侧重于在实现的变化和技巧. T ...

最新文章

  1. 2018年英语计算机职称考试,2018年职称计算机考试报考指南大全
  2. 全新开源，《Pytorch常用函数函数手册》开放下载！内含200余个函数!
  3. 千万级规模高性能、高并发的网络架构经验分享--转
  4. C++常用的系统函数
  5. 第15章 使用DOM的脚本语言
  6. 比较有意思的老家见闻一二三
  7. 为什么显卡更新换代极快，每年都会有更强的新系列，而声卡却永远停留在了“兼容DX9的集成声卡“？
  8. nginx linux详细安装部署教程,Nginx Linux详细安装及部署实战
  9. OpenResty Redis 安装部署测试SET GET功能
  10. Uploading SSH public key ... failed!
  11. BZOJ3711 : [PA2014]Druzyny
  12. scala中“=”的4种使用场景
  13. ThinPHP_5的请求和响应
  14. 离散数学 习题篇 —— 集合相等与子集关系判断
  15. 钉钉第三方服务商应用ISV应用开发及上架教程
  16. centos 7下搭建wiki系统
  17. 充分的准备是成功的关键因素
  18. Windows自带的“QQ”
  19. 手把手教你免费、批量转换HEIC图片到JPG
  20. spring-boot-devtools 快速重启的秘密！

热门文章

  1. anaconda查看conda主环境、虚拟环境的python执行路径
  2. Mac Vmware Fusion在虚拟机中共享文件夹
  3. python代码显示进度条 tqdm
  4. Mac 上无法使用netstat的-p参数
  5. 平衡二叉树（AVL）python实现
  6. java数据结构基础名词解释
  7. linux配置sftp-server,Ubuntu Server如何配置SFTP（建立用户监狱）
  8. oracle增加文件组,Oracle 文件和文件组
  9. C#中使用FFMPEG切割、合并视频。
  10. cocos2dx Action动作解析(1)