libs/luci-lib-ip/src/ip.c

   1 /*
   2 Copyright 2015 Jo-Philipp Wich <jow@openwrt.org>
   3
   4 Licensed under the Apache License, Version 2.0 (the "License");
   5 you may not use this file except in compliance with the License.
   6 You may obtain a copy of the License at
   7
   8         http://www.apache.org/licenses/LICENSE-2.0
   9
  10 Unless required by applicable law or agreed to in writing, software
  11 distributed under the License is distributed on an "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 See the License for the specific language governing permissions and
  14 limitations under the License.
  15 */
  16
  17 #define _GNU_SOURCE
  18
  19 #include <stdio.h>
  20 #include <stdint.h>
  21 #include <stdbool.h>
  22 #include <unistd.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <limits.h>
  26
  27 #include <lua.h>
  28 #include <lualib.h>
  29 #include <lauxlib.h>
  30
  31 #include <net/if.h>
  32 #include <netinet/ether.h>
  33 #include <arpa/inet.h>
  34 #include <netlink/msg.h>
  35 #include <netlink/attr.h>
  36 #include <netlink/socket.h>
  37 #include <linux/rtnetlink.h>
  38
  39 #define LUCI_IP "luci.ip"
  40 #define LUCI_IP_CIDR "luci.ip.cidr"
  41
  42 #define RTA_INT(x)      (*(int *)RTA_DATA(x))
  43 #define RTA_U32(x)      (*(uint32_t *)RTA_DATA(x))
  44
  45 static int hz = 0;
  46 static struct nl_sock *sock = NULL;
  47
  48 typedef struct {
  49         union {
  50                 struct in_addr v4;
  51                 struct in6_addr v6;
  52         } addr;
  53         int len;
  54         int bits;
  55         int family;
  56         bool exact;
  57 } cidr_t;
  58
  59 struct dump_filter {
  60         bool get;
  61         int family;
  62         int iif;
  63         int oif;
  64         int type;
  65         int scope;
  66         int proto;
  67         int table;
  68         cidr_t gw;
  69         cidr_t from;
  70         cidr_t src;
  71         cidr_t dst;
  72         struct ether_addr mac;
  73 };
  74
  75 struct dump_state {
  76         int index;
  77         int pending;
  78         int callback;
  79         struct lua_State *L;
  80         struct dump_filter *filter;
  81 };
  82
  83
  84 static int _cidr_new(lua_State *L, int index, int family, bool mask);
  85
  86 static cidr_t *L_checkcidr (lua_State *L, int index, cidr_t *p)
  87 {
  88         if (lua_type(L, index) == LUA_TUSERDATA)
  89                 return luaL_checkudata(L, index, LUCI_IP_CIDR);
  90
  91         if (_cidr_new(L, index, p ? p->family : 0, false))
  92                 return lua_touserdata(L, -1);
  93
  94         luaL_error(L, "Invalid operand");
  95         return NULL;
  96 }
  97
  98 static bool parse_mask(int family, const char *mask, int *bits)
  99 {
 100         char *e;
 101         struct in_addr m;
 102         struct in6_addr m6;
 103
 104         if (family == AF_INET && inet_pton(AF_INET, mask, &m))
 105         {
 106                 for (*bits = 0, m.s_addr = ntohl(m.s_addr);
 107                          *bits < 32 && (m.s_addr << *bits) & 0x80000000;
 108                          ++*bits);
 109         }
 110         else if (family == AF_INET6 && inet_pton(AF_INET6, mask, &m6))
 111         {
 112                 for (*bits = 0;
 113                          *bits < 128 && (m6.s6_addr[*bits / 8] << (*bits % 8)) & 128;
 114                          ++*bits);
 115         }
 116         else
 117         {
 118                 *bits = strtoul(mask, &e, 10);
 119
 120                 if (e == mask || *e != 0 || *bits > ((family == AF_INET) ? 32 : 128))
 121                         return false;
 122         }
 123
 124         return true;
 125 }
 126
 127 static bool parse_cidr(const char *dest, cidr_t *pp)
 128 {
 129         char *p, *a, buf[INET6_ADDRSTRLEN * 2 + 2];
 130         uint8_t bitlen = 0;
 131
 132         strncpy(buf, dest, sizeof(buf) - 1);
 133
 134         a = buf;
 135         p = strchr(buf, '/');
 136
 137         if (p)
 138                 *p++ = 0;
 139
 140         if (!strncasecmp(buf, "::ffff:", 7))
 141                 a += 7;
 142
 143         if (inet_pton(AF_INET, a, &pp->addr.v4))
 144         {
 145                 bitlen = 32;
 146                 pp->family = AF_INET;
 147                 pp->len = sizeof(struct in_addr);
 148         }
 149         else if (inet_pton(AF_INET6, a, &pp->addr.v6))
 150         {
 151                 bitlen = 128;
 152                 pp->family = AF_INET6;
 153                 pp->len = sizeof(struct in6_addr);
 154         }
 155         else
 156                 return false;
 157
 158         if (p)
 159         {
 160                 if (!parse_mask(pp->family, p, &pp->bits))
 161                         return false;
 162         }
 163         else
 164         {
 165                 pp->bits = bitlen;
 166         }
 167
 168         return true;
 169 }
 170
 171 static int L_getint(lua_State *L, int index, const char *name)
 172 {
 173         int rv = 0;
 174
 175         lua_getfield(L, index, name);
 176
 177         if (lua_type(L, -1) == LUA_TNUMBER)
 178                 rv = lua_tonumber(L, -1);
 179
 180         lua_pop(L, 1);
 181
 182         return rv;
 183 }
 184
 185 static const char * L_getstr(lua_State *L, int index, const char *name)
 186 {
 187         const char *rv = NULL;
 188
 189         lua_getfield(L, index, name);
 190
 191         if (lua_type(L, -1) == LUA_TSTRING)
 192                 rv = lua_tostring(L, -1);
 193
 194         lua_pop(L, 1);
 195
 196         return rv;
 197 }
 198
 199 static void L_setint(struct lua_State *L, const char *name, uint32_t n)
 200 {
 201         lua_pushinteger(L, n);
 202         lua_setfield(L, -2, name);
 203 }
 204
 205 static void L_setbool(struct lua_State *L, const char *name, bool val)
 206 {
 207         lua_pushboolean(L, val);
 208         lua_setfield(L, -2, name);
 209 }
 210
 211 static void L_setaddr(struct lua_State *L, const char *name,
 212                       int family, void *addr, int bits)
 213 {
 214         cidr_t *p;
 215
 216         if (!addr)
 217                 return;
 218
 219         p = lua_newuserdata(L, sizeof(*p));
 220
 221         if (!p)
 222                 return;
 223
 224         if (family == AF_INET)
 225         {
 226                 p->family = AF_INET;
 227                 p->bits = (bits < 0) ? 32 : bits;
 228                 p->len = sizeof(p->addr.v4);
 229                 p->addr.v4 = *(struct in_addr *)addr;
 230         }
 231         else
 232         {
 233                 p->family = AF_INET6;
 234                 p->bits = (bits < 0) ? 128 : bits;
 235                 p->len = sizeof(p->addr.v6);
 236                 p->addr.v6 = *(struct in6_addr *)addr;
 237         }
 238
 239         luaL_getmetatable(L, LUCI_IP_CIDR);
 240         lua_setmetatable(L, -2);
 241         lua_setfield(L, -2, name);
 242 }
 243
 244 static void L_setstr(struct lua_State *L, const char *name, const char *val)
 245 {
 246         lua_pushstring(L, val);
 247         lua_setfield(L, -2, name);
 248 }
 249
 250 static void L_setdev(struct lua_State *L, const char *name,
 251                      struct nlattr *attr)
 252 {
 253         char buf[32];
 254
 255         if (if_indextoname(RTA_INT(attr), buf))
 256                 L_setstr(L, name, buf);
 257 }
 258
 259 static int L_checkbits(lua_State *L, int index, cidr_t *p)
 260 {
 261         int bits;
 262
 263         if (lua_gettop(L) < index || lua_isnil(L, index))
 264         {
 265                 bits = p->bits;
 266         }
 267         else if (lua_type(L, index) == LUA_TNUMBER)
 268         {
 269                 bits = lua_tointeger(L, index);
 270
 271                 if (bits < 0 || bits > ((p->family == AF_INET) ? 32 : 128))
 272                         return luaL_error(L, "Invalid prefix size");
 273         }
 274         else if (lua_type(L, index) == LUA_TSTRING)
 275         {
 276                 if (!parse_mask(p->family, lua_tostring(L, index), &bits))
 277                         return luaL_error(L, "Invalid netmask format");
 278         }
 279         else
 280         {
 281                 return luaL_error(L, "Invalid data type");
 282         }
 283
 284         return bits;
 285 }
 286
 287 static int _cidr_new(lua_State *L, int index, int family, bool mask)
 288 {
 289         uint32_t n;
 290         const char *addr;
 291         cidr_t cidr = { }, *cidrp;
 292
 293         if (lua_type(L, index) == LUA_TNUMBER)
 294         {
 295                 n = htonl(lua_tointeger(L, index));
 296
 297                 if (family == AF_INET6)
 298                 {
 299                         cidr.family = AF_INET6;
 300                         cidr.bits = 128;
 301                         cidr.len = sizeof(cidr.addr.v6);
 302                         cidr.addr.v6.s6_addr[12] = n;
 303                         cidr.addr.v6.s6_addr[13] = (n >> 8);
 304                         cidr.addr.v6.s6_addr[14] = (n >> 16);
 305                         cidr.addr.v6.s6_addr[15] = (n >> 24);
 306                 }
 307                 else
 308                 {
 309                         cidr.family = AF_INET;
 310                         cidr.bits = 32;
 311                         cidr.len = sizeof(cidr.addr.v4);
 312                         cidr.addr.v4.s_addr = n;
 313                 }
 314         }
 315         else
 316         {
 317                 addr = luaL_checkstring(L, index);
 318
 319                 if (!parse_cidr(addr, &cidr))
 320                         return 0;
 321
 322                 if (family && cidr.family != family)
 323                         return 0;
 324
 325                 if (mask)
 326                         cidr.bits = L_checkbits(L, index + 1, &cidr);
 327         }
 328
 329         if (!(cidrp = lua_newuserdata(L, sizeof(*cidrp))))
 330                 return 0;
 331
 332         *cidrp = cidr;
 333         luaL_getmetatable(L, LUCI_IP_CIDR);
 334         lua_setmetatable(L, -2);
 335         return 1;
 336 }
 337
 338 static int cidr_new(lua_State *L)
 339 {
 340         return _cidr_new(L, 1, 0, true);
 341 }
 342
 343 static int cidr_ipv4(lua_State *L)
 344 {
 345         return _cidr_new(L, 1, AF_INET, true);
 346 }
 347
 348 static int cidr_ipv6(lua_State *L)
 349 {
 350         return _cidr_new(L, 1, AF_INET6, true);
 351 }
 352
 353 static int cidr_is4(lua_State *L)
 354 {
 355         cidr_t *p = L_checkcidr(L, 1, NULL);
 356
 357         lua_pushboolean(L, p->family == AF_INET);
 358         return 1;
 359 }
 360
 361 static int cidr_is4rfc1918(lua_State *L)
 362 {
 363         cidr_t *p = L_checkcidr(L, 1, NULL);
 364         uint32_t a = htonl(p->addr.v4.s_addr);
 365
 366         lua_pushboolean(L, (p->family == AF_INET &&
 367                             ((a >= 0x0A000000 && a <= 0x0AFFFFFF) ||
 368                              (a >= 0xAC100000 && a <= 0xAC1FFFFF) ||
 369                              (a >= 0xC0A80000 && a <= 0xC0A8FFFF))));
 370
 371         return 1;
 372 }
 373
 374 static int cidr_is4linklocal(lua_State *L)
 375 {
 376         cidr_t *p = L_checkcidr(L, 1, NULL);
 377         uint32_t a = htonl(p->addr.v4.s_addr);
 378
 379         lua_pushboolean(L, (p->family == AF_INET &&
 380                             a >= 0xA9FE0000 &&
 381                             a <= 0xA9FEFFFF));
 382
 383         return 1;
 384 }
 385
 386 static int cidr_is6(lua_State *L)
 387 {
 388         cidr_t *p = L_checkcidr(L, 1, NULL);
 389
 390         lua_pushboolean(L, p->family == AF_INET6);
 391         return 1;
 392 }
 393
 394 static int cidr_is6linklocal(lua_State *L)
 395 {
 396         cidr_t *p = L_checkcidr(L, 1, NULL);
 397
 398         lua_pushboolean(L, (p->family == AF_INET6 &&
 399                             p->addr.v6.s6_addr[0] == 0xFE &&
 400                             p->addr.v6.s6_addr[1] >= 0x80 &&
 401                             p->addr.v6.s6_addr[1] <= 0xBF));
 402
 403         return 1;
 404 }
 405
 406 static int _cidr_cmp(lua_State *L)
 407 {
 408         cidr_t *a = L_checkcidr(L, 1, NULL);
 409         cidr_t *b = L_checkcidr(L, 2, NULL);
 410
 411         if (a->family != b->family)
 412                 return (a->family - b->family);
 413
 414         return memcmp(&a->addr.v6, &b->addr.v6, a->len);
 415 }
 416
 417 static int cidr_lower(lua_State *L)
 418 {
 419         lua_pushboolean(L, _cidr_cmp(L) < 0);
 420         return 1;
 421 }
 422
 423 static int cidr_higher(lua_State *L)
 424 {
 425         lua_pushboolean(L, _cidr_cmp(L) > 0);
 426         return 1;
 427 }
 428
 429 static int cidr_equal(lua_State *L)
 430 {
 431         lua_pushboolean(L, _cidr_cmp(L) == 0);
 432         return 1;
 433 }
 434
 435 static int cidr_lower_equal(lua_State *L)
 436 {
 437         lua_pushboolean(L, _cidr_cmp(L) <= 0);
 438         return 1;
 439 }
 440
 441 static int cidr_prefix(lua_State *L)
 442 {
 443         cidr_t *p = L_checkcidr(L, 1, NULL);
 444         int bits = L_checkbits(L, 2, p);
 445
 446         p->bits = bits;
 447         lua_pushinteger(L, p->bits);
 448         return 1;
 449 }
 450
 451 static void _apply_mask(cidr_t *p, int bits, bool inv)
 452 {
 453         uint8_t b, i;
 454
 455         if (bits <= 0)
 456         {
 457                 memset(&p->addr.v6, inv * 0xFF, p->len);
 458         }
 459         else if (p->family == AF_INET && bits <= 32)
 460         {
 461                 if (inv)
 462                         p->addr.v4.s_addr |= ntohl((1 << (32 - bits)) - 1);
 463                 else
 464                         p->addr.v4.s_addr &= ntohl(~((1 << (32 - bits)) - 1));
 465         }
 466         else if (p->family == AF_INET6 && bits <= 128)
 467         {
 468                 for (i = 0; i < sizeof(p->addr.v6.s6_addr); i++)
 469                 {
 470                         b = (bits > 8) ? 8 : bits;
 471                         if (inv)
 472                                 p->addr.v6.s6_addr[i] |= ~((uint8_t)(0xFF << (8 - b)));
 473                         else
 474                                 p->addr.v6.s6_addr[i] &= (uint8_t)(0xFF << (8 - b));
 475                         bits -= b;
 476                 }
 477         }
 478 }
 479
 480 static int cidr_network(lua_State *L)
 481 {
 482         cidr_t *p1 = L_checkcidr(L, 1, NULL), *p2;
 483         int bits = L_checkbits(L, 2, p1);
 484
 485         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 486                 return 0;
 487
 488         *p2 = *p1;
 489         p2->bits = (p1->family == AF_INET) ? 32 : 128;
 490         _apply_mask(p2, bits, false);
 491
 492         luaL_getmetatable(L, LUCI_IP_CIDR);
 493         lua_setmetatable(L, -2);
 494         return 1;
 495 }
 496
 497 static int cidr_host(lua_State *L)
 498 {
 499         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 500         cidr_t *p2 = lua_newuserdata(L, sizeof(*p2));
 501
 502         if (!p2)
 503                 return 0;
 504
 505         *p2 = *p1;
 506         p2->bits = (p1->family == AF_INET) ? 32 : 128;
 507
 508         luaL_getmetatable(L, LUCI_IP_CIDR);
 509         lua_setmetatable(L, -2);
 510         return 1;
 511 }
 512
 513 static int cidr_mask(lua_State *L)
 514 {
 515         cidr_t *p1 = L_checkcidr(L, 1, NULL), *p2;
 516         int bits = L_checkbits(L, 2, p1);
 517
 518         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 519                 return 0;
 520
 521         p2->bits = (p1->family == AF_INET) ? 32 : 128;
 522         p2->family = p1->family;
 523
 524         memset(&p2->addr.v6.s6_addr, 0xFF, sizeof(p2->addr.v6.s6_addr));
 525         _apply_mask(p2, bits, false);
 526
 527         luaL_getmetatable(L, LUCI_IP_CIDR);
 528         lua_setmetatable(L, -2);
 529         return 1;
 530 }
 531
 532 static int cidr_broadcast(lua_State *L)
 533 {
 534         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 535         cidr_t *p2;
 536         int bits = L_checkbits(L, 2, p1);
 537
 538         if (p1->family == AF_INET6)
 539                 return 0;
 540
 541         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 542                 return 0;
 543
 544         *p2 = *p1;
 545         p2->bits = (p1->family == AF_INET) ? 32 : 128;
 546         _apply_mask(p2, bits, true);
 547
 548         luaL_getmetatable(L, LUCI_IP_CIDR);
 549         lua_setmetatable(L, -2);
 550         return 1;
 551 }
 552
 553 static int cidr_contains(lua_State *L)
 554 {
 555         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 556         cidr_t *p2 = L_checkcidr(L, 2, NULL);
 557         cidr_t a = *p1, b = *p2;
 558         bool rv = false;
 559
 560         if (p1->family == p2->family && p1->bits <= p2->bits)
 561         {
 562                 _apply_mask(&a, p1->bits, false);
 563                 _apply_mask(&b, p1->bits, false);
 564
 565                 rv = !memcmp(&a.addr.v6, &b.addr.v6, a.len);
 566         }
 567
 568         lua_pushboolean(L, rv);
 569         return 1;
 570 }
 571
 572 #define S6_BYTE(a, i) \
 573         (a)->addr.v6.s6_addr[sizeof((a)->addr.v6.s6_addr) - (i) - 1]
 574
 575 static int _cidr_add_sub(lua_State *L, bool add)
 576 {
 577         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 578         cidr_t *p2 = L_checkcidr(L, 2, p1);
 579         cidr_t r = *p1;
 580         bool inplace = lua_isboolean(L, 3) ? lua_toboolean(L, 3) : false;
 581         bool ok = true;
 582         uint8_t i, carry;
 583         uint32_t a, b;
 584
 585         if (p1->family == p2->family)
 586         {
 587                 if (p1->family == AF_INET6)
 588                 {
 589                         for (i = 0, carry = 0; i < sizeof(r.addr.v6.s6_addr); i++)
 590                         {
 591                                 if (add)
 592                                 {
 593                                         S6_BYTE(&r, i) = S6_BYTE(p1, i) + S6_BYTE(p2, i) + carry;
 594                                         carry = (S6_BYTE(p1, i) + S6_BYTE(p2, i) + carry) / 256;
 595                                 }
 596                                 else
 597                                 {
 598                                         S6_BYTE(&r, i) = (S6_BYTE(p1, i) - S6_BYTE(p2, i) - carry);
 599                                         carry = (S6_BYTE(p1, i) < (S6_BYTE(p2, i) + carry));
 600                                 }
 601                         }
 602
 603                         /* would over/underflow */
 604                         if (carry)
 605                         {
 606                                 memset(&r.addr.v6, add * 0xFF, sizeof(r.addr.v6));
 607                                 ok = false;
 608                         }
 609                 }
 610                 else
 611                 {
 612                         a = ntohl(p1->addr.v4.s_addr);
 613                         b = ntohl(p2->addr.v4.s_addr);
 614
 615                         /* would over/underflow */
 616                         if ((add && (UINT_MAX - a) < b) || (!add && a < b))
 617                         {
 618                                 r.addr.v4.s_addr = add * 0xFFFFFFFF;
 619                                 ok = false;
 620                         }
 621                         else
 622                         {
 623                                 r.addr.v4.s_addr = add ? htonl(a + b) : htonl(a - b);
 624                         }
 625                 }
 626         }
 627         else
 628         {
 629                 ok = false;
 630         }
 631
 632         if (inplace)
 633         {
 634                 *p1 = r;
 635                 lua_pushboolean(L, ok);
 636                 return 1;
 637         }
 638
 639         if (!(p1 = lua_newuserdata(L, sizeof(*p1))))
 640                 return 0;
 641
 642         *p1 = r;
 643
 644         luaL_getmetatable(L, LUCI_IP_CIDR);
 645         lua_setmetatable(L, -2);
 646         return 1;
 647 }
 648
 649 static int cidr_add(lua_State *L)
 650 {
 651         return _cidr_add_sub(L, true);
 652 }
 653
 654 static int cidr_sub(lua_State *L)
 655 {
 656         return _cidr_add_sub(L, false);
 657 }
 658
 659 static int cidr_minhost(lua_State *L)
 660 {
 661         cidr_t *p = L_checkcidr(L, 1, NULL);
 662         cidr_t r = *p;
 663         uint8_t i, rest, carry;
 664
 665         _apply_mask(&r, r.bits, false);
 666
 667         if (r.family == AF_INET6 && r.bits < 128)
 668         {
 669                 r.bits = 128;
 670
 671                 for (i = 0, carry = 1; i < sizeof(r.addr.v6.s6_addr); i++)
 672                 {
 673                         rest = (S6_BYTE(&r, i) + carry) > 255;
 674                         S6_BYTE(&r, i) += carry;
 675                         carry = rest;
 676                 }
 677         }
 678         else if (r.family == AF_INET && r.bits < 32)
 679         {
 680                 r.bits = 32;
 681                 r.addr.v4.s_addr = htonl(ntohl(r.addr.v4.s_addr) + 1);
 682         }
 683
 684         if (!(p = lua_newuserdata(L, sizeof(*p))))
 685                 return 0;
 686
 687         *p = r;
 688
 689         luaL_getmetatable(L, LUCI_IP_CIDR);
 690         lua_setmetatable(L, -2);
 691         return 1;
 692 }
 693
 694 static int cidr_maxhost(lua_State *L)
 695 {
 696         cidr_t *p = L_checkcidr(L, 1, NULL);
 697         cidr_t r = *p;
 698
 699         _apply_mask(&r, r.bits, true);
 700
 701         if (r.family == AF_INET && r.bits < 32)
 702         {
 703                 r.bits = 32;
 704                 r.addr.v4.s_addr = htonl(ntohl(r.addr.v4.s_addr) - 1);
 705         }
 706         else if (r.family == AF_INET6)
 707         {
 708                 r.bits = 128;
 709         }
 710
 711         if (!(p = lua_newuserdata(L, sizeof(*p))))
 712                 return 0;
 713
 714         *p = r;
 715
 716         luaL_getmetatable(L, LUCI_IP_CIDR);
 717         lua_setmetatable(L, -2);
 718         return 1;
 719 }
 720
 721 static int cidr_gc (lua_State *L)
 722 {
 723         return 0;
 724 }
 725
 726 static int cidr_tostring (lua_State *L)
 727 {
 728         char buf[INET6_ADDRSTRLEN];
 729         cidr_t *p = L_checkcidr(L, 1, NULL);
 730
 731         if ((p->family == AF_INET && p->bits < 32) ||
 732             (p->family == AF_INET6 && p->bits < 128))
 733         {
 734                 lua_pushfstring(L, "%s/%d",
 735                                 inet_ntop(p->family, &p->addr.v6, buf, sizeof(buf)),
 736                                                 p->bits);
 737         }
 738         else
 739         {
 740                 lua_pushstring(L, inet_ntop(p->family, &p->addr.v6, buf, sizeof(buf)));
 741         }
 742
 743         return 1;
 744 }
 745
 746 /*
 747  * route functions
 748  */
 749
 750 static bool diff_prefix(int family, void *addr, int bits, cidr_t *p)
 751 {
 752         uint8_t i, b, r;
 753         uint32_t m;
 754
 755         if (!p->family)
 756                 return false;
 757
 758         if (!addr || p->family != family || p->bits > bits)
 759                 return true;
 760
 761         if (family == AF_INET6)
 762         {
 763                 for (i = 0, r = p->bits; i < sizeof(struct in6_addr); i++)
 764                 {
 765                         b = r ? (0xFF << (8 - ((r > 8) ? 8 : r))) : 0;
 766
 767                         if ((((struct in6_addr *)addr)->s6_addr[i] & b) !=
 768                             (p->addr.v6.s6_addr[i] & b))
 769                                 return true;
 770
 771                         r -= ((r > 8) ? 8 : r);
 772                 }
 773         }
 774         else
 775         {
 776                 m = p->bits ? htonl(~((1 << (32 - p->bits)) - 1)) : 0;
 777
 778                 if ((((struct in_addr *)addr)->s_addr & m) != (p->addr.v4.s_addr & m))
 779                         return true;
 780         }
 781
 782         return (p->exact && p->bits != bits);
 783 }
 784
 785 static int cb_dump_route(struct nl_msg *msg, void *arg)
 786 {
 787         struct dump_state *s = arg;
 788         struct dump_filter *f = s->filter;
 789         struct nlmsghdr *hdr = nlmsg_hdr(msg);
 790         struct rtmsg *rt = NLMSG_DATA(hdr);
 791         struct nlattr *tb[RTA_MAX+1];
 792         struct in6_addr *src, *dst, *gw, *from, def = { };
 793         int iif, oif, bitlen;
 794         uint32_t table;
 795
 796         if (hdr->nlmsg_type != RTM_NEWROUTE ||
 797             (rt->rtm_family != AF_INET && rt->rtm_family != AF_INET6))
 798                 return NL_SKIP;
 799
 800         nlmsg_parse(hdr, sizeof(*rt), tb, RTA_MAX, NULL);
 801
 802         iif   = tb[RTA_IIF]     ? RTA_INT(tb[RTA_IIF])      : 0;
 803         oif   = tb[RTA_OIF]     ? RTA_INT(tb[RTA_OIF])      : 0;
 804         table = tb[RTA_TABLE]   ? RTA_U32(tb[RTA_TABLE])    : rt->rtm_table;
 805         from  = tb[RTA_SRC]     ? RTA_DATA(tb[RTA_SRC])     : NULL;
 806         src   = tb[RTA_PREFSRC] ? RTA_DATA(tb[RTA_PREFSRC]) : NULL;
 807         dst   = tb[RTA_DST]     ? RTA_DATA(tb[RTA_DST])     : &def;
 808         gw    = tb[RTA_GATEWAY] ? RTA_DATA(tb[RTA_GATEWAY]) : NULL;
 809
 810         bitlen = (rt->rtm_family == AF_INET6) ? 128 : 32;
 811
 812         if ((f->type   && rt->rtm_type     != f->type)   ||
 813             (f->family && rt->rtm_family   != f->family) ||
 814             (f->proto  && rt->rtm_protocol != f->proto)  ||
 815             (f->scope  && rt->rtm_scope    != f->scope)  ||
 816                 (f->iif    && iif              != f->iif)    ||
 817                 (f->oif    && oif              != f->oif)    ||
 818                 (f->table  && table            != f->table)  ||
 819             diff_prefix(rt->rtm_family, from, rt->rtm_src_len, &f->from) ||
 820             diff_prefix(rt->rtm_family, dst,  rt->rtm_dst_len, &f->dst)  ||
 821             diff_prefix(rt->rtm_family, gw,   bitlen, &f->gw)            ||
 822             diff_prefix(rt->rtm_family, src,  bitlen, &f->src))
 823                 goto out;
 824
 825         if (s->callback)
 826                 lua_pushvalue(s->L, 2);
 827
 828         lua_newtable(s->L);
 829
 830         L_setint(s->L, "type", rt->rtm_type);
 831         L_setint(s->L, "family", (rt->rtm_family == AF_INET) ? 4 : 6);
 832
 833         L_setaddr(s->L, "dest", rt->rtm_family, dst, rt->rtm_dst_len);
 834
 835         if (gw)
 836                 L_setaddr(s->L, "gw", rt->rtm_family, gw, -1);
 837
 838         if (from)
 839                 L_setaddr(s->L, "from", rt->rtm_family, from, rt->rtm_src_len);
 840
 841         if (iif)
 842                 L_setdev(s->L, "iif", tb[RTA_IIF]);
 843
 844         if (oif)
 845                 L_setdev(s->L, "dev", tb[RTA_OIF]);
 846
 847         L_setint(s->L, "table", table);
 848         L_setint(s->L, "proto", rt->rtm_protocol);
 849         L_setint(s->L, "scope", rt->rtm_scope);
 850
 851         if (src)
 852                 L_setaddr(s->L, "src", rt->rtm_family, src, -1);
 853
 854         if (tb[RTA_PRIORITY])
 855                 L_setint(s->L, "metric", RTA_U32(tb[RTA_PRIORITY]));
 856
 857         if (rt->rtm_family == AF_INET6 && tb[RTA_CACHEINFO])
 858         {
 859                 struct rta_cacheinfo *ci = RTA_DATA(tb[RTA_CACHEINFO]);
 860
 861                 if (ci->rta_expires)
 862                 {
 863                         if (ci->rta_expires)
 864                                 L_setint(s->L, "expires", ci->rta_expires / hz);
 865
 866                         if (ci->rta_error != 0)
 867                                 L_setint(s->L, "error", ci->rta_error);
 868                 }
 869         }
 870
 871         s->index++;
 872
 873         if (s->callback)
 874                 lua_call(s->L, 1, 0);
 875         else if (hdr->nlmsg_flags & NLM_F_MULTI)
 876                 lua_rawseti(s->L, -2, s->index);
 877
 878 out:
 879         s->pending = !!(hdr->nlmsg_flags & NLM_F_MULTI);
 880         return NL_SKIP;
 881 }
 882
 883 static int
 884 cb_done(struct nl_msg *msg, void *arg)
 885 {
 886         struct dump_state *s = arg;
 887         s->pending = 0;
 888         return NL_STOP;
 889 }
 890
 891 static int
 892 cb_error(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
 893 {
 894         struct dump_state *s = arg;
 895         s->pending = 0;
 896         return NL_STOP;
 897 }
 898
 899 static int _error(lua_State *L, int code, const char *msg)
 900 {
 901         lua_pushnil(L);
 902         lua_pushnumber(L, code ? code : errno);
 903         lua_pushstring(L, msg ? msg : strerror(errno));
 904
 905         return 3;
 906 }
 907
 908 static int _route_dump(lua_State *L, struct dump_filter *filter)
 909 {
 910         int flags = NLM_F_REQUEST;
 911         struct dump_state s = {
 912                 .L = L,
 913                 .pending = 1,
 914                 .index = 0,
 915                 .callback = lua_isfunction(L, 2),
 916                 .filter = filter
 917         };
 918
 919         if (!hz)
 920                 hz = sysconf(_SC_CLK_TCK);
 921
 922         if (!sock)
 923         {
 924                 sock = nl_socket_alloc();
 925                 if (!sock)
 926                         return _error(L, -1, "Out of memory");
 927
 928                 if (nl_connect(sock, NETLINK_ROUTE))
 929                         return _error(L, 0, NULL);
 930         }
 931
 932         struct nl_msg *msg;
 933         struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
 934         struct rtmsg rtm = {
 935                 .rtm_family = filter->family,
 936                 .rtm_dst_len = filter->dst.bits,
 937                 .rtm_src_len = filter->src.bits
 938         };
 939
 940         if (!filter->get)
 941                 flags |= NLM_F_DUMP;
 942
 943         msg = nlmsg_alloc_simple(RTM_GETROUTE, flags);
 944         if (!msg)
 945                 goto out;
 946
 947         nlmsg_append(msg, &rtm, sizeof(rtm), 0);
 948
 949         if (filter->get)
 950                 nla_put(msg, RTA_DST, filter->dst.len, &filter->dst.addr.v6);
 951
 952         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_dump_route, &s);
 953         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_done, &s);
 954         nl_cb_err(cb, NL_CB_CUSTOM, cb_error, &s);
 955
 956         nl_send_auto_complete(sock, msg);
 957
 958         if (!filter->get && !s.callback)
 959                 lua_newtable(L);
 960
 961         while (s.pending > 0)
 962                 nl_recvmsgs(sock, cb);
 963
 964         nlmsg_free(msg);
 965
 966 out:
 967         nl_cb_put(cb);
 968         return (s.callback == 0);
 969 }
 970
 971 static int route_get(lua_State *L)
 972 {
 973         struct dump_filter filter = { .get = true };
 974         const char *dest = luaL_checkstring(L, 1);
 975
 976         if (!parse_cidr(dest, &filter.dst))
 977                 return _error(L, -1, "Invalid destination");
 978
 979         filter.family = filter.dst.family;
 980
 981         return _route_dump(L, &filter);
 982 }
 983
 984 static int route_dump(lua_State *L)
 985 {
 986         const char *s;
 987         cidr_t p = { };
 988         struct dump_filter filter = { };
 989
 990         if (lua_type(L, 1) == LUA_TTABLE)
 991         {
 992                 filter.family = L_getint(L, 1, "family");
 993
 994                 if (filter.family == 4)
 995                         filter.family = AF_INET;
 996                 else if (filter.family == 6)
 997                         filter.family = AF_INET6;
 998                 else
 999                         filter.family = 0;
1000
1001                 if ((s = L_getstr(L, 1, "iif")) != NULL)
1002                         filter.iif = if_nametoindex(s);
1003
1004                 if ((s = L_getstr(L, 1, "oif")) != NULL)
1005                         filter.oif = if_nametoindex(s);
1006
1007                 filter.type = L_getint(L, 1, "type");
1008                 filter.scope = L_getint(L, 1, "scope");
1009                 filter.proto = L_getint(L, 1, "proto");
1010                 filter.table = L_getint(L, 1, "table");
1011
1012                 if ((s = L_getstr(L, 1, "gw")) != NULL && parse_cidr(s, &p))
1013                         filter.gw = p;
1014
1015                 if ((s = L_getstr(L, 1, "from")) != NULL && parse_cidr(s, &p))
1016                         filter.from = p;
1017
1018                 if ((s = L_getstr(L, 1, "src")) != NULL && parse_cidr(s, &p))
1019                         filter.src = p;
1020
1021                 if ((s = L_getstr(L, 1, "dest")) != NULL && parse_cidr(s, &p))
1022                         filter.dst = p;
1023
1024                 if ((s = L_getstr(L, 1, "from_exact")) != NULL && parse_cidr(s, &p))
1025                         filter.from = p, filter.from.exact = true;
1026
1027                 if ((s = L_getstr(L, 1, "dest_exact")) != NULL && parse_cidr(s, &p))
1028                         filter.dst = p, filter.dst.exact = true;
1029         }
1030
1031         return _route_dump(L, &filter);
1032 }
1033
1034
1035 static bool diff_macaddr(struct ether_addr *mac1, struct ether_addr *mac2)
1036 {
1037         struct ether_addr empty = { };
1038
1039         if (!memcmp(mac2, &empty, sizeof(empty)))
1040                 return false;
1041
1042         if (!mac1 || memcmp(mac1, mac2, sizeof(empty)))
1043                 return true;
1044
1045         return false;
1046 }
1047
1048 static int cb_dump_neigh(struct nl_msg *msg, void *arg)
1049 {
1050         char buf[32];
1051         struct ether_addr *mac;
1052         struct in6_addr *dst;
1053         struct dump_state *s = arg;
1054         struct dump_filter *f = s->filter;
1055         struct nlmsghdr *hdr = nlmsg_hdr(msg);
1056         struct ndmsg *nd = NLMSG_DATA(hdr);
1057         struct nlattr *tb[NDA_MAX+1];
1058         int bitlen;
1059
1060         if (hdr->nlmsg_type != RTM_NEWNEIGH ||
1061             (nd->ndm_family != AF_INET && nd->ndm_family != AF_INET6))
1062                 return NL_SKIP;
1063
1064         nlmsg_parse(hdr, sizeof(*nd), tb, NDA_MAX, NULL);
1065
1066         mac = tb[NDA_LLADDR] ? RTA_DATA(tb[NDA_LLADDR]) : NULL;
1067         dst = tb[NDA_DST]    ? RTA_DATA(tb[NDA_DST])    : NULL;
1068
1069         bitlen = (nd->ndm_family == AF_INET) ? 32 : 128;
1070
1071         if ((f->family && nd->ndm_family  != f->family) ||
1072             (f->iif    && nd->ndm_ifindex != f->iif) ||
1073                 (f->type   && !(f->type & nd->ndm_state)) ||
1074             diff_prefix(nd->ndm_family, dst, bitlen, &f->dst) ||
1075             diff_macaddr(mac, &f->mac))
1076                 goto out;
1077
1078         if (s->callback)
1079                 lua_pushvalue(s->L, 2);
1080
1081         lua_newtable(s->L);
1082
1083         L_setint(s->L, "family", (nd->ndm_family == AF_INET) ? 4 : 6);
1084         L_setstr(s->L, "dev", if_indextoname(nd->ndm_ifindex, buf));
1085
1086         L_setbool(s->L, "router", (nd->ndm_flags & NTF_ROUTER));
1087         L_setbool(s->L, "proxy", (nd->ndm_flags & NTF_PROXY));
1088
1089         L_setbool(s->L, "incomplete", (nd->ndm_state & NUD_INCOMPLETE));
1090         L_setbool(s->L, "reachable", (nd->ndm_state & NUD_REACHABLE));
1091         L_setbool(s->L, "stale", (nd->ndm_state & NUD_STALE));
1092         L_setbool(s->L, "delay", (nd->ndm_state & NUD_DELAY));
1093         L_setbool(s->L, "probe", (nd->ndm_state & NUD_PROBE));
1094         L_setbool(s->L, "failed", (nd->ndm_state & NUD_FAILED));
1095         L_setbool(s->L, "noarp", (nd->ndm_state & NUD_NOARP));
1096         L_setbool(s->L, "permanent", (nd->ndm_state & NUD_PERMANENT));
1097
1098         if (dst)
1099                 L_setaddr(s->L, "dest", nd->ndm_family, dst, -1);
1100
1101         if (mac)
1102         {
1103                 snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x",
1104                          mac->ether_addr_octet[0], mac->ether_addr_octet[1],
1105                          mac->ether_addr_octet[2], mac->ether_addr_octet[3],
1106                          mac->ether_addr_octet[4], mac->ether_addr_octet[5]);
1107
1108                 lua_pushstring(s->L, buf);
1109                 lua_setfield(s->L, -2, "mac");
1110         }
1111
1112         s->index++;
1113
1114         if (s->callback)
1115                 lua_call(s->L, 1, 0);
1116         else if (hdr->nlmsg_flags & NLM_F_MULTI)
1117                 lua_rawseti(s->L, -2, s->index);
1118
1119 out:
1120         s->pending = !!(hdr->nlmsg_flags & NLM_F_MULTI);
1121         return NL_SKIP;
1122 }
1123
1124 static int neighbor_dump(lua_State *L)
1125 {
1126         cidr_t p = { };
1127         const char *s;
1128         struct ether_addr *mac;
1129         struct dump_filter filter = { .type = 0xFF & ~NUD_NOARP };
1130         struct dump_state st = {
1131                 .callback = lua_isfunction(L, 2),
1132                 .pending = 1,
1133                 .filter = &filter,
1134                 .L = L
1135         };
1136
1137         if (lua_type(L, 1) == LUA_TTABLE)
1138         {
1139                 filter.family = L_getint(L, 1, "family");
1140
1141                 if (filter.family == 4)
1142                         filter.family = AF_INET;
1143                 else if (filter.family == 6)
1144                         filter.family = AF_INET6;
1145                 else
1146                         filter.family = 0;
1147
1148                 if ((s = L_getstr(L, 1, "dev")) != NULL)
1149                         filter.iif = if_nametoindex(s);
1150
1151                 if ((s = L_getstr(L, 1, "dest")) != NULL && parse_cidr(s, &p))
1152                         filter.dst = p;
1153
1154                 if ((s = L_getstr(L, 1, "mac")) != NULL &&
1155                     (mac = ether_aton(s)) != NULL)
1156                         filter.mac = *mac;
1157         }
1158
1159         if (!sock)
1160         {
1161                 sock = nl_socket_alloc();
1162                 if (!sock)
1163                         return _error(L, -1, "Out of memory");
1164
1165                 if (nl_connect(sock, NETLINK_ROUTE))
1166                         return _error(L, 0, NULL);
1167         }
1168
1169         struct nl_msg *msg;
1170         struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
1171         struct ndmsg ndm = {
1172                 .ndm_family = filter.family
1173         };
1174
1175         msg = nlmsg_alloc_simple(RTM_GETNEIGH, NLM_F_REQUEST | NLM_F_DUMP);
1176         if (!msg)
1177                 goto out;
1178
1179         nlmsg_append(msg, &ndm, sizeof(ndm), 0);
1180
1181         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_dump_neigh, &st);
1182         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_done, &st);
1183         nl_cb_err(cb, NL_CB_CUSTOM, cb_error, &st);
1184
1185         nl_send_auto_complete(sock, msg);
1186
1187         if (!st.callback)
1188                 lua_newtable(L);
1189
1190         while (st.pending > 0)
1191                 nl_recvmsgs(sock, cb);
1192
1193         nlmsg_free(msg);
1194
1195 out:
1196         nl_cb_put(cb);
1197         return (st.callback == 0);
1198 }
1199
1200
1201 static int cb_dump_link(struct nl_msg *msg, void *arg)
1202 {
1203         char *p, *addr, buf[48];
1204         struct dump_state *s = arg;
1205         struct nlmsghdr *hdr = nlmsg_hdr(msg);
1206         struct ifinfomsg *ifm = NLMSG_DATA(hdr);
1207         struct nlattr *tb[IFLA_MAX+1];
1208         int i, len;
1209
1210         if (hdr->nlmsg_type != RTM_NEWLINK)
1211                 return NL_SKIP;
1212
1213         nlmsg_parse(hdr, sizeof(*ifm), tb, IFLA_MAX, NULL);
1214
1215         L_setbool(s->L, "up", (ifm->ifi_flags & IFF_RUNNING));
1216         L_setint(s->L, "type", ifm->ifi_type);
1217         L_setstr(s->L, "name", if_indextoname(ifm->ifi_index, buf));
1218
1219         if (tb[IFLA_MTU])
1220                 L_setint(s->L, "mtu", RTA_U32(tb[IFLA_MTU]));
1221
1222         if (tb[IFLA_TXQLEN])
1223                 L_setint(s->L, "qlen", RTA_U32(tb[IFLA_TXQLEN]));
1224
1225         if (tb[IFLA_MASTER])
1226                 L_setdev(s->L, "master", tb[IFLA_MASTER]);
1227
1228         if (tb[IFLA_ADDRESS])
1229         {
1230                 len  = nla_len(tb[IFLA_ADDRESS]);
1231                 addr = nla_get_string(tb[IFLA_ADDRESS]);
1232
1233                 if ((len * 3) <= sizeof(buf))
1234                 {
1235                         for (p = buf, i = 0; i < len; i++)
1236                                 p += sprintf(p, "%s%02x", (i ? ":" : ""), (uint8_t)*addr++);
1237
1238                         L_setstr(s->L, "mac", buf);
1239                 }
1240         }
1241
1242         s->pending = 0;
1243         return NL_SKIP;
1244 }
1245
1246 static int link_get(lua_State *L)
1247 {
1248         const char *dev = luaL_checkstring(L, 1);
1249         struct dump_state st = {
1250                 .pending = 1,
1251                 .L = L
1252         };
1253
1254         if (!sock)
1255         {
1256                 sock = nl_socket_alloc();
1257                 if (!sock)
1258                         return _error(L, -1, "Out of memory");
1259
1260                 if (nl_connect(sock, NETLINK_ROUTE))
1261                         return _error(L, 0, NULL);
1262         }
1263
1264         struct nl_msg *msg = nlmsg_alloc_simple(RTM_GETLINK, NLM_F_REQUEST);
1265         struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
1266         struct ifinfomsg ifm = { .ifi_index = if_nametoindex(dev) };
1267
1268         if (!msg || !cb)
1269                 return 0;
1270
1271         nlmsg_append(msg, &ifm, sizeof(ifm), 0);
1272
1273         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_dump_link, &st);
1274         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_done, &st);
1275         nl_cb_err(cb, NL_CB_CUSTOM, cb_error, &st);
1276
1277         lua_newtable(L);
1278
1279         nl_send_auto_complete(sock, msg);
1280
1281         while (st.pending > 0)
1282                 nl_recvmsgs(sock, cb);
1283
1284         nlmsg_free(msg);
1285         nl_cb_put(cb);
1286
1287         return 1;
1288 }
1289
1290
1291 static const luaL_reg ip_methods[] = {
1292         { "new",                        cidr_new          },
1293         { "IPv4",                       cidr_ipv4         },
1294         { "IPv6",                       cidr_ipv6         },
1295
1296         { "route",                      route_get         },
1297         { "routes",                     route_dump        },
1298
1299         { "neighbors",          neighbor_dump     },
1300
1301         { "link",           link_get          },
1302
1303         { }
1304 };
1305
1306 static const luaL_reg ip_cidr_methods[] = {
1307         { "is4",                        cidr_is4          },
1308         { "is4rfc1918",         cidr_is4rfc1918   },
1309         { "is4linklocal",       cidr_is4linklocal },
1310         { "is6",                        cidr_is6          },
1311         { "is6linklocal",       cidr_is6linklocal },
1312         { "lower",                      cidr_lower        },
1313         { "higher",                     cidr_higher       },
1314         { "equal",                      cidr_equal        },
1315         { "prefix",                     cidr_prefix       },
1316         { "network",            cidr_network      },
1317         { "host",                       cidr_host         },
1318         { "mask",                       cidr_mask         },
1319         { "broadcast",          cidr_broadcast    },
1320         { "contains",       cidr_contains     },
1321         { "add",                        cidr_add          },
1322         { "sub",                        cidr_sub          },
1323         { "minhost",            cidr_minhost      },
1324         { "maxhost",            cidr_maxhost      },
1325         { "string",                     cidr_tostring     },
1326
1327         { "__lt",                       cidr_lower        },
1328         { "__le",                       cidr_lower_equal  },
1329         { "__eq",                       cidr_equal        },
1330         { "__add",                      cidr_add          },
1331         { "__sub",                      cidr_sub          },
1332         { "__gc",                       cidr_gc           },
1333         { "__tostring",         cidr_tostring     },
1334
1335         { }
1336 };
1337
1338 int luaopen_luci_ip(lua_State *L)
1339 {
1340         luaL_register(L, LUCI_IP, ip_methods);
1341
1342         luaL_newmetatable(L, LUCI_IP_CIDR);
1343         luaL_register(L, NULL, ip_cidr_methods);
1344         lua_pushvalue(L, -1);
1345         lua_setfield(L, -2, "__index");
1346         lua_pop(L, 1);
1347
1348         return 1;
1349 }