-{%
-
let fs = require("fs");
let uci = require("uci");
let ubus = require("ubus");
"CS6": 0x30,
"CS7": 0x38,
"BE": 0x00,
+ "LE": 0x01,
"AF11": 0x0a,
"AF12": 0x0c,
"AF13": 0x0e,
return length(rv) ? rv : null;
}
-function filter_neg_nonwildcard(x) {
- let rv = filter(x, e => e.invert && !e.wildcard);
- return length(rv) ? rv : null;
-}
-
-function filter_neg_wildcard(x) {
- let rv = filter(x, e => e.invert && e.wildcard);
- return length(rv) ? rv : null;
+function null_if_empty(x) {
+ return length(x) ? x : null;
}
function subnets_split_af(x) {
- let rv = [];
+ let rv = {};
for (let ag in to_array(x)) {
for (let a in filter(ag.addrs, a => (a.family == 4))) {
}
}
+ if (rv[0] || rv[1])
+ rv.family = (!rv[0] ^ !rv[1]) ? (rv[0] ? 4 : 6) : 0;
+
return rv;
}
+function subnets_group_by_masking(x) {
+ let groups = [], plain = [], nc = [], invert_plain = [], invert_masked = [];
+
+ for (let a in to_array(x)) {
+ if (a.bits == -1 && !a.invert)
+ push(nc, a);
+ else if (!a.invert)
+ push(plain, a);
+ else if (a.bits == -1)
+ push(invert_masked, a);
+ else
+ push(invert_plain, a);
+ }
+
+ for (let a in nc)
+ push(groups, [ null, null_if_empty(invert_plain), [ a, ...invert_masked ] ]);
+
+ if (length(plain)) {
+ push(groups, [
+ plain,
+ null_if_empty(invert_plain),
+ null_if_empty(invert_masked)
+ ]);
+ }
+ else if (!length(groups)) {
+ push(groups, [
+ null,
+ null_if_empty(invert_plain),
+ null_if_empty(invert_masked)
+ ]);
+ }
+
+ return groups;
+}
+
function ensure_tcpudp(x) {
if (length(filter(x, p => (p.name == "tcp" || p.name == "udp"))))
return true;
if (!obj || !obj.family || obj.family == res)
continue;
- if (res == 0) {
+ if (!res) {
res = obj.family;
by = obj.desc;
continue;
return fields;
}
+function resolve_lower_devices(devstatus, devname) {
+ let dir = fs.opendir("/sys/class/net/" + devname);
+ let devs = [];
+
+ if (dir) {
+ if (!devstatus || devstatus[devname]?.["hw-tc-offload"]) {
+ push(devs, devname);
+ }
+ else {
+ let e;
+
+ while ((e = dir.read()) != null)
+ if (index(e, "lower_") === 0)
+ push(devs, ...resolve_lower_devices(devstatus, substr(e, 6)));
+ }
+
+ dir.close();
+ }
+
+ return devs;
+}
+
+function nft_json_command(...args) {
+ let cmd = [ "/usr/sbin/nft", "--terse", "--json", ...args ];
+ let nft = fs.popen(join(" ", cmd), "r");
+ let info;
+
+ if (nft) {
+ try {
+ info = filter(json(nft.read("all"))?.nftables,
+ item => (type(item) == "object" && !item.metainfo));
+ }
+ catch (e) {
+ warn(sprintf("Unable to parse nftables JSON output: %s\n", e));
+ }
+
+ nft.close();
+ }
+ else {
+ warn(sprintf("Unable to popen() %s: %s\n", cmd, fs.error()));
+ }
+
+ return info || [];
+}
+
+function nft_try_hw_offload(devices) {
+ let nft_test =
+ 'add table inet fw4-hw-offload-test; ' +
+ 'add flowtable inet fw4-hw-offload-test ft { ' +
+ 'hook ingress priority 0; ' +
+ 'devices = { "' + join('", "', devices) + '" }; ' +
+ 'flags offload; ' +
+ '}';
+
+ let rc = system(sprintf("/usr/sbin/nft -c '%s' 2>/dev/null", replace(nft_test, "'", "'\\''")));
+
+ return (rc == 0);
+}
+
return {
read_kernel_version: function() {
return v;
},
+ resolve_offload_devices: function() {
+ if (!this.default_option("flow_offloading"))
+ return [];
+
+ let devstatus = null;
+ let devices = [];
+
+ if (this.default_option("flow_offloading_hw")) {
+ let bus = ubus.connect();
+
+ if (bus) {
+ devstatus = bus.call("network.device", "status") || {};
+ bus.disconnect();
+ }
+
+ for (let zone in this.zones())
+ for (let device in zone.related_physdevs)
+ push(devices, ...resolve_lower_devices(devstatus, device));
+
+ devices = uniq(devices);
+
+ if (nft_try_hw_offload(devices))
+ return devices;
+
+ this.warn('Hardware flow offloading unavailable, falling back to software offloading');
+ this.state.defaults.flow_offloading_hw = false;
+
+ devices = [];
+ }
+
+ for (let zone in this.zones())
+ for (let device in zone.match_devices)
+ push(devices, ...resolve_lower_devices(null, device));
+
+ return uniq(devices);
+ },
+
+ check_set_types: function() {
+ let sets = {};
+
+ for (let item in nft_json_command("list", "sets", "inet"))
+ if (item.set?.table == "fw4")
+ sets[item.set.name] = (type(item.set.type) == "array") ? item.set.type : [ item.set.type ];
+
+ return sets;
+ },
+
+ check_flowtable: function() {
+ for (let item in nft_json_command("list", "flowtables", "inet"))
+ if (item.flowtable?.table == "fw4" && item.flowtable?.name == "ft")
+ return true;
+
+ return false;
+ },
+
read_state: function() {
let fd = fs.open(STATEFILE, "r");
let state = null;
let net = {
up: ifc.up,
device: ifc.l3_device,
+ physdev: ifc.device,
zone: ifc.data?.zone
};
//
- // Build list of forwardings
+ // Build list of rules
//
- this.cursor.foreach("firewall", "forwarding", f => self.parse_forwarding(f));
+ map(filter(this.state.ubus_rules, r => (r.type == "rule")), r => self.parse_rule(r));
+ this.cursor.foreach("firewall", "rule", r => self.parse_rule(r));
//
- // Build list of rules
+ // Build list of forwardings
//
- map(filter(this.state.ubus_rules, r => (r.type == "rule")), r => self.parse_rule(r));
- this.cursor.foreach("firewall", "rule", r => self.parse_rule(r));
+ this.cursor.foreach("firewall", "forwarding", f => self.parse_forwarding(f));
//
b = to_bits(parts[1]);
- if (b == null)
- return null;
+ /* allow non-contiguous masks such as `::ffff:ffff:ffff:ffff` */
+ if (b == null) {
+ b = -1;
+
+ for (let i, x in m)
+ a[i] &= x;
+ }
m = arrtoip(m);
}
val = lc(val);
for (let i = 0; i < length(choices); i++)
- if (substr(choices[i], 0, length(val)) == val)
+ if (lc(substr(choices[i], 0, length(val))) == val)
return choices[i];
}
parse_direction: function(val) {
if (val == 'in' || val == 'ingress')
- return true;
- else if (val == 'out' || val == 'egress')
return false;
+ else if (val == 'out' || val == 'egress')
+ return true;
return null;
},
let nets = this.parse_subnet(rv.val);
if (nets === null)
- return false;
+ return null;
if (length(nets))
rv.addrs = [ ...nets ];
for (let day in to_array(rv.val)) {
day = this.parse_enum(day, [
- "monday",
- "tuesday",
- "wednesday",
- "thursday",
- "friday",
- "saturday",
- "sunday"
+ "Monday",
+ "Tuesday",
+ "Wednesday",
+ "Thursday",
+ "Friday",
+ "Saturday",
+ "Sunday"
]);
if (!day)
case 'ipv4_addr':
ip = filter(this.parse_subnet(values[i]), a => (a.family == 4));
- switch (length(ip)) {
+ switch (length(ip) ?? 0) {
case 0: return null;
case 1: break;
default: this.warn("Set entry '%s' resolves to multiple addresses, using first one", values[i]);
(a.family == 6 && a.bits == 128))
return a.addr;
- return sprintf("%s/%d", apply_mask(a.addr, a.bits), a.bits);
+ if (a.bits >= 0)
+ return sprintf("%s/%d", apply_mask(a.addr, a.bits), a.bits);
+
+ return sprintf("%s/%s", a.addr, a.mask);
},
- host: function(a) {
+ host: function(a, v6brackets) {
return a.range
? sprintf("%s-%s", a.addr, a.addr2)
- : apply_mask(a.addr, a.bits);
+ : sprintf((a.family == 6 && v6brackets) ? "[%s]" : "%s", apply_mask(a.addr, a.bits));
},
port: function(p) {
}
},
+ l4proto: function(family, proto) {
+ switch (proto.name) {
+ case 'icmp':
+ switch (family ?? 0) {
+ case 0:
+ return this.set(['icmp', 'ipv6-icmp']);
+
+ case 6:
+ return 'ipv6-icmp';
+ }
+
+ default:
+ return proto.name;
+ }
+ },
+
datetime: function(stamp) {
return sprintf('"%04d-%02d-%02d %02d:%02d:%02d"',
stamp.year, stamp.month, stamp.day,
},
filter_loopback_devs: function(devs, invert) {
- let self = this;
- return filter(devs, d => (self.is_loopback_dev(d) == invert));
+ return null_if_empty(filter(devs, d => (this.is_loopback_dev(d) == invert)));
},
filter_loopback_addrs: function(addrs, invert) {
- let self = this;
- return filter(addrs, a => (self.is_loopback_addr(a) == invert));
+ return null_if_empty(filter(addrs, a => (this.is_loopback_addr(a) == invert)));
},
zone.auto_helper = false;
let match_devices = [];
+ let related_physdevs = [];
let related_subnets = [];
let related_ubus_networks = [];
let match_subnets, masq_src_subnets, masq_dest_subnets;
});
}
+ if (net.physdev && !e.invert)
+ push(related_physdevs, net.physdev);
+
push(related_subnets, ...(net.ipaddrs || []));
}
}
r.family = family;
- r.devices_pos = map(filter_pos(devices), d => d.device);
- r.devices_neg = map(filter_neg_nonwildcard(devices), d => d.device);
- r.devices_neg_wildcard = map(filter_neg_wildcard(devices), d => d.device);
+ r.devices_pos = null_if_empty(devices[0]);
+ r.devices_neg = null_if_empty(devices[1]);
+ r.devices_neg_wildcard = null_if_empty(devices[2]);
- r.subnets_pos = map(filter_pos(subnets), this.cidr);
- r.subnets_neg = map(filter_neg(subnets), this.cidr);
+ r.subnets_pos = map(subnets[0], this.cidr);
+ r.subnets_neg = map(subnets[1], this.cidr);
+ r.subnets_masked = subnets[2];
push(match_rules, r);
};
let family = infer_family(zone.family, [
- zone.helper, "ct helper"
+ zone.helper, "ct helper",
+ match_subnets, "subnet list"
]);
+ if (type(family) == "string") {
+ this.warn_section(data, family + ", skipping");
+ return;
+ }
+
// group non-inverted device matches into wildcard and non-wildcard ones
- let wildcard_devices = [], plain_devices = [], match_all_devices = false;
+ let devices = [], plain_devices = [], plain_invert_devices = [], wildcard_invert_devices = [];
for (let device in match_devices) {
let m = match(device.device, /^([^+]*)(\+)?$/);
// filter `+` (match any device) since nftables does not support
// wildcard only matches
- if (!device.invert && m[0] == '+') {
- match_all_devices = true;
+ if (!device.invert && m[0] == '+')
continue;
- }
// replace inverted `+` (match no device) with invalid pattern
if (device.invert && m[0] == '+') {
device.wildcard = !!m[2];
if (!device.invert && device.wildcard)
- push(wildcard_devices, device);
+ push(devices, [ [ device.device ], plain_invert_devices, wildcard_invert_devices ]);
+ else if (!device.invert)
+ push(plain_devices, device.device);
+ else if (device.wildcard)
+ push(wildcard_invert_devices, device.device);
else
- push(plain_devices, device);
+ push(plain_invert_devices, device.device);
}
- // loop wildcard devices
- for (let wildcard_device in wildcard_devices) {
- // cover this wildcard and any inverted wildcard or non-wildcard interface
- let devices = [ wildcard_device, ...(filter_neg(plain_devices) || []) ];
+ if (length(plain_devices))
+ push(devices, [
+ plain_devices,
+ plain_invert_devices,
+ wildcard_invert_devices
+ ]);
+ else if (!length(devices))
+ push(devices, [
+ null,
+ plain_invert_devices,
+ wildcard_invert_devices
+ ]);
- // check if there's no AF specific bits, in this case we can do AF agnostic matching
- if (!family && length(devices) && !length(match_subnets[0]) && !length(match_subnets[1])) {
- add_rule(0, devices, null, zone);
- }
+ // emit zone jump rules for each device group
+ if (length(match_devices) || length(match_subnets[0]) || length(match_subnets[1])) {
+ for (let devgroup in devices) {
+ // check if there's no AF specific bits, in this case we can do AF agnostic matching
+ if (!family && !length(match_subnets[0]) && !length(match_subnets[1])) {
+ add_rule(0, devgroup, [], zone);
+ }
- // we need to emit one or two AF specific rules
- else {
- if (family_is_ipv4(zone) && (length(devices) || length(match_subnets[0])))
- add_rule(4, devices, match_subnets[0], zone);
+ // we need to emit one or two AF specific rules
+ else {
+ if (!family || family == 4)
+ for (let subnets in subnets_group_by_masking(match_subnets[0]))
+ add_rule(4, devgroup, subnets, zone);
- if (family_is_ipv6(zone) && (length(devices) || length(match_subnets[1])))
- add_rule(6, devices, match_subnets[1], zone);
+ if (!family || family == 6)
+ for (let subnets in subnets_group_by_masking(match_subnets[1]))
+ add_rule(6, devgroup, subnets, zone);
+ }
}
}
- // check if there's no AF specific bits, in this case we can do AF agnostic matching
- if (!family && (match_all_devices || length(plain_devices)) && !length(match_subnets[0]) && !length(match_subnets[1])) {
- add_rule(0, plain_devices, null, zone);
- }
-
- // we need to emit one or two AF specific rules
- else {
- if (family_is_ipv4(zone) && (match_all_devices || length(plain_devices) || length(match_subnets[0])))
- add_rule(4, plain_devices, match_subnets[0], zone);
-
- if (family_is_ipv6(zone) && (match_all_devices || length(plain_devices) || length(match_subnets[1])))
- add_rule(6, plain_devices, match_subnets[1], zone);
- }
+ zone.family = family;
zone.match_rules = match_rules;
- if (masq_src_subnets[0]) {
- zone.masq4_src_pos = map(filter_pos(masq_src_subnets[0]), this.cidr);
- zone.masq4_src_neg = map(filter_neg(masq_src_subnets[0]), this.cidr);
- }
-
- if (masq_src_subnets[1]) {
- zone.masq6_src_pos = map(filter_pos(masq_src_subnets[1]), this.cidr);
- zone.masq6_src_neg = map(filter_neg(masq_src_subnets[1]), this.cidr);
- }
+ zone.masq4_src_subnets = subnets_group_by_masking(masq_src_subnets[0]);
+ zone.masq4_dest_subnets = subnets_group_by_masking(masq_dest_subnets[0]);
- if (masq_dest_subnets[0]) {
- zone.masq4_dest_pos = map(filter_pos(masq_dest_subnets[0]), this.cidr);
- zone.masq4_dest_neg = map(filter_neg(masq_dest_subnets[0]), this.cidr);
- }
-
- if (masq_dest_subnets[1]) {
- zone.masq6_dest_pos = map(filter_pos(masq_dest_subnets[1]), this.cidr);
- zone.masq6_dest_neg = map(filter_neg(masq_dest_subnets[1]), this.cidr);
- }
+ zone.masq6_src_subnets = subnets_group_by_masking(masq_src_subnets[1]);
+ zone.masq6_dest_subnets = subnets_group_by_masking(masq_dest_subnets[1]);
zone.sflags = {};
zone.sflags[zone.input] = true;
zone.dflags[zone.forward] = true;
zone.match_devices = map(filter(match_devices, d => !d.invert), d => d.device);
- zone.match_subnets = map(filter(related_subnets, s => !s.invert), this.cidr);
+ zone.match_subnets = map(filter(related_subnets, s => !s.invert && s.bits != -1), this.cidr);
zone.related_subnets = related_subnets;
+ zone.related_physdevs = related_physdevs;
if (zone.masq || zone.masq6)
zone.dflags.snat = true;
let f1 = fwd.src.zone ? fwd.src.zone.family : 0;
let f2 = fwd.dest.zone ? fwd.dest.zone.family : 0;
- if (f1 != 0 && f2 != 0 && f1 != f2) {
+ if (f1 && f2 && f1 != f2) {
this.warn_section(data,
- sprintf("references src %s restricted to %s and dest restricted to %s, ignoring forwarding",
+ sprintf("references src %s restricted to %s and dest %s restricted to %s, ignoring forwarding",
fwd.src.zone.name, this.nfproto(f1, true),
fwd.dest.zone.name, this.nfproto(f2, true)));
src: [ "zone_ref" ],
dest: [ "zone_ref" ],
- device: [ "device" ],
+ device: [ "device", null, NO_INVERT ],
direction: [ "direction" ],
ipset: [ "setmatch" ],
this.warn_section(data, "must specify option 'set_helper' for target 'helper'");
return;
}
+ else if (rule.device?.any) {
+ this.warn_section(data, "must not specify '*' as device");
+ return;
+ }
let ipset;
family: family,
proto: proto,
- has_addrs: !!(length(saddrs) || length(daddrs)),
+ has_addrs: !!(saddrs[0] || saddrs[1] || saddrs[2] || daddrs[0] || daddrs[1] || daddrs[2]),
has_ports: !!(length(sports) || length(dports)),
- saddrs_pos: map(filter_pos(saddrs), this.cidr),
- saddrs_neg: map(filter_neg(saddrs), this.cidr),
- daddrs_pos: map(filter_pos(daddrs), this.cidr),
- daddrs_neg: map(filter_neg(daddrs), this.cidr),
+ saddrs_pos: map(saddrs[0], this.cidr),
+ saddrs_neg: map(saddrs[1], this.cidr),
+ saddrs_masked: saddrs[2],
+ daddrs_pos: map(daddrs[0], this.cidr),
+ daddrs_neg: map(daddrs[1], this.cidr),
+ daddrs_masked: daddrs[2],
sports_pos: map(filter_pos(sports), this.port),
sports_neg: map(filter_neg(sports), this.port),
dports_pos: map(filter_pos(dports), this.port),
else
r.chain = "mangle_output";
- if (r.src?.zone)
+ if (r.src?.zone) {
r.src.zone.dflags[r.target] = true;
+ r.iifnames = null_if_empty(r.src.zone.match_devices);
+ }
- if (r.dest?.zone)
+ if (r.dest?.zone) {
r.dest.zone.dflags[r.target] = true;
+ r.oifnames = null_if_empty(r.dest.zone.match_devices);
+ }
}
else {
r.chain = "output";
}
else if (need_src_action_chain(r)) {
r.jump_chain = sprintf("%s_from_%s", r.target, r.src.zone.name);
- r.src.zone.dflags[r.target] = true;
+ r.src.zone.sflags[r.target] = true;
}
else if (r.target == "reject")
r.jump_chain = "handle_reject";
}
+ if (r.device)
+ r[r.direction ? "oifnames" : "iifnames"] = [ r.device.device ];
+
this.state.rules = this.state.rules || [];
push(this.state.rules, r);
};
break;
}
+ sip = subnets_split_af(rule.src_ip);
+ dip = subnets_split_af(rule.dest_ip);
+
family = infer_family(family, [
ipset, "set match",
- rule.src, "source zone",
- rule.dest, "destination zone",
+ sip, "source IP",
+ dip, "destination IP",
+ rule.src?.zone, "source zone",
+ rule.dest?.zone, "destination zone",
rule.helper, "helper match",
rule.set_helper, "helper to set"
]);
continue;
}
- sip = subnets_split_af(rule.src_ip);
- dip = subnets_split_af(rule.dest_ip);
-
let has_ipv4_specifics = (length(sip[0]) || length(dip[0]) || length(itypes4) || rule.dscp !== null);
let has_ipv6_specifics = (length(sip[1]) || length(dip[1]) || length(itypes6) || rule.dscp !== null);
/* check if there's no AF specific bits, in this case we can do an AF agnostic rule */
if (!family && rule.target != "dscp" && !has_ipv4_specifics && !has_ipv6_specifics) {
- add_rule(0, proto, null, null, sports, dports, null, null, null, rule);
+ add_rule(0, proto, [], [], sports, dports, null, null, null, rule);
}
/* we need to emit one or two AF specific rules */
let icmp_types = filter(itypes4, i => (i.code_min == 0 && i.code_max == 0xFF));
let icmp_codes = filter(itypes4, i => (i.code_min != 0 || i.code_max != 0xFF));
- if (length(icmp_types) || (!length(icmp_types) && !length(icmp_codes)))
- add_rule(4, proto, sip[0], dip[0], sports, dports, icmp_types, null, ipset, rule);
+ for (let saddrs in subnets_group_by_masking(sip[0])) {
+ for (let daddrs in subnets_group_by_masking(dip[0])) {
+ if (length(icmp_types) || (!length(icmp_types) && !length(icmp_codes)))
+ add_rule(4, proto, saddrs, daddrs, sports, dports, icmp_types, null, ipset, rule);
- if (length(icmp_codes))
- add_rule(4, proto, sip[0], dip[0], sports, dports, null, icmp_codes, ipset, rule);
+ if (length(icmp_codes))
+ add_rule(4, proto, saddrs, daddrs, sports, dports, null, icmp_codes, ipset, rule);
+ }
+ }
}
if (family == 0 || family == 6) {
let icmp_types = filter(itypes6, i => (i.code_min == 0 && i.code_max == 0xFF));
let icmp_codes = filter(itypes6, i => (i.code_min != 0 || i.code_max != 0xFF));
- if (length(icmp_types) || (!length(icmp_types) && !length(icmp_codes)))
- add_rule(6, proto, sip[1], dip[1], sports, dports, icmp_types, null, ipset, rule);
+ for (let saddrs in subnets_group_by_masking(sip[1])) {
+ for (let daddrs in subnets_group_by_masking(dip[1])) {
+ if (length(icmp_types) || (!length(icmp_types) && !length(icmp_codes)))
+ add_rule(6, proto, saddrs, daddrs, sports, dports, icmp_types, null, ipset, rule);
- if (length(icmp_codes))
- add_rule(6, proto, sip[1], dip[1], sports, dports, null, icmp_codes, ipset, rule);
+ if (length(icmp_codes))
+ add_rule(6, proto, saddrs, daddrs, sports, dports, null, icmp_codes, ipset, rule);
+ }
+ }
}
}
}
name: [ "string", this.section_id(data[".name"]) ],
_name: [ "string", null, DEPRECATED ],
- family: [ "family", "4" ],
+ family: [ "family" ],
src: [ "zone_ref" ],
dest: [ "zone_ref" ],
let resolve_dest = (redir) => {
for (let zone in this.state.zones) {
- for (let addr in zone.related_subnets) {
- if (redir.dest_ip.family != addr.family)
- continue;
+ for (let zone_addr in zone.related_subnets) {
+ for (let dest_addr in redir.dest_ip.addrs) {
+ if (dest_addr.family != zone_addr.family)
+ continue;
- let a = apply_mask(redir.dest_ip.addr, addr.bits);
- let b = apply_mask(addr.addr, addr.bits);
+ let a = apply_mask(dest_addr.addr, zone_addr.mask);
+ let b = apply_mask(zone_addr.addr, zone_addr.mask);
- if (a != b)
- continue;
+ if (a != b)
+ continue;
- redir.dest = {
- any: false,
- zone: zone
- };
+ redir.dest = {
+ any: false,
+ zone: zone
+ };
- return true;
+ return true;
+ }
}
}
if (redir.target == "dnat") {
if (!redir.src)
- return this.warn_section(r, "has no source specified");
+ return this.warn_section(data, "has no source specified");
else if (redir.src.any)
- return this.warn_section(r, "must not have source '*' for dnat target");
+ return this.warn_section(data, "must not have source '*' for dnat target");
else if (redir.dest_ip && redir.dest_ip.invert)
- return this.warn_section(r, "must not specify a negated 'dest_ip' value");
+ return this.warn_section(data, "must not specify a negated 'dest_ip' value");
+ else if (redir.dest_ip && length(filter(redir.dest_ip.addrs, a => a.bits == -1)))
+ return this.warn_section(data, "must not use non-contiguous masks in 'dest_ip'");
if (!redir.dest && redir.dest_ip && resolve_dest(redir))
- this.warn_section(r, "does not specify a destination, assuming '" + redir.dest.zone.name + "'");
+ this.warn_section(data, "does not specify a destination, assuming '" + redir.dest.zone.name + "'");
if (!redir.dest_port)
redir.dest_port = redir.src_dport;
return this.warn_section(data, "has no 'src_dip' option specified");
else if (redir.src_dip.invert)
return this.warn_section(data, "must not specify a negated 'src_dip' value");
+ else if (length(filter(redir.src_dip.addrs, a => a.bits == -1)))
+ return this.warn_section(data, "must not use non-contiguous masks in 'src_dip'");
else if (redir.src_mac)
return this.warn_section(data, "must not use 'src_mac' option for snat target");
else if (redir.helper)
family: family,
proto: proto,
- has_addrs: !!(length(saddrs) || length(daddrs)),
+ has_addrs: !!(saddrs[0] || saddrs[1] || saddrs[2] || daddrs[0] || daddrs[1] || daddrs[2]),
has_ports: !!(sport || dport || rport),
- saddrs_pos: map(filter_pos(saddrs), this.cidr),
- saddrs_neg: map(filter_neg(saddrs), this.cidr),
- daddrs_pos: map(filter_pos(daddrs), this.cidr),
- daddrs_neg: map(filter_neg(daddrs), this.cidr),
+ saddrs_pos: map(saddrs[0], this.cidr),
+ saddrs_neg: map(saddrs[1], this.cidr),
+ saddrs_masked: saddrs[2],
+ daddrs_pos: map(daddrs[0], this.cidr),
+ daddrs_neg: map(daddrs[1], this.cidr),
+ daddrs_masked: daddrs[2],
sports_pos: map(filter_pos(to_array(sport)), this.port),
sports_neg: map(filter_neg(to_array(sport)), this.port),
dports_pos: map(filter_pos(to_array(dport)), this.port),
switch (r.target) {
case "dnat":
r.chain = sprintf("dstnat_%s", r.src.zone.name);
+ r.src.zone.dflags.dnat = true;
if (!r.raddr)
r.target = "redirect";
case "snat":
r.chain = sprintf("srcnat_%s", r.dest.zone.name);
+ r.dest.zone.dflags.snat = true;
break;
}
if (proto.name == "ipv6-icmp")
family = 6;
- family = infer_family(family, [
- ipset, "set match",
- redir.src, "source zone",
- redir.dest, "destination zone",
- redir.helper, "helper match"
- ]);
-
- if (type(family) == "string") {
- this.warn_section(data, family + ", skipping");
- continue;
- }
-
switch (redir.target) {
case "dnat":
sip = subnets_split_af(redir.src_ip);
break;
}
- /* build reflection rules */
- if (redir.reflection && (length(rip[0]) || length(rip[1])) &&
- redir.src && redir.src.zone && redir.src.zone[family == 4 ? "masq" : "masq6"] &&
- redir.dest && redir.dest.zone) {
+ break;
- let refredir = {
- name: redir.name + " (reflection)",
+ case "snat":
+ sip = subnets_split_af(redir.src_ip);
+ dip = subnets_split_af(redir.dest_ip);
+ rip = subnets_split_af(redir.src_dip);
- helper: redir.helper,
+ switch (proto.name) {
+ case "tcp":
+ case "udp":
+ sport = redir.src_port;
+ dport = redir.dest_port;
+ rport = redir.src_dport;
+ break;
+ }
+
+ break;
+ }
- // XXX: this likely makes no sense for reflection rules
- //src_mac: redir.src_mac,
+ family = infer_family(family, [
+ ipset, "set match",
+ sip, "source IP",
+ dip, "destination IP",
+ rip, "rewrite IP",
+ redir.src?.zone, "source zone",
+ redir.dest?.zone, "destination zone",
+ redir.helper, "helper match"
+ ]);
- limit: redir.limit,
- limit_burst: redir.limit_burst,
+ if (type(family) == "string") {
+ this.warn_section(data, family + ", skipping");
+ continue;
+ }
- start_date: redir.start_date,
- stop_date: redir.stop_date,
- start_time: redir.start_time,
- stop_time: redir.stop_time,
- weekdays: redir.weekdays,
+ /* build reflection rules */
+ if (redir.target == "dnat" && redir.reflection &&
+ (length(rip[0]) || length(rip[1])) && redir.src?.zone && redir.dest?.zone) {
+ let refredir = {
+ name: redir.name + " (reflection)",
- mark: redir.mark
- };
+ helper: redir.helper,
- let eaddrs = subnets_split_af(length(dip) ? dip : { addrs: redir.src.zone.related_subnets });
- let rzones = length(redir.reflection_zone) ? redir.reflection_zone : [ redir.dest ];
+ // XXX: this likely makes no sense for reflection rules
+ //src_mac: redir.src_mac,
- for (let rzone in rzones) {
- if (!is_family(rzone, family)) {
- this.warn_section(data,
- sprintf("is restricted to IPv%d but referenced reflection zone is IPv%d only, skipping",
- family, rzone.family));
- continue;
- }
+ limit: redir.limit,
+ limit_burst: redir.limit_burst,
- let iaddrs = subnets_split_af({ addrs: rzone.zone.related_subnets });
- let refaddrs = (redir.reflection_src == "internal") ? iaddrs : eaddrs;
+ start_date: redir.start_date,
+ stop_date: redir.stop_date,
+ start_time: redir.start_time,
+ stop_time: redir.stop_time,
+ weekdays: redir.weekdays,
- refaddrs = [
- map(refaddrs[0], to_hostaddr),
- map(refaddrs[1], to_hostaddr)
- ];
+ mark: redir.mark
+ };
- eaddrs = [
- map(eaddrs[0], to_hostaddr),
- map(eaddrs[1], to_hostaddr)
- ];
+ let eaddrs = length(dip) ? dip : subnets_split_af({ addrs: map(redir.src.zone.related_subnets, to_hostaddr) });
+ let rzones = length(redir.reflection_zone) ? redir.reflection_zone : [ redir.dest ];
- for (let i = 0; i <= 1; i++) {
- if (length(rip[i])) {
- refredir.src = rzone;
- refredir.dest = null;
- refredir.target = "dnat";
- add_rule(i ? 6 : 4, proto, iaddrs[i], eaddrs[i], rip[i], sport, dport, rport, null, refredir);
+ for (let rzone in rzones) {
+ if (!is_family(rzone, family)) {
+ this.warn_section(data,
+ sprintf("is restricted to IPv%d but referenced reflection zone is IPv%d only, skipping",
+ family, rzone.family));
+ continue;
+ }
+
+ let iaddrs = subnets_split_af({ addrs: rzone.zone.related_subnets });
+ let refaddrs = (redir.reflection_src == "internal") ? iaddrs : eaddrs;
+
+ for (let i = 0; i <= 1; i++) {
+ if (redir.src.zone[i ? "masq6" : "masq"] && length(rip[i])) {
+ let snat_addr = refaddrs[i]?.[0];
- for (let refaddr in refaddrs[i]) {
- refredir.src = null;
- refredir.dest = rzone;
- refredir.target = "snat";
- add_rule(i ? 6 : 4, proto, iaddrs[i], rip[i], [ refaddr ], null, rport, null, null, refredir);
+ /* For internal reflection sources try to find a suitable candiate IP
+ * among the reflection zone subnets which is within the same subnet
+ * as the original DNAT destination. If we can't find any matching
+ * one then simply take the first candidate. */
+ if (redir.reflection_src == "internal") {
+ for (let zone_addr in rzone.zone.related_subnets) {
+ if (zone_addr.family != rip[i][0].family)
+ continue;
+
+ let r = apply_mask(rip[i][0].addr, zone_addr.mask);
+ let a = apply_mask(zone_addr.addr, zone_addr.mask);
+
+ if (r != a)
+ continue;
+
+ snat_addr = zone_addr;
+ break;
}
}
- }
- }
- }
+ if (!snat_addr) {
+ this.warn_section(data, (redir.reflection_src || "external") + " rewrite IP cannot be determined, disabling reflection");
+ }
+ else if (!length(iaddrs[i])) {
+ this.warn_section(data, "internal address range cannot be determined, disabling reflection");
+ }
+ else if (!length(eaddrs[i])) {
+ this.warn_section(data, "external address range cannot be determined, disabling reflection");
+ }
+ else {
+ refredir.src = rzone;
+ refredir.dest = null;
+ refredir.target = "dnat";
- break;
+ for (let saddrs in subnets_group_by_masking(iaddrs[i]))
+ for (let daddrs in subnets_group_by_masking(eaddrs[i]))
+ add_rule(i ? 6 : 4, proto, saddrs, daddrs, rip[i], sport, dport, rport, null, refredir);
- case "snat":
- sip = subnets_split_af(redir.src_ip);
- dip = subnets_split_af(redir.dest_ip);
- rip = subnets_split_af(redir.src_dip);
+ refredir.src = null;
+ refredir.dest = rzone;
+ refredir.target = "snat";
- switch (proto.name) {
- case "tcp":
- case "udp":
- sport = redir.src_port;
- dport = redir.dest_port;
- rport = redir.src_dport;
- break;
+ for (let daddrs in subnets_group_by_masking(rip[i]))
+ for (let saddrs in subnets_group_by_masking(iaddrs[i]))
+ add_rule(i ? 6 : 4, proto, saddrs, daddrs, [ to_hostaddr(snat_addr) ], null, rport, null, null, refredir);
+ }
+ }
+ }
}
-
- break;
}
if (length(rip[0]) > 1 || length(rip[1]) > 1)
this.warn_section(data, "specifies multiple rewrite addresses, using only first one");
+ let has_ip4_addr = length(sip[0]) || length(dip[0]) || length(rip[0]),
+ has_ip6_addr = length(sip[1]) || length(dip[1]) || length(rip[1]),
+ has_any_addr = has_ip4_addr || has_ip6_addr;
+
/* check if there's no AF specific bits, in this case we can do an AF agnostic rule */
- if (!family && !length(sip[0]) && !length(sip[1]) && !length(dip[0]) && !length(dip[1]) && !length(rip[0]) && !length(rip[1])) {
- add_rule(0, proto, null, null, null, sport, dport, rport, null, redir);
+ if (!family && !has_any_addr) {
+ /* for backwards compatibility, treat unspecified family as IPv4 unless user explicitly requested any (0) */
+ if (family == null)
+ family = 4;
+
+ add_rule(family, proto, [], [], null, sport, dport, rport, null, redir);
}
/* we need to emit one or two AF specific rules */
else {
- if (family == 0 || family == 4)
- add_rule(4, proto, sip[0], dip[0], rip[0], sport, dport, rport, ipset, redir);
+ if ((!family || family == 4) && (!has_any_addr || has_ip4_addr)) {
+ for (let saddrs in subnets_group_by_masking(sip[0]))
+ for (let daddrs in subnets_group_by_masking(dip[0]))
+ add_rule(4, proto, saddrs, daddrs, rip[0], sport, dport, rport, ipset, redir);
+ }
- if (family == 0 || family == 6)
- add_rule(6, proto, sip[1], dip[1], rip[1], sport, dport, rport, ipset, redir);
+ if ((!family || family == 6) && (!has_any_addr || has_ip6_addr)) {
+ for (let saddrs in subnets_group_by_masking(sip[1]))
+ for (let daddrs in subnets_group_by_masking(dip[1]))
+ add_rule(6, proto, saddrs, daddrs, rip[1], sport, dport, rport, ipset, redir);
+ }
}
}
},
enabled: [ "bool", "1" ],
name: [ "string", this.section_id(data[".name"]) ],
- family: [ "family", "4" ],
+ family: [ "family" ],
src: [ "zone_ref" ],
device: [ "string" ],
return;
}
- if (snat.src && snat.src.zone)
- snat.src.zone.dflags.snat = true;
+ if (snat.snat_ip && length(filter(snat.snat_ip.addrs, a => a.bits == -1 || a.invert))) {
+ this.warn_section(data, "must not use inversion or non-contiguous masks in 'snat_ip', ignoring section");
+ return;
+ }
let add_rule = (family, proto, saddrs, daddrs, raddrs, sport, dport, rport, snat) => {
let n = {
family: family,
proto: proto,
- has_addrs: !!(length(saddrs) || length(daddrs) || length(raddrs)),
+ has_addrs: !!(saddrs[0] || saddrs[1] || saddrs[2] || daddrs[0] || daddrs[1] || daddrs[2]),
has_ports: !!(sport || dport),
- saddrs_pos: map(filter_pos(saddrs), this.cidr),
- saddrs_neg: map(filter_neg(saddrs), this.cidr),
- daddrs_pos: map(filter_pos(daddrs), this.cidr),
- daddrs_neg: map(filter_neg(daddrs), this.cidr),
+ saddrs_pos: map(saddrs[0], this.cidr),
+ saddrs_neg: map(saddrs[1], this.cidr),
+ saddrs_masked: saddrs[2],
+ daddrs_pos: map(daddrs[0], this.cidr),
+ daddrs_neg: map(daddrs[1], this.cidr),
+ daddrs_masked: daddrs[2],
sports_pos: map(filter_pos(to_array(sport)), this.port),
sports_neg: map(filter_neg(to_array(sport)), this.port),
dports_pos: map(filter_pos(to_array(dport)), this.port),
if (length(rip[0]) > 1 || length(rip[1]) > 1)
this.warn_section(data, "specifies multiple rewrite addresses, using only first one");
- /* inherit family restrictions from related zones */
- if (family === 0 || family === null) {
- let f = (rule.src && rule.src.zone) ? rule.src.zone.family : 0;
-
- if (f) {
- this.warn_section(r,
- sprintf("inheriting %s restriction from src %s",
- this.nfproto(f1, true), rule.src.zone.name));
+ family = infer_family(family, [
+ sip, "source IP",
+ dip, "destination IP",
+ rip, "rewrite IP",
+ snat.src?.zone, "source zone"
+ ]);
- family = f;
- }
+ if (type(family) == "string") {
+ this.warn_section(data, family + ", skipping");
+ continue;
}
+ if (snat.src?.zone)
+ snat.src.zone.dflags.snat = true;
+
/* if no family was configured, infer target family from IP addresses */
if (family === null) {
if ((length(sip[0]) || length(dip[0]) || length(rip[0])) && !length(sip[1]) && !length(dip[1]) && !length(rip[1]))
else if ((length(sip[1]) || length(dip[1]) || length(rip[1])) && !length(sip[0]) && !length(dip[0]) && !length(rip[0]))
family = 6;
else
- family = 0;
+ family = 4; /* default to IPv4 only for backwards compatibility, unless an explict family any was configured */
}
/* check if there's no AF specific bits, in this case we can do an AF agnostic rule */
if (!family && !length(sip[0]) && !length(sip[1]) && !length(dip[0]) && !length(dip[1]) && !length(rip[0]) && !length(rip[1])) {
- add_rule(0, proto, null, null, null, sport, dport, rport, snat);
+ add_rule(0, proto, [], [], null, sport, dport, rport, snat);
}
/* we need to emit one or two AF specific rules */
else {
if (family == 0 || family == 4)
- add_rule(4, proto, sip[0], dip[0], rip[0], sport, dport, rport, snat);
+ for (let saddr in subnets_group_by_masking(sip[0]))
+ for (let daddr in subnets_group_by_masking(dip[0]))
+ add_rule(4, proto, saddr, daddr, rip[0], sport, dport, rport, snat);
if (family == 0 || family == 6)
- add_rule(6, proto, sip[1], dip[1], rip[1], sport, dport, rport, snat);
+ for (let saddr in subnets_group_by_masking(sip[1]))
+ for (let daddr in subnets_group_by_masking(dip[1]))
+ add_rule(6, proto, saddr, daddr, rip[1], sport, dport, rport, snat);
}
}
},