protocol(p25,audio,tests): keep P25P2 ENC audio gating aligned with media policy

Author: arancormonk

include/dsd-neo/core/audio.h

@@ -180,6 +180,8 @@ void audio_mix_mono_from_slots_f32(const float* left, const float* right, size_t
 
 /** @brief Simple P25 P2 per-slot mixer gate used by tests (maps p25_p2_audio_allowed -> enc flags). */
 int dsd_p25p2_mixer_gate(const dsd_state* state, int* encL, int* encR);
+/** @brief Return 1 when P25p2 decode should queue audio for the slot under decrypt and media policy. */
+int dsd_p25p2_decode_audio_allowed(const dsd_opts* opts, const dsd_state* state, int slot, int alg);
 
 /** @brief Flush partially buffered P25p2 SS18 audio on call end/release. */
 void dsd_p25p2_flush_partial_audio(dsd_opts* opts, dsd_state* state);

src/core/audio/dsd_audio_gate.c

@@ -72,6 +72,76 @@ dsd_p25p2_mixer_gate(const dsd_state* state, int* encL, int* encR) {
     return 0;
 }
 
+static int
+dsd_p25p2_slot_can_decrypt(const dsd_state* state, int slot, int alg) {
+    unsigned long long key = 0;
+    if (!state || slot < 0 || slot > 1) {
+        return 0;
+    }
+    if (alg == 0 || alg == 0x80) {
+        return 1;
+    }
+    key = (slot == 0) ? state->R : state->RR;
+    if ((alg == 0xAA || alg == 0x81 || alg == 0x9F) && key != 0ULL) {
+        return 1;
+    }
+    if ((alg == 0x84 || alg == 0x89) && state->aes_key_loaded[slot] == 1) {
+        return 1;
+    }
+    return 0;
+}
+
+static int
+dsd_p25p2_media_decision_allows_audio(const dsd_tg_policy_decision* decision) {
+    if (!decision) {
+        return 1;
+    }
+    if (decision->tg_hold_active && decision->tg_hold_match) {
+        return 1;
+    }
+    if (!decision->audio_allowed || (decision->block_reasons & DSD_TG_POLICY_BLOCK_ALLOWLIST) != 0u) {
+        return 0;
+    }
+    return 1;
+}
+
+int
+dsd_p25p2_decode_audio_allowed(const dsd_opts* opts, const dsd_state* state, int slot, int alg) {
+    dsd_tg_policy_decision decision;
+    int raw_target = 0;
+    int raw_source = 0;
+    uint32_t target = 0;
+    uint32_t source = 0;
+
+    if (!state || slot < 0 || slot > 1) {
+        return 0;
+    }
+    if (!dsd_p25p2_slot_can_decrypt(state, slot, alg)) {
+        return 0;
+    }
+
+    raw_target = (slot == 0) ? state->lasttg : state->lasttgR;
+    raw_source = (slot == 0) ? state->lastsrc : state->lastsrcR;
+    target = (raw_target > 0) ? (uint32_t)raw_target : 0u;
+    source = (raw_source > 0) ? (uint32_t)raw_source : 0u;
+    if (state->gi[slot] == 1) {
+        if (dsd_tg_policy_evaluate_private_call(opts, state, source, target, 0, 0,
+                                                DSD_TG_POLICY_PRIVATE_ALLOWLIST_UNKNOWN_BLOCK,
+                                                DSD_TG_POLICY_HOLD_FORCE_MEDIA_ONLY, &decision)
+            == 0) {
+            return dsd_p25p2_media_decision_allows_audio(&decision);
+        }
+    } else {
+        if (dsd_tg_policy_evaluate_group_call(opts, state, target, source, 0, 0, DSD_TG_POLICY_HOLD_FORCE_MEDIA_ONLY,
+                                              &decision)
+            == 0) {
+            return dsd_p25p2_media_decision_allows_audio(&decision);
+        }
+    }
+
+    return 0;
+}
+
 int
 dsd_audio_group_gate_mono(const dsd_opts* opts, const dsd_state* state, unsigned long tg, int enc_in, int* enc_out) {
     dsd_tg_policy_decision decision;

src/protocol/p25/p25_trunk_sm.c

@@ -5,6 +5,7 @@
  * Unified P25 trunking state machine.
  */
 
+#include <dsd-neo/core/audio.h>
 #include <dsd-neo/core/dsd_time.h>
 #include <dsd-neo/core/opts.h>
 #include <dsd-neo/core/state.h>
@@ -570,16 +571,21 @@ handle_enc(p25_sm_ctx_t* ctx, dsd_opts* opts, dsd_state* state, const p25_sm_eve
     int slot = (ev->slot >= 0 && ev->slot <= 1) ? ev->slot : 0;
     int algid = ev->algid;
     int tg = ev->tg;
+    int can_decrypt = 0;
+    int allow_audio = 0;
 
     // Store encryption params in slot context
     ctx->slots[slot].algid = algid;
     ctx->slots[slot].keyid = ev->keyid;
     ctx->slots[slot].tg = tg;
+    can_decrypt = slot_can_decrypt(state, slot, algid);
+    allow_audio = dsd_p25p2_decode_audio_allowed(opts, state, slot, algid);
 
     // Skip lockout processing if encryption lockout is disabled
     if (opts->trunk_tune_enc_calls != 0) {
-        // Still update audio gating based on decryptability
-        state->p25_p2_audio_allowed[slot] = slot_can_decrypt(state, slot, algid) ? 1 : 0;
+        // Even when encrypted calls are permitted, keep the gate aligned with
+        // the current media policy so allow-list/TG-hold blocks are not reopened.
+        state->p25_p2_audio_allowed[slot] = allow_audio;
         return;
     }
 
@@ -588,9 +594,10 @@ handle_enc(p25_sm_ctx_t* ctx, dsd_opts* opts, dsd_state* state, const p25_sm_eve
         return;
     }
 
-    // Skip if stream is clear or we have a key
-    if (slot_can_decrypt(state, slot, algid)) {
-        state->p25_p2_audio_allowed[slot] = 1;
+    // Decryptable encrypted calls still need to respect the current media
+    // policy; do not reopen slots that the caller already blocked.
+    if (can_decrypt) {
+        state->p25_p2_audio_allowed[slot] = allow_audio;
         return;
     }
 
@@ -1234,21 +1241,14 @@ p25_emit_enc_lockout_once(dsd_opts* opts, dsd_state* state, uint8_t slot, int tg
         return; // already marked; event previously emitted
     }
 
-    // Prepare per-slot context and clear encryption display variables for this slot
+    // Prepare per-slot context. Keep live encryption fields intact: callers may
+    // still need ALG/KID/MI after this helper returns to keep audio gates closed.
     if ((slot & 1) == 0) {
         state->lasttg = (uint32_t)tg;
         state->dmr_so = (uint16_t)svc_bits;
-        // Clear slot 0 encryption display variables to prevent stale UI
-        state->payload_algid = 0;
-        state->payload_keyid = 0;
-        state->payload_miP = 0;
     } else {
         state->lasttgR = (uint32_t)tg;
         state->dmr_soR = (uint16_t)svc_bits;
-        // Clear slot 1 encryption display variables to prevent stale UI
-        state->payload_algidR = 0;
-        state->payload_keyidR = 0;
-        state->payload_miN = 0;
     }
     state->gi[slot & 1] = 0;
 

src/protocol/p25/phase2/p25p2_frame.c

@@ -61,6 +61,31 @@ p25_p2_s16_frames_have_audio(short frames[18][160]) {
     return 0;
 }
 
+static int
+p25p2_frame_slot_audio_allowed(const dsd_opts* opts, const dsd_state* state, int slot, int alg) {
+#if defined(DSD_NEO_P25P2_TEST_STUB)
+    unsigned long long key = 0;
+    (void)opts;
+
+    if (!state || slot < 0 || slot > 1) {
+        return 0;
+    }
+    if (alg == 0 || alg == 0x80) {
+        return 1;
+    }
+    key = (slot == 0) ? state->R : state->RR;
+    if ((alg == 0xAA || alg == 0x81 || alg == 0x9F) && key != 0ULL) {
+        return 1;
+    }
+    if ((alg == 0x84 || alg == 0x89) && state->aes_key_loaded[slot] == 1) {
+        return 1;
+    }
+    return 0;
+#else
+    return dsd_p25p2_decode_audio_allowed(opts, state, slot, alg);
+#endif
+}
+
 // Clear per-slot audio gates, small audio rings, encryption indicators, and
 // UI call banners for both logical slots. Intended for use on call teardown
 // before returning to the control channel.
@@ -840,12 +865,7 @@ process_ESS(dsd_opts* opts, dsd_state* state) {
                 // protecting against stale re-enables after teardown.
                 int in_call = ((state->dmrburstL >= 20 && state->dmrburstL <= 22) || voice);
                 int alg = state->payload_algid;
-                int allow = (in_call
-                             && ((alg == 0 || alg == 0x80)
-                                 || (((alg == 0xAA || alg == 0x81 || alg == 0x9F) && state->R != 0)
-                                     || ((alg == 0x84 || alg == 0x89) && state->aes_key_loaded[0] == 1))))
-                                ? 1
-                                : 0;
+                int allow = in_call && p25p2_frame_slot_audio_allowed(opts, state, 0, alg);
                 if (allow) {
                     state->p25_p2_audio_allowed[0] = 1;
                 }
@@ -891,12 +911,7 @@ process_ESS(dsd_opts* opts, dsd_state* state) {
                 // context for the right slot, mirroring left-slot handling.
                 int in_call = ((state->dmrburstR >= 20 && state->dmrburstR <= 22) || voice);
                 int alg = state->payload_algidR;
-                int allow = (in_call
-                             && ((alg == 0 || alg == 0x80)
-                                 || (((alg == 0xAA || alg == 0x81 || alg == 0x9F) && state->RR != 0)
-                                     || ((alg == 0x84 || alg == 0x89) && state->aes_key_loaded[1] == 1))))
-                                ? 1
-                                : 0;
+                int allow = in_call && p25p2_frame_slot_audio_allowed(opts, state, 1, alg);
                 if (allow) {
                     state->p25_p2_audio_allowed[1] = 1;
                 }

src/protocol/p25/phase2/p25p2_vpdu.c

@@ -2486,8 +2486,9 @@ process_MAC_VPDU(dsd_opts* opts, dsd_state* state, int type, unsigned long long
                     // Mark and emit once via centralized helper
                     p25_emit_enc_lockout_once(opts, state, (uint8_t)slot, ttg, /*svc_bits*/ 0);
                 }
-                // Gate this slot only
+                // Gate this slot only and flush any queued audio to avoid residue
                 state->p25_p2_audio_allowed[slot] = 0;
+                p25_p2_audio_ring_reset(state, slot);
                 int other = slot ^ 1;
                 int other_audio = state->p25_p2_audio_allowed[other] || state->p25_p2_audio_ring_count[other] > 0;
                 if (!other_audio) {

src/protocol/p25/phase2/p25p2_xcch.c

@@ -10,6 +10,7 @@
  * 2022-09 DSD-FME Florida Man Edition
  *-----------------------------------------------------------------------------*/
 
+#include <dsd-neo/core/audio.h>
 #include <dsd-neo/core/constants.h>
 #include <dsd-neo/core/dsd_time.h>
 #include <dsd-neo/core/file_io.h>
@@ -28,6 +29,23 @@
 #include "dsd-neo/core/opts_fwd.h"
 #include "dsd-neo/core/state_fwd.h"
 
+static int
+p25p2_xcch_slot_audio_allowed(const dsd_opts* opts, const dsd_state* state, int slot) {
+    int alg = 0;
+
+    if (!state || slot < 0 || slot > 1) {
+        return 0;
+    }
+
+    if (slot == 0) {
+        alg = state->payload_algid;
+    } else {
+        alg = state->payload_algidR;
+    }
+
+    return dsd_p25p2_decode_audio_allowed(opts, state, slot, alg);
+}
+
 void
 process_SACCH_MAC_PDU(dsd_opts* opts, dsd_state* state, int payload[180]) {
     //Figure out which PDU we are looking at, see above info on 8.4.1
@@ -216,14 +234,7 @@ process_SACCH_MAC_PDU(dsd_opts* opts, dsd_state* state, int payload[180]) {
             }
             // Conditionally enable audio only if clear or decryptable
             {
-                int allow_audio = 0;
-                int alg = (slot == 0) ? state->payload_algid : state->payload_algidR;
-                unsigned long long key = (slot == 0) ? state->R : state->RR;
-                int aes_loaded = state->aes_key_loaded[slot];
-                if (alg == 0 || alg == 0x80 || ((alg == 0xAA || alg == 0x81 || alg == 0x9F) && key != 0)
-                    || ((alg == 0x84 || alg == 0x89) && aes_loaded == 1)) {
-                    allow_audio = 1; // clear or decryptable with key
-                }
+                int allow_audio = p25p2_xcch_slot_audio_allowed(opts, state, slot);
                 state->p25_p2_audio_allowed[slot] = allow_audio;
                 // Only set PTT burst indicator when audio is allowed; encrypted/locked-out
                 // calls should not influence audio routing decisions
@@ -295,14 +306,7 @@ process_SACCH_MAC_PDU(dsd_opts* opts, dsd_state* state, int payload[180]) {
             }
             // Conditionally enable audio only if clear or decryptable
             {
-                int allow_audio = 0;
-                int alg = (slot == 0) ? state->payload_algid : state->payload_algidR;
-                unsigned long long key = (slot == 0) ? state->R : state->RR;
-                int aes_loaded = state->aes_key_loaded[slot];
-                if (alg == 0 || alg == 0x80 || ((alg == 0xAA || alg == 0x81 || alg == 0x9F) && key != 0)
-                    || ((alg == 0x84 || alg == 0x89) && aes_loaded == 1)) {
-                    allow_audio = 1;
-                }
+                int allow_audio = p25p2_xcch_slot_audio_allowed(opts, state, slot);
                 state->p25_p2_audio_allowed[slot] = allow_audio;
                 // Only set PTT burst indicator when audio is allowed; encrypted/locked-out
                 // calls should not influence audio routing decisions
@@ -502,18 +506,7 @@ process_SACCH_MAC_PDU(dsd_opts* opts, dsd_state* state, int payload[180]) {
         fprintf(stderr, "%s", KNRM);
         // Enable audio per policy (respect encryption, key presence, and ignore stale packet bit when clear)
         {
-            int allow_audio = 0;
-            int alg = (slot == 0) ? state->payload_algid : state->payload_algidR;
-            unsigned long long key = (slot == 0) ? state->R : state->RR;
-            int aes_loaded = state->aes_key_loaded[slot];
-            // If stream is clear or decryptable, enable regardless of a stale Packet/Data flag
-            if (alg == 0 || alg == 0x80 || ((alg == 0xAA || alg == 0x81 || alg == 0x9F) && key != 0)
-                || ((alg == 0x84 || alg == 0x89) && aes_loaded == 1)) {
-                allow_audio = 1;
-            } else {
-                // Otherwise, suppress audio for Packet/Data sessions
-                allow_audio = state->p25_call_is_packet[slot] ? 0 : allow_audio;
-            }
+            int allow_audio = p25p2_xcch_slot_audio_allowed(opts, state, slot);
             state->p25_p2_audio_allowed[slot] = allow_audio;
 
             // Only set voice-active burst indicator when audio is allowed;
@@ -687,14 +680,7 @@ process_FACCH_MAC_PDU(dsd_opts* opts, dsd_state* state, int payload[156]) {
             }
             // Conditionally enable audio only if clear or decryptable
             {
-                int allow_audio = 0;
-                int alg = (slot == 0) ? state->payload_algid : state->payload_algidR;
-                unsigned long long key = (slot == 0) ? state->R : state->RR;
-                int aes_loaded = state->aes_key_loaded[slot];
-                if (alg == 0 || alg == 0x80 || ((alg == 0xAA || alg == 0x81 || alg == 0x9F) && key != 0)
-                    || ((alg == 0x84 || alg == 0x89) && aes_loaded == 1)) {
-                    allow_audio = 1; // clear or decryptable with key
-                }
+                int allow_audio = p25p2_xcch_slot_audio_allowed(opts, state, slot);
                 state->p25_p2_audio_allowed[slot] = allow_audio;
             }
         }
@@ -761,14 +747,7 @@ process_FACCH_MAC_PDU(dsd_opts* opts, dsd_state* state, int payload[156]) {
             }
             // Conditionally enable audio only if clear or decryptable
             {
-                int allow_audio = 0;
-                int alg = (slot == 0) ? state->payload_algid : state->payload_algidR;
-                unsigned long long key = (slot == 0) ? state->R : state->RR;
-                int aes_loaded = state->aes_key_loaded[slot];
-                if (alg == 0 || alg == 0x80 || ((alg == 0xAA || alg == 0x81 || alg == 0x9F) && key != 0)
-                    || ((alg == 0x84 || alg == 0x89) && aes_loaded == 1)) {
-                    allow_audio = 1;
-                }
+                int allow_audio = p25p2_xcch_slot_audio_allowed(opts, state, slot);
                 state->p25_p2_audio_allowed[slot] = allow_audio;
             }
         }
@@ -961,16 +940,7 @@ process_FACCH_MAC_PDU(dsd_opts* opts, dsd_state* state, int payload[156]) {
         p25_sm_emit_active(opts, state, slot);
         // Enable audio per policy (respect encryption, key presence, and ignore stale packet bit when clear)
         {
-            int allow_audio = 0;
-            int alg = (slot == 0) ? state->payload_algid : state->payload_algidR;
-            unsigned long long key = (slot == 0) ? state->R : state->RR;
-            int aes_loaded = state->aes_key_loaded[slot];
-            if (alg == 0 || alg == 0x80 || ((alg == 0xAA || alg == 0x81 || alg == 0x9F) && key != 0)
-                || ((alg == 0x84 || alg == 0x89) && aes_loaded == 1)) {
-                allow_audio = 1; // clear or decryptable with key
-            } else {
-                allow_audio = state->p25_call_is_packet[slot] ? 0 : allow_audio;
-            }
+            int allow_audio = p25p2_xcch_slot_audio_allowed(opts, state, slot);
             state->p25_p2_audio_allowed[slot] = allow_audio;
         }