开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ip_nat_rule.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：8k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ip_nat_rule.c：源码内容
  1. /* Everything about the rules for NAT. */
  2. #define __NO_VERSION__
  3. #include <linux/types.h>
  4. #include <linux/ip.h>
  5. #include <linux/netfilter.h>
  6. #include <linux/netfilter_ipv4.h>
  7. #include <linux/module.h>
  8. #include <linux/kmod.h>
  9. #include <linux/skbuff.h>
  10. #include <linux/proc_fs.h>
  11. #include <net/checksum.h>
  12. #include <linux/bitops.h>
  13. #include <linux/version.h>
  15. #define ASSERT_READ_LOCK(x) MUST_BE_READ_LOCKED(&ip_nat_lock)
  16. #define ASSERT_WRITE_LOCK(x) MUST_BE_WRITE_LOCKED(&ip_nat_lock)
  18. #include <linux/netfilter_ipv4/ip_tables.h>
  19. #include <linux/netfilter_ipv4/ip_nat.h>
  20. #include <linux/netfilter_ipv4/ip_nat_core.h>
  21. #include <linux/netfilter_ipv4/ip_nat_rule.h>
  22. #include <linux/netfilter_ipv4/listhelp.h>
  24. #if 0
  25. #define DEBUGP printk
  26. #else
  27. #define DEBUGP(format, args...)
  28. #endif
  30. #define NAT_VALID_HOOKS ((1<<NF_IP_PRE_ROUTING) | (1<<NF_IP_POST_ROUTING) | (1<<NF_IP_LOCAL_OUT))
  32. /* Standard entry. */
  33. struct ipt_standard
  34. {
  35. struct ipt_entry entry;
  36. struct ipt_standard_target target;
  37. };
  39. struct ipt_error_target
  40. {
  41. struct ipt_entry_target target;
  42. char errorname[IPT_FUNCTION_MAXNAMELEN];
  43. };
  45. struct ipt_error
  46. {
  47. struct ipt_entry entry;
  48. struct ipt_error_target target;
  49. };
  51. static struct
  52. {
  53. struct ipt_replace repl;
  54. struct ipt_standard entries[3];
  55. struct ipt_error term;
  56. } nat_initial_table __initdata
  57. = { { "nat", NAT_VALID_HOOKS, 4,
  58.       sizeof(struct ipt_standard) * 3 + sizeof(struct ipt_error),
  59.       { [NF_IP_PRE_ROUTING] 0,
  60. [NF_IP_POST_ROUTING] sizeof(struct ipt_standard),
  61. [NF_IP_LOCAL_OUT] sizeof(struct ipt_standard) * 2 },
  62.       { [NF_IP_PRE_ROUTING] 0,
  63. [NF_IP_POST_ROUTING] sizeof(struct ipt_standard),
  64. [NF_IP_LOCAL_OUT] sizeof(struct ipt_standard) * 2 },
  65.       0, NULL, { } },
  66.     {
  67.     /* PRE_ROUTING */
  68.     { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },
  69. 0,
  70. sizeof(struct ipt_entry),
  71. sizeof(struct ipt_standard),
  72. 0, { 0, 0 }, { } },
  73.       { { { { IPT_ALIGN(sizeof(struct ipt_standard_target)), "" } }, { } },
  74. -NF_ACCEPT - 1 } },
  75.     /* POST_ROUTING */
  76.     { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },
  77. 0,
  78. sizeof(struct ipt_entry),
  79. sizeof(struct ipt_standard),
  80. 0, { 0, 0 }, { } },
  81.       { { { { IPT_ALIGN(sizeof(struct ipt_standard_target)), "" } }, { } },
  82. -NF_ACCEPT - 1 } },
  83.     /* LOCAL_OUT */
  84.     { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },
  85. 0,
  86. sizeof(struct ipt_entry),
  87. sizeof(struct ipt_standard),
  88. 0, { 0, 0 }, { } },
  89.       { { { { IPT_ALIGN(sizeof(struct ipt_standard_target)), "" } }, { } },
  90. -NF_ACCEPT - 1 } }
  91.     },
  92.     /* ERROR */
  93.     { { { { 0 }, { 0 }, { 0 }, { 0 }, "", "", { 0 }, { 0 }, 0, 0, 0 },
  94. 0,
  95. sizeof(struct ipt_entry),
  96. sizeof(struct ipt_error),
  97. 0, { 0, 0 }, { } },
  98.       { { { { IPT_ALIGN(sizeof(struct ipt_error_target)), IPT_ERROR_TARGET } },
  99.   { } },
  100. "ERROR"
  101.       }
  102.     }
  103. };
  105. static struct ipt_table nat_table
  106. = { { NULL, NULL }, "nat", &nat_initial_table.repl,
  107.     NAT_VALID_HOOKS, RW_LOCK_UNLOCKED, NULL, THIS_MODULE };
  109. /* Source NAT */
  110. static unsigned int ipt_snat_target(struct sk_buff **pskb,
  111.     unsigned int hooknum,
  112.     const struct net_device *in,
  113.     const struct net_device *out,
  114.     const void *targinfo,
  115.     void *userinfo)
  116. {
  117. struct ip_conntrack *ct;
  118. enum ip_conntrack_info ctinfo;
  120. IP_NF_ASSERT(hooknum == NF_IP_POST_ROUTING);
  122. ct = ip_conntrack_get(*pskb, &ctinfo);
  124. /* Connection must be valid and new. */
  125. IP_NF_ASSERT(ct && (ctinfo == IP_CT_NEW || ctinfo == IP_CT_RELATED));
  126. IP_NF_ASSERT(out);
  128. return ip_nat_setup_info(ct, targinfo, hooknum);
  129. }
  131. static unsigned int ipt_dnat_target(struct sk_buff **pskb,
  132.     unsigned int hooknum,
  133.     const struct net_device *in,
  134.     const struct net_device *out,
  135.     const void *targinfo,
  136.     void *userinfo)
  137. {
  138. struct ip_conntrack *ct;
  139. enum ip_conntrack_info ctinfo;
  141. #ifdef CONFIG_IP_NF_NAT_LOCAL
  142. IP_NF_ASSERT(hooknum == NF_IP_PRE_ROUTING
  143.      || hooknum == NF_IP_LOCAL_OUT);
  144. #else
  145. IP_NF_ASSERT(hooknum == NF_IP_PRE_ROUTING);
  146. #endif
  148. ct = ip_conntrack_get(*pskb, &ctinfo);
  150. /* Connection must be valid and new. */
  151. IP_NF_ASSERT(ct && (ctinfo == IP_CT_NEW || ctinfo == IP_CT_RELATED));
  153. return ip_nat_setup_info(ct, targinfo, hooknum);
  154. }
  156. static int ipt_snat_checkentry(const char *tablename,
  157.        const struct ipt_entry *e,
  158.        void *targinfo,
  159.        unsigned int targinfosize,
  160.        unsigned int hook_mask)
  161. {
  162. struct ip_nat_multi_range *mr = targinfo;
  164. /* Must be a valid range */
  165. if (targinfosize < sizeof(struct ip_nat_multi_range)) {
  166. DEBUGP("SNAT: Target size %u too smalln", targinfosize);
  167. return 0;
  168. }
  170. if (targinfosize != IPT_ALIGN((sizeof(struct ip_nat_multi_range)
  171.        + (sizeof(struct ip_nat_range)
  172.   * (mr->rangesize - 1))))) {
  173. DEBUGP("SNAT: Target size %u wrong for %u rangesn",
  174.        targinfosize, mr->rangesize);
  175. return 0;
  176. }
  178. /* Only allow these for NAT. */
  179. if (strcmp(tablename, "nat") != 0) {
  180. DEBUGP("SNAT: wrong table %sn", tablename);
  181. return 0;
  182. }
  184. if (hook_mask & ~(1 << NF_IP_POST_ROUTING)) {
  185. DEBUGP("SNAT: hook mask 0x%x badn", hook_mask);
  186. return 0;
  187. }
  188. return 1;
  189. }
  191. static int ipt_dnat_checkentry(const char *tablename,
  192.        const struct ipt_entry *e,
  193.        void *targinfo,
  194.        unsigned int targinfosize,
  195.        unsigned int hook_mask)
  196. {
  197. struct ip_nat_multi_range *mr = targinfo;
  199. /* Must be a valid range */
  200. if (targinfosize < sizeof(struct ip_nat_multi_range)) {
  201. DEBUGP("DNAT: Target size %u too smalln", targinfosize);
  202. return 0;
  203. }
  205. if (targinfosize != IPT_ALIGN((sizeof(struct ip_nat_multi_range)
  206.        + (sizeof(struct ip_nat_range)
  207.   * (mr->rangesize - 1))))) {
  208. DEBUGP("DNAT: Target size %u wrong for %u rangesn",
  209.        targinfosize, mr->rangesize);
  210. return 0;
  211. }
  213. /* Only allow these for NAT. */
  214. if (strcmp(tablename, "nat") != 0) {
  215. DEBUGP("DNAT: wrong table %sn", tablename);
  216. return 0;
  217. }
  219. if (hook_mask & ~((1 << NF_IP_PRE_ROUTING) | (1 << NF_IP_LOCAL_OUT))) {
  220. DEBUGP("DNAT: hook mask 0x%x badn", hook_mask);
  221. return 0;
  222. }
  224. #ifndef CONFIG_IP_NF_NAT_LOCAL
  225. if (hook_mask & (1 << NF_IP_LOCAL_OUT)) {
  226. DEBUGP("DNAT: CONFIG_IP_NF_NAT_LOCAL not enabledn");
  227. return 0;
  228. }
  229. #endif
  231. return 1;
  232. }
  234. static inline unsigned int
  235. alloc_null_binding(struct ip_conntrack *conntrack,
  236.    struct ip_nat_info *info,
  237.    unsigned int hooknum)
  238. {
  239. /* Force range to this IP; let proto decide mapping for
  240.    per-proto parts (hence not IP_NAT_RANGE_PROTO_SPECIFIED).
  241.    Use reply in case it's already been mangled (eg local packet).
  242. */
  243. u_int32_t ip
  244. = (HOOK2MANIP(hooknum) == IP_NAT_MANIP_SRC
  245.    ? conntrack->tuplehash[IP_CT_DIR_REPLY].tuple.dst.ip
  246.    : conntrack->tuplehash[IP_CT_DIR_REPLY].tuple.src.ip);
  247. struct ip_nat_multi_range mr
  248. = { 1, { { IP_NAT_RANGE_MAP_IPS, ip, ip, { 0 }, { 0 } } } };
  250. DEBUGP("Allocating NULL binding for %p (%u.%u.%u.%u)n", conntrack,
  251.        NIPQUAD(ip));
  252. return ip_nat_setup_info(conntrack, &mr, hooknum);
  253. }
  255. int ip_nat_rule_find(struct sk_buff **pskb,
  256.      unsigned int hooknum,
  257.      const struct net_device *in,
  258.      const struct net_device *out,
  259.      struct ip_conntrack *ct,
  260.      struct ip_nat_info *info)
  261. {
  262. int ret;
  264. ret = ipt_do_table(pskb, hooknum, in, out, &nat_table, NULL);
  266. if (ret == NF_ACCEPT) {
  267. if (!(info->initialized & (1 << HOOK2MANIP(hooknum))))
  268. /* NUL mapping */
  269. ret = alloc_null_binding(ct, info, hooknum);
  270. }
  271. return ret;
  272. }
  274. static struct ipt_target ipt_snat_reg
  275. = { { NULL, NULL }, "SNAT", ipt_snat_target, ipt_snat_checkentry, NULL };
  276. static struct ipt_target ipt_dnat_reg
  277. = { { NULL, NULL }, "DNAT", ipt_dnat_target, ipt_dnat_checkentry, NULL };
  279. int __init ip_nat_rule_init(void)
  280. {
  281. int ret;
  283. ret = ipt_register_table(&nat_table);
  284. if (ret != 0)
  285. return ret;
  286. ret = ipt_register_target(&ipt_snat_reg);
  287. if (ret != 0)
  288. goto unregister_table;
  290. ret = ipt_register_target(&ipt_dnat_reg);
  291. if (ret != 0)
  292. goto unregister_snat;
  294. return ret;
  296.  unregister_snat:
  297. ipt_unregister_target(&ipt_snat_reg);
  298.  unregister_table:
  299. ipt_unregister_table(&nat_table);
  301. return ret;
  302. }
  304. void ip_nat_rule_cleanup(void)
  305. {
  306. ipt_unregister_target(&ipt_dnat_reg);
  307. ipt_unregister_target(&ipt_snat_reg);
  308. ipt_unregister_table(&nat_table);
  309. }