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 <iptables.h>
   8 #include <linux/netfilter_ipv4/ip_tables.h>
   9 #include <linux/netfilter_ipv4/ip_nat_rule.h>
  10
  11 /* Function which prints out usage message. */
  12 static void
  13 help(void)
  14 {
  15         printf(
  16 "MASQUERADE v%s options:\n"
  17 " --to-ports <port>[-<port>]\n"
  18 "                               Port (range) to map to.\n\n",
  19 IPTABLES_VERSION);
  20 }
  21
  22 static struct option opts[] = {
  23         { "to-ports", 1, 0, '1' },
  24         { 0 }
  25 };
  26
  27 /* Initialize the target. */
  28 static void
  29 init(struct ipt_entry_target *t, unsigned int *nfcache)
  30 {
  31         struct ip_nat_multi_range *mr = (struct ip_nat_multi_range *)t->data;
  32
  33         /* Actually, it's 0, but it's ignored at the moment. */
  34         mr->rangesize = 1;
  35
  36 }
  37
  38 /* Parses ports */
  39 static void
  40 parse_ports(const char *arg, struct ip_nat_multi_range *mr)
  41 {
  42         const char *dash;
  43         int port;
  44
  45         mr->range[0].flags |= IP_NAT_RANGE_PROTO_SPECIFIED;
  46
  47         port = atoi(arg);
  48         if (port <= 0 || port > 65535)
  49                 exit_error(PARAMETER_PROBLEM, "Port `%s' not valid\n", arg);
  50
  51         dash = strchr(arg, '-');
  52         if (!dash) {
  53                 mr->range[0].min.tcp.port
  54                         = mr->range[0].max.tcp.port
  55                         = htons(port);
  56         } else {
  57                 int maxport;
  58
  59                 maxport = atoi(dash + 1);
  60                 if (maxport == 0 || maxport > 65535)
  61                         exit_error(PARAMETER_PROBLEM,
  62                                    "Port `%s' not valid\n", dash+1);
  63                 if (maxport < port)
  64                         /* People are stupid.  Present reader excepted. */
  65                         exit_error(PARAMETER_PROBLEM,
  66                                    "Port range `%s' funky\n", arg);
  67                 mr->range[0].min.tcp.port = htons(port);
  68                 mr->range[0].max.tcp.port = htons(maxport);
  69         }
  70 }
  71
  72 /* Function which parses command options; returns true if it
  73    ate an option */
  74 static int
  75 parse(int c, char **argv, int invert, unsigned int *flags,
  76       const struct ipt_entry *entry,
  77       struct ipt_entry_target **target)
  78 {
  79         int portok;
  80         struct ip_nat_multi_range *mr
  81                 = (struct ip_nat_multi_range *)(*target)->data;
  82
  83         if (entry->ip.proto == IPPROTO_TCP
  84             || entry->ip.proto == IPPROTO_UDP)
  85                 portok = 1;
  86         else
  87                 portok = 0;
  88
  89         switch (c) {
  90         case '1':
  91                 if (!portok)
  92                         exit_error(PARAMETER_PROBLEM,
  93                                    "Need TCP or UDP with port specification");
  94
  95                 if (check_inverse(optarg, &invert, NULL, 0))
  96                         exit_error(PARAMETER_PROBLEM,
  97                                    "Unexpected `!' after --to-ports");
  98
  99                 parse_ports(optarg, mr);
 100                 return 1;
 101
 102         default:
 103                 return 0;
 104         }
 105 }
 106
 107 /* Final check; don't care. */
 108 static void final_check(unsigned int flags)
 109 {
 110 }
 111
 112 /* Prints out the targinfo. */
 113 static void
 114 print(const struct ipt_ip *ip,
 115       const struct ipt_entry_target *target,
 116       int numeric)
 117 {
 118         struct ip_nat_multi_range *mr
 119                 = (struct ip_nat_multi_range *)target->data;
 120         struct ip_nat_range *r = &mr->range[0];
 121
 122         if (r->flags & IP_NAT_RANGE_PROTO_SPECIFIED) {
 123                 printf("masq ports: ");
 124                 printf("%hu", ntohs(r->min.tcp.port));
 125                 if (r->max.tcp.port != r->min.tcp.port)
 126                         printf("-%hu", ntohs(r->max.tcp.port));
 127                 printf(" ");
 128         }
 129 }
 130
 131 /* Saves the union ipt_targinfo in parsable form to stdout. */
 132 static void
 133 save(const struct ipt_ip *ip, const struct ipt_entry_target *target)
 134 {
 135         struct ip_nat_multi_range *mr
 136                 = (struct ip_nat_multi_range *)target->data;
 137         struct ip_nat_range *r = &mr->range[0];
 138
 139         if (r->flags & IP_NAT_RANGE_PROTO_SPECIFIED) {
 140                 printf("--to-ports %hu", ntohs(r->min.tcp.port));
 141                 if (r->max.tcp.port != r->min.tcp.port)
 142                         printf("-%hu", ntohs(r->max.tcp.port));
 143                 printf(" ");
 144         }
 145 }
 146
 147 static struct iptables_target masq = { NULL,
 148         .name           = "MASQUERADE",
 149         .version        = IPTABLES_VERSION,
 150         .size           = IPT_ALIGN(sizeof(struct ip_nat_multi_range)),
 151         .userspacesize  = IPT_ALIGN(sizeof(struct ip_nat_multi_range)),
 152         .help           = &help,
 153         .init           = &init,
 154         .parse          = &parse,
 155         .final_check    = &final_check,
 156         .print          = &print,
 157         .save           = &save,
 158         .extra_opts     = opts
 159 };
 160
 161 void _init(void)
 162 {
 163         register_target(&masq);
 164 }