extensions/libipt_REDIRECT.c

   1 /* Shared library add-on to iptables to add redirect support. */
   2 #include <stdio.h>
   3 #include <netdb.h>
   4 #include <string.h>
   5 #include <stdlib.h>
   6 #include <getopt.h>
   7 #include <iptables.h>
   8 #include <linux/netfilter_ipv4/ip_tables.h>
   9 #include <linux/netfilter/nf_nat.h>
  10
  11 #define IPT_REDIRECT_OPT_DEST   0x01
  12 #define IPT_REDIRECT_OPT_RANDOM 0x02
  13
  14 /* Function which prints out usage message. */
  15 static void REDIRECT_help(void)
  16 {
  17         printf(
  18 "REDIRECT target options:\n"
  19 " --to-ports <port>[-<port>]\n"
  20 "                               Port (range) to map to.\n");
  21 }
  22
  23 static const struct option REDIRECT_opts[] = {
  24         { "to-ports", 1, NULL, '1' },
  25         { "random", 0, NULL, '2' },
  26         { .name = NULL }
  27 };
  28
  29 /* Initialize the target. */
  30 static void REDIRECT_init(struct xt_entry_target *t)
  31 {
  32         struct ip_nat_multi_range *mr = (struct ip_nat_multi_range *)t->data;
  33
  34         /* Actually, it's 0, but it's ignored at the moment. */
  35         mr->rangesize = 1;
  36
  37 }
  38
  39 /* Parses ports */
  40 static void
  41 parse_ports(const char *arg, struct ip_nat_multi_range *mr)
  42 {
  43         const char *dash;
  44         int port;
  45
  46         mr->range[0].flags |= IP_NAT_RANGE_PROTO_SPECIFIED;
  47
  48         if (strchr(arg, '.'))
  49                 exit_error(PARAMETER_PROBLEM, "IP address not permitted\n");
  50
  51         port = atoi(arg);
  52         if (port == 0)
  53                 port = service_to_port(arg, NULL);
  54
  55         if (port == 0 || port > 65535)
  56                 exit_error(PARAMETER_PROBLEM, "Port `%s' not valid\n", arg);
  57
  58         dash = strchr(arg, '-');
  59         if (!dash) {
  60                 mr->range[0].min.tcp.port
  61                         = mr->range[0].max.tcp.port
  62                         = htons(port);
  63         } else {
  64                 int maxport;
  65
  66                 maxport = atoi(dash + 1);
  67                 if (maxport == 0 || maxport > 65535)
  68                         exit_error(PARAMETER_PROBLEM,
  69                                    "Port `%s' not valid\n", dash+1);
  70                 if (maxport < port)
  71                         /* People are stupid. */
  72                         exit_error(PARAMETER_PROBLEM,
  73                                    "Port range `%s' funky\n", arg);
  74                 mr->range[0].min.tcp.port = htons(port);
  75                 mr->range[0].max.tcp.port = htons(maxport);
  76         }
  77 }
  78
  79 /* Function which parses command options; returns true if it
  80    ate an option */
  81 static int REDIRECT_parse(int c, char **argv, int invert, unsigned int *flags,
  82                           const void *e, struct xt_entry_target **target)
  83 {
  84         const struct ipt_entry *entry = e;
  85         struct ip_nat_multi_range *mr
  86                 = (struct ip_nat_multi_range *)(*target)->data;
  87         int portok;
  88
  89         if (entry->ip.proto == IPPROTO_TCP
  90             || entry->ip.proto == IPPROTO_UDP
  91             || entry->ip.proto == IPPROTO_ICMP)
  92                 portok = 1;
  93         else
  94                 portok = 0;
  95
  96         switch (c) {
  97         case '1':
  98                 if (!portok)
  99                         exit_error(PARAMETER_PROBLEM,
 100                                    "Need TCP or UDP with port specification");
 101
 102                 if (check_inverse(optarg, &invert, NULL, 0))
 103                         exit_error(PARAMETER_PROBLEM,
 104                                    "Unexpected `!' after --to-ports");
 105
 106                 parse_ports(optarg, mr);
 107                 if (*flags & IPT_REDIRECT_OPT_RANDOM)
 108                         mr->range[0].flags |= IP_NAT_RANGE_PROTO_RANDOM;
 109                 *flags |= IPT_REDIRECT_OPT_DEST;
 110                 return 1;
 111
 112         case '2':
 113                 if (*flags & IPT_REDIRECT_OPT_DEST) {
 114                         mr->range[0].flags |= IP_NAT_RANGE_PROTO_RANDOM;
 115                         *flags |= IPT_REDIRECT_OPT_RANDOM;
 116                 } else
 117                         *flags |= IPT_REDIRECT_OPT_RANDOM;
 118                 return 1;
 119
 120         default:
 121                 return 0;
 122         }
 123 }
 124
 125 /* Prints out the targinfo. */
 126 static void REDIRECT_print(const void *ip, const struct xt_entry_target *target,
 127                            int numeric)
 128 {
 129         struct ip_nat_multi_range *mr
 130                 = (struct ip_nat_multi_range *)target->data;
 131         struct ip_nat_range *r = &mr->range[0];
 132
 133         if (r->flags & IP_NAT_RANGE_PROTO_SPECIFIED) {
 134                 printf("redir ports ");
 135                 printf("%hu", ntohs(r->min.tcp.port));
 136                 if (r->max.tcp.port != r->min.tcp.port)
 137                         printf("-%hu", ntohs(r->max.tcp.port));
 138                 printf(" ");
 139                 if (mr->range[0].flags & IP_NAT_RANGE_PROTO_RANDOM)
 140                         printf("random ");
 141         }
 142 }
 143
 144 /* Saves the union ipt_targinfo in parsable form to stdout. */
 145 static void REDIRECT_save(const void *ip, const struct xt_entry_target *target)
 146 {
 147         struct ip_nat_multi_range *mr
 148                 = (struct ip_nat_multi_range *)target->data;
 149         struct ip_nat_range *r = &mr->range[0];
 150
 151         if (r->flags & IP_NAT_RANGE_PROTO_SPECIFIED) {
 152                 printf("--to-ports ");
 153                 printf("%hu", ntohs(r->min.tcp.port));
 154                 if (r->max.tcp.port != r->min.tcp.port)
 155                         printf("-%hu", ntohs(r->max.tcp.port));
 156                 printf(" ");
 157                 if (mr->range[0].flags & IP_NAT_RANGE_PROTO_RANDOM)
 158                         printf("--random ");
 159         }
 160 }
 161
 162 static struct xtables_target redirect_tg_reg = {
 163         .name           = "REDIRECT",
 164         .version        = XTABLES_VERSION,
 165         .family         = PF_INET,
 166         .size           = XT_ALIGN(sizeof(struct ip_nat_multi_range)),
 167         .userspacesize  = XT_ALIGN(sizeof(struct ip_nat_multi_range)),
 168         .help           = REDIRECT_help,
 169         .init           = REDIRECT_init,
 170         .parse          = REDIRECT_parse,
 171         .print          = REDIRECT_print,
 172         .save           = REDIRECT_save,
 173         .extra_opts     = REDIRECT_opts,
 174 };
 175
 176 void _init(void)
 177 {
 178         xtables_register_target(&redirect_tg_reg);
 179 }