Quando si codificano/decodificano i dati utente di SMS PDU (GSM 7 Bit), devo prima aggiungere l'UDH?

Question

Anche se riesco a codificare e decodificare la parte di dati utente di un messaggio SMS quando un UDH è non, ho problemi a farlo quando un UDH è presente (in questo caso, per SMS concatenati).

Quando decodifico o codifico i dati utente, è necessario anteporre l'UDH al testo prima di farlo?

Questo articolo fornisce un esempio di routine di codifica che compensa l'UDH con i bit di riempimento (che ancora non capisco completamente) ma non fornisce un esempio di dati passati alla routine, quindi non ho un chiaro caso d'uso (e non sono riuscito a trovare un campione di decodifica sul sito): http://mobiletidings.com/2009/07/06/how-to-pack-gsm7-into-septets/.

Finora, sono stato in grado di ottenere dei risultati se ho anteposto l'UDH ai dati utente prima di decodificarlo, ma sospetto che sia solo una coincidenza.

A titolo di esempio (utilizzando i valori da https://en.wikipedia.org/wiki/Concatenated_SMS):

UDH := '050003000302'; 
ENCODED_USER_DATA_PART := 'D06536FB0DBABFE56C32'; // with padding, evidently 
DecodedUserData := Decode7Bit(UDH + ENCODED_USER_DATA_PART); 
Writeln(DecodedUserData); 

in uscita: "ß @ ø¿Æ @hello mondo"

EncodedUserData := Encode7Bit(DecodedUserData); 
DecodedUserData := Decode7Bit(EncodedEncodedUserData); 
Writeln(DecodedUserData); 

stessa uscita: "ß @ ø¿Æ @ ciao mondo"

Senza anteponendo l'UDH ottengo spazzatura:

DecodedUserData := Decode7Bit(ENCODED_USER_DATA_PART); 
Writeln(DecodedUserData); 

in uscita: "PKYY§An§eYI"

Qual è corretto modo di gestire questo?

Devo includere l'UDH con il testo durante la codifica dei dati utente?

Dovrei togliere i caratteri della spazzatura dopo la decodifica o sono (come sospetto) completamente fuori base con questa ipotesi?

Mentre l'algoritmo di decodifica qui sembra funzionare senza un UDH non sembra prendere in considerazione alcuna informazione UDH: Looking for GSM 7bit encode/decode algorithm.

Sarei eternamente grato se qualcuno potesse dirmi il modo corretto di procedere. Qualsiasi esempio chiaro/esempi di codice sarebbe molto apprezzato. ;-)

Fornirò anche una piccola applicazione di esempio che include gli algoritmi se qualcuno ritiene di poter risolvere l'enigma.

EDIT 1:

sto usando Delphi XE2 Update 4 Hotfix 1

EDIT 2:

Grazie all'aiuto di @whosrdaddy, sono stato in grado di ottenere con successo il mio routine di codifica/decodifica per funzionare.

Come nota a margine, ero curioso di sapere perché i dati utente dovevano essere su un limite di 7 bit quando l'UDH non era codificato con esso, ma l'ultima frase nel paragrafo dalla specifica ETSI citata da @whosrdaddy ha risposto che:

Se viene utilizzato dati 7 bit e il TP-UD-Header non finisce sul confine di un settetto quindi riempire i bit sono inseriti dopo l'ultima ottetto Informazioni elemento di dati in modo che ci sia un numero integrale di settetti per l'intera intestazione TP-UD. Questo è quello di garantire che la SM si inizia un ottetto di confine in modo che una fase precedente cellulare sarà in grado di visualizzare la SM stessa anche se il TP-UD Header nel campo TP-UD non può essere intesa

il mio codice si basa in parte su esempi tratti dalle seguenti risorse:

Looking for GSM 7bit encode/decode algorithm

https://en.wikipedia.org/wiki/Concatenated_SMS

http://mobiletidings.com/2009/02/18/combining-sms-messages/

http://mobiletidings.com/2009/07/06/how-to-pack-gsm7-into-septets/

http://mobileforensics.files.wordpress.com/2007/06/understanding_sms.pdf

http://www.dreamfabric.com/sms/

http://www.mediaburst.co.uk/blog/concatenated-sms/

Ecco il codice per chiunque altro che ha avuto problemi con la codifica SMS/decodifica. Sono sicuro che può essere semplificato/ottimizzato (e i commenti sono benvenuti), ma l'ho testato con diverse permutazioni e lunghezze di intestazione UDH con successo. Spero possa essere d'aiuto.

unit SmsUtils; 

interface 

uses Windows, Classes, Math; 

function Encode7Bit(const AText: string; AUdhLen: Byte; 
    out ATextLen: Byte): string; 

function Decode7Bit(const APduData: string; AUdhLen: Integer): string; 

implementation 

var 
    g7BitToAsciiTable: array [0 .. 127] of Byte; 
    gAsciiTo7BitTable: array [0 .. 255] of Byte; 

procedure InitializeTables; 
var 
    AsciiValue: Integer; 
    i: Integer; 
begin 
    // create 7-bit to ascii table 
    g7BitToAsciiTable[0] := 64; // @ 
    g7BitToAsciiTable[1] := 163; 
    g7BitToAsciiTable[2] := 36; 
    g7BitToAsciiTable[3] := 165; 
    g7BitToAsciiTable[4] := 232; 
    g7BitToAsciiTable[5] := 223; 
    g7BitToAsciiTable[6] := 249; 
    g7BitToAsciiTable[7] := 236; 
    g7BitToAsciiTable[8] := 242; 
    g7BitToAsciiTable[9] := 199; 
    g7BitToAsciiTable[10] := 10; 
    g7BitToAsciiTable[11] := 216; 
    g7BitToAsciiTable[12] := 248; 
    g7BitToAsciiTable[13] := 13; 
    g7BitToAsciiTable[14] := 197; 
    g7BitToAsciiTable[15] := 229; 
    g7BitToAsciiTable[16] := 0; 
    g7BitToAsciiTable[17] := 95; 
    g7BitToAsciiTable[18] := 0; 
    g7BitToAsciiTable[19] := 0; 
    g7BitToAsciiTable[20] := 0; 
    g7BitToAsciiTable[21] := 0; 
    g7BitToAsciiTable[22] := 0; 
    g7BitToAsciiTable[23] := 0; 
    g7BitToAsciiTable[24] := 0; 
    g7BitToAsciiTable[25] := 0; 
    g7BitToAsciiTable[26] := 0; 
    g7BitToAsciiTable[27] := 0; 
    g7BitToAsciiTable[28] := 198; 
    g7BitToAsciiTable[29] := 230; 
    g7BitToAsciiTable[30] := 223; 
    g7BitToAsciiTable[31] := 201; 
    g7BitToAsciiTable[32] := 32; 
    g7BitToAsciiTable[33] := 33; 
    g7BitToAsciiTable[34] := 34; 
    g7BitToAsciiTable[35] := 35; 
    g7BitToAsciiTable[36] := 164; 
    g7BitToAsciiTable[37] := 37; 
    g7BitToAsciiTable[38] := 38; 
    g7BitToAsciiTable[39] := 39; 
    g7BitToAsciiTable[40] := 40; 
    g7BitToAsciiTable[41] := 41; 
    g7BitToAsciiTable[42] := 42; 
    g7BitToAsciiTable[43] := 43; 
    g7BitToAsciiTable[44] := 44; 
    g7BitToAsciiTable[45] := 45; 
    g7BitToAsciiTable[46] := 46; 
    g7BitToAsciiTable[47] := 47; 
    g7BitToAsciiTable[48] := 48; 
    g7BitToAsciiTable[49] := 49; 
    g7BitToAsciiTable[50] := 50; 
    g7BitToAsciiTable[51] := 51; 
    g7BitToAsciiTable[52] := 52; 
    g7BitToAsciiTable[53] := 53; 
    g7BitToAsciiTable[54] := 54; 
    g7BitToAsciiTable[55] := 55; 
    g7BitToAsciiTable[56] := 56; 
    g7BitToAsciiTable[57] := 57; 
    g7BitToAsciiTable[58] := 58; 
    g7BitToAsciiTable[59] := 59; 
    g7BitToAsciiTable[60] := 60; 
    g7BitToAsciiTable[61] := 61; 
    g7BitToAsciiTable[62] := 62; 
    g7BitToAsciiTable[63] := 63; 
    g7BitToAsciiTable[64] := 161; 
    g7BitToAsciiTable[65] := 65; 
    g7BitToAsciiTable[66] := 66; 
    g7BitToAsciiTable[67] := 67; 
    g7BitToAsciiTable[68] := 68; 
    g7BitToAsciiTable[69] := 69; 
    g7BitToAsciiTable[70] := 70; 
    g7BitToAsciiTable[71] := 71; 
    g7BitToAsciiTable[72] := 72; 
    g7BitToAsciiTable[73] := 73; 
    g7BitToAsciiTable[74] := 74; 
    g7BitToAsciiTable[75] := 75; 
    g7BitToAsciiTable[76] := 76; 
    g7BitToAsciiTable[77] := 77; 
    g7BitToAsciiTable[78] := 78; 
    g7BitToAsciiTable[79] := 79; 
    g7BitToAsciiTable[80] := 80; 
    g7BitToAsciiTable[81] := 81; 
    g7BitToAsciiTable[82] := 82; 
    g7BitToAsciiTable[83] := 83; 
    g7BitToAsciiTable[84] := 84; 
    g7BitToAsciiTable[85] := 85; 
    g7BitToAsciiTable[86] := 86; 
    g7BitToAsciiTable[87] := 87; 
    g7BitToAsciiTable[88] := 88; 
    g7BitToAsciiTable[89] := 89; 
    g7BitToAsciiTable[90] := 90; 
    g7BitToAsciiTable[91] := 196; 
    g7BitToAsciiTable[92] := 204; 
    g7BitToAsciiTable[93] := 209; 
    g7BitToAsciiTable[94] := 220; 
    g7BitToAsciiTable[95] := 167; 
    g7BitToAsciiTable[96] := 191; 
    g7BitToAsciiTable[97] := 97; 
    g7BitToAsciiTable[98] := 98; 
    g7BitToAsciiTable[99] := 99; 
    g7BitToAsciiTable[100] := 100; 
    g7BitToAsciiTable[101] := 101; 
    g7BitToAsciiTable[102] := 102; 
    g7BitToAsciiTable[103] := 103; 
    g7BitToAsciiTable[104] := 104; 
    g7BitToAsciiTable[105] := 105; 
    g7BitToAsciiTable[106] := 106; 
    g7BitToAsciiTable[107] := 107; 
    g7BitToAsciiTable[108] := 108; 
    g7BitToAsciiTable[109] := 109; 
    g7BitToAsciiTable[110] := 110; 
    g7BitToAsciiTable[111] := 111; 
    g7BitToAsciiTable[112] := 112; 
    g7BitToAsciiTable[113] := 113; 
    g7BitToAsciiTable[114] := 114; 
    g7BitToAsciiTable[115] := 115; 
    g7BitToAsciiTable[116] := 116; 
    g7BitToAsciiTable[117] := 117; 
    g7BitToAsciiTable[118] := 118; 
    g7BitToAsciiTable[119] := 119; 
    g7BitToAsciiTable[120] := 120; 
    g7BitToAsciiTable[121] := 121; 
    g7BitToAsciiTable[122] := 122; 
    g7BitToAsciiTable[123] := 228; 
    g7BitToAsciiTable[124] := 246; 
    g7BitToAsciiTable[125] := 241; 
    g7BitToAsciiTable[126] := 252; 
    g7BitToAsciiTable[127] := 224; 

    // create ascii to 7-bit table 
    ZeroMemory(@gAsciiTo7BitTable, SizeOf(gAsciiTo7BitTable)); 
    for i := 0 to High(g7BitToAsciiTable) do 
    begin 
    AsciiValue := g7BitToAsciiTable[i]; 
    gAsciiTo7BitTable[AsciiValue] := i; 
    end; 
end; 

function ConvertAsciiTo7Bit(const AText: string; AUdhLen: Byte): AnsiString; 
const 
    ESC = #27; 
    ESCAPED_ASCII_CODES = [#94, #123, #125, #92, #91, #126, #93, #124, #164]; 
var 
    Septet: Byte; 
    Ch: AnsiChar; 
    i: Integer; 
begin 
    for i := 1 to Length(AText) do 
    begin 
    Ch := AnsiChar(AText[i]); 
    if not(Ch in ESCAPED_ASCII_CODES) then 
     Septet := gAsciiTo7BitTable[Byte(Ch)] 
    else 
    begin 
     Result := Result + ESC; 
     case (Ch) of 
     #12: Septet := 10; 
     #94: Septet := 20; 
     #123: Septet := 40; 
     #125: Septet := 41; 
     #92: Septet := 47; 
     #91: Septet := 60; 
     #126: Septet := 61; 
     #93: Septet := 62; 
     #124: Septet := 64; 
     #164: Septet := 101; 
     else Septet := 0; 
     end; 
    end; 
    Result := Result + AnsiChar(Septet); 
    end; 
end; 

function Convert7BitToAscii(const AText: AnsiString): string; 
const 
    ESC = #27; 
var 
    TextLen: Integer; 
    Ch: Char; 
    i: Integer; 
begin 
    Result := ''; 
    TextLen := Length(AText); 
    i := 1; 
    while (i <= TextLen) do 
    begin 
    Ch := Char(AText[i]); 
    if (Ch <> ESC) then 
     Result := Result + Char(g7BitToAsciiTable[Ord(Ch)]) 
    else 
    begin 
     Inc(i); // skip ESC 
     if (i <= TextLen) then 
     begin 
     Ch := Char(AText[i]); 
     case (Ch) of 
      #10: Ch := #12; 
      #20: Ch := #94; 
      #40: Ch := #123; 
      #41: Ch := #125; 
      #47: Ch := #92; 
      #60: Ch := #91; 
      #61: Ch := #126; 
      #62: Ch := #93; 
      #64: Ch := #124; 
      #101: Ch := #164; 
     end; 
     Result := Result + Ch; 
     end; 
    end; 
    Inc(i); 
    end; 
end; 

function StrToHex(const AText: AnsiString): AnsiString; overload; 
var 
    TextLen: Integer; 
begin 
    // set the text buffer size 
    TextLen := Length(AText); 
    // set the length of the result to double the string length 
    SetLength(Result, TextLen * 2); 
    // convert the string to hex 
    BinToHex(PAnsiChar(AText), PAnsiChar(Result), TextLen); 
end; 

function StrToHex(const AText: string): string; overload; 
begin 
    Result := string(StrToHex(AnsiString(AText))); 
end; 

function HexToStr(const AText: AnsiString): AnsiString; overload; 
var 
    ResultLen: Integer; 
begin 
    // set the length of the result to half the Text length 
    ResultLen := Length(AText) div 2; 
    SetLength(Result, ResultLen); 
    // convert the hex back into a string 
    if (HexToBin(PAnsiChar(AText), PAnsiChar(Result), ResultLen) <> ResultLen) then 
    Result := 'Error Converting Hex To String: ' + AText; 
end; 

function HexToStr(const AText: string): string; overload; 
begin 
    Result := string(HexToStr(AnsiString(AText))); 
end; 

function Encode7Bit(const AText: string; AUdhLen: Byte; 
    out ATextLen: Byte): string; 
// AText: Ascii text 
// AUdhLen: Length of UDH including UDH Len byte (e.g. '050003CC0101' = 6 bytes) 
// ATextLen: returns length of text that was encoded. This can be different 
// than Length(AText) due to escape characters 
// Returns text as encoded PDU hex string 
var 
    Text7Bit: AnsiString; 
    Pdu: AnsiString; 
    PduIdx: Integer; 
    PduLen: Byte; 
    PaddingBits: Byte; 
    BitsToMove: Byte; 
    Septet: Byte; 
    Octet: Byte; 
    PrevOctet: Byte; 
    ShiftedOctet: Byte; 
    i: Integer; 
begin 
    Result := ''; 
    Text7Bit := ConvertAsciiTo7Bit(AText, AUdhLen); 
    ATextLen := Length(Text7Bit); 
    BitsToMove := 0; 
    // determine how many padding bits needed based on the UDH 
    if (AUdhLen > 0) then 
    PaddingBits := 7 - ((AUdhLen * 8) mod 7) 
    else 
    PaddingBits := 0; 
    // calculate the number of bytes needed to store the 7-bit text 
    // along with any padding bits that are required 
    PduLen := Ceil(((ATextLen * 7) + PaddingBits)/8); 
    // reserve space for the PDU bytes 
    Pdu := AnsiString(StringOfChar(#0, PduLen)); 
    PduIdx := 1; 
    for i := 1 to ATextLen do 
    begin 
    if (BitsToMove = 7) then 
     BitsToMove := 0 
    else 
    begin 
     // convert the current character to a septet (7-bits) and make room for 
     // the bits from the next one 
     Septet := (Byte(Text7Bit[i]) shr BitsToMove); 
     if (i = ATextLen) then 
     Octet := Septet 
     else 
     begin 
     // convert the next character to a septet and copy the bits from it 
     // to the octet (PDU byte) 
     Octet := Septet or 
      Byte((Byte(Text7Bit[i + 1]) shl Byte(7 - BitsToMove))); 
     end; 
     Byte(Pdu[PduIdx]) := Octet; 
     Inc(PduIdx); 
     Inc(BitsToMove); 
    end; 
    end; 
    // The following code pads the pdu on the *right* by shifting it to the *left* 
    // by <PaddingBits>. It does this by using the same bit storage convention as 
    // the 7-bit compression routine above, by taking the most significant 
    // <PaddingBits> from each PDU byte and moving them to the least significant 
    // bits of the next PDU byte. If there is no room in the last PDU byte for the 
    // high bits of the previous byte that were removed, then those bits are 
    // placed into an additional byte reserved for this purpose. 
    // Note: <PduLen> has already been set to account for the reserved byte if 
    // it is required. 
    if (PaddingBits > 0) then 
    begin 
    SetLength(Result, (PduLen * 2)); 
    PrevOctet := 0; 
    for PduIdx := 1 to PduLen do 
    begin 
     Octet := Byte(Pdu[PduIdx]); 
     if (PduIdx = 1) then 
     ShiftedOctet := Byte(Octet shl PaddingBits) 
     else 
     ShiftedOctet := Byte(Octet shl PaddingBits) or 
      Byte(PrevOctet shr (8 - PaddingBits)); 
     Byte(Pdu[PduIdx]) := ShiftedOctet; 
     PrevOctet := Octet; 
    end; 
    end; 
    Result := string(StrToHex(Pdu)); 
end; 

function Decode7Bit(const APduData: string; AUdhLen: Integer): string; 
// APduData: Hex string representation of PDU data 
// AUdhLen: Length of UDH including UDH Len (e.g. '050003CC0101' = 6 bytes) 
// Returns decoded Ascii text 
var 
    Pdu: AnsiString; 
    NumSeptets: Byte; 
    Septets: AnsiString; 
    PduIdx: Integer; 
    PduLen: Integer; 
    by: Byte; 
    currBy: Byte; 
    left: Byte; 
    mask: Byte; 
    nextBy: Byte; 
    Octet: Byte; 
    NextOctet: Byte; 
    PaddingBits: Byte; 
    ShiftedOctet: Byte; 
    i: Integer; 
begin 
    Result := ''; 
    PaddingBits := 0; 
    // convert hex string to bytes 
    Pdu := AnsiString(HexToStr(APduData)); 
    PduLen := Length(Pdu); 
    // The following code removes padding at the end of the PDU by shifting it 
    // *right* by <PaddingBits>. It does this by taking the least significant 
    // <PaddingBits> from the following PDU byte and moving them to the most 
    // significant the current PDU byte. 
    if (AUdhLen > 0) then 
    begin 
    PaddingBits := 7 - ((AUdhLen * 8) mod 7); 
    for PduIdx := 1 to PduLen do 
    begin 
     Octet := Byte(Pdu[PduIdx]); 
     if (PduIdx = PduLen) then 
     ShiftedOctet := Byte(Octet shr PaddingBits) 
     else 
     begin 
     NextOctet := Byte(Pdu[PduIdx + 1]); 
     ShiftedOctet := Byte(Octet shr PaddingBits) or 
      Byte(NextOctet shl (8 - PaddingBits)); 
     end; 
     Byte(Pdu[PduIdx]) := ShiftedOctet; 
    end; 
    end; 
    // decode 
    // number of septets in PDU after excluding the padding bits 
    NumSeptets := ((PduLen * 8) - PaddingBits) div 7; 
    Septets := AnsiString(StringOfChar(#0, NumSeptets)); 
    left := 7; 
    mask := $7F; 
    nextBy := 0; 
    PduIdx := 1; 
    for i := 1 to NumSeptets do 
    begin 
    if mask = 0 then 
    begin 
     Septets[i] := AnsiChar(nextBy); 
     left := 7; 
     mask := $7F; 
     nextBy := 0; 
    end 
    else 
    begin 
     if (PduIdx > PduLen) then 
     Break; 
     by := Byte(Pdu[PduIdx]); 
     Inc(PduIdx); 
     currBy := ((by AND mask) SHL (7 - left)) OR nextBy; 
     nextBy := (by AND (NOT mask)) SHR left; 
     Septets[i] := AnsiChar(currBy); 
     mask := mask SHR 1; 
     left := left - 1; 
    end; 
    end; // for 
    // remove last character if unused 
    // this is kind of a hack, but frankly I don't know how else to compensate 
    // for it. 
    if (Septets[NumSeptets] = #0) then 
    SetLength(Septets, NumSeptets - 1); 
    // convert 7-bit alphabet to ascii 
    Result := Convert7BitToAscii(Septets); 
end; 

initialization 
    InitializeTables; 
end. 

Answer 1

no non includere la parte UDH quando la codifica, ma se leggere il GSM phase 2 specification a pagina 57, si parla di questo fatto: "Se viene utilizzato dati 7 bit e il TP-UD-Header non terminare su un limite del settetto, quindi i bit di riempimento vengono inseriti dopo l'ultimo ottetto Information Element Data in modo che sia presente un numero intero di setti per l'intera intestazione TP TP-UD ". Quando si include una parte UDH questo non potrebbe essere il caso, quindi tutto quello che dovete fare è calcolare l'offset (= numero di bit di riempimento)

Calcolare l'offset, questo codice presuppone che UDHPart è un AnsiString:

Len := Length(UDHPart) shr 1; 
Offset := 7 - ((Len * 8) mod 7); // fill bits 

ora durante la codifica dei dati 7 bit, si procede normalmente, ma alla fine, si sposta i dati offset bit verso sinistra, questo codice ha i dati codificati in variabile risultato (Ansi):

// fill bits 
if Offset > 0 then 
    begin 
    v := Result; 
    Len := Length(v); 
    BytesRemain := ceil(((Len * 7)+Offset)/8);  
    Result := StringOfChar(#0, BytesRemain); 
    for InPos := 1 to BytesRemain do 
    begin 
    if InPos = 1 then 
     Byte(Result[InPos]) := Byte(v[InPos]) shl offset 
    else 
     Byte(Result[InPos]) := (Byte(v[InPos]) shl offset) or (Byte(v[InPos-1]) shr (8 - offset)); 
    end; 
    end; 

La decodifica è la stessa cosa, prima spostate l'offset dei dati a 7 bit ts a destra prima della decodifica ...

Spero che questo ti metta sulla giusta strada ...

Answer 2

Nel tuo caso dati è D06536FB0DBABFE56C32

Get primo carattere è D0 => h (in primi 7 bit, l'8 bit non utilizzare)

Il resto è 6536FB0DBABFE56C32

In bin

(01100101) 0011011011111011000011011011101010111111111001010110110000110010

spostamento da destra a sinistra. => ogni diritto 7 bit è un char!

001100100110110011100101101111111011101000001101111 1101100 110110 (0 1100101)

sposto 7 a sinistra. puoi ottenere uno spago dall'alto. ma lo faccio per una facile spettacolo: D

(1100101) (1101100) (1101100) (1101111) (0100000) (1110111) (1101111) (1110010) (1101100) (1100100) 00

e la stringa è "ello mondo"

combinano con primo carattere si ottiene "ciao mondo"