mirror of
https://github.com/lwvmobile/dsd-fme.git
synced 2026-11-16 10:47:21 -05:00
NXDN Type-D Decoding/Trunking; NXDN Tweaks; #115
This commit is contained in:
@@ -55,8 +55,6 @@ void NXDN_Elements_Content_decode(dsd_opts * opts, dsd_state * state,
|
||||
MessageType |= (ElementsContent[6] & 1) << 1;
|
||||
MessageType |= (ElementsContent[7] & 1) << 0;
|
||||
|
||||
nxdn_message_type (opts, state, MessageType);
|
||||
|
||||
/* Save the "F1" and "F2" flags */
|
||||
state->NxdnElementsContent.F1 = ElementsContent[0];
|
||||
state->NxdnElementsContent.F2 = ElementsContent[1];
|
||||
@@ -64,21 +62,30 @@ void NXDN_Elements_Content_decode(dsd_opts * opts, dsd_state * state,
|
||||
/* Save the "Message Type" field */
|
||||
state->NxdnElementsContent.MessageType = MessageType;
|
||||
|
||||
/* Set the CRC state */
|
||||
state->NxdnElementsContent.VCallCrcIsGood = CrcCorrect;
|
||||
|
||||
/* Decode the right "Message Type" */
|
||||
switch(MessageType)
|
||||
{
|
||||
//VCALL_ASSGN
|
||||
case 0x04:
|
||||
//continue flow to DUP, both use same message format
|
||||
//Debug: Disable DUP messages if they cause random issues with Type-C trunking (i.e. changing SRC ang TGT IDs, hopping in the middle of calls, etc)
|
||||
|
||||
//VCALL_ASSGN_DUP
|
||||
case 0x05:
|
||||
|
||||
//DCALL_ASSGN_DUP
|
||||
case 0x0D:
|
||||
|
||||
//VCALL_ASSGN
|
||||
case 0x04:
|
||||
|
||||
//DCALL_ASSGN
|
||||
case 0x0E:
|
||||
NXDN_decode_VCALL_ASSGN(opts, state, ElementsContent);
|
||||
break;
|
||||
|
||||
//Alias 0x3F
|
||||
case 0x3F:
|
||||
state->NxdnElementsContent.VCallCrcIsGood = CrcCorrect;
|
||||
NXDN_decode_Alias(opts, state, ElementsContent);
|
||||
break;
|
||||
|
||||
@@ -102,9 +109,16 @@ void NXDN_Elements_Content_decode(dsd_opts * opts, dsd_state * state,
|
||||
NXDN_decode_adj_site(opts, state, ElementsContent);
|
||||
break;
|
||||
|
||||
//VCALL, TX_REL_EXT and TX_REL
|
||||
case 0x01:
|
||||
case 0x07:
|
||||
case 0x08:
|
||||
NXDN_decode_VCALL(opts, state, ElementsContent);
|
||||
break;
|
||||
|
||||
//DISC
|
||||
case 0x11:
|
||||
//NXDN_decode_VCALL(opts, state, ElementsContent);
|
||||
NXDN_decode_VCALL(opts, state, ElementsContent);
|
||||
|
||||
//tune back to CC here - save about 1-2 seconds
|
||||
if (opts->p25_trunk == 1 && state->p25_cc_freq != 0 && opts->p25_is_tuned == 1)
|
||||
@@ -115,8 +129,6 @@ void NXDN_Elements_Content_decode(dsd_opts * opts, dsd_state * state,
|
||||
//extra safeguards due to sync issues with NXDN
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
|
||||
// state->lastsynctype = -1;
|
||||
// state->last_cc_sync_time = time(NULL);
|
||||
opts->p25_is_tuned = 0;
|
||||
if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
|
||||
SetFreq(opts->rigctl_sockfd, state->p25_cc_freq);
|
||||
@@ -128,8 +140,6 @@ void NXDN_Elements_Content_decode(dsd_opts * opts, dsd_state * state,
|
||||
//extra safeguards due to sync issues with NXDN
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
|
||||
// state->lastsynctype = -1;
|
||||
// state->last_cc_sync_time = time(NULL);
|
||||
opts->p25_is_tuned = 0;
|
||||
rtl_udp_tune (opts, state, state->p25_cc_freq);
|
||||
}
|
||||
@@ -139,60 +149,12 @@ void NXDN_Elements_Content_decode(dsd_opts * opts, dsd_state * state,
|
||||
|
||||
//Idle
|
||||
case 0x10:
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
/* VCALL */
|
||||
case 0x01:
|
||||
{
|
||||
|
||||
/* Set the CRC state */
|
||||
state->NxdnElementsContent.VCallCrcIsGood = CrcCorrect;
|
||||
|
||||
/* Decode the "VCALL" message */
|
||||
NXDN_decode_VCALL(opts, state, ElementsContent);
|
||||
|
||||
/* Check the "Cipher Type" and the "Key ID" validity */
|
||||
if(CrcCorrect)
|
||||
{
|
||||
state->NxdnElementsContent.CipherParameterValidity = 1;
|
||||
}
|
||||
else state->NxdnElementsContent.CipherParameterValidity = 0;
|
||||
break;
|
||||
} /* End case NXDN_VCALL: */
|
||||
|
||||
/* VCALL_IV */
|
||||
case 0x03:
|
||||
{
|
||||
|
||||
/* Set the CRC state */
|
||||
state->NxdnElementsContent.VCallIvCrcIsGood = CrcCorrect;
|
||||
|
||||
/* Decode the "VCALL_IV" message */
|
||||
//VCALL_IV
|
||||
case 0x03:
|
||||
NXDN_decode_VCALL_IV(opts, state, ElementsContent);
|
||||
|
||||
if(CrcCorrect)
|
||||
{
|
||||
/* CRC is correct, copy the next theorical IV to use directly from the
|
||||
* received VCALL_IV */
|
||||
memcpy(state->NxdnElementsContent.NextIVComputed, state->NxdnElementsContent.IV, 8);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* CRC is incorrect, compute the next IV to use */
|
||||
CurrentIV = 0;
|
||||
|
||||
/* Convert the 8 bytes buffer into a 64 bits integer */
|
||||
for(i = 0; i < 8; i++)
|
||||
{
|
||||
CurrentIV |= state->NxdnElementsContent.NextIVComputed[i];
|
||||
CurrentIV = CurrentIV << 8;
|
||||
}
|
||||
|
||||
}
|
||||
break;
|
||||
} /* End case NXDN_VCALL_IV: */
|
||||
|
||||
/* Unknown Message Type */
|
||||
default:
|
||||
@@ -201,6 +163,8 @@ void NXDN_Elements_Content_decode(dsd_opts * opts, dsd_state * state,
|
||||
}
|
||||
} /* End switch(MessageType) */
|
||||
|
||||
nxdn_message_type (opts, state, MessageType);
|
||||
|
||||
} /* End NXDN_Elements_Content_decode() */
|
||||
|
||||
//externalize multiple sub-element handlers
|
||||
@@ -368,6 +332,20 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
|
||||
uint8_t DuplexMode[32] = {0};
|
||||
uint8_t TransmissionMode[32] = {0};
|
||||
|
||||
uint8_t MessageType;
|
||||
/* Get the "Message Type" field */
|
||||
MessageType = (Message[2] & 1) << 5;
|
||||
MessageType |= (Message[3] & 1) << 4;
|
||||
MessageType |= (Message[4] & 1) << 3;
|
||||
MessageType |= (Message[5] & 1) << 2;
|
||||
MessageType |= (Message[6] & 1) << 1;
|
||||
MessageType |= (Message[7] & 1) << 0;
|
||||
|
||||
if (MessageType == 0x4) fprintf (stderr, "%s", KGRN); //VCALL_ASSGN
|
||||
else if (MessageType == 0x05) fprintf (stderr, "%s", KGRN); //VCALL_ASSGN_DUP
|
||||
else if (MessageType == 0x0E) fprintf (stderr, "%s", KCYN); //DCALL_ASSGN
|
||||
else if (MessageType == 0x0D) fprintf (stderr, "%s", KCYN); //DCALL_ASSGN_DUP
|
||||
|
||||
//DFA specific variables
|
||||
uint8_t bw = 0;
|
||||
uint16_t OFN = 0;
|
||||
@@ -406,35 +384,88 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
|
||||
OFN = (uint16_t)ConvertBitIntoBytes(&Message[64], 16);
|
||||
IFN = (uint16_t)ConvertBitIntoBytes(&Message[80], 16);
|
||||
}
|
||||
|
||||
//Part 1-E Common Air Interface Ver.1.3 - 6.4.1.23. Voice Call Assignment (VCALL_ASSGN)
|
||||
//While I've only seen Busy Repeater Message on the SCCH message (different format)
|
||||
//The manual suggests this message exists on Type-D systems with this configuration
|
||||
|
||||
//On Type-D systems, need to truncate to an 11-bit value
|
||||
//other 5-bits are repeater or prefix value
|
||||
// uint8_t idas = 0;
|
||||
// uint8_t rep1 = 0;
|
||||
// uint8_t rep2 = 0;
|
||||
// if (strcmp (state->nxdn_location_category, "Type-D") == 0) idas = 1;
|
||||
// if (idas)
|
||||
// {
|
||||
// rep1 = (SourceUnitID >> 11) & 0x1F;
|
||||
// rep2 = (DestinationID >> 11) & 0x1F;
|
||||
// SourceUnitID = SourceUnitID & 0x7FF;
|
||||
// DestinationID = DestinationID & 0x7FF;
|
||||
// //assign source prefix/rep1 as the tune to channel?
|
||||
// //In normal VCALL, both prefix/rep values are the same on the Type-D samples I have
|
||||
// Channel = rep1;
|
||||
// }
|
||||
|
||||
if (MessageType == 0x4 || MessageType == 0x5)
|
||||
fprintf (stderr, "%s", KGRN); //VCALL_ASSGN
|
||||
else fprintf (stderr, "%s", KCYN); //DCALL_ASSGN
|
||||
|
||||
fprintf (stderr, "\n ");
|
||||
|
||||
/* Print the "CC Option" */
|
||||
if(CCOption & 0x80) fprintf(stderr, "Emergency ");
|
||||
if(CCOption & 0x40) fprintf(stderr, "Visitor ");
|
||||
if(CCOption & 0x20) fprintf(stderr, "Priority Paging ");
|
||||
|
||||
/* Print the "Call Type" */
|
||||
fprintf (stderr, "%s", KGRN);
|
||||
fprintf(stderr, "\n %s - ", NXDN_Call_Type_To_Str(CallType));
|
||||
fprintf(stderr, "%s - ", NXDN_Call_Type_To_Str(CallType));
|
||||
|
||||
/* Print the "Voice Call Option" */
|
||||
NXDN_Voice_Call_Option_To_Str(VoiceCallOption, DuplexMode, TransmissionMode);
|
||||
fprintf(stderr, "%s %s - ", DuplexMode, TransmissionMode);
|
||||
if (MessageType == 0x4 || MessageType == 0x5) NXDN_Voice_Call_Option_To_Str(VoiceCallOption, DuplexMode, TransmissionMode);
|
||||
if (MessageType == 0x4 || MessageType == 0x5) fprintf(stderr, "%s %s - ", DuplexMode, TransmissionMode);
|
||||
else fprintf (stderr, " Data Call Assignment - "); //DCALL_ASSGN or DCALL_ASSGN_DUP
|
||||
|
||||
/* Print Source ID and Destination ID (Talk Group or Unit ID) */
|
||||
fprintf(stderr, "Src=%u - Dst/TG=%u ", SourceUnitID & 0xFFFF, DestinationID & 0xFFFF);
|
||||
|
||||
// if (idas) fprintf (stderr, "- Ch: %d ", rep1);
|
||||
|
||||
/* Print Channel */
|
||||
if (state->nxdn_rcn == 0)
|
||||
fprintf(stderr, "- Channel [%03X][%04d] ", Channel & 0x3FF, Channel & 0x3FF);
|
||||
if (state->nxdn_rcn == 1)
|
||||
{
|
||||
fprintf(stderr, "- DFA Channel [%04X][%05d] ", OFN, OFN);
|
||||
//running the BW here is a bit repetitive since running the call type/option will echo the same thing
|
||||
// if (bw == 0) fprintf (stderr, "BW: 6.25 kHz - 4800 bps");
|
||||
// else if (bw == 1) fprintf (stderr, "BW: 12.5 kHz - 9600 bps");
|
||||
// else fprintf (stderr, "BW: %d Reserved Value", bw);
|
||||
|
||||
//test VCALL_ASSGN_DUP, if no voice sync activity in 1-2 seconds, then convert to assgn and allow tuning
|
||||
//VCALL_ASSGN_DUP has been seen in the middle of calls, but also on the tail end instead of a TX_REL or DISC
|
||||
if (MessageType == 0x5 && opts->p25_is_tuned == 1 && opts->p25_trunk == 1)
|
||||
{
|
||||
if ( (time(NULL) - state->last_vc_sync_time) > 1 )
|
||||
{
|
||||
MessageType = 0x04; //convert to VCALL
|
||||
opts->p25_is_tuned = 0; //open tuning back up to tune
|
||||
}
|
||||
}
|
||||
|
||||
//Add support for tuning data and group/private calls on trunking systems
|
||||
uint8_t tune = 0;
|
||||
|
||||
//DCALL_ASSGN and DCALL_ASSGN_DUP
|
||||
if (MessageType == 0x0D || MessageType == 0x0E )
|
||||
{
|
||||
if (opts->trunk_tune_data_calls == 1) tune = 1;
|
||||
}
|
||||
else if (MessageType == 0x04) //VCALL_ASSGN and converted VCALL_ASSGN_DUP
|
||||
{
|
||||
if (CallType == 4) //individual/private call
|
||||
{
|
||||
if (opts->trunk_tune_private_calls) tune = 1;
|
||||
}
|
||||
else if (opts->trunk_tune_group_calls) tune = 1;
|
||||
}
|
||||
|
||||
if (tune == 0) goto END_ASSGN;
|
||||
|
||||
//run process to figure out frequency value from the channel import or from DFA
|
||||
long int freq = 0;
|
||||
if (state->nxdn_rcn == 0)
|
||||
@@ -442,11 +473,6 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
|
||||
if (state->nxdn_rcn == 1)
|
||||
freq = nxdn_channel_to_frequency(opts, state, OFN);
|
||||
|
||||
//check the rkey array for a scrambler key value
|
||||
//TGT ID and Key ID could clash though if csv or system has both with different keys
|
||||
if (state->rkey_array[DestinationID] != 0) state->R = state->rkey_array[DestinationID];
|
||||
if (state->M == 1) state->nxdn_cipher_type = 0x1;
|
||||
|
||||
//check for control channel frequency in the channel map if not available
|
||||
if (opts->p25_trunk == 1 && state->p25_cc_freq == 0)
|
||||
{
|
||||
@@ -492,7 +518,7 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
|
||||
//check to see if the source/target candidate is blocked first
|
||||
if (opts->p25_trunk == 1 && (strcmp(mode, "DE") != 0) && (strcmp(mode, "B") != 0)) //DE is digital encrypted, B is block
|
||||
{
|
||||
if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency already
|
||||
if (state->p25_cc_freq != 0 && opts->p25_is_tuned == 0 && freq != 0) //if we aren't already on a VC and have a valid frequency
|
||||
{
|
||||
//rigctl
|
||||
if (opts->use_rigctl == 1)
|
||||
@@ -502,7 +528,7 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
|
||||
state->lastsynctype = -1;
|
||||
state->last_cc_sync_time = time(NULL);
|
||||
state->last_vc_sync_time = time(NULL); //useful?
|
||||
state->last_vc_sync_time = time(NULL);
|
||||
//
|
||||
|
||||
if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
|
||||
@@ -511,9 +537,19 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
|
||||
opts->p25_is_tuned = 1; //set to 1 to set as currently tuned so we don't keep tuning nonstop
|
||||
|
||||
//set rid and tg when we actually tune to it
|
||||
state->nxdn_last_rid = SourceUnitID & 0xFFFF;
|
||||
state->nxdn_last_tg = (DestinationID & 0xFFFF);
|
||||
state->nxdn_last_rid = SourceUnitID;
|
||||
state->nxdn_last_tg = DestinationID;
|
||||
sprintf (state->nxdn_call_type, "%s", NXDN_Call_Type_To_Str(CallType));
|
||||
|
||||
//check the rkey array for a scrambler key value
|
||||
//TGT ID and Key ID could clash though if csv or system has both with different keys
|
||||
if (state->rkey_array[DestinationID] != 0)
|
||||
{
|
||||
state->R = state->rkey_array[DestinationID];
|
||||
fprintf (stderr, " %s", KYEL);
|
||||
fprintf (stderr, " Key Loaded: %lld", state->rkey_array[DestinationID]);
|
||||
}
|
||||
if (state->M == 1) state->nxdn_cipher_type = 0x1;
|
||||
}
|
||||
//rtl_udp
|
||||
else if (opts->audio_in_type == 3)
|
||||
@@ -531,14 +567,25 @@ void NXDN_decode_VCALL_ASSGN(dsd_opts * opts, dsd_state * state, uint8_t * Messa
|
||||
opts->p25_is_tuned = 1;
|
||||
|
||||
//set rid and tg when we actually tune to it
|
||||
state->nxdn_last_rid = SourceUnitID & 0xFFFF;
|
||||
state->nxdn_last_tg = (DestinationID & 0xFFFF);
|
||||
state->nxdn_last_rid = SourceUnitID;
|
||||
state->nxdn_last_tg = DestinationID;
|
||||
sprintf (state->nxdn_call_type, "%s", NXDN_Call_Type_To_Str(CallType));
|
||||
|
||||
//check the rkey array for a scrambler key value
|
||||
//TGT ID and Key ID could clash though if csv or system has both with different keys
|
||||
if (state->rkey_array[DestinationID] != 0)
|
||||
{
|
||||
state->R = state->rkey_array[DestinationID];
|
||||
fprintf (stderr, " %s", KYEL);
|
||||
fprintf (stderr, " Key Loaded: %lld", state->rkey_array[DestinationID]);
|
||||
}
|
||||
if (state->M == 1) state->nxdn_cipher_type = 0x1;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
END_ASSGN: ; //do nothing
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
|
||||
} /* End NXDN_decode_VCALL_ASSGN() */
|
||||
@@ -954,6 +1001,20 @@ void NXDN_decode_VCALL(dsd_opts * opts, dsd_state * state, uint8_t * Message)
|
||||
uint8_t TransmissionMode[32] = {0};
|
||||
unsigned long long int FullMessage = 0;
|
||||
|
||||
uint8_t MessageType;
|
||||
/* Get the "Message Type" field */
|
||||
MessageType = (Message[2] & 1) << 5;
|
||||
MessageType |= (Message[3] & 1) << 4;
|
||||
MessageType |= (Message[4] & 1) << 3;
|
||||
MessageType |= (Message[5] & 1) << 2;
|
||||
MessageType |= (Message[6] & 1) << 1;
|
||||
MessageType |= (Message[7] & 1) << 0;
|
||||
|
||||
if (MessageType == 0x1) fprintf (stderr, "%s", KGRN); //VCALL
|
||||
else if (MessageType == 0x07) fprintf (stderr, "%s", KYEL); //TX_REL_EXT
|
||||
else if (MessageType == 0x08) fprintf (stderr, "%s", KYEL); //TX_REL
|
||||
else if (MessageType == 0x11) fprintf (stderr, "%s", KRED); //DISC
|
||||
|
||||
/* Decode "CC Option" */
|
||||
CCOption = (uint8_t)ConvertBitIntoBytes(&Message[8], 8);
|
||||
state->NxdnElementsContent.CCOption = CCOption;
|
||||
@@ -974,6 +1035,20 @@ void NXDN_decode_VCALL(dsd_opts * opts, dsd_state * state, uint8_t * Message)
|
||||
DestinationID = (uint16_t)ConvertBitIntoBytes(&Message[40], 16);
|
||||
state->NxdnElementsContent.DestinationID = DestinationID;
|
||||
|
||||
//On Type-D systems, need to truncate to an 11-bit value
|
||||
//other 5-bits are repeater or prefix value
|
||||
uint8_t idas = 0;
|
||||
uint8_t rep1 = 0;
|
||||
uint8_t rep2 = 0;
|
||||
if (strcmp (state->nxdn_location_category, "Type-D") == 0) idas = 1;
|
||||
if (idas)
|
||||
{
|
||||
rep1 = (SourceUnitID >> 11) & 0x1F;
|
||||
rep2 = (DestinationID >> 11) & 0x1F;
|
||||
SourceUnitID = SourceUnitID & 0x7FF;
|
||||
DestinationID = DestinationID & 0x7FF;
|
||||
}
|
||||
|
||||
/* Decode the "Cipher Type" */
|
||||
CipherType = (uint8_t)ConvertBitIntoBytes(&Message[56], 2);
|
||||
state->NxdnElementsContent.CipherType = CipherType;
|
||||
@@ -982,6 +1057,8 @@ void NXDN_decode_VCALL(dsd_opts * opts, dsd_state * state, uint8_t * Message)
|
||||
KeyID = (uint8_t)ConvertBitIntoBytes(&Message[58], 6);
|
||||
state->NxdnElementsContent.KeyID = KeyID;
|
||||
|
||||
fprintf (stderr, "\n ");
|
||||
|
||||
/* Print the "CC Option" */
|
||||
if(CCOption & 0x80) fprintf(stderr, "Emergency ");
|
||||
if(CCOption & 0x40) fprintf(stderr, "Visitor ");
|
||||
@@ -999,16 +1076,21 @@ void NXDN_decode_VCALL(dsd_opts * opts, dsd_state * state, uint8_t * Message)
|
||||
}
|
||||
|
||||
/* Print the "Call Type" */
|
||||
fprintf (stderr, "%s", KGRN);
|
||||
fprintf(stderr, "\n %s - ", NXDN_Call_Type_To_Str(CallType));
|
||||
sprintf (state->nxdn_call_type, "%s", NXDN_Call_Type_To_Str(CallType));
|
||||
fprintf (stderr, "%s - ", NXDN_Call_Type_To_Str(CallType));
|
||||
sprintf (state->nxdn_call_type, "%s", NXDN_Call_Type_To_Str(CallType));
|
||||
|
||||
/* Print the "Voice Call Option" */
|
||||
NXDN_Voice_Call_Option_To_Str(VoiceCallOption, DuplexMode, TransmissionMode);
|
||||
fprintf(stderr, "%s %s - ", DuplexMode, TransmissionMode);
|
||||
if (MessageType == 0x1) NXDN_Voice_Call_Option_To_Str(VoiceCallOption, DuplexMode, TransmissionMode);
|
||||
if (MessageType == 0x1) fprintf(stderr, "%s %s - ", DuplexMode, TransmissionMode);
|
||||
else if (MessageType == 0x07) fprintf (stderr, "Transmission Release Ex - "); //TX_REL_EX
|
||||
else if (MessageType == 0x08) fprintf (stderr, " Transmission Release - "); //TX_REL
|
||||
else if (MessageType == 0x11) fprintf (stderr, " Disconnect - "); //DISC
|
||||
|
||||
/* Print Source ID and Destination ID (Talk Group or Unit ID) */
|
||||
fprintf(stderr, "Src=%u - Dst/TG=%u ", SourceUnitID & 0xFFFF, DestinationID & 0xFFFF);
|
||||
|
||||
if (idas) fprintf (stderr, "- Ch: %d ", rep1);
|
||||
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
|
||||
//check the rkey array for a scrambler key value
|
||||
@@ -1017,58 +1099,38 @@ void NXDN_decode_VCALL(dsd_opts * opts, dsd_state * state, uint8_t * Message)
|
||||
if (state->rkey_array[KeyID] != 0) state->R = state->rkey_array[KeyID];
|
||||
else if (state->rkey_array[DestinationID] != 0) state->R = state->rkey_array[DestinationID];
|
||||
|
||||
//consider removing code below, if we get this far (under good crc),
|
||||
//then we will always have a correct cipher type and won't need to
|
||||
//force it, its only needed on the vcall_assgn where no cipher is set
|
||||
//dsd_mbe can also force the scrambler without triggering the settings here
|
||||
|
||||
// if (state->M == 1)
|
||||
// {
|
||||
// state->nxdn_cipher_type = 0x1;
|
||||
// CipherType = 0x1;
|
||||
// }
|
||||
|
||||
//debug
|
||||
// if (CipherType > 0x1) state->R = 0; //don't use on manual key entry
|
||||
//Don't zero key if no keyloader
|
||||
if (CipherType != 0x1 && state->keyloader == 1) state->R = 0;
|
||||
|
||||
/* Print the "Cipher Type" */
|
||||
if(CipherType != 0)
|
||||
if(CipherType != 0 && MessageType == 0x1)
|
||||
{
|
||||
fprintf (stderr, "\n %s", KYEL);
|
||||
fprintf(stderr, "%s - ", NXDN_Cipher_Type_To_Str(CipherType));
|
||||
}
|
||||
|
||||
/* Print the Key ID */
|
||||
if(CipherType != 0)
|
||||
if(CipherType != 0 && MessageType == 0x1)
|
||||
{
|
||||
fprintf(stderr, "Key ID %u - ", KeyID & 0xFF);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
|
||||
|
||||
if (state->nxdn_cipher_type == 0x01 && state->R > 0) //scrambler key value
|
||||
if (CipherType == 0x01 && state->R > 0) //scrambler key value
|
||||
{
|
||||
fprintf (stderr, "%s", KYEL);
|
||||
fprintf(stderr, "Value: %05lld", state->R);
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
}
|
||||
|
||||
//only grab if CRC is okay
|
||||
if(state->NxdnElementsContent.VCallCrcIsGood)
|
||||
//only grab if VCALL
|
||||
if(MessageType == 0x1)
|
||||
{
|
||||
if ( (SourceUnitID & 0xFFFF) > 0 ) //
|
||||
{
|
||||
state->nxdn_last_rid = SourceUnitID & 0xFFFF;
|
||||
state->nxdn_last_tg = (DestinationID & 0xFFFF);
|
||||
state->nxdn_key = (KeyID & 0xFF);
|
||||
state->nxdn_cipher_type = CipherType;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf (stderr, "%s", KRED);
|
||||
fprintf(stderr, "(CRC ERR) ");
|
||||
fprintf (stderr, "%s", KNRM);
|
||||
state->nxdn_last_rid = SourceUnitID;
|
||||
state->nxdn_last_tg = DestinationID;
|
||||
state->nxdn_key = KeyID;
|
||||
state->nxdn_cipher_type = CipherType;
|
||||
}
|
||||
|
||||
//set enc bit here so we can tell playSynthesizedVoice whether or not to play enc traffic
|
||||
@@ -1086,20 +1148,328 @@ void NXDN_decode_VCALL_IV(dsd_opts * opts, dsd_state * state, uint8_t * Message)
|
||||
{
|
||||
uint32_t i;
|
||||
state->payload_miN = 0; //zero out
|
||||
|
||||
/* Extract the IV from the VCALL_IV message */
|
||||
for(i = 0; i < 8; i++)
|
||||
{
|
||||
state->NxdnElementsContent.IV[i] = (uint8_t)ConvertBitIntoBytes(&Message[(i + 1) * 8], 8);
|
||||
uint64_t IV = 0;
|
||||
|
||||
state->payload_miN = state->payload_miN << 8 | state->NxdnElementsContent.IV[i];
|
||||
}
|
||||
//NOTE: On Type-D systems, the FACCH1 version of message only carries a 4-octet payload and also only carries a 22-bit IV
|
||||
//which makes no sense since you still have the full 80-bits of FACCH1 to use
|
||||
uint8_t idas = 0;
|
||||
if (strcmp (state->nxdn_location_category, "Type-D") == 0) idas = 1;
|
||||
if (!idas) IV = (uint64_t)ConvertBitIntoBytes(&Message[8], 64);
|
||||
else IV = (uint64_t)ConvertBitIntoBytes(&Message[8], 22);
|
||||
//At this point, I would assume an LFSR function is needed to expand the 22-bit IV collected here into a 64-bit IV, or 128-bit IV
|
||||
|
||||
state->payload_miN = IV;
|
||||
state->NxdnElementsContent.PartOfCurrentEncryptedFrame = 2;
|
||||
state->NxdnElementsContent.PartOfNextEncryptedFrame = 1;
|
||||
|
||||
fprintf (stderr, "\n VCALL_IV: %016llX", state->payload_miN);
|
||||
|
||||
} /* End NXDN_decode_VCALL_IV() */
|
||||
|
||||
//SCCH messages have a unique format that can be used in a super frame, but each 'unit'
|
||||
//can also (mostly) be decoded seperately, except an enc IV
|
||||
void NXDN_decode_scch(dsd_opts * opts, dsd_state * state, uint8_t * Message, uint8_t direction)
|
||||
{
|
||||
uint8_t sf = (uint8_t)ConvertBitIntoBytes(&Message[0], 2);
|
||||
uint8_t opcode = (direction << 2 | sf);
|
||||
|
||||
fprintf (stderr, "\n " ); //initial line break
|
||||
|
||||
if (opts->payload == 1)
|
||||
{
|
||||
if (direction == 0) fprintf (stderr, "ISM ");
|
||||
else fprintf (stderr, "OSM ");
|
||||
|
||||
if (sf == 0) fprintf (stderr, "INFO4 ");
|
||||
else if (sf == 1) fprintf (stderr, "INFO3 ");
|
||||
else if (sf == 2) fprintf (stderr, "INFO2 ");
|
||||
else fprintf (stderr, "INFO1 ");
|
||||
fprintf (stderr, "- ");
|
||||
fprintf (stderr, "%02X ",opcode);
|
||||
}
|
||||
|
||||
//elements used will be determined by other elements in the ISM/OSM messages
|
||||
|
||||
//OSM 4 elements
|
||||
uint8_t area = Message[2];
|
||||
uint8_t rep1 = (uint8_t)ConvertBitIntoBytes(&Message[3], 5); //repeater 1 value
|
||||
uint8_t rep2 = (uint8_t)ConvertBitIntoBytes(&Message[8], 5); //repeater 2 value
|
||||
uint16_t id = (uint16_t)ConvertBitIntoBytes(&Message[13], 11); //id is context dependent
|
||||
uint8_t sitet = (uint8_t)ConvertBitIntoBytes(&Message[3], 5); //site type on id=2041 only
|
||||
uint8_t gu = Message[24]; //group or unit bit
|
||||
|
||||
//OSM 2 and 3 elements -- unique only
|
||||
uint64_t iv_a = (uint64_t)ConvertBitIntoBytes(&Message[13], 12); //initialization vector (0-11)
|
||||
|
||||
//OSM 1 elements -- unique only -- DOUBLE CHECK ALL OF THESE!
|
||||
uint64_t iv_b = (uint64_t)ConvertBitIntoBytes(&Message[18], 6); //initialization vector (b12-17)
|
||||
uint64_t iv_c = (uint64_t)ConvertBitIntoBytes(&Message[8], 5); //initialization vector (b18-22)
|
||||
uint8_t iv_type = Message[24]; //0 or 1 tells us whether or not this is for IV, or for cipher/key
|
||||
uint8_t call_opt = (uint8_t)ConvertBitIntoBytes(&Message[13], 3); //Call Options
|
||||
uint8_t key_id = (uint8_t)ConvertBitIntoBytes(&Message[18], 6); //Key ID
|
||||
uint8_t cipher = (uint8_t)ConvertBitIntoBytes(&Message[16], 2); //Cipher Type
|
||||
uint8_t DuplexMode[32] = {0};
|
||||
uint8_t TransmissionMode[32] = {0};
|
||||
|
||||
//ISM messages are seemingly exactly the same info as OSM, so just going to use OSM versions
|
||||
//(manual doesn't specify other than that ISM 4 is the same as ISM2, but probably doesn't have IDLE/HALT/SITE ID messages)
|
||||
|
||||
//set category to "Type-D" to alert users this is an a Distributed Trunking System
|
||||
sprintf (state->nxdn_location_category, "Type-D");
|
||||
|
||||
//placeholder numbers, using 99 if these aren't set by the Site ID Message (single sites)
|
||||
if (state->nxdn_location_site_code == 0) state->nxdn_location_site_code = 99;
|
||||
if (state->nxdn_location_sys_code == 0) state->nxdn_location_sys_code = 99;
|
||||
if (state->nxdn_last_ran == -1) state->nxdn_last_ran = 99;
|
||||
|
||||
state->last_cc_sync_time = time(NULL);
|
||||
|
||||
//OSM messages
|
||||
if (opcode == 0x4 || opcode == 0x0) //INFO 4
|
||||
{
|
||||
if (id == 2046)
|
||||
{
|
||||
fprintf (stderr, "Idle Repeater Message - ");
|
||||
fprintf (stderr, "Area: %d; ", area);
|
||||
fprintf (stderr, "Repeater 1: %d; ", rep1);
|
||||
fprintf (stderr, "Repeater 2: %d; ", rep2);
|
||||
|
||||
}
|
||||
else if (id == 2045)
|
||||
{
|
||||
fprintf (stderr, "Halt Repeater Message - ");
|
||||
fprintf (stderr, "Area: %d; ", area);
|
||||
fprintf (stderr, "Repeater 1: %d; ", rep1);
|
||||
fprintf (stderr, "Repeater 2: %d; ", rep2);
|
||||
|
||||
}
|
||||
else if (id == 2044)
|
||||
{
|
||||
fprintf (stderr, "Free Repeater Message - ");
|
||||
fprintf (stderr, "Area: %d; ", area);
|
||||
fprintf (stderr, "Free Repeater 1: %d; ", rep1);
|
||||
fprintf (stderr, "Free Repeater 2: %d; ", rep2);
|
||||
|
||||
}
|
||||
else if (id == 2041)
|
||||
{
|
||||
fprintf (stderr, "Site ID Message - ");
|
||||
fprintf (stderr, "Area: %d; ", area);
|
||||
fprintf (stderr, "Site Type: %d ", sitet); //Roaming Algorithm by SU; See below;
|
||||
if (sitet == 0) fprintf (stderr, "Reserved; ");
|
||||
else if (sitet == 1) fprintf (stderr, "Wide; ");
|
||||
else if (sitet == 2) fprintf (stderr, "Middle; ");
|
||||
else fprintf (stderr, "Narrow; ");
|
||||
fprintf (stderr, "Site Code: %d ", rep2);
|
||||
if (rep2 == 0) fprintf (stderr, "Reserved; ");
|
||||
else if (rep2 < 251) fprintf (stderr, "Open Access; "); //Usable voluntary every TRS...?
|
||||
else fprintf (stderr, "Reserved; ");
|
||||
state->nxdn_location_site_code = sitet;
|
||||
state->nxdn_location_sys_code = sitet;
|
||||
state->nxdn_last_ran = sitet;
|
||||
|
||||
}
|
||||
else //Busy Repeater Message is essentially our 'call in progess' message for a repeater
|
||||
{
|
||||
if (gu && rep1 == 0) fprintf (stderr, "REG_COMM; ");
|
||||
else fprintf (stderr, "Busy Repeater Message - ");
|
||||
fprintf (stderr, "Area: %d; ", area);
|
||||
fprintf (stderr, "Go to Repeater: %d; ", rep1);
|
||||
fprintf (stderr, "Home Repeater: %d; ", rep2);
|
||||
|
||||
if (rep1 == 31)
|
||||
{
|
||||
fprintf (stderr, "\n%s ", KRED);
|
||||
state->nxdn_last_tg = 0;
|
||||
state->nxdn_last_rid = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf (stderr, "\n%s ", KGRN);
|
||||
//only set this is during a voice tx, and not a data tx
|
||||
if ( time(NULL) - state->last_vc_sync_time < 1 )
|
||||
state->nxdn_last_tg = id;
|
||||
}
|
||||
|
||||
fprintf (stderr, " Channel Update - CH: %d - TGT: %d ", rep1, id);
|
||||
if (gu == 0) fprintf (stderr, "Group Call ");
|
||||
else fprintf (stderr, "Private Call ");
|
||||
|
||||
if (rep1 == 31) fprintf (stderr, "Termination ");
|
||||
|
||||
//start tuning section here
|
||||
uint8_t tune = 0; //use this to check to see if okay to tune
|
||||
|
||||
//only tune group calls if user set
|
||||
if (gu == 0 && opts->trunk_tune_group_calls == 1) tune = 1;
|
||||
|
||||
//only tune private calls if user set
|
||||
if (gu == 1 && opts->trunk_tune_private_calls == 1) tune = 1;
|
||||
|
||||
//tune back to 'channel 31' on termination, will be user provided 'default' listening channel
|
||||
if (rep1 == 31) tune = 1;
|
||||
|
||||
//begin tuning
|
||||
if (tune == 1 && rep1 != 0)
|
||||
{
|
||||
//check for control channel frequency in the channel map if not available
|
||||
if (state->trunk_chan_map[31] != 0) state->p25_cc_freq = state->trunk_chan_map[31]; //user provided channel to go to for '31' -- may change to 0 later?
|
||||
else if (state->trunk_chan_map[rep2] != 0) state->p25_cc_freq = state->trunk_chan_map[rep2]; //rep2 is home repeater under this message
|
||||
|
||||
//run group/tgt analysis and tune if available/desired
|
||||
//group list mode so we can look and see if we need to block tuning any groups, etc
|
||||
char mode[8]; //allow, block, digital, enc, etc
|
||||
|
||||
//if we are using allow/whitelist mode, then write 'B' to mode for block
|
||||
//comparison below will look for an 'A' to write to mode if it is allowed
|
||||
if (opts->trunk_use_allow_list == 1) sprintf (mode, "%s", "B");
|
||||
|
||||
for (int i = 0; i < state->group_tally; i++)
|
||||
{
|
||||
if (state->group_array[i].groupNumber == id) //tg/tgt only on info4 unit
|
||||
{
|
||||
fprintf (stderr, " [%s]", state->group_array[i].groupName);
|
||||
strcpy (mode, state->group_array[i].groupMode);
|
||||
}
|
||||
}
|
||||
|
||||
long int freq = 0;
|
||||
freq = nxdn_channel_to_frequency(opts, state, rep1);
|
||||
|
||||
//check to see if the source/target candidate is blocked first
|
||||
if (opts->p25_trunk == 1 && (strcmp(mode, "DE") != 0) && (strcmp(mode, "B") != 0)) //DE is digital encrypted, B is block
|
||||
{
|
||||
if (state->p25_cc_freq != 0 && state->last_vc_sync_time > 1 && freq != 0) //if we aren't already on a VC and have a valid frequency already
|
||||
{
|
||||
//rigctl
|
||||
if (opts->use_rigctl == 1)
|
||||
{
|
||||
//extra safeguards due to sync issues with NXDN
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
|
||||
state->lastsynctype = -1;
|
||||
state->last_cc_sync_time = time(NULL);
|
||||
state->last_vc_sync_time = time(NULL); //should we use this here, or not?
|
||||
//
|
||||
if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
|
||||
SetFreq(opts->rigctl_sockfd, freq);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
|
||||
opts->p25_is_tuned = 1;
|
||||
//check the rkey array for a scrambler key value
|
||||
//TGT ID and Key ID could clash though if csv or system has both with different keys
|
||||
if (state->rkey_array[id] != 0) state->R = state->rkey_array[id];
|
||||
if (state->M == 1) state->nxdn_cipher_type = 0x1;
|
||||
}
|
||||
//rtl_udp
|
||||
else if (opts->audio_in_type == 3)
|
||||
{
|
||||
//extra safeguards due to sync issues with NXDN
|
||||
memset (state->nxdn_sacch_frame_segment, 1, sizeof(state->nxdn_sacch_frame_segment));
|
||||
memset (state->nxdn_sacch_frame_segcrc, 1, sizeof(state->nxdn_sacch_frame_segcrc));
|
||||
state->lastsynctype = -1;
|
||||
state->last_cc_sync_time = time(NULL);
|
||||
state->last_vc_sync_time = time(NULL); //should we use this here, or not?
|
||||
//
|
||||
rtl_udp_tune (opts, state, freq);
|
||||
state->p25_vc_freq[0] = state->p25_vc_freq[1] = freq;
|
||||
opts->p25_is_tuned = 1;
|
||||
//check the rkey array for a scrambler key value
|
||||
//TGT ID and Key ID could clash though if csv or system has both with different keys
|
||||
if (state->rkey_array[id] != 0) state->R = state->rkey_array[id];
|
||||
if (state->M == 1) state->nxdn_cipher_type = 0x1;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
} //end tuning -- NOTE: since we are only going by last time voice sync detected, tuning here is always 'unlocked'
|
||||
|
||||
} //end 'busy' repeater
|
||||
|
||||
}
|
||||
|
||||
if (opcode == 0x5 || opcode == 0x1) //INFO 3
|
||||
{
|
||||
fprintf (stderr, "Source Message - ");
|
||||
fprintf (stderr, "Area: %d; ", area);
|
||||
fprintf (stderr, "Free Repeater 1: %d; ", rep1);
|
||||
|
||||
if (id == 31)
|
||||
{
|
||||
fprintf (stderr, "\n%s ", KYEL);
|
||||
fprintf (stderr, " Call IV A: %04lX", iv_a);
|
||||
}
|
||||
else
|
||||
{
|
||||
//rep2 is the home repeater/source prefix in this instance
|
||||
fprintf (stderr, "\n%s ", KGRN);
|
||||
fprintf (stderr, " Source Update - Prefix CH: %d SRC: %d - (%d-%d) ", rep2, id, rep2, id); //rep2
|
||||
//only set this is during a voice tx, and not a data tx
|
||||
if ( time(NULL) - state->last_vc_sync_time < 1 )
|
||||
state->nxdn_last_rid = id;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (opcode == 0x6 || opcode == 0x2) //OSM INFO 2 -- same as 4
|
||||
{
|
||||
fprintf (stderr, "Target Message - ");
|
||||
fprintf (stderr, "Area: %d; ", area);
|
||||
fprintf (stderr, "Go to Repeater: %d; ", rep1);
|
||||
if (id == 31)
|
||||
{
|
||||
fprintf (stderr, "\n%s ", KYEL);
|
||||
fprintf (stderr, " Call IV A: %04lX; ", iv_a); //MSB 0-11
|
||||
//zero out IV storage and append this chunk to MSB position
|
||||
state->payload_miN = 0;
|
||||
state->payload_miN = state->payload_miN | (iv_a << 11); //MSB 11, so shift 11 (22 total bits).
|
||||
}
|
||||
else
|
||||
{
|
||||
//rep2 is the home repeater/source prefix in this instance
|
||||
fprintf (stderr, "\n%s ", KGRN);
|
||||
fprintf (stderr, " Target Update - Prefix CH: %d SRC: %d - (%d-%d) ", rep2, id, rep2, id); //rep2
|
||||
//only set this is during a voice tx, and not a data tx
|
||||
if ( time(NULL) - state->last_vc_sync_time < 1 )
|
||||
state->nxdn_last_tg = id;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (opcode == 0x7 || opcode == 0x3) //INFO 1 - Call Option/Encryption Parms
|
||||
{
|
||||
fprintf (stderr, "Call Option - ");
|
||||
fprintf (stderr, "Area: %d; ", area);
|
||||
fprintf (stderr, "Free Repeater 1: %d; ", rep1);
|
||||
if (iv_type == 0)
|
||||
{
|
||||
fprintf (stderr, "Free Repeater 2: %d; ", rep2); //or Pass Character (31) on ISM
|
||||
fprintf (stderr, "\n%s ", KYEL);
|
||||
NXDN_Voice_Call_Option_To_Str(call_opt, DuplexMode, TransmissionMode);
|
||||
fprintf(stderr, " %s %s ", DuplexMode, TransmissionMode);
|
||||
if (cipher)
|
||||
{
|
||||
fprintf(stderr, "- %s - ", NXDN_Cipher_Type_To_Str(cipher));
|
||||
fprintf (stderr, "Key ID: %d; ", key_id);
|
||||
state->nxdn_cipher_type = cipher;
|
||||
state->nxdn_key = key_id;
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf (stderr, "\n%s ", KYEL);
|
||||
fprintf (stderr, "Call IV B: %04lX; ", iv_b);
|
||||
fprintf (stderr, "Call IV C: %04lX; ", iv_c);
|
||||
//Append to Call IV storage
|
||||
state->payload_miN = state->payload_miN | (iv_c << 6); //middle 5 bits..shifts 6 to accomodate last 6 bits below
|
||||
state->payload_miN = state->payload_miN | (iv_b << 0); //last 6 bits...no shift needed
|
||||
//At this point, I would assume an LFSR function is needed to expand the 22-bit IV collected here into a 64-bit IV, or 128-bit IV
|
||||
fprintf (stderr, "Completed IV: %016llX", state->payload_miN);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
char * NXDN_Call_Type_To_Str(uint8_t CallType)
|
||||
{
|
||||
@@ -1107,14 +1477,14 @@ char * NXDN_Call_Type_To_Str(uint8_t CallType)
|
||||
|
||||
switch(CallType)
|
||||
{
|
||||
case 0: Ptr = "Broadcast Call"; break;
|
||||
case 1: Ptr = "Group Call"; break;
|
||||
case 2: Ptr = "Unspecified Call"; break;
|
||||
case 3: Ptr = "Reserved"; break;
|
||||
case 4: Ptr = "Individual Call"; break;
|
||||
case 5: Ptr = "Reserved"; break;
|
||||
case 6: Ptr = "Interconnect Call"; break;
|
||||
case 7: Ptr = "Speed Dial Call"; break;
|
||||
case 0: Ptr = "Broadcast Call"; break;
|
||||
case 1: Ptr = "Group Call"; break;
|
||||
case 2: Ptr = "Transmission Release"; break; //"Unspecified Call" This value is used only on TX_REL message.
|
||||
case 3: Ptr = "Session Call"; break; //"reserved" is session call on Type D
|
||||
case 4: Ptr = "Private Call"; break;
|
||||
case 5: Ptr = "Reserved"; break;
|
||||
case 6: Ptr = "PSTN Interconnect Call"; break;
|
||||
case 7: Ptr = "PSTN Speed Dial Call"; break;
|
||||
default: Ptr = "Unknown Call Type"; break;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user