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

   1 /*
   2 Copyright 2015-2018 Jo-Philipp Wich <jo@mein.io>
   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 #define AF_BITS(f) \
  46         ((f) == AF_INET ? 32 : \
  47                 ((f) == AF_INET6 ? 128 : \
  48                         ((f) == AF_PACKET ? 48 : 0)))
  49
  50 #define AF_BYTES(f) \
  51         ((f) == AF_INET ? 4 : \
  52                 ((f) == AF_INET6 ? 16 : \
  53                         ((f) == AF_PACKET ? 6 : 0)))
  54
  55 static int hz = 0;
  56 static struct nl_sock *sock = NULL;
  57
  58 typedef struct {
  59         union {
  60                 struct in_addr v4;
  61                 struct in6_addr v6;
  62                 struct ether_addr mac;
  63                 uint8_t u8[16];
  64         } addr;
  65         uint32_t scope;
  66         uint16_t family;
  67         int16_t bits;
  68 } cidr_t;
  69
  70 struct dump_filter {
  71         bool get;
  72         int family;
  73         int iif;
  74         int oif;
  75         int type;
  76         int scope;
  77         int proto;
  78         int table;
  79         cidr_t gw;
  80         cidr_t from;
  81         cidr_t src;
  82         cidr_t dst;
  83         struct ether_addr mac;
  84         bool from_exact;
  85         bool dst_exact;
  86 };
  87
  88 struct dump_state {
  89         int index;
  90         int pending;
  91         int callback;
  92         struct lua_State *L;
  93         struct dump_filter *filter;
  94 };
  95
  96
  97 static int _cidr_new(lua_State *L, int index, int family, bool mask);
  98
  99 static cidr_t *L_checkcidr (lua_State *L, int index, cidr_t *p)
 100 {
 101         if (lua_type(L, index) == LUA_TUSERDATA)
 102                 return luaL_checkudata(L, index, LUCI_IP_CIDR);
 103
 104         if (_cidr_new(L, index, p ? p->family : 0, false))
 105                 return lua_touserdata(L, -1);
 106
 107         luaL_error(L, "Invalid operand");
 108         return NULL;
 109 }
 110
 111 static bool parse_mac(const char *mac, struct ether_addr *ea)
 112 {
 113         unsigned long int n;
 114         char *e, sep = 0;
 115         int i;
 116
 117         for (i = 0; i < 6; i++)
 118         {
 119                 if (i > 0)
 120                 {
 121                         if (sep == 0 && (mac[0] == ':' || mac[0] == '-'))
 122                                 sep = mac[0];
 123
 124                         if (sep == 0 || mac[0] != sep)
 125                                 return false;
 126
 127                         mac++;
 128                 }
 129
 130                 n = strtoul(mac, &e, 16);
 131
 132                 if (n > 0xFF)
 133                         return false;
 134
 135                 mac += (e - mac);
 136                 ea->ether_addr_octet[i] = n;
 137         }
 138
 139         if (mac[0] != 0)
 140                 return false;
 141
 142         return true;
 143 }
 144
 145 static bool parse_mask(int family, const char *mask, int16_t *bits)
 146 {
 147         char *e;
 148         union {
 149                 struct in_addr v4;
 150                 struct in6_addr v6;
 151                 struct ether_addr mac;
 152                 uint8_t u8[16];
 153         } m;
 154
 155         if (family == AF_INET && inet_pton(AF_INET, mask, &m.v4))
 156         {
 157                 for (*bits = 0, m.v4.s_addr = ntohl(m.v4.s_addr);
 158                          *bits < AF_BITS(AF_INET) && (m.v4.s_addr << *bits) & 0x80000000;
 159                          ++*bits);
 160         }
 161         else if ((family == AF_INET6 && inet_pton(AF_INET6, mask, &m.v6)) ||
 162                  (family == AF_PACKET && parse_mac(mask, &m.mac)))
 163         {
 164                 for (*bits = 0;
 165                          *bits < AF_BITS(family) && (m.u8[*bits / 8] << (*bits % 8)) & 128;
 166                          ++*bits);
 167         }
 168         else
 169         {
 170                 *bits = strtoul(mask, &e, 10);
 171
 172                 if (e == mask || *e != 0 || *bits > AF_BITS(family))
 173                         return false;
 174         }
 175
 176         return true;
 177 }
 178
 179 static bool parse_cidr(const char *dest, cidr_t *pp)
 180 {
 181         char *p, *s, buf[INET6_ADDRSTRLEN * 2 + 2];
 182
 183         strncpy(buf, dest, sizeof(buf) - 1);
 184
 185         p = strchr(buf, '/');
 186
 187         if (p)
 188                 *p++ = 0;
 189
 190         s = strchr(buf, '%');
 191
 192         if (s)
 193                 *s++ = 0;
 194
 195         if (inet_pton(AF_INET, buf, &pp->addr.v4))
 196                 pp->family = AF_INET;
 197         else if (inet_pton(AF_INET6, buf, &pp->addr.v6))
 198                 pp->family = AF_INET6;
 199         else if (parse_mac(buf, &pp->addr.mac))
 200                 pp->family = AF_PACKET;
 201         else
 202                 return false;
 203
 204         if (s)
 205         {
 206                 if (pp->family != AF_INET6)
 207                         return false;
 208
 209                 if (!(pp->addr.v6.s6_addr[0] == 0xFE &&
 210                       pp->addr.v6.s6_addr[1] >= 0x80 &&
 211                       pp->addr.v6.s6_addr[2] <= 0xBF))
 212                         return false;
 213
 214                 pp->scope = if_nametoindex(s);
 215
 216                 if (pp->scope == 0)
 217                         return false;
 218         }
 219         else {
 220                 pp->scope = 0;
 221         }
 222
 223         if (p)
 224         {
 225                 if (!parse_mask(pp->family, p, &pp->bits))
 226                         return false;
 227         }
 228         else
 229         {
 230                 pp->bits = AF_BITS(pp->family);
 231         }
 232
 233         return true;
 234 }
 235
 236 static int format_cidr(lua_State *L, cidr_t *p)
 237 {
 238         char *s, buf[INET6_ADDRSTRLEN + 1 + IF_NAMESIZE + 4];
 239
 240         if (p->family == AF_PACKET)
 241         {
 242                 snprintf(buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X",
 243                          p->addr.mac.ether_addr_octet[0],
 244                          p->addr.mac.ether_addr_octet[1],
 245                          p->addr.mac.ether_addr_octet[2],
 246                          p->addr.mac.ether_addr_octet[3],
 247                          p->addr.mac.ether_addr_octet[4],
 248                          p->addr.mac.ether_addr_octet[5]);
 249
 250                 if (p->bits < AF_BITS(AF_PACKET))
 251                         lua_pushfstring(L, "%s/%d", buf, p->bits);
 252                 else
 253                         lua_pushstring(L, buf);
 254         }
 255         else
 256         {
 257                 inet_ntop(p->family, &p->addr.v6, buf, sizeof(buf));
 258
 259                 s = buf + strlen(buf);
 260
 261                 if (p->scope != 0 && if_indextoname(p->scope, s + 1) != NULL) {
 262                         *s++ = '%';
 263                         s += strlen(s);
 264                 }
 265
 266                 if (p->bits < AF_BITS(p->family))
 267                         s += sprintf(s, "/%d", p->bits);
 268
 269                 lua_pushstring(L, buf);
 270         }
 271
 272         return 1;
 273 }
 274
 275 static int L_getint(lua_State *L, int index, const char *name)
 276 {
 277         int rv = 0;
 278
 279         lua_getfield(L, index, name);
 280
 281         if (lua_type(L, -1) == LUA_TNUMBER)
 282                 rv = lua_tonumber(L, -1);
 283
 284         lua_pop(L, 1);
 285
 286         return rv;
 287 }
 288
 289 static const char * L_getstr(lua_State *L, int index, const char *name)
 290 {
 291         const char *rv = NULL;
 292
 293         lua_getfield(L, index, name);
 294
 295         if (lua_type(L, -1) == LUA_TSTRING)
 296                 rv = lua_tostring(L, -1);
 297
 298         lua_pop(L, 1);
 299
 300         return rv;
 301 }
 302
 303 static void L_setint(struct lua_State *L, const char *name, uint32_t n)
 304 {
 305         lua_pushinteger(L, n);
 306         lua_setfield(L, -2, name);
 307 }
 308
 309 static void L_setbool(struct lua_State *L, const char *name, bool val)
 310 {
 311         lua_pushboolean(L, val);
 312         lua_setfield(L, -2, name);
 313 }
 314
 315 static void L_setaddr(struct lua_State *L, const char *name,
 316                       int family, void *addr, int bits)
 317 {
 318         cidr_t *p;
 319
 320         if (!addr)
 321                 return;
 322
 323         p = lua_newuserdata(L, sizeof(*p));
 324
 325         if (!p)
 326                 return;
 327
 328         if (family == AF_INET)
 329         {
 330                 p->family = AF_INET;
 331                 p->bits = (bits < 0) ? AF_BITS(AF_INET) : bits;
 332                 p->addr.v4 = *(struct in_addr *)addr;
 333                 p->scope = 0;
 334         }
 335         else if (family == AF_INET6)
 336         {
 337                 p->family = AF_INET6;
 338                 p->bits = (bits < 0) ? AF_BITS(AF_INET6) : bits;
 339                 p->addr.v6 = *(struct in6_addr *)addr;
 340                 p->scope = 0;
 341         }
 342         else
 343         {
 344                 p->family = AF_PACKET;
 345                 p->bits = (bits < 0) ? AF_BITS(AF_PACKET) : bits;
 346                 p->addr.mac = *(struct ether_addr *)addr;
 347                 p->scope = 0;
 348         }
 349
 350         luaL_getmetatable(L, LUCI_IP_CIDR);
 351         lua_setmetatable(L, -2);
 352         lua_setfield(L, -2, name);
 353 }
 354
 355 static void L_setstr(struct lua_State *L, const char *name, const char *val)
 356 {
 357         lua_pushstring(L, val);
 358         lua_setfield(L, -2, name);
 359 }
 360
 361 static void L_setdev(struct lua_State *L, const char *name,
 362                      struct nlattr *attr)
 363 {
 364         char buf[32];
 365
 366         if (if_indextoname(RTA_INT(attr), buf))
 367                 L_setstr(L, name, buf);
 368 }
 369
 370 static int L_checkbits(lua_State *L, int index, cidr_t *p)
 371 {
 372         int16_t s16;
 373         int bits;
 374
 375         if (lua_gettop(L) < index || lua_isnil(L, index))
 376         {
 377                 bits = p->bits;
 378         }
 379         else if (lua_type(L, index) == LUA_TNUMBER)
 380         {
 381                 bits = lua_tointeger(L, index);
 382
 383                 if (bits < 0 || bits > AF_BITS(p->family))
 384                         return luaL_error(L, "Invalid prefix size");
 385         }
 386         else if (lua_type(L, index) == LUA_TSTRING)
 387         {
 388                 if (!parse_mask(p->family, lua_tostring(L, index), &s16))
 389                         return luaL_error(L, "Invalid netmask format");
 390
 391                 bits = s16;
 392         }
 393         else
 394         {
 395                 return luaL_error(L, "Invalid data type");
 396         }
 397
 398         return bits;
 399 }
 400
 401 static int _cidr_new(lua_State *L, int index, int family, bool mask)
 402 {
 403         uint32_t n;
 404         const char *addr;
 405         cidr_t cidr = { }, *cidrp;
 406
 407         if (lua_type(L, index) == LUA_TNUMBER)
 408         {
 409                 n = htonl(lua_tointeger(L, index));
 410
 411                 if (family == AF_INET6)
 412                 {
 413                         cidr.family = AF_INET6;
 414                         cidr.addr.v6.s6_addr[12] = n;
 415                         cidr.addr.v6.s6_addr[13] = (n >> 8);
 416                         cidr.addr.v6.s6_addr[14] = (n >> 16);
 417                         cidr.addr.v6.s6_addr[15] = (n >> 24);
 418                 }
 419                 else if (family == AF_INET)
 420                 {
 421                         cidr.family = AF_INET;
 422                         cidr.addr.v4.s_addr = n;
 423                 }
 424                 else
 425                 {
 426                         cidr.family = AF_PACKET;
 427                         cidr.addr.mac.ether_addr_octet[2] = n;
 428                         cidr.addr.mac.ether_addr_octet[3] = (n >> 8);
 429                         cidr.addr.mac.ether_addr_octet[4] = (n >> 16);
 430                         cidr.addr.mac.ether_addr_octet[5] = (n >> 24);
 431                 }
 432
 433                 cidr.bits = AF_BITS(cidr.family);
 434         }
 435         else
 436         {
 437                 addr = luaL_checkstring(L, index);
 438
 439                 if (!parse_cidr(addr, &cidr))
 440                         return 0;
 441
 442                 if (family && cidr.family != family)
 443                         return 0;
 444
 445                 if (mask)
 446                         cidr.bits = L_checkbits(L, index + 1, &cidr);
 447         }
 448
 449         if (!(cidrp = lua_newuserdata(L, sizeof(*cidrp))))
 450                 return 0;
 451
 452         *cidrp = cidr;
 453         luaL_getmetatable(L, LUCI_IP_CIDR);
 454         lua_setmetatable(L, -2);
 455         return 1;
 456 }
 457
 458 static int cidr_new(lua_State *L)
 459 {
 460         return _cidr_new(L, 1, 0, true);
 461 }
 462
 463 static int cidr_ipv4(lua_State *L)
 464 {
 465         return _cidr_new(L, 1, AF_INET, true);
 466 }
 467
 468 static int cidr_ipv6(lua_State *L)
 469 {
 470         return _cidr_new(L, 1, AF_INET6, true);
 471 }
 472
 473 static int cidr_mac(lua_State *L)
 474 {
 475         return _cidr_new(L, 1, AF_PACKET, true);
 476 }
 477
 478 static int cidr_check(lua_State *L, int family)
 479 {
 480         cidr_t cidr = { }, *cidrp;
 481         const char *addr;
 482
 483         if (lua_type(L, 1) == LUA_TSTRING)
 484         {
 485                 addr = lua_tostring(L, 1);
 486
 487                 if (addr && parse_cidr(addr, &cidr) && cidr.family == family)
 488                         return format_cidr(L, &cidr);
 489         }
 490         else
 491         {
 492                 cidrp = lua_touserdata(L, 1);
 493
 494                 if (cidrp == NULL)
 495                         return 0;
 496
 497                 if (!lua_getmetatable(L, 1))
 498                         return 0;
 499
 500                 lua_getfield(L, LUA_REGISTRYINDEX, LUCI_IP_CIDR);
 501
 502                 if (!lua_rawequal(L, -1, -2))
 503                         cidrp = NULL;
 504
 505                 lua_pop(L, 2);
 506
 507                 if (cidrp != NULL && cidrp->family == family)
 508                         return format_cidr(L, cidrp);
 509         }
 510
 511         return 0;
 512 }
 513
 514 static int cidr_checkip4(lua_State *L)
 515 {
 516         return cidr_check(L, AF_INET);
 517 }
 518
 519 static int cidr_checkip6(lua_State *L)
 520 {
 521         return cidr_check(L, AF_INET6);
 522 }
 523
 524 static int cidr_checkmac(lua_State *L)
 525 {
 526         return cidr_check(L, AF_PACKET);
 527 }
 528
 529 static int cidr_is4(lua_State *L)
 530 {
 531         cidr_t *p = L_checkcidr(L, 1, NULL);
 532
 533         lua_pushboolean(L, p->family == AF_INET);
 534         return 1;
 535 }
 536
 537 static int cidr_is4rfc1918(lua_State *L)
 538 {
 539         cidr_t *p = L_checkcidr(L, 1, NULL);
 540         uint32_t a = htonl(p->addr.v4.s_addr);
 541
 542         lua_pushboolean(L, (p->family == AF_INET &&
 543                             ((a >= 0x0A000000 && a <= 0x0AFFFFFF) ||
 544                              (a >= 0xAC100000 && a <= 0xAC1FFFFF) ||
 545                              (a >= 0xC0A80000 && a <= 0xC0A8FFFF))));
 546
 547         return 1;
 548 }
 549
 550 static int cidr_is4linklocal(lua_State *L)
 551 {
 552         cidr_t *p = L_checkcidr(L, 1, NULL);
 553         uint32_t a = htonl(p->addr.v4.s_addr);
 554
 555         lua_pushboolean(L, (p->family == AF_INET &&
 556                             a >= 0xA9FE0000 &&
 557                             a <= 0xA9FEFFFF));
 558
 559         return 1;
 560 }
 561
 562 static bool _is_mapped4(cidr_t *p)
 563 {
 564         return (p->family == AF_INET6 &&
 565                 p->addr.v6.s6_addr[0] == 0 &&
 566                 p->addr.v6.s6_addr[1] == 0 &&
 567                 p->addr.v6.s6_addr[2] == 0 &&
 568                 p->addr.v6.s6_addr[3] == 0 &&
 569                 p->addr.v6.s6_addr[4] == 0 &&
 570                 p->addr.v6.s6_addr[5] == 0 &&
 571                 p->addr.v6.s6_addr[6] == 0 &&
 572                 p->addr.v6.s6_addr[7] == 0 &&
 573                 p->addr.v6.s6_addr[8] == 0 &&
 574                 p->addr.v6.s6_addr[9] == 0 &&
 575                 p->addr.v6.s6_addr[10] == 0xFF &&
 576                 p->addr.v6.s6_addr[11] == 0xFF);
 577 }
 578
 579 static int cidr_is6mapped4(lua_State *L)
 580 {
 581         cidr_t *p = L_checkcidr(L, 1, NULL);
 582
 583         lua_pushboolean(L, _is_mapped4(p));
 584         return 1;
 585 }
 586
 587 static int cidr_is6(lua_State *L)
 588 {
 589         cidr_t *p = L_checkcidr(L, 1, NULL);
 590
 591         lua_pushboolean(L, p->family == AF_INET6);
 592         return 1;
 593 }
 594
 595 static int cidr_is6linklocal(lua_State *L)
 596 {
 597         cidr_t *p = L_checkcidr(L, 1, NULL);
 598
 599         lua_pushboolean(L, (p->family == AF_INET6 &&
 600                             p->addr.v6.s6_addr[0] == 0xFE &&
 601                             p->addr.v6.s6_addr[1] >= 0x80 &&
 602                             p->addr.v6.s6_addr[1] <= 0xBF));
 603
 604         return 1;
 605 }
 606
 607 static int cidr_ismac(lua_State *L)
 608 {
 609         cidr_t *p = L_checkcidr(L, 1, NULL);
 610
 611         lua_pushboolean(L, p->family == AF_PACKET);
 612         return 1;
 613 }
 614
 615 static int cidr_ismacmcast(lua_State *L)
 616 {
 617         cidr_t *p = L_checkcidr(L, 1, NULL);
 618
 619         lua_pushboolean(L, (p->family == AF_PACKET &&
 620                             (p->addr.mac.ether_addr_octet[0] & 0x1)));
 621
 622         return 1;
 623 }
 624
 625 static int cidr_ismaclocal(lua_State *L)
 626 {
 627         cidr_t *p = L_checkcidr(L, 1, NULL);
 628
 629         lua_pushboolean(L, (p->family == AF_PACKET &&
 630                             (p->addr.mac.ether_addr_octet[0] & 0x2)));
 631
 632         return 1;
 633 }
 634
 635 static int _cidr_cmp(lua_State *L)
 636 {
 637         cidr_t *a = L_checkcidr(L, 1, NULL);
 638         cidr_t *b = L_checkcidr(L, 2, NULL);
 639
 640         if (a->family != b->family)
 641                 return (a->family - b->family);
 642
 643         return memcmp(&a->addr.v6, &b->addr.v6, AF_BYTES(a->family));
 644 }
 645
 646 static int cidr_lower(lua_State *L)
 647 {
 648         lua_pushboolean(L, _cidr_cmp(L) < 0);
 649         return 1;
 650 }
 651
 652 static int cidr_higher(lua_State *L)
 653 {
 654         lua_pushboolean(L, _cidr_cmp(L) > 0);
 655         return 1;
 656 }
 657
 658 static int cidr_equal(lua_State *L)
 659 {
 660         lua_pushboolean(L, _cidr_cmp(L) == 0);
 661         return 1;
 662 }
 663
 664 static int cidr_lower_equal(lua_State *L)
 665 {
 666         lua_pushboolean(L, _cidr_cmp(L) <= 0);
 667         return 1;
 668 }
 669
 670 static int cidr_prefix(lua_State *L)
 671 {
 672         cidr_t *p = L_checkcidr(L, 1, NULL);
 673         int bits = L_checkbits(L, 2, p);
 674
 675         p->bits = bits;
 676         lua_pushinteger(L, p->bits);
 677         return 1;
 678 }
 679
 680 static void _apply_mask(cidr_t *p, int bits, bool inv)
 681 {
 682         uint8_t b, i;
 683
 684         if (bits <= 0)
 685         {
 686                 memset(&p->addr.u8, inv * 0xFF, AF_BYTES(p->family));
 687         }
 688         else if (p->family == AF_INET && bits <= AF_BITS(AF_INET))
 689         {
 690                 if (inv)
 691                         p->addr.v4.s_addr |= ntohl((1 << (AF_BITS(AF_INET) - bits)) - 1);
 692                 else
 693                         p->addr.v4.s_addr &= ntohl(~((1 << (AF_BITS(AF_INET) - bits)) - 1));
 694         }
 695         else if (bits <= AF_BITS(p->family))
 696         {
 697                 for (i = 0; i < AF_BYTES(p->family); i++)
 698                 {
 699                         b = (bits > 8) ? 8 : bits;
 700                         if (inv)
 701                                 p->addr.u8[i] |= ~((uint8_t)(0xFF << (8 - b)));
 702                         else
 703                                 p->addr.u8[i] &= (uint8_t)(0xFF << (8 - b));
 704                         bits -= b;
 705                 }
 706         }
 707 }
 708
 709 static int cidr_network(lua_State *L)
 710 {
 711         cidr_t *p1 = L_checkcidr(L, 1, NULL), *p2;
 712         int bits = L_checkbits(L, 2, p1);
 713
 714         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 715                 return 0;
 716
 717         *p2 = *p1;
 718         p2->bits = AF_BITS(p1->family);
 719         _apply_mask(p2, bits, false);
 720
 721         luaL_getmetatable(L, LUCI_IP_CIDR);
 722         lua_setmetatable(L, -2);
 723         return 1;
 724 }
 725
 726 static int cidr_host(lua_State *L)
 727 {
 728         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 729         cidr_t *p2 = lua_newuserdata(L, sizeof(*p2));
 730
 731         if (!p2)
 732                 return 0;
 733
 734         *p2 = *p1;
 735         p2->bits = AF_BITS(p1->family);
 736
 737         luaL_getmetatable(L, LUCI_IP_CIDR);
 738         lua_setmetatable(L, -2);
 739         return 1;
 740 }
 741
 742 static int cidr_mask(lua_State *L)
 743 {
 744         cidr_t *p1 = L_checkcidr(L, 1, NULL), *p2;
 745         int bits = L_checkbits(L, 2, p1);
 746
 747         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 748                 return 0;
 749
 750         p2->scope = 0;
 751         p2->bits = AF_BITS(p1->family);
 752         p2->family = p1->family;
 753
 754         memset(&p2->addr.v6.s6_addr, 0xFF, sizeof(p2->addr.v6.s6_addr));
 755         _apply_mask(p2, bits, false);
 756
 757         luaL_getmetatable(L, LUCI_IP_CIDR);
 758         lua_setmetatable(L, -2);
 759         return 1;
 760 }
 761
 762 static int cidr_broadcast(lua_State *L)
 763 {
 764         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 765         cidr_t *p2;
 766         int bits = L_checkbits(L, 2, p1);
 767
 768         if (p1->family != AF_INET)
 769                 return 0;
 770
 771         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 772                 return 0;
 773
 774         *p2 = *p1;
 775         p2->bits = AF_BITS(AF_INET);
 776         _apply_mask(p2, bits, true);
 777
 778         luaL_getmetatable(L, LUCI_IP_CIDR);
 779         lua_setmetatable(L, -2);
 780         return 1;
 781 }
 782
 783 static int cidr_mapped4(lua_State *L)
 784 {
 785         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 786         cidr_t *p2;
 787
 788         if (!_is_mapped4(p1))
 789                 return 0;
 790
 791         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 792                 return 0;
 793
 794         p2->scope = 0;
 795         p2->family = AF_INET;
 796         p2->bits = (p1->bits > AF_BITS(AF_INET)) ? AF_BITS(AF_INET) : p1->bits;
 797         memcpy(&p2->addr.v4, p1->addr.v6.s6_addr + 12, sizeof(p2->addr.v4));
 798
 799         luaL_getmetatable(L, LUCI_IP_CIDR);
 800         lua_setmetatable(L, -2);
 801         return 1;
 802 }
 803
 804 static int cidr_unscoped(lua_State *L)
 805 {
 806         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 807         cidr_t *p2;
 808
 809         if (p1->family != AF_INET6)
 810                 return 0;
 811
 812         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 813                 return 0;
 814
 815         *p2 = *p1;
 816         p2->scope = 0;
 817
 818         luaL_getmetatable(L, LUCI_IP_CIDR);
 819         lua_setmetatable(L, -2);
 820         return 1;
 821 }
 822
 823 static int cidr_tolinklocal(lua_State *L)
 824 {
 825         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 826         cidr_t *p2;
 827         int i;
 828
 829         if (p1->family != AF_PACKET)
 830                 return 0;
 831
 832         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 833                 return 0;
 834
 835         p2->scope = p1->scope;
 836         p2->family = AF_INET6;
 837         p2->bits = AF_BITS(AF_INET6);
 838         p2->addr.u8[0] = 0xFE;
 839         p2->addr.u8[1] = 0x80;
 840         p2->addr.u8[8] = p1->addr.u8[0] ^ 0x02;
 841         p2->addr.u8[9] = p1->addr.u8[1];
 842         p2->addr.u8[10] = p1->addr.u8[2];
 843         p2->addr.u8[11] = 0xFF;
 844         p2->addr.u8[12] = 0xFE;
 845         p2->addr.u8[13] = p1->addr.u8[3];
 846         p2->addr.u8[14] = p1->addr.u8[4];
 847         p2->addr.u8[15] = p1->addr.u8[5];
 848
 849         luaL_getmetatable(L, LUCI_IP_CIDR);
 850         lua_setmetatable(L, -2);
 851         return 1;
 852 }
 853
 854 static int cidr_tomac(lua_State *L)
 855 {
 856         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 857         cidr_t *p2;
 858         int i;
 859
 860         if (p1->family != AF_INET6 ||
 861             p1->addr.u8[0] != 0xFE ||
 862             p1->addr.u8[1] != 0x80 ||
 863             p1->addr.u8[2] != 0x00 ||
 864             p1->addr.u8[3] != 0x00 ||
 865             p1->addr.u8[4] != 0x00 ||
 866             p1->addr.u8[5] != 0x00 ||
 867             p1->addr.u8[6] != 0x00 ||
 868             p1->addr.u8[7] != 0x00 ||
 869             p1->addr.u8[11] != 0xFF ||
 870             p1->addr.u8[12] != 0xFE)
 871             return 0;
 872
 873         if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
 874                 return 0;
 875
 876         p2->scope = 0;
 877         p2->family = AF_PACKET;
 878         p2->bits = AF_BITS(AF_PACKET);
 879         p2->addr.u8[0] = p1->addr.u8[8] ^ 0x02;
 880         p2->addr.u8[1] = p1->addr.u8[9];
 881         p2->addr.u8[2] = p1->addr.u8[10];
 882         p2->addr.u8[3] = p1->addr.u8[13];
 883         p2->addr.u8[4] = p1->addr.u8[14];
 884         p2->addr.u8[5] = p1->addr.u8[15];
 885
 886         luaL_getmetatable(L, LUCI_IP_CIDR);
 887         lua_setmetatable(L, -2);
 888         return 1;
 889 }
 890
 891 static int cidr_contains(lua_State *L)
 892 {
 893         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 894         cidr_t *p2 = L_checkcidr(L, 2, NULL);
 895         cidr_t a = *p1, b = *p2;
 896         bool rv = false;
 897
 898         if (p1->family == p2->family && p1->bits <= p2->bits)
 899         {
 900                 _apply_mask(&a, p1->bits, false);
 901                 _apply_mask(&b, p1->bits, false);
 902
 903                 rv = !memcmp(&a.addr.v6, &b.addr.v6, AF_BYTES(a.family));
 904         }
 905
 906         lua_pushboolean(L, rv);
 907         return 1;
 908 }
 909
 910 #define BYTE(a, i) \
 911         (a)->addr.u8[AF_BYTES((a)->family) - (i) - 1]
 912
 913 static int _cidr_add_sub(lua_State *L, bool add)
 914 {
 915         cidr_t *p1 = L_checkcidr(L, 1, NULL);
 916         cidr_t *p2 = L_checkcidr(L, 2, p1);
 917         cidr_t r = *p1;
 918         bool inplace = lua_isboolean(L, 3) ? lua_toboolean(L, 3) : false;
 919         bool ok = true;
 920         uint8_t i, carry;
 921         uint32_t a, b;
 922
 923         if (p1->family == p2->family)
 924         {
 925                 if (p1->family == AF_INET)
 926                 {
 927                         a = ntohl(p1->addr.v4.s_addr);
 928                         b = ntohl(p2->addr.v4.s_addr);
 929
 930                         /* would over/underflow */
 931                         if ((add && (UINT_MAX - a) < b) || (!add && a < b))
 932                         {
 933                                 r.addr.v4.s_addr = add * 0xFFFFFFFF;
 934                                 ok = false;
 935                         }
 936                         else
 937                         {
 938                                 r.addr.v4.s_addr = add ? htonl(a + b) : htonl(a - b);
 939                         }
 940                 }
 941                 else
 942                 {
 943                         for (i = 0, carry = 0; i < AF_BYTES(p1->family); i++)
 944                         {
 945                                 if (add)
 946                                 {
 947                                         BYTE(&r, i) = BYTE(p1, i) + BYTE(p2, i) + carry;
 948                                         carry = (BYTE(p1, i) + BYTE(p2, i) + carry) / 256;
 949                                 }
 950                                 else
 951                                 {
 952                                         BYTE(&r, i) = (BYTE(p1, i) - BYTE(p2, i) - carry);
 953                                         carry = (BYTE(p1, i) < (BYTE(p2, i) + carry));
 954                                 }
 955                         }
 956
 957                         /* would over/underflow */
 958                         if (carry)
 959                         {
 960                                 memset(&r.addr.u8, add * 0xFF, AF_BYTES(r.family));
 961                                 ok = false;
 962                         }
 963                 }
 964         }
 965         else
 966         {
 967                 ok = false;
 968         }
 969
 970         if (inplace)
 971         {
 972                 *p1 = r;
 973                 lua_pushboolean(L, ok);
 974                 return 1;
 975         }
 976
 977         if (!(p1 = lua_newuserdata(L, sizeof(*p1))))
 978                 return 0;
 979
 980         *p1 = r;
 981
 982         luaL_getmetatable(L, LUCI_IP_CIDR);
 983         lua_setmetatable(L, -2);
 984         return 1;
 985 }
 986
 987 static int cidr_add(lua_State *L)
 988 {
 989         return _cidr_add_sub(L, true);
 990 }
 991
 992 static int cidr_sub(lua_State *L)
 993 {
 994         return _cidr_add_sub(L, false);
 995 }
 996
 997 static int cidr_minhost(lua_State *L)
 998 {
 999         cidr_t *p = L_checkcidr(L, 1, NULL);
1000         cidr_t r = *p;
1001         uint8_t i, rest, carry;
1002
1003         _apply_mask(&r, r.bits, false);
1004
1005         if (r.family == AF_INET && r.bits < AF_BITS(AF_INET))
1006         {
1007                 r.bits = AF_BITS(AF_INET);
1008                 r.addr.v4.s_addr = htonl(ntohl(r.addr.v4.s_addr) + 1);
1009         }
1010         else if (r.bits < AF_BITS(r.family))
1011         {
1012                 r.bits = AF_BITS(r.family);
1013
1014                 for (i = 0, carry = 1; i < AF_BYTES(r.family); i++)
1015                 {
1016                         rest = (BYTE(&r, i) + carry) > 255;
1017                         BYTE(&r, i) += carry;
1018                         carry = rest;
1019                 }
1020         }
1021
1022         if (!(p = lua_newuserdata(L, sizeof(*p))))
1023                 return 0;
1024
1025         *p = r;
1026
1027         luaL_getmetatable(L, LUCI_IP_CIDR);
1028         lua_setmetatable(L, -2);
1029         return 1;
1030 }
1031
1032 static int cidr_maxhost(lua_State *L)
1033 {
1034         cidr_t *p = L_checkcidr(L, 1, NULL);
1035         cidr_t r = *p;
1036
1037         _apply_mask(&r, r.bits, true);
1038
1039         if (r.family == AF_INET && r.bits < AF_BITS(AF_INET))
1040         {
1041                 r.bits = AF_BITS(AF_INET);
1042                 r.addr.v4.s_addr = htonl(ntohl(r.addr.v4.s_addr) - 1);
1043         }
1044         else
1045         {
1046                 r.bits = AF_BITS(r.family);
1047         }
1048
1049         if (!(p = lua_newuserdata(L, sizeof(*p))))
1050                 return 0;
1051
1052         *p = r;
1053
1054         luaL_getmetatable(L, LUCI_IP_CIDR);
1055         lua_setmetatable(L, -2);
1056         return 1;
1057 }
1058
1059 static int cidr_gc (lua_State *L)
1060 {
1061         return 0;
1062 }
1063
1064 static int cidr_tostring (lua_State *L)
1065 {
1066         cidr_t *p = L_checkcidr(L, 1, NULL);
1067         return format_cidr(L, p);
1068 }
1069
1070 /*
1071  * route functions
1072  */
1073
1074 static bool diff_prefix(int family, void *addr, int bits, bool exact, cidr_t *p)
1075 {
1076         uint8_t i, b, r, *a;
1077         uint32_t m;
1078
1079         if (!p->family)
1080                 return false;
1081
1082         if (!addr || p->family != family || p->bits > bits)
1083                 return true;
1084
1085         if (family == AF_INET)
1086         {
1087                 m = p->bits ? htonl(~((1 << (AF_BITS(AF_INET) - p->bits)) - 1)) : 0;
1088
1089                 if ((((struct in_addr *)addr)->s_addr & m) != (p->addr.v4.s_addr & m))
1090                         return true;
1091         }
1092         else
1093         {
1094                 for (i = 0, a = addr, r = p->bits; i < AF_BYTES(p->family); i++)
1095                 {
1096                         b = r ? (0xFF << (8 - ((r > 8) ? 8 : r))) : 0;
1097
1098                         if ((a[i] & b) != (p->addr.u8[i] & b))
1099                                 return true;
1100
1101                         r -= ((r > 8) ? 8 : r);
1102                 }
1103         }
1104
1105         return (exact && p->bits != bits);
1106 }
1107
1108 static int cb_dump_route(struct nl_msg *msg, void *arg)
1109 {
1110         struct dump_state *s = arg;
1111         struct dump_filter *f = s->filter;
1112         struct nlmsghdr *hdr = nlmsg_hdr(msg);
1113         struct rtmsg *rt = NLMSG_DATA(hdr);
1114         struct nlattr *tb[RTA_MAX+1];
1115         struct in6_addr *src, *dst, *gw, *from, def = { };
1116         int iif, oif, bitlen;
1117         uint32_t table;
1118
1119         if (hdr->nlmsg_type != RTM_NEWROUTE ||
1120             (rt->rtm_family != AF_INET && rt->rtm_family != AF_INET6))
1121                 return NL_SKIP;
1122
1123         nlmsg_parse(hdr, sizeof(*rt), tb, RTA_MAX, NULL);
1124
1125         iif   = tb[RTA_IIF]     ? RTA_INT(tb[RTA_IIF])      : 0;
1126         oif   = tb[RTA_OIF]     ? RTA_INT(tb[RTA_OIF])      : 0;
1127         table = tb[RTA_TABLE]   ? RTA_U32(tb[RTA_TABLE])    : rt->rtm_table;
1128         from  = tb[RTA_SRC]     ? RTA_DATA(tb[RTA_SRC])     : NULL;
1129         src   = tb[RTA_PREFSRC] ? RTA_DATA(tb[RTA_PREFSRC]) : NULL;
1130         dst   = tb[RTA_DST]     ? RTA_DATA(tb[RTA_DST])     : &def;
1131         gw    = tb[RTA_GATEWAY] ? RTA_DATA(tb[RTA_GATEWAY]) : NULL;
1132
1133         bitlen = AF_BITS(rt->rtm_family);
1134
1135         if (!f->get) {
1136                 if ((f->type   && rt->rtm_type     != f->type)   ||
1137                     (f->family && rt->rtm_family   != f->family) ||
1138                     (f->proto  && rt->rtm_protocol != f->proto)  ||
1139                     (f->scope  && rt->rtm_scope    != f->scope)  ||
1140                     (f->iif    && iif              != f->iif)    ||
1141                     (f->oif    && oif              != f->oif)    ||
1142                     (f->table  && table            != f->table)  ||
1143                     diff_prefix(rt->rtm_family, from, rt->rtm_src_len,
1144                                 f->from_exact, &f->from)         ||
1145                     diff_prefix(rt->rtm_family, dst,  rt->rtm_dst_len,
1146                                 f->dst_exact, &f->dst)           ||
1147                     diff_prefix(rt->rtm_family, gw,   bitlen,
1148                                 false, &f->gw)                   ||
1149                     diff_prefix(rt->rtm_family, src,  bitlen,
1150                                 false, &f->src))
1151                         goto out;
1152         }
1153
1154         if (s->callback)
1155                 lua_pushvalue(s->L, 2);
1156
1157         lua_newtable(s->L);
1158
1159         L_setint(s->L, "type", rt->rtm_type);
1160         L_setint(s->L, "family", (rt->rtm_family == AF_INET) ? 4 : 6);
1161
1162         L_setaddr(s->L, "dest", rt->rtm_family, dst, rt->rtm_dst_len);
1163
1164         if (gw)
1165                 L_setaddr(s->L, "gw", rt->rtm_family, gw, -1);
1166
1167         if (from)
1168                 L_setaddr(s->L, "from", rt->rtm_family, from, rt->rtm_src_len);
1169
1170         if (iif)
1171                 L_setdev(s->L, "iif", tb[RTA_IIF]);
1172
1173         if (oif)
1174                 L_setdev(s->L, "dev", tb[RTA_OIF]);
1175
1176         L_setint(s->L, "table", table);
1177         L_setint(s->L, "proto", rt->rtm_protocol);
1178         L_setint(s->L, "scope", rt->rtm_scope);
1179
1180         if (src)
1181                 L_setaddr(s->L, "src", rt->rtm_family, src, -1);
1182
1183         if (tb[RTA_PRIORITY])
1184                 L_setint(s->L, "metric", RTA_U32(tb[RTA_PRIORITY]));
1185
1186         if (rt->rtm_family == AF_INET6 && tb[RTA_CACHEINFO])
1187         {
1188                 struct rta_cacheinfo *ci = RTA_DATA(tb[RTA_CACHEINFO]);
1189
1190                 if (ci->rta_expires)
1191                 {
1192                         if (ci->rta_expires)
1193                                 L_setint(s->L, "expires", ci->rta_expires / hz);
1194
1195                         if (ci->rta_error != 0)
1196                                 L_setint(s->L, "error", ci->rta_error);
1197                 }
1198         }
1199
1200         s->index++;
1201
1202         if (s->callback)
1203                 lua_call(s->L, 1, 0);
1204         else if (hdr->nlmsg_flags & NLM_F_MULTI)
1205                 lua_rawseti(s->L, -2, s->index);
1206
1207 out:
1208         s->pending = !!(hdr->nlmsg_flags & NLM_F_MULTI);
1209         return NL_SKIP;
1210 }
1211
1212 static int
1213 cb_done(struct nl_msg *msg, void *arg)
1214 {
1215         struct dump_state *s = arg;
1216         s->pending = 0;
1217         return NL_STOP;
1218 }
1219
1220 static int
1221 cb_error(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
1222 {
1223         struct dump_state *s = arg;
1224         s->pending = 0;
1225         return NL_STOP;
1226 }
1227
1228 static int _error(lua_State *L, int code, const char *msg)
1229 {
1230         lua_pushnil(L);
1231         lua_pushnumber(L, code ? code : errno);
1232         lua_pushstring(L, msg ? msg : strerror(errno));
1233
1234         return 3;
1235 }
1236
1237 static int _route_dump(lua_State *L, struct dump_filter *filter)
1238 {
1239         int flags = NLM_F_REQUEST;
1240         struct dump_state s = {
1241                 .L = L,
1242                 .pending = 1,
1243                 .index = 0,
1244                 .callback = lua_isfunction(L, 2),
1245                 .filter = filter
1246         };
1247
1248         if (!hz)
1249                 hz = sysconf(_SC_CLK_TCK);
1250
1251         if (!sock)
1252         {
1253                 sock = nl_socket_alloc();
1254                 if (!sock)
1255                         return _error(L, -1, "Out of memory");
1256
1257                 if (nl_connect(sock, NETLINK_ROUTE))
1258                         return _error(L, 0, NULL);
1259         }
1260
1261         struct nl_msg *msg;
1262         struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
1263         struct rtmsg rtm = {
1264                 .rtm_family = filter->family,
1265                 .rtm_dst_len = filter->dst.bits,
1266                 .rtm_src_len = filter->src.bits
1267         };
1268
1269         if (!filter->get)
1270                 flags |= NLM_F_DUMP;
1271
1272         msg = nlmsg_alloc_simple(RTM_GETROUTE, flags);
1273         if (!msg)
1274                 goto out;
1275
1276         nlmsg_append(msg, &rtm, sizeof(rtm), 0);
1277
1278         if (filter->get) {
1279                 nla_put(msg, RTA_DST, AF_BYTES(filter->dst.family),
1280                         &filter->dst.addr.v6);
1281
1282                 if (filter->src.family)
1283                         nla_put(msg, RTA_SRC, AF_BYTES(filter->src.family),
1284                                 &filter->src.addr.v6);
1285         }
1286
1287         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_dump_route, &s);
1288         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_done, &s);
1289         nl_cb_err(cb, NL_CB_CUSTOM, cb_error, &s);
1290
1291         nl_send_auto_complete(sock, msg);
1292
1293         if (!filter->get && !s.callback)
1294                 lua_newtable(L);
1295
1296         while (s.pending > 0)
1297                 nl_recvmsgs(sock, cb);
1298
1299         nlmsg_free(msg);
1300
1301 out:
1302         nl_cb_put(cb);
1303
1304         if (s.callback)
1305                 return 0;
1306
1307         if (!filter->get)
1308                 return 1;
1309
1310         return (s.index > 0);
1311 }
1312
1313 static int route_get(lua_State *L)
1314 {
1315         struct dump_filter filter = { .get = true };
1316         const char *dest = luaL_checkstring(L, 1);
1317         const char *from = luaL_optstring(L, 2, NULL);
1318
1319         if (!parse_cidr(dest, &filter.dst))
1320                 return _error(L, -1, "Invalid destination");
1321
1322         if (from && !parse_cidr(from, &filter.src))
1323                 return _error(L, -1, "Invalid source");
1324
1325         if (filter.src.family != 0 &&
1326             filter.src.family != filter.dst.family)
1327                 return _error(L, -1, "Different source/destination family");
1328
1329         filter.family = filter.dst.family;
1330
1331         return _route_dump(L, &filter);
1332 }
1333
1334 static int route_dump(lua_State *L)
1335 {
1336         const char *s;
1337         cidr_t p = { };
1338         struct dump_filter filter = { };
1339
1340         if (lua_type(L, 1) == LUA_TTABLE)
1341         {
1342                 filter.family = L_getint(L, 1, "family");
1343
1344                 if (filter.family == 4)
1345                         filter.family = AF_INET;
1346                 else if (filter.family == 6)
1347                         filter.family = AF_INET6;
1348                 else
1349                         filter.family = 0;
1350
1351                 if ((s = L_getstr(L, 1, "iif")) != NULL)
1352                         filter.iif = if_nametoindex(s);
1353
1354                 if ((s = L_getstr(L, 1, "oif")) != NULL)
1355                         filter.oif = if_nametoindex(s);
1356
1357                 filter.type = L_getint(L, 1, "type");
1358                 filter.scope = L_getint(L, 1, "scope");
1359                 filter.proto = L_getint(L, 1, "proto");
1360                 filter.table = L_getint(L, 1, "table");
1361
1362                 if ((s = L_getstr(L, 1, "gw")) != NULL && parse_cidr(s, &p))
1363                         filter.gw = p;
1364
1365                 if ((s = L_getstr(L, 1, "from")) != NULL && parse_cidr(s, &p))
1366                         filter.from = p;
1367
1368                 if ((s = L_getstr(L, 1, "src")) != NULL && parse_cidr(s, &p))
1369                         filter.src = p;
1370
1371                 if ((s = L_getstr(L, 1, "dest")) != NULL && parse_cidr(s, &p))
1372                         filter.dst = p;
1373
1374                 if ((s = L_getstr(L, 1, "from_exact")) != NULL && parse_cidr(s, &p))
1375                         filter.from = p, filter.from_exact = true;
1376
1377                 if ((s = L_getstr(L, 1, "dest_exact")) != NULL && parse_cidr(s, &p))
1378                         filter.dst = p, filter.dst_exact = true;
1379         }
1380
1381         return _route_dump(L, &filter);
1382 }
1383
1384
1385 static bool diff_macaddr(struct ether_addr *mac1, struct ether_addr *mac2)
1386 {
1387         struct ether_addr empty = { };
1388
1389         if (!memcmp(mac2, &empty, sizeof(empty)))
1390                 return false;
1391
1392         if (!mac1 || memcmp(mac1, mac2, sizeof(empty)))
1393                 return true;
1394
1395         return false;
1396 }
1397
1398 static int cb_dump_neigh(struct nl_msg *msg, void *arg)
1399 {
1400         char buf[32];
1401         struct ether_addr *mac;
1402         struct in6_addr *dst;
1403         struct dump_state *s = arg;
1404         struct dump_filter *f = s->filter;
1405         struct nlmsghdr *hdr = nlmsg_hdr(msg);
1406         struct ndmsg *nd = NLMSG_DATA(hdr);
1407         struct nlattr *tb[NDA_MAX+1];
1408         int bitlen;
1409
1410         if (hdr->nlmsg_type != RTM_NEWNEIGH ||
1411             (nd->ndm_family != AF_INET && nd->ndm_family != AF_INET6))
1412                 return NL_SKIP;
1413
1414         nlmsg_parse(hdr, sizeof(*nd), tb, NDA_MAX, NULL);
1415
1416         mac = tb[NDA_LLADDR] ? RTA_DATA(tb[NDA_LLADDR]) : NULL;
1417         dst = tb[NDA_DST]    ? RTA_DATA(tb[NDA_DST])    : NULL;
1418
1419         bitlen = AF_BITS(nd->ndm_family);
1420
1421         if ((f->family && nd->ndm_family  != f->family) ||
1422             (f->iif    && nd->ndm_ifindex != f->iif) ||
1423                 (f->type   && !(f->type & nd->ndm_state)) ||
1424             diff_prefix(nd->ndm_family, dst, bitlen, false, &f->dst) ||
1425             diff_macaddr(mac, &f->mac))
1426                 goto out;
1427
1428         if (s->callback)
1429                 lua_pushvalue(s->L, 2);
1430
1431         lua_newtable(s->L);
1432
1433         L_setint(s->L, "family", (nd->ndm_family == AF_INET) ? 4 : 6);
1434         L_setstr(s->L, "dev", if_indextoname(nd->ndm_ifindex, buf));
1435
1436         L_setbool(s->L, "router", (nd->ndm_flags & NTF_ROUTER));
1437         L_setbool(s->L, "proxy", (nd->ndm_flags & NTF_PROXY));
1438
1439         L_setbool(s->L, "incomplete", (nd->ndm_state & NUD_INCOMPLETE));
1440         L_setbool(s->L, "reachable", (nd->ndm_state & NUD_REACHABLE));
1441         L_setbool(s->L, "stale", (nd->ndm_state & NUD_STALE));
1442         L_setbool(s->L, "delay", (nd->ndm_state & NUD_DELAY));
1443         L_setbool(s->L, "probe", (nd->ndm_state & NUD_PROBE));
1444         L_setbool(s->L, "failed", (nd->ndm_state & NUD_FAILED));
1445         L_setbool(s->L, "noarp", (nd->ndm_state & NUD_NOARP));
1446         L_setbool(s->L, "permanent", (nd->ndm_state & NUD_PERMANENT));
1447
1448         if (dst)
1449                 L_setaddr(s->L, "dest", nd->ndm_family, dst, -1);
1450
1451         if (mac)
1452                 L_setaddr(s->L, "mac", AF_PACKET, mac, -1);
1453
1454         s->index++;
1455
1456         if (s->callback)
1457                 lua_call(s->L, 1, 0);
1458         else if (hdr->nlmsg_flags & NLM_F_MULTI)
1459                 lua_rawseti(s->L, -2, s->index);
1460
1461 out:
1462         s->pending = !!(hdr->nlmsg_flags & NLM_F_MULTI);
1463         return NL_SKIP;
1464 }
1465
1466 static int neighbor_dump(lua_State *L)
1467 {
1468         cidr_t p = { };
1469         const char *s;
1470         struct ether_addr *mac;
1471         struct dump_filter filter = { .type = 0xFF & ~NUD_NOARP };
1472         struct dump_state st = {
1473                 .callback = lua_isfunction(L, 2),
1474                 .pending = 1,
1475                 .filter = &filter,
1476                 .L = L
1477         };
1478
1479         if (lua_type(L, 1) == LUA_TTABLE)
1480         {
1481                 filter.family = L_getint(L, 1, "family");
1482
1483                 if (filter.family == 4)
1484                         filter.family = AF_INET;
1485                 else if (filter.family == 6)
1486                         filter.family = AF_INET6;
1487                 else
1488                         filter.family = 0;
1489
1490                 if ((s = L_getstr(L, 1, "dev")) != NULL)
1491                         filter.iif = if_nametoindex(s);
1492
1493                 if ((s = L_getstr(L, 1, "dest")) != NULL && parse_cidr(s, &p))
1494                         filter.dst = p;
1495
1496                 if ((s = L_getstr(L, 1, "mac")) != NULL &&
1497                     (mac = ether_aton(s)) != NULL)
1498                         filter.mac = *mac;
1499         }
1500
1501         if (!sock)
1502         {
1503                 sock = nl_socket_alloc();
1504                 if (!sock)
1505                         return _error(L, -1, "Out of memory");
1506
1507                 if (nl_connect(sock, NETLINK_ROUTE))
1508                         return _error(L, 0, NULL);
1509         }
1510
1511         struct nl_msg *msg;
1512         struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
1513         struct ndmsg ndm = {
1514                 .ndm_family = filter.family
1515         };
1516
1517         msg = nlmsg_alloc_simple(RTM_GETNEIGH, NLM_F_REQUEST | NLM_F_DUMP);
1518         if (!msg)
1519                 goto out;
1520
1521         nlmsg_append(msg, &ndm, sizeof(ndm), 0);
1522
1523         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_dump_neigh, &st);
1524         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_done, &st);
1525         nl_cb_err(cb, NL_CB_CUSTOM, cb_error, &st);
1526
1527         nl_send_auto_complete(sock, msg);
1528
1529         if (!st.callback)
1530                 lua_newtable(L);
1531
1532         while (st.pending > 0)
1533                 nl_recvmsgs(sock, cb);
1534
1535         nlmsg_free(msg);
1536
1537 out:
1538         nl_cb_put(cb);
1539         return (st.callback == 0);
1540 }
1541
1542
1543 static int cb_dump_link(struct nl_msg *msg, void *arg)
1544 {
1545         char buf[48];
1546         struct dump_state *s = arg;
1547         struct nlmsghdr *hdr = nlmsg_hdr(msg);
1548         struct ifinfomsg *ifm = NLMSG_DATA(hdr);
1549         struct nlattr *tb[IFLA_MAX+1];
1550         int i, len;
1551
1552         if (hdr->nlmsg_type != RTM_NEWLINK)
1553                 return NL_SKIP;
1554
1555         nlmsg_parse(hdr, sizeof(*ifm), tb, IFLA_MAX, NULL);
1556
1557         L_setbool(s->L, "up", (ifm->ifi_flags & IFF_RUNNING));
1558         L_setint(s->L, "type", ifm->ifi_type);
1559         L_setstr(s->L, "name", if_indextoname(ifm->ifi_index, buf));
1560
1561         if (tb[IFLA_MTU])
1562                 L_setint(s->L, "mtu", RTA_U32(tb[IFLA_MTU]));
1563
1564         if (tb[IFLA_TXQLEN])
1565                 L_setint(s->L, "qlen", RTA_U32(tb[IFLA_TXQLEN]));
1566
1567         if (tb[IFLA_MASTER])
1568                 L_setdev(s->L, "master", tb[IFLA_MASTER]);
1569
1570         if (tb[IFLA_ADDRESS] && nla_len(tb[IFLA_ADDRESS]) == AF_BYTES(AF_PACKET))
1571                 L_setaddr(s->L, "mac", AF_PACKET, nla_get_string(tb[IFLA_ADDRESS]), -1);
1572
1573         s->pending = 0;
1574         return NL_SKIP;
1575 }
1576
1577 static int link_get(lua_State *L)
1578 {
1579         const char *dev = luaL_checkstring(L, 1);
1580         struct dump_state st = {
1581                 .pending = 1,
1582                 .L = L
1583         };
1584
1585         if (!sock)
1586         {
1587                 sock = nl_socket_alloc();
1588                 if (!sock)
1589                         return _error(L, -1, "Out of memory");
1590
1591                 if (nl_connect(sock, NETLINK_ROUTE))
1592                         return _error(L, 0, NULL);
1593         }
1594
1595         struct nl_msg *msg = nlmsg_alloc_simple(RTM_GETLINK, NLM_F_REQUEST);
1596         struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
1597         struct ifinfomsg ifm = { .ifi_index = if_nametoindex(dev) };
1598
1599         if (!msg || !cb)
1600                 return 0;
1601
1602         nlmsg_append(msg, &ifm, sizeof(ifm), 0);
1603
1604         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_dump_link, &st);
1605         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_done, &st);
1606         nl_cb_err(cb, NL_CB_CUSTOM, cb_error, &st);
1607
1608         lua_newtable(L);
1609
1610         nl_send_auto_complete(sock, msg);
1611
1612         while (st.pending > 0)
1613                 nl_recvmsgs(sock, cb);
1614
1615         nlmsg_free(msg);
1616         nl_cb_put(cb);
1617
1618         return 1;
1619 }
1620
1621
1622 static const luaL_reg ip_methods[] = {
1623         { "new",                        cidr_new          },
1624         { "IPv4",                       cidr_ipv4         },
1625         { "IPv6",                       cidr_ipv6         },
1626         { "MAC",                        cidr_mac          },
1627
1628         { "checkip4",                   cidr_checkip4     },
1629         { "checkip6",                   cidr_checkip6     },
1630         { "checkmac",                   cidr_checkmac     },
1631
1632         { "route",                      route_get         },
1633         { "routes",                     route_dump        },
1634
1635         { "neighbors",          neighbor_dump     },
1636
1637         { "link",                       link_get          },
1638
1639         { }
1640 };
1641
1642 static const luaL_reg ip_cidr_methods[] = {
1643         { "is4",                        cidr_is4          },
1644         { "is4rfc1918",         cidr_is4rfc1918   },
1645         { "is4linklocal",       cidr_is4linklocal },
1646         { "is6",                        cidr_is6          },
1647         { "is6linklocal",       cidr_is6linklocal },
1648         { "is6mapped4",         cidr_is6mapped4   },
1649         { "ismac",                      cidr_ismac        },
1650         { "ismaclocal",         cidr_ismaclocal   },
1651         { "ismacmcast",         cidr_ismacmcast   },
1652         { "lower",                      cidr_lower        },
1653         { "higher",                     cidr_higher       },
1654         { "equal",                      cidr_equal        },
1655         { "prefix",                     cidr_prefix       },
1656         { "network",            cidr_network      },
1657         { "host",                       cidr_host         },
1658         { "mask",                       cidr_mask         },
1659         { "broadcast",          cidr_broadcast    },
1660         { "mapped4",            cidr_mapped4      },
1661         { "unscoped",           cidr_unscoped     },
1662         { "tomac",                      cidr_tomac        },
1663         { "tolinklocal",        cidr_tolinklocal  },
1664         { "contains",           cidr_contains     },
1665         { "add",                        cidr_add          },
1666         { "sub",                        cidr_sub          },
1667         { "minhost",            cidr_minhost      },
1668         { "maxhost",            cidr_maxhost      },
1669         { "string",                     cidr_tostring     },
1670
1671         { "__lt",                       cidr_lower        },
1672         { "__le",                       cidr_lower_equal  },
1673         { "__eq",                       cidr_equal        },
1674         { "__add",                      cidr_add          },
1675         { "__sub",                      cidr_sub          },
1676         { "__gc",                       cidr_gc           },
1677         { "__tostring",         cidr_tostring     },
1678
1679         { }
1680 };
1681
1682 int luaopen_luci_ip(lua_State *L)
1683 {
1684         luaL_register(L, LUCI_IP, ip_methods);
1685
1686         luaL_newmetatable(L, LUCI_IP_CIDR);
1687         luaL_register(L, NULL, ip_cidr_methods);
1688         lua_pushvalue(L, -1);
1689         lua_setfield(L, -2, "__index");
1690         lua_pop(L, 1);
1691
1692         return 1;
1693 }