L4协议和raw ip处理

红太狼 2022-01-14 15:23 248阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

*L4协议的注册：*

位于IPv4之上的L4协议是由net\_protocol数据结构定义的

1:  struct net_protocol {

2:      int            (*handler)(struct sk_buff *skb);

3:      void            (*err_handler)(struct sk_buff *skb, u32 info);

4:      int            (*gso_send_check)(struct sk_buff *skb);

5:      struct sk_buff           *(*gso_segment)(struct sk_buff *skb,

6:                             int features);

7:      struct sk_buff          **(*gro_receive)(struct sk_buff **head,

8:                             struct sk_buff *skb);

9:      int            (*gro_complete)(struct sk_buff *skb);

10:      unsigned int        no_policy:1,

11:                  netns_ok:1;

12:  };

handler，由此协议注册的函数，来作为送进来的封包的处理函数。

err\_handler，由icmp协议处理函数所用的函数，用于通知l4协议有关接收到icmp unreachable消息的时间。

no\_policy，此字段在网络协议中的某些关键点都会被查询，用于使协议免于ipsec策略检查：1是指没有必要针对此协议检查ipsec策略。

1:  /*

2:   *    Add a protocol handler to the hash tables

3:   */

5:  int inet_add_protocol(const struct net_protocol *prot, unsigned char protocol)

6:  {

7:      int hash, ret;

9:      hash = protocol & (MAX_INET_PROTOS - 1);

10:

11:      spin_lock_bh(&inet_proto_lock);

12:      if (inet_protos[hash]) {

13:          ret = -1;

14:      } else {

15:          inet_protos[hash] = prot;

16:          ret = 0;

17:      }

18:      spin_unlock_bh(&inet_proto_lock);

19:

20:      return ret;

21:  }

22:

23:  /*

24:   *    Remove a protocol from the hash tables.

25:   */

26:

27:  int inet_del_protocol(const struct net_protocol *prot, unsigned char protocol)

28:  {

29:      int hash, ret;

30:

31:      hash = protocol & (MAX_INET_PROTOS - 1);

32:

33:      spin_lock_bh(&inet_proto_lock);

34:      if (inet_protos[hash] == prot) {

35:          inet_protos[hash] = NULL;

36:          ret = 0;

37:      } else {

38:          ret = -1;

39:      }

40:      spin_unlock_bh(&inet_proto_lock);

41:

42:      synchronize_net();

43:

44:      return ret;

45:  }

**L3到L4的传递：ip\_local\_deliver\_finish**

1:  static int ip_local_deliver_finish(struct sk_buff *skb)

2:  {

3:      struct net *net = dev_net(skb->dev);

5:      __skb_pull(skb, ip_hdrlen(skb));

7:      /* Point into the IP datagram, just past the header. */

8:      skb_reset_transport_header(skb);

10:      rcu_read_lock();

11:      {

12:          int protocol = ip_hdr(skb)->protocol;

13:          int hash, raw;

14:          const struct net_protocol *ipprot;

15:

16:      resubmit:

17:          raw = raw_local_deliver(skb, protocol);

18:

19:          hash = protocol & (MAX_INET_PROTOS - 1);

20:          ipprot = rcu_dereference(inet_protos[hash]);

21:          if (ipprot != NULL) {

22:              int ret;

23:

24:              if (!net_eq(net, &init_net) && !ipprot->netns_ok) {

25:                  if (net_ratelimit())

26:                      printk("%s: proto %d isn't netns-ready\n",

27:                          __func__, protocol);

28:                  kfree_skb(skb);

29:                  goto out;

30:              }

31:

32:              if (!ipprot->no_policy) {

33:                  if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {

34:                      kfree_skb(skb);

35:                      goto out;

36:                  }

37:                  nf_reset(skb);

38:              }

39:              ret = ipprot->handler(skb);

40:              if (ret < 0) {

41:                  protocol = -ret;

42:                  goto resubmit;

43:              }

44:              IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);

45:          } else {

46:              if (!raw) {

47:                  if (xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {

48:                      IP_INC_STATS_BH(net, IPSTATS_MIB_INUNKNOWNPROTOS);

49:                      icmp_send(skb, ICMP_DEST_UNREACH,

50:                            ICMP_PROT_UNREACH, 0);

51:                  }

52:              } else

53:                  IP_INC_STATS_BH(net, IPSTATS_MIB_INDELIVERS);

54:              kfree_skb(skb);

55:          }

56:      }

57:   out:

58:      rcu_read_unlock();

59:

60:      return 0;

61:  }

转载于:https://my.oschina.net/longscu/blog/60642

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220114/262f4305cf6a45328755ded38d101ef0.png

L4协议和raw ip处理

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 TCP/IP__TCP协议IP协议&IP地址

相关网络层重点协议之IP协议（IPv4）

相关 IP地址和IP协议

相关 Linux Kernel TCP/IP Stack — L4 Layer

相关 IP协议、IP协议头部、IP地址、DNS

相关深入理解Linux网络技术内幕——L4层协议与Raw IP的处理

相关 tcp ip协议笔记（4）——arp

相关网络协议： TCP/IP 和UDP/IP

相关 TCP/IP_IP协议辅助协议

相关 L4协议和raw ip处理