[NETFILTER]: x_tables: remove duplicate of xt_prefix
[linux-2.6.git] / net / ipv4 / netfilter / ip_nat_proto_tcp.c
1 /* (C) 1999-2001 Paul `Rusty' Russell
2  * (C) 2002-2004 Netfilter Core Team <coreteam@netfilter.org>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  */
8
9 #include <linux/types.h>
10 #include <linux/init.h>
11 #include <linux/random.h>
12 #include <linux/netfilter.h>
13 #include <linux/ip.h>
14 #include <linux/tcp.h>
15 #include <linux/if.h>
16 #include <linux/netfilter/nfnetlink_conntrack.h>
17 #include <linux/netfilter_ipv4/ip_nat.h>
18 #include <linux/netfilter_ipv4/ip_nat_rule.h>
19 #include <linux/netfilter_ipv4/ip_nat_protocol.h>
20 #include <linux/netfilter_ipv4/ip_nat_core.h>
21
22 static int
23 tcp_in_range(const struct ip_conntrack_tuple *tuple,
24              enum ip_nat_manip_type maniptype,
25              const union ip_conntrack_manip_proto *min,
26              const union ip_conntrack_manip_proto *max)
27 {
28         __be16 port;
29
30         if (maniptype == IP_NAT_MANIP_SRC)
31                 port = tuple->src.u.tcp.port;
32         else
33                 port = tuple->dst.u.tcp.port;
34
35         return ntohs(port) >= ntohs(min->tcp.port)
36                 && ntohs(port) <= ntohs(max->tcp.port);
37 }
38
39 static int
40 tcp_unique_tuple(struct ip_conntrack_tuple *tuple,
41                  const struct ip_nat_range *range,
42                  enum ip_nat_manip_type maniptype,
43                  const struct ip_conntrack *conntrack)
44 {
45         static u_int16_t port;
46         __be16 *portptr;
47         unsigned int range_size, min, i;
48
49         if (maniptype == IP_NAT_MANIP_SRC)
50                 portptr = &tuple->src.u.tcp.port;
51         else
52                 portptr = &tuple->dst.u.tcp.port;
53
54         /* If no range specified... */
55         if (!(range->flags & IP_NAT_RANGE_PROTO_SPECIFIED)) {
56                 /* If it's dst rewrite, can't change port */
57                 if (maniptype == IP_NAT_MANIP_DST)
58                         return 0;
59
60                 /* Map privileged onto privileged. */
61                 if (ntohs(*portptr) < 1024) {
62                         /* Loose convention: >> 512 is credential passing */
63                         if (ntohs(*portptr)<512) {
64                                 min = 1;
65                                 range_size = 511 - min + 1;
66                         } else {
67                                 min = 600;
68                                 range_size = 1023 - min + 1;
69                         }
70                 } else {
71                         min = 1024;
72                         range_size = 65535 - 1024 + 1;
73                 }
74         } else {
75                 min = ntohs(range->min.tcp.port);
76                 range_size = ntohs(range->max.tcp.port) - min + 1;
77         }
78
79         /* Start from random port to avoid prediction */
80         if (range->flags & IP_NAT_RANGE_PROTO_RANDOM)
81                 port =  net_random();
82
83         for (i = 0; i < range_size; i++, port++) {
84                 *portptr = htons(min + port % range_size);
85                 if (!ip_nat_used_tuple(tuple, conntrack)) {
86                         return 1;
87                 }
88         }
89         return 0;
90 }
91
92 static int
93 tcp_manip_pkt(struct sk_buff **pskb,
94               unsigned int iphdroff,
95               const struct ip_conntrack_tuple *tuple,
96               enum ip_nat_manip_type maniptype)
97 {
98         struct iphdr *iph = (struct iphdr *)((*pskb)->data + iphdroff);
99         struct tcphdr *hdr;
100         unsigned int hdroff = iphdroff + iph->ihl*4;
101         __be32 oldip, newip;
102         __be16 *portptr, newport, oldport;
103         int hdrsize = 8; /* TCP connection tracking guarantees this much */
104
105         /* this could be a inner header returned in icmp packet; in such
106            cases we cannot update the checksum field since it is outside of
107            the 8 bytes of transport layer headers we are guaranteed */
108         if ((*pskb)->len >= hdroff + sizeof(struct tcphdr))
109                 hdrsize = sizeof(struct tcphdr);
110
111         if (!skb_make_writable(pskb, hdroff + hdrsize))
112                 return 0;
113
114         iph = (struct iphdr *)((*pskb)->data + iphdroff);
115         hdr = (struct tcphdr *)((*pskb)->data + hdroff);
116
117         if (maniptype == IP_NAT_MANIP_SRC) {
118                 /* Get rid of src ip and src pt */
119                 oldip = iph->saddr;
120                 newip = tuple->src.ip;
121                 newport = tuple->src.u.tcp.port;
122                 portptr = &hdr->source;
123         } else {
124                 /* Get rid of dst ip and dst pt */
125                 oldip = iph->daddr;
126                 newip = tuple->dst.ip;
127                 newport = tuple->dst.u.tcp.port;
128                 portptr = &hdr->dest;
129         }
130
131         oldport = *portptr;
132         *portptr = newport;
133
134         if (hdrsize < sizeof(*hdr))
135                 return 1;
136
137         nf_proto_csum_replace4(&hdr->check, *pskb, oldip, newip, 1);
138         nf_proto_csum_replace2(&hdr->check, *pskb, oldport, newport, 0);
139         return 1;
140 }
141
142 struct ip_nat_protocol ip_nat_protocol_tcp = {
143         .name                   = "TCP",
144         .protonum               = IPPROTO_TCP,
145         .me                     = THIS_MODULE,
146         .manip_pkt              = tcp_manip_pkt,
147         .in_range               = tcp_in_range,
148         .unique_tuple           = tcp_unique_tuple,
149 #if defined(CONFIG_IP_NF_CONNTRACK_NETLINK) || \
150     defined(CONFIG_IP_NF_CONNTRACK_NETLINK_MODULE)
151         .range_to_nfattr        = ip_nat_port_range_to_nfattr,
152         .nfattr_to_range        = ip_nat_port_nfattr_to_range,
153 #endif
154 };