X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fluci2%2Fui.git;a=blobdiff_plain;f=luci2%2Fhtdocs%2Fluci2%2Fluci2.js;h=5947791600a9ace955dade058bbd8849ec29a2ce;hp=52ea2e7a035600270e911853a59ed7edcf9839c5;hb=e314622aa9ad41f5d3083dfd21ff0f61175c237f;hpb=bb111090d399e5d4eb9513187f410eb3428da07a diff --git a/luci2/htdocs/luci2/luci2.js b/luci2/htdocs/luci2/luci2.js index 52ea2e7..5947791 100644 --- a/luci2/htdocs/luci2/luci2.js +++ b/luci2/htdocs/luci2/luci2.js @@ -175,7 +175,7 @@ String.prototype.format = function() function LuCI2() { - var _luci2 = this; + var L = this; var Class = function() { }; @@ -214,7 +214,7 @@ function LuCI2() _class.prototype = prototype; _class.prototype.constructor = _class; - _class.extend = arguments.callee; + _class.extend = Class.extend; return _class; }; @@ -253,42 +253,42 @@ function LuCI2() plural: function(n) { return 0 + (n != 1) }, init: function() { - if (_luci2.i18n.loaded) + if (L.i18n.loaded) return; var lang = (navigator.userLanguage || navigator.language || 'en').toLowerCase(); var langs = (lang.indexOf('-') > -1) ? [ lang, lang.split(/-/)[0] ] : [ lang ]; for (var i = 0; i < langs.length; i++) - $.ajax('%s/i18n/base.%s.json'.format(_luci2.globals.resource, langs[i]), { + $.ajax('%s/i18n/base.%s.json'.format(L.globals.resource, langs[i]), { async: false, cache: true, dataType: 'json', success: function(data) { - $.extend(_luci2.i18n.catalog, data); + $.extend(L.i18n.catalog, data); - var pe = _luci2.i18n.catalog['']; + var pe = L.i18n.catalog['']; if (pe) { - delete _luci2.i18n.catalog['']; + delete L.i18n.catalog['']; try { var pf = new Function('n', 'return 0 + (' + pe + ')'); - _luci2.i18n.plural = pf; + L.i18n.plural = pf; } catch (e) { }; } } }); - _luci2.i18n.loaded = true; + L.i18n.loaded = true; } }; this.tr = function(msgid) { - _luci2.i18n.init(); + L.i18n.init(); - var msgstr = _luci2.i18n.catalog[msgid]; + var msgstr = L.i18n.catalog[msgid]; if (typeof(msgstr) == 'undefined') return msgid; @@ -300,23 +300,23 @@ function LuCI2() this.trp = function(msgid, msgid_plural, count) { - _luci2.i18n.init(); + L.i18n.init(); - var msgstr = _luci2.i18n.catalog[msgid]; + var msgstr = L.i18n.catalog[msgid]; if (typeof(msgstr) == 'undefined') return (count == 1) ? msgid : msgid_plural; else if (typeof(msgstr) == 'string') return msgstr; else - return msgstr[_luci2.i18n.plural(count)]; + return msgstr[L.i18n.plural(count)]; }; this.trc = function(msgctx, msgid) { - _luci2.i18n.init(); + L.i18n.init(); - var msgstr = _luci2.i18n.catalog[msgid + '\u0004' + msgctx]; + var msgstr = L.i18n.catalog[msgid + '\u0004' + msgctx]; if (typeof(msgstr) == 'undefined') return msgid; @@ -328,16 +328,16 @@ function LuCI2() this.trcp = function(msgctx, msgid, msgid_plural, count) { - _luci2.i18n.init(); + L.i18n.init(); - var msgstr = _luci2.i18n.catalog[msgid + '\u0004' + msgctx]; + var msgstr = L.i18n.catalog[msgid + '\u0004' + msgctx]; if (typeof(msgstr) == 'undefined') return (count == 1) ? msgid : msgid_plural; else if (typeof(msgstr) == 'string') return msgstr; else - return msgstr[_luci2.i18n.plural(count)]; + return msgstr[L.i18n.plural(count)]; }; this.setHash = function(key, value) @@ -364,8 +364,10 @@ function LuCI2() h += keys[i] + ':' + data[keys[i]]; } - if (h) + if (h.length) location.hash = '#' + h; + else + location.hash = ''; }; this.getHash = function(key) @@ -386,8 +388,251 @@ function LuCI2() return data; }; + this.toArray = function(x) + { + switch (typeof(x)) + { + case 'number': + case 'boolean': + return [ x ]; + + case 'string': + var r = [ ]; + var l = x.split(/\s+/); + for (var i = 0; i < l.length; i++) + if (l[i].length > 0) + r.push(l[i]); + return r; + + case 'object': + if ($.isArray(x)) + { + var r = [ ]; + for (var i = 0; i < x.length; i++) + r.push(x[i]); + return r; + } + else if ($.isPlainObject(x)) + { + var r = [ ]; + for (var k in x) + if (x.hasOwnProperty(k)) + r.push(k); + return r.sort(); + } + } + + return [ ]; + }; + + this.toObject = function(x) + { + switch (typeof(x)) + { + case 'number': + case 'boolean': + return { x: true }; + + case 'string': + var r = { }; + var l = x.split(/\x+/); + for (var i = 0; i < l.length; i++) + if (l[i].length > 0) + r[l[i]] = true; + return r; + + case 'object': + if ($.isArray(x)) + { + var r = { }; + for (var i = 0; i < x.length; i++) + r[x[i]] = true; + return r; + } + else if ($.isPlainObject(x)) + { + return x; + } + } + + return { }; + }; + + this.filterArray = function(array, item) + { + if (!$.isArray(array)) + return [ ]; + + for (var i = 0; i < array.length; i++) + if (array[i] === item) + array.splice(i--, 1); + + return array; + }; + + this.toClassName = function(str, suffix) + { + var n = ''; + var l = str.split(/[\/.]/); + + for (var i = 0; i < l.length; i++) + if (l[i].length > 0) + n += l[i].charAt(0).toUpperCase() + l[i].substr(1).toLowerCase(); + + if (typeof(suffix) == 'string') + n += suffix; + + return n; + }; + + this.toColor = function(str) + { + if (typeof(str) != 'string' || str.length == 0) + return '#CCCCCC'; + + if (str == 'wan') + return '#F09090'; + else if (str == 'lan') + return '#90F090'; + + var i = 0, hash = 0; + + while (i < str.length) + hash = str.charCodeAt(i++) + ((hash << 5) - hash); + + var r = (hash & 0xFF) % 128; + var g = ((hash >> 8) & 0xFF) % 128; + + var min = 0; + var max = 128; + + if ((r + g) < 128) + min = 128 - r - g; + else + max = 255 - r - g; + + var b = min + (((hash >> 16) & 0xFF) % (max - min)); + + return '#%02X%02X%02X'.format(0xFF - r, 0xFF - g, 0xFF - b); + }; + + this.parseIPv4 = function(str) + { + if ((typeof(str) != 'string' && !(str instanceof String)) || + !str.match(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/)) + return undefined; + + var num = [ ]; + var parts = str.split(/\./); + + for (var i = 0; i < parts.length; i++) + { + var n = parseInt(parts[i], 10); + if (isNaN(n) || n > 255) + return undefined; + + num.push(n); + } + + return num; + }; + + this.parseIPv6 = function(str) + { + if ((typeof(str) != 'string' && !(str instanceof String)) || + !str.match(/^[a-fA-F0-9:]+(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/)) + return undefined; + + var parts = str.split(/::/); + if (parts.length == 0 || parts.length > 2) + return undefined; + + var lnum = [ ]; + if (parts[0].length > 0) + { + var left = parts[0].split(/:/); + for (var i = 0; i < left.length; i++) + { + var n = parseInt(left[i], 16); + if (isNaN(n)) + return undefined; + + lnum.push((n / 256) >> 0); + lnum.push(n % 256); + } + } + + var rnum = [ ]; + if (parts.length > 1 && parts[1].length > 0) + { + var right = parts[1].split(/:/); + + for (var i = 0; i < right.length; i++) + { + if (right[i].indexOf('.') > 0) + { + var addr = L.parseIPv4(right[i]); + if (!addr) + return undefined; + + rnum.push.apply(rnum, addr); + continue; + } + + var n = parseInt(right[i], 16); + if (isNaN(n)) + return undefined; + + rnum.push((n / 256) >> 0); + rnum.push(n % 256); + } + } + + if (rnum.length > 0 && (lnum.length + rnum.length) > 15) + return undefined; + + var num = [ ]; + + num.push.apply(num, lnum); + + for (var i = 0; i < (16 - lnum.length - rnum.length); i++) + num.push(0); + + num.push.apply(num, rnum); + + if (num.length > 16) + return undefined; + + return num; + }; + + this.isNetmask = function(addr) + { + if (!$.isArray(addr)) + return false; + + var c; + + for (c = 0; (c < addr.length) && (addr[c] == 255); c++); + + if (c == addr.length) + return true; + + if ((addr[c] == 254) || (addr[c] == 252) || (addr[c] == 248) || + (addr[c] == 240) || (addr[c] == 224) || (addr[c] == 192) || + (addr[c] == 128) || (addr[c] == 0)) + { + for (c++; (c < addr.length) && (addr[c] == 0); c++); + + if (c == addr.length) + return true; + } + + return false; + }; + this.globals = { - timeout: 3000, + timeout: 15000, resource: '/luci2', sid: '00000000000000000000000000000000' }; @@ -406,43 +651,48 @@ function LuCI2() data: JSON.stringify(req), dataType: 'json', type: 'POST', - timeout: _luci2.globals.timeout - }).then(cb); + timeout: L.globals.timeout, + _rpc_req: req + }).then(cb, cb); }, _list_cb: function(msg) { + var list = msg.result; + /* verify message frame */ - if (typeof(msg) != 'object' || msg.jsonrpc != '2.0' || !msg.id) - throw 'Invalid JSON response'; + if (typeof(msg) != 'object' || msg.jsonrpc != '2.0' || !msg.id || !$.isArray(list)) + list = [ ]; - return msg.result; + return $.Deferred().resolveWith(this, [ list ]); }, _call_cb: function(msg) { var data = [ ]; var type = Object.prototype.toString; + var reqs = this._rpc_req; - if (!$.isArray(msg)) + if (!$.isArray(reqs)) + { msg = [ msg ]; + reqs = [ reqs ]; + } for (var i = 0; i < msg.length; i++) { - /* verify message frame */ - if (typeof(msg[i]) != 'object' || msg[i].jsonrpc != '2.0' || !msg[i].id) - throw 'Invalid JSON response'; - /* fetch related request info */ - var req = _luci2.rpc._requests[msg[i].id]; + var req = L.rpc._requests[reqs[i].id]; if (typeof(req) != 'object') throw 'No related request for JSON response'; /* fetch response attribute and verify returned type */ var ret = undefined; - if ($.isArray(msg[i].result) && msg[i].result[0] == 0) - ret = (msg[i].result.length > 1) ? msg[i].result[1] : msg[i].result[0]; + /* verify message frame */ + if (typeof(msg[i]) == 'object' && msg[i].jsonrpc == '2.0') + if ($.isArray(msg[i].result) && msg[i].result[0] == 0) + ret = (msg[i].result.length > 1) ? msg[i].result[1] : msg[i].result[0]; if (req.expect) { @@ -451,7 +701,7 @@ function LuCI2() if (typeof(ret) != 'undefined' && key != '') ret = ret[key]; - if (type.call(ret) != type.call(req.expect[key])) + if (typeof(ret) == 'undefined' || type.call(ret) != type.call(req.expect[key])) ret = req.expect[key]; break; @@ -463,7 +713,7 @@ function LuCI2() { req.priv[0] = ret; req.priv[1] = req.params; - ret = req.filter.apply(_luci2.rpc, req.priv); + ret = req.filter.apply(L.rpc, req.priv); } /* store response data */ @@ -473,10 +723,10 @@ function LuCI2() data = ret; /* delete request object */ - delete _luci2.rpc._requests[msg[i].id]; + delete L.rpc._requests[reqs[i].id]; } - return data; + return $.Deferred().resolveWith(this, [ data ]); }, list: function() @@ -504,7 +754,7 @@ function LuCI2() flush: function() { if (!$.isArray(this._batch)) - return _luci2.deferrable([ ]); + return L.deferrable([ ]); var req = this._batch; delete this._batch; @@ -544,7 +794,7 @@ function LuCI2() id: _rpc._id++, method: 'call', params: [ - _luci2.globals.sid, + L.globals.sid, options.object, options.method, params @@ -556,7 +806,7 @@ function LuCI2() if ($.isArray(_rpc._batch)) { req.index = _rpc._batch.push(msg) - 1; - return _luci2.deferrable(msg); + return L.deferrable(msg); } /* call rpc */ @@ -565,389 +815,556 @@ function LuCI2() } }; - this.uci = { - - writable: function() - { - return _luci2.session.access('ubus', 'uci', 'commit'); - }, - - add: _luci2.rpc.declare({ - object: 'uci', - method: 'add', - params: [ 'config', 'type', 'name', 'values' ], - expect: { section: '' } - }), + this.UCIContext = Class.extend({ - apply: function() + init: function() { - + this.state = { + newidx: 0, + values: { }, + creates: { }, + changes: { }, + deletes: { }, + reorder: { } + }; }, - configs: _luci2.rpc.declare({ + _load: L.rpc.declare({ object: 'uci', - method: 'configs', - expect: { configs: [ ] } + method: 'get', + params: [ 'config' ], + expect: { values: { } } }), - _changes: _luci2.rpc.declare({ + _order: L.rpc.declare({ object: 'uci', - method: 'changes', - params: [ 'config' ], - expect: { changes: [ ] } + method: 'order', + params: [ 'config', 'sections' ] }), - changes: function(config) - { - if (typeof(config) == 'string') - return this._changes(config); - - var configlist; - return this.configs().then(function(configs) { - _luci2.rpc.batch(); - configlist = configs; - - for (var i = 0; i < configs.length; i++) - _luci2.uci._changes(configs[i]); - - return _luci2.rpc.flush(); - }).then(function(changes) { - var rv = { }; - - for (var i = 0; i < configlist.length; i++) - if (changes[i].length) - rv[configlist[i]] = changes[i]; - - return rv; - }); - }, - - commit: _luci2.rpc.declare({ + _add: L.rpc.declare({ object: 'uci', - method: 'commit', - params: [ 'config' ] + method: 'add', + params: [ 'config', 'type', 'name', 'values' ], + expect: { section: '' } }), - _delete_one: _luci2.rpc.declare({ + _set: L.rpc.declare({ object: 'uci', - method: 'delete', - params: [ 'config', 'section', 'option' ] + method: 'set', + params: [ 'config', 'section', 'values' ] }), - _delete_multiple: _luci2.rpc.declare({ + _delete: L.rpc.declare({ object: 'uci', method: 'delete', params: [ 'config', 'section', 'options' ] }), - 'delete': function(config, section, option) + _newid: function(conf) { - if ($.isArray(option)) - return this._delete_multiple(config, section, option); - else - return this._delete_one(config, section, option); - }, + var v = this.state.values; + var n = this.state.creates; + var sid; - delete_all: _luci2.rpc.declare({ - object: 'uci', - method: 'delete', - params: [ 'config', 'type', 'match' ] - }), + do { + sid = "new%06x".format(Math.random() * 0xFFFFFF); + } while ((n[conf] && n[conf][sid]) || (v[conf] && v[conf][sid])); - _foreach: _luci2.rpc.declare({ - object: 'uci', - method: 'get', - params: [ 'config', 'type' ], - expect: { values: { } } - }), + return sid; + }, - foreach: function(config, type, cb) + load: function(packages) { - return this._foreach(config, type).then(function(sections) { - for (var s in sections) - cb(sections[s]); - }); - }, + var self = this; + var seen = { }; + var pkgs = [ ]; - get: _luci2.rpc.declare({ - object: 'uci', - method: 'get', - params: [ 'config', 'section', 'option' ], - expect: { '': { } }, - filter: function(data, params) { - if (typeof(params.option) == 'undefined') - return data.values ? data.values['.type'] : undefined; - else - return data.value; - } - }), + if (!$.isArray(packages)) + packages = [ packages ]; - get_all: _luci2.rpc.declare({ - object: 'uci', - method: 'get', - params: [ 'config', 'section' ], - expect: { values: { } }, - filter: function(data, params) { - if (typeof(params.section) == 'string') - data['.section'] = params.section; - else if (typeof(params.config) == 'string') - data['.package'] = params.config; - return data; - } - }), + L.rpc.batch(); - get_first: function(config, type, option) - { - return this._foreach(config, type).then(function(sections) { - for (var s in sections) + for (var i = 0; i < packages.length; i++) + if (!seen[packages[i]] && !self.state.values[packages[i]]) { - var val = (typeof(option) == 'string') ? sections[s][option] : sections[s]['.name']; - - if (typeof(val) != 'undefined') - return val; + pkgs.push(packages[i]); + seen[packages[i]] = true; + self._load(packages[i]); } - return undefined; + return L.rpc.flush().then(function(responses) { + for (var i = 0; i < responses.length; i++) + self.state.values[pkgs[i]] = responses[i]; + + return pkgs; }); }, - section: _luci2.rpc.declare({ - object: 'uci', - method: 'add', - params: [ 'config', 'type', 'name', 'values' ], - expect: { section: '' } - }), + unload: function(packages) + { + if (!$.isArray(packages)) + packages = [ packages ]; - _set: _luci2.rpc.declare({ - object: 'uci', - method: 'set', - params: [ 'config', 'section', 'values' ] - }), + for (var i = 0; i < packages.length; i++) + { + delete this.state.values[packages[i]]; + delete this.state.creates[packages[i]]; + delete this.state.changes[packages[i]]; + delete this.state.deletes[packages[i]]; + } + }, - set: function(config, section, option, value) + add: function(conf, type, name) { - if (typeof(value) == 'undefined' && typeof(option) == 'string') - return this.section(config, section, option); /* option -> type */ - else if ($.isPlainObject(option)) - return this._set(config, section, option); /* option -> values */ + var n = this.state.creates; + var sid = this._newid(conf); - var values = { }; - values[option] = value; + if (!n[conf]) + n[conf] = { }; - return this._set(config, section, values); - }, - - order: _luci2.rpc.declare({ - object: 'uci', - method: 'order', - params: [ 'config', 'sections' ] - }) - }; + n[conf][sid] = { + '.type': type, + '.name': sid, + '.create': name, + '.anonymous': !name, + '.index': 1000 + this.state.newidx++ + }; - this.network = { - listNetworkNames: function() { - return _luci2.rpc.list('network.interface.*').then(function(list) { - var names = [ ]; - for (var name in list) - if (name != 'network.interface.loopback') - names.push(name.substring(18)); - names.sort(); - return names; - }); + return sid; }, - listDeviceNames: _luci2.rpc.declare({ - object: 'network.device', - method: 'status', - expect: { '': { } }, - filter: function(data) { - var names = [ ]; - for (var name in data) - if (name != 'lo') - names.push(name); - names.sort(); - return names; - } - }), - - getNetworkStatus: function() + remove: function(conf, sid) { - var nets = [ ]; - var devs = { }; + var n = this.state.creates; + var c = this.state.changes; + var d = this.state.deletes; - return this.listNetworkNames().then(function(names) { - _luci2.rpc.batch(); + /* requested deletion of a just created section */ + if (n[conf] && n[conf][sid]) + { + delete n[conf][sid]; + } + else + { + if (c[conf]) + delete c[conf][sid]; - for (var i = 0; i < names.length; i++) - _luci2.network.getInterfaceStatus(names[i]); + if (!d[conf]) + d[conf] = { }; - return _luci2.rpc.flush(); - }).then(function(networks) { - for (var i = 0; i < networks.length; i++) - { - var net = nets[i] = networks[i]; - var dev = net.l3_device || net.l2_device; - if (dev) - net.device = devs[dev] = { }; - } + d[conf][sid] = true; + } + }, - _luci2.rpc.batch(); + sections: function(conf, type, cb) + { + var sa = [ ]; + var v = this.state.values[conf]; + var n = this.state.creates[conf]; + var c = this.state.changes[conf]; + var d = this.state.deletes[conf]; - for (var dev in devs) - _luci2.network.listDeviceNamestatus(dev); + if (!v) + return sa; - return _luci2.rpc.flush(); - }).then(function(devices) { - _luci2.rpc.batch(); + for (var s in v) + if (!d || d[s] !== true) + if (!type || v[s]['.type'] == type) + sa.push($.extend({ }, v[s], c ? c[s] : undefined)); - for (var i = 0; i < devices.length; i++) - { - var brm = devices[i]['bridge-members']; - delete devices[i]['bridge-members']; + if (n) + for (var s in n) + if (!type || n[s]['.type'] == type) + sa.push(n[s]); - $.extend(devs[devices[i]['device']], devices[i]); + sa.sort(function(a, b) { + return a['.index'] - b['.index']; + }); - if (!brm) - continue; + for (var i = 0; i < sa.length; i++) + sa[i]['.index'] = i; - devs[devices[i]['device']].subdevices = [ ]; + if (typeof(cb) == 'function') + for (var i = 0; i < sa.length; i++) + cb.call(this, sa[i], sa[i]['.name']); - for (var j = 0; j < brm.length; j++) - { - if (!devs[brm[j]]) - { - devs[brm[j]] = { }; - _luci2.network.listDeviceNamestatus(brm[j]); - } + return sa; + }, - devs[devices[i]['device']].subdevices[j] = devs[brm[j]]; - } - } + get: function(conf, sid, opt) + { + var v = this.state.values; + var n = this.state.creates; + var c = this.state.changes; + var d = this.state.deletes; - return _luci2.rpc.flush(); - }).then(function(subdevices) { - for (var i = 0; i < subdevices.length; i++) - $.extend(devs[subdevices[i]['device']], subdevices[i]); + if (typeof(sid) == 'undefined') + return undefined; - _luci2.rpc.batch(); + /* requested option in a just created section */ + if (n[conf] && n[conf][sid]) + { + if (!n[conf]) + return undefined; - for (var dev in devs) - _luci2.wireless.getDeviceStatus(dev); + if (typeof(opt) == 'undefined') + return n[conf][sid]; - return _luci2.rpc.flush(); - }).then(function(wifidevices) { - for (var i = 0; i < wifidevices.length; i++) - if (wifidevices[i]) - devs[wifidevices[i]['device']].wireless = wifidevices[i]; + return n[conf][sid][opt]; + } - nets.sort(function(a, b) { - if (a['interface'] < b['interface']) - return -1; - else if (a['interface'] > b['interface']) - return 1; - else - return 0; - }); + /* requested an option value */ + if (typeof(opt) != 'undefined') + { + /* check whether option was deleted */ + if (d[conf] && d[conf][sid]) + { + if (d[conf][sid] === true) + return undefined; + + for (var i = 0; i < d[conf][sid].length; i++) + if (d[conf][sid][i] == opt) + return undefined; + } + + /* check whether option was changed */ + if (c[conf] && c[conf][sid] && typeof(c[conf][sid][opt]) != 'undefined') + return c[conf][sid][opt]; + + /* return base value */ + if (v[conf] && v[conf][sid]) + return v[conf][sid][opt]; + + return undefined; + } + + /* requested an entire section */ + if (v[conf]) + return v[conf][sid]; + + return undefined; + }, + + set: function(conf, sid, opt, val) + { + var v = this.state.values; + var n = this.state.creates; + var c = this.state.changes; + var d = this.state.deletes; + + if (typeof(sid) == 'undefined' || + typeof(opt) == 'undefined' || + opt.charAt(0) == '.') + return; + + if (n[conf] && n[conf][sid]) + { + if (typeof(val) != 'undefined') + n[conf][sid][opt] = val; + else + delete n[conf][sid][opt]; + } + else if (typeof(val) != 'undefined') + { + /* do not set within deleted section */ + if (d[conf] && d[conf][sid] === true) + return; + + /* only set in existing sections */ + if (!v[conf] || !v[conf][sid]) + return; + + if (!c[conf]) + c[conf] = { }; + + if (!c[conf][sid]) + c[conf][sid] = { }; + + /* undelete option */ + if (d[conf] && d[conf][sid]) + d[conf][sid] = L.filterArray(d[conf][sid], opt); + + c[conf][sid][opt] = val; + } + else + { + /* only delete in existing sections */ + if (!v[conf] || !v[conf][sid]) + return; + + if (!d[conf]) + d[conf] = { }; + + if (!d[conf][sid]) + d[conf][sid] = [ ]; + + if (d[conf][sid] !== true) + d[conf][sid].push(opt); + } + }, + + unset: function(conf, sid, opt) + { + return this.set(conf, sid, opt, undefined); + }, - return nets; + get_first: function(conf, type, opt) + { + var sid = undefined; + + L.uci.sections(conf, type, function(s) { + if (typeof(sid) != 'string') + sid = s['.name']; }); + + return this.get(conf, sid, opt); }, - findWanInterfaces: function(cb) + set_first: function(conf, type, opt, val) { - return this.listNetworkNames().then(function(names) { - _luci2.rpc.batch(); + var sid = undefined; - for (var i = 0; i < names.length; i++) - _luci2.network.getInterfaceStatus(names[i]); + L.uci.sections(conf, type, function(s) { + if (typeof(sid) != 'string') + sid = s['.name']; + }); + + return this.set(conf, sid, opt, val); + }, + + unset_first: function(conf, type, opt) + { + return this.set_first(conf, type, opt, undefined); + }, + + _reload: function() + { + var pkgs = [ ]; + + for (var pkg in this.state.values) + pkgs.push(pkg); + + this.init(); + + return this.load(pkgs); + }, + + _reorder: function() + { + var v = this.state.values; + var n = this.state.creates; + var r = this.state.reorder; + + if ($.isEmptyObject(r)) + return L.deferrable(); + + L.rpc.batch(); + + /* + gather all created and existing sections, sort them according + to their index value and issue an uci order call + */ + for (var c in r) + { + var o = [ ]; + + if (n[c]) + for (var s in n[c]) + o.push(n[c][s]); + + for (var s in v[c]) + o.push(v[c][s]); + + if (o.length > 0) + { + o.sort(function(a, b) { + return (a['.index'] - b['.index']); + }); + + var sids = [ ]; - return _luci2.rpc.flush(); - }).then(function(interfaces) { - var rv = [ undefined, undefined ]; + for (var i = 0; i < o.length; i++) + sids.push(o[i]['.name']); - for (var i = 0; i < interfaces.length; i++) + this._order(c, sids); + } + } + + this.state.reorder = { }; + return L.rpc.flush(); + }, + + swap: function(conf, sid1, sid2) + { + var s1 = this.get(conf, sid1); + var s2 = this.get(conf, sid2); + var n1 = s1 ? s1['.index'] : NaN; + var n2 = s2 ? s2['.index'] : NaN; + + if (isNaN(n1) || isNaN(n2)) + return false; + + s1['.index'] = n2; + s2['.index'] = n1; + + this.state.reorder[conf] = true; + + return true; + }, + + save: function() + { + L.rpc.batch(); + + var v = this.state.values; + var n = this.state.creates; + var c = this.state.changes; + var d = this.state.deletes; + + var self = this; + var snew = [ ]; + var pkgs = { }; + + if (n) + for (var conf in n) { - for (var j = 0; j < interfaces[i].route.length; j++) + for (var sid in n[conf]) { - var rt = interfaces[i].route[j]; + var r = { + config: conf, + values: { } + }; - if (typeof(rt.table) != 'undefined') - continue; + for (var k in n[conf][sid]) + { + if (k == '.type') + r.type = n[conf][sid][k]; + else if (k == '.create') + r.name = n[conf][sid][k]; + else if (k.charAt(0) != '.') + r.values[k] = n[conf][sid][k]; + } - if (rt.target == '0.0.0.0' && rt.mask == 0) - rv[0] = interfaces[i]; - else if (rt.target == '::' && rt.mask == 0) - rv[1] = interfaces[i]; + snew.push(n[conf][sid]); + + self._add(r.config, r.type, r.name, r.values); } + + pkgs[conf] = true; } - return rv; + if (c) + for (var conf in c) + { + for (var sid in c[conf]) + self._set(conf, sid, c[conf][sid]); + + pkgs[conf] = true; + } + + if (d) + for (var conf in d) + { + for (var sid in d[conf]) + { + var o = d[conf][sid]; + self._delete(conf, sid, (o === true) ? undefined : o); + } + + pkgs[conf] = true; + } + + return L.rpc.flush().then(function(responses) { + /* + array "snew" holds references to the created uci sections, + use it to assign the returned names of the new sections + */ + for (var i = 0; i < snew.length; i++) + snew[i]['.name'] = responses[i]; + + return self._reorder(); + }).then(function() { + pkgs = L.toArray(pkgs); + + self.unload(pkgs); + + return self.load(pkgs); }); }, - getDHCPLeases: _luci2.rpc.declare({ - object: 'luci2.network', - method: 'dhcp_leases', - expect: { leases: [ ] } + _apply: L.rpc.declare({ + object: 'uci', + method: 'apply', + params: [ 'timeout', 'rollback' ] }), - getDHCPv6Leases: _luci2.rpc.declare({ - object: 'luci2.network', - method: 'dhcp6_leases', - expect: { leases: [ ] } + _confirm: L.rpc.declare({ + object: 'uci', + method: 'confirm' }), - getRoutes: _luci2.rpc.declare({ - object: 'luci2.network', - method: 'routes', - expect: { routes: [ ] } - }), + apply: function(timeout) + { + var self = this; + var date = new Date(); + var deferred = $.Deferred(); - getIPv6Routes: _luci2.rpc.declare({ - object: 'luci2.network', - method: 'routes', - expect: { routes: [ ] } - }), + if (typeof(timeout) != 'number' || timeout < 1) + timeout = 10; - getARPTable: _luci2.rpc.declare({ - object: 'luci2.network', - method: 'arp_table', - expect: { entries: [ ] } - }), + self._apply(timeout, true).then(function(rv) { + if (rv != 0) + { + deferred.rejectWith(self, [ rv ]); + return; + } - getInterfaceStatus: _luci2.rpc.declare({ - object: 'network.interface', - method: 'status', - params: [ 'interface' ], - expect: { '': { } }, - filter: function(data, params) { - data['interface'] = params['interface']; - data['l2_device'] = data['device']; - delete data['device']; - return data; - } - }), + var try_deadline = date.getTime() + 1000 * timeout; + var try_confirm = function() + { + return self._confirm().then(function(rv) { + if (rv != 0) + { + if (date.getTime() < try_deadline) + window.setTimeout(try_confirm, 250); + else + deferred.rejectWith(self, [ rv ]); - listDeviceNamestatus: _luci2.rpc.declare({ - object: 'network.device', - method: 'status', - params: [ 'name' ], - expect: { '': { } }, - filter: function(data, params) { - data['device'] = params['name']; - return data; - } + return; + } + + deferred.resolveWith(self, [ rv ]); + }); + }; + + window.setTimeout(try_confirm, 1000); + }); + + return deferred; + }, + + changes: L.rpc.declare({ + object: 'uci', + method: 'changes', + expect: { changes: { } } }), - getConntrackCount: _luci2.rpc.declare({ - object: 'luci2.network', - method: 'conntrack_count', - expect: { '': { count: 0, limit: 0 } } - }) - }; + readable: function(conf) + { + return L.session.hasACL('uci', conf, 'read'); + }, + + writable: function(conf) + { + return L.session.hasACL('uci', conf, 'write'); + } + }); + + this.uci = new this.UCIContext(); this.wireless = { - listDeviceNames: _luci2.rpc.declare({ + listDeviceNames: L.rpc.declare({ object: 'iwinfo', method: 'devices', expect: { 'devices': [ ] }, @@ -957,7 +1374,7 @@ function LuCI2() } }), - getDeviceStatus: _luci2.rpc.declare({ + getDeviceStatus: L.rpc.declare({ object: 'iwinfo', method: 'info', params: [ 'device' ], @@ -972,7 +1389,7 @@ function LuCI2() } }), - getAssocList: _luci2.rpc.declare({ + getAssocList: L.rpc.declare({ object: 'iwinfo', method: 'assoclist', params: [ 'device' ], @@ -996,12 +1413,12 @@ function LuCI2() getWirelessStatus: function() { return this.listDeviceNames().then(function(names) { - _luci2.rpc.batch(); + L.rpc.batch(); for (var i = 0; i < names.length; i++) - _luci2.wireless.getDeviceStatus(names[i]); + L.wireless.getDeviceStatus(names[i]); - return _luci2.rpc.flush(); + return L.rpc.flush(); }).then(function(networks) { var rv = { }; @@ -1041,12 +1458,12 @@ function LuCI2() getAssocLists: function() { return this.listDeviceNames().then(function(names) { - _luci2.rpc.batch(); + L.rpc.batch(); for (var i = 0; i < names.length; i++) - _luci2.wireless.getAssocList(names[i]); + L.wireless.getAssocList(names[i]); - return _luci2.rpc.flush(); + return L.rpc.flush(); }).then(function(assoclists) { var rv = [ ]; @@ -1069,21 +1486,21 @@ function LuCI2() } if (!enc || !enc.enabled) - return _luci2.tr('None'); + return L.tr('None'); if (enc.wep) { if (enc.wep.length == 2) - return _luci2.tr('WEP Open/Shared') + ' (%s)'.format(format_list(enc.ciphers, ', ')); + return L.tr('WEP Open/Shared') + ' (%s)'.format(format_list(enc.ciphers, ', ')); else if (enc.wep[0] == 'shared') - return _luci2.tr('WEP Shared Auth') + ' (%s)'.format(format_list(enc.ciphers, ', ')); + return L.tr('WEP Shared Auth') + ' (%s)'.format(format_list(enc.ciphers, ', ')); else - return _luci2.tr('WEP Open System') + ' (%s)'.format(format_list(enc.ciphers, ', ')); + return L.tr('WEP Open System') + ' (%s)'.format(format_list(enc.ciphers, ', ')); } else if (enc.wpa) { if (enc.wpa.length == 2) - return _luci2.tr('mixed WPA/WPA2') + ' %s (%s)'.format( + return L.tr('mixed WPA/WPA2') + ' %s (%s)'.format( format_list(enc.authentication, '/'), format_list(enc.ciphers, ', ') ); @@ -1099,365 +1516,1569 @@ function LuCI2() ); } - return _luci2.tr('Unknown'); + return L.tr('Unknown'); } }; - this.system = { - getSystemInfo: _luci2.rpc.declare({ - object: 'system', - method: 'info', - expect: { '': { } } - }), + this.firewall = { + getZoneColor: function(zone) + { + if ($.isPlainObject(zone)) + zone = zone.name; - getBoardInfo: _luci2.rpc.declare({ - object: 'system', - method: 'board', - expect: { '': { } } - }), + if (zone == 'lan') + return '#90f090'; + else if (zone == 'wan') + return '#f09090'; - getDiskInfo: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'diskfree', - expect: { '': { } } - }), + for (var i = 0, hash = 0; + i < zone.length; + hash = zone.charCodeAt(i++) + ((hash << 5) - hash)); - getInfo: function(cb) + for (var i = 0, color = '#'; + i < 3; + color += ('00' + ((hash >> i++ * 8) & 0xFF).tostring(16)).slice(-2)); + + return color; + }, + + findZoneByNetwork: function(network) { - _luci2.rpc.batch(); + var self = this; + var zone = undefined; - this.getSystemInfo(); - this.getBoardInfo(); - this.getDiskInfo(); + return L.uci.sections('firewall', 'zone', function(z) { + if (!z.name || !z.network) + return; - return _luci2.rpc.flush().then(function(info) { - var rv = { }; + if (!$.isArray(z.network)) + z.network = z.network.split(/\s+/); - $.extend(rv, info[0]); - $.extend(rv, info[1]); - $.extend(rv, info[2]); + for (var i = 0; i < z.network.length; i++) + { + if (z.network[i] == network) + { + zone = z; + break; + } + } + }).then(function() { + if (zone) + zone.color = self.getZoneColor(zone); - return rv; + return zone; }); - }, + } + }; - getProcessList: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'process_list', - expect: { processes: [ ] }, - filter: function(data) { - data.sort(function(a, b) { return a.pid - b.pid }); - return data; - } - }), + this.NetworkModel = { + _device_blacklist: [ + /^gre[0-9]+$/, + /^gretap[0-9]+$/, + /^ifb[0-9]+$/, + /^ip6tnl[0-9]+$/, + /^sit[0-9]+$/, + /^wlan[0-9]+\.sta[0-9]+$/ + ], + + _cache_functions: [ + 'protolist', 0, L.rpc.declare({ + object: 'network', + method: 'get_proto_handlers', + expect: { '': { } } + }), + 'ifstate', 1, L.rpc.declare({ + object: 'network.interface', + method: 'dump', + expect: { 'interface': [ ] } + }), + 'devstate', 2, L.rpc.declare({ + object: 'network.device', + method: 'status', + expect: { '': { } } + }), + 'wifistate', 0, L.rpc.declare({ + object: 'network.wireless', + method: 'status', + expect: { '': { } } + }), + 'bwstate', 2, L.rpc.declare({ + object: 'luci2.network.bwmon', + method: 'statistics', + expect: { 'statistics': { } } + }), + 'devlist', 2, L.rpc.declare({ + object: 'luci2.network', + method: 'device_list', + expect: { 'devices': [ ] } + }), + 'swlist', 0, L.rpc.declare({ + object: 'luci2.network', + method: 'switch_list', + expect: { 'switches': [ ] } + }) + ], + + _fetch_protocol: function(proto) + { + var url = L.globals.resource + '/proto/' + proto + '.js'; + var self = L.NetworkModel; + + var def = $.Deferred(); + + $.ajax(url, { + method: 'GET', + cache: true, + dataType: 'text' + }).then(function(data) { + try { + var protoConstructorSource = ( + '(function(L, $) { ' + + 'return %s' + + '})(L, $);\n\n' + + '//@ sourceURL=%s' + ).format(data, url); - getSystemLog: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'syslog', - expect: { log: '' } - }), + var protoClass = eval(protoConstructorSource); - getKernelLog: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'dmesg', - expect: { log: '' } - }), + self._protos[proto] = new protoClass(); + } + catch(e) { + alert('Unable to instantiate proto "%s": %s'.format(url, e)); + }; - getZoneInfo: function(cb) + def.resolve(); + }).fail(function() { + def.resolve(); + }); + + return def; + }, + + _fetch_protocols: function() { - return $.getJSON(_luci2.globals.resource + '/zoneinfo.json', cb); + var self = L.NetworkModel; + var deferreds = [ + self._fetch_protocol('none') + ]; + + for (var proto in self._cache.protolist) + deferreds.push(self._fetch_protocol(proto)); + + return $.when.apply($, deferreds); }, - sendSignal: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'process_signal', - params: [ 'pid', 'signal' ], - filter: function(data) { - return (data == 0); - } + _fetch_swstate: L.rpc.declare({ + object: 'luci2.network', + method: 'switch_info', + params: [ 'switch' ], + expect: { 'info': { } } }), - initList: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'init_list', - expect: { initscripts: [ ] }, - filter: function(data) { - data.sort(function(a, b) { return (a.start || 0) - (b.start || 0) }); - return data; + _fetch_swstate_cb: function(responses) { + var self = L.NetworkModel; + var swlist = self._cache.swlist; + var swstate = self._cache.swstate = { }; + + for (var i = 0; i < responses.length; i++) + swstate[swlist[i]] = responses[i]; + }, + + _fetch_cache_cb: function(level) + { + var self = L.NetworkModel; + var name = '_fetch_cache_cb_' + level; + + return self[name] || ( + self[name] = function(responses) + { + for (var i = 0; i < self._cache_functions.length; i += 3) + if (!level || self._cache_functions[i + 1] == level) + self._cache[self._cache_functions[i]] = responses.shift(); + + if (!level) + { + L.rpc.batch(); + + for (var i = 0; i < self._cache.swlist.length; i++) + self._fetch_swstate(self._cache.swlist[i]); + + return L.rpc.flush().then(self._fetch_swstate_cb); + } + + return L.deferrable(); + } + ); + }, + + _fetch_cache: function(level) + { + var self = L.NetworkModel; + + return L.uci.load(['network', 'wireless']).then(function() { + L.rpc.batch(); + + for (var i = 0; i < self._cache_functions.length; i += 3) + if (!level || self._cache_functions[i + 1] == level) + self._cache_functions[i + 2](); + + return L.rpc.flush().then(self._fetch_cache_cb(level || 0)); + }); + }, + + _get: function(pkg, sid, key) + { + return L.uci.get(pkg, sid, key); + }, + + _set: function(pkg, sid, key, val) + { + return L.uci.set(pkg, sid, key, val); + }, + + _is_blacklisted: function(dev) + { + for (var i = 0; i < this._device_blacklist.length; i++) + if (dev.match(this._device_blacklist[i])) + return true; + + return false; + }, + + _sort_devices: function(a, b) + { + if (a.options.kind < b.options.kind) + return -1; + else if (a.options.kind > b.options.kind) + return 1; + + if (a.options.name < b.options.name) + return -1; + else if (a.options.name > b.options.name) + return 1; + + return 0; + }, + + _get_dev: function(ifname) + { + var alias = (ifname.charAt(0) == '@'); + return this._devs[ifname] || ( + this._devs[ifname] = { + ifname: ifname, + kind: alias ? 'alias' : 'ethernet', + type: alias ? 0 : 1, + up: false, + changed: { } + } + ); + }, + + _get_iface: function(name) + { + return this._ifaces[name] || ( + this._ifaces[name] = { + name: name, + proto: this._protos.none, + changed: { } + } + ); + }, + + _parse_devices: function() + { + var self = L.NetworkModel; + var wificount = { }; + + for (var ifname in self._cache.devstate) + { + if (self._is_blacklisted(ifname)) + continue; + + var dev = self._cache.devstate[ifname]; + var entry = self._get_dev(ifname); + + entry.up = dev.up; + + switch (dev.type) + { + case 'IP tunnel': + entry.kind = 'tunnel'; + break; + + case 'Bridge': + entry.kind = 'bridge'; + //entry.ports = dev['bridge-members'].sort(); + break; + } } - }), - initEnabled: function(init, cb) + for (var i = 0; i < self._cache.devlist.length; i++) + { + var dev = self._cache.devlist[i]; + + if (self._is_blacklisted(dev.device)) + continue; + + var entry = self._get_dev(dev.device); + + entry.up = dev.is_up; + entry.type = dev.type; + + switch (dev.type) + { + case 1: /* Ethernet */ + if (dev.is_bridge) + entry.kind = 'bridge'; + else if (dev.is_tuntap) + entry.kind = 'tunnel'; + else if (dev.is_wireless) + entry.kind = 'wifi'; + break; + + case 512: /* PPP */ + case 768: /* IP-IP Tunnel */ + case 769: /* IP6-IP6 Tunnel */ + case 776: /* IPv6-in-IPv4 */ + case 778: /* GRE over IP */ + entry.kind = 'tunnel'; + break; + } + } + + var net = L.uci.sections('network'); + for (var i = 0; i < net.length; i++) + { + var s = net[i]; + var sid = s['.name']; + + if (s['.type'] == 'device' && s.name) + { + var entry = self._get_dev(s.name); + + switch (s.type) + { + case 'macvlan': + case 'tunnel': + entry.kind = 'tunnel'; + break; + } + + entry.sid = sid; + } + else if (s['.type'] == 'interface' && !s['.anonymous'] && s.ifname) + { + var ifnames = L.toArray(s.ifname); + + for (var j = 0; j < ifnames.length; j++) + self._get_dev(ifnames[j]); + + if (s['.name'] != 'loopback') + { + var entry = self._get_dev('@%s'.format(s['.name'])); + + entry.type = 0; + entry.kind = 'alias'; + entry.sid = sid; + } + } + else if (s['.type'] == 'switch_vlan' && s.device) + { + var sw = self._cache.swstate[s.device]; + var vid = parseInt(s.vid || s.vlan); + var ports = L.toArray(s.ports); + + if (!sw || !ports.length || isNaN(vid)) + continue; + + var ifname = undefined; + + for (var j = 0; j < ports.length; j++) + { + var port = parseInt(ports[j]); + var tag = (ports[j].replace(/[^tu]/g, '') == 't'); + + if (port == sw.cpu_port) + { + // XXX: need a way to map switch to netdev + if (tag) + ifname = 'eth0.%d'.format(vid); + else + ifname = 'eth0'; + + break; + } + } + + if (!ifname) + continue; + + var entry = self._get_dev(ifname); + + entry.kind = 'vlan'; + entry.sid = sid; + entry.vsw = sw; + entry.vid = vid; + } + } + + var wifi = L.uci.sections('wireless'); + for (var i = 0; i < wifi.length; i++) + { + var s = wifi[i]; + var sid = s['.name']; + + if (s['.type'] == 'wifi-iface' && s.device) + { + var r = parseInt(s.device.replace(/^[^0-9]+/, '')); + var n = wificount[s.device] = (wificount[s.device] || 0) + 1; + var id = 'radio%d.network%d'.format(r, n); + var ifname = id; + + if (self._cache.wifistate[s.device]) + { + var ifcs = self._cache.wifistate[s.device].interfaces; + for (var ifc in ifcs) + { + if (ifcs[ifc].section == sid) + { + ifname = ifcs[ifc].ifname; + break; + } + } + } + + var entry = self._get_dev(ifname); + + entry.kind = 'wifi'; + entry.sid = sid; + entry.wid = id; + entry.wdev = s.device; + entry.wmode = s.mode; + entry.wssid = s.ssid; + entry.wbssid = s.bssid; + } + } + + for (var i = 0; i < net.length; i++) + { + var s = net[i]; + var sid = s['.name']; + + if (s['.type'] == 'interface' && !s['.anonymous'] && s.type == 'bridge') + { + var ifnames = L.toArray(s.ifname); + + for (var ifname in self._devs) + { + var dev = self._devs[ifname]; + + if (dev.kind != 'wifi') + continue; + + var wnets = L.toArray(L.uci.get('wireless', dev.sid, 'network')); + if ($.inArray(sid, wnets) > -1) + ifnames.push(ifname); + } + + entry = self._get_dev('br-%s'.format(s['.name'])); + entry.type = 1; + entry.kind = 'bridge'; + entry.sid = sid; + entry.ports = ifnames.sort(); + } + } + }, + + _parse_interfaces: function() { - return this.initList().then(function(list) { - for (var i = 0; i < list.length; i++) - if (list[i].name == init) - return !!list[i].enabled; + var self = L.NetworkModel; + var net = L.uci.sections('network'); - return false; + for (var i = 0; i < net.length; i++) + { + var s = net[i]; + var sid = s['.name']; + + if (s['.type'] == 'interface' && !s['.anonymous'] && s.proto) + { + var entry = self._get_iface(s['.name']); + var proto = self._protos[s.proto] || self._protos.none; + + var l3dev = undefined; + var l2dev = undefined; + + var ifnames = L.toArray(s.ifname); + + for (var ifname in self._devs) + { + var dev = self._devs[ifname]; + + if (dev.kind != 'wifi') + continue; + + var wnets = L.toArray(L.uci.get('wireless', dev.sid, 'network')); + if ($.inArray(entry.name, wnets) > -1) + ifnames.push(ifname); + } + + if (proto.virtual) + l3dev = '%s-%s'.format(s.proto, entry.name); + else if (s.type == 'bridge') + l3dev = 'br-%s'.format(entry.name); + else + l3dev = ifnames[0]; + + if (!proto.virtual && s.type == 'bridge') + l2dev = 'br-%s'.format(entry.name); + else if (!proto.virtual) + l2dev = ifnames[0]; + + entry.proto = proto; + entry.sid = sid; + entry.l3dev = l3dev; + entry.l2dev = l2dev; + } + } + + for (var i = 0; i < self._cache.ifstate.length; i++) + { + var iface = self._cache.ifstate[i]; + var entry = self._get_iface(iface['interface']); + var proto = self._protos[iface.proto] || self._protos.none; + + /* this is a virtual interface, either deleted from config but + not applied yet or set up from external tools (6rd) */ + if (!entry.sid) + { + entry.proto = proto; + entry.l2dev = iface.device; + entry.l3dev = iface.l3_device; + } + } + }, + + init: function() + { + var self = this; + + if (self._cache) + return L.deferrable(); + + self._cache = { }; + self._devs = { }; + self._ifaces = { }; + self._protos = { }; + + return self._fetch_cache() + .then(self._fetch_protocols) + .then(self._parse_devices) + .then(self._parse_interfaces); + }, + + update: function() + { + delete this._cache; + return this.init(); + }, + + refreshInterfaceStatus: function() + { + return this._fetch_cache(1).then(this._parse_interfaces); + }, + + refreshDeviceStatus: function() + { + return this._fetch_cache(2).then(this._parse_devices); + }, + + refreshStatus: function() + { + return this._fetch_cache(1) + .then(this._fetch_cache(2)) + .then(this._parse_devices) + .then(this._parse_interfaces); + }, + + getDevices: function() + { + var devs = [ ]; + + for (var ifname in this._devs) + if (ifname != 'lo') + devs.push(new L.NetworkModel.Device(this._devs[ifname])); + + return devs.sort(this._sort_devices); + }, + + getDeviceByInterface: function(iface) + { + if (iface instanceof L.NetworkModel.Interface) + iface = iface.name(); + + if (this._ifaces[iface]) + return this.getDevice(this._ifaces[iface].l3dev) || + this.getDevice(this._ifaces[iface].l2dev); + + return undefined; + }, + + getDevice: function(ifname) + { + if (this._devs[ifname]) + return new L.NetworkModel.Device(this._devs[ifname]); + + return undefined; + }, + + createDevice: function(name) + { + return new L.NetworkModel.Device(this._get_dev(name)); + }, + + getInterfaces: function() + { + var ifaces = [ ]; + + for (var name in this._ifaces) + if (name != 'loopback') + ifaces.push(this.getInterface(name)); + + ifaces.sort(function(a, b) { + if (a.name() < b.name()) + return -1; + else if (a.name() > b.name()) + return 1; + else + return 0; }); + + return ifaces; }, - initRun: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'init_action', - params: [ 'name', 'action' ], - filter: function(data) { - return (data == 0); + getInterfacesByDevice: function(dev) + { + var ifaces = [ ]; + + if (dev instanceof L.NetworkModel.Device) + dev = dev.name(); + + for (var name in this._ifaces) + { + var iface = this._ifaces[name]; + if (iface.l2dev == dev || iface.l3dev == dev) + ifaces.push(this.getInterface(name)); } - }), - initStart: function(init, cb) { return _luci2.system.initRun(init, 'start', cb) }, - initStop: function(init, cb) { return _luci2.system.initRun(init, 'stop', cb) }, - initRestart: function(init, cb) { return _luci2.system.initRun(init, 'restart', cb) }, - initReload: function(init, cb) { return _luci2.system.initRun(init, 'reload', cb) }, - initEnable: function(init, cb) { return _luci2.system.initRun(init, 'enable', cb) }, - initDisable: function(init, cb) { return _luci2.system.initRun(init, 'disable', cb) }, + ifaces.sort(function(a, b) { + if (a.name() < b.name()) + return -1; + else if (a.name() > b.name()) + return 1; + else + return 0; + }); + return ifaces; + }, - getRcLocal: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'rclocal_get', - expect: { data: '' } - }), + getInterface: function(iface) + { + if (this._ifaces[iface]) + return new L.NetworkModel.Interface(this._ifaces[iface]); - setRcLocal: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'rclocal_set', - params: [ 'data' ] - }), + return undefined; + }, + + getProtocols: function() + { + var rv = [ ]; + + for (var proto in this._protos) + { + var pr = this._protos[proto]; + + rv.push({ + name: proto, + description: pr.description, + virtual: pr.virtual, + tunnel: pr.tunnel + }); + } + + return rv.sort(function(a, b) { + if (a.name < b.name) + return -1; + else if (a.name > b.name) + return 1; + else + return 0; + }); + }, + + _find_wan: function(ipaddr) + { + for (var i = 0; i < this._cache.ifstate.length; i++) + { + var ifstate = this._cache.ifstate[i]; + + if (!ifstate.route) + continue; + + for (var j = 0; j < ifstate.route.length; j++) + if (ifstate.route[j].mask == 0 && + ifstate.route[j].target == ipaddr && + typeof(ifstate.route[j].table) == 'undefined') + { + return this.getInterface(ifstate['interface']); + } + } + + return undefined; + }, + + findWAN: function() + { + return this._find_wan('0.0.0.0'); + }, + + findWAN6: function() + { + return this._find_wan('::'); + }, + + resolveAlias: function(ifname) + { + if (ifname instanceof L.NetworkModel.Device) + ifname = ifname.name(); + + var dev = this._devs[ifname]; + var seen = { }; + + while (dev && dev.kind == 'alias') + { + // loop + if (seen[dev.ifname]) + return undefined; + + var ifc = this._ifaces[dev.sid]; + + seen[dev.ifname] = true; + dev = ifc ? this._devs[ifc.l3dev] : undefined; + } + + return dev ? this.getDevice(dev.ifname) : undefined; + } + }; + + this.NetworkModel.Device = Class.extend({ + _wifi_modes: { + ap: L.tr('Master'), + sta: L.tr('Client'), + adhoc: L.tr('Ad-Hoc'), + monitor: L.tr('Monitor'), + wds: L.tr('Static WDS') + }, + + _status: function(key) + { + var s = L.NetworkModel._cache.devstate[this.options.ifname]; + + if (s) + return key ? s[key] : s; + + return undefined; + }, + + get: function(key) + { + var sid = this.options.sid; + var pkg = (this.options.kind == 'wifi') ? 'wireless' : 'network'; + return L.NetworkModel._get(pkg, sid, key); + }, + + set: function(key, val) + { + var sid = this.options.sid; + var pkg = (this.options.kind == 'wifi') ? 'wireless' : 'network'; + return L.NetworkModel._set(pkg, sid, key, val); + }, + + init: function() + { + if (typeof(this.options.type) == 'undefined') + this.options.type = 1; + + if (typeof(this.options.kind) == 'undefined') + this.options.kind = 'ethernet'; + + if (typeof(this.options.networks) == 'undefined') + this.options.networks = [ ]; + }, + + name: function() + { + return this.options.ifname; + }, + + description: function() + { + switch (this.options.kind) + { + case 'alias': + return L.tr('Alias for network "%s"').format(this.options.ifname.substring(1)); + + case 'bridge': + return L.tr('Network bridge'); + + case 'ethernet': + return L.tr('Network device'); + + case 'tunnel': + switch (this.options.type) + { + case 1: /* tuntap */ + return L.tr('TAP device'); + + case 512: /* PPP */ + return L.tr('PPP tunnel'); + + case 768: /* IP-IP Tunnel */ + return L.tr('IP-in-IP tunnel'); + + case 769: /* IP6-IP6 Tunnel */ + return L.tr('IPv6-in-IPv6 tunnel'); + + case 776: /* IPv6-in-IPv4 */ + return L.tr('IPv6-over-IPv4 tunnel'); + break; + + case 778: /* GRE over IP */ + return L.tr('GRE-over-IP tunnel'); + + default: + return L.tr('Tunnel device'); + } + + case 'vlan': + return L.tr('VLAN %d on %s').format(this.options.vid, this.options.vsw.model); + + case 'wifi': + var o = this.options; + return L.trc('(Wifi-Mode) "(SSID)" on (radioX)', '%s "%h" on %s').format( + o.wmode ? this._wifi_modes[o.wmode] : L.tr('Unknown mode'), + o.wssid || '?', o.wdev + ); + } + + return L.tr('Unknown device'); + }, + + icon: function(up) + { + var kind = this.options.kind; + + if (kind == 'alias') + kind = 'ethernet'; + + if (typeof(up) == 'undefined') + up = this.isUp(); + + return L.globals.resource + '/icons/%s%s.png'.format(kind, up ? '' : '_disabled'); + }, + + isUp: function() + { + var l = L.NetworkModel._cache.devlist; + + for (var i = 0; i < l.length; i++) + if (l[i].device == this.options.ifname) + return (l[i].is_up === true); + + return false; + }, + + isAlias: function() + { + return (this.options.kind == 'alias'); + }, + + isBridge: function() + { + return (this.options.kind == 'bridge'); + }, + + isBridgeable: function() + { + return (this.options.type == 1 && this.options.kind != 'bridge'); + }, + + isWireless: function() + { + return (this.options.kind == 'wifi'); + }, + + isInNetwork: function(net) + { + if (!(net instanceof L.NetworkModel.Interface)) + net = L.NetworkModel.getInterface(net); + + if (net) + { + if (net.options.l3dev == this.options.ifname || + net.options.l2dev == this.options.ifname) + return true; + + var dev = L.NetworkModel._devs[net.options.l2dev]; + if (dev && dev.kind == 'bridge' && dev.ports) + return ($.inArray(this.options.ifname, dev.ports) > -1); + } + + return false; + }, + + getMTU: function() + { + var dev = L.NetworkModel._cache.devstate[this.options.ifname]; + if (dev && !isNaN(dev.mtu)) + return dev.mtu; + + return undefined; + }, + + getMACAddress: function() + { + if (this.options.type != 1) + return undefined; + + var dev = L.NetworkModel._cache.devstate[this.options.ifname]; + if (dev && dev.macaddr) + return dev.macaddr.toUpperCase(); + + return undefined; + }, + + getInterfaces: function() + { + return L.NetworkModel.getInterfacesByDevice(this.options.name); + }, + + getStatistics: function() + { + var s = this._status('statistics') || { }; + return { + rx_bytes: (s.rx_bytes || 0), + tx_bytes: (s.tx_bytes || 0), + rx_packets: (s.rx_packets || 0), + tx_packets: (s.tx_packets || 0) + }; + }, + + getTrafficHistory: function() + { + var def = new Array(120); + + for (var i = 0; i < 120; i++) + def[i] = 0; + + var h = L.NetworkModel._cache.bwstate[this.options.ifname] || { }; + return { + rx_bytes: (h.rx_bytes || def), + tx_bytes: (h.tx_bytes || def), + rx_packets: (h.rx_packets || def), + tx_packets: (h.tx_packets || def) + }; + }, + + removeFromInterface: function(iface) + { + if (!(iface instanceof L.NetworkModel.Interface)) + iface = L.NetworkModel.getInterface(iface); + + if (!iface) + return; + + var ifnames = L.toArray(iface.get('ifname')); + if ($.inArray(this.options.ifname, ifnames) > -1) + iface.set('ifname', L.filterArray(ifnames, this.options.ifname)); + + if (this.options.kind != 'wifi') + return; + + var networks = L.toArray(this.get('network')); + if ($.inArray(iface.name(), networks) > -1) + this.set('network', L.filterArray(networks, iface.name())); + }, + + attachToInterface: function(iface) + { + if (!(iface instanceof L.NetworkModel.Interface)) + iface = L.NetworkModel.getInterface(iface); + + if (!iface) + return; + + if (this.options.kind != 'wifi') + { + var ifnames = L.toArray(iface.get('ifname')); + if ($.inArray(this.options.ifname, ifnames) < 0) + { + ifnames.push(this.options.ifname); + iface.set('ifname', (ifnames.length > 1) ? ifnames : ifnames[0]); + } + } + else + { + var networks = L.toArray(this.get('network')); + if ($.inArray(iface.name(), networks) < 0) + { + networks.push(iface.name()); + this.set('network', (networks.length > 1) ? networks : networks[0]); + } + } + } + }); + + this.NetworkModel.Interface = Class.extend({ + _status: function(key) + { + var s = L.NetworkModel._cache.ifstate; + + for (var i = 0; i < s.length; i++) + if (s[i]['interface'] == this.options.name) + return key ? s[i][key] : s[i]; + + return undefined; + }, + + get: function(key) + { + return L.NetworkModel._get('network', this.options.name, key); + }, + + set: function(key, val) + { + return L.NetworkModel._set('network', this.options.name, key, val); + }, + + name: function() + { + return this.options.name; + }, + + protocol: function() + { + return (this.get('proto') || 'none'); + }, + + isUp: function() + { + return (this._status('up') === true); + }, + + isVirtual: function() + { + return (typeof(this.options.sid) != 'string'); + }, + + getProtocol: function() + { + var prname = this.get('proto') || 'none'; + return L.NetworkModel._protos[prname] || L.NetworkModel._protos.none; + }, + + getUptime: function() + { + var uptime = this._status('uptime'); + return isNaN(uptime) ? 0 : uptime; + }, + + getDevice: function(resolveAlias) + { + if (this.options.l3dev) + return L.NetworkModel.getDevice(this.options.l3dev); + + return undefined; + }, + + getPhysdev: function() + { + if (this.options.l2dev) + return L.NetworkModel.getDevice(this.options.l2dev); + + return undefined; + }, + + getSubdevices: function() + { + var rv = [ ]; + var dev = this.options.l2dev ? + L.NetworkModel._devs[this.options.l2dev] : undefined; + + if (dev && dev.kind == 'bridge' && dev.ports && dev.ports.length) + for (var i = 0; i < dev.ports.length; i++) + rv.push(L.NetworkModel.getDevice(dev.ports[i])); + + return rv; + }, + + getIPv4Addrs: function(mask) + { + var rv = [ ]; + var addrs = this._status('ipv4-address'); + + if (addrs) + for (var i = 0; i < addrs.length; i++) + if (!mask) + rv.push(addrs[i].address); + else + rv.push('%s/%d'.format(addrs[i].address, addrs[i].mask)); + + return rv; + }, + + getIPv6Addrs: function(mask) + { + var rv = [ ]; + var addrs; + + addrs = this._status('ipv6-address'); + + if (addrs) + for (var i = 0; i < addrs.length; i++) + if (!mask) + rv.push(addrs[i].address); + else + rv.push('%s/%d'.format(addrs[i].address, addrs[i].mask)); + + addrs = this._status('ipv6-prefix-assignment'); + + if (addrs) + for (var i = 0; i < addrs.length; i++) + if (!mask) + rv.push('%s1'.format(addrs[i].address)); + else + rv.push('%s1/%d'.format(addrs[i].address, addrs[i].mask)); + + return rv; + }, + + getDNSAddrs: function() + { + var rv = [ ]; + var addrs = this._status('dns-server'); + + if (addrs) + for (var i = 0; i < addrs.length; i++) + rv.push(addrs[i]); + + return rv; + }, + + getIPv4DNS: function() + { + var rv = [ ]; + var dns = this._status('dns-server'); + + if (dns) + for (var i = 0; i < dns.length; i++) + if (dns[i].indexOf(':') == -1) + rv.push(dns[i]); + + return rv; + }, + + getIPv6DNS: function() + { + var rv = [ ]; + var dns = this._status('dns-server'); + + if (dns) + for (var i = 0; i < dns.length; i++) + if (dns[i].indexOf(':') > -1) + rv.push(dns[i]); + + return rv; + }, + + getIPv4Gateway: function() + { + var rt = this._status('route'); + + if (rt) + for (var i = 0; i < rt.length; i++) + if (rt[i].target == '0.0.0.0' && rt[i].mask == 0) + return rt[i].nexthop; + + return undefined; + }, + + getIPv6Gateway: function() + { + var rt = this._status('route'); + + if (rt) + for (var i = 0; i < rt.length; i++) + if (rt[i].target == '::' && rt[i].mask == 0) + return rt[i].nexthop; + + return undefined; + }, + + getStatistics: function() + { + var dev = this.getDevice() || new L.NetworkModel.Device({}); + return dev.getStatistics(); + }, + + getTrafficHistory: function() + { + var dev = this.getDevice() || new L.NetworkModel.Device({}); + return dev.getTrafficHistory(); + }, + + setDevices: function(devs) + { + var dev = this.getPhysdev(); + var old_devs = [ ]; + var changed = false; + + if (dev && dev.isBridge()) + old_devs = this.getSubdevices(); + else if (dev) + old_devs = [ dev ]; + + if (old_devs.length != devs.length) + changed = true; + else + for (var i = 0; i < old_devs.length; i++) + { + var dev = devs[i]; + + if (dev instanceof L.NetworkModel.Device) + dev = dev.name(); + + if (!dev || old_devs[i].name() != dev) + { + changed = true; + break; + } + } + + if (changed) + { + for (var i = 0; i < old_devs.length; i++) + old_devs[i].removeFromInterface(this); + + for (var i = 0; i < devs.length; i++) + { + var dev = devs[i]; + + if (!(dev instanceof L.NetworkModel.Device)) + dev = L.NetworkModel.getDevice(dev); + + if (dev) + dev.attachToInterface(this); + } + } + }, + + changeProtocol: function(proto) + { + var pr = L.NetworkModel._protos[proto]; + + if (!pr) + return; + + for (var opt in (this.get() || { })) + { + switch (opt) + { + case 'type': + case 'ifname': + case 'macaddr': + if (pr.virtual) + this.set(opt, undefined); + break; + + case 'auto': + case 'mtu': + break; + + case 'proto': + this.set(opt, pr.protocol); + break; + + default: + this.set(opt, undefined); + break; + } + } + }, + + createForm: function(mapwidget) + { + var self = this; + var proto = self.getProtocol(); + var device = self.getDevice(); + + if (!mapwidget) + mapwidget = L.cbi.Map; + + var map = new mapwidget('network', { + caption: L.tr('Configure "%s"').format(self.name()) + }); + + var section = map.section(L.cbi.SingleSection, self.name(), { + anonymous: true + }); + section.tab({ + id: 'general', + caption: L.tr('General Settings') + }); - getCrontab: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'crontab_get', - expect: { data: '' } - }), + section.tab({ + id: 'advanced', + caption: L.tr('Advanced Settings') + }); - setCrontab: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'crontab_set', - params: [ 'data' ] - }), + section.tab({ + id: 'ipv6', + caption: L.tr('IPv6') + }); + section.tab({ + id: 'physical', + caption: L.tr('Physical Settings') + }); - getSSHKeys: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'sshkeys_get', - expect: { keys: [ ] } - }), - setSSHKeys: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'sshkeys_set', - params: [ 'keys' ] - }), + section.taboption('general', L.cbi.CheckboxValue, 'auto', { + caption: L.tr('Start on boot'), + optional: true, + initial: true + }); + var pr = section.taboption('general', L.cbi.ListValue, 'proto', { + caption: L.tr('Protocol') + }); - setPassword: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'password_set', - params: [ 'user', 'password' ] - }), + pr.ucivalue = function(sid) { + return self.get('proto') || 'none'; + }; + var ok = section.taboption('general', L.cbi.ButtonValue, '_confirm', { + caption: L.tr('Really switch?'), + description: L.tr('Changing the protocol will clear all configuration for this interface!'), + text: L.tr('Change protocol') + }); - listLEDs: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'led_list', - expect: { leds: [ ] } - }), + ok.on('click', function(ev) { + self.changeProtocol(pr.formvalue(ev.data.sid)); + self.createForm(mapwidget).show(); + }); - listUSBDevices: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'usb_list', - expect: { devices: [ ] } - }), + var protos = L.NetworkModel.getProtocols(); + for (var i = 0; i < protos.length; i++) + pr.value(protos[i].name, protos[i].description); - testUpgrade: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'upgrade_test', - expect: { '': { } } - }), + proto.populateForm(section, self); - startUpgrade: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'upgrade_start', - params: [ 'keep' ] - }), + if (!proto.virtual) + { + var br = section.taboption('physical', L.cbi.CheckboxValue, 'type', { + caption: L.tr('Network bridge'), + description: L.tr('Merges multiple devices into one logical bridge'), + optional: true, + enabled: 'bridge', + disabled: '', + initial: '' + }); - cleanUpgrade: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'upgrade_clean' - }), + section.taboption('physical', L.cbi.DeviceList, '__iface_multi', { + caption: L.tr('Devices'), + multiple: true, + bridges: false + }).depends('type', true); + + section.taboption('physical', L.cbi.DeviceList, '__iface_single', { + caption: L.tr('Device'), + multiple: false, + bridges: true + }).depends('type', false); + + var mac = section.taboption('physical', L.cbi.InputValue, 'macaddr', { + caption: L.tr('Override MAC'), + optional: true, + placeholder: device ? device.getMACAddress() : undefined, + datatype: 'macaddr' + }) + mac.ucivalue = function(sid) + { + if (device) + return device.get('macaddr'); - restoreBackup: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'backup_restore' - }), + return this.callSuper('ucivalue', sid); + }; - cleanBackup: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'backup_clean' - }), + mac.save = function(sid) + { + if (!this.changed(sid)) + return false; + if (device) + device.set('macaddr', this.formvalue(sid)); + else + this.callSuper('set', sid); - getBackupConfig: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'backup_config_get', - expect: { config: '' } - }), + return true; + }; + } - setBackupConfig: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'backup_config_set', - params: [ 'data' ] - }), + section.taboption('physical', L.cbi.InputValue, 'mtu', { + caption: L.tr('Override MTU'), + optional: true, + placeholder: device ? device.getMTU() : undefined, + datatype: 'range(1, 9000)' + }); + section.taboption('physical', L.cbi.InputValue, 'metric', { + caption: L.tr('Override Metric'), + optional: true, + placeholder: 0, + datatype: 'uinteger' + }); - listBackup: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'backup_list', - expect: { files: [ ] } - }), + for (var field in section.fields) + { + switch (field) + { + case 'proto': + break; + case '_confirm': + for (var i = 0; i < protos.length; i++) + if (protos[i].name != (this.get('proto') || 'none')) + section.fields[field].depends('proto', protos[i].name); + break; - testReset: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'reset_test', - expect: { supported: false } - }), + default: + section.fields[field].depends('proto', this.get('proto') || 'none', true); + break; + } + } - startReset: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'reset_start' - }), + return map; + } + }); + this.NetworkModel.Protocol = this.NetworkModel.Interface.extend({ + description: '__unknown__', + tunnel: false, + virtual: false, - performReboot: _luci2.rpc.declare({ - object: 'luci2.system', - method: 'reboot' - }) - }; + populateForm: function(section, iface) + { - this.opkg = { - updateLists: _luci2.rpc.declare({ - object: 'luci2.opkg', - method: 'update', - expect: { '': { } } - }), + } + }); - _allPackages: _luci2.rpc.declare({ - object: 'luci2.opkg', - method: 'list', - params: [ 'offset', 'limit', 'pattern' ], + this.system = { + getSystemInfo: L.rpc.declare({ + object: 'system', + method: 'info', expect: { '': { } } }), - _installedPackages: _luci2.rpc.declare({ - object: 'luci2.opkg', - method: 'list_installed', - params: [ 'offset', 'limit', 'pattern' ], + getBoardInfo: L.rpc.declare({ + object: 'system', + method: 'board', expect: { '': { } } }), - _findPackages: _luci2.rpc.declare({ - object: 'luci2.opkg', - method: 'find', - params: [ 'offset', 'limit', 'pattern' ], + getDiskInfo: L.rpc.declare({ + object: 'luci2.system', + method: 'diskfree', expect: { '': { } } }), - _fetchPackages: function(action, offset, limit, pattern) + getInfo: function(cb) { - var packages = [ ]; - - return action(offset, limit, pattern).then(function(list) { - if (!list.total || !list.packages) - return { length: 0, total: 0 }; - - packages.push.apply(packages, list.packages); - packages.total = list.total; - - if (limit <= 0) - limit = list.total; - - if (packages.length >= limit) - return packages; - - _luci2.rpc.batch(); + L.rpc.batch(); - for (var i = offset + packages.length; i < limit; i += 100) - action(i, (Math.min(i + 100, limit) % 100) || 100, pattern); + this.getSystemInfo(); + this.getBoardInfo(); + this.getDiskInfo(); - return _luci2.rpc.flush(); - }).then(function(lists) { - for (var i = 0; i < lists.length; i++) - { - if (!lists[i].total || !lists[i].packages) - continue; + return L.rpc.flush().then(function(info) { + var rv = { }; - packages.push.apply(packages, lists[i].packages); - packages.total = lists[i].total; - } + $.extend(rv, info[0]); + $.extend(rv, info[1]); + $.extend(rv, info[2]); - return packages; + return rv; }); }, - listPackages: function(offset, limit, pattern) - { - return _luci2.opkg._fetchPackages(_luci2.opkg._allPackages, offset, limit, pattern); - }, - installedPackages: function(offset, limit, pattern) - { - return _luci2.opkg._fetchPackages(_luci2.opkg._installedPackages, offset, limit, pattern); - }, + initList: L.rpc.declare({ + object: 'luci2.system', + method: 'init_list', + expect: { initscripts: [ ] }, + filter: function(data) { + data.sort(function(a, b) { return (a.start || 0) - (b.start || 0) }); + return data; + } + }), - findPackages: function(offset, limit, pattern) + initEnabled: function(init, cb) { - return _luci2.opkg._fetchPackages(_luci2.opkg._findPackages, offset, limit, pattern); + return this.initList().then(function(list) { + for (var i = 0; i < list.length; i++) + if (list[i].name == init) + return !!list[i].enabled; + + return false; + }); }, - installPackage: _luci2.rpc.declare({ - object: 'luci2.opkg', - method: 'install', - params: [ 'package' ], - expect: { '': { } } + initRun: L.rpc.declare({ + object: 'luci2.system', + method: 'init_action', + params: [ 'name', 'action' ], + filter: function(data) { + return (data == 0); + } }), - removePackage: _luci2.rpc.declare({ - object: 'luci2.opkg', - method: 'remove', - params: [ 'package' ], - expect: { '': { } } - }), + initStart: function(init, cb) { return L.system.initRun(init, 'start', cb) }, + initStop: function(init, cb) { return L.system.initRun(init, 'stop', cb) }, + initRestart: function(init, cb) { return L.system.initRun(init, 'restart', cb) }, + initReload: function(init, cb) { return L.system.initRun(init, 'reload', cb) }, + initEnable: function(init, cb) { return L.system.initRun(init, 'enable', cb) }, + initDisable: function(init, cb) { return L.system.initRun(init, 'disable', cb) }, - getConfig: _luci2.rpc.declare({ - object: 'luci2.opkg', - method: 'config_get', - expect: { config: '' } - }), - setConfig: _luci2.rpc.declare({ - object: 'luci2.opkg', - method: 'config_set', - params: [ 'data' ] + performReboot: L.rpc.declare({ + object: 'luci2.system', + method: 'reboot' }) }; this.session = { - login: _luci2.rpc.declare({ + login: L.rpc.declare({ object: 'session', method: 'login', params: [ 'username', 'password' ], expect: { '': { } } }), - access: _luci2.rpc.declare({ + access: L.rpc.declare({ object: 'session', method: 'access', params: [ 'scope', 'object', 'function' ], @@ -1466,21 +3087,21 @@ function LuCI2() isAlive: function() { - return _luci2.session.access('ubus', 'session', 'access'); + return L.session.access('ubus', 'session', 'access'); }, startHeartbeat: function() { this._hearbeatInterval = window.setInterval(function() { - _luci2.session.isAlive().then(function(alive) { + L.session.isAlive().then(function(alive) { if (!alive) { - _luci2.session.stopHeartbeat(); - _luci2.ui.login(true); + L.session.stopHeartbeat(); + L.ui.login(true); } }); - }, _luci2.globals.timeout * 2); + }, L.globals.timeout * 2); }, stopHeartbeat: function() @@ -1490,6 +3111,41 @@ function LuCI2() window.clearInterval(this._hearbeatInterval); delete this._hearbeatInterval; } + }, + + + _acls: { }, + + _fetch_acls: L.rpc.declare({ + object: 'session', + method: 'access', + expect: { '': { } } + }), + + _fetch_acls_cb: function(acls) + { + L.session._acls = acls; + }, + + updateACLs: function() + { + return L.session._fetch_acls() + .then(L.session._fetch_acls_cb); + }, + + hasACL: function(scope, object, func) + { + var acls = L.session._acls; + + if (typeof(func) == 'undefined') + return (acls && acls[scope] && acls[scope][object]); + + if (acls && acls[scope] && acls[scope][object]) + for (var i = 0; i < acls[scope][object].length; i++) + if (acls[scope][object][i] == func) + return true; + + return false; } }; @@ -1515,31 +3171,25 @@ function LuCI2() var win = $(window); var body = $('body'); - var state = _luci2.ui._loading || (_luci2.ui._loading = { + var state = L.ui._loading || (L.ui._loading = { modal: $('
') - .addClass('cbi-modal-loader') - .append($('
').text(_luci2.tr('Loading data...'))) + .css('z-index', 2000) + .addClass('modal fade') + .append($('
') + .addClass('modal-dialog') + .append($('
') + .addClass('modal-content luci2-modal-loader') + .append($('
') + .addClass('modal-body') + .text(L.tr('Loading data…'))))) .appendTo(body) + .modal({ + backdrop: 'static', + keyboard: false + }) }); - if (enable) - { - body.css('overflow', 'hidden'); - body.css('padding', 0); - body.css('width', win.width()); - body.css('height', win.height()); - state.modal.css('width', win.width()); - state.modal.css('height', win.height()); - state.modal.show(); - } - else - { - state.modal.hide(); - body.css('overflow', ''); - body.css('padding', ''); - body.css('width', ''); - body.css('height', ''); - } + state.modal.modal(enable ? 'show' : 'hide'); }, dialog: function(title, content, options) @@ -1547,28 +3197,25 @@ function LuCI2() var win = $(window); var body = $('body'); - var state = _luci2.ui._dialog || (_luci2.ui._dialog = { + var state = L.ui._dialog || (L.ui._dialog = { dialog: $('
') - .addClass('cbi-modal-dialog') + .addClass('modal fade') .append($('
') + .addClass('modal-dialog') .append($('
') - .addClass('cbi-modal-dialog-header')) - .append($('
') - .addClass('cbi-modal-dialog-body')) - .append($('
') - .addClass('cbi-modal-dialog-footer') - .append($('