modules/luci-base/luasrc/model/network.lua

   1 -- Copyright 2009-2015 Jo-Philipp Wich <jow@openwrt.org>
   2 -- Licensed to the public under the Apache License 2.0.
   3
   4 local type, next, pairs, ipairs, loadfile, table, select
   5         = type, next, pairs, ipairs, loadfile, table, select
   6
   7 local tonumber, tostring, math = tonumber, tostring, math
   8
   9 local require = require
  10
  11 local nxo = require "nixio"
  12 local nfs = require "nixio.fs"
  13 local ipc = require "luci.ip"
  14 local sys = require "luci.sys"
  15 local utl = require "luci.util"
  16 local dsp = require "luci.dispatcher"
  17 local uci = require "luci.model.uci"
  18 local lng = require "luci.i18n"
  19 local jsc = require "luci.jsonc"
  20
  21 module "luci.model.network"
  22
  23
  24 IFACE_PATTERNS_VIRTUAL  = { }
  25 IFACE_PATTERNS_IGNORE   = { "^wmaster%d", "^wifi%d", "^hwsim%d", "^imq%d", "^ifb%d", "^mon%.wlan%d", "^sit%d", "^gre%d", "^gretap%d", "^ip6gre%d", "^ip6tnl%d", "^tunl%d", "^lo$" }
  26 IFACE_PATTERNS_WIRELESS = { "^wlan%d", "^wl%d", "^ath%d", "^%w+%.network%d" }
  27
  28
  29 protocol = utl.class()
  30
  31 local _protocols = { }
  32
  33 local _interfaces, _bridge, _switch, _tunnel, _swtopo
  34 local _ubusnetcache, _ubusdevcache, _ubuswificache
  35 local _uci
  36
  37 function _filter(c, s, o, r)
  38         local val = _uci:get(c, s, o)
  39         if val then
  40                 local l = { }
  41                 if type(val) == "string" then
  42                         for val in val:gmatch("%S+") do
  43                                 if val ~= r then
  44                                         l[#l+1] = val
  45                                 end
  46                         end
  47                         if #l > 0 then
  48                                 _uci:set(c, s, o, table.concat(l, " "))
  49                         else
  50                                 _uci:delete(c, s, o)
  51                         end
  52                 elseif type(val) == "table" then
  53                         for _, val in ipairs(val) do
  54                                 if val ~= r then
  55                                         l[#l+1] = val
  56                                 end
  57                         end
  58                         if #l > 0 then
  59                                 _uci:set(c, s, o, l)
  60                         else
  61                                 _uci:delete(c, s, o)
  62                         end
  63                 end
  64         end
  65 end
  66
  67 function _append(c, s, o, a)
  68         local val = _uci:get(c, s, o) or ""
  69         if type(val) == "string" then
  70                 local l = { }
  71                 for val in val:gmatch("%S+") do
  72                         if val ~= a then
  73                                 l[#l+1] = val
  74                         end
  75                 end
  76                 l[#l+1] = a
  77                 _uci:set(c, s, o, table.concat(l, " "))
  78         elseif type(val) == "table" then
  79                 local l = { }
  80                 for _, val in ipairs(val) do
  81                         if val ~= a then
  82                                 l[#l+1] = val
  83                         end
  84                 end
  85                 l[#l+1] = a
  86                 _uci:set(c, s, o, l)
  87         end
  88 end
  89
  90 function _stror(s1, s2)
  91         if not s1 or #s1 == 0 then
  92                 return s2 and #s2 > 0 and s2
  93         else
  94                 return s1
  95         end
  96 end
  97
  98 function _get(c, s, o)
  99         return _uci:get(c, s, o)
 100 end
 101
 102 function _set(c, s, o, v)
 103         if v ~= nil then
 104                 if type(v) == "boolean" then v = v and "1" or "0" end
 105                 return _uci:set(c, s, o, v)
 106         else
 107                 return _uci:delete(c, s, o)
 108         end
 109 end
 110
 111 function _wifi_iface(x)
 112         local _, p
 113         for _, p in ipairs(IFACE_PATTERNS_WIRELESS) do
 114                 if x:match(p) then
 115                         return true
 116                 end
 117         end
 118         return false
 119 end
 120
 121 function _wifi_state(key, val, field)
 122         local radio, radiostate, ifc, ifcstate
 123
 124         if not next(_ubuswificache) then
 125                 _ubuswificache = utl.ubus("network.wireless", "status", {}) or {}
 126
 127                 -- workaround extended section format
 128                 for radio, radiostate in pairs(_ubuswificache) do
 129                         for ifc, ifcstate in pairs(radiostate.interfaces) do
 130                                 if ifcstate.section and ifcstate.section:sub(1, 1) == '@' then
 131                                         local s = _uci:get_all('wireless.%s' % ifcstate.section)
 132                                         if s then
 133                                                 ifcstate.section = s['.name']
 134                                         end
 135                                 end
 136                         end
 137                 end
 138         end
 139
 140         for radio, radiostate in pairs(_ubuswificache) do
 141                 for ifc, ifcstate in pairs(radiostate.interfaces) do
 142                         if ifcstate[key] == val then
 143                                 return ifcstate[field]
 144                         end
 145                 end
 146         end
 147 end
 148
 149 function _wifi_lookup(ifn)
 150         -- got a radio#.network# pseudo iface, locate the corresponding section
 151         local radio, ifnidx = ifn:match("^(%w+)%.network(%d+)$")
 152         if radio and ifnidx then
 153                 local sid = nil
 154                 local num = 0
 155
 156                 ifnidx = tonumber(ifnidx)
 157                 _uci:foreach("wireless", "wifi-iface",
 158                         function(s)
 159                                 if s.device == radio then
 160                                         num = num + 1
 161                                         if num == ifnidx then
 162                                                 sid = s['.name']
 163                                                 return false
 164                                         end
 165                                 end
 166                         end)
 167
 168                 return sid
 169
 170         -- looks like wifi, try to locate the section via ubus state
 171         elseif _wifi_iface(ifn) then
 172                 return _wifi_state("ifname", ifn, "section")
 173         end
 174 end
 175
 176 function _iface_virtual(x)
 177         local _, p
 178         for _, p in ipairs(IFACE_PATTERNS_VIRTUAL) do
 179                 if x:match(p) then
 180                         return true
 181                 end
 182         end
 183         return false
 184 end
 185
 186 function _iface_ignore(x)
 187         local _, p
 188         for _, p in ipairs(IFACE_PATTERNS_IGNORE) do
 189                 if x:match(p) then
 190                         return true
 191                 end
 192         end
 193         return false
 194 end
 195
 196 function init(cursor)
 197         _uci = cursor or _uci or uci.cursor()
 198
 199         _interfaces = { }
 200         _bridge     = { }
 201         _switch     = { }
 202         _tunnel     = { }
 203         _swtopo     = { }
 204
 205         _ubusnetcache  = { }
 206         _ubusdevcache  = { }
 207         _ubuswificache = { }
 208
 209         -- read interface information
 210         local n, i
 211         for n, i in ipairs(nxo.getifaddrs()) do
 212                 local name = i.name:match("[^:]+")
 213
 214                 if _iface_virtual(name) then
 215                         _tunnel[name] = true
 216                 end
 217
 218                 if _tunnel[name] or not (_iface_ignore(name) or _iface_virtual(name)) then
 219                         _interfaces[name] = _interfaces[name] or {
 220                                 idx      = i.ifindex or n,
 221                                 name     = name,
 222                                 rawname  = i.name,
 223                                 flags    = { },
 224                                 ipaddrs  = { },
 225                                 ip6addrs = { }
 226                         }
 227
 228                         if i.family == "packet" then
 229                                 _interfaces[name].flags   = i.flags
 230                                 _interfaces[name].stats   = i.data
 231                                 _interfaces[name].macaddr = i.addr
 232                         elseif i.family == "inet" then
 233                                 _interfaces[name].ipaddrs[#_interfaces[name].ipaddrs+1] = ipc.IPv4(i.addr, i.netmask)
 234                         elseif i.family == "inet6" then
 235                                 _interfaces[name].ip6addrs[#_interfaces[name].ip6addrs+1] = ipc.IPv6(i.addr, i.netmask)
 236                         end
 237                 end
 238         end
 239
 240         -- read bridge informaton
 241         local b, l
 242         for l in utl.execi("brctl show") do
 243                 if not l:match("STP") then
 244                         local r = utl.split(l, "%s+", nil, true)
 245                         if #r == 4 then
 246                                 b = {
 247                                         name    = r[1],
 248                                         id      = r[2],
 249                                         stp     = r[3] == "yes",
 250                                         ifnames = { _interfaces[r[4]] }
 251                                 }
 252                                 if b.ifnames[1] then
 253                                         b.ifnames[1].bridge = b
 254                                 end
 255                                 _bridge[r[1]] = b
 256                         elseif b then
 257                                 b.ifnames[#b.ifnames+1] = _interfaces[r[2]]
 258                                 b.ifnames[#b.ifnames].bridge = b
 259                         end
 260                 end
 261         end
 262
 263         -- read switch topology
 264         local boardinfo = jsc.parse(nfs.readfile("/etc/board.json") or "")
 265         if type(boardinfo) == "table" and type(boardinfo.switch) == "table" then
 266                 local switch, layout
 267                 for switch, layout in pairs(boardinfo.switch) do
 268                         if type(layout) == "table" and type(layout.ports) == "table" then
 269                                 local _, port
 270                                 local ports = { }
 271                                 local nports = { }
 272                                 local netdevs = { }
 273
 274                                 for _, port in ipairs(layout.ports) do
 275                                         if type(port) == "table" and
 276                                            type(port.num) == "number" and
 277                                            (type(port.role) == "string" or
 278                                             type(port.device) == "string")
 279                                         then
 280                                                 local spec = {
 281                                                         num    = port.num,
 282                                                         role   = port.role or "cpu",
 283                                                         index  = port.index or port.num
 284                                                 }
 285
 286                                                 if port.device then
 287                                                         spec.device = port.device
 288                                                         spec.tagged = port.need_tag
 289                                                         netdevs[tostring(port.num)] = port.device
 290                                                 end
 291
 292                                                 ports[#ports+1] = spec
 293
 294                                                 if port.role then
 295                                                         nports[port.role] = (nports[port.role] or 0) + 1
 296                                                 end
 297                                         end
 298                                 end
 299
 300                                 table.sort(ports, function(a, b)
 301                                         if a.role ~= b.role then
 302                                                 return (a.role < b.role)
 303                                         end
 304
 305                                         return (a.index < b.index)
 306                                 end)
 307
 308                                 local pnum, role
 309                                 for _, port in ipairs(ports) do
 310                                         if port.role ~= role then
 311                                                 role = port.role
 312                                                 pnum = 1
 313                                         end
 314
 315                                         if role == "cpu" then
 316                                                 port.label = "CPU (%s)" % port.device
 317                                         elseif nports[role] > 1 then
 318                                                 port.label = "%s %d" %{ role:upper(), pnum }
 319                                                 pnum = pnum + 1
 320                                         else
 321                                                 port.label = role:upper()
 322                                         end
 323
 324                                         port.role = nil
 325                                         port.index = nil
 326                                 end
 327
 328                                 _swtopo[switch] = {
 329                                         ports = ports,
 330                                         netdevs = netdevs
 331                                 }
 332                         end
 333                 end
 334         end
 335
 336         return _M
 337 end
 338
 339 function save(self, ...)
 340         _uci:save(...)
 341         _uci:load(...)
 342 end
 343
 344 function commit(self, ...)
 345         _uci:commit(...)
 346         _uci:load(...)
 347 end
 348
 349 function ifnameof(self, x)
 350         if utl.instanceof(x, interface) then
 351                 return x:name()
 352         elseif utl.instanceof(x, protocol) then
 353                 return x:ifname()
 354         elseif type(x) == "string" then
 355                 return x:match("^[^:]+")
 356         end
 357 end
 358
 359 function get_protocol(self, protoname, netname)
 360         local v = _protocols[protoname]
 361         if v then
 362                 return v(netname or "__dummy__")
 363         end
 364 end
 365
 366 function get_protocols(self)
 367         local p = { }
 368         local _, v
 369         for _, v in ipairs(_protocols) do
 370                 p[#p+1] = v("__dummy__")
 371         end
 372         return p
 373 end
 374
 375 function register_protocol(self, protoname)
 376         local proto = utl.class(protocol)
 377
 378         function proto.__init__(self, name)
 379                 self.sid = name
 380         end
 381
 382         function proto.proto(self)
 383                 return protoname
 384         end
 385
 386         _protocols[#_protocols+1] = proto
 387         _protocols[protoname]     = proto
 388
 389         return proto
 390 end
 391
 392 function register_pattern_virtual(self, pat)
 393         IFACE_PATTERNS_VIRTUAL[#IFACE_PATTERNS_VIRTUAL+1] = pat
 394 end
 395
 396
 397 function has_ipv6(self)
 398         return nfs.access("/proc/net/ipv6_route")
 399 end
 400
 401 function add_network(self, n, options)
 402         local oldnet = self:get_network(n)
 403         if n and #n > 0 and n:match("^[a-zA-Z0-9_]+$") and not oldnet then
 404                 if _uci:section("network", "interface", n, options) then
 405                         return network(n)
 406                 end
 407         elseif oldnet and oldnet:is_empty() then
 408                 if options then
 409                         local k, v
 410                         for k, v in pairs(options) do
 411                                 oldnet:set(k, v)
 412                         end
 413                 end
 414                 return oldnet
 415         end
 416 end
 417
 418 function get_network(self, n)
 419         if n and _uci:get("network", n) == "interface" then
 420                 return network(n)
 421         end
 422 end
 423
 424 function get_networks(self)
 425         local nets = { }
 426         local nls = { }
 427
 428         _uci:foreach("network", "interface",
 429                 function(s)
 430                         nls[s['.name']] = network(s['.name'])
 431                 end)
 432
 433         local n
 434         for n in utl.kspairs(nls) do
 435                 nets[#nets+1] = nls[n]
 436         end
 437
 438         return nets
 439 end
 440
 441 function del_network(self, n)
 442         local r = _uci:delete("network", n)
 443         if r then
 444                 _uci:delete_all("network", "alias",
 445                         function(s) return (s.interface == n) end)
 446
 447                 _uci:delete_all("network", "route",
 448                         function(s) return (s.interface == n) end)
 449
 450                 _uci:delete_all("network", "route6",
 451                         function(s) return (s.interface == n) end)
 452
 453                 _uci:foreach("wireless", "wifi-iface",
 454                         function(s)
 455                                 local net
 456                                 local rest = { }
 457                                 for net in utl.imatch(s.network) do
 458                                         if net ~= n then
 459                                                 rest[#rest+1] = net
 460                                         end
 461                                 end
 462                                 if #rest > 0 then
 463                                         _uci:set("wireless", s['.name'], "network",
 464                                                       table.concat(rest, " "))
 465                                 else
 466                                         _uci:delete("wireless", s['.name'], "network")
 467                                 end
 468                         end)
 469         end
 470         return r
 471 end
 472
 473 function rename_network(self, old, new)
 474         local r
 475         if new and #new > 0 and new:match("^[a-zA-Z0-9_]+$") and not self:get_network(new) then
 476                 r = _uci:section("network", "interface", new, _uci:get_all("network", old))
 477
 478                 if r then
 479                         _uci:foreach("network", "alias",
 480                                 function(s)
 481                                         if s.interface == old then
 482                                                 _uci:set("network", s['.name'], "interface", new)
 483                                         end
 484                                 end)
 485
 486                         _uci:foreach("network", "route",
 487                                 function(s)
 488                                         if s.interface == old then
 489                                                 _uci:set("network", s['.name'], "interface", new)
 490                                         end
 491                                 end)
 492
 493                         _uci:foreach("network", "route6",
 494                                 function(s)
 495                                         if s.interface == old then
 496                                                 _uci:set("network", s['.name'], "interface", new)
 497                                         end
 498                                 end)
 499
 500                         _uci:foreach("wireless", "wifi-iface",
 501                                 function(s)
 502                                         local net
 503                                         local list = { }
 504                                         for net in utl.imatch(s.network) do
 505                                                 if net == old then
 506                                                         list[#list+1] = new
 507                                                 else
 508                                                         list[#list+1] = net
 509                                                 end
 510                                         end
 511                                         if #list > 0 then
 512                                                 _uci:set("wireless", s['.name'], "network",
 513                                                               table.concat(list, " "))
 514                                         end
 515                                 end)
 516
 517                         _uci:delete("network", old)
 518                 end
 519         end
 520         return r or false
 521 end
 522
 523 function get_interface(self, i)
 524         if _interfaces[i] or _wifi_iface(i) then
 525                 return interface(i)
 526         else
 527                 local ifc
 528                 local num = { }
 529                 _uci:foreach("wireless", "wifi-iface",
 530                         function(s)
 531                                 if s.device then
 532                                         num[s.device] = num[s.device] and num[s.device] + 1 or 1
 533                                         if s['.name'] == i then
 534                                                 ifc = interface(
 535                                                         "%s.network%d" %{s.device, num[s.device] })
 536                                                 return false
 537                                         end
 538                                 end
 539                         end)
 540                 return ifc
 541         end
 542 end
 543
 544 function get_interfaces(self)
 545         local iface
 546         local ifaces = { }
 547         local nfs = { }
 548
 549         -- find normal interfaces
 550         _uci:foreach("network", "interface",
 551                 function(s)
 552                         for iface in utl.imatch(s.ifname) do
 553                                 if not _iface_ignore(iface) and not _iface_virtual(iface) and not _wifi_iface(iface) then
 554                                         nfs[iface] = interface(iface)
 555                                 end
 556                         end
 557                 end)
 558
 559         for iface in utl.kspairs(_interfaces) do
 560                 if not (nfs[iface] or _iface_ignore(iface) or _iface_virtual(iface) or _wifi_iface(iface)) then
 561                         nfs[iface] = interface(iface)
 562                 end
 563         end
 564
 565         -- find vlan interfaces
 566         _uci:foreach("network", "switch_vlan",
 567                 function(s)
 568                         if type(s.ports) ~= "string" or
 569                            type(s.device) ~= "string" or
 570                            type(_swtopo[s.device]) ~= "table"
 571                         then
 572                                 return
 573                         end
 574
 575                         local pnum, ptag
 576                         for pnum, ptag in s.ports:gmatch("(%d+)([tu]?)") do
 577                                 local netdev = _swtopo[s.device].netdevs[pnum]
 578                                 if netdev then
 579                                         if not nfs[netdev] then
 580                                                 nfs[netdev] = interface(netdev)
 581                                         end
 582                                         _switch[netdev] = true
 583
 584                                         if ptag == "t" then
 585                                                 local vid = tonumber(s.vid or s.vlan)
 586                                                 if vid ~= nil and vid >= 0 and vid <= 4095 then
 587                                                         local iface = "%s.%d" %{ netdev, vid }
 588                                                         if not nfs[iface] then
 589                                                                 nfs[iface] = interface(iface)
 590                                                         end
 591                                                         _switch[iface] = true
 592                                                 end
 593                                         end
 594                                 end
 595                         end
 596                 end)
 597
 598         for iface in utl.kspairs(nfs) do
 599                 ifaces[#ifaces+1] = nfs[iface]
 600         end
 601
 602         -- find wifi interfaces
 603         local num = { }
 604         local wfs = { }
 605         _uci:foreach("wireless", "wifi-iface",
 606                 function(s)
 607                         if s.device then
 608                                 num[s.device] = num[s.device] and num[s.device] + 1 or 1
 609                                 local i = "%s.network%d" %{ s.device, num[s.device] }
 610                                 wfs[i] = interface(i)
 611                         end
 612                 end)
 613
 614         for iface in utl.kspairs(wfs) do
 615                 ifaces[#ifaces+1] = wfs[iface]
 616         end
 617
 618         return ifaces
 619 end
 620
 621 function ignore_interface(self, x)
 622         return _iface_ignore(x)
 623 end
 624
 625 function get_wifidev(self, dev)
 626         if _uci:get("wireless", dev) == "wifi-device" then
 627                 return wifidev(dev)
 628         end
 629 end
 630
 631 function get_wifidevs(self)
 632         local devs = { }
 633         local wfd  = { }
 634
 635         _uci:foreach("wireless", "wifi-device",
 636                 function(s) wfd[#wfd+1] = s['.name'] end)
 637
 638         local dev
 639         for _, dev in utl.vspairs(wfd) do
 640                 devs[#devs+1] = wifidev(dev)
 641         end
 642
 643         return devs
 644 end
 645
 646 function get_wifinet(self, net)
 647         local wnet = _wifi_lookup(net)
 648         if wnet then
 649                 return wifinet(wnet)
 650         end
 651 end
 652
 653 function add_wifinet(self, net, options)
 654         if type(options) == "table" and options.device and
 655                 _uci:get("wireless", options.device) == "wifi-device"
 656         then
 657                 local wnet = _uci:section("wireless", "wifi-iface", nil, options)
 658                 return wifinet(wnet)
 659         end
 660 end
 661
 662 function del_wifinet(self, net)
 663         local wnet = _wifi_lookup(net)
 664         if wnet then
 665                 _uci:delete("wireless", wnet)
 666                 return true
 667         end
 668         return false
 669 end
 670
 671 function get_status_by_route(self, addr, mask)
 672         local _, object
 673         for _, object in ipairs(utl.ubus()) do
 674                 local net = object:match("^network%.interface%.(.+)")
 675                 if net then
 676                         local s = utl.ubus(object, "status", {})
 677                         if s and s.route then
 678                                 local rt
 679                                 for _, rt in ipairs(s.route) do
 680                                         if not rt.table and rt.target == addr and rt.mask == mask then
 681                                                 return net, s
 682                                         end
 683                                 end
 684                         end
 685                 end
 686         end
 687 end
 688
 689 function get_status_by_address(self, addr)
 690         local _, object
 691         for _, object in ipairs(utl.ubus()) do
 692                 local net = object:match("^network%.interface%.(.+)")
 693                 if net then
 694                         local s = utl.ubus(object, "status", {})
 695                         if s and s['ipv4-address'] then
 696                                 local a
 697                                 for _, a in ipairs(s['ipv4-address']) do
 698                                         if a.address == addr then
 699                                                 return net, s
 700                                         end
 701                                 end
 702                         end
 703                         if s and s['ipv6-address'] then
 704                                 local a
 705                                 for _, a in ipairs(s['ipv6-address']) do
 706                                         if a.address == addr then
 707                                                 return net, s
 708                                         end
 709                                 end
 710                         end
 711                 end
 712         end
 713 end
 714
 715 function get_wannet(self)
 716         local net, stat = self:get_status_by_route("0.0.0.0", 0)
 717         return net and network(net, stat.proto)
 718 end
 719
 720 function get_wandev(self)
 721         local _, stat = self:get_status_by_route("0.0.0.0", 0)
 722         return stat and interface(stat.l3_device or stat.device)
 723 end
 724
 725 function get_wan6net(self)
 726         local net, stat = self:get_status_by_route("::", 0)
 727         return net and network(net, stat.proto)
 728 end
 729
 730 function get_wan6dev(self)
 731         local _, stat = self:get_status_by_route("::", 0)
 732         return stat and interface(stat.l3_device or stat.device)
 733 end
 734
 735 function get_switch_topologies(self)
 736         return _swtopo
 737 end
 738
 739
 740 function network(name, proto)
 741         if name then
 742                 local p = proto or _uci:get("network", name, "proto")
 743                 local c = p and _protocols[p] or protocol
 744                 return c(name)
 745         end
 746 end
 747
 748 function protocol.__init__(self, name)
 749         self.sid = name
 750 end
 751
 752 function protocol._get(self, opt)
 753         local v = _uci:get("network", self.sid, opt)
 754         if type(v) == "table" then
 755                 return table.concat(v, " ")
 756         end
 757         return v or ""
 758 end
 759
 760 function protocol._ubus(self, field)
 761         if not _ubusnetcache[self.sid] then
 762                 _ubusnetcache[self.sid] = utl.ubus("network.interface.%s" % self.sid,
 763                                                    "status", { })
 764         end
 765         if _ubusnetcache[self.sid] and field then
 766                 return _ubusnetcache[self.sid][field]
 767         end
 768         return _ubusnetcache[self.sid]
 769 end
 770
 771 function protocol.get(self, opt)
 772         return _get("network", self.sid, opt)
 773 end
 774
 775 function protocol.set(self, opt, val)
 776         return _set("network", self.sid, opt, val)
 777 end
 778
 779 function protocol.ifname(self)
 780         local ifname
 781         if self:is_floating() then
 782                 ifname = self:_ubus("l3_device")
 783         else
 784                 ifname = self:_ubus("device")
 785         end
 786         if not ifname then
 787                 local num = { }
 788                 _uci:foreach("wireless", "wifi-iface",
 789                         function(s)
 790                                 if s.device then
 791                                         num[s.device] = num[s.device]
 792                                                 and num[s.device] + 1 or 1
 793
 794                                         local net
 795                                         for net in utl.imatch(s.network) do
 796                                                 if net == self.sid then
 797                                                         ifname = "%s.network%d" %{ s.device, num[s.device] }
 798                                                         return false
 799                                                 end
 800                                         end
 801                                 end
 802                         end)
 803         end
 804         return ifname
 805 end
 806
 807 function protocol.proto(self)
 808         return "none"
 809 end
 810
 811 function protocol.get_i18n(self)
 812         local p = self:proto()
 813         if p == "none" then
 814                 return lng.translate("Unmanaged")
 815         elseif p == "static" then
 816                 return lng.translate("Static address")
 817         elseif p == "dhcp" then
 818                 return lng.translate("DHCP client")
 819         else
 820                 return lng.translate("Unknown")
 821         end
 822 end
 823
 824 function protocol.type(self)
 825         return self:_get("type")
 826 end
 827
 828 function protocol.name(self)
 829         return self.sid
 830 end
 831
 832 function protocol.uptime(self)
 833         return self:_ubus("uptime") or 0
 834 end
 835
 836 function protocol.expires(self)
 837         local u = self:_ubus("uptime")
 838         local d = self:_ubus("data")
 839
 840         if type(u) == "number" and type(d) == "table" and
 841            type(d.leasetime) == "number"
 842         then
 843                 local r = (d.leasetime - (u % d.leasetime))
 844                 return r > 0 and r or 0
 845         end
 846
 847         return -1
 848 end
 849
 850 function protocol.metric(self)
 851         return self:_ubus("metric") or 0
 852 end
 853
 854 function protocol.ipaddr(self)
 855         local addrs = self:_ubus("ipv4-address")
 856         return addrs and #addrs > 0 and addrs[1].address
 857 end
 858
 859 function protocol.ipaddrs(self)
 860         local addrs = self:_ubus("ipv4-address")
 861         local rv = { }
 862
 863         if type(addrs) == "table" then
 864                 local n, addr
 865                 for n, addr in ipairs(addrs) do
 866                         rv[#rv+1] = "%s/%d" %{ addr.address, addr.mask }
 867                 end
 868         end
 869
 870         return rv
 871 end
 872
 873 function protocol.netmask(self)
 874         local addrs = self:_ubus("ipv4-address")
 875         return addrs and #addrs > 0 and
 876                 ipc.IPv4("0.0.0.0/%d" % addrs[1].mask):mask():string()
 877 end
 878
 879 function protocol.gwaddr(self)
 880         local _, route
 881         for _, route in ipairs(self:_ubus("route") or { }) do
 882                 if route.target == "0.0.0.0" and route.mask == 0 then
 883                         return route.nexthop
 884                 end
 885         end
 886 end
 887
 888 function protocol.dnsaddrs(self)
 889         local dns = { }
 890         local _, addr
 891         for _, addr in ipairs(self:_ubus("dns-server") or { }) do
 892                 if not addr:match(":") then
 893                         dns[#dns+1] = addr
 894                 end
 895         end
 896         return dns
 897 end
 898
 899 function protocol.ip6addr(self)
 900         local addrs = self:_ubus("ipv6-address")
 901         if addrs and #addrs > 0 then
 902                 return "%s/%d" %{ addrs[1].address, addrs[1].mask }
 903         else
 904                 addrs = self:_ubus("ipv6-prefix-assignment")
 905                 if addrs and #addrs > 0 then
 906                         return "%s/%d" %{ addrs[1].address, addrs[1].mask }
 907                 end
 908         end
 909 end
 910
 911 function protocol.ip6addrs(self)
 912         local addrs = self:_ubus("ipv6-address")
 913         local rv = { }
 914         local n, addr
 915
 916         if type(addrs) == "table" then
 917                 for n, addr in ipairs(addrs) do
 918                         rv[#rv+1] = "%s/%d" %{ addr.address, addr.mask }
 919                 end
 920         end
 921
 922         addrs = self:_ubus("ipv6-prefix-assignment")
 923
 924         if type(addrs) == "table" then
 925                 for n, addr in ipairs(addrs) do
 926                         rv[#rv+1] = "%s1/%d" %{ addr.address, addr.mask }
 927                 end
 928         end
 929
 930         return rv
 931 end
 932
 933 function protocol.gw6addr(self)
 934         local _, route
 935         for _, route in ipairs(self:_ubus("route") or { }) do
 936                 if route.target == "::" and route.mask == 0 then
 937                         return ipc.IPv6(route.nexthop):string()
 938                 end
 939         end
 940 end
 941
 942 function protocol.dns6addrs(self)
 943         local dns = { }
 944         local _, addr
 945         for _, addr in ipairs(self:_ubus("dns-server") or { }) do
 946                 if addr:match(":") then
 947                         dns[#dns+1] = addr
 948                 end
 949         end
 950         return dns
 951 end
 952
 953 function protocol.ip6prefix(self)
 954         local prefix = self:_ubus("ipv6-prefix")
 955         if prefix and #prefix > 0 then
 956                 return "%s/%d" %{ prefix[1].address, prefix[1].mask }
 957         end
 958 end
 959
 960 function protocol.is_bridge(self)
 961         return (not self:is_virtual() and self:type() == "bridge")
 962 end
 963
 964 function protocol.opkg_package(self)
 965         return nil
 966 end
 967
 968 function protocol.is_installed(self)
 969         return true
 970 end
 971
 972 function protocol.is_virtual(self)
 973         return false
 974 end
 975
 976 function protocol.is_floating(self)
 977         return false
 978 end
 979
 980 function protocol.is_empty(self)
 981         if self:is_floating() then
 982                 return false
 983         else
 984                 local rv = true
 985
 986                 if (self:_get("ifname") or ""):match("%S+") then
 987                         rv = false
 988                 end
 989
 990                 _uci:foreach("wireless", "wifi-iface",
 991                         function(s)
 992                                 local n
 993                                 for n in utl.imatch(s.network) do
 994                                         if n == self.sid then
 995                                                 rv = false
 996                                                 return false
 997                                         end
 998                                 end
 999                         end)
1000
1001                 return rv
1002         end
1003 end
1004
1005 function protocol.add_interface(self, ifname)
1006         ifname = _M:ifnameof(ifname)
1007         if ifname and not self:is_floating() then
1008                 -- if its a wifi interface, change its network option
1009                 local wif = _wifi_lookup(ifname)
1010                 if wif then
1011                         _append("wireless", wif, "network", self.sid)
1012
1013                 -- add iface to our iface list
1014                 else
1015                         _append("network", self.sid, "ifname", ifname)
1016                 end
1017         end
1018 end
1019
1020 function protocol.del_interface(self, ifname)
1021         ifname = _M:ifnameof(ifname)
1022         if ifname and not self:is_floating() then
1023                 -- if its a wireless interface, clear its network option
1024                 local wif = _wifi_lookup(ifname)
1025                 if wif then _filter("wireless", wif, "network", self.sid) end
1026
1027                 -- remove the interface
1028                 _filter("network", self.sid, "ifname", ifname)
1029         end
1030 end
1031
1032 function protocol.get_interface(self)
1033         if self:is_virtual() then
1034                 _tunnel[self:proto() .. "-" .. self.sid] = true
1035                 return interface(self:proto() .. "-" .. self.sid, self)
1036         elseif self:is_bridge() then
1037                 _bridge["br-" .. self.sid] = true
1038                 return interface("br-" .. self.sid, self)
1039         else
1040                 local ifn = nil
1041                 local num = { }
1042                 for ifn in utl.imatch(_uci:get("network", self.sid, "ifname")) do
1043                         ifn = ifn:match("^[^:/]+")
1044                         return ifn and interface(ifn, self)
1045                 end
1046                 ifn = nil
1047                 _uci:foreach("wireless", "wifi-iface",
1048                         function(s)
1049                                 if s.device then
1050                                         num[s.device] = num[s.device] and num[s.device] + 1 or 1
1051
1052                                         local net
1053                                         for net in utl.imatch(s.network) do
1054                                                 if net == self.sid then
1055                                                         ifn = "%s.network%d" %{ s.device, num[s.device] }
1056                                                         return false
1057                                                 end
1058                                         end
1059                                 end
1060                         end)
1061                 return ifn and interface(ifn, self)
1062         end
1063 end
1064
1065 function protocol.get_interfaces(self)
1066         if self:is_bridge() or (self:is_virtual() and not self:is_floating()) then
1067                 local ifaces = { }
1068
1069                 local ifn
1070                 local nfs = { }
1071                 for ifn in utl.imatch(self:get("ifname")) do
1072                         ifn = ifn:match("^[^:/]+")
1073                         nfs[ifn] = interface(ifn, self)
1074                 end
1075
1076                 for ifn in utl.kspairs(nfs) do
1077                         ifaces[#ifaces+1] = nfs[ifn]
1078                 end
1079
1080                 local num = { }
1081                 local wfs = { }
1082                 _uci:foreach("wireless", "wifi-iface",
1083                         function(s)
1084                                 if s.device then
1085                                         num[s.device] = num[s.device] and num[s.device] + 1 or 1
1086
1087                                         local net
1088                                         for net in utl.imatch(s.network) do
1089                                                 if net == self.sid then
1090                                                         ifn = "%s.network%d" %{ s.device, num[s.device] }
1091                                                         wfs[ifn] = interface(ifn, self)
1092                                                 end
1093                                         end
1094                                 end
1095                         end)
1096
1097                 for ifn in utl.kspairs(wfs) do
1098                         ifaces[#ifaces+1] = wfs[ifn]
1099                 end
1100
1101                 return ifaces
1102         end
1103 end
1104
1105 function protocol.contains_interface(self, ifname)
1106         ifname = _M:ifnameof(ifname)
1107         if not ifname then
1108                 return false
1109         elseif self:is_virtual() and self:proto() .. "-" .. self.sid == ifname then
1110                 return true
1111         elseif self:is_bridge() and "br-" .. self.sid == ifname then
1112                 return true
1113         else
1114                 local ifn
1115                 for ifn in utl.imatch(self:get("ifname")) do
1116                         ifn = ifn:match("[^:]+")
1117                         if ifn == ifname then
1118                                 return true
1119                         end
1120                 end
1121
1122                 local wif = _wifi_lookup(ifname)
1123                 if wif then
1124                         local n
1125                         for n in utl.imatch(_uci:get("wireless", wif, "network")) do
1126                                 if n == self.sid then
1127                                         return true
1128                                 end
1129                         end
1130                 end
1131         end
1132
1133         return false
1134 end
1135
1136 function protocol.adminlink(self)
1137         return dsp.build_url("admin", "network", "network", self.sid)
1138 end
1139
1140
1141 interface = utl.class()
1142
1143 function interface.__init__(self, ifname, network)
1144         local wif = _wifi_lookup(ifname)
1145         if wif then
1146                 self.wif    = wifinet(wif)
1147                 self.ifname = _wifi_state("section", wif, "ifname")
1148         end
1149
1150         self.ifname  = self.ifname or ifname
1151         self.dev     = _interfaces[self.ifname]
1152         self.network = network
1153 end
1154
1155 function interface._ubus(self, field)
1156         if not _ubusdevcache[self.ifname] then
1157                 _ubusdevcache[self.ifname] = utl.ubus("network.device", "status",
1158                                                       { name = self.ifname })
1159         end
1160         if _ubusdevcache[self.ifname] and field then
1161                 return _ubusdevcache[self.ifname][field]
1162         end
1163         return _ubusdevcache[self.ifname]
1164 end
1165
1166 function interface.name(self)
1167         return self.wif and self.wif:ifname() or self.ifname
1168 end
1169
1170 function interface.mac(self)
1171         local mac = self:_ubus("macaddr")
1172         return mac and mac:upper()
1173 end
1174
1175 function interface.ipaddrs(self)
1176         return self.dev and self.dev.ipaddrs or { }
1177 end
1178
1179 function interface.ip6addrs(self)
1180         return self.dev and self.dev.ip6addrs or { }
1181 end
1182
1183 function interface.type(self)
1184         if self.wif or _wifi_iface(self.ifname) then
1185                 return "wifi"
1186         elseif _bridge[self.ifname] then
1187                 return "bridge"
1188         elseif _tunnel[self.ifname] then
1189                 return "tunnel"
1190         elseif self.ifname:match("%.") then
1191                 return "vlan"
1192         elseif _switch[self.ifname] then
1193                 return "switch"
1194         else
1195                 return "ethernet"
1196         end
1197 end
1198
1199 function interface.shortname(self)
1200         if self.wif then
1201                 return self.wif:shortname()
1202         else
1203                 return self.ifname
1204         end
1205 end
1206
1207 function interface.get_i18n(self)
1208         if self.wif then
1209                 return "%s: %s %q" %{
1210                         lng.translate("Wireless Network"),
1211                         self.wif:active_mode(),
1212                         self.wif:active_ssid() or self.wif:active_bssid() or self.wif:id()
1213                 }
1214         else
1215                 return "%s: %q" %{ self:get_type_i18n(), self:name() }
1216         end
1217 end
1218
1219 function interface.get_type_i18n(self)
1220         local x = self:type()
1221         if x == "wifi" then
1222                 return lng.translate("Wireless Adapter")
1223         elseif x == "bridge" then
1224                 return lng.translate("Bridge")
1225         elseif x == "switch" then
1226                 return lng.translate("Ethernet Switch")
1227         elseif x == "vlan" then
1228                 if _switch[self.ifname] then
1229                         return lng.translate("Switch VLAN")
1230                 else
1231                         return lng.translate("Software VLAN")
1232                 end
1233         elseif x == "tunnel" then
1234                 return lng.translate("Tunnel Interface")
1235         else
1236                 return lng.translate("Ethernet Adapter")
1237         end
1238 end
1239
1240 function interface.adminlink(self)
1241         if self.wif then
1242                 return self.wif:adminlink()
1243         end
1244 end
1245
1246 function interface.ports(self)
1247         local members = self:_ubus("bridge-members")
1248         if members then
1249                 local _, iface
1250                 local ifaces = { }
1251                 for _, iface in ipairs(members) do
1252                         ifaces[#ifaces+1] = interface(iface)
1253                 end
1254         end
1255 end
1256
1257 function interface.bridge_id(self)
1258         if self.br then
1259                 return self.br.id
1260         else
1261                 return nil
1262         end
1263 end
1264
1265 function interface.bridge_stp(self)
1266         if self.br then
1267                 return self.br.stp
1268         else
1269                 return false
1270         end
1271 end
1272
1273 function interface.is_up(self)
1274         return self:_ubus("up") or false
1275 end
1276
1277 function interface.is_bridge(self)
1278         return (self:type() == "bridge")
1279 end
1280
1281 function interface.is_bridgeport(self)
1282         return self.dev and self.dev.bridge and true or false
1283 end
1284
1285 function interface.tx_bytes(self)
1286         local stat = self:_ubus("statistics")
1287         return stat and stat.tx_bytes or 0
1288 end
1289
1290 function interface.rx_bytes(self)
1291         local stat = self:_ubus("statistics")
1292         return stat and stat.rx_bytes or 0
1293 end
1294
1295 function interface.tx_packets(self)
1296         local stat = self:_ubus("statistics")
1297         return stat and stat.tx_packets or 0
1298 end
1299
1300 function interface.rx_packets(self)
1301         local stat = self:_ubus("statistics")
1302         return stat and stat.rx_packets or 0
1303 end
1304
1305 function interface.get_network(self)
1306         return self:get_networks()[1]
1307 end
1308
1309 function interface.get_networks(self)
1310         if not self.networks then
1311                 local nets = { }
1312                 local _, net
1313                 for _, net in ipairs(_M:get_networks()) do
1314                         if net:contains_interface(self.ifname) or
1315                            net:ifname() == self.ifname
1316                         then
1317                                 nets[#nets+1] = net
1318                         end
1319                 end
1320                 table.sort(nets, function(a, b) return a.sid < b.sid end)
1321                 self.networks = nets
1322                 return nets
1323         else
1324                 return self.networks
1325         end
1326 end
1327
1328 function interface.get_wifinet(self)
1329         return self.wif
1330 end
1331
1332
1333 wifidev = utl.class()
1334
1335 function wifidev.__init__(self, dev)
1336         self.sid    = dev
1337         self.iwinfo = dev and sys.wifi.getiwinfo(dev) or { }
1338 end
1339
1340 function wifidev.get(self, opt)
1341         return _get("wireless", self.sid, opt)
1342 end
1343
1344 function wifidev.set(self, opt, val)
1345         return _set("wireless", self.sid, opt, val)
1346 end
1347
1348 function wifidev.name(self)
1349         return self.sid
1350 end
1351
1352 function wifidev.hwmodes(self)
1353         local l = self.iwinfo.hwmodelist
1354         if l and next(l) then
1355                 return l
1356         else
1357                 return { b = true, g = true }
1358         end
1359 end
1360
1361 function wifidev.get_i18n(self)
1362         local t = "Generic"
1363         if self.iwinfo.type == "wl" then
1364                 t = "Broadcom"
1365         end
1366
1367         local m = ""
1368         local l = self:hwmodes()
1369         if l.a then m = m .. "a" end
1370         if l.b then m = m .. "b" end
1371         if l.g then m = m .. "g" end
1372         if l.n then m = m .. "n" end
1373         if l.ac then m = "ac" end
1374
1375         return "%s 802.11%s Wireless Controller (%s)" %{ t, m, self:name() }
1376 end
1377
1378 function wifidev.is_up(self)
1379         if _ubuswificache[self.sid] then
1380                 return (_ubuswificache[self.sid].up == true)
1381         end
1382
1383         return false
1384 end
1385
1386 function wifidev.get_wifinet(self, net)
1387         if _uci:get("wireless", net) == "wifi-iface" then
1388                 return wifinet(net)
1389         else
1390                 local wnet = _wifi_lookup(net)
1391                 if wnet then
1392                         return wifinet(wnet)
1393                 end
1394         end
1395 end
1396
1397 function wifidev.get_wifinets(self)
1398         local nets = { }
1399
1400         _uci:foreach("wireless", "wifi-iface",
1401                 function(s)
1402                         if s.device == self.sid then
1403                                 nets[#nets+1] = wifinet(s['.name'])
1404                         end
1405                 end)
1406
1407         return nets
1408 end
1409
1410 function wifidev.add_wifinet(self, options)
1411         options = options or { }
1412         options.device = self.sid
1413
1414         local wnet = _uci:section("wireless", "wifi-iface", nil, options)
1415         if wnet then
1416                 return wifinet(wnet, options)
1417         end
1418 end
1419
1420 function wifidev.del_wifinet(self, net)
1421         if utl.instanceof(net, wifinet) then
1422                 net = net.sid
1423         elseif _uci:get("wireless", net) ~= "wifi-iface" then
1424                 net = _wifi_lookup(net)
1425         end
1426
1427         if net and _uci:get("wireless", net, "device") == self.sid then
1428                 _uci:delete("wireless", net)
1429                 return true
1430         end
1431
1432         return false
1433 end
1434
1435
1436 wifinet = utl.class()
1437
1438 function wifinet.__init__(self, net, data)
1439         self.sid = net
1440
1441         local n = 0
1442         local num = { }
1443         local netid, sid
1444         _uci:foreach("wireless", "wifi-iface",
1445                 function(s)
1446                         n = n + 1
1447                         if s.device then
1448                                 num[s.device] = num[s.device] and num[s.device] + 1 or 1
1449                                 if s['.name'] == self.sid then
1450                                         sid = "@wifi-iface[%d]" % n
1451                                         netid = "%s.network%d" %{ s.device, num[s.device] }
1452                                         return false
1453                                 end
1454                         end
1455                 end)
1456
1457         if sid then
1458                 local _, k, r, i
1459                 for k, r in pairs(_ubuswificache) do
1460                         if type(r) == "table" and
1461                            type(r.interfaces) == "table"
1462                         then
1463                                 for _, i in ipairs(r.interfaces) do
1464                                         if type(i) == "table" and i.section == sid then
1465                                                 self._ubusdata = {
1466                                                         radio = k,
1467                                                         dev = r,
1468                                                         net = i
1469                                                 }
1470                                         end
1471                                 end
1472                         end
1473                 end
1474         end
1475
1476         local dev = _wifi_state("section", self.sid, "ifname") or netid
1477
1478         self.netid  = netid
1479         self.wdev   = dev
1480         self.iwinfo = dev and sys.wifi.getiwinfo(dev) or { }
1481 end
1482
1483 function wifinet.ubus(self, ...)
1484         local n, v = self._ubusdata
1485         for n = 1, select('#', ...) do
1486                 if type(v) == "table" then
1487                         v = v[select(n, ...)]
1488                 else
1489                         return nil
1490                 end
1491         end
1492         return v
1493 end
1494
1495 function wifinet.get(self, opt)
1496         return _get("wireless", self.sid, opt)
1497 end
1498
1499 function wifinet.set(self, opt, val)
1500         return _set("wireless", self.sid, opt, val)
1501 end
1502
1503 function wifinet.mode(self)
1504         return self:ubus("net", "config", "mode") or self:get("mode") or "ap"
1505 end
1506
1507 function wifinet.ssid(self)
1508         return self:ubus("net", "config", "ssid") or self:get("ssid")
1509 end
1510
1511 function wifinet.bssid(self)
1512         return self:ubus("net", "config", "bssid") or self:get("bssid")
1513 end
1514
1515 function wifinet.network(self)
1516         local net, networks = nil, { }
1517         for net in utl.imatch(self:ubus("net", "config", "network") or self:get("network")) do
1518                 networks[#networks+1] = net
1519         end
1520         return networks
1521 end
1522
1523 function wifinet.id(self)
1524         return self.netid
1525 end
1526
1527 function wifinet.name(self)
1528         return self.sid
1529 end
1530
1531 function wifinet.ifname(self)
1532         local ifname = self:ubus("net", "ifname") or self.iwinfo.ifname
1533         if not ifname or ifname:match("^wifi%d") or ifname:match("^radio%d") then
1534                 ifname = self.wdev
1535         end
1536         return ifname
1537 end
1538
1539 function wifinet.get_device(self)
1540         local dev = self:ubus("radio") or self:get("device")
1541         return dev and wifidev(dev) or nil
1542 end
1543
1544 function wifinet.is_up(self)
1545         local ifc = self:get_interface()
1546         return (ifc and ifc:is_up() or false)
1547 end
1548
1549 function wifinet.active_mode(self)
1550         local m = self.iwinfo.mode or self:ubus("net", "config", "mode") or self:get("mode") or "ap"
1551
1552         if     m == "ap"      then m = "Master"
1553         elseif m == "sta"     then m = "Client"
1554         elseif m == "adhoc"   then m = "Ad-Hoc"
1555         elseif m == "mesh"    then m = "Mesh"
1556         elseif m == "monitor" then m = "Monitor"
1557         end
1558
1559         return m
1560 end
1561
1562 function wifinet.active_mode_i18n(self)
1563         return lng.translate(self:active_mode())
1564 end
1565
1566 function wifinet.active_ssid(self)
1567         return self.iwinfo.ssid or self:ubus("net", "config", "ssid") or self:get("ssid")
1568 end
1569
1570 function wifinet.active_bssid(self)
1571         return self.iwinfo.bssid or self:ubus("net", "config", "bssid") or self:get("bssid")
1572 end
1573
1574 function wifinet.active_encryption(self)
1575         local enc = self.iwinfo and self.iwinfo.encryption
1576         return enc and enc.description or "-"
1577 end
1578
1579 function wifinet.assoclist(self)
1580         return self.iwinfo.assoclist or { }
1581 end
1582
1583 function wifinet.frequency(self)
1584         local freq = self.iwinfo.frequency
1585         if freq and freq > 0 then
1586                 return "%.03f" % (freq / 1000)
1587         end
1588 end
1589
1590 function wifinet.bitrate(self)
1591         local rate = self.iwinfo.bitrate
1592         if rate and rate > 0 then
1593                 return (rate / 1000)
1594         end
1595 end
1596
1597 function wifinet.channel(self)
1598         return self.iwinfo.channel or self:ubus("dev", "config", "channel") or
1599                 tonumber(self:get("channel"))
1600 end
1601
1602 function wifinet.signal(self)
1603         return self.iwinfo.signal or 0
1604 end
1605
1606 function wifinet.noise(self)
1607         return self.iwinfo.noise or 0
1608 end
1609
1610 function wifinet.country(self)
1611         return self.iwinfo.country or self:ubus("dev", "config", "country") or "00"
1612 end
1613
1614 function wifinet.txpower(self)
1615         local pwr = (self.iwinfo.txpower or 0)
1616         return pwr + self:txpower_offset()
1617 end
1618
1619 function wifinet.txpower_offset(self)
1620         return self.iwinfo.txpower_offset or 0
1621 end
1622
1623 function wifinet.signal_level(self, s, n)
1624         if self:active_bssid() ~= "00:00:00:00:00:00" then
1625                 local signal = s or self:signal()
1626                 local noise  = n or self:noise()
1627
1628                 if signal < 0 and noise < 0 then
1629                         local snr = -1 * (noise - signal)
1630                         return math.floor(snr / 5)
1631                 else
1632                         return 0
1633                 end
1634         else
1635                 return -1
1636         end
1637 end
1638
1639 function wifinet.signal_percent(self)
1640         local qc = self.iwinfo.quality or 0
1641         local qm = self.iwinfo.quality_max or 0
1642
1643         if qc > 0 and qm > 0 then
1644                 return math.floor((100 / qm) * qc)
1645         else
1646                 return 0
1647         end
1648 end
1649
1650 function wifinet.shortname(self)
1651         return "%s %q" %{
1652                 lng.translate(self:active_mode()),
1653                 self:active_ssid() or self:active_bssid() or self:id()
1654         }
1655 end
1656
1657 function wifinet.get_i18n(self)
1658         return "%s: %s %q (%s)" %{
1659                 lng.translate("Wireless Network"),
1660                 lng.translate(self:active_mode()),
1661                 self:active_ssid() or self:active_bssid() or self:id(),
1662                 self:ifname()
1663         }
1664 end
1665
1666 function wifinet.adminlink(self)
1667         return dsp.build_url("admin", "network", "wireless", self.netid)
1668 end
1669
1670 function wifinet.get_network(self)
1671         return self:get_networks()[1]
1672 end
1673
1674 function wifinet.get_networks(self)
1675         local nets = { }
1676         local net
1677         for net in utl.imatch(self:ubus("net", "config", "network") or self:get("network")) do
1678                 if _uci:get("network", net) == "interface" then
1679                         nets[#nets+1] = network(net)
1680                 end
1681         end
1682         table.sort(nets, function(a, b) return a.sid < b.sid end)
1683         return nets
1684 end
1685
1686 function wifinet.get_interface(self)
1687         return interface(self:ifname())
1688 end
1689
1690
1691 -- setup base protocols
1692 _M:register_protocol("static")
1693 _M:register_protocol("dhcp")
1694 _M:register_protocol("none")
1695
1696 -- load protocol extensions
1697 local exts = nfs.dir(utl.libpath() .. "/model/network")
1698 if exts then
1699         local ext
1700         for ext in exts do
1701                 if ext:match("%.lua$") then
1702                         require("luci.model.network." .. ext:gsub("%.lua$", ""))
1703                 end
1704         end
1705 end