public void Parse(LogicChannel channelData, int offset, ReceivedData result)
{
var protokol = (MLEPduType)TetraUtils.BitsToInt32(channelData.Ptr, offset, 3);
offset += 3;
result.Add(GlobalNames.MLE_PDU_Type, (int)protokol);
//Debug.Write(" " + protokol.ToString());
switch (protokol)
{
case MLEPduType.CMCE:
ParseCMCEPDU(channelData, offset, result);
break;
case MLEPduType.MLE:
ParseMLEPDU(channelData, offset, result);
break;
default:
//Debug.Write(" Unknow_PDU_Type");
result.Add(GlobalNames.UnknowData, 1);
break;
}
}
public void ParseSDS(LogicChannel channelData, int offset, ReceivedData result)
{
var length = 8;
var type = (SdsProtocolIdent)TetraUtils.BitsToInt32(channelData.Ptr, offset, length);
offset += length;
result.Add(GlobalNames.Protocol_identifier, (int)type);
Debug.Write(" " + type.ToString());
if ((int)type > 127)
{
offset = ParseTLService(channelData, offset, result);
}
switch (type)
{
case SdsProtocolIdent.Simple_immediate_text:
case SdsProtocolIdent.Simple_text_msg:
offset = Global.ParseParams(channelData, offset, _sds_SimpleTextRules, result);
ParseTextMessage(channelData, offset, result);
break;
case SdsProtocolIdent.Immediate_text_messaging_TL:
case SdsProtocolIdent.Text_Messaging_TL:
offset = Global.ParseParams(channelData, offset, _sds_SimpleTextRules, result);
ParseTextMessage(channelData, offset, result);
break;
case SdsProtocolIdent.Location_System_TL:
case SdsProtocolIdent.Simple_location_system:
length = 8;
var locationCodingSheme = TetraUtils.BitsToInt32(channelData.Ptr, offset, length);
offset += length;
result.Add(GlobalNames.Location_System_Coding, locationCodingSheme);
if (locationCodingSheme == 0)
{
result.Add(GlobalNames.Text_coding_scheme, 1);
ParseTextMessage(channelData, offset, result);
}
else
{
result.Add(GlobalNames.UnknowData, 1);
}
break;
case SdsProtocolIdent.Location_information_protokol:
ParseLocationInformationProtokol(channelData, offset, result);
break;
default:
offset = Global.ParseParams(channelData, offset, _sds_SimpleTextRules, result);
ParseTextMessage(channelData, offset, result);
result.Add(GlobalNames.UnknowData, 1);
break;
}
}
public void ResourcePDU(LogicChannel channelData, int offset, ReceivedData result)
{
var startOffset = offset - 2;
offset = Global.ParseParams(channelData, offset, _macResourceRules, result);
//Debug.Write(" | Resource_PDU");
var encr = result.Value(GlobalNames.Encryption_mode);
var lengthIndication = result.Value(GlobalNames.Length_indication); //Only for pi/4 modulation
HalfSlotStolen = (lengthIndication == 62) || (lengthIndication == 63);
Debug.WriteIf(HalfSlotStolen, " Second_slot_stolen");
Debug.WriteIf(((lengthIndication < 62) && (lengthIndication > 58)), " Incorrect_PDU_length");
if (((lengthIndication > 58) && (lengthIndication < 62)) || (lengthIndication == 0) || result.Value(GlobalNames.Address_type) == 0)
{
result.Add(GlobalNames.Null_pdu, 1);
//Debug.Write(" Null_PDU");
return;
}
if (encr != 0) // All data before channel allocation flag is clear
{ // after is encrypted
Debug.Write(" Encr");
return;
}
offset = Global.ParseParams(channelData, offset, _channelAllocationRules, result);
if (lengthIndication != 63)
{
_llc.Parse(channelData, offset, result);
return;
}
var realLength = Math.Min(lengthIndication * 8 - (offset - startOffset), channelData.Length - offset);
if (result.Value(GlobalNames.Fill_bit) != 0)
{
realLength = CalcRealLength(channelData.Ptr, offset, realLength);
}
if (realLength < 0)
{
result.Add(GlobalNames.UnknowData, 1);
Debug.Write(" frag_length_err");
return;
}
//Debug.Write(" Start_fragmented_PDU");
CreateFraqmentsBuffer(channelData, offset, realLength, result);
}
public void MacEndPDU(LogicChannel channelData, int offset, ReceivedData result)
{
var startOffset = offset - 3;
offset = Global.ParseParams(channelData, offset, _macEndRules, result);
//Debug.Write(" | FragEnd_PDU");
if (FraqmentsBufferIsEmpty(channelData.TimeSlot))
{
Debug.Write(" Buffer_is_empty");
return;
}
offset = Global.ParseParams(channelData, offset, _channelAllocationRules, result);
var lengthIndication = result.Value(GlobalNames.Length_indication);
var realLength = Math.Min(lengthIndication * 8 - (offset - startOffset), channelData.Length - offset);
if (lengthIndication > 58)
{
Debug.Write(" Incorrect_PDU_length");
result.Add(GlobalNames.Null_pdu, 1);
return;
}
if (result.Value(GlobalNames.Fill_bit) != 0)
{
realLength = CalcRealLength(channelData.Ptr, offset, realLength);
}
if (realLength < 0)
{
result.Add(GlobalNames.UnknowData, 1);
Debug.Write(" frag_length_err");
return;
}
AddFraqmentsToBuffer(channelData, offset, realLength);
var newBuffer = GetDeFragmentedBuffer(channelData, result);
if (newBuffer.Length == 0)
{
Debug.Write(" Defrag_PDU_length_err");
result.Add(GlobalNames.Null_pdu, 1);
return;
}
//Debug.Write(" Defrag_PDU_length=" + newBuffer.Length.ToString());
offset = 0;
_llc.Parse(newBuffer, offset, result);
}
private void ParseMLEPDU(LogicChannel channelData, int offset, ReceivedData result)
{
var length = 3;
var type = (MlePrimitivesType)TetraUtils.BitsToInt32(channelData.Ptr, offset, length);
offset += length;
result.Add(GlobalNames.MLE_Primitives_Type, (int)type);
//Debug.Write(" " + type.ToString());
switch (type)
{
case MlePrimitivesType.D_NWRK_BROADCAST:
offset = Global.ParseParams(channelData, offset, _d_Nwrk_BroadcastRules, result);
var count = 0;
if (result.TryGetValue(GlobalNames.Number_of_Neighbour_cells_element, ref count))
{
for (int i = 0; i < count; i++)
{
var neighbourData = new ReceivedData();
offset = Global.ParseParams(channelData, offset, _neighbour_Cell_InfoRules, neighbourData);
var cellID = 0;
if (neighbourData.TryGetValue(GlobalNames.Cell_identifier, ref cellID))
{
//////Debug.WriteLine("Neighbour " + Thread.CurrentThread.ManagedThreadId.ToString());
if (Global.NeighbourList.Count < 32)
{
Global.NeighbourList.Add(neighbourData);
}
}
}
}
break;
case MlePrimitivesType.D_NEW_CELL:
case MlePrimitivesType.D_PREPARE:
case MlePrimitivesType.D_RESTORE_ACK:
case MlePrimitivesType.D_RESTORE_FAIL:
default:
//Debug.Write(" Unknow_MLE_SDU");
result.Add(GlobalNames.UnknowData, 1);
break;
}
}
public int ParseTLService(LogicChannel channelData, int offset, ReceivedData result)
{
var length = 4;
var messageType = TetraUtils.BitsToInt32(channelData.Ptr, offset, length);
offset += length;
result.Add(GlobalNames.SDS_TL_MesaggeType, messageType);
switch (messageType)
{
case 0: //Forward
offset = Global.ParseParams(channelData, offset, _d_Sds_TL_ForwardRules, result);
break;
case 1: //Report
offset = Global.ParseParams(channelData, offset, _d_Sds_TL_ReportRules, result);
break;
case 2:
case 3:
//
break;
}
return(offset);
}
public void MacFraqPDU(LogicChannel channelData, int offset, ReceivedData result)
{
var startOffset = offset - 3;
//Debug.Write(" | Frag_PDU");
if (FraqmentsBufferIsEmpty(channelData.TimeSlot))
{
Debug.Write(" Buffer_is_empty!!!");
return;
}
var fill = (TetraUtils.BitsToInt32(channelData.Ptr, offset, 1) != 0);
offset++;
var realLength = channelData.Length - offset;
if (fill)
{
realLength = CalcRealLength(channelData.Ptr, offset, realLength);
}
if (realLength < 0)
{
result.Add(GlobalNames.UnknowData, 1);
Debug.Write(" frag_length_err");
return;
}
AddFraqmentsToBuffer(channelData, offset, realLength);
}
public void DmoParseMacPDU(LogicChannel channelData, List <ReceivedData> result)
{
var offset = 0;
var pdu = new ReceivedData();
pdu.Add(GlobalNames.CurrTimeSlot, channelData.TimeSlot);
var pduType = (MAC_PDU_Type)TetraUtils.BitsToInt32(channelData.Ptr, offset, 2);
offset += 2;
pdu.Add(GlobalNames.MAC_PDU_Type, (int)pduType);
switch (pduType)
{
case MAC_PDU_Type.MAC_resource: //DMAC-DATA
DmacDataPDU(channelData, offset, pdu);
break;
case MAC_PDU_Type.MAC_frag:
var isTheEnd = TetraUtils.BitsToInt32(channelData.Ptr, offset, 1);
offset++;
if (isTheEnd == 0)
{
Debug.Write(" DMAC-Frag_PDU");
DmacFraqPDU(channelData, offset, pdu);
}
else
{
Debug.Write(" DMAC-End_PDU");
DmacEndPDU(channelData, offset, pdu);
}
break;
case MAC_PDU_Type.MAC_U_Signal:
Debug.Write(" U-signal_DMO_PDU");
//UsignalPDU(channelData, offset, pdu);
break;
case MAC_PDU_Type.Broadcast: //Not used for dmo
Debug.Write(" Reserved_DMO_PDU");
break;
}
result.Add(pdu);
}
private void ParseLocationInformationProtokol(LogicChannel channelData, int offset, ReceivedData result)
{
var length = 2;
var pduType = TetraUtils.BitsToInt32(channelData.Ptr, offset, length);
offset += length;
result.Add(GlobalNames.Location_PDU_type, pduType);
switch (pduType)
{
case 0: //Short
Global.ParseParams(channelData, offset, _sds_LocationShortRules, result);
break;
case 1: //Long
length = 4;
var pduSubType = (LocationTypeExtension)TetraUtils.BitsToInt32(channelData.Ptr, offset, length);
offset += length;
result.Add(GlobalNames.Location_PDU_type_extension, (int)pduSubType);
switch (pduSubType)
{
case LocationTypeExtension.Immediate_location_report:
Global.ParseParams(channelData, offset, _sds_ImmediateLocRepRules, result);
break;
case LocationTypeExtension.Long_location_report:
case LocationTypeExtension.Remove_trigger:
case LocationTypeExtension.Location_report_acknowledgement:
case LocationTypeExtension.Add_modify_trigger:
case LocationTypeExtension.Backlog:
case LocationTypeExtension.Basic_location_parameters:
case LocationTypeExtension.Location_reporting_enable_disable:
case LocationTypeExtension.Location_reporting_temporary_control:
case LocationTypeExtension.Report_basic_location_parameters:
case LocationTypeExtension.Report_trigger:
default:
result.Add(GlobalNames.UnknowData, 1);
break;
}
break;
default:
break;
}
}
private LogicChannel GetDeFragmentedBuffer(LogicChannel channelData, ReceivedData header)
{
var ts = channelData.TimeSlot - 1;
Debug.WriteIf(_writeAddress[ts] == 0, " Warning!!! Fraqments buffer is empty!");
var result = new LogicChannel
{
Ptr = _tempBuffersPtr[ts],
Length = _writeAddress[ts],
CrcIsOk = true,
TimeSlot = channelData.TimeSlot,
Frame = channelData.Frame
};
var key = GlobalNames.Encryption_mode;
if (_fragmentsHeader[ts].Contains(key))
{
header.Add(key, _fragmentsHeader[ts].Value(key));
}
key = GlobalNames.Address_type;
if (_fragmentsHeader[ts].Contains(key))
{
header.Add(key, _fragmentsHeader[ts].Value(key));
}
key = GlobalNames.SSI;
if (_fragmentsHeader[ts].Contains(key))
{
header.Add(key, _fragmentsHeader[ts].Value(key));
}
_fragmentsHeader[ts].Clear();
_writeAddress[ts] = 0;
return(result);
}
private void ParseCMCEPDU(LogicChannel channelData, int offset, ReceivedData result)
{
var length = 5;
var type = (CmcePrimitivesType)TetraUtils.BitsToInt32(channelData.Ptr, offset, length);
offset += length;
result.Add(GlobalNames.CMCE_Primitives_Type, (int)type);
//Debug.Write(" " + type.ToString());
switch (type)
{
case CmcePrimitivesType.D_Connect:
Global.ParseParams(channelData, offset, _d_connectRules, result);
break;
case CmcePrimitivesType.D_Setup:
Global.ParseParams(channelData, offset, _d_setupRules, result);
break;
case CmcePrimitivesType.D_TX_Granted:
Global.ParseParams(channelData, offset, _d_TX_GrantedRules, result);
break;
case CmcePrimitivesType.D_TX_Ceased:
Global.ParseParams(channelData, offset, _d_TX_CeasedRules, result);
break;
case CmcePrimitivesType.D_Release:
Global.ParseParams(channelData, offset, _d_ReleaseRules, result);
break;
case CmcePrimitivesType.D_Disconnect:
break;
case CmcePrimitivesType.D_Connect_Acknowledgea:
break;
case CmcePrimitivesType.D_Info:
Global.ParseParams(channelData, offset, _d_infoRules, result);
break;
case CmcePrimitivesType.D_SDS_Data:
offset = Global.ParseParams(channelData, offset, _d_SdsDataRules, result);
if (result.Contains(GlobalNames.User_Defined_Data4_Length))
{
var sdsData = new LogicChannel
{
Ptr = channelData.Ptr + offset,
Length = result.Value(GlobalNames.User_Defined_Data4_Length),
};
_sds.ParseSDS(sdsData, 0, result);
}
break;
case CmcePrimitivesType.D_Alert:
case CmcePrimitivesType.D_Call_Proceeding:
case CmcePrimitivesType.D_Status:
case CmcePrimitivesType.D_TX_Continue:
case CmcePrimitivesType.D_TX_Wait:
case CmcePrimitivesType.D_TX_Interrupt:
case CmcePrimitivesType.D_Call_Restore:
case CmcePrimitivesType.D_Facility:
case CmcePrimitivesType.Reserved17:
case CmcePrimitivesType.Reserved18:
case CmcePrimitivesType.Reserved19:
case CmcePrimitivesType.Reserved20:
case CmcePrimitivesType.Reserved21:
case CmcePrimitivesType.Reserved22:
case CmcePrimitivesType.Reserved23:
case CmcePrimitivesType.Reserved24:
case CmcePrimitivesType.Reserved25:
case CmcePrimitivesType.Reserved26:
case CmcePrimitivesType.Reserved27:
case CmcePrimitivesType.Reserved28:
case CmcePrimitivesType.Reserved29:
case CmcePrimitivesType.Reserved30:
case CmcePrimitivesType.CMCE_Function_Not_Supported:
//Debug.Write(" Unknow_CMCE_SDU");
result.Add(GlobalNames.UnknowData, 1);
break;
}
}
public void Parse(LogicChannel channelData, int offset, ReceivedData result)
{
var llcType = (LLCPduType)TetraUtils.BitsToInt32(channelData.Ptr, offset, 4);
offset += 4;
result.Add(GlobalNames.LLC_Pdu_Type, (int)llcType);
//Debug.WriteLine(" " + llcType.ToString());
var fcsIsGood = true;
switch (llcType)
{
case LLCPduType.BL_ADATA:
offset += 1; //N(R)
offset += 1; //N(S)
break;
case LLCPduType.BL_ADATA_FCS:
offset += 1; //N(R)
offset += 1; //N(S)
fcsIsGood = CalculateFCS(channelData, offset);
break;
case LLCPduType.BL_DATA:
offset += 1; //N(S)
break;
case LLCPduType.BL_DATA_FCS:
offset += 1; //N(S)
fcsIsGood = CalculateFCS(channelData, offset);
break;
case LLCPduType.BL_UDATA:
//No bits here
break;
case LLCPduType.BL_UDATA_FCS:
//No bits here
fcsIsGood = CalculateFCS(channelData, offset);
break;
case LLCPduType.BL_ACK:
offset += 1; //N(R)
break;
case LLCPduType.BL_ACK_FCS:
offset += 1; //N(R)
fcsIsGood = CalculateFCS(channelData, offset);
break;
case LLCPduType.AL_SETUP:
case LLCPduType.AL_DATA_AR_FINAL:
case LLCPduType.AL_UDATA_UFINAL:
case LLCPduType.AL_ACK_RNR:
case LLCPduType.AL_RECONNECT:
case LLCPduType.Reserved1:
case LLCPduType.Reserved2:
case LLCPduType.AL_DISC:
default:
Debug.WriteLine(" Unknow_LLC_PDU " + llcType);
result.Add(GlobalNames.UnknowData, 1);
return;
}
if (fcsIsGood)
{
_mle.Parse(channelData, offset, result);
}
else
{
result.Add(GlobalNames.UnknowData, 1);
}
}
private unsafe void ParseTextMessage(LogicChannel channelData, int offset, ReceivedData result)
{
if (result.Contains(GlobalNames.OutOfBuffer))
{
return;
}
var codingSheme = result.Value(GlobalNames.Text_coding_scheme);
Encoding encTable = Encoding.GetEncoding("iso-8859-1");
int symbLength = 8;
switch (codingSheme)
{
case 1:
encTable = Encoding.GetEncoding("iso-8859-1");
break;
case 2:
encTable = Encoding.GetEncoding("iso-8859-2");
break;
case 3:
encTable = Encoding.GetEncoding("iso-8859-3");
break;
case 4:
encTable = Encoding.GetEncoding("iso-8859-4");
break;
case 5:
encTable = Encoding.GetEncoding("iso-8859-5");
break;
case 6:
encTable = Encoding.GetEncoding("iso-8859-6");
break;
case 7:
encTable = Encoding.GetEncoding("iso-8859-7");
break;
case 8:
encTable = Encoding.GetEncoding("iso-8859-8");
break;
case 9:
encTable = Encoding.GetEncoding("iso-8859-9");
break;
case 10:
encTable = Encoding.GetEncoding("iso-8859-10");
break;
case 11:
encTable = Encoding.GetEncoding("iso-8859-13");
break;
case 12:
encTable = Encoding.GetEncoding("iso-8859-14");
break;
case 13:
encTable = Encoding.GetEncoding("iso-8859-15");
break;
case 14:
encTable = Encoding.GetEncoding(437);
break;
case 15:
encTable = Encoding.GetEncoding(737);
break;
case 16:
encTable = Encoding.GetEncoding(850);
break;
case 17:
encTable = Encoding.GetEncoding(852);
break;
case 18:
encTable = Encoding.GetEncoding(855);
break;
case 19:
encTable = Encoding.GetEncoding(857);
break;
case 20:
encTable = Encoding.GetEncoding(860);
break;
case 21:
encTable = Encoding.GetEncoding(861);
break;
case 22:
encTable = Encoding.GetEncoding(863);
break;
case 23:
encTable = Encoding.GetEncoding(865);
break;
case 24:
encTable = Encoding.GetEncoding(866);
break;
case 25:
encTable = Encoding.GetEncoding(869);
break;
default:
break;
result.Add(GlobalNames.UnknowData, 1);
return;
}
Decoder dec = encTable.GetDecoder();
var messageLength = (channelData.Length - offset) / symbLength;
if (messageLength < 0)
{
return;
}
string message;
byte[] symbolsArray = new byte[messageLength];
int index = 0;
while (messageLength > 0)
{
symbolsArray[index++] = TetraUtils.BitsToByte(channelData.Ptr, offset, symbLength);
offset += symbLength;
messageLength--;
}
message = encTable.GetString(symbolsArray);
Debug.WriteLine(" data:" + message);
}
public void TmoParseMacPDU(LogicChannel channelData, List <ReceivedData> result)
{
var nullPduLength = 16; // only for receive pi/4 modulation ;
var blockOffset = 0;
var nullPdu = false;
var pduEnd = false;
for (int i = 0; i < 5; i++)
{
var offset = blockOffset;
var pdu = new ReceivedData();
pdu.Add(GlobalNames.CurrTimeSlot, channelData.TimeSlot);
var resourceType = (MAC_PDU_Type)TetraUtils.BitsToInt32(channelData.Ptr, offset, 2);
offset += 2;
pdu.Add(GlobalNames.MAC_PDU_Type, (int)resourceType);
switch (resourceType)
{
case MAC_PDU_Type.Broadcast:
blockOffset = SysInfoPDU(channelData, offset, pdu);
break;
case MAC_PDU_Type.MAC_resource:
ResourcePDU(channelData, offset, pdu);
blockOffset += (pdu.Value(GlobalNames.Length_indication) * 8);
break;
case MAC_PDU_Type.MAC_U_Signal:
if (channelData.Length == 124)
{
UsignalPDU(channelData, offset, pdu);
pduEnd = true;
}
else
{
Debug.Write(" MAC-D-BLCK_PDU");
pduEnd = true;
}
break;
case MAC_PDU_Type.MAC_frag:
var isTheEnd = TetraUtils.BitsToInt32(channelData.Ptr, offset, 1);
offset++;
if (isTheEnd == 0)
{
MacFraqPDU(channelData, offset, pdu);
pduEnd = true;
}
else
{
MacEndPDU(channelData, offset, pdu);
blockOffset += (pdu.Value(GlobalNames.Length_indication) * 8);
}
break;
}
nullPdu = pdu.Contains(GlobalNames.Null_pdu) || pdu.Contains(GlobalNames.OutOfBuffer);
if (nullPdu)
{
pduEnd = true;
}
//if (pdu.ContainsKey(GlobalNames.UnknowData)) nullPdu = true;
if (!nullPdu)
{
result.Add(pdu);
}
if ((blockOffset >= (channelData.Length - nullPduLength)) || pduEnd)
{
break;
}
}
}
