gsmmulti.c File Reference

#include <ctype.h>
#include <string.h>
#include <time.h>
#include <gammu-unicode.h>
#include <gammu-debug.h>
#include "gsmmulti.h"
#include "../gsmring.h"
#include "../gsmlogo.h"
#include "../../misc/coding/coding.h"
#include "../../debug.h"
#include "gsmems.h"
#include "../gsmdata.h"
#include "../gsmnet.h"

Include dependency graph for gsmmulti.c:

Go to the source code of this file.

Functions
unsigned char	GSM_MakeSMSIDFromTime (void)
void	GSM_Find_Free_Used_SMS2 (GSM_Debug_Info *di, GSM_Coding_Type Coding, GSM_SMSMessage *SMS, size_t *UsedText, size_t *FreeText, size_t *FreeBytes)
unsigned int	ReassembleCharacter (char *Buffer, size_t character_index)
int	AlignIfSurrogatePair (GSM_Debug_Info *di, size_t *Copy, char *Buffer, size_t BufferLen)
int	AlignIfCombinedCharacter (GSM_Debug_Info *di, size_t *Copy, char *Buffer, size_t BufferLen)
int	AlignIfCombinedSurrogate (GSM_Debug_Info *di, size_t *Copy, char *Buffer, size_t BufferLen)
int	AlignSegmentForContent (GSM_Debug_Info *di, size_t *Copy, char *Buffer, size_t BufferLen)
GSM_Error	GSM_AddSMS_Text_UDH (GSM_Debug_Info *di, GSM_MultiSMSMessage *SMS, GSM_Coding_Type Coding, char *Buffer, size_t BufferLen, gboolean UDH, size_t *UsedText, size_t *CopiedText, size_t *CopiedSMSText)
void	GSM_MakeMultiPartSMS (GSM_Debug_Info *di, GSM_MultiSMSMessage *SMS, unsigned char *MessageBuffer, size_t MessageLength, GSM_UDH UDHType, GSM_Coding_Type Coding, int Class, unsigned char ReplaceMessage)
void	GSM_SMSCounter (GSM_Debug_Info *di, unsigned char *MessageBuffer, GSM_UDH UDHType, GSM_Coding_Type Coding, int *SMSNum, size_t *CharsLeft)
static void	GSM_EncodeSMS30MultiPartSMS (GSM_MultiPartSMSInfo *Info, char *Buffer, size_t *Length)
GSM_Error	GSM_EncodeAlcatelMultiPartSMS (GSM_Debug_Info *di, GSM_MultiSMSMessage *SMS, unsigned char *Data, size_t Len, unsigned char *Name, size_t Type)
GSM_Error	GSM_EncodeMultiPartSMS (GSM_Debug_Info *di, GSM_MultiPartSMSInfo *Info, GSM_MultiSMSMessage *SMS)
void	GSM_ClearMultiPartSMSInfo (GSM_MultiPartSMSInfo *Info)
void	GSM_FreeMultiPartSMSInfo (GSM_MultiPartSMSInfo *Info)
gboolean	GSM_DecodeMMSIndication (GSM_Debug_Info *di, GSM_MultiPartSMSInfo *Info, GSM_MultiSMSMessage *SMS)
gboolean	GSM_DecodeNokiaProfile (GSM_Debug_Info *di, GSM_MultiPartSMSInfo *Info, GSM_MultiSMSMessage *SMS)
gboolean	GSM_DecodeLinkedText (GSM_Debug_Info *di, GSM_MultiPartSMSInfo *Info, GSM_MultiSMSMessage *SMS)
gboolean	GSM_DecodeMultiPartSMS (GSM_Debug_Info *di, GSM_MultiPartSMSInfo *Info, GSM_MultiSMSMessage *SMS, gboolean ems)
GSM_Error	GSM_LinkSMS (GSM_Debug_Info *di, GSM_MultiSMSMessage **InputMessages, GSM_MultiSMSMessage **OutputMessages, gboolean ems)

Function Documentation

AlignIfCombinedCharacter()

int AlignIfCombinedCharacter	(	GSM_Debug_Info *	di,
		size_t *	Copy,
		char *	Buffer,
		size_t	BufferLen
	)

Definition at line 115 of file gsmmulti.c.

References ReassembleCharacter().

Referenced by AlignSegmentForContent().

{
        int rv = 0;
        unsigned int n;

        /* Precondition:
         *   If we only have one character to copy, or if there isn't any
         *   code unit following our copy window, don't change anything. */

        if (*Copy <= 1 || *Copy >= BufferLen) {
                return rv;
        }

        /* Don't split up a combining sequence:
         *   Peek at the next message segment to see if it begins with
         *   a combining character (e.g. a discritical mark). If it does,
         *   push the final character of this message segment in to the
         *   next message segment. This ensures that the recipient can
         *   visually combine the sequence, even if reassembly fails. */

        n = ReassembleCharacter(Buffer, *Copy);

        /* Unicode combining characters:
         *   Combining Half Marks (U+FE20 - U+FE2F)
         *   Combining Diacritical Marks (U+300 - U+36F)
         *   Combining Diacritical Marks Extended (U+1AB0 - U+1AFF)
         *   Combining Diacritical Marks Supplement (U+1DC0 - U+1DFF)
         *   Combining Diacritical Marks for Symbols (U+20D0 - U+20FF) */

        if ((n >= 0xfe20 && n <= 0xfe2f) ||
            (n >= 0x300 && n <= 0x36f) || (n >= 0x1ab0 && n <= 0x1aff) ||
            (n >= 0x1dc0 && n <= 0x1dff) || (n >= 0x20d0 && n <= 0x20ff)) {
                *Copy -= 1;
                ++rv;
        }

        return rv;
}

AlignIfCombinedSurrogate()

int AlignIfCombinedSurrogate	(	GSM_Debug_Info *	di,
		size_t *	Copy,
		char *	Buffer,
		size_t	BufferLen
	)

Definition at line 157 of file gsmmulti.c.

References ReassembleCharacter().

Referenced by AlignSegmentForContent().

{
        int rv = 0;
        unsigned int l1, l2, r1, r2;

        /* Precondition:
         *   If we have two or fewer characters to copy, omitting two
         *   of them would cause us to send empty message segments. If
         *   there aren't at least two characters remaining *after* the
         *   copy boundary, then there can't possibly be space for a
         *   second surrogate pair there. In either case, send as-is. */

        if (*Copy <= 2 || (*Copy + 2) >= BufferLen) {
                return rv;
        }

        /* Fetch characters:
         *   We retrieve two UTF-16 characters directly preceeding the
         *   copy boundary, and two directly following the copy boundary. */

        l1 = ReassembleCharacter(Buffer, *Copy - 2);
        l2 = ReassembleCharacter(Buffer, *Copy - 1);
        r1 = ReassembleCharacter(Buffer, *Copy);
        r2 = ReassembleCharacter(Buffer, *Copy + 1);

        /* Regional Indicator Symbol (U+1F1E6 - U+1F1FF)
         *   UTF-16 surrogate pairs: 0xd83c 0xdde6 - 0xd83c 0xddff */

        if (l1 == 0xd83c && r1 == 0xd83c &&
            l2 >= 0xdde6 && l2 <= 0xddff && r2 >= 0xdde6 && r2 <= 0xddff) {
                *Copy -= 2;
                rv += 2;
        }

        return rv;
}

AlignIfSurrogatePair()

int AlignIfSurrogatePair	(	GSM_Debug_Info *	di,
		size_t *	Copy,
		char *	Buffer,
		size_t	BufferLen
	)

Definition at line 81 of file gsmmulti.c.

References ReassembleCharacter().

Referenced by AlignSegmentForContent().

{
        int rv = 0;
        unsigned int n;

        /* Precondition:
         *   Resulting copy must always be non-zero. */

        if (*Copy <= 1) {
                return rv;
        }

        /* Don't split a UTF-16 surrogate pair:
         *   If the final code unit to be copied is a lead surrogate, save
         *   it for the next message segment. This allows recipients to view
         *   the proper four-byte UTF-16 character even if they're unable to
         *   reassemble the message (e.g. if a telecom strips off the UDH). */

        n = ReassembleCharacter(Buffer, *Copy - 1);

        /* UTF-16 leading surrogate:
         *   First character in pair is always between U+D800 and U+DBFF */

        if (n >= 0xd800 && n <= 0xdbff) {
                *Copy -= 1;
                ++rv;
        }

        return rv;
}

AlignSegmentForContent()

int AlignSegmentForContent	(	GSM_Debug_Info *	di,
		size_t *	Copy,
		char *	Buffer,
		size_t	BufferLen
	)

Definition at line 197 of file gsmmulti.c.

References AlignIfCombinedCharacter(), AlignIfCombinedSurrogate(), and AlignIfSurrogatePair().

Referenced by GSM_AddSMS_Text_UDH().

{
        int rv = 0;

        if (!(rv += AlignIfSurrogatePair(di, Copy, Buffer, BufferLen))) {
                rv += AlignIfCombinedCharacter(di, Copy, Buffer, BufferLen);
        }

        rv += AlignIfCombinedSurrogate(di, Copy, Buffer, BufferLen);
        return rv;
}

GSM_AddSMS_Text_UDH()

GSM_Error GSM_AddSMS_Text_UDH	(	GSM_Debug_Info *	di,
		GSM_MultiSMSMessage *	SMS,
		GSM_Coding_Type	Coding,
		char *	Buffer,
		size_t	BufferLen,
		gboolean	UDH,
		size_t *	UsedText,
		size_t *	CopiedText,
		size_t *	CopiedSMSText
	)

Definition at line 212 of file gsmmulti.c.

References AlignSegmentForContent(), ERR_NONE, FindDefaultAlphabetLen(), GSM_Find_Free_Used_SMS2(), GSM_UDHHeader::Length, GSM_SMSMessage::Length, GSM_MultiSMSMessage::Number, smfprintf(), GSM_MultiSMSMessage::SMS, SMS_Coding_8bit, SMS_Coding_Default_No_Compression, SMS_Coding_Unicode_No_Compression, GSM_UDHHeader::Text, GSM_SMSMessage::Text, GSM_UDHHeader::Type, GSM_SMSMessage::UDH, UDH_UserUDH, and UnicodeLength().

Referenced by GSM_EncodeEMSMultiPartSMS(), and GSM_MakeMultiPartSMS().

{
        size_t FreeText=0,FreeBytes=0,Copy,i,j;

        smfprintf(di, "Checking used: ");
        GSM_Find_Free_Used_SMS2(
                di, Coding, &(SMS->SMS[SMS->Number]),
                UsedText, &FreeText, &FreeBytes
        );

        if (UDH) {
                smfprintf(di, "Adding UDH\n");
                if (FreeBytes - BufferLen <= 0) {
                        smfprintf(di, "Going to the new SMS\n");
                        SMS->Number++;
                        GSM_Find_Free_Used_SMS2(
                                di, Coding, &(SMS->SMS[SMS->Number]),
                                UsedText, &FreeText, &FreeBytes
                        );
                }
                if (SMS->SMS[SMS->Number].UDH.Length == 0) {
                        SMS->SMS[SMS->Number].UDH.Length  = 1;
                        SMS->SMS[SMS->Number].UDH.Text[0] = 0x00;
                }
                memcpy(SMS->SMS[SMS->Number].UDH.Text+SMS->SMS[SMS->Number].UDH.Length,Buffer,BufferLen);
                SMS->SMS[SMS->Number].UDH.Length        += BufferLen;
                SMS->SMS[SMS->Number].UDH.Text[0]       += BufferLen;
                SMS->SMS[SMS->Number].UDH.Type          =  UDH_UserUDH;
                smfprintf(di, "UDH added %ld\n", (long)BufferLen);
        } else {
                smfprintf(di, "Adding text\n");
                if (FreeText == 0) {
                        smfprintf(di, "Going to the new SMS\n");
                        SMS->Number++;
                        GSM_Find_Free_Used_SMS2(
                                di, Coding, &(SMS->SMS[SMS->Number]),
                                UsedText, &FreeText, &FreeBytes
                        );
                }

                Copy = FreeText;
                smfprintf(di, "Copy %ld (max %ld)\n", (long)Copy, (long)BufferLen);
                if (BufferLen < Copy) {
                        Copy = BufferLen;
                }

                switch (Coding) {
                case SMS_Coding_Default_No_Compression:
                        FindDefaultAlphabetLen(Buffer,&i,&j,FreeText);
                        smfprintf(di, "Defalt text, length %ld %ld\n", (long)i, (long)j);
                        SMS->SMS[SMS->Number].Text[UnicodeLength(SMS->SMS[SMS->Number].Text)*2+i*2]   = 0;
                        SMS->SMS[SMS->Number].Text[UnicodeLength(SMS->SMS[SMS->Number].Text)*2+i*2+1] = 0;
                        memcpy(SMS->SMS[SMS->Number].Text+UnicodeLength(SMS->SMS[SMS->Number].Text)*2,Buffer,i*2);
                        *CopiedText     = i;
                        *CopiedSMSText  = j;
                        SMS->SMS[SMS->Number].Length += i;
                        break;
                case SMS_Coding_Unicode_No_Compression:
                        AlignSegmentForContent(di, &Copy, Buffer, BufferLen);
                        SMS->SMS[SMS->Number].Text[UnicodeLength(SMS->SMS[SMS->Number].Text)*2+Copy*2]   = 0;
                        SMS->SMS[SMS->Number].Text[UnicodeLength(SMS->SMS[SMS->Number].Text)*2+Copy*2+1] = 0;
                        memcpy(SMS->SMS[SMS->Number].Text+UnicodeLength(SMS->SMS[SMS->Number].Text)*2,Buffer,Copy*2);
                        *CopiedText = *CopiedSMSText = Copy;
                        SMS->SMS[SMS->Number].Length += Copy;
                        break;
                case SMS_Coding_8bit:
                        memcpy(SMS->SMS[SMS->Number].Text+SMS->SMS[SMS->Number].Length,Buffer,Copy);
                        SMS->SMS[SMS->Number].Length += Copy;
                        *CopiedText = *CopiedSMSText = Copy;
                        break;
                default:
                        break;
                }
                smfprintf(di, "Text added\n");
        }

        smfprintf(di, "Checking at the end: ");
        GSM_Find_Free_Used_SMS2(
                di, Coding, &(SMS->SMS[SMS->Number]),
                UsedText, &FreeText, &FreeBytes
        );

        return ERR_NONE;
}

GSM_DecodeLinkedText()

gboolean GSM_DecodeLinkedText	(	GSM_Debug_Info *	di,
		GSM_MultiPartSMSInfo *	Info,
		GSM_MultiSMSMessage *	SMS
	)

Decodes long linked text SMS.

Definition at line 1229 of file gsmmulti.c.

References GSM_MultiPartSMSEntry::Buffer, GSM_SMSMessage::Coding, GSM_MultiPartSMSInfo::Entries, GSM_MultiPartSMSInfo::EntriesNum, FALSE, GSM_MultiPartSMSEntry::ID, GSM_SMSMessage::Length, GSM_MultiSMSMessage::Number, GSM_MultiSMSMessage::SMS, SMS_Coding_8bit, SMS_Coding_Default_No_Compression, SMS_Coding_Unicode_No_Compression, SMS_ConcatenatedAutoTextLong, SMS_ConcatenatedAutoTextLong16bit, SMS_ConcatenatedTextLong, SMS_ConcatenatedTextLong16bit, GSM_SMSMessage::Text, TRUE, GSM_UDHHeader::Type, GSM_SMSMessage::UDH, UDH_ConcatenatedMessages16bit, and UnicodeLength().

Referenced by GSM_DecodeMultiPartSMS().

{
        int i, Length = 0;

        Info->EntriesNum    = 1;
        Info->Entries[0].ID = SMS_ConcatenatedTextLong;
        if (SMS->SMS[0].UDH.Type == UDH_ConcatenatedMessages16bit) {
                Info->Entries[0].ID = SMS_ConcatenatedTextLong16bit;
        }

        for (i=0;i<SMS->Number;i++) {
                switch (SMS->SMS[i].Coding) {
                case SMS_Coding_8bit:
                        Info->Entries[0].Buffer = (unsigned char *)realloc(Info->Entries[0].Buffer, Length + SMS->SMS[i].Length + 2);
                        if (Info->Entries[0].Buffer == NULL) return FALSE;

                        memcpy(Info->Entries[0].Buffer + Length, SMS->SMS[i].Text, SMS->SMS[i].Length);
                        Length=Length+SMS->SMS[i].Length;
                        break;
                case SMS_Coding_Unicode_No_Compression:
                        if (Info->Entries[0].ID == SMS_ConcatenatedTextLong) {
                                Info->Entries[0].ID = SMS_ConcatenatedAutoTextLong;
                        }
                        if (Info->Entries[0].ID == SMS_ConcatenatedTextLong16bit) {
                                Info->Entries[0].ID = SMS_ConcatenatedAutoTextLong16bit;
                        }
                case SMS_Coding_Default_No_Compression:
                        Info->Entries[0].Buffer = (unsigned char *)realloc(Info->Entries[0].Buffer, Length + UnicodeLength(SMS->SMS[i].Text)*2 + 2);
                        if (Info->Entries[0].Buffer == NULL) return FALSE;

                        memcpy(Info->Entries[0].Buffer+Length,SMS->SMS[i].Text,UnicodeLength(SMS->SMS[i].Text)*2);
                        Length=Length+UnicodeLength(SMS->SMS[i].Text)*2;
                        break;
                default:
                        break;
                }
        }
        Info->Entries[0].Buffer[Length]   = 0;
        Info->Entries[0].Buffer[Length+1] = 0;
        return TRUE;
}

GSM_DecodeMMSIndication()

gboolean GSM_DecodeMMSIndication	(	GSM_Debug_Info *	di,
		GSM_MultiPartSMSInfo *	Info,
		GSM_MultiSMSMessage *	SMS
	)

Decodes long MMS notification SMS.

Definition at line 981 of file gsmmulti.c.

References GSM_MMSIndicator::Address, GSM_MMSIndicator::Class, dbgprintf, DumpMessage(), GSM_MultiPartSMSInfo::Entries, GSM_MultiPartSMSInfo::EntriesNum, FALSE, GSM_MAX_MULTI_SMS, GSM_MAX_SMS_LENGTH, GSM_MMS_Advertisement, GSM_MMS_Auto, GSM_MMS_Info, GSM_MMS_None, GSM_MMS_Personal, GSM_MultiPartSMSEntry::ID, GSM_SMSMessage::Length, GSM_MMSIndicator::MessageSize, GSM_MultiPartSMSEntry::MMSIndicator, GSM_MultiSMSMessage::Number, GSM_MMSIndicator::Sender, GSM_MultiSMSMessage::SMS, SMS_MMSIndicatorLong, GSM_UDHHeader::Text, GSM_SMSMessage::Text, GSM_MMSIndicator::Title, TRUE, GSM_UDHHeader::Type, GSM_SMSMessage::UDH, UDH_MMSIndicatorLong, and UDH_UserUDH.

Referenced by GSM_DecodeEMSMultiPartSMS(), and GSM_DecodeMultiPartSMS().

{
        int i, Length = 0, j;
        unsigned char Buffer[GSM_MAX_SMS_LENGTH*2*GSM_MAX_MULTI_SMS];

        /* Concatenate data */
        for (i = 0; i < SMS->Number; i++) {
                if (SMS->SMS[i].UDH.Type == UDH_MMSIndicatorLong) {
                        if (SMS->SMS[i].UDH.Text[11] != i+1              ||
                            SMS->SMS[i].UDH.Text[10] != SMS->Number) {
                                return FALSE;
                        }
                } else if (SMS->SMS[i].UDH.Type != UDH_UserUDH) {
                        return FALSE;
                }
                memcpy(Buffer + Length, SMS->SMS[i].Text, SMS->SMS[i].Length);
                Length = Length + SMS->SMS[i].Length;
        }

        dbgprintf(di, "MMS data of length %d:\n", Length);
        DumpMessage(di, Buffer, Length);
        Info->Entries[0].MMSIndicator = (GSM_MMSIndicator *)malloc(sizeof(GSM_MMSIndicator));
        if (Info->Entries[0].MMSIndicator == NULL) {
                return FALSE;
        }
        Info->EntriesNum    = 1;
        Info->Entries[0].ID = SMS_MMSIndicatorLong;
        Info->Entries[0].MMSIndicator->Class = GSM_MMS_None;
        Info->Entries[0].MMSIndicator->MessageSize = 0;
        Info->Entries[0].MMSIndicator->Title[0] = 0;
        Info->Entries[0].MMSIndicator->Sender[0] = 0;
        Info->Entries[0].MMSIndicator->Address[0] = 0;

        /* First byte is transaction ID */
        /* PUSH */
        if (Buffer[1] != 0x06) {
                dbgprintf(di, "Unsupported transaction id: 0x%02x\n", Buffer[1]);
                return FALSE;
        }
        /* Process payload */
        for (i = 3 + Buffer[2]; i < Length; i++) {
                switch(Buffer[i]) {
                        case 0x8c:
                                /* Transaction type */
                                i++;
                                if (Buffer[i] != 0x82) {
                                        dbgprintf(di, "Unsupported transaction type: 0x%02x\n", Buffer[i]);
                                        return FALSE;
                                }
                                break;
                        case 0x98:
                                /* Message ID */
                                while (Buffer[i] != 0 && i < Length) i++;
                                break;
                        case 0x8d:
                                /* MMS version */
                                i++;
                                if (Buffer[i] < 0x90 || Buffer[i] > 0x92) {
                                        dbgprintf(di, "Unsupported MMS version: 0x%02x\n", Buffer[i]);
                                        return FALSE;
                                }
                                break;
                        case 0x89:
                                /* Sender */
                                i++;
                                if (Buffer[i] == 0) continue;
                                if (Buffer[i + 1] == 0x80) {
                                        if (Buffer[i + 2] < 32) {
                                                /* String with length + encoding, we just ignore it for now */
                                                strcpy(Info->Entries[0].MMSIndicator->Sender, Buffer + i + 4);
                                        } else {
                                                strcpy(Info->Entries[0].MMSIndicator->Sender, Buffer + i + 2);
                                        }
                                }
                                i += Buffer[i];
                                break;
                        case 0x96:
                                /* Title */
                                if (Buffer[i + 1] == 0x0a && Buffer[i + 2] == 0xea) {
                                        /* UTF-8 */
                                        strcpy(Info->Entries[0].MMSIndicator->Title, Buffer + i + 3);
                                        i += strlen(Info->Entries[0].MMSIndicator->Title) + 3;
                                } else {
                                        strcpy(Info->Entries[0].MMSIndicator->Title, Buffer + i + 1);
                                        i += strlen(Info->Entries[0].MMSIndicator->Title) + 1;
                                }
                                break;
                        case 0x8a:
                                /* Class */
                                i++;
                                switch (Buffer[i]) {
                                        case 0x80:
                                                Info->Entries[0].MMSIndicator->Class = GSM_MMS_Personal;
                                                break;
                                        case 0x81:
                                                Info->Entries[0].MMSIndicator->Class = GSM_MMS_Advertisement;
                                                break;
                                        case 0x82:
                                                Info->Entries[0].MMSIndicator->Class = GSM_MMS_Info;
                                                break;
                                        case 0x83:
                                                Info->Entries[0].MMSIndicator->Class = GSM_MMS_Auto;
                                                break;
                                        default:
                                                dbgprintf(di, "Unsupported MMS class: 0x%02x\n", Buffer[i]);
                                                break;
                                }
                                break;
                        case 0x8e:
                                /* Message size */
                                i++;
                                for (j = i + 1; j < i + 1 + Buffer[i]; j++) {
                                        Info->Entries[0].MMSIndicator->MessageSize = (Info->Entries[0].MMSIndicator->MessageSize << 8) + Buffer[j];
                                }
                                i += Buffer[i];
                                break;
                        case 0x88:
                                /* Don't know */
                                i++;
                                break;
                        case 0x81:
                                /* Don't know */
                                i++;
                                i += Buffer[i];
                                break;
                        case 0x83:
                                /* URL */
                                strcpy(Info->Entries[0].MMSIndicator->Address, Buffer + i + 1);
                                i += strlen(Info->Entries[0].MMSIndicator->Address) + 1;
                                break;
                        case 0x87:
                        default:
                                dbgprintf(di, "Unknown MMS tag: 0x%02x\n", Buffer[i]);
                                break;
                }
        }

        return TRUE;
}

GSM_DecodeNokiaProfile()

gboolean GSM_DecodeNokiaProfile	(	GSM_Debug_Info *	di,
		GSM_MultiPartSMSInfo *	Info,
		GSM_MultiSMSMessage *	SMS
	)

Decodes long Nokia profile SMS.

Definition at line 1126 of file gsmmulti.c.

References GSM_MultiBitmap::Bitmap, GSM_MultiPartSMSEntry::Bitmap, DecodeUnicodeString(), _GSM_Debug_Info::df, _GSM_Debug_Info::dl, DL_TEXTALL, DL_TEXTALLDATE, EncodeUnicode(), GSM_MultiPartSMSInfo::Entries, GSM_MultiPartSMSInfo::EntriesNum, FALSE, GSM_MAX_MULTI_SMS, GSM_MAX_SMS_LENGTH, GSM_NokiaPictureImage, GSM_PrintBitmap(), GSM_MultiPartSMSEntry::ID, GSM_SMSMessage::Length, GSM_MultiBitmap::Number, GSM_MultiSMSMessage::Number, PHONE_DecodeBitmap(), SM30_ISOTEXT, SM30_OTA, SM30_PROFILENAME, SM30_RINGTONE, SM30_SCREENSAVER, SM30_UNICODETEXT, smfprintf(), GSM_MultiSMSMessage::SMS, SMS_NokiaPictureImageLong, SMS_NokiaProfileLong, SMS_NokiaScreenSaverLong, GSM_Bitmap::Text, GSM_UDHHeader::Text, GSM_SMSMessage::Text, TRUE, GSM_UDHHeader::Type, GSM_SMSMessage::UDH, UDH_NokiaProfileLong, and GSM_MultiPartSMSInfo::Unknown.

Referenced by GSM_DecodeMultiPartSMS().

{
        int i, Length = 0;
        char Buffer[GSM_MAX_SMS_LENGTH*2*GSM_MAX_MULTI_SMS];

        for (i=0;i<SMS->Number;i++) {
                if (SMS->SMS[i].UDH.Type != UDH_NokiaProfileLong ||
                    SMS->SMS[i].UDH.Text[11] != i+1              ||
                    SMS->SMS[i].UDH.Text[10] != SMS->Number) {
                        return FALSE;
                }
                memcpy(Buffer+Length,SMS->SMS[i].Text,SMS->SMS[i].Length);
                Length = Length + SMS->SMS[i].Length;
        }
        Info->EntriesNum    = 1;
        Info->Entries[0].ID = SMS_NokiaPictureImageLong;
        Info->Entries[0].Bitmap = (GSM_MultiBitmap *)malloc(sizeof(GSM_MultiBitmap));
        if (Info->Entries[0].Bitmap == NULL) return FALSE;
        Info->Entries[0].Bitmap->Number = 0;
        Info->Entries[0].Bitmap->Bitmap[0].Text[0] = 0;
        Info->Entries[0].Bitmap->Bitmap[0].Text[1] = 0;
        i=1;
        while (i < Length) {
                switch (Buffer[i]) {
                case SM30_ISOTEXT:
                        smfprintf(di, "ISO 8859-2 text\n");
                        break;
                case SM30_UNICODETEXT:
                        smfprintf(di, "Unicode text\n");
                        break;
                case SM30_OTA:
                        smfprintf(di, "OTA bitmap as Picture Image\n");
                        PHONE_DecodeBitmap(GSM_NokiaPictureImage, Buffer + i + 7, &Info->Entries[0].Bitmap->Bitmap[Info->Entries[0].Bitmap->Number]);
                        Info->Entries[0].Bitmap->Number += 1;
#ifdef DEBUG
                        if (di->dl == DL_TEXTALL || di->dl == DL_TEXTALLDATE) {
                                GSM_PrintBitmap(di->df, &Info->Entries[0].Bitmap->Bitmap[0]);
                        }
#endif
                        break;
                case SM30_RINGTONE:
                        smfprintf(di, "RTTL ringtone\n");
                        Info->Unknown = TRUE;
                        break;
                case SM30_PROFILENAME:
                        smfprintf(di, "Profile Name\n");
                        Info->Entries[0].ID = SMS_NokiaProfileLong;
                        Info->Unknown = TRUE;
                        break;
                case SM30_SCREENSAVER:
                        smfprintf(di, "OTA bitmap as Screen Saver\n");
                        PHONE_DecodeBitmap(GSM_NokiaPictureImage, Buffer + i + 7, &Info->Entries[0].Bitmap->Bitmap[Info->Entries[0].Bitmap->Number]);
                        Info->Entries[0].Bitmap->Number += 1;
#ifdef DEBUG
                        if (di->dl == DL_TEXTALL || di->dl == DL_TEXTALLDATE) {
                                GSM_PrintBitmap(di->df, &Info->Entries[0].Bitmap->Bitmap[0]);
                        }
#endif
                        Info->Entries[0].ID = SMS_NokiaScreenSaverLong;
                        break;
                }
                i = i + Buffer[i+1]*256 + Buffer[i+2] + 3;
                smfprintf(di, "Profile: pos=%i length=%i\n", i, Length);
        }
        i=1;
        while (i < Length) {
                switch (Buffer[i]) {
                case SM30_ISOTEXT:
                        smfprintf(di, "ISO 8859-2 text\n");
                        EncodeUnicode (Info->Entries[0].Bitmap->Bitmap[0].Text, Buffer+i+3, Buffer[i+2]);
                        smfprintf(di, "ISO Text \"%s\"\n",DecodeUnicodeString(Info->Entries[0].Bitmap->Bitmap[0].Text));
                        break;
                case SM30_UNICODETEXT:
                        smfprintf(di, "Unicode text\n");
                        memcpy(Info->Entries[0].Bitmap->Bitmap[0].Text,Buffer+i+3,Buffer[i+1]*256+Buffer[i+2]);
                        Info->Entries[0].Bitmap->Bitmap[0].Text[Buffer[i+1]*256 + Buffer[i+2]]  = 0;
                        Info->Entries[0].Bitmap->Bitmap[0].Text[Buffer[i+1]*256 + Buffer[i+2]+ 1]       = 0;
                        smfprintf(di, "Unicode Text \"%s\"\n",DecodeUnicodeString(Info->Entries[0].Bitmap->Bitmap[0].Text));
                        break;
                case SM30_OTA:
                        smfprintf(di, "OTA bitmap as Picture Image\n");
                        break;
                case SM30_RINGTONE:
                        smfprintf(di, "RTTL ringtone\n");
                        break;
                case SM30_PROFILENAME:
                        smfprintf(di, "Profile Name\n");
                        break;
                case SM30_SCREENSAVER:
                        smfprintf(di, "OTA bitmap as Screen Saver\n");
                        break;
                }
                i = i + Buffer[i+1]*256 + Buffer[i+2] + 3;
                smfprintf(di, "Profile: pos=%i length=%i\n", i, Length);
        }
        return TRUE;
}

GSM_EncodeAlcatelMultiPartSMS()

GSM_Error GSM_EncodeAlcatelMultiPartSMS	(	GSM_Debug_Info *	di,
		GSM_MultiSMSMessage *	SMS,
		unsigned char *	Data,
		size_t	Len,
		unsigned char *	Name,
		size_t	Type
	)

Definition at line 438 of file gsmmulti.c.

References GSM_SMSMessage::Class, GSM_SMSMessage::Coding, EncodeDefault(), ERR_NONE, GSM_EncodeUDHHeader(), GSM_MakeSMSIDFromTime(), GSM_MAX_MULTI_SMS, GSM_PackSevenBitsToEight(), GSM_SetDefaultSMSData(), GSM_UDHHeader::Length, GSM_SMSMessage::Length, GSM_MultiSMSMessage::Number, GSM_MultiSMSMessage::SMS, SMS_Coding_8bit, GSM_UDHHeader::Text, GSM_SMSMessage::Text, TRUE, GSM_UDHHeader::Type, GSM_SMSMessage::UDH, UDH_ConcatenatedMessages, UDH_UserUDH, and UnicodeLength().

Referenced by GSM_EncodeMultiPartSMS().

{
        unsigned char   buff[100],UDHID;
        size_t          i, p;
        GSM_UDHHeader   MyUDH;

        for (i=0;i<GSM_MAX_MULTI_SMS;i++) {
                GSM_SetDefaultSMSData(&SMS->SMS[i]);
                SMS->SMS[i].UDH.Type    = UDH_UserUDH;
                SMS->SMS[i].UDH.Text[1] = 0x80; /* Alcatel */
                p                       = UnicodeLength(Name);
                EncodeDefault(buff, Name, &p, TRUE, NULL);
                SMS->SMS[i].UDH.Text[2] = GSM_PackSevenBitsToEight(0, buff, SMS->SMS[i].UDH.Text+3, p) + 4;
                SMS->SMS[i].UDH.Text[3] = GSM_PackSevenBitsToEight(0, buff, SMS->SMS[i].UDH.Text+3, p);
                SMS->SMS[i].UDH.Text[4] = Type;
                SMS->SMS[i].UDH.Text[5] = Len / 256;
                SMS->SMS[i].UDH.Text[6] = Len % 256;
                SMS->SMS[i].UDH.Text[0] = 6 + SMS->SMS[i].UDH.Text[3];
                SMS->SMS[i].UDH.Length  = SMS->SMS[i].UDH.Text[0] + 1;

                if (Len > (size_t)(140 - SMS->SMS[i].UDH.Length)) {
                        MyUDH.Type = UDH_ConcatenatedMessages;
                        GSM_EncodeUDHHeader(di, &MyUDH);

                        memcpy(SMS->SMS[i].UDH.Text+SMS->SMS[i].UDH.Length,MyUDH.Text+1,MyUDH.Length-1);
                        SMS->SMS[i].UDH.Text[0] += MyUDH.Length-1;
                        SMS->SMS[i].UDH.Length  += MyUDH.Length-1;
                }

                SMS->SMS[i].Coding = SMS_Coding_8bit;
                SMS->SMS[i].Class  = 1;
        }

        p = 0;
        while (p != Len) {
                i = 140-SMS->SMS[SMS->Number].UDH.Length;
                if (Len - p < i) i = Len - p;
                memcpy(SMS->SMS[SMS->Number].Text,Data+p,i);
                p += i;
                SMS->SMS[SMS->Number].Length = i;
                SMS->Number++;

        }

        /* Linked sms UDH */
        if (SMS->Number != 1) {
                UDHID = GSM_MakeSMSIDFromTime();
                for (i = 0; i < (size_t)SMS->Number; i++) {
                        SMS->SMS[i].UDH.Text[SMS->SMS[i].UDH.Length-3] = UDHID;
                        SMS->SMS[i].UDH.Text[SMS->SMS[i].UDH.Length-2] = SMS->Number;
                        SMS->SMS[i].UDH.Text[SMS->SMS[i].UDH.Length-1] = i+1;
                }
        }

        return ERR_NONE;
}

GSM_EncodeSMS30MultiPartSMS()

static void GSM_EncodeSMS30MultiPartSMS ( GSM_MultiPartSMSInfo *  Info, char *  Buffer, size_t *  Length  )

static

Definition at line 375 of file gsmmulti.c.

References GSM_MultiBitmap::Bitmap, GSM_MultiPartSMSEntry::Bitmap, GSM_MultiPartSMSEntry::Buffer, CopyUnicodeString(), DecodeUnicodeString(), GSM_MultiPartSMSInfo::Entries, GSM_EncodeNokiaRTTLRingtone(), GSM_NokiaPictureImage, GSM_MultiPartSMSEntry::ID, NOKIA_CopyBitmap(), GSM_MultiPartSMSEntry::Ringtone, GSM_MultiPartSMSEntry::RingtoneNotes, SM30_ISOTEXT, SM30_OTA, SM30_PROFILENAME, SM30_RINGTONE, SM30_SCREENSAVER, SM30_UNICODETEXT, SMS_NokiaPictureImageLong, SMS_NokiaProfileLong, GSM_Bitmap::Text, GSM_MultiPartSMSInfo::UnicodeCoding, and UnicodeLength().

Referenced by GSM_EncodeMultiPartSMS().

{
        size_t len;

        /*SM version. Here 3.0*/
        Buffer[(*Length)++] = 0x30;

        if (Info->Entries[0].ID == SMS_NokiaProfileLong) {
                if (Info->Entries[0].Buffer != NULL) {
                        if (Info->Entries[0].Buffer[0]!=0x00 || Info->Entries[0].Buffer[1]!=0x00) {
                                Buffer[(*Length)++] = SM30_PROFILENAME;
                                Buffer[(*Length)++] = 0x00;
                                Buffer[(*Length)++] = 2*UnicodeLength(Info->Entries[0].Buffer);
                                CopyUnicodeString(Buffer+(*Length),Info->Entries[0].Buffer);
                                *Length = *Length + 2*UnicodeLength(Info->Entries[0].Buffer);
                        }
                }
                if (Info->Entries[0].Ringtone != NULL) {
                        Buffer[(*Length)++] = SM30_RINGTONE;
                        /* Length for this part later will be changed */
                        Buffer[(*Length)++] = 0x01;
                        Buffer[(*Length)++] = 0x00;
                        /* Smart Messaging 3.0 says: 16*9=144 bytes,
                         * but on 3310 4.02 it was possible to save about 196 chars
                         * (without cutting) */
                        len = 196;
                        Info->Entries[0].RingtoneNotes=GSM_EncodeNokiaRTTLRingtone(Info->Entries[0].Ringtone,Buffer+(*Length),&len);
                        Buffer[(*Length)-2] = len / 256;
                        Buffer[(*Length)-1] = len % 256;
                        *Length = *Length + len;
                }
        }
        if (Info->Entries[0].Bitmap != NULL) {
                if (Info->Entries[0].ID == SMS_NokiaPictureImageLong) {
                        Buffer[(*Length)++] = SM30_OTA;
                } else {
                        Buffer[(*Length)++] = SM30_SCREENSAVER;
                }
                Buffer[(*Length)++] = 0x01;
                Buffer[(*Length)++] = 0x00;
                NOKIA_CopyBitmap(GSM_NokiaPictureImage, &Info->Entries[0].Bitmap->Bitmap[0], Buffer, Length);
                if (Info->Entries[0].Bitmap->Bitmap[0].Text[0]!=0 || Info->Entries[0].Bitmap->Bitmap[0].Text[1]!=0) {
                        if (Info->UnicodeCoding) {
                                Buffer[(*Length)++] = SM30_UNICODETEXT;
                                /* Length for text part */
                                Buffer[(*Length)++] = 0x00;
                                Buffer[(*Length)++] = UnicodeLength(Info->Entries[0].Bitmap->Bitmap[0].Text)*2;
                                memcpy(Buffer+(*Length),Info->Entries[0].Bitmap->Bitmap[0].Text,UnicodeLength(Info->Entries[0].Bitmap->Bitmap[0].Text)*2);
                                *Length = *Length + UnicodeLength(Info->Entries[0].Bitmap->Bitmap[0].Text)*2;
                        } else {
                                /*ID for ISO-8859-1 text*/
                                Buffer[(*Length)++] = SM30_ISOTEXT;
                                Buffer[(*Length)++] = 0x00;
                                Buffer[(*Length)++] = UnicodeLength(Info->Entries[0].Bitmap->Bitmap[0].Text);
                                memcpy(Buffer+(*Length),DecodeUnicodeString(Info->Entries[0].Bitmap->Bitmap[0].Text),UnicodeLength(Info->Entries[0].Bitmap->Bitmap[0].Text));
                                *Length = *Length +UnicodeLength(Info->Entries[0].Bitmap->Bitmap[0].Text);
                        }
                }
        }
}

GSM_Find_Free_Used_SMS2()

void GSM_Find_Free_Used_SMS2	(	GSM_Debug_Info *	di,
		GSM_Coding_Type	Coding,
		GSM_SMSMessage *	SMS,
		size_t *	UsedText,
		size_t *	FreeText,
		size_t *	FreeBytes
	)

Definition at line 37 of file gsmmulti.c.

References FindDefaultAlphabetLen(), GSM_MAX_8BIT_SMS_LENGTH, GSM_UDHHeader::Length, GSM_SMSMessage::Length, smfprintf(), SMS_Coding_8bit, SMS_Coding_Default_No_Compression, SMS_Coding_Unicode_No_Compression, GSM_SMSMessage::Text, GSM_SMSMessage::UDH, and UnicodeLength().

Referenced by GSM_AddSMS_Text_UDH(), GSM_EncodeEMSMultiPartSMS(), and GSM_SMSCounter().

{
        size_t UsedBytes = 0;

        switch (Coding) {
        case SMS_Coding_Default_No_Compression:
                FindDefaultAlphabetLen(SMS->Text,&UsedBytes,UsedText,500);
                UsedBytes = *UsedText * 7 / 8;
                if (UsedBytes * 8 / 7 != *UsedText) UsedBytes++;
                *FreeBytes = GSM_MAX_8BIT_SMS_LENGTH - SMS->UDH.Length - UsedBytes;
                *FreeText = (GSM_MAX_8BIT_SMS_LENGTH - SMS->UDH.Length) * 8 / 7 - *UsedText;
                break;
        case SMS_Coding_Unicode_No_Compression:
                *UsedText = UnicodeLength(SMS->Text);
                UsedBytes = *UsedText * 2;
                *FreeBytes = GSM_MAX_8BIT_SMS_LENGTH - SMS->UDH.Length - UsedBytes;
                *FreeText = *FreeBytes / 2;
                break;
        case SMS_Coding_8bit:
                *UsedText = UsedBytes = SMS->Length;
                *FreeBytes = GSM_MAX_8BIT_SMS_LENGTH - SMS->UDH.Length - UsedBytes;
                *FreeText = *FreeBytes;
                break;
        default:
                break;
        }
        smfprintf(di, "UDH len %i, UsedBytes %ld, FreeText %ld, UsedText %ld, FreeBytes %ld\n",
                SMS->UDH.Length,
                (long)UsedBytes,
                (long)*FreeText,
                (long)*UsedText,
                (long)*FreeBytes);
}

GSM_MakeMultiPartSMS()

void GSM_MakeMultiPartSMS	(	GSM_Debug_Info *	di,
		GSM_MultiSMSMessage *	SMS,
		unsigned char *	MessageBuffer,
		size_t	MessageLength,
		GSM_UDH	UDHType,
		GSM_Coding_Type	Coding,
		int	Class,
		unsigned char	ReplaceMessage
	)

Definition at line 305 of file gsmmulti.c.

References GSM_UDHHeader::AllParts, GSM_SMSMessage::Class, GSM_SMSMessage::Coding, FALSE, GSM_AddSMS_Text_UDH(), GSM_EncodeUDHHeader(), GSM_GetCurrentDateTime(), GSM_MakeSMSIDFromTime(), GSM_MAX_MULTI_SMS, GSM_SetDefaultSMSData(), GSM_DateTime::Hour, GSM_UDHHeader::ID16bit, GSM_UDHHeader::ID8bit, GSM_MultiSMSMessage::Number, GSM_UDHHeader::PartNumber, GSM_SMSMessage::ReplaceMessage, smfprintf(), GSM_MultiSMSMessage::SMS, SMS_Coding_8bit, GSM_UDHHeader::Type, and GSM_SMSMessage::UDH.

Referenced by GSM_EncodeMultiPartSMS(), and GSM_SMSCounter().

{
        size_t          Len,UsedText = 0,CopiedText = 0,CopiedSMSText = 0;
        int             j;
        unsigned char   UDHID;
        GSM_DateTime    Date;

        Len = 0;
        while(1) {
                if (SMS->Number >= GSM_MAX_MULTI_SMS) {
                        break;
                }
                GSM_SetDefaultSMSData(&SMS->SMS[SMS->Number]);
                SMS->SMS[SMS->Number].Class    = Class;
                SMS->SMS[SMS->Number].Coding   = Coding;

                SMS->SMS[SMS->Number].UDH.Type = UDHType;
                GSM_EncodeUDHHeader(di, &SMS->SMS[SMS->Number].UDH);

                if (Coding == SMS_Coding_8bit) {
                        GSM_AddSMS_Text_UDH(di, SMS,Coding,MessageBuffer+Len,MessageLength - Len,FALSE,&UsedText,&CopiedText,&CopiedSMSText);
                } else {
                        GSM_AddSMS_Text_UDH(di, SMS,Coding,MessageBuffer+Len*2,MessageLength - Len,FALSE,&UsedText,&CopiedText,&CopiedSMSText);
                }
                Len += CopiedText;
                smfprintf(di, "%ld %ld\n", (long)Len, (long)MessageLength);
                SMS->Number++;
                if (Len == MessageLength) break;
        }

        UDHID = GSM_MakeSMSIDFromTime();
        GSM_GetCurrentDateTime (&Date);
        for (j=0;j<SMS->Number;j++) {
                SMS->SMS[j].UDH.Type            = UDHType;
                SMS->SMS[j].UDH.ID8bit          = UDHID;
                SMS->SMS[j].UDH.ID16bit         = UDHID + 256 * Date.Hour;
                SMS->SMS[j].UDH.PartNumber      = j+1;
                SMS->SMS[j].UDH.AllParts        = SMS->Number;
                GSM_EncodeUDHHeader(di, &SMS->SMS[j].UDH);
        }
        if (SMS->Number == 1) SMS->SMS[0].ReplaceMessage = ReplaceMessage;
}

GSM_MakeSMSIDFromTime()

unsigned char GSM_MakeSMSIDFromTime

(

void

)

Definition at line 21 of file gsmmulti.c.

References GSM_GetCurrentDateTime(), GSM_DateTime::Minute, and GSM_DateTime::Second.

Referenced by GSM_EncodeAlcatelMultiPartSMS(), GSM_EncodeEMSMultiPartSMS(), and GSM_MakeMultiPartSMS().

{
        GSM_DateTime    Date;
        unsigned char   retval;

        GSM_GetCurrentDateTime (&Date);
        retval = Date.Second;
        switch (Date.Minute/10) {
                case 2: case 7:         retval = retval +  60; break;
                case 4: case 8:         retval = retval + 120; break;
                case 9: case 5: case 0: retval = retval + 180; break;
        }
        retval += Date.Minute/10;
        return retval;
}

ReassembleCharacter()

unsigned int ReassembleCharacter	(	char *	Buffer,
		size_t	character_index
	)

Definition at line 71 of file gsmmulti.c.

Referenced by AlignIfCombinedCharacter(), AlignIfCombinedSurrogate(), and AlignIfSurrogatePair().

{
        size_t offset = character_index * 2;

        return (
          (unsigned int) ((unsigned char) Buffer[offset] << 8)
            + (unsigned char) Buffer[offset + 1]
        );
}