package/network/ipv6/map/src/mapcalc.c

   1 /*
   2  * mapcalc - MAP parameter calculation
   3  *
   4  * Author: Steven Barth <cyrus@openwrt.org>
   5  * Copyright (c) 2014-2015 cisco Systems, Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2
   9  * as published by the Free Software Foundation
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <stdio.h>
  19 #include <arpa/inet.h>
  20 #include <errno.h>
  21 #include <libubus.h>
  22 #include <libubox/utils.h>
  23
  24
  25 struct blob_attr *dump = NULL;
  26
  27 enum {
  28         DUMP_ATTR_INTERFACE,
  29         DUMP_ATTR_MAX
  30 };
  31
  32 static const struct blobmsg_policy dump_attrs[DUMP_ATTR_MAX] = {
  33         [DUMP_ATTR_INTERFACE] = { .name = "interface", .type = BLOBMSG_TYPE_ARRAY },
  34 };
  35
  36
  37 enum {
  38         IFACE_ATTR_INTERFACE,
  39         IFACE_ATTR_PREFIX,
  40         IFACE_ATTR_ADDRESS,
  41         IFACE_ATTR_MAX,
  42 };
  43
  44 static const struct blobmsg_policy iface_attrs[IFACE_ATTR_MAX] = {
  45         [IFACE_ATTR_INTERFACE] = { .name = "interface", .type = BLOBMSG_TYPE_STRING },
  46         [IFACE_ATTR_PREFIX] = { .name = "ipv6-prefix", .type = BLOBMSG_TYPE_ARRAY },
  47         [IFACE_ATTR_ADDRESS] = { .name = "ipv6-address", .type = BLOBMSG_TYPE_ARRAY },
  48 };
  49
  50
  51 enum {
  52         PREFIX_ATTR_ADDRESS,
  53         PREFIX_ATTR_MASK,
  54         PREFIX_ATTR_MAX,
  55 };
  56
  57 static const struct blobmsg_policy prefix_attrs[PREFIX_ATTR_MAX] = {
  58         [PREFIX_ATTR_ADDRESS] = { .name = "address", .type = BLOBMSG_TYPE_STRING },
  59         [PREFIX_ATTR_MASK] = { .name = "mask", .type = BLOBMSG_TYPE_INT32 },
  60 };
  61
  62 static int bmemcmp(const void *av, const void *bv, size_t bits)
  63 {
  64         const uint8_t *a = av, *b = bv;
  65         size_t bytes = bits / 8;
  66         bits %= 8;
  67
  68         int res = memcmp(a, b, bytes);
  69         if (res == 0 && bits > 0)
  70                 res = (a[bytes] >> (8 - bits)) - (b[bytes] >> (8 - bits));
  71
  72         return res;
  73 }
  74
  75 static void bmemcpy(void *av, const void *bv, size_t bits)
  76 {
  77         uint8_t *a = av;
  78         const uint8_t *b = bv;
  79
  80         size_t bytes = bits / 8;
  81         bits %= 8;
  82         memcpy(a, b, bytes);
  83
  84         if (bits > 0) {
  85                 uint8_t mask = (1 << (8 - bits)) - 1;
  86                 a[bytes] = (a[bytes] & mask) | ((~mask) & b[bytes]);
  87         }
  88 }
  89
  90 static void bmemcpys64(void *av, const void *bv, size_t frombits, size_t nbits)
  91 {
  92         uint64_t buf = 0;
  93         const uint8_t *b = bv;
  94         size_t frombyte = frombits / 8, tobyte = (frombits + nbits) / 8;
  95
  96         memcpy(&buf, &b[frombyte], tobyte - frombyte + 1);
  97         buf = cpu_to_be64(be64_to_cpu(buf) << (frombits % 8));
  98
  99         bmemcpy(av, &buf, nbits);
 100 }
 101
 102 static void handle_dump(struct ubus_request *req __attribute__((unused)),
 103                 int type __attribute__((unused)), struct blob_attr *msg)
 104 {
 105         struct blob_attr *tb[DUMP_ATTR_INTERFACE];
 106         blobmsg_parse(dump_attrs, DUMP_ATTR_MAX, tb, blob_data(msg), blob_len(msg));
 107
 108         if (!tb[DUMP_ATTR_INTERFACE])
 109                 return;
 110
 111         dump = blob_memdup(tb[DUMP_ATTR_INTERFACE]);
 112 }
 113
 114 static void match_prefix(int *pdlen, struct in6_addr *pd, struct blob_attr *cur,
 115                 const struct in6_addr *ipv6prefix, int prefix6len)
 116 {
 117         struct blob_attr *d;
 118         unsigned drem;
 119
 120         if (!cur || blobmsg_type(cur) != BLOBMSG_TYPE_ARRAY || !blobmsg_check_attr(cur, NULL))
 121                 return;
 122
 123         blobmsg_for_each_attr(d, cur, drem) {
 124                 struct blob_attr *ptb[PREFIX_ATTR_MAX];
 125                 blobmsg_parse(prefix_attrs, PREFIX_ATTR_MAX, ptb,
 126                                 blobmsg_data(d), blobmsg_data_len(d));
 127
 128                 if (!ptb[PREFIX_ATTR_ADDRESS] || !ptb[PREFIX_ATTR_MASK])
 129                         continue;
 130
 131                 struct in6_addr prefix = IN6ADDR_ANY_INIT;
 132                 int mask = blobmsg_get_u32(ptb[PREFIX_ATTR_MASK]);
 133                 inet_pton(AF_INET6, blobmsg_get_string(ptb[PREFIX_ATTR_ADDRESS]), &prefix);
 134
 135                 // lw4over6 /128-address-as-PD matching madness workaround
 136                 if (mask == 128)
 137                         mask = 64;
 138
 139                 if (*pdlen < mask && mask >= prefix6len &&
 140                                 !bmemcmp(&prefix, ipv6prefix, prefix6len)) {
 141                         bmemcpy(pd, &prefix, mask);
 142                         *pdlen = mask;
 143                 }
 144         }
 145 }
 146
 147 enum {
 148         OPT_TYPE,
 149         OPT_FMR,
 150         OPT_EALEN,
 151         OPT_PREFIX4LEN,
 152         OPT_PREFIX6LEN,
 153         OPT_IPV6PREFIX,
 154         OPT_IPV4PREFIX,
 155         OPT_OFFSET,
 156         OPT_PSIDLEN,
 157         OPT_PSID,
 158         OPT_BR,
 159         OPT_DMR,
 160         OPT_PD,
 161         OPT_PDLEN,
 162         OPT_MAX
 163 };
 164
 165 static char *const token[] = {
 166         [OPT_TYPE] = "type",
 167         [OPT_FMR] = "fmr",
 168         [OPT_EALEN] = "ealen",
 169         [OPT_PREFIX4LEN] = "prefix4len",
 170         [OPT_PREFIX6LEN] = "prefix6len",
 171         [OPT_IPV6PREFIX] = "ipv6prefix",
 172         [OPT_IPV4PREFIX] = "ipv4prefix",
 173         [OPT_OFFSET] = "offset",
 174         [OPT_PSIDLEN] = "psidlen",
 175         [OPT_PSID] = "psid",
 176         [OPT_BR] = "br",
 177         [OPT_DMR] = "dmr",
 178         [OPT_PD] = "pd",
 179         [OPT_PDLEN] = "pdlen",
 180         [OPT_MAX] = NULL
 181 };
 182
 183
 184 int main(int argc, char *argv[])
 185 {
 186         int status = 0;
 187         const char *iface = argv[1];
 188
 189         const char *legacy_env = getenv("LEGACY");
 190         bool legacy = legacy_env && atoi(legacy_env);
 191
 192
 193         if (argc < 3) {
 194                 fprintf(stderr, "Usage: %s <interface|*> <rule1> [rule2] [...]\n", argv[0]);
 195                 return 1;
 196         }
 197
 198         uint32_t network_interface;
 199         struct ubus_context *ubus = ubus_connect(NULL);
 200         if (ubus) {
 201                 ubus_lookup_id(ubus, "network.interface", &network_interface);
 202                 ubus_invoke(ubus, network_interface, "dump", NULL, handle_dump, NULL, 5000);
 203         }
 204
 205         int rulecnt = 0;
 206         for (int i = 2; i < argc; ++i) {
 207                 bool lw4o6 = false;
 208                 bool fmr = false;
 209                 int ealen = -1;
 210                 int addr4len = 32;
 211                 int prefix4len = 32;
 212                 int prefix6len = -1;
 213                 int pdlen = -1;
 214                 struct in_addr ipv4prefix = {INADDR_ANY};
 215                 struct in_addr ipv4addr = {INADDR_ANY};
 216                 struct in6_addr ipv6addr = IN6ADDR_ANY_INIT;
 217                 struct in6_addr ipv6prefix = IN6ADDR_ANY_INIT;
 218                 struct in6_addr pd = IN6ADDR_ANY_INIT;
 219                 int offset = -1;
 220                 int psidlen = -1;
 221                 int psid = -1;
 222                 uint16_t psid16 = 0;
 223                 const char *dmr = NULL;
 224                 const char *br = NULL;
 225
 226                 for (char *rule = strdup(argv[i]); *rule; ) {
 227                         char *value;
 228                         int intval;
 229                         int idx = getsubopt(&rule, token, &value);
 230                         errno = 0;
 231
 232                         if (idx == OPT_TYPE) {
 233                                 lw4o6 = (value && !strcmp(value, "lw4o6"));
 234                         } else if (idx == OPT_FMR) {
 235                                 fmr = true;
 236                         } else if (idx == OPT_EALEN && (intval = strtoul(value, NULL, 0)) <= 48 && !errno) {
 237                                 ealen = intval;
 238                         } else if (idx == OPT_PREFIX4LEN && (intval = strtoul(value, NULL, 0)) <= 32 && !errno) {
 239                                 prefix4len = intval;
 240                         } else if (idx == OPT_PREFIX6LEN && (intval = strtoul(value, NULL, 0)) <= 112 && !errno) {
 241                                 prefix6len = intval;
 242                         } else if (idx == OPT_IPV4PREFIX && inet_pton(AF_INET, value, &ipv4prefix) == 1) {
 243                                 // dummy
 244                         } else if (idx == OPT_IPV6PREFIX && inet_pton(AF_INET6, value, &ipv6prefix) == 1) {
 245                                 // dummy
 246                         } else if (idx == OPT_PD && inet_pton(AF_INET6, value, &pd) == 1) {
 247                                 // dummy
 248                         } else if (idx == OPT_OFFSET && (intval = strtoul(value, NULL, 0)) <= 16 && !errno) {
 249                                 offset = intval;
 250                         } else if (idx == OPT_PSIDLEN && (intval = strtoul(value, NULL, 0)) <= 16 && !errno) {
 251                                 psidlen = intval;
 252                         } else if (idx == OPT_PDLEN && (intval = strtoul(value, NULL, 0)) <= 128 && !errno) {
 253                                 pdlen = intval;
 254                         } else if (idx == OPT_PSID && (intval = strtoul(value, NULL, 0)) <= 65535 && !errno) {
 255                                 psid = intval;
 256                         } else if (idx == OPT_DMR) {
 257                                 dmr = value;
 258                         } else if (idx == OPT_BR) {
 259                                 br = value;
 260                         } else {
 261                                 if (idx == -1 || idx >= OPT_MAX)
 262                                         fprintf(stderr, "Skipped invalid option: %s\n", value);
 263                                 else
 264                                         fprintf(stderr, "Skipped invalid value %s for option %s\n",
 265                                                         value, token[idx]);
 266                         }
 267                 }
 268
 269                 if (offset < 0)
 270                         offset = (lw4o6) ? 0 : (legacy) ? 4 : 6;
 271
 272                 // LW4over6 doesn't have an EALEN and has no psid-autodetect
 273                 if (lw4o6) {
 274                         if (psidlen < 0)
 275                                 psidlen = 0;
 276
 277                         ealen = psidlen;
 278                 }
 279
 280                 // Find PD
 281                 if (pdlen < 0) {
 282                         struct blob_attr *c;
 283                         unsigned rem;
 284                         blobmsg_for_each_attr(c, dump, rem) {
 285                                 struct blob_attr *tb[IFACE_ATTR_MAX];
 286                                 blobmsg_parse(iface_attrs, IFACE_ATTR_MAX, tb, blobmsg_data(c), blobmsg_data_len(c));
 287
 288                                 if (!tb[IFACE_ATTR_INTERFACE] || (strcmp(argv[1], "*") && strcmp(argv[1],
 289                                                 blobmsg_get_string(tb[IFACE_ATTR_INTERFACE]))))
 290                                         continue;
 291
 292                                 match_prefix(&pdlen, &pd, tb[IFACE_ATTR_PREFIX], &ipv6prefix, prefix6len);
 293
 294                                 if (lw4o6)
 295                                         match_prefix(&pdlen, &pd, tb[IFACE_ATTR_ADDRESS], &ipv6prefix, prefix6len);
 296
 297                                 if (pdlen >= 0) {
 298                                         iface = blobmsg_get_string(tb[IFACE_ATTR_INTERFACE]);
 299                                         break;
 300                                 }
 301                         }
 302                 }
 303
 304                 if (ealen < 0 && pdlen >= 0)
 305                         ealen = pdlen - prefix6len;
 306
 307                 if (psidlen <= 0) {
 308                         psidlen = ealen - (32 - prefix4len);
 309                         psid = -1;
 310                 }
 311
 312                 if (psid < 0 && psidlen <= 16 && psidlen >= 0 && pdlen >= 0 && ealen >= psidlen) {
 313                         bmemcpys64(&psid16, &pd, prefix6len + ealen - psidlen, psidlen);
 314                         psid = be16_to_cpu(psid16);
 315                 }
 316
 317                 psid = psid >> (16 - psidlen);
 318                 psid16 = cpu_to_be16(psid);
 319                 psid = psid << (16 - psidlen);
 320
 321                 if (prefix4len < 0 || prefix6len < 0 || ealen < 0 || ealen < psidlen) {
 322                         fprintf(stderr, "Skipping invalid or incomplete rule: %s\n", argv[i]);
 323                         status = 1;
 324                         continue;
 325                 }
 326
 327                 if ((pdlen >= 0 || ealen == psidlen) && ealen >= psidlen) {
 328                         bmemcpys64(&ipv4addr, &pd, prefix6len, ealen - psidlen);
 329                         ipv4addr.s_addr = htonl(ntohl(ipv4addr.s_addr) >> prefix4len);
 330                         bmemcpy(&ipv4addr, &ipv4prefix, prefix4len);
 331
 332                         if (prefix4len + ealen < 32)
 333                                 addr4len = prefix4len + ealen;
 334                 }
 335
 336                 if (pdlen < 0 && !fmr) {
 337                         fprintf(stderr, "Skipping non-FMR without matching PD: %s\n", argv[i]);
 338                         status = 1;
 339                         continue;
 340                 } else if (pdlen >= 0) {
 341                         size_t v4offset = (legacy) ? 9 : 10;
 342                         memcpy(&ipv6addr.s6_addr[v4offset], &ipv4addr, 4);
 343                         memcpy(&ipv6addr.s6_addr[v4offset + 4], &psid16, 2);
 344                         bmemcpy(&ipv6addr, &pd, pdlen);
 345                 }
 346
 347                 ++rulecnt;
 348                 char ipv4addrbuf[INET_ADDRSTRLEN];
 349                 char ipv4prefixbuf[INET_ADDRSTRLEN];
 350                 char ipv6prefixbuf[INET6_ADDRSTRLEN];
 351                 char ipv6addrbuf[INET6_ADDRSTRLEN];
 352                 char pdbuf[INET6_ADDRSTRLEN];
 353
 354                 inet_ntop(AF_INET, &ipv4addr, ipv4addrbuf, sizeof(ipv4addrbuf));
 355                 inet_ntop(AF_INET, &ipv4prefix, ipv4prefixbuf, sizeof(ipv4prefixbuf));
 356                 inet_ntop(AF_INET6, &ipv6prefix, ipv6prefixbuf, sizeof(ipv6prefixbuf));
 357                 inet_ntop(AF_INET6, &ipv6addr, ipv6addrbuf, sizeof(ipv6addrbuf));
 358                 inet_ntop(AF_INET6, &pd, pdbuf, sizeof(pdbuf));
 359
 360                 printf("RULE_%d_FMR=%d\n", rulecnt, fmr);
 361                 printf("RULE_%d_EALEN=%d\n", rulecnt, ealen);
 362                 printf("RULE_%d_PSIDLEN=%d\n", rulecnt, psidlen);
 363                 printf("RULE_%d_OFFSET=%d\n", rulecnt, offset);
 364                 printf("RULE_%d_PREFIX4LEN=%d\n", rulecnt, prefix4len);
 365                 printf("RULE_%d_PREFIX6LEN=%d\n", rulecnt, prefix6len);
 366                 printf("RULE_%d_IPV4PREFIX=%s\n", rulecnt, ipv4prefixbuf);
 367                 printf("RULE_%d_IPV6PREFIX=%s\n", rulecnt, ipv6prefixbuf);
 368
 369                 if (pdlen >= 0) {
 370                         printf("RULE_%d_IPV6PD=%s\n", rulecnt, pdbuf);
 371                         printf("RULE_%d_PD6LEN=%d\n", rulecnt, pdlen);
 372                         printf("RULE_%d_PD6IFACE=%s\n", rulecnt, iface);
 373                         printf("RULE_%d_IPV6ADDR=%s\n", rulecnt, ipv6addrbuf);
 374                         printf("RULE_BMR=%d\n", rulecnt);
 375                 }
 376
 377                 if (ipv4addr.s_addr) {
 378                         printf("RULE_%d_IPV4ADDR=%s\n", rulecnt, ipv4addrbuf);
 379                         printf("RULE_%d_ADDR4LEN=%d\n", rulecnt, addr4len);
 380                 }
 381
 382
 383                 if (psidlen > 0 && psid >= 0) {
 384                         printf("RULE_%d_PORTSETS='", rulecnt);
 385                         for (int k = (offset) ? 1 : 0; k < (1 << offset); ++k) {
 386                                 int start = (k << (16 - offset)) | (psid >> offset);
 387                                 int end = start + (1 << (16 - offset - psidlen)) - 1;
 388
 389                                 if (start == 0)
 390                                         start = 1;
 391
 392                                 if (start <= end)
 393                                         printf("%d-%d ", start, end);
 394                         }
 395                         printf("'\n");
 396                 }
 397
 398                 if (dmr)
 399                         printf("RULE_%d_DMR=%s\n", rulecnt, dmr);
 400
 401                 if (br)
 402                         printf("RULE_%d_BR=%s\n", rulecnt, br);
 403         }
 404
 405         printf("RULE_COUNT=%d\n", rulecnt);
 406         return status;
 407 }