/net/ipv4/xfrm4_tunnel.c

http://github.com/mirrors/linux · C · 117 lines · 94 code · 18 blank · 5 comment · 8 complexity · 3d3046b4a133aa8a04d6379a32dc1a08 MD5 · raw file 

    

  1. // SPDX-License-Identifier: GPL-2.0-only
    2. 

  2. /* xfrm4_tunnel.c: Generic IP tunnel transformer.
    3. 

  3.  *
    4. 

  4.  * Copyright (C) 2003 David S. Miller (davem@redhat.com)
    5. 

  5.  */
    6. 

  6. 

  7. #define pr_fmt(fmt) "IPsec: " fmt
    8. 

  8. 

  9. #include <linux/skbuff.h>
    10. 

  10. #include <linux/module.h>
    11. 

  11. #include <linux/mutex.h>
    12. 

  12. #include <net/xfrm.h>
    13. 

  13. #include <net/ip.h>
    14. 

  14. #include <net/protocol.h>
    15. 

  15. 

  16. static int ipip_output(struct xfrm_state *x, struct sk_buff *skb)
    17. 

  17. {
    18. 

  18. 	skb_push(skb, -skb_network_offset(skb));
    19. 

  19. 	return 0;
    20. 

  20. }
    21. 

  21. 

  22. static int ipip_xfrm_rcv(struct xfrm_state *x, struct sk_buff *skb)
    23. 

  23. {
    24. 

  24. 	return ip_hdr(skb)->protocol;
    25. 

  25. }
    26. 

  26. 

  27. static int ipip_init_state(struct xfrm_state *x)
    28. 

  28. {
    29. 

  29. 	if (x->props.mode != XFRM_MODE_TUNNEL)
    30. 

  30. 		return -EINVAL;
    31. 

  31. 

  32. 	if (x->encap)
    33. 

  33. 		return -EINVAL;
    34. 

  34. 

  35. 	x->props.header_len = sizeof(struct iphdr);
    36. 

  36. 

  37. 	return 0;
    38. 

  38. }
    39. 

  39. 

  40. static void ipip_destroy(struct xfrm_state *x)
    41. 

  41. {
    42. 

  42. }
    43. 

  43. 

  44. static const struct xfrm_type ipip_type = {
    45. 

  45. 	.description	= "IPIP",
    46. 

  46. 	.owner		= THIS_MODULE,
    47. 

  47. 	.proto	     	= IPPROTO_IPIP,
    48. 

  48. 	.init_state	= ipip_init_state,
    49. 

  49. 	.destructor	= ipip_destroy,
    50. 

  50. 	.input		= ipip_xfrm_rcv,
    51. 

  51. 	.output		= ipip_output
    52. 

  52. };
    53. 

  53. 

  54. static int xfrm_tunnel_rcv(struct sk_buff *skb)
    55. 

  55. {
    56. 

  56. 	return xfrm4_rcv_spi(skb, IPPROTO_IPIP, ip_hdr(skb)->saddr);
    57. 

  57. }
    58. 

  58. 

  59. static int xfrm_tunnel_err(struct sk_buff *skb, u32 info)
    60. 

  60. {
    61. 

  61. 	return -ENOENT;
    62. 

  62. }
    63. 

  63. 

  64. static struct xfrm_tunnel xfrm_tunnel_handler __read_mostly = {
    65. 

  65. 	.handler	=	xfrm_tunnel_rcv,
    66. 

  66. 	.err_handler	=	xfrm_tunnel_err,
    67. 

  67. 	.priority	=	3,
    68. 

  68. };
    69. 

  69. 

  70. #if IS_ENABLED(CONFIG_IPV6)
    71. 

  71. static struct xfrm_tunnel xfrm64_tunnel_handler __read_mostly = {
    72. 

  72. 	.handler	=	xfrm_tunnel_rcv,
    73. 

  73. 	.err_handler	=	xfrm_tunnel_err,
    74. 

  74. 	.priority	=	2,
    75. 

  75. };
    76. 

  76. #endif
    77. 

  77. 

  78. static int __init ipip_init(void)
    79. 

  79. {
    80. 

  80. 	if (xfrm_register_type(&ipip_type, AF_INET) < 0) {
    81. 

  81. 		pr_info("%s: can't add xfrm type\n", __func__);
    82. 

  82. 		return -EAGAIN;
    83. 

  83. 	}
    84. 

  84. 

  85. 	if (xfrm4_tunnel_register(&xfrm_tunnel_handler, AF_INET)) {
    86. 

  86. 		pr_info("%s: can't add xfrm handler for AF_INET\n", __func__);
    87. 

  87. 		xfrm_unregister_type(&ipip_type, AF_INET);
    88. 

  88. 		return -EAGAIN;
    89. 

  89. 	}
    90. 

  90. #if IS_ENABLED(CONFIG_IPV6)
    91. 

  91. 	if (xfrm4_tunnel_register(&xfrm64_tunnel_handler, AF_INET6)) {
    92. 

  92. 		pr_info("%s: can't add xfrm handler for AF_INET6\n", __func__);
    93. 

  93. 		xfrm4_tunnel_deregister(&xfrm_tunnel_handler, AF_INET);
    94. 

  94. 		xfrm_unregister_type(&ipip_type, AF_INET);
    95. 

  95. 		return -EAGAIN;
    96. 

  96. 	}
    97. 

  97. #endif
    98. 

  98. 	return 0;
    99. 

  99. }
    100. 

  100. 

  101. static void __exit ipip_fini(void)
    102. 

  102. {
    103. 

  103. #if IS_ENABLED(CONFIG_IPV6)
    104. 

  104. 	if (xfrm4_tunnel_deregister(&xfrm64_tunnel_handler, AF_INET6))
    105. 

  105. 		pr_info("%s: can't remove xfrm handler for AF_INET6\n",
    106. 

  106. 			__func__);
    107. 

  107. #endif
    108. 

  108. 	if (xfrm4_tunnel_deregister(&xfrm_tunnel_handler, AF_INET))
    109. 

  109. 		pr_info("%s: can't remove xfrm handler for AF_INET\n",
    110. 

  110. 			__func__);
    111. 

  111. 	xfrm_unregister_type(&ipip_type, AF_INET);
    112. 

  112. }
    113. 

  113. 

  114. module_init(ipip_init);
    115. 

  115. module_exit(ipip_fini);
    116. 

  116. MODULE_LICENSE("GPL");
    117. 

  117. MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_IPIP);
    118.