🌴 Sync 2026-03-05 23:51:42

luci-app-mptcp/htdocs/luci-static/resources/seedrandom.js

@@ -0,0 +1,402 @@
+/**
+
+seedrandom.js
+=============
+
+Seeded random number generator for Javascript.
+
+version 2.3.10
+Author: David Bau
+Date: 2014 Sep 20
+
+Can be used as a plain script, a node.js module or an AMD module.
+
+Script tag usage
+----------------
+
+<script src=//cdnjs.cloudflare.com/ajax/libs/seedrandom/2.3.10/seedrandom.min.js>
+</script>
+
+// Sets Math.random to a PRNG initialized using the given explicit seed.
+Math.seedrandom('hello.');
+console.log(Math.random());          // Always 0.9282578795792454
+console.log(Math.random());          // Always 0.3752569768646784
+
+// Sets Math.random to an ARC4-based PRNG that is autoseeded using the
+// current time, dom state, and other accumulated local entropy.
+// The generated seed string is returned.
+Math.seedrandom();
+console.log(Math.random());          // Reasonably unpredictable.
+
+// Seeds using the given explicit seed mixed with accumulated entropy.
+Math.seedrandom('added entropy.', { entropy: true });
+console.log(Math.random());          // As unpredictable as added entropy.
+
+// Use "new" to create a local prng without altering Math.random.
+var myrng = new Math.seedrandom('hello.');
+console.log(myrng());                // Always 0.9282578795792454
+
+
+Node.js usage
+-------------
+
+npm install seedrandom
+
+// Local PRNG: does not affect Math.random.
+var seedrandom = require('seedrandom');
+var rng = seedrandom('hello.');
+console.log(rng());                  // Always 0.9282578795792454
+
+// Autoseeded ARC4-based PRNG.
+rng = seedrandom();
+console.log(rng());                  // Reasonably unpredictable.
+
+// Global PRNG: set Math.random.
+seedrandom('hello.', { global: true });
+console.log(Math.random());          // Always 0.9282578795792454
+
+// Mixing accumulated entropy.
+rng = seedrandom('added entropy.', { entropy: true });
+console.log(rng());                  // As unpredictable as added entropy.
+
+
+Require.js usage
+----------------
+
+Similar to node.js usage:
+
+bower install seedrandom
+
+require(['seedrandom'], function(seedrandom) {
+  var rng = seedrandom('hello.');
+  console.log(rng());                  // Always 0.9282578795792454
+});
+
+
+Network seeding
+---------------
+
+<script src=//cdnjs.cloudflare.com/ajax/libs/seedrandom/2.3.10/seedrandom.min.js>
+</script>
+
+<!-- Seeds using urandom bits from a server. -->
+<script src=//jsonlib.appspot.com/urandom?callback=Math.seedrandom">
+</script>
+
+<!-- Seeds mixing in random.org bits -->
+<script>
+(function(x, u, s){
+  try {
+    // Make a synchronous request to random.org.
+    x.open('GET', u, false);
+    x.send();
+    s = unescape(x.response.trim().replace(/^|\s/g, '%'));
+  } finally {
+    // Seed with the response, or autoseed on failure.
+    Math.seedrandom(s, !!s);
+  }
+})(new XMLHttpRequest, 'https://www.random.org/integers/' +
+  '?num=256&min=0&max=255&col=1&base=16&format=plain&rnd=new');
+</script>
+
+Reseeding using user input
+--------------------------
+
+var seed = Math.seedrandom();        // Use prng with an automatic seed.
+document.write(Math.random());       // Pretty much unpredictable x.
+
+var rng = new Math.seedrandom(seed); // A new prng with the same seed.
+document.write(rng());               // Repeat the 'unpredictable' x.
+
+function reseed(event, count) {      // Define a custom entropy collector.
+  var t = [];
+  function w(e) {
+    t.push([e.pageX, e.pageY, +new Date]);
+    if (t.length &lt; count) { return; }
+    document.removeEventListener(event, w);
+    Math.seedrandom(t, { entropy: true });
+  }
+  document.addEventListener(event, w);
+}
+reseed('mousemove', 100);            // Reseed after 100 mouse moves.
+
+The "pass" option can be used to get both the prng and the seed.
+The following returns both an autoseeded prng and the seed as an object,
+without mutating Math.random:
+
+var obj = Math.seedrandom(null, { pass: function(prng, seed) {
+  return { random: prng, seed: seed };
+}});
+
+
+Version notes
+-------------
+
+The random number sequence is the same as version 1.0 for string seeds.
+* Version 2.0 changed the sequence for non-string seeds.
+* Version 2.1 speeds seeding and uses window.crypto to autoseed if present.
+* Version 2.2 alters non-crypto autoseeding to sweep up entropy from plugins.
+* Version 2.3 adds support for "new", module loading, and a null seed arg.
+* Version 2.3.1 adds a build environment, module packaging, and tests.
+* Version 2.3.4 fixes bugs on IE8, and switches to MIT license.
+* Version 2.3.6 adds a readable options object argument.
+* Version 2.3.10 adds support for node.js crypto (contributed by ctd1500).
+
+The standard ARC4 key scheduler cycles short keys, which means that
+seedrandom('ab') is equivalent to seedrandom('abab') and 'ababab'.
+Therefore it is a good idea to add a terminator to avoid trivial
+equivalences on short string seeds, e.g., Math.seedrandom(str + '\0').
+Starting with version 2.0, a terminator is added automatically for
+non-string seeds, so seeding with the number 111 is the same as seeding
+with '111\0'.
+
+When seedrandom() is called with zero args or a null seed, it uses a
+seed drawn from the browser crypto object if present.  If there is no
+crypto support, seedrandom() uses the current time, the native rng,
+and a walk of several DOM objects to collect a few bits of entropy.
+
+Each time the one- or two-argument forms of seedrandom are called,
+entropy from the passed seed is accumulated in a pool to help generate
+future seeds for the zero- and two-argument forms of seedrandom.
+
+On speed - This javascript implementation of Math.random() is several
+times slower than the built-in Math.random() because it is not native
+code, but that is typically fast enough.  Some details (timings on
+Chrome 25 on a 2010 vintage macbook):
+
+* seeded Math.random()          - avg less than 0.0002 milliseconds per call
+* seedrandom('explicit.')       - avg less than 0.2 milliseconds per call
+* seedrandom('explicit.', true) - avg less than 0.2 milliseconds per call
+* seedrandom() with crypto      - avg less than 0.2 milliseconds per call
+
+Autoseeding without crypto is somewhat slower, about 20-30 milliseconds on
+a 2012 windows 7 1.5ghz i5 laptop, as seen on Firefox 19, IE 10, and Opera.
+Seeded rng calls themselves are fast across these browsers, with slowest
+numbers on Opera at about 0.0005 ms per seeded Math.random().
+
+
+LICENSE (MIT)
+-------------
+
+Copyright 2014 David Bau.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+
+/**
+ * All code is in an anonymous closure to keep the global namespace clean.
+ */
+(function (
+    global, pool, math, width, chunks, digits, module, define, rngname) {
+
+//
+// The following constants are related to IEEE 754 limits.
+//
+var startdenom = math.pow(width, chunks),
+    significance = math.pow(2, digits),
+    overflow = significance * 2,
+    mask = width - 1,
+    nodecrypto;
+
+//
+// seedrandom()
+// This is the seedrandom function described above.
+//
+var impl = math['seed' + rngname] = function(seed, options, callback) {
+  var key = [];
+  options = (options == true) ? { entropy: true } : (options || {});
+
+  // Flatten the seed string or build one from local entropy if needed.
+  var shortseed = mixkey(flatten(
+    options.entropy ? [seed, tostring(pool)] :
+    (seed == null) ? autoseed() : seed, 3), key);
+
+  // Use the seed to initialize an ARC4 generator.
+  var arc4 = new ARC4(key);
+
+  // Mix the randomness into accumulated entropy.
+  mixkey(tostring(arc4.S), pool);
+
+  // Calling convention: what to return as a function of prng, seed, is_math.
+  return (options.pass || callback ||
+      // If called as a method of Math (Math.seedrandom()), mutate Math.random
+      // because that is how seedrandom.js has worked since v1.0.  Otherwise,
+      // it is a newer calling convention, so return the prng directly.
+      function(prng, seed, is_math_call) {
+        if (is_math_call) { math[rngname] = prng; return seed; }
+        else return prng;
+      })(
+
+  // This function returns a random double in [0, 1) that contains
+  // randomness in every bit of the mantissa of the IEEE 754 value.
+  function() {
+    var n = arc4.g(chunks),             // Start with a numerator n < 2 ^ 48
+        d = startdenom,                 //   and denominator d = 2 ^ 48.
+        x = 0;                          //   and no 'extra last byte'.
+    while (n < significance) {          // Fill up all significant digits by
+      n = (n + x) * width;              //   shifting numerator and
+      d *= width;                       //   denominator and generating a
+      x = arc4.g(1);                    //   new least-significant-byte.
+    }
+    while (n >= overflow) {             // To avoid rounding up, before adding
+      n /= 2;                           //   last byte, shift everything
+      d /= 2;                           //   right using integer math until
+      x >>>= 1;                         //   we have exactly the desired bits.
+    }
+    return (n + x) / d;                 // Form the number within [0, 1).
+  }, shortseed, 'global' in options ? options.global : (this == math));
+};
+
+//
+// ARC4
+//
+// An ARC4 implementation.  The constructor takes a key in the form of
+// an array of at most (width) integers that should be 0 <= x < (width).
+//
+// The g(count) method returns a pseudorandom integer that concatenates
+// the next (count) outputs from ARC4.  Its return value is a number x
+// that is in the range 0 <= x < (width ^ count).
+//
+/** @constructor */
+function ARC4(key) {
+  var t, keylen = key.length,
+      me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];
+
+  // The empty key [] is treated as [0].
+  if (!keylen) { key = [keylen++]; }
+
+  // Set up S using the standard key scheduling algorithm.
+  while (i < width) {
+    s[i] = i++;
+  }
+  for (i = 0; i < width; i++) {
+    s[i] = s[j = mask & (j + key[i % keylen] + (t = s[i]))];
+    s[j] = t;
+  }
+
+  // The "g" method returns the next (count) outputs as one number.
+  (me.g = function(count) {
+    // Using instance members instead of closure state nearly doubles speed.
+    var t, r = 0,
+        i = me.i, j = me.j, s = me.S;
+    while (count--) {
+      t = s[i = mask & (i + 1)];
+      r = r * width + s[mask & ((s[i] = s[j = mask & (j + t)]) + (s[j] = t))];
+    }
+    me.i = i; me.j = j;
+    return r;
+    // For robust unpredictability, the function call below automatically
+    // discards an initial batch of values.  This is called RC4-drop[256].
+    // See http://google.com/search?q=rsa+fluhrer+response&btnI
+  })(width);
+}
+
+//
+// flatten()
+// Converts an object tree to nested arrays of strings.
+//
+function flatten(obj, depth) {
+  var result = [], typ = (typeof obj), prop;
+  if (depth && typ == 'object') {
+    for (prop in obj) {
+      try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
+    }
+  }
+  return (result.length ? result : typ == 'string' ? obj : obj + '\0');
+}
+
+//
+// mixkey()
+// Mixes a string seed into a key that is an array of integers, and
+// returns a shortened string seed that is equivalent to the result key.
+//
+function mixkey(seed, key) {
+  var stringseed = seed + '', smear, j = 0;
+  while (j < stringseed.length) {
+    key[mask & j] =
+      mask & ((smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++));
+  }
+  return tostring(key);
+}
+
+//
+// autoseed()
+// Returns an object for autoseeding, using window.crypto if available.
+//
+/** @param {Uint8Array|Navigator=} seed */
+function autoseed(seed) {
+  try {
+    if (nodecrypto) return tostring(nodecrypto.randomBytes(width));
+    global.crypto.getRandomValues(seed = new Uint8Array(width));
+    return tostring(seed);
+  } catch (e) {
+    return [+new Date, global, (seed = global.navigator) && seed.plugins,
+      global.screen, tostring(pool)];
+  }
+}
+
+//
+// tostring()
+// Converts an array of charcodes to a string
+//
+function tostring(a) {
+  return String.fromCharCode.apply(0, a);
+}
+
+//
+// When seedrandom.js is loaded, we immediately mix a few bits
+// from the built-in RNG into the entropy pool.  Because we do
+// not want to interfere with deterministic PRNG state later,
+// seedrandom will not call math.random on its own again after
+// initialization.
+//
+mixkey(math[rngname](), pool);
+
+//
+// Nodejs and AMD support: export the implementation as a module using
+// either convention.
+//
+if (module && module.exports) {
+  module.exports = impl;
+  try {
+    // When in node.js, try using crypto package for autoseeding.
+    nodecrypto = require('crypto');
+  } catch (ex) {}
+} else if (define && define.amd) {
+  define(function() { return impl; });
+}
+
+//
+// Node.js native crypto support.
+//
+
+// End anonymous scope, and pass initial values.
+})(
+  this,   // global window object
+  [],     // pool: entropy pool starts empty
+  Math,   // math: package containing random, pow, and seedrandom
+  256,    // width: each RC4 output is 0 <= x < 256
+  6,      // chunks: at least six RC4 outputs for each double
+  52,     // digits: there are 52 significant digits in a double
+  (typeof module) == 'object' && module,    // present in node.js
+  (typeof define) == 'function' && define,  // present with an AMD loader
+  'random'// rngname: name for Math.random and Math.seedrandom
+);

luci-app-mptcp/htdocs/luci-static/resources/view/mptcp/mptcp.js

@@ -0,0 +1,282 @@
+'use strict';
+'require rpc';
+'require form';
+'require fs';
+'require uci';
+'require tools.widgets as widgets';
+
+/*
+ * Copyright (C) 2024-2025 Ycarus (Yannick Chabanois) <contact@openmptcprouter.com> for OpenMPTCProuter
+ * This is free software, licensed under the GNU General Public License v3.
+ * See /LICENSE for more information
+ */
+
+var callSystemBoard = rpc.declare({
+    object: 'system',
+    method: 'board'
+});
+
+
+return L.view.extend({
+    load: function() {
+	return Promise.all([
+	    L.resolveDefault(callSystemBoard(), {})
+	]);
+    },
+
+    render: function(res) {
+	var m, s, o;
+	var boardinfo = res[0];
+
+	m = new form.Map('network', _('MPTCP'),_('Networks MPTCP settings.'));
+
+	s = m.section(form.TypedSection, 'globals');
+
+	o = s.option(form.ListValue, 'multipath', _('Multipath TCP'));
+	o.value("enable", _("enable"));
+	o.value("disable", _("disable"));
+	o.readonly = true;
+
+	o = s.option(form.ListValue, "mptcp_checksum", _("Multipath TCP checksum"));
+	o.value(1, _("enable"));
+	o.value(0, _("disable"));
+
+	if (parseFloat(boardinfo.kernel.substring(0,4)) < 6) {
+		o = s.option(form.ListValue, "mptcp_debug", _("Multipath Debug"));
+		o.value(1, _("enable"));
+		o.value(0, _("disable"));
+	}
+
+	o = s.option(form.ListValue, "mptcp_path_manager", _("Multipath TCP path-manager"), _("Default is fullmesh"));
+	o.value("default", _("default"));
+	o.value("fullmesh", "fullmesh");
+
+	if (parseFloat(boardinfo.kernel.substring(0,4)) < 6) {
+		o.value("ndiffports", "ndiffports");
+		o.value("binder", "binder");
+		o.value("netlink", _("Netlink"));
+	}
+
+	var scheduler = s.option(form.ListValue, "mptcp_scheduler", _("Multipath TCP scheduler"), _('BPF schedulers (not available on all platforms):') + '<br />' +
+		_('bpf_burst => same as the default scheduler') + '<br />' +
+		_('bpf_red => sends all packets redundantly on all available subflows') + '<br />' +
+		_('bpf_first => always picks the first subflow to send data')  + '<br />' +
+		_('bpf_rr => always picks the next available subflow to send data (round-robin)')
+
+	);
+	scheduler.value("default", _("default"));
+	if (parseFloat(boardinfo.kernel.substring(0,4)) < 6) {
+		scheduler.value("roundrobin", "round-robin");
+		scheduler.value("redundant", "redundant");
+		scheduler.value("blest", "BLEST");
+		scheduler.value("ecf", "ECF");
+	}
+
+	if (parseFloat(boardinfo.kernel.substring(0,3)) > 6) {
+	    scheduler.load = function(section_id) {
+		    return L.resolveDefault(fs.list('/usr/share/bpf/scheduler'), []).then(L.bind(function(entries) {
+			    for (var i = 0; i < entries.length; i++)
+				    if (entries[i].type == 'file' && entries[i].name.match(/\.o$/))
+					this.value(entries[i].name);
+			    return this.super('load', [section_id]);
+		    }, this));
+	    };
+	    // bpf_burst => same as the default scheduler
+	    // bpf_red => sends all packets redundantly on all available subflows
+	    // bpf_first => always picks the first subflow to send data
+	    // bpf_rr => always picks the next available subflow to send data (round-robin)
+	}
+
+	scheduler.onchange = function(ev, section_id, value) {
+		return m.checkDepends();
+	};
+
+	if (parseFloat(boardinfo.kernel.substring(0,4)) < 6) {
+		o = s.option(form.Value, "mptcp_syn_retries", _("Multipath TCP SYN retries"));
+		o.datatype = "uinteger";
+		o.rmempty = false;
+	}
+
+	if (parseFloat(boardinfo.kernel.substring(0,4)) < 6) {
+		o = s.option(form.ListValue, "mptcp_version", _("Multipath TCP version"));
+		o.value(0, _("0"));
+		o.value(1, _("1"));
+		o.default = 0;
+	}
+
+	o = s.option(form.ListValue, "congestion", _("Congestion Control"),_("Default is cubic"));
+	o.load = function(section_id) {
+		return fs.exec_direct('/sbin/sysctl', ['-n', 'net.ipv4.tcp_available_congestion_control']).then(L.bind(function(entries) {
+			var congestioncontrol = entries.toString().split(' ');
+			for (var d in congestioncontrol) {
+				this.value(congestioncontrol[d]);
+			};
+			return this.super('load', [section_id]);
+		}, this));
+	};
+
+	if (parseFloat(boardinfo.kernel.substring(0,4)) >= 6) {
+		o = s.option(form.ListValue, "mptcp_pm_type", _("Path Manager type"));
+		o.value(0, _("In-kernel path manager"));
+		o.value(1, _("Userspace path manager"));
+		o.default = 0;
+
+		o = s.option(form.ListValue, "mptcp_disable_initial_config", _("Initial MPTCP configuration"));
+		o.depends("mptcp_pm_type","1");
+		o.value("0", _("enable"));
+		o.value("1", _("disable"));
+		o.default = "0";
+
+		o = s.option(form.ListValue, "mptcp_force_multipath", _("Force Multipath configuration"));
+		o.depends("mptcp_pm_type","1");
+		o.value("1", _("enable"));
+		o.value("0", _("disable"));
+		o.default = "1";
+
+		o = s.option(form.ListValue, "mptcpd_enable", _("Enable MPTCPd"));
+		o.depends("mptcp_pm_type","1");
+		o.value("enable", _("enable"));
+		o.value("disable", _("disable"));
+		o.default = "disable";
+
+		o = s.option(form.DynamicList, "mptcpd_path_manager", _("MPTCPd path managers"));
+		o.load = function(section_id) {
+			return L.resolveDefault(fs.list('/usr/lib/mptcpd'), []).then(L.bind(function(entries) {
+				for (var i = 0; i < entries.length; i++)
+					if (entries[i].type == 'file' && entries[i].name.match(/\.so$/))
+						this.value(entries[i].name);
+				return this.super('load', [section_id]);
+			}, this));
+		};
+		o.depends("mptcp_pm_type","1");
+
+		o = s.option(form.DynamicList, "mptcpd_plugins", _("MPTCPd plugins"));
+		o.load = function(section_id) {
+			return L.resolveDefault(fs.list('/usr/lib/mptcpd'), []).then(L.bind(function(entries) {
+				for (var i = 0; i < entries.length; i++)
+					if (entries[i].type == 'file' && entries[i].name.match(/\.so$/))
+						this.value(entries[i].name);
+				return this.super('load', [section_id]);
+			}, this));
+		};
+		o.depends("mptcp_pm_type","1");
+
+		o = s.option(form.DynamicList, "mptcpd_addr_flags", _("MPTCPd Address annoucement flags"));
+		o.value("subflow","subflow");
+		o.value("signal","signal");
+		o.value("backup","backup");
+		o.value("fullmesh","fullmesh");
+		o.depends("mptcp_pm_type","1");
+
+		o = s.option(form.DynamicList, "mptcpd_notify_flags", _("MPTCPd Address notification flags"));
+		o.value("existing","existing");
+		o.value("skip_link_local","skip_link_local");
+		o.value("skip_loopback","skip_loopback");
+		o.depends("mptcp_pm_type","1");
+
+		o = s.option(form.Value, "mptcp_subflows", _("Max subflows"),_("specifies the maximum number of additional subflows allowed for each MPTCP connection"));
+		o.datatype = "uinteger";
+		o.rmempty = false;
+		o.default = 3;
+
+		o = s.option(form.Value, "mptcp_stale_loss_cnt", _("Retranmission intervals"),_("The number of MPTCP-level retransmission intervals with no traffic and pending outstanding data on a given subflow required to declare it stale. A low stale_loss_cnt value allows for fast active-backup switch-over, an high value maximize links utilization on edge scenarios e.g. lossy link with high BER or peer pausing the data processing."));
+		o.datatype = "uinteger";
+		o.rmempty = false;
+		o.default = 4;
+
+		o = s.option(form.Value, "mptcp_add_addr_accepted", _("Max add address"),_("specifies the maximum number of ADD_ADDR (add address) suboptions accepted for each MPTCP connection"));
+		o.datatype = "uinteger";
+		o.rmempty = false;
+		o.default = 1;
+
+		o = s.option(form.Value, "mptcp_add_addr_timeout", _("Control message timeout"),_("Set the timeout after which an ADD_ADDR (add address) control message will be resent to an MPTCP peer that has not acknowledged a previous ADD_ADDR message."));
+		o.datatype = "uinteger";
+		o.rmempty = false;
+		o.default = 120;
+		if (parseFloat(boardinfo.kernel.substring(0,4)) >= 6.18) {
+			o = s.option(form.Value, "mptcp_blackhole_timeout", _("Blackhole timeout"),_("Initial time period in second to disable MPTCP on active MPTCP sockets when a MPTCP firewall blackhole issue happens. This time period will grow exponentially when more blackhole issues get detected right after MPTCP is re-enabled and will reset to the initial value when the blackhole issue goes away."));
+			o.datatype = "uinteger";
+			o.rmempty = false;
+			o.default = 3600;
+
+			o = s.option(form.Value, "mptcp_close_timeout", _("Close timeout"),_("Set the make-after-break timeout: in absence of any close or shutdown syscall, MPTCP sockets will maintain the status unchanged for such time, after the last subflow removal, before moving to TCP_CLOSE."));
+			o.datatype = "uinteger";
+			o.rmempty = false;
+			o.default = 60;
+
+			o = s.option(form.Value, "mptcp_syn_retrans_before_tcp_fallback", _("Control message timeout"),_("The number of SYN + MP_CAPABLE retransmissions before falling back to TCP, i.e. dropping the MPTCP options."));
+			o.datatype = "uinteger";
+			o.rmempty = false;
+			o.default = 2;
+		}
+	} else {
+		o = s.option(form.Value, "mptcp_fullmesh_num_subflows", _("Fullmesh subflows for each pair of IP addresses"));
+		o.datatype = "uinteger";
+		o.rmempty = false;
+		o.default = 1;
+		//o.depends("mptcp_path_manager","fullmesh")
+
+		o = s.option(form.ListValue, "mptcp_fullmesh_create_on_err", _("Re-create fullmesh subflows after a timeout"));
+		o.value(1, _("enable"));
+		o.value(0, _("disable"));
+		//o.depends("mptcp_path_manager","fullmesh");
+
+		o = s.option(form.Value, "mptcp_ndiffports_num_subflows", _("ndiffports subflows number"));
+		o.datatype = "uinteger";
+		o.rmempty = false;
+		o.default = 1;
+		//o.depends("mptcp_path_manager","ndiffports")
+
+		o = s.option(form.ListValue, "mptcp_rr_cwnd_limited", _("Fill the congestion window on all subflows for round robin"));
+		o.value("Y", _("enable"));
+		o.value("N", _("disable"));
+		o.default = "Y";
+		//o.depends("mptcp_scheduler","roundrobin")
+
+		o = s.option(form.Value, "mptcp_rr_num_segments", _("Consecutive segments that should be sent for round robin"));
+		o.datatype = "uinteger";
+		o.rmempty = false;
+		o.default = 1;
+		//o.depends("mptcp_scheduler","roundrobin")
+	}
+
+	s = m.section(form.TypedSection, "interface", _("Interfaces Settings"));
+	s.filter = function(section) {
+	    return (!section.match("^oip.*") && !section.match("^lo.*") && section != "omrvpn" && section != "OWVPN" && section != "omr6in4");
+	}
+
+	o = s.option(form.ListValue, "multipath", _("Multipath TCP"), _("One interface must be set as master"));
+	o.value("on", _("enabled"));
+	o.value("off", _("disabled"));
+	o.value("master", _("master"));
+	o.value("backup", _("backup"));
+	//o.value("handover", _("handover"));
+	o.default = "off";
+
+	o = s.option(form.Value, "multipath_weight", _("Weight"), _("Only for *weight schedulers/path managers (if any available)") + '<br />' + _("A weight >100 make it more attractive, a weight <100 make it less attractive. Max 256"));
+	o.datatype = "uinteger";
+	o.rmempty = false;
+	o.default = 100;
+
+	return m.render().then(function(mapEl) {
+		function updateWeightVisibility() {
+			var schedulerEl = document.getElementById('widget.cbid.network.globals.mptcp_scheduler');
+			var val = schedulerEl ? schedulerEl.value : (uci.get('network', 'globals', 'mptcp_scheduler') || '');
+			var show = val.toLowerCase().indexOf('weight') > -1;
+
+			mapEl.querySelectorAll('[data-name="multipath_weight"]').forEach(function(el) {
+				var row = el.closest('.cbi-value') || el;
+				row.style.display = show ? '' : 'none';
+			});
+		}
+
+		var schedulerEl = document.getElementById('widget.cbid.network.globals.mptcp_scheduler');
+		if (schedulerEl) {
+			schedulerEl.addEventListener('change', updateWeightVisibility);
+		}
+		updateWeightVisibility();
+
+		return mapEl;
+	});
+    }
+});