/// <summary> /// Decodes the timestamp out of a PDU stream. /// </summary> /// <param name="pdu">The string to get the timestamp from.</param> /// <param name="index">The current position in the string</param> public SmsTimestampEx(string pdu, ref int index) { string bytesString = BcdWorker.GetBytesString(pdu, index, 7); index = index + 7; string str = BcdWorker.DecodeSemiOctets(bytesString); this.year = byte.Parse(str.Substring(0, 2)); this.month = byte.Parse(str.Substring(2, 2)); this.day = byte.Parse(str.Substring(4, 2)); this.hour = byte.Parse(str.Substring(6, 2)); this.minute = byte.Parse(str.Substring(8, 2)); this.second = byte.Parse(str.Substring(10, 2)); string str1 = str.Substring(12, 2); byte num = Calc.HexToInt(str1)[0]; if ((num & 128) <= 0) { try { this.timeZoneOffset = int.Parse(str1); } catch { this.timeZoneOffset = 0; } return; } else { num = (byte)(num & 127); try { this.timeZoneOffset = -num; } catch { this.timeZoneOffset = 0; } return; } }
/// <summary> /// Decodes an SMSC address out of a PDU string. /// </summary> /// <param name="pdu">The PDU string to use.</param> /// <param name="index">The index where to start in the string.</param> /// <param name="address">The address (phone number) read.</param> /// <param name="addressType">The address type of the read address.</param> public static void DecodeSmscAddress(string pdu, ref int index, out string address, out byte addressType) { int num = index; int num1 = num; index = num + 1; byte num2 = BcdWorker.GetByte(pdu, num1); if (num2 <= 0) { addressType = 0; address = string.Empty; return; } else { int num3 = index; int num4 = num3; index = num3 + 1; byte num5 = BcdWorker.GetByte(pdu, num4); int num6 = num2 - 1; string bytesString = BcdWorker.GetBytesString(pdu, index, num6); index = index + num6; string str = BcdWorker.DecodeSemiOctets(bytesString); if (str.EndsWith("F") || str.EndsWith("f")) { str = str.Substring(0, str.Length - 1); } addressType = num5; address = str; return; } }
/// <summary> /// Decodes an address out of a PDU string. /// </summary> /// <param name="pdu">The PDU string to use.</param> /// <param name="index">The index where to start in the string.</param> /// <param name="address">The address (phone number) read.</param> /// <param name="addressType">The address type of the read address.</param> public static void DecodeGeneralAddress(string pdu, ref int index, out string address, out byte addressType) { int num; int num1 = index; int num2 = num1; index = num1 + 1; byte num3 = BcdWorker.GetByte(pdu, num2); int num4 = index; int num5 = num4; index = num4 + 1; addressType = BcdWorker.GetByte(pdu, num5); if (num3 <= 0) { address = string.Empty; return; } else { bool flag = false; if (num3 % 2 != 0) { num = num3 + 1; } else { num = (int)num3; } int length = num / 2; if (index * 2 + length * 2 > pdu.Length - length * 2) { length = (pdu.Length - index * 2) / 2; flag = true; } AddressType addressType1 = new AddressType(addressType); if (addressType1.Ton != 5) { string bytesString = BcdWorker.GetBytesString(pdu, index, length); index = index + length; if (flag) { address = BcdWorker.DecodeSemiOctets(bytesString).Substring(0, length * 2); return; } else { address = BcdWorker.DecodeSemiOctets(bytesString).Substring(0, num3); return; } } else { byte[] bytes = BcdWorker.GetBytes(pdu, index, length); index = index + length; address = PduParts.Decode7BitText(bytes); return; } } }
/// <summary> /// Gets the user data out of the string. /// </summary> /// <param name="pdu">The PDU string to use.</param> /// <param name="index">The index where to start in the string.</param> /// <param name="dcs">The coding that was used to encode the data. Required to determine the proper data length.</param> /// <param name="userDataLength">Receives the user data length in bytes.</param> /// <param name="userData">Received the user data.</param> /// <remarks> /// <para>If there's no data, userDataLength will be set to 0 and userData to null.</para> /// <para>The decoded data might require further processing, for example 7-bit data (septets) packed /// into octets, that must be converted back to septets before the data can be used.</para> /// <para>Processing will stop at the first character that is not hex encountered or if the /// string ends too early. It will not change the <b>userDataLength</b> read from the string.</para> /// </remarks> public static void DecodeUserData(string pdu, ref int index, byte dcs, out byte userDataLength, out byte[] userData) { int num = index; int num1 = num; index = num + 1; byte num2 = BcdWorker.GetByte(pdu, num1); if (num2 <= 0) { userDataLength = 0; userData = new byte[0]; return; } else { int remainingUserDataBytes = PduParts.GetRemainingUserDataBytes(num2, dcs); int num3 = BcdWorker.CountBytes(pdu) - index; if (num3 < remainingUserDataBytes) { remainingUserDataBytes = num3; } string bytesString = BcdWorker.GetBytesString(pdu, index, remainingUserDataBytes); index = index + remainingUserDataBytes; string empty = string.Empty; for (int i = 0; i < bytesString.Length / 2; i++) { string byteString = BcdWorker.GetByteString(bytesString, i); if (!Calc.IsHexString(byteString)) { break; } empty = string.Concat(empty, byteString); } userDataLength = num2; userData = Calc.HexToInt(empty); return; } }
/// <summary> /// Initializes a new instance of the <see cref="T:GsmComm.PduConverter.SmsSubmitPdu" /> class /// using the specified PDU string. /// </summary> /// <param name="pdu">The PDU string to convert.</param> /// <param name="includesSmscData">Specifies if the string contains /// SMSC data octets at the beginning.</param> /// <param name="actualLength">Specifies the actual PDU length, that is the length in bytes without /// the SMSC header. Set to -1 if unknown.</param> /// <remarks> /// <para>This constructor assumes that the string contains an <b>SMS-SUBMIT</b> /// PDU data stream as specified /// by GSM 07.05.</para> /// <para>AbsuluteValidityPeriod and EnhancedValidityPeriod are not /// supported and will generate a <see cref="T:System.NotSupportedException" /> /// when encountered. /// </para> /// </remarks> /// <exception cref="T:System.NotSupportedException">The string contains a /// validity and the validity period format is not relative validity. /// </exception> public SmsSubmitPdu(string pdu, bool includesSmscData, int actualLength) { byte num = 0; byte[] numArray = null; int num1; if (pdu != string.Empty) { bool flag = actualLength >= 0; int num2 = actualLength; if (!flag || num2 > 0) { int num3 = 0; if (!includesSmscData) { base.SmscAddress = string.Empty; } else { int num4 = num3; num3 = num4 + 1; byte num5 = BcdWorker.GetByte(pdu, num4); if (num5 <= 0) { base.SmscAddress = string.Empty; } else { int num6 = num3; num3 = num6 + 1; byte num7 = BcdWorker.GetByte(pdu, num6); int num8 = num5 - 1; string bytesString = BcdWorker.GetBytesString(pdu, num3, num8); num3 = num3 + num8; string str = BcdWorker.DecodeSemiOctets(bytesString); if (str.EndsWith("F") || str.EndsWith("f")) { str = str.Substring(0, str.Length - 1); } base.SetSmscAddress(str, num7); } } int num9 = num3; num3 = num9 + 1; this.messageFlags = new SmsSubmitMessageFlags(BcdWorker.GetByte(pdu, num9)); if (flag) { num2--; if (num2 <= 0) { base.ConstructLength = num3 * 2; return; } } int num10 = num3; num3 = num10 + 1; base.MessageReference = BcdWorker.GetByte(pdu, num10); int num11 = num3; num3 = num11 + 1; byte num12 = BcdWorker.GetByte(pdu, num11); int num13 = num3; num3 = num13 + 1; byte num14 = BcdWorker.GetByte(pdu, num13); if (num12 <= 0) { this.DestinationAddress = string.Empty; } else { if (num12 % 2 != 0) { num1 = num12 + 1; } else { num1 = (int)num12; } int num15 = num1 / 2; string bytesString1 = BcdWorker.GetBytesString(pdu, num3, num15); num3 = num3 + num15; string str1 = BcdWorker.DecodeSemiOctets(bytesString1).Substring(0, num12); this.SetDestinationAddress(str1, num14); } int num16 = num3; num3 = num16 + 1; base.ProtocolID = BcdWorker.GetByte(pdu, num16); int num17 = num3; num3 = num17 + 1; base.DataCodingScheme = BcdWorker.GetByte(pdu, num17); ValidityPeriodFormat validityPeriodFormat = this.MessageFlags.ValidityPeriodFormat; if (validityPeriodFormat == ValidityPeriodFormat.Unspecified) { this.ValidityPeriod = null; } else if (validityPeriodFormat == ValidityPeriodFormat.Relative) { int num18 = num3; num3 = num18 + 1; this.ValidityPeriod = new RelativeValidityPeriod(BcdWorker.GetByte(pdu, num18)); } else if (validityPeriodFormat == ValidityPeriodFormat.Absolute) { throw new NotSupportedException("Absolute validity period format not supported."); } else if (validityPeriodFormat == ValidityPeriodFormat.Enhanced) { throw new NotSupportedException("Enhanced validity period format not supported."); } else { throw new NotSupportedException(string.Concat("Validity period format \"", (object)this.MessageFlags.ValidityPeriodFormat.ToString(), "\" not supported.")); } PduParts.DecodeUserData(pdu, ref num3, base.DataCodingScheme, out num, out numArray); base.SetUserData(numArray, num); base.ConstructLength = num3 * 2; return; } else { return; } } else { throw new ArgumentException("pdu must not be an empty string."); } }