/net/ipv4/xfrm4_tunnel.c

https://bitbucket.org/abioy/linux · C · 113 lines · 92 code · 17 blank · 4 comment · 12 complexity · 64981354817d30f08a5046241c3fc132 MD5 · raw file 

    

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

  2.  *
    3. 

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

  4.  */
    5. 

  5. 

  6. #include <linux/skbuff.h>
    7. 

  7. #include <linux/module.h>
    8. 

  8. #include <linux/mutex.h>
    9. 

  9. #include <net/xfrm.h>
    10. 

  10. #include <net/ip.h>
    11. 

  11. #include <net/protocol.h>
    12. 

  12. 

  13. static int ipip_output(struct xfrm_state *x, struct sk_buff *skb)
    14. 

  14. {
    15. 

  15. 	skb_push(skb, -skb_network_offset(skb));
    16. 

  16. 	return 0;
    17. 

  17. }
    18. 

  18. 

  19. static int ipip_xfrm_rcv(struct xfrm_state *x, struct sk_buff *skb)
    20. 

  20. {
    21. 

  21. 	return ip_hdr(skb)->protocol;
    22. 

  22. }
    23. 

  23. 

  24. static int ipip_init_state(struct xfrm_state *x)
    25. 

  25. {
    26. 

  26. 	if (x->props.mode != XFRM_MODE_TUNNEL)
    27. 

  27. 		return -EINVAL;
    28. 

  28. 

  29. 	if (x->encap)
    30. 

  30. 		return -EINVAL;
    31. 

  31. 

  32. 	x->props.header_len = sizeof(struct iphdr);
    33. 

  33. 

  34. 	return 0;
    35. 

  35. }
    36. 

  36. 

  37. static void ipip_destroy(struct xfrm_state *x)
    38. 

  38. {
    39. 

  39. }
    40. 

  40. 

  41. static const struct xfrm_type ipip_type = {
    42. 

  42. 	.description	= "IPIP",
    43. 

  43. 	.owner		= THIS_MODULE,
    44. 

  44. 	.proto	     	= IPPROTO_IPIP,
    45. 

  45. 	.init_state	= ipip_init_state,
    46. 

  46. 	.destructor	= ipip_destroy,
    47. 

  47. 	.input		= ipip_xfrm_rcv,
    48. 

  48. 	.output		= ipip_output
    49. 

  49. };
    50. 

  50. 

  51. static int xfrm_tunnel_rcv(struct sk_buff *skb)
    52. 

  52. {
    53. 

  53. 	return xfrm4_rcv_spi(skb, IPPROTO_IPIP, ip_hdr(skb)->saddr);
    54. 

  54. }
    55. 

  55. 

  56. static int xfrm_tunnel_err(struct sk_buff *skb, u32 info)
    57. 

  57. {
    58. 

  58. 	return -ENOENT;
    59. 

  59. }
    60. 

  60. 

  61. static struct xfrm_tunnel xfrm_tunnel_handler = {
    62. 

  62. 	.handler	=	xfrm_tunnel_rcv,
    63. 

  63. 	.err_handler	=	xfrm_tunnel_err,
    64. 

  64. 	.priority	=	2,
    65. 

  65. };
    66. 

  66. 

  67. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
    68. 

  68. static struct xfrm_tunnel xfrm64_tunnel_handler = {
    69. 

  69. 	.handler	=	xfrm_tunnel_rcv,
    70. 

  70. 	.err_handler	=	xfrm_tunnel_err,
    71. 

  71. 	.priority	=	2,
    72. 

  72. };
    73. 

  73. #endif
    74. 

  74. 

  75. static int __init ipip_init(void)
    76. 

  76. {
    77. 

  77. 	if (xfrm_register_type(&ipip_type, AF_INET) < 0) {
    78. 

  78. 		printk(KERN_INFO "ipip init: can't add xfrm type\n");
    79. 

  79. 		return -EAGAIN;
    80. 

  80. 	}
    81. 

  81. 

  82. 	if (xfrm4_tunnel_register(&xfrm_tunnel_handler, AF_INET)) {
    83. 

  83. 		printk(KERN_INFO "ipip init: can't add xfrm handler for AF_INET\n");
    84. 

  84. 		xfrm_unregister_type(&ipip_type, AF_INET);
    85. 

  85. 		return -EAGAIN;
    86. 

  86. 	}
    87. 

  87. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
    88. 

  88. 	if (xfrm4_tunnel_register(&xfrm64_tunnel_handler, AF_INET6)) {
    89. 

  89. 		printk(KERN_INFO "ipip init: can't add xfrm handler for AF_INET6\n");
    90. 

  90. 		xfrm4_tunnel_deregister(&xfrm_tunnel_handler, AF_INET);
    91. 

  91. 		xfrm_unregister_type(&ipip_type, AF_INET);
    92. 

  92. 		return -EAGAIN;
    93. 

  93. 	}
    94. 

  94. #endif
    95. 

  95. 	return 0;
    96. 

  96. }
    97. 

  97. 

  98. static void __exit ipip_fini(void)
    99. 

  99. {
    100. 

  100. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
    101. 

  101. 	if (xfrm4_tunnel_deregister(&xfrm64_tunnel_handler, AF_INET6))
    102. 

  102. 		printk(KERN_INFO "ipip close: can't remove xfrm handler for AF_INET6\n");
    103. 

  103. #endif
    104. 

  104. 	if (xfrm4_tunnel_deregister(&xfrm_tunnel_handler, AF_INET))
    105. 

  105. 		printk(KERN_INFO "ipip close: can't remove xfrm handler for AF_INET\n");
    106. 

  106. 	if (xfrm_unregister_type(&ipip_type, AF_INET) < 0)
    107. 

  107. 		printk(KERN_INFO "ipip close: can't remove xfrm type\n");
    108. 

  108. }
    109. 

  109. 

  110. module_init(ipip_init);
    111. 

  111. module_exit(ipip_fini);
    112. 

  112. MODULE_LICENSE("GPL");
    113. 

  113. MODULE_ALIAS_XFRM_TYPE(AF_INET, XFRM_PROTO_IPIP);
    114.