modules/luci-mod-network/htdocs/luci-static/resources/view/network/dhcp.js

   1 'use strict';
   2 'require view';
   3 'require dom';
   4 'require poll';
   5 'require rpc';
   6 'require uci';
   7 'require form';
   8 'require network';
   9 'require validation';
  10 'require tools.widgets as widgets';
  11
  12 var callHostHints, callDUIDHints, callDHCPLeases, CBILeaseStatus, CBILease6Status;
  13
  14 callHostHints = rpc.declare({
  15         object: 'luci-rpc',
  16         method: 'getHostHints',
  17         expect: { '': {} }
  18 });
  19
  20 callDUIDHints = rpc.declare({
  21         object: 'luci-rpc',
  22         method: 'getDUIDHints',
  23         expect: { '': {} }
  24 });
  25
  26 callDHCPLeases = rpc.declare({
  27         object: 'luci-rpc',
  28         method: 'getDHCPLeases',
  29         expect: { '': {} }
  30 });
  31
  32 CBILeaseStatus = form.DummyValue.extend({
  33         renderWidget: function(section_id, option_id, cfgvalue) {
  34                 return E([
  35                         E('h4', _('Active DHCP Leases')),
  36                         E('table', { 'id': 'lease_status_table', 'class': 'table' }, [
  37                                 E('tr', { 'class': 'tr table-titles' }, [
  38                                         E('th', { 'class': 'th' }, _('Hostname')),
  39                                         E('th', { 'class': 'th' }, _('IPv4 address')),
  40                                         E('th', { 'class': 'th' }, _('MAC address')),
  41                                         E('th', { 'class': 'th' }, _('Lease time remaining'))
  42                                 ]),
  43                                 E('tr', { 'class': 'tr placeholder' }, [
  44                                         E('td', { 'class': 'td' }, E('em', _('Collecting data...')))
  45                                 ])
  46                         ])
  47                 ]);
  48         }
  49 });
  50
  51 CBILease6Status = form.DummyValue.extend({
  52         renderWidget: function(section_id, option_id, cfgvalue) {
  53                 return E([
  54                         E('h4', _('Active DHCPv6 Leases')),
  55                         E('table', { 'id': 'lease6_status_table', 'class': 'table' }, [
  56                                 E('tr', { 'class': 'tr table-titles' }, [
  57                                         E('th', { 'class': 'th' }, _('Host')),
  58                                         E('th', { 'class': 'th' }, _('IPv6 address')),
  59                                         E('th', { 'class': 'th' }, _('DUID')),
  60                                         E('th', { 'class': 'th' }, _('Lease time remaining'))
  61                                 ]),
  62                                 E('tr', { 'class': 'tr placeholder' }, [
  63                                         E('td', { 'class': 'td' }, E('em', _('Collecting data...')))
  64                                 ])
  65                         ])
  66                 ]);
  67         }
  68 });
  69
  70 function calculateNetwork(addr, mask) {
  71         addr = validation.parseIPv4(String(addr));
  72
  73         if (!isNaN(mask))
  74                 mask = validation.parseIPv4(network.prefixToMask(+mask));
  75         else
  76                 mask = validation.parseIPv4(String(mask));
  77
  78         if (addr == null || mask == null)
  79                 return null;
  80
  81         return [
  82                 [
  83                         addr[0] & (mask[0] >>> 0 & 255),
  84                         addr[1] & (mask[1] >>> 0 & 255),
  85                         addr[2] & (mask[2] >>> 0 & 255),
  86                         addr[3] & (mask[3] >>> 0 & 255)
  87                 ].join('.'),
  88                 mask.join('.')
  89         ];
  90 }
  91
  92 function generateDnsmasqInstanceEntry(data) {
  93         const nameValueMap = new Map(Object.entries(data));
  94         let formatString = nameValueMap.get('.index') + ' (' +  _('Name') + (nameValueMap.get('.anonymous') ? ': dnsmasq[' + nameValueMap.get('.index') + ']': ': ' + nameValueMap.get('.name'));
  95
  96         if (data.domain) {
  97                 formatString += ', ' +  _('Domain')  + ': ' + data.domain;
  98         }
  99         if (data.local) {
 100                 formatString += ', ' +  _('Local')  + ': ' + data.local;
 101         }
 102         formatString += ')';
 103
 104         return nameValueMap.get('.name'), formatString;
 105 }
 106
 107 function getDHCPPools() {
 108         return uci.load('dhcp').then(function() {
 109                 let sections = uci.sections('dhcp', 'dhcp'),
 110                     tasks = [], pools = [];
 111
 112                 for (var i = 0; i < sections.length; i++) {
 113                         if (sections[i].ignore == '1' || !sections[i].interface)
 114                                 continue;
 115
 116                         tasks.push(network.getNetwork(sections[i].interface).then(L.bind(function(section_id, net) {
 117                                 var cidr = net ? (net.getIPAddrs()[0] || '').split('/') : null;
 118
 119                                 if (cidr && cidr.length == 2) {
 120                                         var net_mask = calculateNetwork(cidr[0], cidr[1]);
 121
 122                                         pools.push({
 123                                                 section_id: section_id,
 124                                                 network: net_mask[0],
 125                                                 netmask: net_mask[1]
 126                                         });
 127                                 }
 128                         }, null, sections[i]['.name'])));
 129                 }
 130
 131                 return Promise.all(tasks).then(function() {
 132                         return pools;
 133                 });
 134         });
 135 }
 136
 137 function validateHostname(sid, s) {
 138         if (s == null || s == '')
 139                 return true;
 140
 141         if (s.length > 256)
 142                 return _('Expecting: %s').format(_('valid hostname'));
 143
 144         var labels = s.replace(/^\*?\.?|\.$/g, '').split(/\./);
 145
 146         for (var i = 0; i < labels.length; i++)
 147                 if (!labels[i].match(/^[a-z0-9_](?:[a-z0-9-]{0,61}[a-z0-9])?$/i))
 148                         return _('Expecting: %s').format(_('valid hostname'));
 149
 150         return true;
 151 }
 152
 153 function validateAddressList(sid, s) {
 154         if (s == null || s == '')
 155                 return true;
 156
 157         var m = s.match(/^\/(.+)\/$/),
 158             names = m ? m[1].split(/\//) : [ s ];
 159
 160         for (var i = 0; i < names.length; i++) {
 161                 var res = validateHostname(sid, names[i]);
 162
 163                 if (res !== true)
 164                         return res;
 165         }
 166
 167         return true;
 168 }
 169
 170 function validateServerSpec(sid, s) {
 171         if (s == null || s == '')
 172                 return true;
 173
 174         var m = s.match(/^(\/.*\/)?(.*)$/);
 175         if (!m)
 176                 return _('Expecting: %s').format(_('valid hostname'));
 177
 178         if (m[1] != '//' && m[1] != '/#/') {
 179                 var res = validateAddressList(sid, m[1]);
 180                 if (res !== true)
 181                         return res;
 182         }
 183
 184         if (m[2] == '' || m[2] == '#')
 185                 return true;
 186
 187         // ipaddr%scopeid#srvport@source@interface#srcport
 188
 189         m = m[2].match(/^([0-9a-f:.]+)(?:%[^#@]+)?(?:#(\d+))?(?:@([0-9a-f:.]+)(?:@[^#]+)?(?:#(\d+))?)?$/);
 190
 191         if (!m)
 192                 return _('Expecting: %s').format(_('valid IP address'));
 193
 194         if (validation.parseIPv4(m[1])) {
 195                 if (m[3] != null && !validation.parseIPv4(m[3]))
 196                         return _('Expecting: %s').format(_('valid IPv4 address'));
 197         }
 198         else if (validation.parseIPv6(m[1])) {
 199                 if (m[3] != null && !validation.parseIPv6(m[3]))
 200                         return _('Expecting: %s').format(_('valid IPv6 address'));
 201         }
 202         else {
 203                 return _('Expecting: %s').format(_('valid IP address'));
 204         }
 205
 206         if ((m[2] != null && +m[2] > 65535) || (m[4] != null && +m[4] > 65535))
 207                 return _('Expecting: %s').format(_('valid port value'));
 208
 209         return true;
 210 }
 211
 212 function expandAndFormatMAC(macs) {
 213         let result = [];
 214
 215         macs.forEach(mac => {
 216                 if (isValidMAC(mac)) {
 217                         const expandedMac = mac.split(':').map(part => {
 218                                 return (part.length === 1 && part !== '*') ? '0' + part : part;
 219                         }).join(':').toUpperCase();
 220                         result.push(expandedMac);
 221                 }
 222         });
 223
 224         return result.length ? result.join(' ') : null;
 225 }
 226
 227 function isValidMAC(sid, s) {
 228         if (!s)
 229                 return true;
 230
 231         let macaddrs = L.toArray(s);
 232
 233         for (var i = 0; i < macaddrs.length; i++)
 234                 if (!macaddrs[i].match(/^(([0-9a-f]{1,2}|\*)[:-]){5}([0-9a-f]{1,2}|\*)$/i))
 235                         return _('Expecting a valid MAC address, optionally including wildcards') + _('; invalid MAC: ') + macaddrs[i];
 236
 237         return true;
 238 }
 239
 240 function validateMACAddr(pools, sid, s) {
 241         if (s == null || s == '')
 242                 return true;
 243
 244         var leases = uci.sections('dhcp', 'host'),
 245             this_macs = L.toArray(s).map(function(m) { return m.toUpperCase() });
 246
 247         for (var i = 0; i < pools.length; i++) {
 248                 var this_net_mask = calculateNetwork(this.section.formvalue(sid, 'ip'), pools[i].netmask);
 249
 250                 if (!this_net_mask)
 251                         continue;
 252
 253                 for (var j = 0; j < leases.length; j++) {
 254                         if (leases[j]['.name'] == sid || !leases[j].ip)
 255                                 continue;
 256
 257                         var lease_net_mask = calculateNetwork(leases[j].ip, pools[i].netmask);
 258
 259                         if (!lease_net_mask || this_net_mask[0] != lease_net_mask[0])
 260                                 continue;
 261
 262                         var lease_macs = L.toArray(leases[j].mac).map(function(m) { return m.toUpperCase() });
 263
 264                         for (var k = 0; k < lease_macs.length; k++)
 265                                 for (var l = 0; l < this_macs.length; l++)
 266                                         if (lease_macs[k] == this_macs[l])
 267                                                 return _('The MAC address %h is already used by another static lease in the same DHCP pool').format(this_macs[l]);
 268                 }
 269         }
 270
 271         return isValidMAC(sid, s);
 272 }
 273
 274 return view.extend({
 275         load: function() {
 276                 return Promise.all([
 277                         callHostHints(),
 278                         callDUIDHints(),
 279                         getDHCPPools(),
 280                         network.getNetworks()
 281                 ]);
 282         },
 283
 284         render: function(hosts_duids_pools) {
 285                 var has_dhcpv6 = L.hasSystemFeature('dnsmasq', 'dhcpv6') || L.hasSystemFeature('odhcpd'),
 286                     hosts = hosts_duids_pools[0],
 287                     duids = hosts_duids_pools[1],
 288                     pools = hosts_duids_pools[2],
 289                     networks = hosts_duids_pools[3],
 290                     m, s, o, ss, so;
 291
 292                 let noi18nstrings = {
 293                         etc_hosts: '<code>/etc/hosts</code>',
 294                         etc_ethers: '<code>/etc/ethers</code>',
 295                         localhost_v6: '<code>::1</code>',
 296                         loopback_slash_8_v4: '<code>127.0.0.0/8</code>',
 297                         not_found: '<code>Not found</code>',
 298                         nxdomain: '<code>NXDOMAIN</code>',
 299                         rfc_1918_link: '<a href="https://www.rfc-editor.org/rfc/rfc1918">RFC1918</a>',
 300                         rfc_4193_link: '<a href="https://www.rfc-editor.org/rfc/rfc4193">RFC4193</a>',
 301                         rfc_4291_link: '<a href="https://www.rfc-editor.org/rfc/rfc4291">RFC4291</a>',
 302                         rfc_6303_link: '<a href="https://www.rfc-editor.org/rfc/rfc6303">RFC6303</a>',
 303                         reverse_arpa: '<code>*.IN-ADDR.ARPA,*.IP6.ARPA</code>',
 304                         servers_file_entry01: '<code>server=1.2.3.4</code>',
 305                         servers_file_entry02: '<code>server=/domain/1.2.3.4</code>',
 306
 307                 };
 308
 309                 function customi18n(template, values) {
 310                         if (!values)
 311                                 values = noi18nstrings;
 312                         return template.replace(/\{(\w+)\}/g, (match, key) => values[key] || match);
 313                 };
 314
 315                 m = new form.Map('dhcp', _('DHCP and DNS'),
 316                         _('Dnsmasq is a lightweight <abbr title="Dynamic Host Configuration Protocol">DHCP</abbr> server and <abbr title="Domain Name System">DNS</abbr> forwarder.'));
 317
 318                 s = m.section(form.TypedSection, 'dnsmasq');
 319                 s.anonymous = false;
 320                 s.addremove = true;
 321
 322
 323
 324                 s.tab('general', _('General'));
 325                 s.tab('devices', _('Devices &amp; Ports'));
 326                 s.tab('dnssecopt', _('DNSSEC'));
 327                 s.tab('filteropts', _('Filter'));
 328                 s.tab('forward', _('Forwards'));
 329                 s.tab('limits', _('Limits'));
 330                 s.tab('logging', _('Log'));
 331                 s.tab('files', _('Resolv &amp; Hosts Files'));
 332                 s.tab('leases', _('Static Leases'));
 333                 s.tab('hosts', _('Hostnames'));
 334                 s.tab('ipsets', _('IP Sets'));
 335                 s.tab('relay', _('Relay'));
 336                 s.tab('srvhosts', _('SRV'));
 337                 s.tab('mxhosts', _('MX'));
 338                 s.tab('cnamehosts', _('CNAME'));
 339                 s.tab('pxe_tftp', _('PXE/TFTP'));
 340
 341                 s.taboption('filteropts', form.Flag, 'domainneeded',
 342                         _('Domain required'),
 343                         _('Never forward DNS queries which lack dots or domain parts.') + '<br />' +
 344                         customi18n(_('Names not in {etc_hosts} are answered {not_found}.') )
 345                 );
 346                 s.taboption('general', form.Flag, 'authoritative',
 347                         _('Authoritative'),
 348                         _('This is the only DHCP server in the local network.'));
 349
 350                 o = s.taboption('general', form.Value, 'local',
 351                         _('Resolve these locally'),
 352                         _('Never forward these matching domains or subdomains; resolve from DHCP or hosts files only.'));
 353                 o.placeholder = '/internal.example.com/private.example.com/example.org';
 354
 355                 s.taboption('general', form.Value, 'domain',
 356                         _('Local domain'),
 357                         _('Local domain suffix appended to DHCP names and hosts file entries.'));
 358
 359                 s.taboption('general', form.Flag, 'expandhosts',
 360                         _('Expand hosts'),
 361                         _('Add local domain suffix to names served from hosts files.'));
 362
 363                 o = s.taboption('logging', form.Flag, 'logqueries',
 364                         _('Log queries'),
 365                         _('Write received DNS queries to syslog.') + ' ' + _('Dump cache on SIGUSR1, include requesting IP.'));
 366                 o.optional = true;
 367
 368                 o = s.taboption('logging', form.Flag, 'logdhcp',
 369                         _('Extra DHCP logging'),
 370                         _('Log all options sent to DHCP clients and the tags used to determine them.'));
 371                 o.optional = true;
 372
 373                 o = s.taboption('logging', form.Value, 'logfacility',
 374                         _('Log facility'),
 375                         _('Set log class/facility for syslog entries.'));
 376                 o.optional = true;
 377                 o.value('KERN');
 378                 o.value('USER');
 379                 o.value('MAIL');
 380                 o.value('DAEMON');
 381                 o.value('AUTH');
 382                 o.value('LPR');
 383                 o.value('NEWS');
 384                 o.value('UUCP');
 385                 o.value('CRON');
 386                 o.value('LOCAL0');
 387                 o.value('LOCAL1');
 388                 o.value('LOCAL2');
 389                 o.value('LOCAL3');
 390                 o.value('LOCAL4');
 391                 o.value('LOCAL5');
 392                 o.value('LOCAL6');
 393                 o.value('LOCAL7');
 394                 o.value('-', _('stderr'));
 395
 396                 o = s.taboption('forward', form.DynamicList, 'server',
 397                         _('DNS forwardings'),
 398                         _('Forward specific domain queries to specific upstream servers.'));
 399                 o.optional = true;
 400                 o.placeholder = '/*.example.org/10.1.2.3';
 401                 o.validate = validateServerSpec;
 402
 403                 o = s.taboption('general', form.DynamicList, 'address',
 404                         _('Addresses'),
 405                         _('Resolve specified FQDNs to an IP.') + '<br />' +
 406                         customi18n(_('Syntax: {code_syntax}.'),
 407                                 {code_syntax: '<code>/fqdn[/fqdn…]/[ipaddr]</code>'}) + '<br />' +
 408                         customi18n(_('{example_nx} returns {nxdomain}.',
 409                                 'hint: <code>/example.com/</code> returns <code>NXDOMAIN</code>.'),
 410                                 {example_nx: '<code>/example.com/</code>', nxdomain: '<code>NXDOMAIN</code>'}) + '<br />' +
 411                         customi18n(_('{any_domain} matches any domain (and returns {nxdomain}).',
 412                                 'hint: <code>/#/</code> matches any domain (and returns NXDOMAIN).'),
 413                                 {any_domain:'<code>/#/</code>', nxdomain: '<code>NXDOMAIN</code>'}) + '<br />' +
 414                         customi18n(
 415                                 _('{example_null} returns {null_addr} addresses ({null_ipv4}, {null_ipv6}) for {example_com} and its subdomains.',
 416                                         'hint: <code>/example.com/#</code> returns NULL addresses (<code>0.0.0.0</code>, <code>::</code>) for example.com and its subdomains.'),
 417                                 {       example_null: '<code>/example.com/#</code>',
 418                                         null_addr: '<code>NULL</code>',
 419                                         null_ipv4: '<code>0.0.0.0</code>',
 420                                         null_ipv6: '<code>::</code>',
 421                                         example_com: '<code>example.com</code>',
 422                                 }
 423                         )
 424                 );
 425                 o.optional = true;
 426                 o.placeholder = '/router.local/router.lan/192.168.0.1';
 427
 428                 o = s.taboption('general', form.DynamicList, 'ipset',
 429                         _('IP sets'),
 430                         _('List of IP sets to populate with the IPs of DNS lookup results of the FQDNs also specified here.'));
 431                 o.optional = true;
 432                 o.placeholder = '/example.org/ipset,ipset6';
 433
 434                 o = s.taboption('filteropts', form.Flag, 'rebind_protection',
 435                         _('Rebind protection'),
 436                         customi18n(_('Discard upstream responses containing {rfc_1918_link} addresses.') ) + '<br />' +
 437                         customi18n(_('Discard also upstream responses containing {rfc_4193_link}, Link-Local and private IPv4-Mapped {rfc_4291_link} IPv6 Addresses.') )
 438                 );
 439                 o.rmempty = false;
 440
 441                 o = s.taboption('filteropts', form.Flag, 'rebind_localhost',
 442                         _('Allow localhost'),
 443                         customi18n(
 444                         _('Exempt {loopback_slash_8_v4} and {localhost_v6} from rebinding checks, e.g. for <abbr title="Real-time Block List">RBL</abbr> services.')
 445                         )
 446                 );
 447                 o.depends('rebind_protection', '1');
 448
 449                 o = s.taboption('filteropts', form.DynamicList, 'rebind_domain',
 450                         _('Domain whitelist'),
 451                         customi18n(_('List of domains to allow {rfc_1918_link} responses for.') )
 452                 );
 453                 o.depends('rebind_protection', '1');
 454                 o.optional = true;
 455                 o.placeholder = 'ihost.netflix.com';
 456                 o.validate = validateAddressList;
 457
 458                 o = s.taboption('filteropts', form.Flag, 'localservice',
 459                         _('Local service only'),
 460                         _('Accept DNS queries only from hosts whose address is on a local subnet.'));
 461                 o.optional = false;
 462                 o.rmempty = false;
 463
 464                 o = s.taboption('devices', form.Flag, 'nonwildcard',
 465                         _('Non-wildcard'),
 466                         _('Bind only to configured interface addresses, instead of the wildcard address.'));
 467                 o.default = o.enabled;
 468                 o.optional = false;
 469                 o.rmempty = true;
 470
 471                 o = s.taboption('devices', widgets.NetworkSelect, 'interface',
 472                         _('Listen interfaces'),
 473                         _('Listen only on the specified interfaces, and loopback if not excluded explicitly.'));
 474                 o.multiple = true;
 475                 o.nocreate = true;
 476
 477                 o = s.taboption('devices', widgets.NetworkSelect, 'notinterface',
 478                         _('Exclude interfaces'),
 479                         _('Do not listen on the specified interfaces.'));
 480                 o.loopback = true;
 481                 o.multiple = true;
 482                 o.nocreate = true;
 483
 484                 o = s.taboption('relay', form.SectionValue, '__relays__', form.TableSection, 'relay', null,
 485                         _('Relay DHCP requests elsewhere. OK: v4↔v4, v6↔v6. Not OK: v4↔v6, v6↔v4.')
 486                         + '<br />' + _('Note: you may also need a DHCP Proxy (currently unavailable) when specifying a non-standard Relay To port(<code>addr#port</code>).')
 487                         + '<br />' + _('You may add multiple unique Relay To on the same Listen addr.'));
 488
 489                 ss = o.subsection;
 490
 491                 ss.addremove = true;
 492                 ss.anonymous = true;
 493                 ss.sortable  = true;
 494                 ss.rowcolors = true;
 495                 ss.nodescriptions = true;
 496
 497                 so = ss.option(form.Value, 'local_addr', _('Relay from'));
 498                 so.rmempty = false;
 499                 so.datatype = 'ipaddr';
 500
 501                 for (var family = 4; family <= 6; family += 2) {
 502                         for (var i = 0; i < networks.length; i++) {
 503                                 if (networks[i].getName() != 'loopback') {
 504                                         var addrs = (family == 6) ? networks[i].getIP6Addrs() : networks[i].getIPAddrs();
 505                                         for (var j = 0; j < addrs.length; j++) {
 506                                                 var addr = addrs[j].split('/')[0];
 507                                                 so.value(addr, E([], [
 508                                                         addr, ' (',
 509                                                         widgets.NetworkSelect.prototype.renderIfaceBadge(networks[i]),
 510                                                         ')'
 511                                                 ]));
 512                                         }
 513                                 }
 514                         }
 515                 }
 516
 517                 so = ss.option(form.Value, 'server_addr', _('Relay to address'));
 518                 so.rmempty = false;
 519                 so.optional = false;
 520                 so.placeholder = '192.168.10.1#535';
 521
 522                 so.validate = function(section, value) {
 523                         var m = this.section.formvalue(section, 'local_addr'),
 524                             n = this.section.formvalue(section, 'server_addr'),
 525                             p;
 526
 527                         if (!m || !n) {
 528                                 return _('Both "Relay from" and "Relay to address" must be specified.');
 529                         }
 530                         else {
 531                                 p = n.split('#');
 532                                 if (p.length > 1 && !/^[0-9]+$/.test(p[1]))
 533                                         return _('Expected port number.');
 534                                 else
 535                                         n = p[0];
 536
 537                                 if ((validation.parseIPv6(m) && validation.parseIPv6(n)) ||
 538                                         validation.parseIPv4(m) && validation.parseIPv4(n))
 539                                         return true;
 540                                 else
 541                                         return _('Address families of "Relay from" and "Relay to address" must match.')
 542                         }
 543                         return true;
 544                 };
 545
 546
 547                 so = ss.option(widgets.NetworkSelect, 'interface', _('Only accept replies via'));
 548                 so.optional = true;
 549                 so.rmempty = false;
 550                 so.placeholder = 'lan';
 551
 552                 s.taboption('files', form.Flag, 'readethers',
 553                         customi18n(_('Use {etc_ethers}') ),
 554                         customi18n(_('Read {etc_ethers} to configure the DHCP server.') )
 555                         );
 556
 557                 s.taboption('files', form.Value, 'leasefile',
 558                         _('Lease file'),
 559                         _('File to store DHCP lease information.'));
 560
 561                 o = s.taboption('files', form.Flag, 'noresolv',
 562                         _('Ignore resolv file'));
 563                 o.optional = true;
 564
 565                 o = s.taboption('files', form.Value, 'resolvfile',
 566                         _('Resolv file'),
 567                         _('File with upstream resolvers.'));
 568                 o.depends('noresolv', '0');
 569                 o.placeholder = '/tmp/resolv.conf.d/resolv.conf.auto';
 570                 o.optional = true;
 571
 572                 o = s.taboption('files', form.Flag, 'strictorder',
 573                         _('Strict order'),
 574                         _('Query upstream resolvers in the order they appear in the resolv file.'));
 575                 o.optional = true;
 576
 577                 o = s.taboption('files', form.Flag, 'nohosts',
 578                         customi18n(_('Ignore {etc_hosts}') )
 579                 );
 580                 o.optional = true;
 581
 582                 o = s.taboption('files', form.DynamicList, 'addnhosts',
 583                         _('Additional hosts files'));
 584                 o.optional = true;
 585                 o.placeholder = '/etc/dnsmasq.hosts';
 586
 587                 o = s.taboption('logging', form.Flag, 'quietdhcp',
 588                         _('Suppress logging'),
 589                         _('Suppress logging of the routine operation for the DHCP protocol.'));
 590                 o.optional = true;
 591                 o.depends('logdhcp', '0');
 592
 593                 o = s.taboption('general', form.Flag, 'sequential_ip',
 594                         _('Allocate IPs sequentially'),
 595                         _('Allocate IP addresses sequentially, starting from the lowest available address.'));
 596                 o.optional = true;
 597
 598                 o = s.taboption('filteropts', form.Flag, 'boguspriv',
 599                         _('Filter private'),
 600                         customi18n(
 601                         _('Reject reverse lookups to {rfc_6303_link} IP ranges ({reverse_arpa}) not in {etc_hosts}.') )
 602                 );
 603                 o.default = o.enabled;
 604
 605                 s.taboption('filteropts', form.Flag, 'filterwin2k',
 606                         _('Filter SRV/SOA service discovery'),
 607                         _('Filters SRV/SOA service discovery, to avoid triggering dial-on-demand links.') + '<br />' +
 608                         _('May prevent VoIP or other services from working.'));
 609
 610                 o = s.taboption('filteropts', form.Flag, 'filter_aaaa',
 611                         _('Filter IPv6 AAAA records'),
 612                         _('Remove IPv6 addresses from the results and only return IPv4 addresses.') + '<br />' +
 613                         _('Can be useful if ISP has IPv6 nameservers but does not provide IPv6 routing.'));
 614                 o.optional = true;
 615
 616                 o = s.taboption('filteropts', form.Flag, 'filter_a',
 617                         _('Filter IPv4 A records'),
 618                         _('Remove IPv4 addresses from the results and only return IPv6 addresses.'));
 619                 o.optional = true;
 620
 621                 s.taboption('filteropts', form.Flag, 'localise_queries',
 622                         _('Localise queries'),
 623                         customi18n(_('Limit response records (from {etc_hosts}) to those that fall within the subnet of the querying interface.') ) + '<br />' +
 624                         _('This prevents unreachable IPs in subnets not accessible to you.') + '<br />' +
 625                         _('Note: IPv4 only.'));
 626
 627                 if (L.hasSystemFeature('dnsmasq', 'dnssec')) {
 628                         o = s.taboption('dnssecopt', form.Flag, 'dnssec',
 629                                 _('DNSSEC'),
 630                                 _('Validate DNS replies and cache DNSSEC data, requires upstream to support DNSSEC.'));
 631                         o.optional = true;
 632
 633                         o = s.taboption('dnssecopt', form.Flag, 'dnsseccheckunsigned',
 634                                 _('DNSSEC check unsigned'),
 635                                 _('Verify unsigned domain responses really come from unsigned domains.'));
 636                         o.default = o.enabled;
 637                         o.optional = true;
 638                 }
 639
 640                 s.taboption('filteropts', form.Flag, 'nonegcache',
 641                         _('No negative cache'),
 642                         _('Do not cache negative replies, e.g. for non-existent domains.'));
 643
 644                 o = s.taboption('forward', form.Value, 'serversfile',
 645                         _('Additional servers file'),
 646                         customi18n(_('File listing upstream resolvers, optionally domain-specific, e.g. {servers_file_entry01}, {servers_file_entry02}.') )
 647                 );
 648                 o.placeholder = '/etc/dnsmasq.servers';
 649
 650                 o = s.taboption('general', form.Flag, 'allservers',
 651                         _('All servers'),
 652                         _('Query all available upstream resolvers.') + ' ' + _('First answer wins.'));
 653                 o.optional = true;
 654
 655                 o = s.taboption('filteropts', form.DynamicList, 'bogusnxdomain',
 656                         customi18n(_('IPs to override with {nxdomain}') ),
 657                         customi18n(_('Transform replies which contain the specified addresses or subnets into {nxdomain} responses.') )
 658                 );
 659                 o.optional = true;
 660                 o.placeholder = '64.94.110.11';
 661
 662                 o = s.taboption('devices', form.Value, 'port',
 663                         _('DNS server port'),
 664                         _('Listening port for inbound DNS queries.'));
 665                 o.optional = true;
 666                 o.datatype = 'port';
 667                 o.placeholder = 53;
 668
 669                 o = s.taboption('devices', form.Value, 'queryport',
 670                         _('DNS query port'),
 671                         _('Fixed source port for outbound DNS queries.'));
 672                 o.optional = true;
 673                 o.datatype = 'port';
 674                 o.placeholder = _('any');
 675
 676                 o = s.taboption('limits', form.Value, 'dhcpleasemax',
 677                         _('Max. DHCP leases'),
 678                         _('Maximum allowed number of active DHCP leases.'));
 679                 o.optional = true;
 680                 o.datatype = 'uinteger';
 681                 o.placeholder = 150;
 682
 683                 o = s.taboption('limits', form.Value, 'ednspacket_max',
 684                         _('Max. EDNS0 packet size'),
 685                         _('Maximum allowed size of EDNS0 UDP packets.'));
 686                 o.optional = true;
 687                 o.datatype = 'uinteger';
 688                 o.placeholder = 1280;
 689
 690                 o = s.taboption('limits', form.Value, 'dnsforwardmax',
 691                         _('Max. concurrent queries'),
 692                         _('Maximum allowed number of concurrent DNS queries.'));
 693                 o.optional = true;
 694                 o.datatype = 'uinteger';
 695                 o.placeholder = 150;
 696
 697                 o = s.taboption('limits', form.Value, 'cachesize',
 698                         _('Size of DNS query cache'),
 699                         _('Number of cached DNS entries, 10000 is maximum, 0 is no caching.'));
 700                 o.optional = true;
 701                 o.datatype = 'range(0,10000)';
 702                 o.placeholder = 1000;
 703
 704                 o = s.taboption('limits', form.Value, 'min_cache_ttl',
 705                         _('Min cache TTL'),
 706                         _('Extend short TTL values to the seconds value given when caching them. Use with caution.') +
 707                         _(' (Max 1h == 3600)'));
 708                 o.optional = true;
 709                 o.placeholder = 60;
 710
 711                 o = s.taboption('limits', form.Value, 'max_cache_ttl',
 712                         _('Max cache TTL'),
 713                         _('Set a maximum seconds TTL value for entries in the cache.'));
 714                 o.optional = true;
 715                 o.placeholder = 3600;
 716
 717                 o = s.taboption('pxe_tftp', form.Flag, 'enable_tftp',
 718                         _('Enable TFTP server'),
 719                         _('Enable the built-in single-instance TFTP server.'));
 720                 o.optional = true;
 721
 722                 o = s.taboption('pxe_tftp', form.Value, 'tftp_root',
 723                         _('TFTP server root'),
 724                         _('Root directory for files served via TFTP. <em>Enable TFTP server</em> and <em>TFTP server root</em> turn on the TFTP server and serve files from <em>TFTP server root</em>.'));
 725                 o.depends('enable_tftp', '1');
 726                 o.optional = true;
 727                 o.placeholder = '/';
 728
 729                 o = s.taboption('pxe_tftp', form.Value, 'dhcp_boot',
 730                         _('Network boot image'),
 731                         _('Filename of the boot image advertised to clients.'));
 732                 o.depends('enable_tftp', '1');
 733                 o.optional = true;
 734                 o.placeholder = 'pxelinux.0';
 735
 736                 /* PXE - https://openwrt.org/docs/guide-user/base-system/dhcp#booting_options */
 737                 o = s.taboption('pxe_tftp', form.SectionValue, '__pxe__', form.GridSection, 'boot', null,
 738                         _('Special <abbr title="Preboot eXecution Environment">PXE</abbr> boot options for Dnsmasq.'));
 739                 ss = o.subsection;
 740                 ss.addremove = true;
 741                 ss.anonymous = true;
 742                 ss.nodescriptions = true;
 743
 744                 so = ss.option(form.Value, 'filename',
 745                         _('Filename'),
 746                         _('Host requests this filename from the boot server.'));
 747                 so.optional = false;
 748                 so.placeholder = 'pxelinux.0';
 749
 750                 so = ss.option(form.Value, 'servername',
 751                         _('Server name'),
 752                         _('The hostname of the boot server'));
 753                 so.optional = false;
 754                 so.placeholder = 'myNAS';
 755
 756                 so = ss.option(form.Value, 'serveraddress',
 757                         _('Server address'),
 758                         _('The IP address of the boot server'));
 759                 so.optional = false;
 760                 so.placeholder = '192.168.1.2';
 761
 762                 so = ss.option(form.DynamicList, 'dhcp_option',
 763                         _('DHCP Options'),
 764                         _('Options for the Network-ID. (Note: needs also Network-ID.) E.g. "<code>42,192.168.1.4</code>" for NTP server, "<code>3,192.168.4.4</code>" for default route. <code>0.0.0.0</code> means "the address of the system running dnsmasq".'));
 765                 so.optional = true;
 766                 so.placeholder = '42,192.168.1.4';
 767
 768                 so = ss.option(widgets.DeviceSelect, 'networkid',
 769                         _('Network-ID'),
 770                         _('Apply DHCP Options to this net. (Empty = all clients).'));
 771                 so.optional = true;
 772                 so.noaliases = true;
 773
 774                 so = ss.option(form.Flag, 'force',
 775                         _('Force'),
 776                         _('Always send DHCP Options. Sometimes needed, with e.g. PXELinux.'));
 777                 so.optional = true;
 778
 779                 so = ss.option(form.Value, 'instance',
 780                         _('Instance'),
 781                         _('Dnsmasq instance to which this boot section is bound. If unspecified, the section is valid for all dnsmasq instances.'));
 782                 so.optional = true;
 783
 784                 Object.values(L.uci.sections('dhcp', 'dnsmasq')).forEach(function(val, index) {
 785                         so.value(generateDnsmasqInstanceEntry(val));
 786                 });
 787
 788                 o = s.taboption('srvhosts', form.SectionValue, '__srvhosts__', form.TableSection, 'srvhost', null,
 789                         _('Bind service records to a domain name: specify the location of services. See <a href="%s">RFC2782</a>.').format('https://datatracker.ietf.org/doc/html/rfc2782')
 790                         + '<br />' + _('_service: _sip, _ldap, _imap, _stun, _xmpp-client, … . (Note: while _http is possible, no browsers support SRV records.)')
 791                         + '<br />' + _('_proto: _tcp, _udp, _sctp, _quic, … .')
 792                         + '<br />' + _('You may add multiple records for the same Target.')
 793                         + '<br />' + _('Larger weights (of the same prio) are given a proportionately higher probability of being selected.'));
 794
 795                 ss = o.subsection;
 796
 797                 ss.addremove = true;
 798                 ss.anonymous = true;
 799                 ss.sortable  = true;
 800                 ss.rowcolors = true;
 801
 802                 so = ss.option(form.Value, 'srv', _('SRV'), _('Syntax:') + ' ' + '<code>_service._proto.example.com.</code>');
 803                 so.rmempty = false;
 804                 so.datatype = 'hostname';
 805                 so.placeholder = '_sip._tcp.example.com.';
 806
 807                 so = ss.option(form.Value, 'target', _('Target'), _('CNAME or fqdn'));
 808                 so.rmempty = false;
 809                 so.datatype = 'hostname';
 810                 so.placeholder = 'sip.example.com.';
 811
 812                 so = ss.option(form.Value, 'port', _('Port'));
 813                 so.rmempty = false;
 814                 so.datatype = 'port';
 815                 so.placeholder = '5060';
 816
 817                 so = ss.option(form.Value, 'class', _('Priority'), _('Ordinal: lower comes first.'));
 818                 so.rmempty = true;
 819                 so.datatype = 'range(0,65535)';
 820                 so.placeholder = '10';
 821
 822                 so = ss.option(form.Value, 'weight', _('Weight'));
 823                 so.rmempty = true;
 824                 so.datatype = 'range(0,65535)';
 825                 so.placeholder = '50';
 826
 827                 o = s.taboption('mxhosts', form.SectionValue, '__mxhosts__', form.TableSection, 'mxhost', null,
 828                         _('Bind service records to a domain name: specify the location of services.')
 829                          + '<br />' + _('You may add multiple records for the same domain.'));
 830
 831                 ss = o.subsection;
 832
 833                 ss.addremove = true;
 834                 ss.anonymous = true;
 835                 ss.sortable  = true;
 836                 ss.rowcolors = true;
 837                 ss.nodescriptions = true;
 838
 839                 so = ss.option(form.Value, 'domain', _('Domain'));
 840                 so.rmempty = false;
 841                 so.datatype = 'hostname';
 842                 so.placeholder = 'example.com.';
 843
 844                 so = ss.option(form.Value, 'relay', _('Relay'));
 845                 so.rmempty = false;
 846                 so.datatype = 'hostname';
 847                 so.placeholder = 'relay.example.com.';
 848
 849                 so = ss.option(form.Value, 'pref', _('Priority'), _('Ordinal: lower comes first.'));
 850                 so.rmempty = true;
 851                 so.datatype = 'range(0,65535)';
 852                 so.placeholder = '0';
 853
 854                 o = s.taboption('cnamehosts', form.SectionValue, '__cname__', form.TableSection, 'cname', null,
 855                         _('Set an alias for a hostname.'));
 856
 857                 ss = o.subsection;
 858
 859                 ss.addremove = true;
 860                 ss.anonymous = true;
 861                 ss.sortable  = true;
 862                 ss.rowcolors = true;
 863                 ss.nodescriptions = true;
 864
 865                 so = ss.option(form.Value, 'cname', _('Domain'));
 866                 so.rmempty = false;
 867                 so.datatype = 'hostname';
 868                 so.placeholder = 'www.example.com.';
 869
 870                 so = ss.option(form.Value, 'target', _('Target'));
 871                 so.rmempty = false;
 872                 so.datatype = 'hostname';
 873                 so.placeholder = 'example.com.';
 874
 875                 o = s.taboption('hosts', form.SectionValue, '__hosts__', form.GridSection, 'domain', null,
 876                         _('Hostnames are used to bind a domain name to an IP address. This setting is redundant for hostnames already configured with static leases, but it can be useful to rebind an FQDN.'));
 877
 878                 ss = o.subsection;
 879
 880                 ss.addremove = true;
 881                 ss.anonymous = true;
 882                 ss.sortable  = true;
 883
 884                 so = ss.option(form.Value, 'name', _('Hostname'));
 885                 so.rmempty = false;
 886                 so.datatype = 'hostname';
 887
 888                 so = ss.option(form.Value, 'ip', _('IP address'));
 889                 so.rmempty = false;
 890                 so.datatype = 'ipaddr';
 891
 892                 var ipaddrs = {};
 893
 894                 Object.keys(hosts).forEach(function(mac) {
 895                         var addrs = L.toArray(hosts[mac].ipaddrs || hosts[mac].ipv4);
 896
 897                         for (var i = 0; i < addrs.length; i++)
 898                                 ipaddrs[addrs[i]] = hosts[mac].name || mac;
 899                 });
 900
 901                 L.sortedKeys(ipaddrs, null, 'addr').forEach(function(ipv4) {
 902                         so.value(ipv4, '%s (%s)'.format(ipv4, ipaddrs[ipv4]));
 903                 });
 904
 905                 o = s.taboption('ipsets', form.SectionValue, '__ipsets__', form.GridSection, 'ipset', null,
 906                         _('List of IP sets to populate with the IPs of DNS lookup results of the FQDNs also specified here.') + '<br />' +
 907                         _('The netfilter components below are only regarded when running fw4.'));
 908
 909                 ss = o.subsection;
 910
 911                 ss.addremove = true;
 912                 ss.anonymous = true;
 913                 ss.sortable  = true;
 914                 ss.rowcolors = true;
 915                 ss.nodescriptions = true;
 916                 ss.modaltitle = _('Edit IP set');
 917
 918                 so = ss.option(form.DynamicList, 'name', _('Name of the set'));
 919                 so.rmempty = false;
 920                 so.editable = true;
 921                 so.datatype = 'string';
 922
 923                 so = ss.option(form.DynamicList, 'domain', _('FQDN'));
 924                 so.rmempty = false;
 925                 so.editable = true;
 926                 so.datatype = 'hostname';
 927
 928                 so = ss.option(form.Value, 'table', _('Netfilter table name'), _('Defaults to fw4.'));
 929                 so.editable = true;
 930                 so.placeholder = 'fw4';
 931                 so.rmempty = true;
 932
 933                 so = ss.option(form.ListValue, 'table_family', _('Table IP family'), _('Defaults to IPv4+6.') + ' ' + _('Can be hinted by adding 4 or 6 to the name.') + '<br />' +
 934                         _('Adding an IPv6 to an IPv4 set and vice-versa silently fails.'));
 935                 so.editable = true;
 936                 so.rmempty = true;
 937                 so.value('inet', _('IPv4+6'));
 938                 so.value('ip', _('IPv4'));
 939                 so.value('ip6', _('IPv6'));
 940
 941                 o = s.taboption('leases', form.SectionValue, '__leases__', form.GridSection, 'host', null,
 942                         _('Static leases are used to assign fixed IP addresses and symbolic hostnames to DHCP clients. They are also required for non-dynamic interface configurations where only hosts with a corresponding lease are served.') + '<br /><br />' +
 943                         _('Use the <em>Add</em> Button to add a new lease entry. The <em>MAC address</em> identifies the host, the <em>IPv4 address</em> specifies the fixed address to use, and the <em>Hostname</em> is assigned as a symbolic name to the requesting host. The optional <em>Lease time</em> can be used to set non-standard host-specific lease time, e.g. 12h, 3d or infinite.') + '<br /><br />' +
 944                         _('The tag construct filters which host directives are used; more than one tag can be provided, in this case the request must match all of them. Tagged directives are used in preference to untagged ones. Note that one of mac, duid or hostname still needs to be specified (can be a wildcard).'));
 945
 946                 ss = o.subsection;
 947
 948                 ss.addremove = true;
 949                 ss.anonymous = true;
 950                 ss.sortable = true;
 951                 ss.nodescriptions = true;
 952                 ss.max_cols = 8;
 953                 ss.modaltitle = _('Edit static lease');
 954
 955                 so = ss.option(form.Value, 'name',
 956                         _('Hostname'),
 957                         _('Optional hostname to assign'));
 958                 so.validate = validateHostname;
 959                 so.rmempty  = true;
 960                 so.write = function(section, value) {
 961                         uci.set('dhcp', section, 'name', value);
 962                         uci.set('dhcp', section, 'dns', '1');
 963                 };
 964                 so.remove = function(section) {
 965                         uci.unset('dhcp', section, 'name');
 966                         uci.unset('dhcp', section, 'dns');
 967                 };
 968
 969                 //this can be a .DynamicList or a .Value with a widget and dnsmasq handles multimac OK.
 970                 so = ss.option(form.DynamicList, 'mac',
 971                         _('MAC address(es)'),
 972                         _('The hardware address(es) of this entry/host.') + '<br /><br />' +
 973                         _('In DHCPv4, it is possible to include more than one mac address. This allows an IP address to be associated with multiple macaddrs, and dnsmasq abandons a DHCP lease to one of the macaddrs when another asks for a lease. It only works reliably if only one of the macaddrs is active at any time.'));
 974                 //As a special case, in DHCPv4, it is possible to include more than one hardware address. eg: --dhcp-host=11:22:33:44:55:66,12:34:56:78:90:12,192.168.0.2 This allows an IP address to be associated with multiple hardware addresses, and gives dnsmasq permission to abandon a DHCP lease to one of the hardware addresses when another one asks for a lease
 975                 so.rmempty  = true;
 976                 so.cfgvalue = function(section) {
 977                         var macs = L.toArray(uci.get('dhcp', section, 'mac'));
 978                         return expandAndFormatMAC(macs);
 979                 };
 980                 //removed jows renderwidget function which hindered multi-mac entry
 981                 so.validate = validateMACAddr.bind(so, pools);
 982                 Object.keys(hosts).forEach(function(mac) {
 983                         var hint = hosts[mac].name || L.toArray(hosts[mac].ipaddrs || hosts[mac].ipv4)[0];
 984                         so.value(mac, hint ? '%s (%s)'.format(mac, hint) : mac);
 985                 });
 986
 987                 so = ss.option(form.Value, 'ip', _('IPv4 address'), _('The IP address to be used for this host, or <em>ignore</em> to ignore any DHCP request from this host.'));
 988                 so.value('ignore', _('Ignore'));
 989                 so.datatype = 'or(ip4addr,"ignore")';
 990                 so.validate = function(section, value) {
 991                         var m = this.section.formvalue(section, 'mac'),
 992                             n = this.section.formvalue(section, 'name');
 993
 994                         if ((m && !m.length > 0) && !n)
 995                                 return _('One of hostname or MAC address must be specified!');
 996
 997                         if (!value || value == 'ignore')
 998                                 return true;
 999
1000                         var leases = uci.sections('dhcp', 'host');
1001
1002                         for (var i = 0; i < leases.length; i++)
1003                                 if (leases[i]['.name'] != section && leases[i].ip == value)
1004                                         return _('The IP address %h is already used by another static lease').format(value);
1005
1006                         for (var i = 0; i < pools.length; i++) {
1007                                 var net_mask = calculateNetwork(value, pools[i].netmask);
1008
1009                                 if (net_mask && net_mask[0] == pools[i].network)
1010                                         return true;
1011                         }
1012
1013                         return _('The IP address is outside of any DHCP pool address range');
1014                 };
1015
1016                 L.sortedKeys(ipaddrs, null, 'addr').forEach(function(ipv4) {
1017                         so.value(ipv4, ipaddrs[ipv4] ? '%s (%s)'.format(ipv4, ipaddrs[ipv4]) : ipv4);
1018                 });
1019
1020                 so = ss.option(form.Value, 'leasetime',
1021                         _('Lease time'),
1022                         _('Host-specific lease time, e.g. <code>5m</code>, <code>3h</code>, <code>7d</code>.'));
1023                 so.rmempty = true;
1024                 so.value('5m', _('5m (5 minutes)'));
1025                 so.value('3h', _('3h (3 hours)'));
1026                 so.value('12h', _('12h (12 hours - default)'));
1027                 so.value('7d', _('7d (7 days)'));
1028                 so.value('infinite', _('infinite (lease does not expire)'));
1029
1030                 so = ss.option(form.Value, 'duid',
1031                         _('DUID'),
1032                         _('The DHCPv6-DUID (DHCP unique identifier) of this host.'));
1033                 so.datatype = 'and(rangelength(20,36),hexstring)';
1034                 Object.keys(duids).forEach(function(duid) {
1035                         so.value(duid, '%s (%s)'.format(duid, duids[duid].hostname || duids[duid].macaddr || duids[duid].ip6addr || '?'));
1036                 });
1037
1038                 so = ss.option(form.Value, 'hostid',
1039                         _('IPv6-Suffix (hex)'),
1040                         _('The IPv6 interface identifier (address suffix) as hexadecimal number (max. 16 chars).'));
1041                 so.datatype = 'and(rangelength(0,16),hexstring)';
1042
1043                 so = ss.option(form.DynamicList, 'tag',
1044                         _('Tag'),
1045                         _('Assign new, freeform tags to this entry.'));
1046
1047                 so = ss.option(form.DynamicList, 'match_tag',
1048                         _('Match Tag'),
1049                         _('When a host matches an entry then the special tag %s is set. Use %s to match all known hosts.').format('<code>known</code>', '<code>known</code>') + '<br /><br />' +
1050                         _('Ignore requests from unknown machines using %s.').format('<code>!known</code>') + '<br /><br />' +
1051                         _('If a host matches an entry which cannot be used because it specifies an address on a different subnet, the tag %s is set.').format('<code>known-othernet</code>'));
1052                 so.value('known', _('known'));
1053                 so.value('!known', _('!known (not known)'));
1054                 so.value('known-othernet', _('known-othernet (on different subnet)'));
1055                 so.optional = true;
1056
1057                 so = ss.option(form.Value, 'instance',
1058                         _('Instance'),
1059                         _('Dnsmasq instance to which this DHCP host section is bound. If unspecified, the section is valid for all dnsmasq instances.'));
1060                 so.optional = true;
1061
1062                 Object.values(L.uci.sections('dhcp', 'dnsmasq')).forEach(function(val, index) {
1063                         so.value(generateDnsmasqInstanceEntry(val));
1064                 });
1065
1066
1067                 so = ss.option(form.Flag, 'broadcast',
1068                         _('Broadcast'),
1069                         _('Force broadcast DHCP response.'));
1070
1071                 so = ss.option(form.Flag, 'dns',
1072                         _('Forward/reverse DNS'),
1073                         _('Add static forward and reverse DNS entries for this host.'));
1074
1075                 o = s.taboption('leases', CBILeaseStatus, '__status__');
1076
1077                 if (has_dhcpv6)
1078                         o = s.taboption('leases', CBILease6Status, '__status6__');
1079
1080                 return m.render().then(function(mapEl) {
1081                         poll.add(function() {
1082                                 return callDHCPLeases().then(function(leaseinfo) {
1083                                         var leases = Array.isArray(leaseinfo.dhcp_leases) ? leaseinfo.dhcp_leases : [],
1084                                             leases6 = Array.isArray(leaseinfo.dhcp6_leases) ? leaseinfo.dhcp6_leases : [];
1085
1086                                         cbi_update_table(mapEl.querySelector('#lease_status_table'),
1087                                                 leases.map(function(lease) {
1088                                                         var exp;
1089
1090                                                         if (lease.expires === false)
1091                                                                 exp = E('em', _('unlimited'));
1092                                                         else if (lease.expires <= 0)
1093                                                                 exp = E('em', _('expired'));
1094                                                         else
1095                                                                 exp = '%t'.format(lease.expires);
1096
1097                                                         var hint = lease.macaddr ? hosts[lease.macaddr] : null,
1098                                                             name = hint ? hint.name : null,
1099                                                             host = null;
1100
1101                                                         if (name && lease.hostname && lease.hostname != name)
1102                                                                 host = '%s (%s)'.format(lease.hostname, name);
1103                                                         else if (lease.hostname)
1104                                                                 host = lease.hostname;
1105
1106                                                         return [
1107                                                                 host || '-',
1108                                                                 lease.ipaddr,
1109                                                                 lease.macaddr,
1110                                                                 exp
1111                                                         ];
1112                                                 }),
1113                                                 E('em', _('There are no active leases')));
1114
1115                                         if (has_dhcpv6) {
1116                                                 cbi_update_table(mapEl.querySelector('#lease6_status_table'),
1117                                                         leases6.map(function(lease) {
1118                                                                 var exp;
1119
1120                                                                 if (lease.expires === false)
1121                                                                         exp = E('em', _('unlimited'));
1122                                                                 else if (lease.expires <= 0)
1123                                                                         exp = E('em', _('expired'));
1124                                                                 else
1125                                                                         exp = '%t'.format(lease.expires);
1126
1127                                                                 var hint = lease.macaddr ? hosts[lease.macaddr] : null,
1128                                                                     name = hint ? (hint.name || L.toArray(hint.ipaddrs || hint.ipv4)[0] || L.toArray(hint.ip6addrs || hint.ipv6)[0]) : null,
1129                                                                     host = null;
1130
1131                                                                 if (name && lease.hostname && lease.hostname != name && lease.ip6addr != name)
1132                                                                         host = '%s (%s)'.format(lease.hostname, name);
1133                                                                 else if (lease.hostname)
1134                                                                         host = lease.hostname;
1135                                                                 else if (name)
1136                                                                         host = name;
1137
1138                                                                 return [
1139                                                                         host || '-',
1140                                                                         lease.ip6addrs ? lease.ip6addrs.join(' ') : lease.ip6addr,
1141                                                                         lease.duid,
1142                                                                         exp
1143                                                                 ];
1144                                                         }),
1145                                                         E('em', _('There are no active leases')));
1146                                         }
1147                                 });
1148                         });
1149
1150                         return mapEl;
1151                 });
1152         }
1153 });