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

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

Linux/Unix编程

开发平台：

Unix_Linux

ip_nat_core.c：源码内容
  1. /* NAT for netfilter; shared with compatibility layer. */
  3. /* (c) 1999 Paul `Rusty' Russell.  Licenced under the GNU General
  4.    Public Licence. */
  5. #ifdef MODULE
  6. #define __NO_VERSION__
  7. #endif
  8. #include <linux/version.h>
  9. #include <linux/module.h>
  10. #include <linux/types.h>
  11. #include <linux/timer.h>
  12. #include <linux/skbuff.h>
  13. #include <linux/netfilter_ipv4.h>
  14. #include <linux/brlock.h>
  15. #include <linux/vmalloc.h>
  16. #include <net/checksum.h>
  17. #include <net/icmp.h>
  18. #include <net/ip.h>
  19. #include <net/tcp.h>  /* For tcp_prot in getorigdst */
  21. #define ASSERT_READ_LOCK(x) MUST_BE_READ_LOCKED(&ip_nat_lock)
  22. #define ASSERT_WRITE_LOCK(x) MUST_BE_WRITE_LOCKED(&ip_nat_lock)
  24. #include <linux/netfilter_ipv4/ip_conntrack.h>
  25. #include <linux/netfilter_ipv4/ip_conntrack_core.h>
  26. #include <linux/netfilter_ipv4/ip_conntrack_protocol.h>
  27. #include <linux/netfilter_ipv4/ip_nat.h>
  28. #include <linux/netfilter_ipv4/ip_nat_protocol.h>
  29. #include <linux/netfilter_ipv4/ip_nat_core.h>
  30. #include <linux/netfilter_ipv4/ip_nat_helper.h>
  31. #include <linux/netfilter_ipv4/ip_conntrack_helper.h>
  32. #include <linux/netfilter_ipv4/listhelp.h>
  34. #if 0
  35. #define DEBUGP printk
  36. #else
  37. #define DEBUGP(format, args...)
  38. #endif
  40. DECLARE_RWLOCK(ip_nat_lock);
  41. DECLARE_RWLOCK_EXTERN(ip_conntrack_lock);
  43. /* Calculated at init based on memory size */
  44. static unsigned int ip_nat_htable_size;
  46. static struct list_head *bysource;
  47. static struct list_head *byipsproto;
  48. LIST_HEAD(protos);
  49. LIST_HEAD(helpers);
  51. extern struct ip_nat_protocol unknown_nat_protocol;
  53. /* We keep extra hashes for each conntrack, for fast searching. */
  54. static inline size_t
  55. hash_by_ipsproto(u_int32_t src, u_int32_t dst, u_int16_t proto)
  56. {
  57. /* Modified src and dst, to ensure we don't create two
  58.            identical streams. */
  59. return (src + dst + proto) % ip_nat_htable_size;
  60. }
  62. static inline size_t
  63. hash_by_src(const struct ip_conntrack_manip *manip, u_int16_t proto)
  64. {
  65. /* Original src, to ensure we map it consistently if poss. */
  66. return (manip->ip + manip->u.all + proto) % ip_nat_htable_size;
  67. }
  69. /* Noone using conntrack by the time this called. */
  70. static void ip_nat_cleanup_conntrack(struct ip_conntrack *conn)
  71. {
  72. struct ip_nat_info *info = &conn->nat.info;
  74. if (!info->initialized)
  75. return;
  77. IP_NF_ASSERT(info->bysource.conntrack);
  78. IP_NF_ASSERT(info->byipsproto.conntrack);
  80. WRITE_LOCK(&ip_nat_lock);
  81. LIST_DELETE(&bysource[hash_by_src(&conn->tuplehash[IP_CT_DIR_ORIGINAL]
  82.   .tuple.src,
  83.   conn->tuplehash[IP_CT_DIR_ORIGINAL]
  84.   .tuple.dst.protonum)],
  85.     &info->bysource);
  87. LIST_DELETE(&byipsproto
  88.     [hash_by_ipsproto(conn->tuplehash[IP_CT_DIR_REPLY]
  89.       .tuple.src.ip,
  90.       conn->tuplehash[IP_CT_DIR_REPLY]
  91.       .tuple.dst.ip,
  92.       conn->tuplehash[IP_CT_DIR_REPLY]
  93.       .tuple.dst.protonum)],
  94.     &info->byipsproto);
  95. WRITE_UNLOCK(&ip_nat_lock);
  96. }
  98. /* We do checksum mangling, so if they were wrong before they're still
  99.  * wrong.  Also works for incomplete packets (eg. ICMP dest
  100.  * unreachables.) */
  101. u_int16_t
  102. ip_nat_cheat_check(u_int32_t oldvalinv, u_int32_t newval, u_int16_t oldcheck)
  103. {
  104. u_int32_t diffs[] = { oldvalinv, newval };
  105. return csum_fold(csum_partial((char *)diffs, sizeof(diffs),
  106.       oldcheck^0xFFFF));
  107. }
  109. static inline int cmp_proto(const struct ip_nat_protocol *i, int proto)
  110. {
  111. return i->protonum == proto;
  112. }
  114. struct ip_nat_protocol *
  115. find_nat_proto(u_int16_t protonum)
  116. {
  117. struct ip_nat_protocol *i;
  119. MUST_BE_READ_LOCKED(&ip_nat_lock);
  120. i = LIST_FIND(&protos, cmp_proto, struct ip_nat_protocol *, protonum);
  121. if (!i)
  122. i = &unknown_nat_protocol;
  123. return i;
  124. }
  126. /* Is this tuple already taken? (not by us) */
  127. int
  128. ip_nat_used_tuple(const struct ip_conntrack_tuple *tuple,
  129.   const struct ip_conntrack *ignored_conntrack)
  130. {
  131. /* Conntrack tracking doesn't keep track of outgoing tuples; only
  132.    incoming ones.  NAT means they don't have a fixed mapping,
  133.    so we invert the tuple and look for the incoming reply.
  135.    We could keep a separate hash if this proves too slow. */
  136. struct ip_conntrack_tuple reply;
  138. invert_tuplepr(&reply, tuple);
  139. return ip_conntrack_tuple_taken(&reply, ignored_conntrack);
  140. }
  142. /* Does tuple + the source manip come within the range mr */
  143. static int
  144. in_range(const struct ip_conntrack_tuple *tuple,
  145.  const struct ip_conntrack_manip *manip,
  146.  const struct ip_nat_multi_range *mr)
  147. {
  148. struct ip_nat_protocol *proto = find_nat_proto(tuple->dst.protonum);
  149. unsigned int i;
  150. struct ip_conntrack_tuple newtuple = { *manip, tuple->dst };
  152. for (i = 0; i < mr->rangesize; i++) {
  153. /* If we are allowed to map IPs, then we must be in the
  154.    range specified, otherwise we must be unchanged. */
  155. if (mr->range[i].flags & IP_NAT_RANGE_MAP_IPS) {
  156. if (ntohl(newtuple.src.ip) < ntohl(mr->range[i].min_ip)
  157.     || (ntohl(newtuple.src.ip)
  158. > ntohl(mr->range[i].max_ip)))
  159. continue;
  160. } else {
  161. if (newtuple.src.ip != tuple->src.ip)
  162. continue;
  163. }
  165. if ((mr->range[i].flags & IP_NAT_RANGE_PROTO_SPECIFIED)
  166.     && proto->in_range(&newtuple, IP_NAT_MANIP_SRC,
  167.        &mr->range[i].min, &mr->range[i].max))
  168. return 1;
  169. }
  170. return 0;
  171. }
  173. static inline int
  174. src_cmp(const struct ip_nat_hash *i,
  175. const struct ip_conntrack_tuple *tuple,
  176. const struct ip_nat_multi_range *mr)
  177. {
  178. return (i->conntrack->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum
  179. == tuple->dst.protonum
  180. && i->conntrack->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.ip
  181. == tuple->src.ip
  182. && i->conntrack->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u.all
  183. == tuple->src.u.all
  184. && in_range(tuple,
  185.     &i->conntrack->tuplehash[IP_CT_DIR_ORIGINAL]
  186.     .tuple.src,
  187.     mr));
  188. }
  190. /* Only called for SRC manip */
  191. static struct ip_conntrack_manip *
  192. find_appropriate_src(const struct ip_conntrack_tuple *tuple,
  193.      const struct ip_nat_multi_range *mr)
  194. {
  195. unsigned int h = hash_by_src(&tuple->src, tuple->dst.protonum);
  196. struct ip_nat_hash *i;
  198. MUST_BE_READ_LOCKED(&ip_nat_lock);
  199. i = LIST_FIND(&bysource[h], src_cmp, struct ip_nat_hash *, tuple, mr);
  200. if (i)
  201. return &i->conntrack->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src;
  202. else
  203. return NULL;
  204. }
  206. #ifdef CONFIG_IP_NF_NAT_LOCAL
  207. /* If it's really a local destination manip, it may need to do a
  208.    source manip too. */
  209. static int
  210. do_extra_mangle(u_int32_t var_ip, u_int32_t *other_ipp)
  211. {
  212. struct rtable *rt;
  214. /* FIXME: IPTOS_TOS(iph->tos) --RR */
  215. if (ip_route_output(&rt, var_ip, 0, 0, 0) != 0) {
  216. DEBUGP("do_extra_mangle: Can't get route to %u.%u.%u.%un",
  217.        NIPQUAD(var_ip));
  218. return 0;
  219. }
  221. *other_ipp = rt->rt_src;
  222. ip_rt_put(rt);
  223. return 1;
  224. }
  225. #endif
  227. /* Simple way to iterate through all. */
  228. static inline int fake_cmp(const struct ip_nat_hash *i,
  229.    u_int32_t src, u_int32_t dst, u_int16_t protonum,
  230.    unsigned int *score,
  231.    const struct ip_conntrack *conntrack)
  232. {
  233. /* Compare backwards: we're dealing with OUTGOING tuples, and
  234.            inside the conntrack is the REPLY tuple.  Don't count this
  235.            conntrack. */
  236. if (i->conntrack != conntrack
  237.     && i->conntrack->tuplehash[IP_CT_DIR_REPLY].tuple.src.ip == dst
  238.     && i->conntrack->tuplehash[IP_CT_DIR_REPLY].tuple.dst.ip == src
  239.     && (i->conntrack->tuplehash[IP_CT_DIR_REPLY].tuple.dst.protonum
  240. == protonum))
  241. (*score)++;
  242. return 0;
  243. }
  245. static inline unsigned int
  246. count_maps(u_int32_t src, u_int32_t dst, u_int16_t protonum,
  247.    const struct ip_conntrack *conntrack)
  248. {
  249. unsigned int score = 0;
  251. MUST_BE_READ_LOCKED(&ip_nat_lock);
  252. LIST_FIND(&byipsproto[hash_by_ipsproto(src, dst, protonum)],
  253.   fake_cmp, struct ip_nat_hash *, src, dst, protonum, &score,
  254.   conntrack);
  256. return score;
  257. }
  259. /* For [FUTURE] fragmentation handling, we want the least-used
  260.    src-ip/dst-ip/proto triple.  Fairness doesn't come into it.  Thus
  261.    if the range specifies 1.2.3.4 ports 10000-10005 and 1.2.3.5 ports
  262.    1-65535, we don't do pro-rata allocation based on ports; we choose
  263.    the ip with the lowest src-ip/dst-ip/proto usage.
  265.    If an allocation then fails (eg. all 6 ports used in the 1.2.3.4
  266.    range), we eliminate that and try again.  This is not the most
  267.    efficient approach, but if you're worried about that, don't hand us
  268.    ranges you don't really have.  */
  269. static struct ip_nat_range *
  270. find_best_ips_proto(struct ip_conntrack_tuple *tuple,
  271.     const struct ip_nat_multi_range *mr,
  272.     const struct ip_conntrack *conntrack,
  273.     unsigned int hooknum)
  274. {
  275. unsigned int i;
  276. struct {
  277. const struct ip_nat_range *range;
  278. unsigned int score;
  279. struct ip_conntrack_tuple tuple;
  280. } best = { NULL,  0xFFFFFFFF };
  281. u_int32_t *var_ipp, *other_ipp, saved_ip, orig_dstip;
  282. static unsigned int randomness = 0;
  284. if (HOOK2MANIP(hooknum) == IP_NAT_MANIP_SRC) {
  285. var_ipp = &tuple->src.ip;
  286. saved_ip = tuple->dst.ip;
  287. other_ipp = &tuple->dst.ip;
  288. } else {
  289. var_ipp = &tuple->dst.ip;
  290. saved_ip = tuple->src.ip;
  291. other_ipp = &tuple->src.ip;
  292. }
  293. /* Don't do do_extra_mangle unless neccessary (overrides
  294.            explicit socket bindings, for example) */
  295. orig_dstip = tuple->dst.ip;
  297. IP_NF_ASSERT(mr->rangesize >= 1);
  298. for (i = 0; i < mr->rangesize; i++) {
  299. /* Host order */
  300. u_int32_t minip, maxip, j;
  302. /* Don't do ranges which are already eliminated. */
  303. if (mr->range[i].flags & IP_NAT_RANGE_FULL) {
  304. continue;
  305. }
  307. if (mr->range[i].flags & IP_NAT_RANGE_MAP_IPS) {
  308. minip = ntohl(mr->range[i].min_ip);
  309. maxip = ntohl(mr->range[i].max_ip);
  310. } else
  311. minip = maxip = ntohl(*var_ipp);
  313. randomness++;
  314. for (j = 0; j < maxip - minip + 1; j++) {
  315. unsigned int score;
  317. *var_ipp = htonl(minip + (randomness + j) 
  318.  % (maxip - minip + 1));
  320. /* Reset the other ip in case it was mangled by
  321.  * do_extra_mangle last time. */
  322. *other_ipp = saved_ip;
  324. #ifdef CONFIG_IP_NF_NAT_LOCAL
  325. if (hooknum == NF_IP_LOCAL_OUT
  326.     && *var_ipp != orig_dstip
  327.     && !do_extra_mangle(*var_ipp, other_ipp)) {
  328. DEBUGP("Range %u %u.%u.%u.%u rt failed!n",
  329.        i, NIPQUAD(*var_ipp));
  330. /* Can't route?  This whole range part is
  331.  * probably screwed, but keep trying
  332.  * anyway. */
  333. continue;
  334. }
  335. #endif
  337. /* Count how many others map onto this. */
  338. score = count_maps(tuple->src.ip, tuple->dst.ip,
  339.    tuple->dst.protonum, conntrack);
  340. if (score < best.score) {
  341. /* Optimization: doesn't get any better than
  342.    this. */
  343. if (score == 0)
  344. return (struct ip_nat_range *)
  345. &mr->range[i];
  347. best.score = score;
  348. best.tuple = *tuple;
  349. best.range = &mr->range[i];
  350. }
  351. }
  352. }
  353. *tuple = best.tuple;
  355. /* Discard const. */
  356. return (struct ip_nat_range *)best.range;
  357. }
  359. /* Fast version doesn't iterate through hash chains, but only handles
  360.    common case of single IP address (null NAT, masquerade) */
  361. static struct ip_nat_range *
  362. find_best_ips_proto_fast(struct ip_conntrack_tuple *tuple,
  363.  const struct ip_nat_multi_range *mr,
  364.  const struct ip_conntrack *conntrack,
  365.  unsigned int hooknum)
  366. {
  367. if (mr->rangesize != 1
  368.     || (mr->range[0].flags & IP_NAT_RANGE_FULL)
  369.     || ((mr->range[0].flags & IP_NAT_RANGE_MAP_IPS)
  370. && mr->range[0].min_ip != mr->range[0].max_ip))
  371. return find_best_ips_proto(tuple, mr, conntrack, hooknum);
  373. if (mr->range[0].flags & IP_NAT_RANGE_MAP_IPS) {
  374. if (HOOK2MANIP(hooknum) == IP_NAT_MANIP_SRC)
  375. tuple->src.ip = mr->range[0].min_ip;
  376. else {
  377. /* Only do extra mangle when required (breaks
  378.                            socket binding) */
  379. #ifdef CONFIG_IP_NF_NAT_LOCAL
  380. if (tuple->dst.ip != mr->range[0].min_ip
  381.     && hooknum == NF_IP_LOCAL_OUT
  382.     && !do_extra_mangle(mr->range[0].min_ip,
  383. &tuple->src.ip))
  384. return NULL;
  385. #endif
  386. tuple->dst.ip = mr->range[0].min_ip;
  387. }
  388. }
  390. /* Discard const. */
  391. return (struct ip_nat_range *)&mr->range[0];
  392. }
  394. static int
  395. get_unique_tuple(struct ip_conntrack_tuple *tuple,
  396.  const struct ip_conntrack_tuple *orig_tuple,
  397.  const struct ip_nat_multi_range *mrr,
  398.  struct ip_conntrack *conntrack,
  399.  unsigned int hooknum)
  400. {
  401. struct ip_nat_protocol *proto
  402. = find_nat_proto(orig_tuple->dst.protonum);
  403. struct ip_nat_range *rptr;
  404. unsigned int i;
  405. int ret;
  407. /* We temporarily use flags for marking full parts, but we
  408.    always clean up afterwards */
  409. struct ip_nat_multi_range *mr = (void *)mrr;
  411. /* 1) If this srcip/proto/src-proto-part is currently mapped,
  412.    and that same mapping gives a unique tuple within the given
  413.    range, use that.
  415.    This is only required for source (ie. NAT/masq) mappings.
  416.    So far, we don't do local source mappings, so multiple
  417.    manips not an issue.  */
  418. if (hooknum == NF_IP_POST_ROUTING) {
  419. struct ip_conntrack_manip *manip;
  421. manip = find_appropriate_src(orig_tuple, mr);
  422. if (manip) {
  423. /* Apply same source manipulation. */
  424. *tuple = ((struct ip_conntrack_tuple)
  425.   { *manip, orig_tuple->dst });
  426. DEBUGP("get_unique_tuple: Found current src mapn");
  427. return 1;
  428. }
  429. }
  431. /* 2) Select the least-used IP/proto combination in the given
  432.    range.
  433. */
  434. *tuple = *orig_tuple;
  435. while ((rptr = find_best_ips_proto_fast(tuple, mr, conntrack, hooknum))
  436.        != NULL) {
  437. DEBUGP("Found best for "); DUMP_TUPLE(tuple);
  438. /* 3) The per-protocol part of the manip is made to
  439.    map into the range to make a unique tuple. */
  441. /* Only bother mapping if it's not already in range
  442.    and unique */
  443. if ((!(rptr->flags & IP_NAT_RANGE_PROTO_SPECIFIED)
  444.      || proto->in_range(tuple, HOOK2MANIP(hooknum),
  445. &rptr->min, &rptr->max))
  446.     && !ip_nat_used_tuple(tuple, conntrack)) {
  447. ret = 1;
  448. goto clear_fulls;
  449. } else {
  450. if (proto->unique_tuple(tuple, rptr,
  451. HOOK2MANIP(hooknum),
  452. conntrack)) {
  453. /* Must be unique. */
  454. IP_NF_ASSERT(!ip_nat_used_tuple(tuple,
  455. conntrack));
  456. ret = 1;
  457. goto clear_fulls;
  458. } else if (HOOK2MANIP(hooknum) == IP_NAT_MANIP_DST) {
  459. /* Try implicit source NAT; protocol
  460.                                    may be able to play with ports to
  461.                                    make it unique. */
  462. struct ip_nat_range r
  463. = { IP_NAT_RANGE_MAP_IPS, 
  464.     tuple->src.ip, tuple->src.ip,
  465.     { 0 }, { 0 } };
  466. DEBUGP("Trying implicit mappingn");
  467. if (proto->unique_tuple(tuple, &r,
  468. IP_NAT_MANIP_SRC,
  469. conntrack)) {
  470. /* Must be unique. */
  471. IP_NF_ASSERT(!ip_nat_used_tuple
  472.      (tuple, conntrack));
  473. ret = 1;
  474. goto clear_fulls;
  475. }
  476. }
  477. DEBUGP("Protocol can't get unique tuple %u.n",
  478.        hooknum);
  479. }
  481. /* Eliminate that from range, and try again. */
  482. rptr->flags |= IP_NAT_RANGE_FULL;
  483. *tuple = *orig_tuple;
  484. }
  486. ret = 0;
  488.  clear_fulls:
  489. /* Clear full flags. */
  490. IP_NF_ASSERT(mr->rangesize >= 1);
  491. for (i = 0; i < mr->rangesize; i++)
  492. mr->range[i].flags &= ~IP_NAT_RANGE_FULL;
  494. return ret;
  495. }
  497. static inline int
  498. helper_cmp(const struct ip_nat_helper *helper,
  499.    const struct ip_conntrack_tuple *tuple)
  500. {
  501. return ip_ct_tuple_mask_cmp(tuple, &helper->tuple, &helper->mask);
  502. }
  504. /* Where to manip the reply packets (will be reverse manip). */
  505. static unsigned int opposite_hook[NF_IP_NUMHOOKS]
  506. = { [NF_IP_PRE_ROUTING] = NF_IP_POST_ROUTING,
  507.     [NF_IP_POST_ROUTING] = NF_IP_PRE_ROUTING,
  508. #ifdef CONFIG_IP_NF_NAT_LOCAL
  509.     [NF_IP_LOCAL_OUT] = NF_IP_LOCAL_IN,
  510.     [NF_IP_LOCAL_IN] = NF_IP_LOCAL_OUT,
  511. #endif
  512. };
  514. unsigned int
  515. ip_nat_setup_info(struct ip_conntrack *conntrack,
  516.   const struct ip_nat_multi_range *mr,
  517.   unsigned int hooknum)
  518. {
  519. struct ip_conntrack_tuple new_tuple, inv_tuple, reply;
  520. struct ip_conntrack_tuple orig_tp;
  521. struct ip_nat_info *info = &conntrack->nat.info;
  523. MUST_BE_WRITE_LOCKED(&ip_nat_lock);
  524. IP_NF_ASSERT(hooknum == NF_IP_PRE_ROUTING
  525.      || hooknum == NF_IP_POST_ROUTING
  526.      || hooknum == NF_IP_LOCAL_OUT);
  527. IP_NF_ASSERT(info->num_manips < IP_NAT_MAX_MANIPS);
  529. /* What we've got will look like inverse of reply. Normally
  530.    this is what is in the conntrack, except for prior
  531.    manipulations (future optimization: if num_manips == 0,
  532.    orig_tp =
  533.    conntrack->tuplehash[IP_CT_DIR_ORIGINAL].tuple) */
  534. invert_tuplepr(&orig_tp,
  535.        &conntrack->tuplehash[IP_CT_DIR_REPLY].tuple);
  537. #if 0
  538. {
  539. unsigned int i;
  541. DEBUGP("Hook %u (%s), ", hooknum,
  542.        HOOK2MANIP(hooknum)==IP_NAT_MANIP_SRC ? "SRC" : "DST");
  543. DUMP_TUPLE(&orig_tp);
  544. DEBUGP("Range %p: ", mr);
  545. for (i = 0; i < mr->rangesize; i++) {
  546. DEBUGP("%u:%s%s%s %u.%u.%u.%u - %u.%u.%u.%u %u - %un",
  547.        i,
  548.        (mr->range[i].flags & IP_NAT_RANGE_MAP_IPS)
  549.        ? " MAP_IPS" : "",
  550.        (mr->range[i].flags
  551. & IP_NAT_RANGE_PROTO_SPECIFIED)
  552.        ? " PROTO_SPECIFIED" : "",
  553.        (mr->range[i].flags & IP_NAT_RANGE_FULL)
  554.        ? " FULL" : "",
  555.        NIPQUAD(mr->range[i].min_ip),
  556.        NIPQUAD(mr->range[i].max_ip),
  557.        mr->range[i].min.all,
  558.        mr->range[i].max.all);
  559. }
  560. }
  561. #endif
  563. do {
  564. if (!get_unique_tuple(&new_tuple, &orig_tp, mr, conntrack,
  565.       hooknum)) {
  566. DEBUGP("ip_nat_setup_info: Can't get unique for %p.n",
  567.        conntrack);
  568. return NF_DROP;
  569. }
  571. #if 0
  572. DEBUGP("Hook %u (%s) %pn", hooknum,
  573.        HOOK2MANIP(hooknum)==IP_NAT_MANIP_SRC ? "SRC" : "DST",
  574.        conntrack);
  575. DEBUGP("Original: ");
  576. DUMP_TUPLE(&orig_tp);
  577. DEBUGP("New: ");
  578. DUMP_TUPLE(&new_tuple);
  579. #endif
  581. /* We now have two tuples (SRCIP/SRCPT/DSTIP/DSTPT):
  582.    the original (A/B/C/D') and the mangled one (E/F/G/H').
  584.    We're only allowed to work with the SRC per-proto
  585.    part, so we create inverses of both to start, then
  586.    derive the other fields we need.  */
  588. /* Reply connection: simply invert the new tuple
  589.                    (G/H/E/F') */
  590. invert_tuplepr(&reply, &new_tuple);
  592. /* Alter conntrack table so it recognizes replies.
  593.                    If fail this race (reply tuple now used), repeat. */
  594. } while (!ip_conntrack_alter_reply(conntrack, &reply));
  596. /* FIXME: We can simply used existing conntrack reply tuple
  597.            here --RR */
  598. /* Create inverse of original: C/D/A/B' */
  599. invert_tuplepr(&inv_tuple, &orig_tp);
  601. /* Has source changed?. */
  602. if (!ip_ct_tuple_src_equal(&new_tuple, &orig_tp)) {
  603. /* In this direction, a source manip. */
  604. info->manips[info->num_manips++] =
  605. ((struct ip_nat_info_manip)
  606.  { IP_CT_DIR_ORIGINAL, hooknum,
  607.    IP_NAT_MANIP_SRC, new_tuple.src });
  609. IP_NF_ASSERT(info->num_manips < IP_NAT_MAX_MANIPS);
  611. /* In the reverse direction, a destination manip. */
  612. info->manips[info->num_manips++] =
  613. ((struct ip_nat_info_manip)
  614.  { IP_CT_DIR_REPLY, opposite_hook[hooknum],
  615.    IP_NAT_MANIP_DST, orig_tp.src });
  616. IP_NF_ASSERT(info->num_manips <= IP_NAT_MAX_MANIPS);
  617. }
  619. /* Has destination changed? */
  620. if (!ip_ct_tuple_dst_equal(&new_tuple, &orig_tp)) {
  621. /* In this direction, a destination manip */
  622. info->manips[info->num_manips++] =
  623. ((struct ip_nat_info_manip)
  624.  { IP_CT_DIR_ORIGINAL, hooknum,
  625.    IP_NAT_MANIP_DST, reply.src });
  627. IP_NF_ASSERT(info->num_manips < IP_NAT_MAX_MANIPS);
  629. /* In the reverse direction, a source manip. */
  630. info->manips[info->num_manips++] =
  631. ((struct ip_nat_info_manip)
  632.  { IP_CT_DIR_REPLY, opposite_hook[hooknum],
  633.    IP_NAT_MANIP_SRC, inv_tuple.src });
  634. IP_NF_ASSERT(info->num_manips <= IP_NAT_MAX_MANIPS);
  635. }
  637. /* If there's a helper, assign it; based on new tuple. */
  638. if (!conntrack->master)
  639. info->helper = LIST_FIND(&helpers, helper_cmp, struct ip_nat_helper *,
  640.  &reply);
  642. /* It's done. */
  643. info->initialized |= (1 << HOOK2MANIP(hooknum));
  644. return NF_ACCEPT;
  645. }
  647. void replace_in_hashes(struct ip_conntrack *conntrack,
  648.        struct ip_nat_info *info)
  649. {
  650. /* Source has changed, so replace in hashes. */
  651. unsigned int srchash
  652. = hash_by_src(&conntrack->tuplehash[IP_CT_DIR_ORIGINAL]
  653.       .tuple.src,
  654.       conntrack->tuplehash[IP_CT_DIR_ORIGINAL]
  655.       .tuple.dst.protonum);
  656. /* We place packet as seen OUTGOUNG in byips_proto hash
  657.            (ie. reverse dst and src of reply packet. */
  658. unsigned int ipsprotohash
  659. = hash_by_ipsproto(conntrack->tuplehash[IP_CT_DIR_REPLY]
  660.    .tuple.dst.ip,
  661.    conntrack->tuplehash[IP_CT_DIR_REPLY]
  662.    .tuple.src.ip,
  663.    conntrack->tuplehash[IP_CT_DIR_REPLY]
  664.    .tuple.dst.protonum);
  666. IP_NF_ASSERT(info->bysource.conntrack == conntrack);
  667. MUST_BE_WRITE_LOCKED(&ip_nat_lock);
  669. list_del(&info->bysource.list);
  670. list_del(&info->byipsproto.list);
  672. list_prepend(&bysource[srchash], &info->bysource);
  673. list_prepend(&byipsproto[ipsprotohash], &info->byipsproto);
  674. }
  676. void place_in_hashes(struct ip_conntrack *conntrack,
  677.      struct ip_nat_info *info)
  678. {
  679. unsigned int srchash
  680. = hash_by_src(&conntrack->tuplehash[IP_CT_DIR_ORIGINAL]
  681.       .tuple.src,
  682.       conntrack->tuplehash[IP_CT_DIR_ORIGINAL]
  683.       .tuple.dst.protonum);
  684. /* We place packet as seen OUTGOUNG in byips_proto hash
  685.            (ie. reverse dst and src of reply packet. */
  686. unsigned int ipsprotohash
  687. = hash_by_ipsproto(conntrack->tuplehash[IP_CT_DIR_REPLY]
  688.    .tuple.dst.ip,
  689.    conntrack->tuplehash[IP_CT_DIR_REPLY]
  690.    .tuple.src.ip,
  691.    conntrack->tuplehash[IP_CT_DIR_REPLY]
  692.    .tuple.dst.protonum);
  694. IP_NF_ASSERT(!info->bysource.conntrack);
  696. MUST_BE_WRITE_LOCKED(&ip_nat_lock);
  697. info->byipsproto.conntrack = conntrack;
  698. info->bysource.conntrack = conntrack;
  700. list_prepend(&bysource[srchash], &info->bysource);
  701. list_prepend(&byipsproto[ipsprotohash], &info->byipsproto);
  702. }
  704. static void
  705. manip_pkt(u_int16_t proto, struct iphdr *iph, size_t len,
  706.   const struct ip_conntrack_manip *manip,
  707.   enum ip_nat_manip_type maniptype,
  708.   __u32 *nfcache)
  709. {
  710. *nfcache |= NFC_ALTERED;
  711. find_nat_proto(proto)->manip_pkt(iph, len, manip, maniptype);
  713. if (maniptype == IP_NAT_MANIP_SRC) {
  714. iph->check = ip_nat_cheat_check(~iph->saddr, manip->ip,
  715. iph->check);
  716. iph->saddr = manip->ip;
  717. } else {
  718. iph->check = ip_nat_cheat_check(~iph->daddr, manip->ip,
  719. iph->check);
  720. iph->daddr = manip->ip;
  721. }
  722. #if 0
  723. if (ip_fast_csum((u8 *)iph, iph->ihl) != 0)
  724. DEBUGP("IP: checksum on packet bad.n");
  726. if (proto == IPPROTO_TCP) {
  727. void *th = (u_int32_t *)iph + iph->ihl;
  728. if (tcp_v4_check(th, len - 4*iph->ihl, iph->saddr, iph->daddr,
  729.  csum_partial((char *)th, len-4*iph->ihl, 0)))
  730. DEBUGP("TCP: checksum on packet badn");
  731. }
  732. #endif
  733. }
  735. static inline int exp_for_packet(struct ip_conntrack_expect *exp,
  736.          struct sk_buff **pskb)
  737. {
  738. struct ip_conntrack_protocol *proto;
  739. int ret = 1;
  741. MUST_BE_READ_LOCKED(&ip_conntrack_lock);
  742. proto = __ip_ct_find_proto((*pskb)->nh.iph->protocol);
  743. if (proto->exp_matches_pkt)
  744. ret = proto->exp_matches_pkt(exp, pskb);
  746. return ret;
  747. }
  749. /* Do packet manipulations according to binding. */
  750. unsigned int
  751. do_bindings(struct ip_conntrack *ct,
  752.     enum ip_conntrack_info ctinfo,
  753.     struct ip_nat_info *info,
  754.     unsigned int hooknum,
  755.     struct sk_buff **pskb)
  756. {
  757. unsigned int i;
  758. struct ip_nat_helper *helper;
  759. enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
  760. int is_tcp = (*pskb)->nh.iph->protocol == IPPROTO_TCP;
  762. /* Need nat lock to protect against modification, but neither
  763.    conntrack (referenced) and helper (deleted with
  764.    synchronize_bh()) can vanish. */
  765. READ_LOCK(&ip_nat_lock);
  766. for (i = 0; i < info->num_manips; i++) {
  767. /* raw socket (tcpdump) may have clone of incoming
  768.                    skb: don't disturb it --RR */
  769. if (skb_cloned(*pskb) && !(*pskb)->sk) {
  770. struct sk_buff *nskb = skb_copy(*pskb, GFP_ATOMIC);
  771. if (!nskb) {
  772. READ_UNLOCK(&ip_nat_lock);
  773. return NF_DROP;
  774. }
  775. kfree_skb(*pskb);
  776. *pskb = nskb;
  777. }
  779. if (info->manips[i].direction == dir
  780.     && info->manips[i].hooknum == hooknum) {
  781. DEBUGP("Mangling %p: %s to %u.%u.%u.%u %un",
  782.        *pskb,
  783.        info->manips[i].maniptype == IP_NAT_MANIP_SRC
  784.        ? "SRC" : "DST",
  785.        NIPQUAD(info->manips[i].manip.ip),
  786.        htons(info->manips[i].manip.u.all));
  787. manip_pkt((*pskb)->nh.iph->protocol,
  788.   (*pskb)->nh.iph,
  789.   (*pskb)->len,
  790.   &info->manips[i].manip,
  791.   info->manips[i].maniptype,
  792.   &(*pskb)->nfcache);
  793. }
  794. }
  795. helper = info->helper;
  796. READ_UNLOCK(&ip_nat_lock);
  798. if (helper) {
  799. struct ip_conntrack_expect *exp = NULL;
  800. struct list_head *cur_item;
  801. int ret = NF_ACCEPT;
  803. DEBUGP("do_bindings: helper existing for (%p)n", ct);
  805. /* Always defragged for helpers */
  806. IP_NF_ASSERT(!((*pskb)->nh.iph->frag_off
  807.        & htons(IP_MF|IP_OFFSET)));
  809. /* Have to grab read lock before sibling_list traversal */
  810. READ_LOCK(&ip_conntrack_lock);
  811. list_for_each(cur_item, &ct->sibling_list) { 
  812. exp = list_entry(cur_item, struct ip_conntrack_expect, 
  813.  expected_list);
  814.  
  815. /* if this expectation is already established, skip */
  816. if (exp->sibling)
  817. continue;
  819. if (exp_for_packet(exp, pskb)) {
  820. /* FIXME: May be true multiple times in the case of UDP!! */
  821. DEBUGP("calling nat helper (exp=%p) for packetn",
  822. exp);
  823. ret = helper->help(ct, exp, info, ctinfo, 
  824.    hooknum, pskb);
  825. if (ret != NF_ACCEPT) {
  826. READ_UNLOCK(&ip_conntrack_lock);
  827. return ret;
  828. }
  829. }
  830. }
  831. /* Helper might want to manip the packet even when there is no expectation */
  832. if (!exp && helper->flags & IP_NAT_HELPER_F_ALWAYS) {
  833. DEBUGP("calling nat helper for packet without expectationn");
  834. ret = helper->help(ct, NULL, info, ctinfo, 
  835.    hooknum, pskb);
  836. if (ret != NF_ACCEPT) {
  837. READ_UNLOCK(&ip_conntrack_lock);
  838. return ret;
  839. }
  840. }
  841. READ_UNLOCK(&ip_conntrack_lock);
  843. /* Adjust sequence number only once per packet 
  844.  * (helper is called at all hooks) */
  845. if (is_tcp && (hooknum == NF_IP_POST_ROUTING
  846.        || hooknum == NF_IP_LOCAL_IN)) {
  847. DEBUGP("ip_nat_core: adjusting sequence numbern");
  848. /* future: put this in a l4-proto specific function,
  849.  * and call this function here. */
  850. ip_nat_seq_adjust(*pskb, ct, ctinfo);
  851. }
  853. return ret;
  855. } else 
  856. return NF_ACCEPT;
  858. /* not reached */
  859. }
  861. unsigned int
  862. icmp_reply_translation(struct sk_buff *skb,
  863.        struct ip_conntrack *conntrack,
  864.        unsigned int hooknum,
  865.        int dir)
  866. {
  867. struct iphdr *iph = skb->nh.iph;
  868. struct icmphdr *hdr = (struct icmphdr *)((u_int32_t *)iph + iph->ihl);
  869. struct iphdr *inner = (struct iphdr *)(hdr + 1);
  870. size_t datalen = skb->len - ((void *)inner - (void *)iph);
  871. unsigned int i;
  872. struct ip_nat_info *info = &conntrack->nat.info;
  874. IP_NF_ASSERT(skb->len >= iph->ihl*4 + sizeof(struct icmphdr));
  875. /* Must be RELATED */
  876. IP_NF_ASSERT(skb->nfct - (struct ip_conntrack *)skb->nfct->master
  877.      == IP_CT_RELATED
  878.      || skb->nfct - (struct ip_conntrack *)skb->nfct->master
  879.      == IP_CT_RELATED+IP_CT_IS_REPLY);
  881. /* Redirects on non-null nats must be dropped, else they'll
  882.            start talking to each other without our translation, and be
  883.            confused... --RR */
  884. if (hdr->type == ICMP_REDIRECT) {
  885. /* Don't care about races here. */
  886. if (info->initialized
  887.     != ((1 << IP_NAT_MANIP_SRC) | (1 << IP_NAT_MANIP_DST))
  888.     || info->num_manips != 0)
  889. return NF_DROP;
  890. }
  892. DEBUGP("icmp_reply_translation: translating error %p hook %u dir %sn",
  893.        skb, hooknum, dir == IP_CT_DIR_ORIGINAL ? "ORIG" : "REPLY");
  894. /* Note: May not be from a NAT'd host, but probably safest to
  895.    do translation always as if it came from the host itself
  896.    (even though a "host unreachable" coming from the host
  897.    itself is a bit weird).
  899.    More explanation: some people use NAT for anonymizing.
  900.    Also, CERT recommends dropping all packets from private IP
  901.    addresses (although ICMP errors from internal links with
  902.    such addresses are not too uncommon, as Alan Cox points
  903.    out) */
  905. READ_LOCK(&ip_nat_lock);
  906. for (i = 0; i < info->num_manips; i++) {
  907. DEBUGP("icmp_reply: manip %u dir %s hook %un",
  908.        i, info->manips[i].direction == IP_CT_DIR_ORIGINAL ?
  909.        "ORIG" : "REPLY", info->manips[i].hooknum);
  911. if (info->manips[i].direction != dir)
  912. continue;
  914. /* Mapping the inner packet is just like a normal
  915.    packet, except it was never src/dst reversed, so
  916.    where we would normally apply a dst manip, we apply
  917.    a src, and vice versa. */
  918. if (info->manips[i].hooknum == opposite_hook[hooknum]) {
  919. DEBUGP("icmp_reply: inner %s -> %u.%u.%u.%u %un",
  920.        info->manips[i].maniptype == IP_NAT_MANIP_SRC
  921.        ? "DST" : "SRC",
  922.        NIPQUAD(info->manips[i].manip.ip),
  923.        ntohs(info->manips[i].manip.u.udp.port));
  924. manip_pkt(inner->protocol, inner,
  925.   skb->len - ((void *)inner - (void *)iph),
  926.   &info->manips[i].manip,
  927.   !info->manips[i].maniptype,
  928.   &skb->nfcache);
  929. /* Outer packet needs to have IP header NATed like
  930.                    it's a reply. */
  931. } else if (info->manips[i].hooknum == hooknum) {
  932. /* Use mapping to map outer packet: 0 give no
  933.                            per-proto mapping */
  934. DEBUGP("icmp_reply: outer %s -> %u.%u.%u.%un",
  935.        info->manips[i].maniptype == IP_NAT_MANIP_SRC
  936.        ? "SRC" : "DST",
  937.        NIPQUAD(info->manips[i].manip.ip));
  938. manip_pkt(0, iph, skb->len,
  939.   &info->manips[i].manip,
  940.   info->manips[i].maniptype,
  941.   &skb->nfcache);
  942. }
  943. }
  944. READ_UNLOCK(&ip_nat_lock);
  946. /* Since we mangled inside ICMP packet, recalculate its
  947.    checksum from scratch.  (Hence the handling of incorrect
  948.    checksums in conntrack, so we don't accidentally fix one.)  */
  949. hdr->checksum = 0;
  950. hdr->checksum = ip_compute_csum((unsigned char *)hdr,
  951. sizeof(*hdr) + datalen);
  953. return NF_ACCEPT;
  954. }
  956. int __init ip_nat_init(void)
  957. {
  958. size_t i;
  960. /* Leave them the same for the moment. */
  961. ip_nat_htable_size = ip_conntrack_htable_size;
  963. /* One vmalloc for both hash tables */
  964. bysource = vmalloc(sizeof(struct list_head) * ip_nat_htable_size*2);
  965. if (!bysource) {
  966. return -ENOMEM;
  967. }
  968. byipsproto = bysource + ip_nat_htable_size;
  970. /* Sew in builtin protocols. */
  971. WRITE_LOCK(&ip_nat_lock);
  972. list_append(&protos, &ip_nat_protocol_tcp);
  973. list_append(&protos, &ip_nat_protocol_udp);
  974. list_append(&protos, &ip_nat_protocol_icmp);
  975. WRITE_UNLOCK(&ip_nat_lock);
  977. for (i = 0; i < ip_nat_htable_size; i++) {
  978. INIT_LIST_HEAD(&bysource[i]);
  979. INIT_LIST_HEAD(&byipsproto[i]);
  980. }
  982. /* FIXME: Man, this is a hack.  <SIGH> */
  983. IP_NF_ASSERT(ip_conntrack_destroyed == NULL);
  984. ip_conntrack_destroyed = &ip_nat_cleanup_conntrack;
  986. return 0;
  987. }
  989. /* Clear NAT section of all conntracks, in case we're loaded again. */
  990. static int clean_nat(const struct ip_conntrack *i, void *data)
  991. {
  992. memset((void *)&i->nat, 0, sizeof(i->nat));
  993. return 0;
  994. }
  996. /* Not __exit: called from ip_nat_standalone.c:init_or_cleanup() --RR */
  997. void ip_nat_cleanup(void)
  998. {
  999. ip_ct_selective_cleanup(&clean_nat, NULL);
  1000. ip_conntrack_destroyed = NULL;
  1001. vfree(bysource);
  1002. }