kernel/linux/net/ipv4/netfilter/ip_nat_gre.c

   1 /*
   2  * ip_nat_proto_gre.c - Version 2.0
   3  *
   4  * NAT protocol helper module for GRE.
   5  *
   6  * GRE is a generic encapsulation protocol, which is generally not very
   7  * suited for NAT, as it has no protocol-specific part as port numbers.
   8  *
   9  * It has an optional key field, which may help us distinguishing two
  10  * connections between the same two hosts.
  11  *
  12  * GRE is defined in RFC 1701 and RFC 1702, as well as RFC 2784
  13  *
  14  * PPTP is built on top of a modified version of GRE, and has a mandatory
  15  * field called "CallID", which serves us for the same purpose as the key
  16  * field in plain GRE.
  17  *
  18  * Documentation about PPTP can be found in RFC 2637
  19  *
  20  * (C) 2000-2004 by Harald Welte <laforge@gnumonks.org>
  21  *
  22  * Development of this code funded by Astaro AG (http://www.astaro.com/)
  23  *
  24  */
  25
  26 #include <linux/config.h>
  27 #include <linux/module.h>
  28 #include <linux/ip.h>
  29 #include <linux/netfilter_ipv4/ip_nat.h>
  30 #include <linux/netfilter_ipv4/ip_nat_rule.h>
  31 #include <linux/netfilter_ipv4/ip_nat_protocol.h>
  32 #include <linux/netfilter_ipv4/ip_conntrack_proto_gre.h>
  33
  34 MODULE_LICENSE("GPL");
  35 MODULE_AUTHOR("Harald Welte <laforge@gnumonks.org>");
  36 MODULE_DESCRIPTION("Netfilter NAT protocol helper module for GRE");
  37
  38 #if 0
  39 #define DEBUGP(format, args...) printk(KERN_DEBUG "%s:%s: " format, __FILE__, \
  40                                        __FUNCTION__, ## args)
  41 #else
  42 #define DEBUGP(x, args...)
  43 #endif
  44
  45 /* is key in given range between min and max */
  46 static int
  47 gre_in_range(const struct ip_conntrack_tuple *tuple,
  48              enum ip_nat_manip_type maniptype,
  49              const union ip_conntrack_manip_proto *min,
  50              const union ip_conntrack_manip_proto *max)
  51 {
  52         u_int32_t key;
  53
  54         if (maniptype == IP_NAT_MANIP_SRC)
  55                 key = tuple->src.u.gre.key;
  56         else
  57                 key = tuple->dst.u.gre.key;
  58
  59         return ntohl(key) >= ntohl(min->gre.key)
  60                 && ntohl(key) <= ntohl(max->gre.key);
  61 }
  62
  63 /* generate unique tuple ... */
  64 static int
  65 gre_unique_tuple(struct ip_conntrack_tuple *tuple,
  66                  const struct ip_nat_range *range,
  67                  enum ip_nat_manip_type maniptype,
  68                  const struct ip_conntrack *conntrack)
  69 {
  70         u_int32_t min, i, range_size;
  71         u_int32_t key = 0, *keyptr;
  72
  73         if (maniptype == IP_NAT_MANIP_SRC)
  74                 keyptr = &tuple->src.u.gre.key;
  75         else
  76                 keyptr = &tuple->dst.u.gre.key;
  77
  78         if (!(range->flags & IP_NAT_RANGE_PROTO_SPECIFIED)) {
  79                 DEBUGP("%p: NATing GRE PPTP\n", conntrack);
  80                 min = 1;
  81                 range_size = 0xffff;
  82         } else {
  83                 min = ntohl(range->min.gre.key);
  84                 range_size = ntohl(range->max.gre.key) - min + 1;
  85         }
  86
  87         DEBUGP("min = %u, range_size = %u\n", min, range_size);
  88
  89         for (i = 0; i < range_size; i++, key++) {
  90                 *keyptr = htonl(min + key % range_size);
  91                 if (!ip_nat_used_tuple(tuple, conntrack))
  92                         return 1;
  93         }
  94
  95         DEBUGP("%p: no NAT mapping\n", conntrack);
  96
  97         return 0;
  98 }
  99
 100 /* manipulate a GRE packet according to maniptype */
 101 static int
 102 gre_manip_pkt(struct sk_buff **pskb,
 103               unsigned int iphdroff,
 104               const struct ip_conntrack_manip *manip,
 105               enum ip_nat_manip_type maniptype)
 106 {
 107         struct gre_hdr *greh;
 108         struct gre_hdr_pptp *pgreh;
 109         struct iphdr *iph = (struct iphdr *)((*pskb)->data + iphdroff);
 110         unsigned int hdroff = iphdroff + iph->ihl*4;
 111
 112         /* pgreh includes two optional 32bit fields which are not required
 113          * to be there.  That's where the magic '8' comes from */
 114         if (!skb_ip_make_writable(pskb, hdroff + sizeof(*pgreh)-8))
 115                 return 0;
 116
 117         greh = (void *)(*pskb)->data + hdroff;
 118         pgreh = (struct gre_hdr_pptp *) greh;
 119
 120         /* we only have destination manip of a packet, since 'source key'
 121          * is not present in the packet itself */
 122         if (maniptype == IP_NAT_MANIP_DST) {
 123                 /* key manipulation is always dest */
 124                 switch (greh->version) {
 125                 case 0:
 126                         if (!greh->key) {
 127                                 DEBUGP("can't nat GRE w/o key\n");
 128                                 break;
 129                         }
 130                         if (greh->csum) {
 131                                 /* FIXME: Never tested this code... */
 132                                 *(gre_csum(greh)) =
 133                                         ip_nat_cheat_check(~*(gre_key(greh)),
 134                                                         manip->u.gre.key,
 135                                                         *(gre_csum(greh)));
 136                         }
 137                         *(gre_key(greh)) = manip->u.gre.key;
 138                         break;
 139                 case GRE_VERSION_PPTP:
 140                         DEBUGP("call_id -> 0x%04x\n",
 141                                 ntohl(manip->u.gre.key));
 142                         pgreh->call_id = htons(ntohl(manip->u.gre.key));
 143                         break;
 144                 default:
 145                         DEBUGP("can't nat unknown GRE version\n");
 146                         return 0;
 147                         break;
 148                 }
 149         }
 150         return 1;
 151 }
 152
 153 /* print out a nat tuple */
 154 static unsigned int
 155 gre_print(char *buffer,
 156           const struct ip_conntrack_tuple *match,
 157           const struct ip_conntrack_tuple *mask)
 158 {
 159         unsigned int len = 0;
 160
 161         if (mask->src.u.gre.key)
 162                 len += sprintf(buffer + len, "srckey=0x%x ",
 163                                 ntohl(match->src.u.gre.key));
 164
 165         if (mask->dst.u.gre.key)
 166                 len += sprintf(buffer + len, "dstkey=0x%x ",
 167                                 ntohl(match->src.u.gre.key));
 168
 169         return len;
 170 }
 171
 172 /* print a range of keys */
 173 static unsigned int
 174 gre_print_range(char *buffer, const struct ip_nat_range *range)
 175 {
 176         if (range->min.gre.key != 0
 177             || range->max.gre.key != 0xFFFF) {
 178                 if (range->min.gre.key == range->max.gre.key)
 179                         return sprintf(buffer, "key 0x%x ",
 180                                         ntohl(range->min.gre.key));
 181                 else
 182                         return sprintf(buffer, "keys 0x%u-0x%u ",
 183                                         ntohl(range->min.gre.key),
 184                                         ntohl(range->max.gre.key));
 185         } else
 186                 return 0;
 187 }
 188
 189 /* nat helper struct */
 190 static struct ip_nat_protocol gre = {
 191         .name           = "GRE",
 192         .protonum       = IPPROTO_GRE,
 193         .manip_pkt      = gre_manip_pkt,
 194         .in_range       = gre_in_range,
 195         .unique_tuple   = gre_unique_tuple,
 196         .print          = gre_print,
 197         .print_range    = gre_print_range
 198 };
 199
 200 static int __init init(void)
 201 {
 202         if (ip_nat_protocol_register(&gre))
 203                 return -EIO;
 204
 205         return 0;
 206 }
 207
 208 static void __exit fini(void)
 209 {
 210         ip_nat_protocol_unregister(&gre);
 211 }
 212
 213 module_init(init);
 214 module_exit(fini);