@push.rocks/smartnftables 4.1.0 → 4.2.0

package/changelog.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 2026-10-01 - 4.2.0
+
+### Features
+
+- `ManagedDockerForwarding` now admits every forwarded flow the non-exclusive `hostTransit` barrier admits, each with its replies: besides the leased ranges, each inbound publication (uplink to handoff after the barrier's DNAT, matched on its inside destination and its published `hostIp` and port(s) as the original destination) and each symmetric publication's flows from its target ports (handoff to uplink, before the barrier's SNAT). The barrier's forward chain and the contribution derive from one enumeration of the scope's forwarded flows (`HostScope::forwarding`), and the barrier's compiled bytes are unchanged. A router's own egress reaches the host as a leased flow and stays covered by the leased rules. Every flow kind is three rules (NEW with TCP SYN only, ESTABLISHED, ESTABLISHED reply); the native graph check verifies the conntrack original-destination tuple bytes. A scope without publications keeps its exact rules, comments and graphs. The 192-rule and 100,000-byte bound is unchanged, so beside one handoff with a TCP and a UDP range a scope with more than 62 publications, or 31 symmetric ones, is refused as `EXHAUSTED`.
+- `ManagedDockerForwarding.reconcile()` amends a running generation in place: a handoff link that `previous` and `target` both bind exactly may stay up, because the single `iptables-nft-restore` transaction swaps the owned block in one atomic commit. Links the transition adds or drops, and every link of a first apply, must still be down.
+- `ManagedDockerForwarding.release()` and `close()` count a handoff link whose index no link holds any more as down, so a process restarted in the same boot can release the previous contribution after its router namespace and veths are gone. An existing link must still be the exact bound link and down, and reconcile keeps requiring existing links.
+- Add `inspectForwardHooks({ binaryPath?, networkNamespaceFd? })`: a read-only, generation-consistent report of every nf_tables forward base chain of the `ip`, `ip6` and `inet` families with its table handle, priority and policy, of Docker's `DOCKER-USER`/`DOCKER-FORWARD` chains, and of registered legacy xtables tables, so a caller can refuse `exclusiveForwarding` while another forward owner exists. The native binary gains a `--forward-hooks` mode for it.
+
 ## 2026-10-01 - 4.1.0
 
 ### Features

package/dist_rust/smartnftables_linux_amd64_musl.tsrust-build.json

@@ -1,12 +1,12 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "31265adcd734d687d19c98508332ec591f36afd9581c27a3c7b7fac647620b07",
+  "binarySha256": "5c2f8a063c4d9b145882ca1782151a016adb44940a9a0c99e13cbd5eeea619bb",
   "buildInfo": {
     "projectName": "@push.rocks/smartnftables",
-    "projectVersion": "4.1.0",
-    "gitCommit": "71cf6d5ee0d229b03b01f85901f5d50984b570a3",
+    "projectVersion": "4.2.0",
+    "gitCommit": "8d4de9479b77ba7fd1297d895dc5038f65e2f99a",
     "gitDirty": false,
-    "builtAt": "2026-10-01T18:44:25.782Z",
+    "builtAt": "2026-10-01T20:26:51.965Z",
     "tsrustVersion": "2.0.1",
     "binary": "smartnftables",
     "target": "linux_amd64_musl"

package/dist_rust/smartnftables_linux_arm64_musl.tsrust-build.json

@@ -1,12 +1,12 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "a6d37a21727fed45c2a4079261930682fbb136b67ac1b24971015725b2b4ada5",
+  "binarySha256": "acdccfdbc055aaea30aaf547020585cabfe0a07be6e590794372fbc8950c5f6b",
   "buildInfo": {
     "projectName": "@push.rocks/smartnftables",
-    "projectVersion": "4.1.0",
-    "gitCommit": "71cf6d5ee0d229b03b01f85901f5d50984b570a3",
+    "projectVersion": "4.2.0",
+    "gitCommit": "8d4de9479b77ba7fd1297d895dc5038f65e2f99a",
     "gitDirty": false,
-    "builtAt": "2026-10-01T18:44:34.745Z",
+    "builtAt": "2026-10-01T20:27:00.986Z",
     "tsrustVersion": "2.0.1",
     "binary": "smartnftables",
     "target": "linux_arm64_musl"

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartnftables',
-    version: '4.1.0',
+    version: '4.2.0',
     description: 'A TypeScript module for managing nftables rules including NAT, firewall, and rate limiting with a high-level API.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwyQkFBMkI7SUFDakMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLG1IQUFtSDtDQUNqSSxDQUFBIn0=

package/dist_ts/classes.manageddockerforwarding.d.ts

@@ -12,6 +12,7 @@ export declare class ManagedDockerForwarding {
     release(expected: IAppliedManagedDockerForwardingPolicy): Promise<{
         released: true;
     }>;
-    /** Join operations and exact contributed-rule deletion, then native termination. Keep affected handoff links down through cleanup. */
+    /** Join operations and exact contributed-rule deletion, then native termination. Keep affected handoff links down
+     * through cleanup; a handoff link that no longer exists counts as down. */
     close(): Promise<void>;
 }

package/dist_ts/classes.manageddockerforwarding.js

@@ -65,7 +65,8 @@ export class ManagedDockerForwarding {
     release(expected) {
         return this.#invoke('releaseDockerForwarding', expected);
     }
-    /** Join operations and exact contributed-rule deletion, then native termination. Keep affected handoff links down through cleanup. */
+    /** Join operations and exact contributed-rule deletion, then native termination. Keep affected handoff links down
+     * through cleanup; a handoff link that no longer exists counts as down. */
     close() {
         if (this.#close)
             return this.#close;
@@ -124,4 +125,4 @@ export class ManagedDockerForwarding {
         return owned;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.manageddockerforwarding.js","sourceRoot":"","sources":["../ts/classes.manageddockerforwarding.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAG5G,yGAAyG;AACzG,MAAM,OAAO,uBAAuB;IACzB,QAAQ,CAA4C;IAC7D,OAAO,GAA0E,IAAI,CAAC;IACtF,MAAM,GAA0E,KAAK,CAAC;IACtF,KAAK,GAA4B,IAAI,CAAC;IACtC,MAAM,GAAyB,IAAI,CAAC;IACpC,aAAa,GAAG,KAAK,CAAC;IAEtB,YAAY,OAAwC;QAClD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,oBAAoB,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;eACrH,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;eACrI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,GAAG,EAAE;eACpC,IAAI,CAAC,QAAQ,CAAC,UAAU,KAAK,SAAS,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAC/I,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAC5C,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,SAAS,IAAI,CAAC,OAAO,CAAC,QAAQ,KAAK,OAAO;eAC9E,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,kBAAkB,GAAG,CAAC;eAC3F,IAAI,CAAC,QAAQ,CAAC,kBAAkB,GAAG,WAAW,CAAC;YAAE,MAAM,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC;IAClG,CAAC;IAED,IAAW,KAAK,KAAa,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAElD,uFAAuF;IAChF,KAAK;QACV,IAAI,IAAI,CAAC,MAAM,KAAK,KAAK;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC;QACzB,MAAM,IAAI,GAAG,CAAC,KAAK,IAAI,EAAE;YACvB,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC;gBAAE,MAAM,IAAI,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;YACrI,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YACxE,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,UAAU,CAAmC;gBAChF,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU;uBAC5D,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,uBAAuB,OAAO,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,OAAO,CAAC;gBACnH,UAAU,EAAE,EAAE,EAAE,gBAAgB,EAAE,KAAK;gBACvC,OAAO,EAAE,CAAC,qBAAqB,EAAE,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,wBAAwB,EAAE,GAAG,CAAC,CAAC,CAAC;gBAC5H,wBAAwB,EAAE,IAAI,CAAC,QAAQ,CAAC,kBAAkB,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC;gBACzH,cAAc,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,cAAc,EAAE,eAAe;gBAC/E,0BAA0B,EAAE,EAAE,uBAAuB,EAAE,CAAC,EAAE,oBAAoB,EAAE,CAAC,EAAE,yBAAyB,EAAE,CAAC,EAAE,uBAAuB,EAAE,CAAC,EAAE,uBAAuB,EAAE,CAAC,EAAE,qBAAqB,EAAE,CAAC,EAAE;aACpM,CAAC,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;gBAC3B,IAAI,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;oBAAE,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;YAClF,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;gBAAE,MAAM,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC;YAC/E,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;YAC9C,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,sBAAsB,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC;YACzG,IAAI,IAAI,CAAC,MAAM,KAAK,UAAU;gBAAE,MAAM,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC;YAC9E,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;YAAC,OAAO,MAAM,CAAC;QACvC,CAAC,CAAC,EAAE,CAAC;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAEM,OAAO,CAAC,MAAsC;QACnD,OAAO,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,MAAM,CAAC,CAAC;IACzD,CAAC;IACM,SAAS,CAAC,UAA8C;QAC7D,OAAO,IAAI,CAAC,OAAO,CAAC,2BAA2B,EAAE,UAAU,CAAC,CAAC;IAC/D,CAAC;IACM,OAAO,KAA8C,OAAO,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAC1G,OAAO,CAAC,QAA+C;QAC5D,OAAO,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,QAAQ,CAAC,CAAC;IAC3D,CAAC;IAED,sIAAsI;IAC/H,KAAK;QACV,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC;QACpC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;YAAE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QACxD,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QACxB,IAAI,CAAC,MAAM,GAAG,CAAC,KAAK,IAAI,EAAE;YACxB,MAAM,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YACzC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;oBACvB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,uBAAuB,EAAE,EAAE,CAAC,CAAC;oBAC3E,IAAI,MAAM,CAAC,QAAQ,KAAK,IAAI;wBAAE,MAAM,IAAI,oBAAoB,CAAC,UAAU,CAAC,CAAC;gBAC3E,CAAC;gBACD,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;YACxD,CAAC;YACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QAC/C,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;YAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACjD,MAAM,IAAI,oBAAoB,CAAC,qBAAqB,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,OAAO,CAAmD,MAAS,EAAE,MAAqD;QACxH,IAAI,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC;QACpJ,IAAI,QAAuD,CAAC;QAC5D,IAAI,CAAC;YAAC,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC;YAAC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,oBAAoB,CAAC,SAAS,CAAC,CAAC,CAAC;QAAC,CAAC;QAC1G,IAAI,MAAM,KAAK,2BAA2B,IAAI,MAAM,KAAK,yBAAyB;YAAE,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC9G,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC5E,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;YACxC,IAAI,MAAM,KAAK,yBAAyB;gBAAE,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YACrE,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,MAAM,KAAK,2BAA2B,IAAI,MAAM,KAAK,yBAAyB;mBAC3G,MAAM,KAAK,yBAAyB,IAAK,cAAiD,CAAC,KAAK,KAAK,IAAI,CAAC;gBAAE,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;YACvI,OAAO,cAAc,CAAC;QACxB,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IACD,MAAM,CAAI,IAAgB;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACjC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS;gBAAE,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC;YAC5D,MAAM,WAAW,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,KAAK,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5E,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.manageddockerforwarding.js","sourceRoot":"","sources":["../ts/classes.manageddockerforwarding.ts"],"names":[],"mappings":"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"}

package/dist_ts/forwardhooks.d.ts

@@ -0,0 +1,8 @@
+import type { IForwardHookInspection, IForwardHookInspectionOptions } from './managed.forwardhooks.types.js';
+/** Reads every packet-filter owner on the IPv4/IPv6 forward hook of one network
+ * namespace: nf_tables forward base chains of the `ip`, `ip6` and `inet`
+ * families, Docker's DOCKER-USER/DOCKER-FORWARD chains and registered legacy
+ * xtables tables. One native process takes one generation-consistent read and
+ * exits; it claims, adopts and changes nothing. The result is a point-in-time
+ * view: another owner can appear after it. */
+export declare function inspectForwardHooks(options?: IForwardHookInspectionOptions): Promise<IForwardHookInspection>;

package/dist_ts/forwardhooks.js

@@ -0,0 +1,42 @@
+import * as plugins from './plugins.js';
+import { snapshot, managedIpcBytes, ManagedNftablesError, nativeError } from './classes.managednftables.js';
+/** Reads every packet-filter owner on the IPv4/IPv6 forward hook of one network
+ * namespace: nf_tables forward base chains of the `ip`, `ip6` and `inet`
+ * families, Docker's DOCKER-USER/DOCKER-FORWARD chains and registered legacy
+ * xtables tables. One native process takes one generation-consistent read and
+ * exits; it claims, adopts and changes nothing. The result is a point-in-time
+ * view: another owner can appear after it. */
+export async function inspectForwardHooks(options = {}) {
+    const captured = snapshot(options);
+    if (Object.keys(captured).some((key) => !['binaryPath', 'networkNamespaceFd'].includes(key))
+        || captured.binaryPath !== undefined && (typeof captured.binaryPath !== 'string'
+            || !plugins.path.isAbsolute(captured.binaryPath) || captured.binaryPath.includes('\0'))
+        || captured.networkNamespaceFd !== undefined && (!Number.isInteger(captured.networkNamespaceFd)
+            || captured.networkNamespaceFd < 0 || captured.networkNamespaceFd > 0x7fff_ffff)) {
+        throw new ManagedNftablesError('INVALID');
+    }
+    if (process.platform !== 'linux' || !['x64', 'arm64'].includes(process.arch))
+        throw new ManagedNftablesError('UNSUPPORTED_PLATFORM');
+    const root = plugins.url.fileURLToPath(new URL('../', import.meta.url));
+    const bridge = new plugins.smartrust.RustBridge({
+        binaryName: 'smartnftables', binaryPath: captured.binaryPath
+            ?? plugins.path.join(root, 'dist_rust', `smartnftables_linux_${process.arch === 'x64' ? 'amd64' : 'arm64'}_musl`),
+        localPaths: [], searchSystemPath: false,
+        cliArgs: ['--forward-hooks', ...(captured.networkNamespaceFd === undefined ? [] : ['--network-namespace-fd', '3'])],
+        inheritedFileDescriptors: captured.networkNamespaceFd === undefined ? undefined : [captured.networkNamespaceFd],
+        readyTimeoutMs: 3000, requestTimeoutMs: 30_000, maxPayloadSize: managedIpcBytes,
+        maxPendingRequestsByMethod: { inspectForwardHooks: 1 },
+    });
+    try {
+        if (!await bridge.spawn())
+            throw new ManagedNftablesError('UNAVAILABLE');
+        return snapshot(await bridge.sendCommand('inspectForwardHooks', {}));
+    }
+    catch (error) {
+        throw error instanceof ManagedNftablesError ? error : nativeError(error);
+    }
+    finally {
+        await bridge.terminate({ gracePeriodMs: 1000 });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -13,3 +13,5 @@ export { buildFirewallRule, buildIPSetCreate, buildIPSetAddElements, buildIPSetR
 export type { TNftProtocol, TNftFamily, TNftChainHook, TNftChainType, TNftPolicy, TFirewallAction, TCtState, INftDnatRule, INftSnatRule, INftMasqueradeRule, INftRateLimitRule, INftConnectionRateRule, INftFirewallRule, INftIPSetBlockOptions, INftIPSetConfig, INftCleanupOptions, INftRuleGroup, ISmartNftablesOptions, INftStatus, } from './nft.types.js';
 export * from './managed.docker.types.js';
 export * from './classes.manageddockerforwarding.js';
+export type * from './managed.forwardhooks.types.js';
+export { inspectForwardHooks } from './forwardhooks.js';

package/dist_ts/index.js

@@ -14,4 +14,5 @@ export { buildRateLimitRule, buildPerIpRateLimitRule, buildConnectionRateRule, }
 export { buildFirewallRule, buildIPSetCreate, buildIPSetAddElements, buildIPSetRemoveElements, buildIPSetDelete, buildIPSetMatchRule, } from './nft.rulebuilder.firewall.js';
 export * from './managed.docker.types.js';
 export * from './classes.manageddockerforwarding.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxlQUFlLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUlyRixlQUFlO0FBQ2YsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUU5RCxXQUFXO0FBQ1gsT0FBTyxFQUFFLFdBQVcsRUFBRSxlQUFlLEVBQUUsZUFBZSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbEYscUNBQXFDO0FBQ3JDLE9BQU8sRUFDTCxlQUFlLEVBQ2YsaUJBQWlCLEVBQ2pCLGlCQUFpQixHQUNsQixNQUFNLDRCQUE0QixDQUFDO0FBRXBDLE9BQU8sRUFDTCxjQUFjLEVBQ2QsYUFBYSxFQUNiLG1CQUFtQixHQUNwQixNQUFNLDBCQUEwQixDQUFDO0FBRWxDLE9BQU8sRUFDTCxrQkFBa0IsRUFDbEIsdUJBQXVCLEVBQ3ZCLHVCQUF1QixHQUN4QixNQUFNLGdDQUFnQyxDQUFDO0FBRXhDLE9BQU8sRUFDTCxpQkFBaUIsRUFDakIsZ0JBQWdCLEVBQ2hCLHFCQUFxQixFQUNyQix3QkFBd0IsRUFDeEIsZ0JBQWdCLEVBQ2hCLG1CQUFtQixHQUNwQixNQUFNLCtCQUErQixDQUFDO0FBd0J2QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsc0NBQXNDLENBQUMifQ==
+export { inspectForwardHooks } from './forwardhooks.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxlQUFlLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUlyRixlQUFlO0FBQ2YsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUU5RCxXQUFXO0FBQ1gsT0FBTyxFQUFFLFdBQVcsRUFBRSxlQUFlLEVBQUUsZUFBZSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbEYscUNBQXFDO0FBQ3JDLE9BQU8sRUFDTCxlQUFlLEVBQ2YsaUJBQWlCLEVBQ2pCLGlCQUFpQixHQUNsQixNQUFNLDRCQUE0QixDQUFDO0FBRXBDLE9BQU8sRUFDTCxjQUFjLEVBQ2QsYUFBYSxFQUNiLG1CQUFtQixHQUNwQixNQUFNLDBCQUEwQixDQUFDO0FBRWxDLE9BQU8sRUFDTCxrQkFBa0IsRUFDbEIsdUJBQXVCLEVBQ3ZCLHVCQUF1QixHQUN4QixNQUFNLGdDQUFnQyxDQUFDO0FBRXhDLE9BQU8sRUFDTCxpQkFBaUIsRUFDakIsZ0JBQWdCLEVBQ2hCLHFCQUFxQixFQUNyQix3QkFBd0IsRUFDeEIsZ0JBQWdCLEVBQ2hCLG1CQUFtQixHQUNwQixNQUFNLCtCQUErQixDQUFDO0FBd0J2QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsc0NBQXNDLENBQUM7QUFFckQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sbUJBQW1CLENBQUMifQ==

package/dist_ts/managed.docker.types.d.ts

@@ -32,7 +32,8 @@ export interface IAppliedManagedDockerForwardingPolicy {
     };
     prepared: IPreparedManagedDockerForwardingPolicy;
 }
-/** Persist before mutation. Keep both generations' exact handoff links down until reconciliation is confirmed. */
+/** Persist before mutation. A handoff link both generations bind exactly may stay up: one atomic transaction swaps
+ * the contribution. Keep every link the transition adds or drops down until reconciliation is confirmed. */
 export interface IManagedDockerForwardingTransition {
     previous: IAppliedManagedDockerForwardingPolicy | null;
     target: IPreparedManagedDockerForwardingPolicy;

package/dist_ts/managed.forwardhooks.types.d.ts

@@ -0,0 +1,35 @@
+import type { IManagedNftOptions } from './managed.types.js';
+export interface IForwardHookInspectionOptions extends Pick<IManagedNftOptions, 'binaryPath' | 'networkNamespaceFd'> {
+}
+/** One nf_tables base chain on the forward hook of the `ip`, `ip6` or `inet` family. */
+export interface IForwardHookChain {
+    family: 'ip' | 'ip6' | 'inet';
+    table: string;
+    /** Kernel table handle, as a managed receipt's `tableHandle`. */
+    tableHandle: string;
+    chain: string;
+    type: string;
+    priority: number;
+    policy: 'accept' | 'drop';
+}
+/** One consistent read of every packet-filter owner on the routed forward path of a network namespace. */
+export interface IForwardHookInspection {
+    /** Every forward base chain, sorted by family, table and chain; managed tables included. */
+    chains: IForwardHookChain[];
+    /** Docker's iptables-nft dispatch chains in table `ip filter`. */
+    docker: {
+        dockerUser: boolean;
+        dockerForward: boolean;
+    };
+    /** Registered legacy xtables tables, whose hooks are not nf_tables chains. */
+    legacyTables: {
+        ipv4: string[];
+        ipv6: string[];
+    };
+}
+export type TForwardHookCommands = {
+    inspectForwardHooks: {
+        params: Record<string, never>;
+        result: IForwardHookInspection;
+    };
+};

package/dist_ts/managed.forwardhooks.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFuYWdlZC5mb3J3YXJkaG9va3MudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9tYW5hZ2VkLmZvcndhcmRob29rcy50eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartnftables",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "private": false,
   "description": "A TypeScript module for managing nftables rules including NAT, firewall, and rate limiting with a high-level API.",
   "main": "dist_ts/index.js",

package/readme.md

@@ -452,8 +452,8 @@ under host grants. 64 symmetric ranges take about 19,600 element bytes.
 The caller still owns the route to `targetAddress` through that handoff, the
 workload listener, and every other packet owner on the host. As with leased egress,
 an ACCEPT here cannot override Docker's independent FORWARD DROP; the
-`ManagedDockerForwarding` contribution below derives only leased handoff egress from
-the barrier and currently carries no inbound publication.
+`ManagedDockerForwarding` contribution below admits every inbound and symmetric
+publication of the barrier through it, with the leased flows.
 
 Each router generation binds an immutable lease reference, transit source address,
 leased TCP/UDP source-port ranges, a nonzero conntrack zone and a 16-byte label.
@@ -693,7 +693,8 @@ forwarding that another owner (Docker, a container or VM bridge, a VPN router, a
 second routing daemon) accepts, and accepting in this table still cannot override
 another owner's drop. Use it only on a host where this table is the sole forwarding
 owner; on a Docker host keep it absent and use the Docker contribution below, which
-refuses an exclusive barrier. The
+refuses an exclusive barrier. `inspectForwardHooks()`, described below, reports
+the other forward owners of the namespace for that decision. The
 member does not fence flowtable offload, packet queues, proxies or anything outside
 the forward hook.
 
@@ -880,7 +881,7 @@ drainage, conntrack cleanup, elapsed-time expiry, or safe address/port/zone reus
 
 ### Docker forwarding contribution
 
-`ManagedDockerForwarding` admits the leased handoff traffic from an exact applied
+`ManagedDockerForwarding` admits exactly the forwarded flows of an exact applied
 schema-v2 `hostTransit` receipt through Docker's existing IPv4 forwarding path.
 It reads and verifies that dedicated barrier's complete table and local links,
 without adopting its ownership. The contribution uses Docker's supported
@@ -916,32 +917,84 @@ and never changes a host forwarding policy. `prepare()` refuses a barrier with
 `exclusiveForwarding` as `INVALID`: its drop would also deny Docker's own container
 forwarding.
 
-Each contributed rule binds the handoff and uplink names, current and original
-transit source, exact leased TCP/UDP port range, packet direction and connection
-state. New TCP flows require SYN with FIN/RST/ACK clear; reverse traffic requires
-ESTABLISHED. The exact v2 host barrier independently checks interface indices,
-MAC/iflink facts, the default host conntrack zone, protected original/current
-destinations and explicit outer SNAT. A complete contribution is bounded to 192
-rules and 100,000 generated command bytes.
+The contribution and the barrier's forward chain derive from one enumeration of
+the scope's forwarded flows, so the contribution admits exactly the flow kinds the
+non-exclusive barrier admits, each with its replies:
+
+| Flow kind | Original direction | Live tuple | Conntrack original tuple |
+| --- | --- | --- | --- |
+| Leased range | handoff → uplink | transit source address and leased port range | same source |
+| Inbound publication | uplink → handoff, after the barrier's DNAT | inside target address and port(s) as destination | published `hostIp` and port(s) as destination |
+| Symmetric publication | handoff → uplink, before the barrier's SNAT | target address and port(s) as source | same source |
+
+Every flow kind has three rules: the NEW opening (TCP only with SYN and
+FIN/RST/ACK clear), the ESTABLISHED original direction and the ESTABLISHED reply
+with swapped interfaces and tuple sides. A router's own egress, such as a VPN client
+in the router namespace dialling its hub, reaches the host as a leased flow: the
+router translates it to the transit address and a leased port range, so it is
+admitted by the leased rules exactly when the barrier admits it. Host grants and
+host-local platform endpoints use INPUT/OUTPUT and never cross FORWARD. Each rule
+binds the handoff and uplink names. The exact v2 host barrier independently checks
+interface indices, MAC/iflink facts, the default host conntrack zone, protected
+original/current destinations and explicit outer SNAT; it governs every forwarded
+packet on its handoffs, so the host forwards the intersection, which is the
+barrier's admitted set. A scope without publications keeps its exact 4.1.0 rules,
+comments and graphs. A complete contribution is bounded to 192 rules and 100,000
+generated command bytes: three rules per leased range and per publication, and
+three more per symmetric publication. A larger scope is refused as `EXHAUSTED`
+(`restoreRules`/`restoreBytes`) before any subprocess.
 
 Create the class with `ownerId`, a caller-retained `instanceId` of at least 16
 identifier characters, and optional `binaryPath`/`networkNamespaceFd`. After
 `start()`, call `prepare({ schemaVersion: 1, revision, barrier })`, where `barrier`
 is the exact applied host policy. Persist the complete `{ previous, target }`
-transition before `reconcile()`. Keep every affected handoff link down through
-mutations; retain those exact links until cleanup finishes. The native owner
-verifies this down state before and after its single no-flush restore transaction.
-Exact target replay can recover a lost response without rewriting live rules.
+transition before `reconcile()`. The native owner fences the handoff links before
+and after its single no-flush restore transaction, which deletes the previous block
+and inserts the target block in one atomic nf_tables commit. A handoff link that
+`previous` and `target` both bind exactly may stay up, so a publication or lease
+amendment of a running generation applies in place: every flow both contributions
+admit passes throughout, a flow only the target admits passes from the commit, and
+the referenced barrier must already be the target. Every handoff link the
+transition adds or drops, and every link of a first apply, must be down; retain
+those exact links until cleanup finishes. Exact target replay can recover a lost
+response without rewriting live rules.
 
 `inspect().present` confirms the contribution and its referenced barrier, not
 the complete host packet path or durable controller authority. Errors retain
 failed-owned state and pending intent. `release(applied)` and `close()` delete
-only exact contributed rules under the same link fence. A cold boot needs a new
+only exact contributed rules. Their fence requires every handoff link down or gone:
+a link whose index no link holds any more, such as a veth that left with its router
+namespace when the node process ended, counts as down, so a restarted process in
+the same boot can release the previous contribution before applying the next one.
+A different link at a bound index still rejects. A cold boot needs a new
 barrier receipt and caller-authorized replay; old boot receipts cannot authorize
 native operations. The caller owns restart ordering, disjoint retained leases,
 exclusive privileged mutation authority and activation. The frontend transaction
 does not provide compare-and-swap against other privileged processes.
 
+### Forward hook owners
+
+`inspectForwardHooks({ binaryPath?, networkNamespaceFd? })` reads every
+packet-filter owner on the routed forward path of one network namespace and
+changes nothing. One native process takes the read and exits:
+
+- `chains`: every nf_tables base chain on the forward hook of the `ip`, `ip6` and
+  `inet` families, with `family`, `table`, `tableHandle`, `chain`, `type`,
+  `priority` and `policy`, sorted by family, table and chain. Managed tables are
+  included; compare `table` and `tableHandle` with a receipt's
+  `identity.tableName` and `tableHandle` to find your own.
+- `docker`: whether Docker's iptables-nft `DOCKER-USER` and `DOCKER-FORWARD`
+  chains exist in table `ip filter`.
+- `legacyTables`: the registered legacy xtables `ipv4` and `ipv6` tables. Their
+  hooks, including FORWARD, are not nf_tables objects and never appear in `chains`.
+
+The table and chain dumps share one ruleset generation, or the read is
+`CONFLICT`. Without `CAP_NET_ADMIN` in the namespace it is `PERMISSION`. Bridge
+and netdev hooks do not see routed packets and are not reported. Guard
+`exclusiveForwarding` with it: refuse while any chain other than your own barrier's,
+either Docker chain or any legacy table is present. The read is a point in time;
+the caller still owns exclusive authority over who may add a forward owner later.
+
 ### Native qualification
 
 The separate [Docker fixture](test/native/readme.docker.md) exercises the native

package/rust/src/docker.frontend.rs

@@ -113,10 +113,10 @@ fn normalized(args: &[String]) -> Result<Vec<(String, Vec<String>)>> {
     let mut values=BTreeMap::new();let mut modules=BTreeSet::new();let mut index=0;
     while index<args.len() {
         let key=&args[index];let count=if key=="--tcp-flags" {2} else {1};
-        if !["-i","-o","-s","-d","-p","-m","--sport","--dport","--tcp-flags","--ctstate","--ctproto","--ctorigsrc","--ctorigsrcport","--ctdir","--comment","-j"].contains(&key.as_str()) {return Err(Error::Conflict);}
+        if !["-i","-o","-s","-d","-p","-m","--sport","--dport","--tcp-flags","--ctstate","--ctproto","--ctorigsrc","--ctorigsrcport","--ctorigdst","--ctorigdstport","--ctdir","--comment","-j"].contains(&key.as_str()) {return Err(Error::Conflict);}
         let mut value=args.get(index+1..index+1+count).ok_or(Error::Conflict)?.to_vec();index+=1+count;
         if key=="-m" {if !modules.insert(value[0].clone()) {return Err(Error::Conflict);}continue;}
-        if key=="--ctorigsrc" && !value[0].contains('/') {value[0].push_str("/32");}
+        if (key=="--ctorigsrc" || key=="--ctorigdst") && !value[0].contains('/') {value[0].push_str("/32");}
         if key=="--ctproto" {value[0]=match value[0].as_str() {"tcp"=>"6".into(),"udp"=>"17".into(),_=>value[0].clone()};}
         if values.insert(key.clone(),value).is_some() {return Err(Error::Conflict);}
     }

package/rust/src/docker.graph.rs

@@ -9,17 +9,36 @@ fn payload(base: u32, offset: u32, length: u32) -> Attr {
     expr("payload",vec![Attr::u32(1,1),Attr::u32(2,base),Attr::u32(3,offset),Attr::u32(4,length)])
 }
 
+fn span(value: &str) -> Result<(u16, u16)> {
+    let (first,last)=value.split_once(':').unwrap_or((value,value));
+    Ok((first.parse::<u16>().map_err(|_|Error::Invalid)?,last.parse::<u16>().map_err(|_|Error::Invalid)?))
+}
+/// The one key of a rule among alternatives, with its value.
+fn either<'a>(rule: &'a Rule, keys: [&'static str; 2]) -> Result<(usize, &'a str)> {
+    let mut found=keys.iter().enumerate().filter_map(|(index,key)|value(rule,key).ok().map(|value|(index,value)));
+    let result=found.next().ok_or(Error::Invalid)?;
+    if found.next().is_some() {return Err(Error::Invalid);}
+    Ok(result)
+}
+
 /// Fixed Linux UAPI / xtables 1.8.10 and 1.8.11 constructors, not a raw rule API.
 pub(super) fn expected(rule: &Rule) -> Result<Vec<Attr>> {
     let reply=value(rule,"--ctdir")?=="REPLY";
     let new=value(rule,"--ctstate")?=="NEW";
     let protocol=match value(rule,"-p")? {"tcp"=>6_u16,"udp"=>17,_=>return Err(Error::Invalid)};
-    let address=value(rule,"--ctorigsrc")?.parse::<std::net::Ipv4Addr>().map_err(|_|Error::Invalid)?.octets();
-    let ports=value(rule,"--ctorigsrcport")?;
-    let (first,last)=ports.split_once(':').unwrap_or((ports,ports));
-    let first=first.parse::<u16>().map_err(|_|Error::Invalid)?;
-    let last=last.parse::<u16>().map_err(|_|Error::Invalid)?;
-    let mut result=vec![payload(1,if reply {16} else {12},4),compare(address.to_vec())];
+    // The packet's own source (0) or destination (1) address and port.
+    let (side,live)=either(rule,["-s","-d"])?;
+    let live=live.strip_suffix("/32").ok_or(Error::Invalid)?.parse::<std::net::Ipv4Addr>().map_err(|_|Error::Invalid)?.octets();
+    let (port_side,ports)=either(rule,["--sport","--dport"])?;
+    if port_side!=side {return Err(Error::Invalid);}
+    let (first,last)=span(ports)?;
+    // The originally tracked source (0) or destination (1) address and port.
+    let (tracked_side,tracked)=either(rule,["--ctorigsrc","--ctorigdst"])?;
+    let tracked=tracked.parse::<std::net::Ipv4Addr>().map_err(|_|Error::Invalid)?.octets();
+    let (tracked_port_side,tracked_ports)=either(rule,["--ctorigsrcport","--ctorigdstport"])?;
+    if tracked_port_side!=tracked_side {return Err(Error::Invalid);}
+    let (tracked_first,tracked_last)=span(tracked_ports)?;
+    let mut result=vec![payload(1,if side==0 {12} else {16},4),compare(live.to_vec())];
     for (key,argument) in [(6,"-i"),(7,"-o")] {
         result.extend(meta(key,[value(rule,argument)?.as_bytes(),&[0]].concat()));
     }
@@ -30,7 +49,7 @@ pub(super) fn expected(rule: &Rule) -> Result<Vec<Attr>> {
             Attr::nested(4,vec![Attr::bytes(1,vec![0x17])]),Attr::nested(5,vec![Attr::bytes(1,vec![0])]),
         ]),compare(vec![2])]);
     }
-    result.push(payload(2,if reply {2} else {0},2));
+    result.push(payload(2,if side==0 {0} else {2},2));
     result.push(if first==last {compare(first.to_be_bytes().to_vec())} else {
         expr("range",vec![Attr::u32(1,1),Attr::u32(2,0),
             Attr::nested(3,vec![Attr::bytes(1,first.to_be_bytes().to_vec())]),
@@ -38,11 +57,17 @@ pub(super) fn expected(rule: &Rule) -> Result<Vec<Attr>> {
     });
     // xt_conntrack_mtinfo3 is 164 bytes, XT_ALIGN'ed to 168 on both shipped
     // 64-bit Linux targets. All fields and padding are initialized explicitly.
+    // The original source address/mask are at 0/16, its ports at 138/154; the
+    // original destination's at 32/48 and 140/156.
     let mut conntrack=vec![0;168];
-    conntrack[..4].copy_from_slice(&address);
-    conntrack[16..32].fill(0xff); // canonical bare-host nf_inet_addr mask
-    for (offset,number) in [(136,protocol),(138,first),(146,0x1107),
-        (148,if reply {0x1000} else {0}),(150,if new {8} else {2}),(154,last)] {
+    let address=32*tracked_side;
+    conntrack[address..address+4].copy_from_slice(&tracked);
+    conntrack[address+16..address+32].fill(0xff); // canonical bare-host nf_inet_addr mask
+    // STATE|PROTO|DIRECTION with ORIGSRC|ORIGSRC_PORT or ORIGDST|ORIGDST_PORT.
+    let flags=0x1003|if tracked_side==0 {0x0104} else {0x0208};
+    let port=2*tracked_side;
+    for (offset,number) in [(136,protocol),(138+port,tracked_first),(146,flags),
+        (148,if reply {0x1000} else {0}),(150,if new {8} else {2}),(154+port,tracked_last)] {
         conntrack[offset..offset+2].copy_from_slice(&number.to_ne_bytes());
     }
     result.push(expr("match",vec![Attr::string(1,"conntrack"),Attr::u32(2,3),Attr::bytes(3,conntrack)]));