fix(dmr): generic gateway forwarding and custom TG maps

.gitignore

@@ -5,3 +5,9 @@ reflector/urfd.*
 urfd
 inicheck
 dbutil
+.devcontainer/
+/test_urfd.ini
+/staging_urfd.ini
+/pr_comment_nng.md
+/pr_body_fix.md
+/staging/

config/urfd.ini

@@ -43,6 +43,17 @@ DescriptionM = M17 Chat
 DescriptionS = DStar Chat
 DescriptionZ = Temp Meeting
 
+[Dashboard]
+Enable = true
+NNGAddr = tcp://127.0.0.1:5555
+Interval = 10
+NNGDebug = false
+
+
+[Audio]
+Enable = false
+Path = ./audio/
+
 [Transcoder]
 Port = 10100 # TCP listening port for connection(s), set to 0 if there is no transcoder, then other two values will be ignored
 BindingAddress = 127.0.0.1 # or ::1, the IPv4 or IPv6 "loop-back" address for a local transcoder
@@ -66,6 +77,10 @@ Port = 20001
 [G3]
 Enable = true
 
+[IMRS]
+Enable = false
+Port = 21110
+
 [DMRPlus]
 Port =  8880
 
@@ -101,6 +116,7 @@ Module = A # this has to be a transcoded module!
 [YSF]
 Port = 42000
 AutoLinkModule = A  # comment out if you want to disable AL
+EnableDGID = false
 DefaultTxFreq = 446500000
 DefaultRxFreq = 446500000
 # if you've registered your reflector at register.ysfreflector.de:

docs/DMR_Mini_Mode.md

@@ -0,0 +1,113 @@
+# Flexible DMR Mode (Mini DMR) User Guide
+
+URFD now supports a "Flexible DMR" mode (often called "Mini DMR"), which changes how DMR clients interact with the reflector. Unlike the legacy "XLX" mode where clients link to a specific module (A-Z) and traffic is bridged, Mini DMR mode allows clients to directly subscribe to Talkgroups (TG).
+
+## How it Works
+
+In Mini DMR mode, the reflector acts like a **Scanner**.
+
+1. **Subscriptions**: You "subscribe" to one or more Talkgroups on a Timeslot (TS1 or TS2).
+2. **Scanning**: The reflector monitors all your subscribed Talkgroups.
+3. **Hold Time**: When a Talkgroup becomes active (someone speaks), the scanner "locks" onto that Talkgroup for the duration of the transmission plus a **Hold Time** (default 5 seconds). During this hold, traffic from other Talkgroups is blocked to prevent interruption.
+
+```mermaid
+graph TD
+    Client[MMDVM Client] -->|Subscribe TG 3100 TS1| Reflector
+    Client -->|Subscribe TG 4001 TS2| Reflector
+
+    subgraph Reflector Logic
+        TrafficA[Traffic on TG 3100] --> Scanner{Scanner Free?}
+        TrafficB[Traffic on TG 4001] --> Scanner
+
+        Scanner -->|Yes| Lock[Lock onto TG 3100]
+        Lock --> Map["Route to Client (TS1)"]
+
+        Scanner -->|"No (Held by 3100)"| Block[Block TG 4001]
+    end
+
+    Map --> Client
+```
+
+### Strict Timeslot Routing
+
+The reflector enforces strict routing based on your subscription:
+
+* If you subscribe to **TG 3100 on TS1**, traffic for TG 3100 will **only** be sent to your radio on **Timeslot 1**.
+* If you subscribe to **TG 4001 on TS2**, traffic for TG 4001 will **only** be sent to your radio on **Timeslot 2**.
+* This allows a single client to monitor different Talkgroups on different Timeslots simultaneously (if the Scanner is not held by one).
+
+## Configuration
+
+To enable Mini DMR mode, update your `urfd.ini` (or configuration file) in the `[DMR]` section:
+
+```ini
+[DMR]
+; Disable legacy XLX behavior (REQUIRED for Dashboard Subscription View)
+XlxCompatibility=false
+
+; Optional: enforce single subscription per timeslot (default false)
+SingleMode=false
+
+; Scanner Hold Time in seconds (default 5)
+HoldTime=5
+
+; Dynamic Subscription Timeout in seconds (default 600 / 10 mins)
+; 0 = Infinite
+DefaultTimeout=600
+
+; Module to Talkgroup Mapping (Optional)
+; Maps Module A to TG 4001, B to 4002, etc. automatically.
+; You can override specific maps:
+MapA=4001
+MapB=4002
+
+; IMPORTANT: Any module you map (e.g. A, B) MUST be enabled in the [Modules] section!
+; If Module A is not enabled, traffic for TG 4001 will be dropped.
+```
+
+## Usage
+
+### 1. Subscribing via PTT (Push-To-Talk)
+
+The easiest way to subscribe to a Talkgroup is to simply **transmit** on it from your radio.
+
+* **Action**: Key up (PTT) on `TG 1234`.
+* **Result**: The reflector detects your transmission and automatically subscribes you to `TG 1234` for the configured timeout duration (e.g., 10 minutes).
+* **Renewal**: If you are already subscribed, keying up again will **reset the timeout timer** back to the full duration.
+* **Note**: The first transmission might be muted (Anti-Kerchunk) to prevent noise, but you will immediately be subscribed.
+
+### 2. Subscribing via Options String
+
+You can manage subscriptions sent from your MMDVM hotspot/repeater configuration (or Pi-Star Options field).
+
+* **Format**: `TS1=TG_ID;TS2=TG_ID;AUTO=TIMEOUT`
+* **Example**: `TS2=3100,4001;AUTO=600`
+  * Subscribes Timeslot 2 to TG 3100 and TG 4001.
+  * Sets timeout to 600 seconds.
+
+### 3. Disconnecting / Unsubscribing
+
+* **Disconnect All**: Transmit a Group Call to **TG 4000**. This clears all dynamic subscriptions on that timeslot.
+* **Single Mode**: If `SingleMode=true` is set in config, transmitting on a *new* Talkgroup automatically unsubscribes you from the previous one.
+
+### 4. Talkgroup 9 (Reflector)
+
+* Traffic on **TG 9** is treated as local reflector traffic (linked functionality) if the client is essentially "linked" to a module, but in Mini DMR mode, TG 9 behavior depends on the specific map configuration or defaults. Typically, use specific Talkgroups for wide-area routing.
+
+## Dashboard
+
+The URFD Dashboard includes a dedicated **DMR** page (`/dmr`) to monitor Flexible DMR Mode activity.
+
+* **Active Subscriptions**: Shows all Talkgroups a client is monitoring, along with the specific Timeslot.
+* **Timers**: Displays a real-time countdown for Dynamic Subscriptions. Static subscriptions are marked as `Static`.
+* **DMR ID**: Displays the client's DMR ID alongside their callsign (e.g., `CALLSIGN (3100123)`).
+* **Requirements**: The dashboard requires NO additional configuration. It automatically displays data once `XlxCompatibility=false` is set in the backend config.
+
+## Troubleshooting
+
+### "Recordings are blank" or "No Traffic on other modes"
+
+If clients can connect and transmit but you see no traffic on other protocols (M17, YSF) or blank recordings:
+
+* **Check Modules**: Ensure the mapped Module (e.g. A for TG 4001) is defined and **enabled** in your `[Modules]` configuration.
+* **Log Check**: Look for `Can't find module 'X' for Client ...` errors in the reflector log.

docs/MINIDMR_Architecture.md

@@ -0,0 +1,184 @@
+# Investigation and Fix Plan: Flexible DMR Mode
+
+## Problem Description
+
+User wants to support two modes of operation for DMR:
+
+1. **XLX Mode** (Default): Legacy behaviors. MMDVM clients "link" to a module.
+2. **Mini DMR Mode** (New): MMDVM clients do not "link". Modules are mapped to Talkgroups. Clients "subscribe" to TGs.
+
+## Analysis
+
+- **Modes**:
+  - `XLXCompatibility`: Legacy mode.
+  - `Mini DMR Mode`: Direct TG mapping.
+- **Subscription Logic**:
+  - **Single Mode**: Only one TG allowed per timeslot. New TG replaces old.
+  - **Multi Mode**: Multiple subscriptions allowed per timeslot.
+  - **Scanner / Hold**: If >1 subscription, hold onto active TG for X seconds (default 5s) after idle before switching.
+- **Timeouts**:
+  - Dynamic subscriptions expire after configurable time (default 10 mins).
+  - Configurable per connection via Options string/password.
+  - Static subscriptions (via config/options) do not expire.
+- **Scope**:
+  - Only TGs defined in the Reflector's Module Map (plus 4000) are valid.
+- **Anti-Kerchunk**:
+  - If a client Subscribes via PTT (first time), ignore/mute that transmission to prevent broadcasting unnecessary noise.
+
+## Proposed Changes
+
+### Configuration
+
+- [ ] Modify `JsonKeys.h` / `Configure.h` / `Configure.cpp`:
+  - `Dmr.XlxCompatibility` (bool, default true).
+  - `Dmr.ModuleMap` (map/object).
+  - `Dmr.SingleMode` (bool, default false).
+  - `Dmr.DefaultTimeout` (int, default 600s).
+  - `Dmr.HoldTime` (int, default 5s).
+
+### Client State (`DMRMMDVMClient`)
+
+- [ ] Add `Subscription` structure:
+  - `TalkgroupId`
+  - `Timeslot`
+  - `Expiry` (timestamp or 0 for static)
+- [ ] Add `ScannerState`:
+  - `CurrentSpeakingTG`
+  - `HoldExpiry`
+- [ ] Add `Subscriptions` container (list/map).
+
+### Reflector Logic (`DMRMMDVMProtocol.cpp`)
+
+- [ ] **Options Parsing**:
+  - Parse "Options" string (e.g., `TS1=4001;AUTO=600`) from RPTC Description/Password.
+- [ ] **Incoming Packet (`OnDvHeaderPacketIn`)**:
+  - If `!XlxCompatibility`:
+    - **Validate**: TG must be in `ModuleMap` or 4000.
+    - **Unsubscribe**: If TG 4000, remove subscription (or all depending on logic).
+    - **Subscribe**:
+      - Thread-safe update of subscriptions via `CDMRScanner`.
+      - **First PTT Logic**: If this is a *new* dynamic subscription, flag stream as `Muted` or don't propagate.
+- [ ] **Outgoing/Queue Handling (`HandleQueue`)**:
+  - Filter logic:
+    - Thread-safe check of `CheckPacketAccess(tg)`.
+    - Scanner Logic handled internally in `CDMRScanner` with mutex protection.
+
+## Architecture Diagram
+
+```mermaid
+graph TD
+    Client[MMDVM Client] -->|UDP Packet| Protocol[DMRMMDVMProtocol]
+    Protocol -->|Parse Header| CheckMode{XlxCompatibility?}
+
+    %% XLX Path
+    CheckMode -->|True| XLXLogic[Legacy XLX Logic]
+    XLXLogic -->|TG 9| Core[Reflector Core]
+
+    %% Mini DMR Path
+    CheckMode -->|False| MiniLogic[Mini DMR Logic]
+
+    subgraph CDMRScanner ["class CDMRScanner"]
+        MiniLogic -->|Check Access| ScannerState{State Check}
+        ScannerState -->|Blocked| Drop[Drop Packet]
+        ScannerState -->|Allowed| UpdateTimer[Update Hold Timer]
+    end
+
+    UpdateTimer -->|Mapped TG| Core
+
+    %% Configuration Flow
+    Config[RPTC Packet] -->|Description/Opts| Parser[Options Parser]
+    Parser -->|Update| Subs[Subscription List]
+    Subs -.-> ScannerState
+```
+
+## Cross-Protocol Traffic Flow (Outbound)
+
+```mermaid
+graph TD
+    Src[Source Protocol e.g. YSF] -->|Audio on Module B| Core[Reflector Core]
+    Core -->|Queue Packet| DMRQueue[DMRMMDVMProtocol::HandleQueue]
+
+    subgraph "Handle Queue Logic"
+        DMRQueue --> Encode1[Encode Buffer TS1]
+        DMRQueue --> Encode2[Encode Buffer TS2]
+
+        Encode1 --> ClientCheck{Client Subscribed?}
+        Encode2 --> ClientCheck
+
+        ClientCheck -->|TG + TS1| Send1[Send TS1 Buffer]
+        ClientCheck -->|TG + TS2| Send2[Send TS2 Buffer]
+        ClientCheck -->|No| Drop[Drop]
+    end
+
+    Send1 --> Client[MMDVM Client]
+    Send2 --> Client
+```    %% Mini DMR Logic
+    MapLookup -->|Yes| Map[Map Module B -> TG 4002]
+    Map -->|TG 4002| ScannerCheck{Scanner Check}
+
+    subgraph CDMRScanner
+        ScannerCheck -->|Client Subscribed?| SubCheck{Subscribed?}
+        SubCheck -->|No| Drop[Drop]
+        SubCheck -->|Yes| HoldCheck{Hold Timer Active?}
+
+        HoldCheck -->|Held by other TG| Drop
+        HoldCheck -->|Free / Same TG| Allowed[Allow]
+    end
+
+    Allowed --> SendMini[Send UDP Packet TG 4002]
+```
+
+## Architecture Decision
+
+- **Unified Protocol Class**: We will keep `DMRMMDVMProtocol` as the single class handling the UDP/DMR wire protocol.
+  - **Reasoning**: Both "XLX" and "Mini DMR" modes share identical packet structures, parsing, connection handshakes (RPTL/RPTK), and keepalive mechanisms. Splitting them would require either duplicating this transport logic or creating a complex inheritance hierarchy.
+- **Logic Separation**: instead of polluting `DMRMMDVMProtocol.cpp` with mixed logic:
+  - **Legacy/XLX Logic**: Remains inline (simple routing 9->9).
+  - **New/Mini Logic**: Encapsulated in `CDMRScanner`. The Protocol class will call checking methods on the scanner.
+  - **Toggle**: A simple `if (m_XlxCompatibility)` check at the routing decision points (packet ingress/egress) will switch behavior.
+
+## Safety & Robustness Logic
+
+- **Concurrency**:
+  - `CDMRScanner` will encapsulate all state (`Subscriptions`, `HoldTimer`, `CurrentTG`) protected by an internal `std::recursive_mutex`.
+  - **Deadlock Prevention**: `CDMRScanner` methods will be leaf-node operations (never calling out to other complex locked systems).
+  - Access to `CDMRScanner` from `DMRMMDVMProtocol` will be done via thread-safe public methods only.
+- **Memory Safety**:
+  - Avoid raw `char*` manipulation for Options parsing; use `std::string`.
+  - Input Description field will be clamped to `RPTC` max length (checked in `IsValidConfigPacket` before parsing).
+  - No fixed-size buffers for variable lists (use `std::vector` for TGs).
+
+## Testing Strategy (TDD)
+
+- **Objective**: Verify complex logic (Subscription management, Timeout, Scanner checks) in isolation without needing full network stack (mocking `DMRMMDVMProtocol/Client`).
+- **Plan**:
+  - Create `reflector/DMRScanner.h/cpp` (or similar) to encapsulate the logic:
+    - `class CDMRScanner`:
+      - `AddSubscription(tg, ts, timeout)`
+      - `RemoveSubscription(tg, ts)`
+      - `IsSubscribed(tg)`
+      - `CheckPacketAccess(tg)` -> Validates against Hold timer & Single Mode.
+      - **Safety Tests**: Verify behavior under high-concurrency (if possible in unit test) or logic edge cases.
+  - Create `reflector/test_dmr.cpp`:
+    - A standalone test file similar to `test_audio.cpp`.
+    - **Scenarios**:
+            1. **Single Mode**: Add TG1, Add TG2 -> Assert TG1 removed.
+            2. **Scanner Hold**: Packet from TG1 accepted. Immediately Packet from TG2 -> Rejected (Hold active). Wait 5s -> Packet from TG2 Accepted.
+            3. **Timeout**: Add TG dynamic (timeout 1s). Wait 2s -> Assert TG removed.
+            4. **Options Parsing**: Feed "TS1=1,2;AUTO=300" string -> Verify Subscriptions present.
+            5. **Buffer Safety**: Feed malformed/oversized Option strings -> Verify no crash/leak.
+  - **Build**: Add `test_dmr` target to `Makefile`.
+
+## Verification Plan
+
+- [ ] **Run TDD Tests**: `make test_dmr && ./reflector/test_dmr`
+- [ ] **Manual Verification**:
+  - **Test Configurations**:
+    - Single Mode: Verify PTT on TG A drops TG B.
+    - Multi Mode: Verify PTT on A adds A (keeping B).
+  - **Test Scanner**:
+    - Sub to A and B. Transmit on A. Verify B is blocked during Hold time.
+  - **Test Timeout**:
+    - Set short timeout. Verify subscription drops.
+  - **Test Kerchunk**:
+    - PTT on new TG. Verify not heard by others. Second PTT heard.