extensions/libipt_MASQUERADE.c

   1 /* Shared library add-on to iptables to add masquerade support. */
   2 #include <stdio.h>
   3 #include <netdb.h>
   4 #include <string.h>
   5 #include <stdlib.h>
   6 #include <getopt.h>
   7 #include <xtables.h>
   8 #include <limits.h> /* INT_MAX in ip_tables.h */
   9 #include <linux/netfilter_ipv4/ip_tables.h>
  10 #include <net/netfilter/nf_nat.h>
  11
  12 static void MASQUERADE_help(void)
  13 {
  14         printf(
  15 "MASQUERADE target options:\n"
  16 " --to-ports <port>[-<port>]\n"
  17 "                               Port (range) to map to.\n"
  18 " --random\n"
  19 "                               Randomize source port.\n");
  20 }
  21
  22 static const struct option MASQUERADE_opts[] = {
  23         { "to-ports", 1, NULL, '1' },
  24         { "random", 0, NULL, '2' },
  25         { .name = NULL }
  26 };
  27
  28 static void MASQUERADE_init(struct xt_entry_target *t)
  29 {
  30         struct nf_nat_multi_range *mr = (struct nf_nat_multi_range *)t->data;
  31
  32         /* Actually, it's 0, but it's ignored at the moment. */
  33         mr->rangesize = 1;
  34
  35 }
  36
  37 /* Parses ports */
  38 static void
  39 parse_ports(const char *arg, struct nf_nat_multi_range *mr)
  40 {
  41         char *end;
  42         unsigned int port, maxport;
  43
  44         mr->range[0].flags |= IP_NAT_RANGE_PROTO_SPECIFIED;
  45
  46         if (!xtables_strtoui(arg, &end, &port, 0, UINT16_MAX))
  47                 xtables_param_act(XTF_BAD_VALUE, "MASQUERADE", "--to-ports", arg);
  48
  49         switch (*end) {
  50         case '\0':
  51                 mr->range[0].min.tcp.port
  52                         = mr->range[0].max.tcp.port
  53                         = htons(port);
  54                 return;
  55         case '-':
  56                 if (!xtables_strtoui(end + 1, NULL, &maxport, 0, UINT16_MAX))
  57                         break;
  58
  59                 if (maxport < port)
  60                         break;
  61
  62                 mr->range[0].min.tcp.port = htons(port);
  63                 mr->range[0].max.tcp.port = htons(maxport);
  64                 return;
  65         default:
  66                 break;
  67         }
  68         xtables_param_act(XTF_BAD_VALUE, "MASQUERADE", "--to-ports", arg);
  69 }
  70
  71 static int MASQUERADE_parse(int c, char **argv, int invert, unsigned int *flags,
  72                             const void *e, struct xt_entry_target **target)
  73 {
  74         const struct ipt_entry *entry = e;
  75         int portok;
  76         struct nf_nat_multi_range *mr
  77                 = (struct nf_nat_multi_range *)(*target)->data;
  78
  79         if (entry->ip.proto == IPPROTO_TCP
  80             || entry->ip.proto == IPPROTO_UDP
  81             || entry->ip.proto == IPPROTO_SCTP
  82             || entry->ip.proto == IPPROTO_DCCP
  83             || entry->ip.proto == IPPROTO_ICMP)
  84                 portok = 1;
  85         else
  86                 portok = 0;
  87
  88         switch (c) {
  89         case '1':
  90                 if (!portok)
  91                         xtables_error(PARAMETER_PROBLEM,
  92                                    "Need TCP, UDP, SCTP or DCCP with port specification");
  93
  94                 if (xtables_check_inverse(optarg, &invert, NULL, 0, argv))
  95                         xtables_error(PARAMETER_PROBLEM,
  96                                    "Unexpected `!' after --to-ports");
  97
  98                 parse_ports(optarg, mr);
  99                 return 1;
 100
 101         case '2':
 102                 mr->range[0].flags |=  IP_NAT_RANGE_PROTO_RANDOM;
 103                 return 1;
 104
 105         default:
 106                 return 0;
 107         }
 108 }
 109
 110 static void
 111 MASQUERADE_print(const void *ip, const struct xt_entry_target *target,
 112                  int numeric)
 113 {
 114         const struct nf_nat_multi_range *mr = (const void *)target->data;
 115         const struct nf_nat_range *r = &mr->range[0];
 116
 117         if (r->flags & IP_NAT_RANGE_PROTO_SPECIFIED) {
 118                 printf("masq ports: ");
 119                 printf("%hu", ntohs(r->min.tcp.port));
 120                 if (r->max.tcp.port != r->min.tcp.port)
 121                         printf("-%hu", ntohs(r->max.tcp.port));
 122                 printf(" ");
 123         }
 124
 125         if (r->flags & IP_NAT_RANGE_PROTO_RANDOM)
 126                 printf("random ");
 127 }
 128
 129 static void
 130 MASQUERADE_save(const void *ip, const struct xt_entry_target *target)
 131 {
 132         const struct nf_nat_multi_range *mr = (const void *)target->data;
 133         const struct nf_nat_range *r = &mr->range[0];
 134
 135         if (r->flags & IP_NAT_RANGE_PROTO_SPECIFIED) {
 136                 printf("--to-ports %hu", ntohs(r->min.tcp.port));
 137                 if (r->max.tcp.port != r->min.tcp.port)
 138                         printf("-%hu", ntohs(r->max.tcp.port));
 139                 printf(" ");
 140         }
 141
 142         if (r->flags & IP_NAT_RANGE_PROTO_RANDOM)
 143                 printf("--random ");
 144 }
 145
 146 static struct xtables_target masquerade_tg_reg = {
 147         .name           = "MASQUERADE",
 148         .version        = XTABLES_VERSION,
 149         .family         = NFPROTO_IPV4,
 150         .size           = XT_ALIGN(sizeof(struct nf_nat_multi_range)),
 151         .userspacesize  = XT_ALIGN(sizeof(struct nf_nat_multi_range)),
 152         .help           = MASQUERADE_help,
 153         .init           = MASQUERADE_init,
 154         .parse          = MASQUERADE_parse,
 155         .print          = MASQUERADE_print,
 156         .save           = MASQUERADE_save,
 157         .extra_opts     = MASQUERADE_opts,
 158 };
 159
 160 void _init(void)
 161 {
 162         xtables_register_target(&masquerade_tg_reg);
 163 }