extensions/libip6t_ipv6header.c

   1 /* ipv6header match - matches IPv6 packets based
   2 on whether they contain certain headers */
   3
   4 /* Original idea: Brad Chapman
   5  * Rewritten by: Andras Kis-Szabo <kisza@sch.bme.hu> */
   6
   7 #include <getopt.h>
   8 #include <ip6tables.h>
   9 #include <stddef.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <netdb.h>
  14 #include <sys/types.h>
  15
  16 #include <linux/netfilter_ipv6/ip6_tables.h>
  17 #include <linux/netfilter_ipv6/ip6t_ipv6header.h>
  18
  19 /* This maybe required
  20 #include <linux/in.h>
  21 #include <linux/in6.h>
  22 */
  23
  24
  25 /* A few hardcoded protocols for 'all' and in case the user has no
  26  *    /etc/protocols */
  27 struct pprot {
  28         char *name;
  29         u_int8_t num;
  30 };
  31
  32 struct numflag {
  33         u_int8_t proto;
  34         u_int8_t flag;
  35 };
  36
  37 static const struct pprot chain_protos[] = {
  38         { "hop-by-hop", IPPROTO_HOPOPTS },
  39         { "protocol", IPPROTO_RAW },
  40         { "hop", IPPROTO_HOPOPTS },
  41         { "dst", IPPROTO_DSTOPTS },
  42         { "route", IPPROTO_ROUTING },
  43         { "frag", IPPROTO_FRAGMENT },
  44         { "auth", IPPROTO_AH },
  45         { "esp", IPPROTO_ESP },
  46         { "none", IPPROTO_NONE },
  47         { "prot", IPPROTO_RAW },
  48         { "0", IPPROTO_HOPOPTS },
  49         { "60", IPPROTO_DSTOPTS },
  50         { "43", IPPROTO_ROUTING },
  51         { "44", IPPROTO_FRAGMENT },
  52         { "51", IPPROTO_AH },
  53         { "50", IPPROTO_ESP },
  54         { "59", IPPROTO_NONE },
  55         { "255", IPPROTO_RAW },
  56         /* { "all", 0 }, */
  57 };
  58
  59 static const struct numflag chain_flags[] = {
  60         { IPPROTO_HOPOPTS, MASK_HOPOPTS },
  61         { IPPROTO_DSTOPTS, MASK_DSTOPTS },
  62         { IPPROTO_ROUTING, MASK_ROUTING },
  63         { IPPROTO_FRAGMENT, MASK_FRAGMENT },
  64         { IPPROTO_AH, MASK_AH },
  65         { IPPROTO_ESP, MASK_ESP },
  66         { IPPROTO_NONE, MASK_NONE },
  67         { IPPROTO_RAW, MASK_PROTO },
  68 };
  69
  70 static char *
  71 proto_to_name(u_int8_t proto, int nolookup)
  72 {
  73         unsigned int i;
  74
  75         if (proto && !nolookup) {
  76                 struct protoent *pent = getprotobynumber(proto);
  77                 if (pent)
  78                         return pent->p_name;
  79         }
  80
  81         for (i = 0; i < sizeof(chain_protos)/sizeof(struct pprot); i++)
  82                 if (chain_protos[i].num == proto)
  83                         return chain_protos[i].name;
  84
  85         return NULL;
  86 }
  87
  88 static u_int16_t
  89 name_to_proto(const char *s)
  90 {
  91         unsigned int proto=0;
  92         struct protoent *pent;
  93
  94         if ((pent = getprotobyname(s)))
  95                 proto = pent->p_proto;
  96         else {
  97                 unsigned int i;
  98                 for (i = 0;
  99                         i < sizeof(chain_protos)/sizeof(struct pprot);
 100                         i++) {
 101                         if (strcmp(s, chain_protos[i].name) == 0) {
 102                                 proto = chain_protos[i].num;
 103                                 break;
 104                         }
 105                 }
 106
 107                 if (i == sizeof(chain_protos)/sizeof(struct pprot))
 108                         exit_error(PARAMETER_PROBLEM,
 109                                 "unknown header `%s' specified",
 110                                 s);
 111         }
 112
 113         return (u_int16_t)proto;
 114 }
 115
 116 static unsigned int
 117 add_proto_to_mask(int proto){
 118         unsigned int i=0, flag=0;
 119
 120         for (i = 0;
 121                 i < sizeof(chain_flags)/sizeof(struct numflag);
 122                 i++) {
 123                         if (proto == chain_flags[i].proto){
 124                                 flag = chain_flags[i].flag;
 125                                 break;
 126                         }
 127         }
 128
 129         if (i == sizeof(chain_flags)/sizeof(struct numflag))
 130                 exit_error(PARAMETER_PROBLEM,
 131                 "unknown header `%d' specified",
 132                 proto);
 133
 134         return flag;
 135 }
 136
 137 static void ipv6header_help(void)
 138 {
 139         printf(
 140 "ipv6header match options:\n"
 141 "--header [!] headers     Type of header to match, by name\n"
 142 "                         names: hop,dst,route,frag,auth,esp,none,proto\n"
 143 "                    long names: hop-by-hop,ipv6-opts,ipv6-route,\n"
 144 "                                ipv6-frag,ah,esp,ipv6-nonxt,protocol\n"
 145 "                       numbers: 0,60,43,44,51,50,59\n"
 146 "--soft                    The header CONTAINS the specified extensions\n");
 147 }
 148
 149 static const struct option ipv6header_opts[] = {
 150         { "header", 1, NULL, '1' },
 151         { "soft", 0, NULL, '2' },
 152         { .name = NULL }
 153 };
 154
 155 static void ipv6header_init(struct xt_entry_match *m)
 156 {
 157         struct ip6t_ipv6header_info *info = (struct ip6t_ipv6header_info *)m->data;
 158
 159         info->matchflags = 0x00;
 160         info->invflags = 0x00;
 161         info->modeflag = 0x00;
 162 }
 163
 164 static unsigned int
 165 parse_header(const char *flags) {
 166         unsigned int ret = 0;
 167         char *ptr;
 168         char *buffer;
 169
 170         buffer = strdup(flags);
 171
 172         for (ptr = strtok(buffer, ","); ptr; ptr = strtok(NULL, ","))
 173                 ret |= add_proto_to_mask(name_to_proto(ptr));
 174
 175         free(buffer);
 176         return ret;
 177 }
 178
 179 #define IPV6_HDR_HEADER 0x01
 180 #define IPV6_HDR_SOFT   0x02
 181
 182 /* Parses command options; returns 0 if it ate an option */
 183 static int
 184 ipv6header_parse(int c, char **argv, int invert, unsigned int *flags,
 185                  const void *entry, struct xt_entry_match **match)
 186 {
 187         struct ip6t_ipv6header_info *info = (struct ip6t_ipv6header_info *)(*match)->data;
 188
 189         switch (c) {
 190                 case '1' :
 191                         /* Parse the provided header names */
 192                         if (*flags & IPV6_HDR_HEADER)
 193                                 exit_error(PARAMETER_PROBLEM,
 194                                         "Only one `--header' allowed");
 195
 196                         check_inverse(optarg, &invert, &optind, 0);
 197
 198                         if (! (info->matchflags = parse_header(argv[optind-1])) )
 199                                 exit_error(PARAMETER_PROBLEM, "ip6t_ipv6header: cannot parse header names");
 200
 201                         if (invert)
 202                                 info->invflags |= 0xFF;
 203                         *flags |= IPV6_HDR_HEADER;
 204                         break;
 205                 case '2' :
 206                         /* Soft-mode requested? */
 207                         if (*flags & IPV6_HDR_SOFT)
 208                                 exit_error(PARAMETER_PROBLEM,
 209                                         "Only one `--soft' allowed");
 210
 211                         info->modeflag |= 0xFF;
 212                         *flags |= IPV6_HDR_SOFT;
 213                         break;
 214                 default:
 215                         return 0;
 216         }
 217
 218         return 1;
 219 }
 220
 221 /* Checks the flags variable */
 222 static void ipv6header_check(unsigned int flags)
 223 {
 224         if (!flags) exit_error(PARAMETER_PROBLEM, "ip6t_ipv6header: no options specified");
 225 }
 226
 227 static void
 228 print_header(u_int8_t flags){
 229         int have_flag = 0;
 230
 231         while (flags) {
 232                 unsigned int i;
 233
 234                 for (i = 0; (flags & chain_flags[i].flag) == 0; i++);
 235
 236                 if (have_flag)
 237                         printf(",");
 238
 239                 printf("%s", proto_to_name(chain_flags[i].proto,0));
 240                 have_flag = 1;
 241
 242                 flags &= ~chain_flags[i].flag;
 243         }
 244
 245         if (!have_flag)
 246                 printf("NONE");
 247 }
 248
 249 /* Prints out the match */
 250 static void ipv6header_print(const void *ip,
 251                              const struct xt_entry_match *match, int numeric)
 252 {
 253         const struct ip6t_ipv6header_info *info = (const struct ip6t_ipv6header_info *)match->data;
 254         printf("ipv6header ");
 255
 256         if (info->matchflags || info->invflags) {
 257                 printf("flags:%s", info->invflags ? "!" : "");
 258                 if (numeric)
 259                         printf("0x%02X ", info->matchflags);
 260                 else {
 261                         print_header(info->matchflags);
 262                         printf(" ");
 263                 }
 264         }
 265
 266         if (info->modeflag)
 267                 printf("soft ");
 268
 269         return;
 270 }
 271
 272 /* Saves the match */
 273 static void ipv6header_save(const void *ip, const struct xt_entry_match *match)
 274 {
 275
 276         const struct ip6t_ipv6header_info *info = (const struct ip6t_ipv6header_info *)match->data;
 277
 278         printf("--header ");
 279         printf("%s", info->invflags ? "!" : "");
 280         print_header(info->matchflags);
 281         printf(" ");
 282         if (info->modeflag)
 283                 printf("--soft ");
 284
 285         return;
 286 }
 287
 288 static struct xtables_match ipv6header_mt6_reg = {
 289         .name           = "ipv6header",
 290         .version        = XTABLES_VERSION,
 291         .family         = PF_INET6,
 292         .size           = XT_ALIGN(sizeof(struct ip6t_ipv6header_info)),
 293         .userspacesize  = XT_ALIGN(sizeof(struct ip6t_ipv6header_info)),
 294         .help           = ipv6header_help,
 295         .init           = ipv6header_init,
 296         .parse          = ipv6header_parse,
 297         .final_check    = ipv6header_check,
 298         .print          = ipv6header_print,
 299         .save           = ipv6header_save,
 300         .extra_opts     = ipv6header_opts,
 301 };
 302
 303 void _init(void)
 304 {
 305         xtables_register_match(&ipv6header_mt6_reg);
 306 }