summaryrefslogtreecommitdiffhomepage
path: root/modules/luci-base
diff options
context:
space:
mode:
Diffstat (limited to 'modules/luci-base')
-rw-r--r--modules/luci-base/htdocs/luci-static/resources/network.js2139
1 files changed, 2139 insertions, 0 deletions
diff --git a/modules/luci-base/htdocs/luci-static/resources/network.js b/modules/luci-base/htdocs/luci-static/resources/network.js
new file mode 100644
index 0000000000..978fabae68
--- /dev/null
+++ b/modules/luci-base/htdocs/luci-static/resources/network.js
@@ -0,0 +1,2139 @@
+'use strict';
+'require uci';
+'require rpc';
+'require validation';
+
+var proto_errors = {
+ CONNECT_FAILED: _('Connection attempt failed'),
+ INVALID_ADDRESS: _('IP address in invalid'),
+ INVALID_GATEWAY: _('Gateway address is invalid'),
+ INVALID_LOCAL_ADDRESS: _('Local IP address is invalid'),
+ MISSING_ADDRESS: _('IP address is missing'),
+ MISSING_PEER_ADDRESS: _('Peer address is missing'),
+ NO_DEVICE: _('Network device is not present'),
+ NO_IFACE: _('Unable to determine device name'),
+ NO_IFNAME: _('Unable to determine device name'),
+ NO_WAN_ADDRESS: _('Unable to determine external IP address'),
+ NO_WAN_LINK: _('Unable to determine upstream interface'),
+ PEER_RESOLVE_FAIL: _('Unable to resolve peer host name'),
+ PIN_FAILED: _('PIN code rejected')
+};
+
+var 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$/
+];
+
+var iface_patterns_wireless = [
+ /^wlan\d+/,
+ /^wl\d+/,
+ /^ath\d+/,
+ /^\w+\.network\d+/
+];
+
+var iface_patterns_virtual = [ ];
+
+var callNetworkWirelessStatus = rpc.declare({
+ object: 'network.wireless',
+ method: 'status'
+});
+
+var callLuciNetdevs = rpc.declare({
+ object: 'luci',
+ method: 'netdevs'
+});
+
+var callLuciIfaddrs = rpc.declare({
+ object: 'luci',
+ method: 'ifaddrs',
+ expect: { result: [] }
+});
+
+var callLuciBoardjson = rpc.declare({
+ object: 'luci',
+ method: 'boardjson'
+});
+
+var callIwinfoInfo = rpc.declare({
+ object: 'iwinfo',
+ method: 'info',
+ params: [ 'device' ]
+});
+
+var callNetworkInterfaceStatus = rpc.declare({
+ object: 'network.interface',
+ method: 'dump',
+ expect: { 'interface': [] }
+});
+
+var callNetworkDeviceStatus = rpc.declare({
+ object: 'network.device',
+ method: 'status',
+ expect: { '': {} }
+});
+
+var _cache = {},
+ _state = null,
+ _protocols = {};
+
+function getWifiState() {
+ if (_cache.wifi == null)
+ return callNetworkWirelessStatus().then(function(state) {
+ if (!isObject(state))
+ throw !1;
+ return (_cache.wifi = state);
+ }).catch(function() {
+ return (_cache.wifi = {});
+ });
+
+ return Promise.resolve(_cache.wifi);
+}
+
+function getInterfaceState() {
+ if (_cache.interfacedump == null)
+ return callNetworkInterfaceStatus().then(function(state) {
+ if (!Array.isArray(state))
+ throw !1;
+ return (_cache.interfacedump = state);
+ }).catch(function() {
+ return (_cache.interfacedump = []);
+ });
+
+ return Promise.resolve(_cache.interfacedump);
+}
+
+function getDeviceState() {
+ if (_cache.devicedump == null)
+ return callNetworkDeviceStatus().then(function(state) {
+ if (!isObject(state))
+ throw !1;
+ return (_cache.devicedump = state);
+ }).catch(function() {
+ return (_cache.devicedump = {});
+ });
+
+ return Promise.resolve(_cache.devicedump);
+}
+
+function getIfaddrState() {
+ if (_cache.ifaddrs == null)
+ return callLuciIfaddrs().then(function(addrs) {
+ if (!Array.isArray(addrs))
+ throw !1;
+ return (_cache.ifaddrs = addrs);
+ }).catch(function() {
+ return (_cache.ifaddrs = []);
+ });
+
+ return Promise.resolve(_cache.ifaddrs);
+}
+
+function getNetdevState() {
+ if (_cache.devices == null)
+ return callLuciNetdevs().then(function(state) {
+ if (!isObject(state))
+ throw !1;
+ return (_cache.devices = state);
+ }).catch(function() {
+ return (_cache.devices = {});
+ });
+
+ return Promise.resolve(_cache.devices);
+}
+
+function getBoardState() {
+ if (_cache.board == null)
+ return callLuciBoardjson().then(function(state) {
+ if (!isObject(state))
+ throw !1;
+ return (_cache.board = state);
+ }).catch(function() {
+ return (_cache.board = {});
+ });
+
+ return Promise.resolve(_cache.board);
+}
+
+function getWifiStateBySid(sid) {
+ var s = uci.get('wireless', sid);
+
+ if (s != null && s['.type'] == 'wifi-iface') {
+ for (var radioname in _cache.wifi) {
+ for (var i = 0; i < _cache.wifi[radioname].interfaces.length; i++) {
+ var netstate = _cache.wifi[radioname].interfaces[i];
+
+ if (typeof(netstate.section) != 'string')
+ continue;
+
+ var s2 = uci.get('wireless', netstate.section);
+
+ if (s2 != null && s['.type'] == s2['.type'] && s['.name'] == s2['.name'])
+ return [ radioname, _cache.wifi[radioname], netstate ];
+ }
+ }
+ }
+
+ return null;
+}
+
+function getWifiStateByIfname(ifname) {
+ for (var radioname in _cache.wifi) {
+ for (var i = 0; i < _cache.wifi[radioname].interfaces.length; i++) {
+ var netstate = _cache.wifi[radioname].interfaces[i];
+
+ if (typeof(netstate.ifname) != 'string')
+ continue;
+
+ if (netstate.ifname == ifname)
+ return [ radioname, _cache.wifi[radioname], netstate ];
+ }
+ }
+
+ return null;
+}
+
+function isWifiIfname(ifname) {
+ for (var i = 0; i < iface_patterns_wireless.length; i++)
+ if (iface_patterns_wireless[i].test(ifname))
+ return true;
+
+ return false;
+}
+
+function getWifiIwinfoByIfname(ifname, forcePhyOnly) {
+ var tasks = [ callIwinfoInfo(ifname) ];
+
+ if (!forcePhyOnly)
+ tasks.push(getNetdevState());
+
+ return Promise.all(tasks).then(function(info) {
+ var iwinfo = info[0],
+ devstate = info[1],
+ phyonly = forcePhyOnly || !devstate[ifname] || (devstate[ifname].type != 1);
+
+ if (isObject(iwinfo)) {
+ if (phyonly) {
+ delete iwinfo.bitrate;
+ delete iwinfo.quality;
+ delete iwinfo.quality_max;
+ delete iwinfo.mode;
+ delete iwinfo.ssid;
+ delete iwinfo.bssid;
+ delete iwinfo.encryption;
+ }
+
+ iwinfo.ifname = ifname;
+ }
+
+ return iwinfo;
+ }).catch(function() {
+ return null;
+ });
+}
+
+function getWifiSidByNetid(netid) {
+ var m = /^(\w+)\.network(\d+)$/.exec(netid);
+ if (m) {
+ var sections = uci.sections('wireless', 'wifi-iface');
+ for (var i = 0, n = 0; i < sections.length; i++) {
+ if (sections[i].device != m[1])
+ continue;
+
+ if (++n == +m[2])
+ return sections[i]['.name'];
+ }
+ }
+
+ return null;
+}
+
+function getWifiSidByIfname(ifname) {
+ var sid = getWifiSidByNetid(ifname);
+
+ if (sid != null)
+ return sid;
+
+ var res = getWifiStateByIfname(ifname);
+
+ if (res != null && isObject(res[2]) && typeof(res[2].section) == 'string')
+ return res[2].section;
+
+ return null;
+}
+
+function getWifiNetidBySid(sid) {
+ var s = uci.get('wireless', sid);
+ if (s != null && s['.type'] == 'wifi-iface') {
+ var radioname = s.device;
+ if (typeof(s.device) == 'string') {
+ var i = 0, netid = null, sections = uci.sections('wireless', 'wifi-iface');
+ for (var i = 0, n = 0; i < sections.length; i++) {
+ if (sections[i].device != s.device)
+ continue;
+
+ n++;
+
+ if (sections[i]['.name'] != s['.name'])
+ continue;
+
+ return [ '%s.network%d'.format(s.device, n), s.device ];
+ }
+
+ }
+ }
+
+ return null;
+}
+
+function getWifiNetidByNetname(name) {
+ var sections = uci.sections('wireless', 'wifi-iface');
+ for (var i = 0; i < sections.length; i++) {
+ if (typeof(sections[i].network) != 'string')
+ continue;
+
+ var nets = sections[i].network.split(/\s+/);
+ for (var j = 0; j < nets.length; j++) {
+ if (nets[j] != name)
+ continue;
+
+ return getWifiNetidBySid(sections[i]['.name']);
+ }
+ }
+
+ return null;
+}
+
+function isVirtualIfname(ifname) {
+ for (var i = 0; i < iface_patterns_virtual.length; i++)
+ if (iface_patterns_virtual[i].test(ifname))
+ return true;
+
+ return false;
+}
+
+function isIgnoredIfname(ifname) {
+ for (var i = 0; i < iface_patterns_ignore.length; i++)
+ if (iface_patterns_ignore[i].test(ifname))
+ return true;
+
+ return false;
+}
+
+function isObject(val) {
+ return (val != null && typeof(val) == 'object')
+}
+
+function appendValue(config, section, option, value) {
+ var values = uci.get(config, section, option),
+ isArray = Array.isArray(values),
+ rv = false;
+
+ if (isArray == false)
+ values = String(values || '').split(/\s+/);
+
+ if (values.indexOf(value) == -1) {
+ values.push(value);
+ rv = true;
+ }
+
+ uci.set(config, section, option, isArray ? values : values.join(' '));
+
+ return rv;
+}
+
+function removeValue(config, section, option, value) {
+ var values = uci.get(config, section, option),
+ isArray = Array.isArray(values),
+ rv = false;
+
+ if (isArray == false)
+ values = String(values || '').split(/\s+/);
+
+ for (var i = values.length - 1; i >= 0; i--) {
+ if (values[i] == value) {
+ values.splice(i, 1);
+ rv = true;
+ }
+ }
+
+ if (values.length > 0)
+ uci.set(config, section, option, isArray ? values : values.join(' '));
+ else
+ uci.unset(config, section, option);
+
+ return rv;
+}
+
+function toArray(val) {
+ if (val == null)
+ return [];
+
+ if (Array.isArray(val))
+ return val;
+
+ var s = String(val).trim();
+
+ if (s == '')
+ return [];
+
+ return s.split(/\s+/);
+}
+
+function prefixToMask(bits, v6) {
+ var w = v6 ? 128 : 32,
+ m = [];
+
+ if (bits > w)
+ return null;
+
+ for (var i = 0; i < w / 16; i++) {
+ var b = Math.min(16, bits);
+ m.push((0xffff << (16 - b)) & 0xffff);
+ bits -= b;
+ }
+
+ if (v6)
+ return String.prototype.format.apply('%x:%x:%x:%x:%x:%x:%x:%x', m).replace(/:0(?::0)+$/, '::');
+ else
+ return '%d.%d.%d.%d'.format(m[0] >>> 8, m[0] & 0xff, m[1] >>> 8, m[1] & 0xff);
+}
+
+function maskToPrefix(mask, v6) {
+ var m = v6 ? validation.parseIPv6(mask) : validation.parseIPv4(mask);
+
+ if (!m)
+ return null;
+
+ var bits = 0;
+
+ for (var i = 0, z = false; i < m.length; i++) {
+ z = z || !m[i];
+
+ while (!z && (m[i] & (v6 ? 0x8000 : 0x80))) {
+ m[i] = (m[i] << 1) & (v6 ? 0xffff : 0xff);
+ bits++;
+ }
+
+ if (m[i])
+ return null;
+ }
+
+ return bits;
+}
+
+function initNetworkState() {
+ if (_state == null)
+ return (_state = Promise.all([
+ getInterfaceState(), getDeviceState(), getBoardState(),
+ getWifiState(), getIfaddrState(), getNetdevState(),
+ uci.load('network'), uci.load('wireless'), uci.load('luci')
+ ]).finally(function() {
+ var ifaddrs = _cache.ifaddrs,
+ devices = _cache.devices,
+ board = _cache.board,
+ s = { isTunnel: {}, isBridge: {}, isSwitch: {}, isWifi: {}, interfaces: {}, bridges: {}, switches: {} };
+
+ for (var i = 0, a; (a = ifaddrs[i]) != null; i++) {
+ var name = a.name.replace(/:.+$/, '');
+
+ if (isVirtualIfname(name))
+ s.isTunnel[name] = true;
+
+ if (s.isTunnel[name] || !(isIgnoredIfname(name) || isVirtualIfname(name))) {
+ s.interfaces[name] = s.interfaces[name] || {
+ idx: a.ifindex || i,
+ name: name,
+ rawname: a.name,
+ flags: [],
+ ipaddrs: [],
+ ip6addrs: []
+ };
+
+ if (a.family == 'packet') {
+ s.interfaces[name].flags = a.flags;
+ s.interfaces[name].stats = a.data;
+ s.interfaces[name].macaddr = a.addr;
+ }
+ else if (a.family == 'inet') {
+ s.interfaces[name].ipaddrs.push(a.addr + '/' + a.netmask);
+ }
+ else if (a.family == 'inet6') {
+ s.interfaces[name].ip6addrs.push(a.addr + '/' + a.netmask);
+ }
+ }
+ }
+
+ for (var devname in devices) {
+ var dev = devices[devname];
+
+ if (dev.bridge) {
+ var b = {
+ name: devname,
+ id: dev.id,
+ stp: dev.stp,
+ ifnames: []
+ };
+
+ for (var i = 0; dev.ports && i < dev.ports.length; i++) {
+ var subdev = s.interfaces[dev.ports[i]];
+
+ if (subdev == null)
+ continue;
+
+ b.ifnames.push(subdev);
+ subdev.bridge = b;
+ }
+
+ s.bridges[devname] = b;
+ }
+ }
+
+ if (isObject(board.switch)) {
+ for (var switchname in board.switch) {
+ var layout = board.switch[switchname],
+ netdevs = {},
+ nports = {},
+ ports = [],
+ pnum = null,
+ role = null;
+
+ if (isObject(layout) && Array.isArray(layout.ports)) {
+ for (var i = 0, port; (port = layout.ports[i]) != null; i++) {
+ if (typeof(port) == 'object' && typeof(port.num) == 'number' &&
+ (typeof(port.role) == 'string' || typeof(port.device) == 'string')) {
+ var spec = {
+ num: port.num,
+ role: port.role || 'cpu',
+ index: (port.index != null) ? port.index : port.num
+ };
+
+ if (port.device != null) {
+ spec.device = port.device;
+ spec.tagged = spec.need_tag;
+ netdevs[port.num] = port.device;
+ }
+
+ ports.push(spec);
+
+ if (port.role != null)
+ nports[port.role] = (nports[port.role] || 0) + 1;
+ }
+ }
+
+ ports.sort(function(a, b) {
+ if (a.role != b.role)
+ return (a.role < b.role) ? -1 : 1;
+
+ return (a.index - b.index);
+ });
+
+ for (var i = 0, port; (port = ports[i]) != null; i++) {
+ if (port.role != role) {
+ role = port.role;
+ pnum = 1;
+ }
+
+ if (role == 'cpu')
+ port.label = 'CPU (%s)'.format(port.device);
+ else if (nports[role] > 1)
+ port.label = '%s %d'.format(role.toUpperCase(), pnum++);
+ else
+ port.label = role.toUpperCase();
+
+ delete port.role;
+ delete port.index;
+ }
+
+ s.switches[switchname] = {
+ ports: ports,
+ netdevs: netdevs
+ };
+ }
+ }
+ }
+
+ return (_state = s);
+ }));
+
+ return Promise.resolve(_state);
+}
+
+function ifnameOf(obj) {
+ if (obj instanceof Interface)
+ return obj.name();
+ else if (obj instanceof Protocol)
+ return obj.ifname();
+ else if (typeof(obj) == 'string')
+ return obj.replace(/:.+$/, '');
+
+ return null;
+}
+
+function networkSort(a, b) {
+ return a.getName() > b.getName();
+}
+
+function deviceSort(a, b) {
+ var typeWeigth = { wifi: 2, alias: 3 },
+ weightA = typeWeigth[a.getType()] || 1,
+ weightB = typeWeigth[b.getType()] || 1;
+
+ if (weightA != weightB)
+ return weightA - weightB;
+
+ return a.getName() > b.getName();
+}
+
+
+var Network, Protocol, Device, WifiDevice, WifiNetwork;
+
+Network = L.Class.extend({
+ getProtocol: function(protoname, netname) {
+ var v = _protocols[protoname];
+ if (v != null)
+ return v(netname || '__dummy__');
+
+ return null;
+ },
+
+ getProtocols: function() {
+ var rv = [];
+
+ for (var protoname in _protocols)
+ rv.push(_protocols[protoname]('__dummy__'));
+
+ return rv;
+ },
+
+ registerProtocol: function(protoname, methods) {
+ var proto = Protocol.extend(Object.assign({}, methods, {
+ __init__: function(name) {
+ this.sid = name;
+ },
+
+ proto: function() {
+ return protoname;
+ }
+ }));
+
+ _protocols[protoname] = proto;
+
+ return proto;
+ },
+
+ registerPatternVirtual: function(pat) {
+ iface_patterns_virtual.push(pat);
+ },
+
+ registerErrorCode: function(code, message) {
+ if (typeof(code) == 'string' &&
+ typeof(message) == 'string' &&
+ proto_errors.hasOwnProperty(code)) {
+ proto_errors[code] = message;
+ return true;
+ }
+
+ return false;
+ },
+
+ addNetwork: function(name, options) {
+ return this.getNetwork(name).then(L.bind(function(existingNetwork) {
+ if (name != null && /^[a-zA-Z0-9_]+$/.test(name) && existingNetwork == null) {
+ var sid = uci.add('network', 'interface', name);
+
+ if (sid != null) {
+ if (isObject(options))
+ for (var key in options)
+ if (options.hasOwnProperty(key))
+ uci.set('network', sid, key, options[key]);
+
+ return this.instantiateNetwork(sid);
+ }
+ }
+ else if (existingNetwork != null && existingNetwork.isEmpty()) {
+ if (isObject(options))
+ for (var key in options)
+ if (options.hasOwnProperty(key))
+ existingNetwork.set(key, options[key]);
+
+ return existingNetwork;
+ }
+ }, this));
+ },
+
+ getNetwork: function(name) {
+ return initNetworkState().then(L.bind(function() {
+ var section = (name != null) ? uci.get('network', name) : null;
+
+ if (section != null && section['.type'] == 'interface') {
+ return this.instantiateNetwork(name);
+ }
+ else if (name != null) {
+ for (var i = 0; i < _cache.interfacedump.length; i++)
+ if (_cache.interfacedump[i].interface == name)
+ return this.instantiateNetwork(name, _cache.interfacedump[i].proto);
+ }
+
+ return null;
+ }, this));
+ },
+
+ getNetworks: function() {
+ return initNetworkState().then(L.bind(function() {
+ var uciInterfaces = uci.sections('network', 'interface'),
+ networks = {};
+
+ for (var i = 0; i < uciInterfaces.length; i++)
+ networks[uciInterfaces[i]['.name']] = this.instantiateNetwork(uciInterfaces[i]['.name']);
+
+ for (var i = 0; i < _cache.interfacedump.length; i++)
+ if (networks[_cache.interfacedump[i].interface] == null)
+ networks[_cache.interfacedump[i].interface] =
+ this.instantiateNetwork(_cache.interfacedump[i].interface, _cache.interfacedump[i].proto);
+
+ var rv = [];
+
+ for (var network in networks)
+ if (networks.hasOwnProperty(network))
+ rv.push(networks[network]);
+
+ rv.sort(networkSort);
+
+ return rv;
+ }, this));
+ },
+
+ deleteNetwork: function(name) {
+ return Promise.all([ L.require('firewall').catch(function() { return null }), initNetworkState() ]).then(function() {
+ var uciInterface = uci.get('network', name);
+
+ if (uciInterface != null && uciInterface['.type'] == 'interface') {
+ uci.remove('network', name);
+
+ uci.sections('luci', 'ifstate', function(s) {
+ if (s.interface == name)
+ uci.remove('luci', s['.name']);
+ });
+
+ uci.sections('network', 'alias', function(s) {
+ if (s.interface == name)
+ uci.remove('network', s['.name']);
+ });
+
+ uci.sections('network', 'route', function(s) {
+ if (s.interface == name)
+ uci.remove('network', s['.name']);
+ });
+
+ uci.sections('network', 'route6', function(s) {
+ if (s.interface == name)
+ uci.remove('network', s['.name']);
+ });
+
+ uci.sections('wireless', 'wifi-iface', function(s) {
+ var networks = toArray(s.network).filter(function(network) { return network != name });
+
+ if (networks.length > 0)
+ uci.set('wireless', s['.name'], 'network', networks.join(' '));
+ else
+ uci.unset('wireless', s['.name'], 'network');
+ });
+
+ if (L.firewall)
+ return L.firewall.deleteNetwork(name).then(function() { return true });
+
+ return true;
+ }
+
+ return false;
+ });
+ },
+
+ renameNetwork: function(oldName, newName) {
+ return initNetworkState().then(function() {
+ if (newName == null || !/^[a-zA-Z0-9_]+$/.test(newName) || uci.get('network', newName) != null)
+ return false;
+
+ var oldNetwork = uci.get('network', oldName);
+
+ if (oldNetwork == null || oldNetwork['.type'] != 'interface')
+ return false;
+
+ var sid = uci.add('network', 'interface', newName);
+
+ for (var key in oldNetwork)
+ if (oldNetwork.hasOwnProperty(key) && key.charAt(0) != '.')
+ uci.set('network', sid, key, oldNetwork[key]);
+
+ uci.sections('luci', 'ifstate', function(s) {
+ if (s.interface == oldName)
+ uci.set('luci', s['.name'], 'interface', newName);
+ });
+
+ uci.sections('network', 'alias', function(s) {
+ if (s.interface == oldName)
+ uci.set('network', s['.name'], 'interface', newName);
+ });
+
+ uci.sections('network', 'route', function(s) {
+ if (s.interface == oldName)
+ uci.set('network', s['.name'], 'interface', newName);
+ });
+
+ uci.sections('network', 'route6', function(s) {
+ if (s.interface == oldName)
+ uci.set('network', s['.name'], 'interface', newName);
+ });
+
+ uci.sections('wireless', 'wifi-iface', function(s) {
+ var networks = toArray(s.network).map(function(network) { return (network == oldName ? newName : network) });
+
+ if (networks.length > 0)
+ uci.set('wireless', s['.name'], 'network', networks.join(' '));
+ });
+
+ uci.remove('network', oldName);
+
+ return true;
+ });
+ },
+
+ getDevice: function(name) {
+ return initNetworkState().then(L.bind(function() {
+ if (name == null)
+ return null;
+
+ if (_state.interfaces.hasOwnProperty(name) || isWifiIfname(name))
+ return this.instantiateDevice(name);
+
+ var netid = getWifiNetidBySid(name);
+ if (netid != null)
+ return this.instantiateDevice(netid[0]);
+
+ return null;
+ }, this));
+ },
+
+ getDevices: function() {
+ return initNetworkState().then(L.bind(function() {
+ var devices = {};
+
+ /* find simple devices */
+ var uciInterfaces = uci.sections('network', 'interface');
+ for (var i = 0; i < uciInterfaces.length; i++) {
+ var ifnames = toArray(uciInterfaces[i].ifname);
+
+ for (var j = 0; j < ifnames.length; j++) {
+ if (ifnames[j].charAt(0) == '@')
+ continue;
+
+ if (isIgnoredIfname(ifnames[j]) || isVirtualIfname(ifnames[j]) || isWifiIfname(ifnames[j]))
+ continue;
+
+ devices[ifnames[j]] = this.instantiateDevice(ifnames[j]);
+ }
+ }
+
+ for (var ifname in _state.interfaces) {
+ if (devices.hasOwnProperty(ifname))
+ continue;
+
+ if (isIgnoredIfname(ifname) || isVirtualIfname(ifname) || isWifiIfname(ifname))
+ continue;
+
+ devices[ifname] = this.instantiateDevice(ifname);
+ }
+
+ /* find VLAN devices */
+ var uciSwitchVLANs = uci.sections('network', 'switch_vlan');
+ for (var i = 0; i < uciSwitchVLANs.length; i++) {
+ if (typeof(uciSwitchVLANs[i].ports) != 'string' ||
+ typeof(uciSwitchVLANs[i].device) != 'string' ||
+ !_state.switches.hasOwnProperty(uciSwitchVLANs[i].device))
+ continue;
+
+ var ports = uciSwitchVLANs[i].ports.split(/\s+/);
+ for (var j = 0; j < ports.length; j++) {
+ var m = ports[j].match(/^(\d+)([tu]?)$/);
+ if (m == null)
+ continue;
+
+ var netdev = _state.switches[uciSwitchVLANs[i].device].netdevs[m[1]];
+ if (netdev == null)
+ continue;
+
+ if (!devices.hasOwnProperty(netdev))
+ devices[netdev] = this.instantiateDevice(netdev);
+
+ _state.isSwitch[netdev] = true;
+
+ if (m[2] != 't')
+ continue;
+
+ var vid = uciSwitchVLANs[i].vid || uciSwitchVLANs[i].vlan;
+ vid = (vid != null ? +vid : null);
+
+ if (vid == null || vid < 0 || vid > 4095)
+ continue;
+
+ var vlandev = '%s.%d'.format(netdev, vid);
+
+ if (!devices.hasOwnProperty(vlandev))
+ devices[vlandev] = this.instantiateDevice(vlandev);
+
+ _state.isSwitch[vlandev] = true;
+ }
+ }
+
+ /* find wireless interfaces */
+ var uciWifiIfaces = uci.sections('wireless', 'wifi-iface'),
+ networkCount = {};
+
+ for (var i = 0; i < uciWifiIfaces.length; i++) {
+ if (typeof(uciWifiIfaces[i].device) != 'string')
+ continue;
+
+ networkCount[uciWifiIfaces[i].device] = (networkCount[uciWifiIfaces[i].device] || 0) + 1;
+
+ var netid = '%s.network%d'.format(uciWifiIfaces[i].device, networkCount[uciWifiIfaces[i].device]);
+
+ devices[netid] = this.instantiateDevice(netid);
+ }
+
+ var rv = [];
+
+ for (var netdev in devices)
+ if (devices.hasOwnProperty(netdev))
+ rv.push(devices[netdev]);
+
+ rv.sort(deviceSort);
+
+ return rv;
+ }, this));
+ },
+
+ isIgnoredDevice: function(name) {
+ return isIgnoredIfname(name);
+ },
+
+ getWifiDevice: function(devname) {
+ return Promise.all([ getWifiIwinfoByIfname(devname, true), initNetworkState() ]).then(L.bind(function(res) {
+ var existingDevice = uci.get('wireless', devname);
+
+ if (existingDevice == null || existingDevice['.type'] != 'wifi-device')
+ return null;
+
+ return this.instantiateWifiDevice(devname, res[0]);
+ }, this));
+ },
+
+ getWifiDevices: function() {
+ var deviceNames = [];
+
+ return initNetworkState().then(L.bind(function() {
+ var uciWifiDevices = uci.sections('wireless', 'wifi-device'),
+ tasks = [];
+
+ for (var i = 0; i < uciWifiDevices.length; i++) {
+ tasks.push(callIwinfoInfo(uciWifiDevices['.name'], true));
+ deviceNames.push(uciWifiDevices['.name']);
+ }
+
+ return Promise.all(tasks);
+ }, this)).then(L.bind(function(iwinfos) {
+ var rv = [];
+
+ for (var i = 0; i < deviceNames.length; i++)
+ if (isObject(iwinfos[i]))
+ rv.push(this.instantiateWifiDevice(deviceNames[i], iwinfos[i]));
+
+ rv.sort(function(a, b) { return a.getName() < b.getName() });
+
+ return rv;
+ }, this));
+ },
+
+ getWifiNetwork: function(netname) {
+ var sid, res, netid, radioname, radiostate, netstate;
+
+ return initNetworkState().then(L.bind(function() {
+ sid = getWifiSidByNetid(netname);
+
+ if (sid != null) {
+ res = getWifiStateBySid(sid);
+ netid = netname;
+ radioname = res ? res[0] : null;
+ radiostate = res ? res[1] : null;
+ netstate = res ? res[2] : null;
+ }
+ else {
+ res = getWifiStateByIfname(netname);
+
+ if (res != null) {
+ radioname = res[0];
+ radiostate = res[1];
+ netstate = res[2];
+ sid = netstate.section;
+ netid = getWifiNetidBySid(sid);
+ }
+ else {
+ res = getWifiStateBySid(netname);
+
+ if (res != null) {
+ radioname = res[0];
+ radiostate = res[1];
+ netstate = res[2];
+ sid = netname;
+ netid = getWifiNetidBySid(sid);
+ }
+ else {
+ res = getWifiNetidBySid(netname);
+
+ if (res != null) {
+ netid = res[0];
+ radioname = res[1];
+ sid = netname;
+ }
+ }
+ }
+ }
+
+ return (netstate ? getWifiIwinfoByIfname(netstate.ifname) : Promise.reject())
+ .catch(function() { return radioname ? getWifiIwinfoByIfname(radioname) : Promise.reject() })
+ .catch(function() { return Promise.resolve({ ifname: netid || sid || netname }) });
+ }, this)).then(L.bind(function(iwinfo) {
+ return this.instantiateWifiNetwork(sid || netname, radioname, radiostate, netid, netstate, iwinfo);
+ }, this));
+ },
+
+ addWifiNetwork: function(options) {
+ return initNetworkState().then(L.bind(function() {
+ if (options == null ||
+ typeof(options) != 'object' ||
+ typeof(options.device) != 'string')
+ return null;
+
+ var existingDevice = uci.get('wireless', options.device);
+ if (existingDevice == null || existingDevice['.type'] != 'wifi-device')
+ return null;
+
+ var sid = uci.add('wireless', 'wifi-iface');
+ for (var key in options)
+ if (options.hasOwnProperty(key))
+ uci.set('wireless', sid, key, options[key]);
+
+ var radioname = existingDevice['.name'],
+ netid = getWifiNetidBySid(sid);
+
+ return this.instantiateWifiNetwork(sid, radioname, _cache.wifi[radioname], netid, null, { ifname: netid });
+ }, this));
+ },
+
+ deleteWifiNetwork: function(netname) {
+ return initNetworkState().then(L.bind(function() {
+ var sid = getWifiSidByIfname(netname);
+
+ if (sid == null)
+ return false;
+
+ uci.remove('wireless', sid);
+ return true;
+ }, this));
+ },
+
+ getStatusByRoute: function(addr, mask) {
+ return initNetworkState().then(L.bind(function() {
+ var rv = [];
+
+ for (var i = 0; i < _state.interfacedump.length; i++) {
+ if (!Array.isArray(_state.interfacedump[i].route))
+ continue;
+
+ for (var j = 0; j < _state.interfacedump[i].route.length; j++) {
+ if (typeof(_state.interfacedump[i].route[j]) != 'object' ||
+ typeof(_state.interfacedump[i].route[j].target) != 'string' ||
+ typeof(_state.interfacedump[i].route[j].mask) != 'number')
+ continue;
+
+ if (_state.interfacedump[i].route[j].table)
+ continue;
+
+ rv.push(_state.interfacedump[i]);
+ }
+ }
+
+ return rv;
+ }, this));
+ },
+
+ getStatusByAddress: function(addr) {
+ return initNetworkState().then(L.bind(function() {
+ var rv = [];
+
+ for (var i = 0; i < _state.interfacedump.length; i++) {
+ if (Array.isArray(_state.interfacedump[i]['ipv4-address']))
+ for (var j = 0; j < _state.interfacedump[i]['ipv4-address'].length; j++)
+ if (typeof(_state.interfacedump[i]['ipv4-address'][j]) == 'object' &&
+ _state.interfacedump[i]['ipv4-address'][j].address == addr)
+ return _state.interfacedump[i];
+
+ if (Array.isArray(_state.interfacedump[i]['ipv6-address']))
+ for (var j = 0; j < _state.interfacedump[i]['ipv6-address'].length; j++)
+ if (typeof(_state.interfacedump[i]['ipv6-address'][j]) == 'object' &&
+ _state.interfacedump[i]['ipv6-address'][j].address == addr)
+ return _state.interfacedump[i];
+
+ if (Array.isArray(_state.interfacedump[i]['ipv6-prefix-assignment']))
+ for (var j = 0; j < _state.interfacedump[i]['ipv6-prefix-assignment'].length; j++)
+ if (typeof(_state.interfacedump[i]['ipv6-prefix-assignment'][j]) == 'object' &&
+ typeof(_state.interfacedump[i]['ipv6-prefix-assignment'][j]['local-address']) == 'object' &&
+ _state.interfacedump[i]['ipv6-prefix-assignment'][j]['local-address'].address == addr)
+ return _state.interfacedump[i];
+ }
+
+ return null;
+ }, this));
+ },
+
+ getWANNetworks: function() {
+ return this.getStatusByRoute('0.0.0.0', 0).then(L.bind(function(statuses) {
+ var rv = [];
+
+ for (var i = 0; i < statuses.length; i++)
+ rv.push(this.instantiateNetwork(statuses[i].interface, statuses[i].proto));
+
+ return rv;
+ }, this));
+ },
+
+ getWAN6Networks: function() {
+ return this.getStatusByRoute('::', 0).then(L.bind(function(statuses) {
+ var rv = [];
+
+ for (var i = 0; i < statuses.length; i++)
+ rv.push(this.instantiateNetwork(statuses[i].interface, statuses[i].proto));
+
+ return rv;
+ }, this));
+ },
+
+ getSwitchTopologies: function() {
+ return initNetworkState().then(function() {
+ return _state.switches;
+ });
+ },
+
+ instantiateNetwork: function(name, proto) {
+ if (name == null)
+ return null;
+
+ proto = (proto == null ? uci.get('network', name, 'proto') : proto);
+
+ var protoClass = _protocols[proto] || Protocol;
+ return new protoClass(name);
+ },
+
+ instantiateDevice: function(name, network) {
+ return new Device(name, network);
+ },
+
+ instantiateWifiDevice: function(radioname, iwinfo) {
+ return new WifiDevice(radioname, iwinfo);
+ },
+
+ instantiateWifiNetwork: function(sid, radioname, radiostate, netid, netstate, iwinfo) {
+ return new WifiNetwork(sid, radioname, radiostate, netid, netstate, iwinfo);
+ }
+});
+
+Protocol = L.Class.extend({
+ __init__: function(name) {
+ this.sid = name;
+ },
+
+ _get: function(opt) {
+ var val = uci.get('network', this.sid, opt);
+
+ if (Array.isArray(val))
+ return val.join(' ');
+
+ return val || '';
+ },
+
+ _ubus: function(field) {
+ for (var i = 0; i < _cache.interfacedump.length; i++) {
+ if (_cache.interfacedump[i].interface != this.sid)
+ continue;
+
+ return (field != null ? _cache.interfacedump[i][field] : _cache.interfacedump[i]);
+ }
+ },
+
+ get: function(opt) {
+ return uci.get('network', this.sid, opt);
+ },
+
+ set: function(opt, val) {
+ return uci.set('network', this.sid, opt, val);
+ },
+
+ getIfname: function() {
+ var ifname;
+
+ if (this.isFloating())
+ ifname = this._ubus('l3_device');
+ else
+ ifname = this._ubus('device');
+
+ if (ifname != null)
+ return ifname;
+
+ var res = getWifiNetidByNetname(this.sid);
+ return (res != null ? res[0] : null);
+ },
+
+ getProtocol: function() {
+ return 'none';
+ },
+
+ getI18n: function() {
+ switch (this.getProtocol()) {
+ case 'none': return _('Unmanaged');
+ case 'static': return _('Static address');
+ case 'dhcp': return _('DHCP client');
+ default: return _('Unknown');
+ }
+ },
+
+ getType: function() {
+ return this._get('type');
+ },
+
+ getName: function() {
+ return this.sid;
+ },
+
+ getUptime: function() {
+ return this._ubus('uptime') || 0;
+ },
+
+ getExpiry: function() {
+ var u = this._ubus('uptime'),
+ d = this._ubus('data');
+
+ if (typeof(u) == 'number' && d != null &&
+ typeof(d) == 'object' && typeof(d.leasetime) == 'number') {
+ var r = d.leasetime - (u % d.leasetime);
+ return (r > 0 ? r : 0);
+ }
+
+ return -1;
+ },
+
+ getMetric: function() {
+ return this._ubus('metric') || 0;
+ },
+
+ getZoneName: function() {
+ var d = this._ubus('data');
+
+ if (isObject(d) && typeof(d.zone) == 'string')
+ return d.zone;
+
+ return null;
+ },
+
+ getIPAddr: function() {
+ var addrs = this._ubus('ipv4-address');
+ return ((Array.isArray(addrs) && addrs.length) ? addrs[0].address : null);
+ },
+
+ getIPAddrs: function() {
+ var addrs = this._ubus('ipv4-address'),
+ rv = [];
+
+ if (Array.isArray(addrs))
+ for (var i = 0; i < addrs.length; i++)
+ rv.push('%s/%d'.format(addrs[i].address, addrs[i].mask));
+
+ return rv;
+ },
+
+ getNetmask: function() {
+ var addrs = this._ubus('ipv4-address');
+ if (Array.isArray(addrs) && addrs.length) {
+ switch (addrs[0].mask) {
+ case 0: return '0.0.0.0';
+ case 1: return '128.0.0.0';
+ case 2: return '192.0.0.0';
+ case 3: return '224.0.0.0';
+ case 4: return '240.0.0.0';
+ case 5: return '248.0.0.0';
+ case 6: return '252.0.0.0';
+ case 7: return '254.0.0.0';
+ case 8: return '255.0.0.0';
+ case 9: return '255.128.0.0';
+ case 10: return '255.192.0.0';
+ case 11: return '255.224.0.0';
+ case 12: return '255.240.0.0';
+ case 13: return '255.248.0.0';
+ case 14: return '255.252.0.0';
+ case 15: return '255.254.0.0';
+ case 16: return '255.255.0.0';
+ case 17: return '255.255.128.0';
+ case 18: return '255.255.192.0';
+ case 19: return '255.255.224.0';
+ case 20: return '255.255.240.0';
+ case 21: return '255.255.248.0';
+ case 22: return '255.255.252.0';
+ case 23: return '255.255.254.0';
+ case 24: return '255.255.255.0';
+ case 25: return '255.255.255.128';
+ case 26: return '255.255.255.192';
+ case 27: return '255.255.255.224';
+ case 28: return '255.255.255.240';
+ case 29: return '255.255.255.248';
+ case 30: return '255.255.255.252';
+ case 31: return '255.255.255.254';
+ case 32: return '255.255.255.255';
+ }
+ }
+ },
+
+ getGatewayAddr: function() {
+ var routes = this._ubus('route');
+
+ if (Array.isArray(routes))
+ for (var i = 0; i < routes.length; i++)
+ if (typeof(routes[i]) == 'object' &&
+ routes[i].target == '0.0.0.0' &&
+ routes[i].mask == 0)
+ return routes[i].nexthop;
+
+ return null;
+ },
+
+ getDNSAddrs: function() {
+ var addrs = this._ubus('dns-server'),
+ rv = [];
+
+ if (Array.isArray(addrs))
+ for (var i = 0; i < addrs.length; i++)
+ if (!/:/.test(addrs[i]))
+ rv.push(addrs[i]);
+
+ return rv;
+ },
+
+ getIP6Addr: function() {
+ var addrs = this._ubus('ipv6-address');
+
+ if (Array.isArray(addrs) && isObject(addrs[0]))
+ return '%s/%d'.format(addrs[0].address, addrs[0].mask);
+
+ addrs = this._ubus('ipv6-prefix-assignment');
+
+ if (Array.isArray(addrs) && isObject(addrs[0]) && isObject(addrs[0]['local-address']))
+ return '%s/%d'.format(addrs[0]['local-address'].address, addrs[0]['local-address'].mask);
+
+ return null;
+ },
+
+ getIP6Addrs: function() {
+ var addrs = this._ubus('ipv6-address'),
+ rv = [];
+
+ if (Array.isArray(addrs))
+ for (var i = 0; i < addrs.length; i++)
+ if (isObject(addrs[i]))
+ rv.push('%s/%d'.format(addrs[i].address, addrs[i].mask));
+
+ addrs = this._ubus('ipv6-prefix-assignment');
+
+ if (Array.isArray(addrs))
+ for (var i = 0; i < addrs.length; i++)
+ if (isObject(addrs[i]) && isObject(addrs[i]['local-address']))
+ rv.push('%s/%d'.format(addrs[i]['local-address'].address, addrs[i]['local-address'].mask));
+
+ return rv;
+ },
+
+ getDNS6Addrs: function() {
+ var addrs = this._ubus('dns-server'),
+ rv = [];
+
+ if (Array.isArray(addrs))
+ for (var i = 0; i < addrs.length; i++)
+ if (/:/.test(addrs[i]))
+ rv.push(addrs[i]);
+
+ return rv;
+ },
+
+ getIP6Prefix: function() {
+ var prefixes = this._ubus('ipv6-prefix');
+
+ if (Array.isArray(prefixes) && isObject(prefixes[0]))
+ return '%s/%d'.format(prefixes[0].address, prefixes[0].mask);
+
+ return null;
+ },
+
+ getErrors: function() {
+ var errors = this._ubus('errors'),
+ rv = null;
+
+ if (Array.isArray(errors)) {
+ for (var i = 0; i < errors.length; i++) {
+ if (!isObject(errors[i]) || typeof(errors[i].code) != 'string')
+ continue;
+
+ rv = rv || [];
+ rv.push(proto_errors[errors[i].code] || _('Unknown error (%s)').format(errors[i].code));
+ }
+ }
+
+ return rv;
+ },
+
+ isBridge: function() {
+ return (!this.isVirtual() && this.getType() == 'bridge');
+ },
+
+ getOpkgPackage: function() {
+ return null;
+ },
+
+ isInstalled: function() {
+ return true;
+ },
+
+ isVirtual: function() {
+ return false;
+ },
+
+ isFloating: function() {
+ return false;
+ },
+
+ isDynamic: function() {
+ return (this._ubus('dynamic') == true);
+ },
+
+ isAlias: function() {
+ var ifnames = toArray(uci.get('network', this.sid, 'ifname')),
+ parent = null;
+
+ for (var i = 0; i < ifnames.length; i++)
+ if (ifnames[i].charAt(0) == '@')
+ parent = ifnames[i].substr(1);
+ else if (parent != null)
+ parent = null;
+
+ return parent;
+ },
+
+ isEmpty: function() {
+ if (this.isFloating())
+ return false;
+
+ var empty = true,
+ ifname = this._get('ifname');
+
+ if (ifname != null && ifname.match(/\S+/))
+ empty = false;
+
+ if (empty == true && getWifiNetidBySid(this.sid) != null)
+ empty = false;
+
+ return empty;
+ },
+
+ isUp: function() {
+ return (this._ubus('up') == true);
+ },
+
+ addDevice: function(ifname) {
+ ifname = ifnameOf(ifname);
+
+ if (ifname == null || this.isFloating())
+ return false;
+
+ var wif = getWifiSidByIfname(ifname);
+
+ if (wif != null)
+ return appendValue('wireless', wif, 'network', this.sid);
+
+ return appendValue('network', this.sid, 'ifname', ifname);
+ },
+
+ deleteDevice: function(ifname) {
+ var rv = false;
+
+ ifname = ifnameOf(ifname);
+
+ if (ifname == null || this.isFloating())
+ return false;
+
+ var wif = getWifiSidByIfname(ifname);
+
+ if (wif != null)
+ rv = removeValue('wireless', wif, 'network', this.sid);
+
+ if (removeValue('network', this.sid, 'ifname', ifname))
+ rv = true;
+
+ return rv;
+ },
+
+ getDevice: function() {
+ if (this.isVirtual()) {
+ var ifname = '%s-%s'.format(this.getProtocol(), this.sid);
+ _state.isTunnel[this.getProtocol() + '-' + this.sid] = true;
+ return L.network.instantiateDevice(ifname, this);
+ }
+ else if (this.isBridge()) {
+ var ifname = 'br-%s'.format(this.sid);
+ _state.isBridge[ifname] = true;
+ return new Device(ifname, this);
+ }
+ else {
+ var ifname = this._ubus('l3_device') || this._ubus('device');
+
+ if (ifname != null)
+ return L.network.instantiateDevice(ifname, this);
+
+ var ifnames = toArray(uci.get('network', this.sid, 'ifname'));
+
+ for (var i = 0; i < ifnames.length; i++) {
+ var m = ifnames[i].match(/^([^:/]+)/);
+ return ((m && m[1]) ? L.network.instantiateDevice(m[1], this) : null);
+ }
+
+ ifname = getWifiNetidByNetname(this.sid);
+
+ return (ifname != null ? L.network.instantiateDevice(ifname, this) : null);
+ }
+ },
+
+ getDevices: function() {
+ var rv = [];
+
+ if (!this.isBridge() && !(this.isVirtual() && !this.isFloating()))
+ return null;
+
+ var ifnames = toArray(uci.get('network', this.sid, 'ifname'));
+
+ for (var i = 0; i < ifnames.length; i++) {
+ if (ifnames[i].charAt(0) == '@')
+ continue;
+
+ var m = ifnames[i].match(/^([:/]+)/);
+ if (m != null)
+ rv.push(L.network.instantiateDevice(m[1], this));
+ }
+
+ var uciWifiIfaces = uci.sections('wireless', 'wifi-iface');
+
+ for (var i = 0; i < uciWifiIfaces.length; i++) {
+ if (typeof(uciWifiIfaces[i].device) != 'string')
+ continue;
+
+ var networks = toArray(uciWifiIfaces[i].network);
+
+ for (var j = 0; j < networks.length; j++) {
+ if (networks[j] != this.sid)
+ continue;
+
+ var netid = getWifiNetidBySid(uciWifiIfaces[i]['.name']);
+
+ if (netid != null)
+ rv.push(L.network.instantiateDevice(netid[0], this));
+ }
+ }
+
+ rv.sort(deviceSort);
+
+ return rv;
+ },
+
+ containsDevice: function(ifname) {
+ ifname = ifnameOf(ifname);
+
+ if (ifname == null)
+ return false;
+ else if (this.isVirtual() && '%s-%s'.format(this.getProtocol(), this.sid) == ifname)
+ return true;
+ else if (this.isBridge() && 'br-%s'.format(this.sid) == ifname)
+ return true;
+
+ var ifnames = toArray(uci.get('network', this.sid, 'ifname'));
+
+ for (var i = 0; i < ifnames.length; i++) {
+ var m = ifnames[i].match(/^([^:/]+)/);
+ if (m != null && m[1] == ifname)
+ return true;
+ }
+
+ var wif = getWifiSidByIfname(ifname);
+
+ if (wif != null) {
+ var networks = toArray(uci.get('wireless', wif, 'network'));
+
+ for (var i = 0; i < networks.length; i++)
+ if (networks[i] == this.sid)
+ return true;
+ }
+
+ return false;
+ }
+});
+
+Device = L.Class.extend({
+ __init__: function(ifname, network) {
+ var wif = getWifiSidByIfname(ifname);
+
+ if (wif != null) {
+ var res = getWifiStateBySid(wif) || [],
+ netid = getWifiNetidBySid(wif);
+
+ this.wif = new WifiNetwork(wif, res[0], res[1], netid, res[2], { ifname: ifname });
+ this.ifname = this.wif.getIfname();
+ }
+
+ this.ifname = this.ifname || ifname;
+ this.dev = _state.interfaces[this.ifname];
+ this.network = network;
+ },
+
+ _ubus: function(field) {
+ var dump = _cache.devicedump[this.ifname] || {};
+
+ return (field != null ? dump[field] : dump);
+ },
+
+ getName: function() {
+ return (this.wif != null ? this.wif.getIfname() : this.ifname);
+ },
+
+ getMAC: function() {
+ return this._ubus('macaddr');
+ },
+
+ getIPAddrs: function() {
+ var addrs = (this.dev != null ? this.dev.ipaddrs : null);
+ return (Array.isArray(addrs) ? addrs : []);
+ },
+
+ getIP6Addrs: function() {
+ var addrs = (this.dev != null ? this.dev.ip6addrs : null);
+ return (Array.isArray(addrs) ? addrs : []);
+ },
+
+ getType: function() {
+ if (this.ifname.charAt(0) == '@')
+ return 'alias';
+ else if (this.wif != null || isWifiIfname(this.ifname))
+ return 'wifi';
+ else if (_state.isBridge[this.ifname])
+ return 'bridge';
+ else if (_state.isTunnel[this.ifname])
+ return 'tunnel';
+ else if (this.ifname.indexOf('.') > -1)
+ return 'vlan';
+ else if (_state.isSwitch[this.ifname])
+ return 'switch';
+ else
+ return 'ethernet';
+ },
+
+ getShortName: function() {
+ if (this.wif != null)
+ return this.wif.getShortName();
+
+ return this.ifname;
+ },
+
+ getI18n: function() {
+ if (this.wif != null) {
+ return '%s: %s "%s"'.format(
+ _('Wireless Network'),
+ this.wif.getActiveMode(),
+ this.wif.getActiveSSID() || this.wif.getActiveBSSID() || this.wif.getID() || '?');
+ }
+
+ return '%s: "%s"'.format(this.getTypeI18n(), this.getName());
+ },
+
+ getTypeI18n: function() {
+ switch (this.getType()) {
+ case 'alias':
+ return _('Alias Interface');
+
+ case 'wifi':
+ return _('Wireless Adapter');
+
+ case 'bridge':
+ return _('Bridge');
+
+ case 'switch':
+ return _('Ethernet Switch');
+
+ case 'vlan':
+ return (_state.isSwitch[this.ifname] ? _('Switch VLAN') : _('Software VLAN'));
+
+ case 'tunnel':
+ return _('Tunnel Interface');
+
+ default:
+ return _('Ethernet Adapter');
+ }
+ },
+
+ getPorts: function() {
+ var br = _state.bridges[this.ifname],
+ rv = [];
+
+ if (br == null || !Array.isArray(br.ifnames))
+ return null;
+
+ for (var i = 0; i < br.ifnames.length; i++)
+ rv.push(L.network.instantiateDevice(br.ifnames[i]));
+
+ return rv;
+ },
+
+ getBridgeID: function() {
+ var br = _state.bridges[this.ifname];
+ return (br != null ? br.id : null);
+ },
+
+ getBridgeSTP: function() {
+ var br = _state.bridges[this.ifname];
+ return (br != null ? !!br.stp : false);
+ },
+
+ isUp: function() {
+ var up = this._ubus('up');
+
+ if (up == null)
+ up = (this.getType() == 'alias');
+
+ return up;
+ },
+
+ isBridge: function() {
+ return (this.getType() == 'bridge');
+ },
+
+ isBridgePort: function() {
+ return (this.dev != null && this.dev.bridge != null);
+ },
+
+ getTXBytes: function() {
+ var stat = this._ubus('statistics');
+ return (stat != null ? stat.tx_bytes || 0 : 0);
+ },
+
+ getRXBytes: function() {
+ var stat = this._ubus('statistics');
+ return (stat != null ? stat.rx_bytes || 0 : 0);
+ },
+
+ getTXPackets: function() {
+ var stat = this._ubus('statistics');
+ return (stat != null ? stat.tx_packets || 0 : 0);
+ },
+
+ getRXPackets: function() {
+ var stat = this._ubus('statistics');
+ return (stat != null ? stat.rx_packets || 0 : 0);
+ },
+
+ getNetwork: function() {
+ return this.getNetworks()[0];
+ },
+
+ getNetworks: function() {
+ if (this.networks == null) {
+ this.networks = [];
+
+ var networks = L.network.getNetworks();
+
+ for (var i = 0; i < networks.length; i++)
+ if (networks[i].containsDevice(this.ifname) || networks[i].getIfname() == this.ifname)
+ this.networks.push(networks[i]);
+
+ this.networks.sort(networkSort);
+ }
+
+ return this.networks;
+ },
+
+ getWifiNetwork: function() {
+ return (this.wif != null ? this.wif : null);
+ }
+});
+
+WifiDevice = L.Class.extend({
+ __init__: function(name, iwinfo) {
+ var uciWifiDevice = uci.get('wireless', name);
+
+ if (uciWifiDevice != null &&
+ uciWifiDevice['.type'] == 'wifi-device' &&
+ uciWifiDevice['.name'] != null) {
+ this.sid = uciWifiDevice['.name'];
+ this.iwinfo = iwinfo;
+ }
+
+ this.sid = this.sid || name;
+ this.iwinfo = this.iwinfo || { ifname: this.sid };
+ },
+
+ get: function(opt) {
+ return uci.get('wireless', this.sid, opt);
+ },
+
+ set: function(opt, value) {
+ return uci.set('wireless', this.sid, opt, value);
+ },
+
+ getName: function() {
+ return this.sid;
+ },
+
+ getHWModes: function() {
+ if (isObject(this.iwinfo.hwmodelist))
+ for (var k in this.iwinfo.hwmodelist)
+ return this.iwinfo.hwmodelist;
+
+ return { b: true, g: true };
+ },
+
+ getI18n: function() {
+ var type = this.iwinfo.hardware_name || 'Generic';
+
+ if (this.iwinfo.type == 'wl')
+ type = 'Broadcom';
+
+ var hwmodes = this.getHWModes(),
+ modestr = '';
+
+ if (hwmodes.a) modestr += 'a';
+ if (hwmodes.b) modestr += 'b';
+ if (hwmodes.g) modestr += 'g';
+ if (hwmodes.n) modestr += 'n';
+ if (hwmodes.ad) modestr += 'ac';
+
+ return '%s 802.11%s Wireless Controller (%s)'.format(type, modestr, this.getName());
+ },
+
+ isUp: function() {
+ if (isObject(_cache.wifi[this.sid]))
+ return (_cache.wifi[this.sid].up == true);
+
+ return false;
+ },
+
+ getWifiNetwork: function(network) {
+ return L.network.getWifiNetwork(network).then(L.bind(function(networkInstance) {
+ var uciWifiIface = (networkInstance.sid ? uci.get('wireless', networkInstance.sid) : null);
+
+ if (uciWifiIface == null || uciWifiIface['.type'] != 'wifi-iface' || uciWifiIface.device != this.sid)
+ return Promise.reject();
+
+ return networkInstance;
+ }, this));
+ },
+
+ getWifiNetworks: function() {
+ var uciWifiIfaces = uci.sections('wireless', 'wifi-iface'),
+ tasks = [];
+
+ for (var i = 0; i < uciWifiIfaces.length; i++)
+ if (uciWifiIfaces[i].device == this.sid)
+ tasks.push(L.network.getWifiNetwork(uciWifiIfaces[i]['.name']));
+
+ return Promise.all(tasks);
+ },
+
+ addWifiNetwork: function(options) {
+ if (!isObject(options))
+ options = {};
+
+ options.device = this.sid;
+
+ return L.network.addWifiNetwork(options);
+ },
+
+ deleteWifiNetwork: function(network) {
+ var sid = null;
+
+ if (network instanceof WifiNetwork) {
+ sid = network.sid;
+ }
+ else {
+ var uciWifiIface = uci.get('wireless', network);
+
+ if (uciWifiIface == null || uciWifiIface['.type'] != 'wifi-iface')
+ sid = getWifiSidByIfname(network);
+ }
+
+ if (sid == null || uci.get('wireless', sid, 'device') != this.sid)
+ return Promise.resolve(false);
+
+ uci.delete('wireless', network);
+
+ return Promise.resolve(true);
+ }
+});
+
+WifiNetwork = L.Class.extend({
+ __init__: function(sid, radioname, radiostate, netid, netstate, iwinfo) {
+ this.sid = sid;
+ this.wdev = iwinfo.ifname;
+ this.iwinfo = iwinfo;
+ this.netid = netid;
+ this._ubusdata = {
+ radio: radioname,
+ dev: radiostate,
+ net: netstate
+ };
+ },
+
+ ubus: function(/* ... */) {
+ var v = this._ubusdata;
+
+ for (var i = 0; i < arguments.length; i++)
+ if (isObject(v))
+ v = v[arguments[i]];
+ else
+ return null;
+
+ return v;
+ },
+
+ get: function(opt) {
+ return uci.get('wireless', this.sid, opt);
+ },
+
+ set: function(opt, value) {
+ return uci.set('wireless', this.sid, opt, value);
+ },
+
+ getMode: function() {
+ return this.ubus('net', 'config', 'mode') || this.get('mode') || 'ap';
+ },
+
+ getSSID: function() {
+ return this.ubus('net', 'config', 'ssid') || this.get('ssid');
+ },
+
+ getBSSID: function() {
+ return this.ubus('net', 'config', 'bssid') || this.get('bssid');
+ },
+
+ getNetworkNames: function() {
+ return toArray(this.ubus('net', 'config', 'network') || this.get('network'));
+ },
+
+ getID: function() {
+ return this.netid;
+ },
+
+ getName: function() {
+ return this.sid;
+ },
+
+ getIfname: function() {
+ var ifname = this.ubus('net', 'ifname') || this.iwinfo.ifname;
+
+ if (ifname == null || ifname.match(/^(wifi|radio)\d/))
+ ifname = this.netid;
+
+ return ifname;
+ },
+
+ getWifiDevice: function() {
+ var radioname = this.ubus('radio') || this.get('device');
+
+ if (radioname == null)
+ return Promise.reject();
+
+ return L.network.getWifiDevice(radioname);
+ },
+
+ isUp: function() {
+ var device = this.getDevice();
+
+ if (device == null)
+ return false;
+
+ return device.isUp();
+ },
+
+ getActiveMode: function() {
+ var mode = this.iwinfo.mode || this.ubus('net', 'config', 'mode') || this.get('mode') || 'ap';
+
+ switch (mode) {
+ case 'ap': return 'Master';
+ case 'sta': return 'Client';
+ case 'adhoc': return 'Ad-Hoc';
+ case 'mesh': return 'Mesh';
+ case 'monitor': return 'Monitor';
+ default: return mode;
+ }
+ },
+
+ getActiveModeI18n: function() {
+ var mode = this.getActiveMode();
+
+ switch (mode) {
+ case 'Master': return _('Master');
+ case 'Client': return _('Client');
+ case 'Ad-Hoc': return _('Ad-Hoc');
+ case 'Mash': return _('Mesh');
+ case 'Monitor': return _('Monitor');
+ default: return mode;
+ }
+ },
+
+ getActiveSSID: function() {
+ return this.iwinfo.ssid || this.ubus('net', 'config', 'ssid') || this.get('ssid');
+ },
+
+ getActiveBSSID: function() {
+ return this.iwinfo.bssid || this.ubus('net', 'config', 'bssid') || this.get('bssid');
+ },
+
+ getActiveEncryption: function() {
+ var encryption = this.iwinfo.encryption;
+
+ return (isObject(encryption) ? encryption.description || '-' : '-');
+ },
+
+ getAssocList: function() {
+ // XXX tbd
+ },
+
+ getFrequency: function() {
+ var freq = this.iwinfo.frequency;
+
+ if (freq != null && freq > 0)
+ return '%.03f'.format(freq / 1000);
+
+ return null;
+ },
+
+ getBitRate: function() {
+ var rate = this.iwinfo.bitrate;
+
+ if (rate != null && rate > 0)
+ return (rate / 1000);
+
+ return null;
+ },
+
+ getChannel: function() {
+ return this.iwinfo.channel || this.ubus('dev', 'config', 'channel') || this.get('channel');
+ },
+
+ getSignal: function() {
+ return this.iwinfo.signal || 0;
+ },
+
+ getNoise: function() {
+ return this.iwinfo.noise || 0;
+ },
+
+ getCountryCode: function() {
+ return this.iwinfo.country || this.ubus('dev', 'config', 'country') || '00';
+ },
+
+ getTXPower: function() {
+ var pwr = this.iwinfo.txpower || 0;
+ return (pwr + this.getTXPowerOffset());
+ },
+
+ getTXPowerOffset: function() {
+ return this.iwinfo.txpower_offset || 0;
+ },
+
+ getSignalLevel: function(signal, noise) {
+ if (this.getActiveBSSID() == '00:00:00:00:00:00')
+ return -1;
+
+ signal = signal || this.getSignal();
+ noise = noise || this.getNoise();
+
+ if (signal < 0 && noise < 0) {
+ var snr = -1 * (noise - signal);
+ return Math.floor(snr / 5);
+ }
+
+ return 0;
+ },
+
+ getSignalPercent: function() {
+ var qc = this.iwinfo.quality || 0,
+ qm = this.iwinfo.quality_max || 0;
+
+ if (qc > 0 && qm > 0)
+ return Math.floor((100 / qm) * qc);
+
+ return 0;
+ },
+
+ getShortName: function() {
+ return '%s "%s"'.format(
+ this.getActiveModeI18n(),
+ this.getActiveSSID() || this.getActiveBSSID() || this.getID());
+ },
+
+ getI18n: function() {
+ return '%s: %s "%s" (%s)'.format(
+ _('Wireless Network'),
+ this.getActiveModeI18n(),
+ this.getActiveSSID() || this.getActiveBSSID() || this.getID(),
+ this.getIfname());
+ },
+
+ getNetwork: function() {
+ return this.getNetworks()[0];
+ },
+
+ getNetworks: function() {
+ var networkNames = this.getNetworkNames(),
+ networks = [];
+
+ for (var i = 0; i < networkNames.length; i++) {
+ var uciInterface = uci.get('network', networkNames[i]);
+
+ if (uciInterface == null || uciInterface['.type'] != 'interface')
+ continue;
+
+ networks.push(L.network.instantiateNetwork(networkNames[i]));
+ }
+
+ networks.sort(networkSort);
+
+ return networks;
+ },
+
+ getDevice: function() {
+ return L.network.instantiateDevice(this.getIfname());
+ }
+});
+
+return Network;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-18 18:48:37 +0000