Collaboration diagram for SMS messages:

Data Structures
struct	GSM_SMSMemoryStatus

struct	GSM_SMSValidity

struct	GSM_SMSC

struct	GSM_UDHHeader

struct	GSM_SMSMessage

struct	GSM_OneSMSFolder

struct	GSM_SMSFolders

struct	GSM_SiemensOTASMSInfo

struct	GSM_MultiSMSMessage

struct	GSM_MultiPartSMSEntry

struct	GSM_MultiPartSMSInfo

Enumerations
enum	GSM_SMSFormat { SMS_FORMAT_Pager = 1, SMS_FORMAT_Fax, SMS_FORMAT_Email, SMS_FORMAT_Text }

enum	GSM_ValidityPeriod { SMS_VALID_1_Hour = 0x0b, SMS_VALID_6_Hours = 0x47, SMS_VALID_1_Day = 0xa7, SMS_VALID_3_Days = 0xa9, SMS_VALID_1_Week = 0xad, SMS_VALID_Max_Time = 0xff }

enum	GSM_ValidityPeriodFormat { SMS_Validity_NotAvailable = 1, SMS_Validity_RelativeFormat }

enum	GSM_SMS_State { SMS_Sent = 1, SMS_UnSent, SMS_Read, SMS_UnRead }

enum	GSM_Coding_Type { SMS_Coding_Unicode_No_Compression = 1, SMS_Coding_Unicode_Compression, SMS_Coding_Default_No_Compression, SMS_Coding_Default_Compression, SMS_Coding_8bit }

enum	GSM_UDH { UDH_NoUDH = 1, UDH_ConcatenatedMessages, UDH_ConcatenatedMessages16bit, UDH_DisableVoice, UDH_DisableFax, UDH_DisableEmail, UDH_EnableVoice, UDH_EnableFax, UDH_EnableEmail, UDH_VoidSMS, UDH_NokiaRingtone, UDH_NokiaRingtoneLong, UDH_NokiaOperatorLogo, UDH_NokiaOperatorLogoLong, UDH_NokiaCallerLogo, UDH_NokiaWAP, UDH_NokiaWAPLong, UDH_NokiaCalendarLong, UDH_NokiaProfileLong, UDH_NokiaPhonebookLong, UDH_UserUDH, UDH_MMSIndicatorLong }

enum	GSM_SMSMessageType { SMS_Deliver = 1, SMS_Status_Report, SMS_Submit }

enum	EncodeMultiPartSMSID { SMS_Text = 1, SMS_ConcatenatedTextLong, SMS_ConcatenatedAutoTextLong, SMS_ConcatenatedTextLong16bit, SMS_ConcatenatedAutoTextLong16bit, SMS_NokiaProfileLong, SMS_NokiaPictureImageLong, SMS_NokiaScreenSaverLong, SMS_NokiaRingtone, SMS_NokiaRingtoneLong, SMS_NokiaOperatorLogo, SMS_NokiaOperatorLogoLong, SMS_NokiaCallerLogo, SMS_NokiaWAPBookmarkLong, SMS_NokiaWAPSettingsLong, SMS_NokiaMMSSettingsLong, SMS_NokiaVCARD10Long, SMS_NokiaVCARD21Long, SMS_NokiaVCALENDAR10Long, SMS_NokiaVTODOLong, SMS_VCARD10Long, SMS_VCARD21Long, SMS_DisableVoice, SMS_DisableFax, SMS_DisableEmail, SMS_EnableVoice, SMS_EnableFax, SMS_EnableEmail, SMS_VoidSMS, SMS_EMSSound10, SMS_EMSSound12, SMS_EMSSonyEricssonSound, SMS_EMSSound10Long, SMS_EMSSound12Long, SMS_EMSSonyEricssonSoundLong, SMS_EMSPredefinedSound, SMS_EMSPredefinedAnimation, SMS_EMSAnimation, SMS_EMSFixedBitmap, SMS_EMSVariableBitmap, SMS_EMSVariableBitmapLong, SMS_MMSIndicatorLong, SMS_WAPIndicatorLong, SMS_AlcatelMonoBitmapLong, SMS_AlcatelMonoAnimationLong, SMS_AlcatelSMSTemplateName, SMS_SiemensFile }

Functions
GSM_Error	GSM_DecodePDUFrame (GSM_Debug_Info di, GSM_SMSMessage SMS, const unsigned char buffer, size_t length, size_t final_pos, gboolean SMSC)

GSM_Error	GSM_DecodeSMSFrame (GSM_Debug_Info di, GSM_SMSMessage SMS, unsigned char *buffer, GSM_SMSMessageLayout Layout)

GSM_Error	GSM_EncodeSMSFrame (GSM_Debug_Info di, GSM_SMSMessage SMS, unsigned char buffer, GSM_SMSMessageLayout Layout, int length, gboolean clear)

GSM_Error	GSM_DecodeSMSFrameStatusReportData (GSM_Debug_Info di, GSM_SMSMessage SMS, unsigned char *buffer, GSM_SMSMessageLayout Layout)

GSM_Error	GSM_DecodeSMSFrameText (GSM_Debug_Info di, GSM_SMSMessage SMS, unsigned char *buffer, GSM_SMSMessageLayout Layout)

void	GSM_DecodeUDHHeader (GSM_Debug_Info di, GSM_UDHHeader UDH)

void	GSM_EncodeUDHHeader (GSM_Debug_Info di, GSM_UDHHeader UDH)

void	GSM_SetDefaultReceivedSMSData (GSM_SMSMessage *SMS)

void	GSM_SetDefaultSMSData (GSM_SMSMessage *SMS)

gboolean	GSM_DecodeSiemensOTASMS (GSM_Debug_Info di, GSM_SiemensOTASMSInfo Info, GSM_SMSMessage *SMS)

GSM_Error	PHONE_EncodeSMSFrame (GSM_StateMachine s, GSM_SMSMessage SMS, unsigned char buffer, GSM_SMSMessageLayout Layout, int length, gboolean clear)

GSM_Error	GSM_EncodeMultiPartSMS (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)

void	GSM_ClearMultiPartSMSInfo (GSM_MultiPartSMSInfo *Info)

void	GSM_FreeMultiPartSMSInfo (GSM_MultiPartSMSInfo *Info)

GSM_Error	GSM_LinkSMS (GSM_Debug_Info di, GSM_MultiSMSMessage INPUT, GSM_MultiSMSMessage *OUTPUT, gboolean ems)

GSM_Error	GSM_GetSMSC (GSM_StateMachine s, GSM_SMSC smsc)

GSM_Error	GSM_SetSMSC (GSM_StateMachine s, GSM_SMSC smsc)

GSM_Error	GSM_GetSMSStatus (GSM_StateMachine s, GSM_SMSMemoryStatus status)

GSM_Error	GSM_GetSMS (GSM_StateMachine s, GSM_MultiSMSMessage sms)

GSM_Error	GSM_GetNextSMS (GSM_StateMachine s, GSM_MultiSMSMessage sms, gboolean start)

GSM_Error	GSM_SetSMS (GSM_StateMachine s, GSM_SMSMessage sms)

GSM_Error	GSM_AddSMS (GSM_StateMachine s, GSM_SMSMessage sms)

GSM_Error	GSM_DeleteSMS (GSM_StateMachine s, GSM_SMSMessage sms)

GSM_Error	GSM_SendSMS (GSM_StateMachine s, GSM_SMSMessage sms)

GSM_Error	GSM_SendSavedSMS (GSM_StateMachine *s, int Folder, int Location)

GSM_Error	GSM_SetFastSMSSending (GSM_StateMachine *s, gboolean enable)

GSM_Error	GSM_SetIncomingSMS (GSM_StateMachine *s, gboolean enable)

GSM_Error	GSM_GetSMSFolders (GSM_StateMachine s, GSM_SMSFolders folders)

GSM_Error	GSM_AddSMSFolder (GSM_StateMachine s, unsigned char name)

GSM_Error	GSM_DeleteSMSFolder (GSM_StateMachine *s, int ID)

void	GSM_SMSCounter (GSM_Debug_Info di, unsigned char MessageBuffer, GSM_UDH UDHType, GSM_Coding_Type Coding, int SMSNum, size_t CharsLeft)

Variables
GSM_SMSMessageLayout	PHONE_SMSSubmit

GSM_SMSMessageLayout	PHONE_SMSDeliver

GSM_SMSMessageLayout	PHONE_SMSStatusReport

Detailed Description

SMS messages manipulations.

Enumeration Type Documentation

§ EncodeMultiPartSMSID

enum EncodeMultiPartSMSID

ID during packing SMS for Smart Messaging 3.0, EMS and other

Enumerator
SMS_Text	1 text SMS.
SMS_ConcatenatedTextLong	Contacenated SMS, when longer than 1 SMS.
SMS_ConcatenatedAutoTextLong	Contacenated SMS, auto Default/Unicode coding.
SMS_ConcatenatedTextLong16bit
SMS_ConcatenatedAutoTextLong16bit
SMS_NokiaProfileLong	Nokia profile = Name, Ringtone, ScreenSaver
SMS_NokiaPictureImageLong	Nokia Picture Image + (text)
SMS_NokiaScreenSaverLong	Nokia screen saver + (text)
SMS_NokiaRingtone	Nokia ringtone - old SM2.0 format, 1 SMS
SMS_NokiaRingtoneLong	Nokia ringtone contacenated, when very long
SMS_NokiaOperatorLogo	Nokia 72x14 operator logo, 1 SMS
SMS_NokiaOperatorLogoLong	Nokia 72x14 op logo or 78x21 in 2 SMS
SMS_NokiaCallerLogo	Nokia 72x14 caller logo, 1 SMS
SMS_NokiaWAPBookmarkLong	Nokia WAP bookmark in 1 or 2 SMS
SMS_NokiaWAPSettingsLong	Nokia WAP settings in 2 SMS
SMS_NokiaMMSSettingsLong	Nokia MMS settings in 2 SMS
SMS_NokiaVCARD10Long	Nokia VCARD 1.0 - only name and default number
SMS_NokiaVCARD21Long	Nokia VCARD 2.1 - all numbers + text
SMS_NokiaVCALENDAR10Long	Nokia VCALENDAR 1.0 - can be in few sms
SMS_NokiaVTODOLong
SMS_VCARD10Long
SMS_VCARD21Long
SMS_DisableVoice
SMS_DisableFax
SMS_DisableEmail
SMS_EnableVoice
SMS_EnableFax
SMS_EnableEmail
SMS_VoidSMS
SMS_EMSSound10	IMelody 1.0
SMS_EMSSound12	IMelody 1.2
SMS_EMSSonyEricssonSound	IMelody without header - SonyEricsson extension
SMS_EMSSound10Long	IMelody 1.0 with UPI.
SMS_EMSSound12Long	IMelody 1.2 with UPI.
SMS_EMSSonyEricssonSoundLong	IMelody without header with UPI.
SMS_EMSPredefinedSound
SMS_EMSPredefinedAnimation
SMS_EMSAnimation
SMS_EMSFixedBitmap	Fixed bitmap of size 16x16 or 32x32.
SMS_EMSVariableBitmap
SMS_EMSVariableBitmapLong
SMS_MMSIndicatorLong	MMS message indicator.
SMS_WAPIndicatorLong
SMS_AlcatelMonoBitmapLong	Variable bitmap with black and white colors
SMS_AlcatelMonoAnimationLong	Variable animation with black and white colors
SMS_AlcatelSMSTemplateName
SMS_SiemensFile	Siemens OTA

Definition at line 840 of file gammu-message.h.

              {
         SMS_Text = 1,
         SMS_ConcatenatedTextLong,
         SMS_ConcatenatedAutoTextLong,
         SMS_ConcatenatedTextLong16bit,
         SMS_ConcatenatedAutoTextLong16bit,
         SMS_NokiaProfileLong,
         SMS_NokiaPictureImageLong,
         SMS_NokiaScreenSaverLong,
         SMS_NokiaRingtone,
         SMS_NokiaRingtoneLong,
         SMS_NokiaOperatorLogo,
         SMS_NokiaOperatorLogoLong,
         SMS_NokiaCallerLogo,
         SMS_NokiaWAPBookmarkLong,
         SMS_NokiaWAPSettingsLong,
         SMS_NokiaMMSSettingsLong,
         SMS_NokiaVCARD10Long,
         SMS_NokiaVCARD21Long,
         SMS_NokiaVCALENDAR10Long,
         SMS_NokiaVTODOLong,
         SMS_VCARD10Long,
         SMS_VCARD21Long,
         SMS_DisableVoice,
         SMS_DisableFax,
         SMS_DisableEmail,
         SMS_EnableVoice,
         SMS_EnableFax,
         SMS_EnableEmail,
         SMS_VoidSMS,
         SMS_EMSSound10,
         SMS_EMSSound12,
         SMS_EMSSonyEricssonSound,
         SMS_EMSSound10Long,
         SMS_EMSSound12Long,
         SMS_EMSSonyEricssonSoundLong,
         SMS_EMSPredefinedSound,
         SMS_EMSPredefinedAnimation,
         SMS_EMSAnimation,
         SMS_EMSFixedBitmap,
         SMS_EMSVariableBitmap,
         SMS_EMSVariableBitmapLong,
         SMS_MMSIndicatorLong,
         SMS_WAPIndicatorLong,
         SMS_AlcatelMonoBitmapLong,
         SMS_AlcatelMonoAnimationLong,
         SMS_AlcatelSMSTemplateName,
         SMS_SiemensFile
 } EncodeMultiPartSMSID;

§ GSM_Coding_Type

enum GSM_Coding_Type

Coding type of SMS.

Enumerator
SMS_Coding_Unicode_No_Compression	Unicode
SMS_Coding_Unicode_Compression
SMS_Coding_Default_No_Compression	Default GSM alphabet.
SMS_Coding_Default_Compression
SMS_Coding_8bit	8-bit.

Definition at line 316 of file gammu-message.h.

              {
         SMS_Coding_Unicode_No_Compression = 1,
         SMS_Coding_Unicode_Compression,
         SMS_Coding_Default_No_Compression,
         SMS_Coding_Default_Compression,
         SMS_Coding_8bit
 } GSM_Coding_Type;

§ GSM_SMS_State

enum GSM_SMS_State

Status of SMS message.

Enumerator
SMS_Sent
SMS_UnSent
SMS_Read
SMS_UnRead

Definition at line 304 of file gammu-message.h.

              {
         SMS_Sent = 1,
         SMS_UnSent,
         SMS_Read,
         SMS_UnRead
 } GSM_SMS_State;

§ GSM_SMSFormat

enum GSM_SMSFormat

Enum defines format of SMS messages. See GSM 03.40 section 9.2.3.9

Enumerator
SMS_FORMAT_Pager
SMS_FORMAT_Fax
SMS_FORMAT_Email
SMS_FORMAT_Text

Definition at line 218 of file gammu-message.h.

              {
         SMS_FORMAT_Pager = 1,
         SMS_FORMAT_Fax,
         SMS_FORMAT_Email,
         SMS_FORMAT_Text
             /* Some values not handled here */
 } GSM_SMSFormat;

§ GSM_SMSMessageType

enum GSM_SMSMessageType

TP-Message-Type-Indicator. See GSM 03.40 section 9.2.3.1.

Enumerator
SMS_Deliver	SMS in Inbox.
SMS_Status_Report	Delivery Report
SMS_Submit	SMS for sending or in Outbox

Definition at line 422 of file gammu-message.h.

              {
         SMS_Deliver = 1,
         SMS_Status_Report,
         SMS_Submit
             /* specification gives more */
 } GSM_SMSMessageType;

§ GSM_UDH

enum GSM_UDH

Types of UDH (User Data Header).

Enumerator
UDH_NoUDH
UDH_ConcatenatedMessages	Linked SMS.
UDH_ConcatenatedMessages16bit	Linked SMS with 16 bit reference.
UDH_DisableVoice
UDH_DisableFax
UDH_DisableEmail
UDH_EnableVoice
UDH_EnableFax
UDH_EnableEmail
UDH_VoidSMS
UDH_NokiaRingtone
UDH_NokiaRingtoneLong
UDH_NokiaOperatorLogo
UDH_NokiaOperatorLogoLong
UDH_NokiaCallerLogo
UDH_NokiaWAP
UDH_NokiaWAPLong
UDH_NokiaCalendarLong
UDH_NokiaProfileLong
UDH_NokiaPhonebookLong
UDH_UserUDH
UDH_MMSIndicatorLong

Definition at line 350 of file gammu-message.h.

              {
         UDH_NoUDH = 1,
         UDH_ConcatenatedMessages,
         UDH_ConcatenatedMessages16bit,
         UDH_DisableVoice,
         UDH_DisableFax,
         UDH_DisableEmail,
         UDH_EnableVoice,
         UDH_EnableFax,
         UDH_EnableEmail,
         UDH_VoidSMS,
         UDH_NokiaRingtone,
         UDH_NokiaRingtoneLong,
         UDH_NokiaOperatorLogo,
         UDH_NokiaOperatorLogoLong,
         UDH_NokiaCallerLogo,
         UDH_NokiaWAP,
         UDH_NokiaWAPLong,
         UDH_NokiaCalendarLong,
         UDH_NokiaProfileLong,
         UDH_NokiaPhonebookLong,
         UDH_UserUDH,
         UDH_MMSIndicatorLong
 } GSM_UDH;

§ GSM_ValidityPeriod

enum GSM_ValidityPeriod

Enum defines some the most often used validity lengths for SMS messages for relative validity format. See GSM 03.40 section 9.2.3.12.1 - it gives more values.

Enumerator
SMS_VALID_1_Hour
SMS_VALID_6_Hours
SMS_VALID_1_Day
SMS_VALID_3_Days
SMS_VALID_1_Week
SMS_VALID_Max_Time

Definition at line 233 of file gammu-message.h.

              {
         SMS_VALID_1_Hour = 0x0b,
         SMS_VALID_6_Hours = 0x47,
         SMS_VALID_1_Day = 0xa7,
         SMS_VALID_3_Days = 0xa9,
         SMS_VALID_1_Week = 0xad,
         SMS_VALID_Max_Time = 0xff
 } GSM_ValidityPeriod;

§ GSM_ValidityPeriodFormat

enum GSM_ValidityPeriodFormat

Enum defines format of validity period for SMS messages. See GSM 03.40 section 9.2.3.12

Enumerator
SMS_Validity_NotAvailable
SMS_Validity_RelativeFormat

Definition at line 248 of file gammu-message.h.

              {
         SMS_Validity_NotAvailable = 1,
         SMS_Validity_RelativeFormat
             /* Specification gives also other possibilities */
 } GSM_ValidityPeriodFormat;

Function Documentation

§ GSM_AddSMS()

GSM_Error GSM_AddSMS	(	GSM_StateMachine *	s,
		GSM_SMSMessage *	sms
	)

Adds SMS to specified folder.

Parameters

	s	State machine pointer.
[in,out]	sms	SMS message data, location will be updated.

Returns: Error code.

Adds SMS to specified folder.

Definition at line 712 of file api.c.

References GSM_Phone_Functions::AddSMS, CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, and PRINT_SMS_INFO.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
         PRINT_SMS_INFO();
 
         err = s->Phone.Functions->AddSMS(s, sms);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_AddSMSFolder()

GSM_Error GSM_AddSMSFolder	(	GSM_StateMachine *	s,
		unsigned char *	name
	)

Creates SMS folder.

Parameters

	s	State machine pointer.
[in]	name	Name of SMS folder which should be created.

Returns: Error code.

Creates SMS folder.

Definition at line 819 of file api.c.

References GSM_Phone_Functions::AddSMSFolder, CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
 
         err = s->Phone.Functions->AddSMSFolder(s, name);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_ClearMultiPartSMSInfo()

void GSM_ClearMultiPartSMSInfo ( GSM_MultiPartSMSInfo * Info )

Clears GSM_MultiPartSMSInfo to default values.

Definition at line 915 of file gsmmulti.c.

Referenced by GSM_DecodeMultiPartSMS().

 {
         int i;
 
         for (i=0;i<GSM_MAX_MULTI_SMS;i++) {
                 Info->Entries[i].Number         = 0;
                 Info->Entries[i].Ringtone       = NULL;
                 Info->Entries[i].Bitmap         = NULL;
                 Info->Entries[i].Bookmark       = NULL;
                 Info->Entries[i].File           = NULL;
                 Info->Entries[i].Settings       = NULL;
                 Info->Entries[i].MMSIndicator   = NULL;
                 Info->Entries[i].Phonebook      = NULL;
                 Info->Entries[i].Calendar       = NULL;
                 Info->Entries[i].ToDo           = NULL;
                 Info->Entries[i].Protected      = FALSE;
 
                 Info->Entries[i].Buffer         = NULL;
                 Info->Entries[i].Left           = FALSE;
                 Info->Entries[i].Right          = FALSE;
                 Info->Entries[i].Center         = FALSE;
                 Info->Entries[i].Large          = FALSE;
                 Info->Entries[i].Small          = FALSE;
                 Info->Entries[i].Bold           = FALSE;
                 Info->Entries[i].Italic         = FALSE;
                 Info->Entries[i].Underlined     = FALSE;
                 Info->Entries[i].Strikethrough  = FALSE;
 
                 Info->Entries[i].RingtoneNotes  = 0;
         }
         Info->Unknown           = FALSE;
         Info->EntriesNum        = 0;
         Info->Class             = -1;
         Info->ReplaceMessage    = 0;
         Info->UnicodeCoding     = FALSE;
 }

§ GSM_DecodeMultiPartSMS()

gboolean GSM_DecodeMultiPartSMS	(	GSM_Debug_Info *	di,
		GSM_MultiPartSMSInfo *	Info,
		GSM_MultiSMSMessage *	SMS,
		gboolean	ems
	)

Decodes multi part SMS to "readable" format.

Definition at line 1275 of file gsmmulti.c.

References GSM_SiemensOTASMSInfo::AllDataLen, GSM_MultiBitmap::Bitmap, GSM_MultiPartSMSEntry::Bitmap, GSM_File::Buffer, GSM_SiemensOTASMSInfo::Data, GSM_SiemensOTASMSInfo::DataLen, GSM_SiemensOTASMSInfo::DataName, _GSM_Debug_Info::df, _GSM_Debug_Info::dl, DL_TEXTALL, DL_TEXTALLDATE, EncodeUnicode(), GSM_MultiPartSMSInfo::Entries, GSM_MultiPartSMSInfo::EntriesNum, ERR_NONE, FALSE, GSM_MultiPartSMSEntry::File, GSM_ClearMultiPartSMSInfo(), GSM_DecodeEMSMultiPartSMS(), GSM_DecodeLinkedText(), GSM_DecodeMMSIndication(), GSM_DecodeNokiaProfile(), GSM_DecodeNokiaRTTLRingtone(), GSM_DecodeSiemensOTASMS(), GSM_NokiaCallerLogo, GSM_NokiaOperatorLogo, GSM_PrintBitmap(), GSM_MultiPartSMSEntry::ID, GSM_SMSMessage::Length, GSM_File::Name, GSM_Bitmap::NetworkCode, NOKIA_DecodeNetworkCode(), GSM_MultiBitmap::Number, GSM_MultiSMSMessage::Number, PHONE_DecodeBitmap(), GSM_MultiPartSMSEntry::Ringtone, GSM_MultiSMSMessage::SMS, SMS_NokiaCallerLogo, SMS_NokiaOperatorLogo, SMS_NokiaRingtone, SMS_NokiaVCALENDAR10Long, SMS_NokiaVCARD10Long, SMS_SiemensFile, GSM_SMSMessage::Text, TRUE, GSM_UDHHeader::Type, GSM_SMSMessage::UDH, UDH_ConcatenatedMessages, UDH_ConcatenatedMessages16bit, UDH_MMSIndicatorLong, UDH_NokiaCalendarLong, UDH_NokiaCallerLogo, UDH_NokiaOperatorLogo, UDH_NokiaPhonebookLong, UDH_NokiaProfileLong, UDH_NokiaRingtone, UDH_UserUDH, and GSM_File::Used.

 {
         int                     i;
         unsigned int            j;
         gboolean                        emsexist = FALSE, result;
         GSM_SiemensOTASMSInfo   SiemensInfo;
 
         GSM_ClearMultiPartSMSInfo(Info);
         if (ems) {
                 emsexist = TRUE;
                 for (i=0;i<SMS->Number;i++) {
                         if (SMS->SMS[i].UDH.Type != UDH_ConcatenatedMessages            &&
                             SMS->SMS[i].UDH.Type != UDH_ConcatenatedMessages16bit       &&
                             SMS->SMS[i].UDH.Type != UDH_UserUDH) {
                                 emsexist = FALSE;
                                 break;
                         }
                 }
         }
 
         /* EMS decoding */
         if (emsexist) {
                 return GSM_DecodeEMSMultiPartSMS(di, Info,SMS);
         }
 
         /* Siemens OTA */
         if (GSM_DecodeSiemensOTASMS(di, &SiemensInfo,&SMS->SMS[0])) {
                 Info->Entries[0].File = (GSM_File *)malloc(sizeof(GSM_File));
                 if (Info->Entries[0].File == NULL) return FALSE;
                 Info->Entries[0].File->Buffer   = NULL;
                 Info->Entries[0].File->Used     = 0;
                 for (i=0;i<SMS->Number;i++) {
                         if (GSM_DecodeSiemensOTASMS(di, &SiemensInfo,&SMS->SMS[i])) {
                                 j = SiemensInfo.AllDataLen - Info->Entries[0].File->Used;
                                 if (j>SiemensInfo.DataLen) j = SiemensInfo.DataLen;
                                 Info->Entries[0].File->Buffer = (unsigned char *)realloc(Info->Entries[0].File->Buffer,j+Info->Entries[0].File->Used);
                                 memcpy(Info->Entries[0].File->Buffer+Info->Entries[0].File->Used,SiemensInfo.Data,j);
                                 Info->Entries[0].File->Used += j;
                         }
                 }
                 if (SiemensInfo.AllDataLen == Info->Entries[0].File->Used) {
                         Info->Entries[0].ID     = SMS_SiemensFile;
                         Info->EntriesNum        = 1;
                         EncodeUnicode(Info->Entries[0].File->Name,SiemensInfo.DataName,strlen(SiemensInfo.DataName));
                         return TRUE;
                 }
                 free(Info->Entries[0].File->Buffer);
                 Info->Entries[0].File->Buffer=NULL;
         }
 
         /* Smart Messaging decoding */
         if (SMS->SMS[0].UDH.Type == UDH_NokiaRingtone && SMS->Number == 1) {
                 Info->Entries[0].Ringtone = (GSM_Ringtone *)malloc(sizeof(GSM_Ringtone));
                 if (Info->Entries[0].Ringtone == NULL) return FALSE;
                 if (GSM_DecodeNokiaRTTLRingtone(Info->Entries[0].Ringtone, SMS->SMS[0].Text, SMS->SMS[0].Length)==ERR_NONE) {
                         Info->Entries[0].ID     = SMS_NokiaRingtone;
                         Info->EntriesNum        = 1;
                         return TRUE;
                 }
         }
         if (SMS->SMS[0].UDH.Type == UDH_NokiaCallerLogo && SMS->Number == 1) {
                 Info->Entries[0].Bitmap = (GSM_MultiBitmap *)malloc(sizeof(GSM_MultiBitmap));
                 if (Info->Entries[0].Bitmap == NULL) return FALSE;
                 Info->Entries[0].Bitmap->Number = 1;
                 PHONE_DecodeBitmap(GSM_NokiaCallerLogo, SMS->SMS[0].Text+4, &Info->Entries[0].Bitmap->Bitmap[0]);
 #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_NokiaCallerLogo;
                 Info->EntriesNum        = 1;
                 return TRUE;
         }
         if (SMS->SMS[0].UDH.Type == UDH_NokiaOperatorLogo && SMS->Number == 1) {
                 Info->Entries[0].Bitmap = (GSM_MultiBitmap *)malloc(sizeof(GSM_MultiBitmap));
                 if (Info->Entries[0].Bitmap == NULL) return FALSE;
                 Info->Entries[0].Bitmap->Number = 1;
                 PHONE_DecodeBitmap(GSM_NokiaOperatorLogo, SMS->SMS[0].Text+7, &Info->Entries[0].Bitmap->Bitmap[0]);
                 NOKIA_DecodeNetworkCode(SMS->SMS[0].Text, Info->Entries[0].Bitmap->Bitmap[0].NetworkCode);
 #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_NokiaOperatorLogo;
                 Info->EntriesNum        = 1;
                 return TRUE;
         }
         if (SMS->SMS[0].UDH.Type == UDH_NokiaProfileLong) {
                 return GSM_DecodeNokiaProfile(di, Info, SMS);
         }
 
         /* Linked sms */
         if (SMS->SMS[0].UDH.Type == UDH_ConcatenatedMessages ||
             SMS->SMS[0].UDH.Type == UDH_ConcatenatedMessages16bit) {
                 return GSM_DecodeLinkedText(di, Info, SMS);
         }
         /* Nokia vCard/vCalendar */
         if (SMS->SMS[0].UDH.Type == UDH_NokiaCalendarLong ||
             SMS->SMS[0].UDH.Type == UDH_NokiaPhonebookLong) {
                 result = GSM_DecodeLinkedText(di, Info, SMS);
                 if (result) {
                         if (SMS->SMS[0].UDH.Type == UDH_NokiaPhonebookLong) {
                                 Info->Entries[0].ID = SMS_NokiaVCARD10Long;
                         } else {
                                 Info->Entries[0].ID = SMS_NokiaVCALENDAR10Long;
                         }
                 }
                 return result;
         }
         /* MMS indication */
         if (SMS->SMS[0].UDH.Type == UDH_MMSIndicatorLong) {
                 return GSM_DecodeMMSIndication(di, Info, SMS);
         }
 
         return FALSE;
 }

§ GSM_DecodePDUFrame()

GSM_Error GSM_DecodePDUFrame	(	GSM_Debug_Info *	di,
		GSM_SMSMessage *	SMS,
		const unsigned char *	buffer,
		size_t	length,
		size_t *	final_pos,
		gboolean	SMSC
	)

Decodes PDU data.

Parameters

di	Debug information structure.
SMS	Pointer where to store parsed message.
buffer	PDU data.
length	Length of PDU data.
final_pos	Optional pointer where end position will be stored.
SMSC	Whether PDU includes SMSC data.

Definition at line 508 of file gsmsms.c.

References GSM_SMSMessage::Class, GSM_SMSMessage::Coding, GSM_SMSMessage::DateTime, DecodeDefault(), DecodeUnicodeSpecialNOKIAChars(), DecodeUnicodeString(), DumpMessageText(), ERR_CORRUPTED, ERR_NONE, ERR_NOTSUPPORTED, ERR_UNKNOWN, FALSE, GSM_SMSValidity::Format, GSM_DecodeSMSDateTime(), GSM_DecodeSMSStatusReportData(), GSM_DecodeUDHHeader(), GSM_GetMessageCoding(), GSM_SetDefaultReceivedSMSData(), GSM_UnpackEightBitsToSeven(), GSM_UnpackSemiOctetNumber(), GSM_UDHHeader::Length, GSM_SMSMessage::Length, GSM_SMSMessage::MessageReference, GSM_SMSC::Number, GSM_SMSMessage::Number, GSM_SMSMessage::PDU, GSM_SMSValidity::Relative, GSM_SMSMessage::ReplaceMessage, smfprintf(), SMS_Coding_8bit, SMS_Coding_Default_Compression, SMS_Coding_Default_No_Compression, SMS_Coding_Unicode_Compression, SMS_Coding_Unicode_No_Compression, SMS_Deliver, SMS_Status_Report, SMS_Submit, SMS_Validity_RelativeFormat, GSM_SMSMessage::SMSC, GSM_SMSMessage::SMSCTime, GSM_UDHHeader::Text, GSM_SMSMessage::Text, TRUE, GSM_SMSMessage::UDH, and GSM_SMSC::Validity.

 {
         size_t pos = 0;
         int type, tp_pi;
         int vpf = 0;
         int udh = 0;
         int i,w;
         unsigned char   output[161];
         int                     datalength;
         gboolean have_data = FALSE;
         GSM_Error error;
 
         /* Set some sane data */
         GSM_SetDefaultReceivedSMSData(SMS);
 
         /* Parse SMSC if it is included */
         if (SMSC) {
                 error = GSM_UnpackSemiOctetNumber(di, SMS->SMSC.Number, buffer, &pos, length, FALSE);
                 if (error != ERR_NONE) {
                         return error;
                 }
                 smfprintf(di, "SMS center number : \"%s\"\n",DecodeUnicodeString(SMS->SMSC.Number));
         }
 
         /* Message type */
         type = buffer[pos];
         pos++;
         switch (type & 0x3) {
                 case 0:
                         smfprintf(di, "SMS type: Deliver");
                         SMS->PDU = SMS_Deliver;
                         break;
                 case 1:
                         smfprintf(di, "SMS type: Submit");
                         SMS->PDU = SMS_Submit;
                         break;
                 case 2:
                         smfprintf(di, "SMS type: Status report");
                         SMS->PDU = SMS_Status_Report;
                         break;
                 case 3:
                         smfprintf(di, "SMS type: Reserved message type, aborting!\n");
                         return ERR_UNKNOWN;;
         }
 
         if (SMS->PDU == SMS_Submit || SMS->PDU == SMS_Deliver) {
                 if (type & (1 << 7)) {
                         smfprintf(di, ", Reply path set");
                 }
                 if (type & (1 << 6)) {
                         smfprintf(di, ", UDH included");
                         udh = 1;
                 }
                 if (type & (1 << 5)) {
                         smfprintf(di, ", Delivery report requested");
                 }
         }
         if (SMS->PDU == SMS_Submit) {
                 vpf = (type & (0x3 << 3)) >> 3;
                 switch (vpf) {
                         case 0:
                                 smfprintf(di, ", No VP");
                                 break;
                         case 1:
                                 smfprintf(di, ", Reserved VP!\n");
                                 return ERR_UNKNOWN;
                         case 2:
                                 smfprintf(di, ", Relative VP");
                                 break;
                         case 3:
                                 smfprintf(di, ", Absolute VP");
                                 break;
                 }
         }
         smfprintf(di, "\n");
 
         /* Message reference */
         if (SMS->PDU == SMS_Submit || SMS->PDU == SMS_Status_Report) {
                 SMS->MessageReference = buffer[pos];
                 smfprintf(di, "SMS MR: 0x%02X\n", SMS->MessageReference);
                 pos++;
                 if (pos >= length) {
                         smfprintf(di, "Ran out of buffer when parsing PDU!\n");
                         return ERR_CORRUPTED;
                 }
         }
 
         /* Remote number */
         error = GSM_UnpackSemiOctetNumber(di, SMS->Number, buffer, &pos, length, TRUE);
         if (error != ERR_NONE) {
                 return error;
         }
         smfprintf(di, "Remote number : \"%s\"\n",DecodeUnicodeString(SMS->Number));
         if (pos >= length) {
                 smfprintf(di, "Ran out of buffer when parsing PDU!\n");
                 return ERR_CORRUPTED;
         }
 
 
         if (SMS->PDU == SMS_Submit || SMS->PDU == SMS_Deliver) {
                 /* Protocol identifier */
                 smfprintf(di, "SMS PID: 0x%02X\n", buffer[pos]);
                 if (buffer[pos] > 0x40 && buffer[pos] < 0x48) {
                         SMS->ReplaceMessage = buffer[pos] - 0x40;
                 }
                 pos++;
                 if (pos >= length) {
                         smfprintf(di, "Ran out of buffer when parsing PDU!\n");
                         return ERR_CORRUPTED;
                 }
 
                 /* Data coding scheme */
                 smfprintf(di, "SMS DCS: 0x%02X\n", buffer[pos]);
                 SMS->Coding = GSM_GetMessageCoding(di, buffer[pos]);
 
                 /* Message class */
                 SMS->Class = -1;
                 /* GSM 03.40 section 9.2.3.10 (TP-Data-Coding-Scheme) and GSM 03.38 section 4 */
                 if ((buffer[pos] & 0xD0) == 0x10 || (buffer[pos] & 0xF0) == 0xF0) {
                         SMS->Class = buffer[pos] & 3;
                 }
                 smfprintf(di, "SMS class: %i\n", SMS->Class);
 
                 pos++;
                 if (pos >= length) {
                         smfprintf(di, "Ran out of buffer when parsing PDU!\n");
                         return ERR_CORRUPTED;
                 }
         }
 
         /* SMSC time stamp */
         if (SMS->PDU == SMS_Status_Report || SMS->PDU == SMS_Deliver) {
                 if (pos + 7 >= length) {
                         smfprintf(di, "Ran out of buffer when parsing PDU!\n");
                         return ERR_CORRUPTED;
                 }
                 GSM_DecodeSMSDateTime(di, &SMS->DateTime, buffer + pos);
                 pos += 7;
         }
 
         if (SMS->PDU == SMS_Status_Report) {
                 /* Discharge Time */
                 if (pos + 7 >= length) {
                         smfprintf(di, "Ran out of buffer when parsing PDU!\n");
                         return ERR_CORRUPTED;
                 }
                 GSM_DecodeSMSDateTime(di, &SMS->SMSCTime, buffer + pos);
                 pos += 7;
 
                 /* Status */
                 GSM_DecodeSMSStatusReportData(di, SMS, buffer[pos]);
                 pos++;
 
                 /* Optional part coming from ETSI 123 040, section 9.2.2.3 */
                 /* We ignore 0xff, because some buggy phones pad SMS with it */
                 if (pos < length && buffer[pos] != 0xff) {
                         /* TP-Parameter-Indicator */
                         tp_pi = buffer[pos];
                         pos++;
 
                         /* We have TP-PID */
                         if (tp_pi & 1) {
                                 smfprintf(di, "SMS PID: 0x%02X\n", buffer[pos]);
                                 if (buffer[pos] > 0x40 && buffer[pos] < 0x48) {
                                         SMS->ReplaceMessage = buffer[pos] - 0x40;
                                 }
                                 pos++;
                         }
 
                         /* We have TP-DCS */
                         if (tp_pi & 2) {
                                 smfprintf(di, "SMS DCS: 0x%02X\n", buffer[pos]);
                                 SMS->Coding = GSM_GetMessageCoding(di, buffer[pos]);
                                 pos++;
                         } else {
                                 SMS->Coding = GSM_GetMessageCoding(di, 0);
                         }
 
                         /* We have TP-UDL */
                         if (tp_pi & 4) {
                                 have_data = TRUE;
                         }
                 }
         }
 
         /* Validity period */
         if (SMS->PDU == SMS_Submit) {
                 if (vpf == 2) {
                         SMS->SMSC.Validity.Format = SMS_Validity_RelativeFormat;
                         SMS->SMSC.Validity.Relative = buffer[pos];
                         smfprintf(di, "Relative validity: 0x%02X\n", buffer[pos]);
                         pos++;
                         if (pos >= length) {
                                 smfprintf(di, "Ran out of buffer when parsing PDU!\n");
                                 return ERR_CORRUPTED;
                         }
                 } else if (vpf == 3) {
                         /* @todo TODO: handle absolute validity */
                         smfprintf(di, "Absolute validity not handled!\n");
                         pos += 7;
                         if (pos >= length) {
                                 smfprintf(di, "Ran out of buffer when parsing PDU!\n");
                                 return ERR_CORRUPTED;
                         }
                 }
         }
 
         /* Data */
         if (SMS->PDU == SMS_Submit || SMS->PDU == SMS_Deliver || have_data) {
                 datalength = buffer[pos];
                 if (SMS->Coding == SMS_Coding_Default_No_Compression) {
                         datalength = (datalength * 7) / 8;
                         if ((buffer[pos] * 7) % 8 != 0) {
                                 datalength++;
                         }
                 } else if (SMS->Coding == SMS_Coding_Unicode_Compression) {
                         smfprintf(di, "Compressed unicode messages not yet supported!\n");
                         return ERR_NOTSUPPORTED;
                 } else if (SMS->Coding == SMS_Coding_Default_Compression) {
                         smfprintf(di, "Compressed 7-bit messages not yet supported!\n");
                         return ERR_NOTSUPPORTED;
                 }
 
                 if (pos + datalength >= length) {
                         smfprintf(di, "Ran out of buffer when parsing PDU!\n");
                         return ERR_CORRUPTED;
                 }
                 if (final_pos != NULL) {
                         *final_pos = pos + datalength + 1;
                 }
                 SMS->UDH.Length = 0;
                 /* UDH header available */
                 if (udh) {
                         /* Length of UDH header */
                         SMS->UDH.Length = (buffer[pos + 1] + 1);
                         smfprintf(di, "UDH header available (length %i)\n",SMS->UDH.Length);
 
                         /* Copy UDH header into SMS->UDH */
                         for (i = 0; i < SMS->UDH.Length; i++) SMS->UDH.Text[i] = buffer[pos + 1 + i];
 
                         GSM_DecodeUDHHeader(di, &SMS->UDH);
                 }
 
                 switch (SMS->Coding) {
                         case SMS_Coding_Default_No_Compression:
                                 i = 0;
                                 do {
                                         i+=7;
                                         w=(i-SMS->UDH.Length)%i;
                                 } while (w<0);
                                 SMS->Length=buffer[pos] - (SMS->UDH.Length*8 + w) / 7;
                                 if (SMS->Length < 0) {
                                         smfprintf(di, "No SMS text!\n");
                                         SMS->Length = 0;
                                         break;
                                 }
                                 GSM_UnpackEightBitsToSeven(w, buffer[pos]-SMS->UDH.Length, SMS->Length, buffer+(pos + 1+SMS->UDH.Length), output);
                                 smfprintf(di, "7 bit SMS, length %i\n",SMS->Length);
                                 DecodeDefault (SMS->Text, output, SMS->Length, TRUE, NULL);
                                 smfprintf(di, "%s\n",DecodeUnicodeString(SMS->Text));
                                 break;
                         case SMS_Coding_8bit:
                                 SMS->Length=buffer[pos] - SMS->UDH.Length;
                                 if (SMS->Length < 0) {
                                         smfprintf(di, "Invalid message length!\n");
                                         return ERR_CORRUPTED;
                                 }
                                 memcpy(SMS->Text,buffer+(pos + 1+SMS->UDH.Length),SMS->Length);
 #ifdef DEBUG
                                 smfprintf(di, "8 bit SMS, length %i\n",SMS->Length);
                                 DumpMessageText(di, SMS->Text, SMS->Length);
 #endif
                                 break;
                         case SMS_Coding_Unicode_No_Compression:
                                 SMS->Length=(buffer[pos] - SMS->UDH.Length) / 2;
                                 if (SMS->Length < 0) {
                                         smfprintf(di, "Invalid message length!\n");
                                         return ERR_CORRUPTED;
                                 }
                                 DecodeUnicodeSpecialNOKIAChars(SMS->Text,buffer+(pos + 1+SMS->UDH.Length), SMS->Length);
 #ifdef DEBUG
                                 smfprintf(di, "Unicode SMS, length %i\n",SMS->Length);
                                 DumpMessageText(di, buffer+(pos + 1+SMS->UDH.Length), SMS->Length*2);
                                 smfprintf(di, "%s\n",DecodeUnicodeString(SMS->Text));
 #endif
                                 break;
                         default:
                                 SMS->Length=0;
                                 break;
                 }
         } else {
                 if (final_pos != NULL) {
                         *final_pos = pos;
                 }
         }
 
         return ERR_NONE;
 }

§ GSM_DecodeSiemensOTASMS()

gboolean GSM_DecodeSiemensOTASMS	(	GSM_Debug_Info *	di,
		GSM_SiemensOTASMSInfo *	Info,
		GSM_SMSMessage *	SMS
	)

Decodes Siemens OTA data.

Definition at line 1202 of file gsmsms.c.

Referenced by GSM_DecodeMultiPartSMS(), and GSM_LinkSMS().

 {
         int current;
 
         if (SMS->PDU != SMS_Deliver) {
                 return FALSE;
         }
         if (SMS->Coding != SMS_Coding_8bit) {
                 return FALSE;
         }
         if (SMS->Class != 1) {
                 return FALSE;
         }
         if (SMS->UDH.Type != UDH_NoUDH) {
                 return FALSE;
         }
         if (SMS->Length < 22) {
                 return FALSE;
         }
 
         if (strncmp(SMS->Text, "//SEO",5) != 0) {
                 return FALSE; /* Siemens Exchange Object */
         }
         if (SMS->Text[5] != 1) {
                 return FALSE; /* version 1 */
         }
         Info->DataLen = SMS->Text[6] + SMS->Text[7]*256;
         Info->SequenceID = SMS->Text[8] + SMS->Text[9]*256 +
                          SMS->Text[10]*256*256 + SMS->Text[11]*256*256*256;
         Info->PacketNum = SMS->Text[12] + SMS->Text[13]*256;
         Info->PacketsNum = SMS->Text[14] + SMS->Text[15]*256;
         smfprintf(di, "Packet %i/%i\n",Info->PacketNum,Info->PacketsNum);
         Info->AllDataLen = SMS->Text[16] + SMS->Text[17]*256 +
                          SMS->Text[18]*256*256 + SMS->Text[19]*256*256*256;
         smfprintf(di, "DataLen %i/%lu\n",Info->DataLen,Info->AllDataLen);
 
         if (SMS->Text[20] > 9) {
                 return FALSE;
         }
         memcpy(Info->DataType,SMS->Text+21,SMS->Text[20]);
         Info->DataType[SMS->Text[20]] = 0;
         smfprintf(di, "DataType '%s'\n",Info->DataType);
 
         current = 21+SMS->Text[20];
         if (SMS->Text[current] > 39) {
                 return FALSE;
         }
         memcpy(Info->DataName,SMS->Text+current+1,SMS->Text[current]);
         Info->DataName[SMS->Text[current]] = 0;
         smfprintf(di, "DataName '%s'\n",Info->DataName);
 
         current += SMS->Text[current]+1;
         memcpy(Info->Data,SMS->Text+current,Info->DataLen);
 
         return TRUE;
 }

§ GSM_DecodeSMSFrame()

GSM_Error GSM_DecodeSMSFrame	(	GSM_Debug_Info *	di,
		GSM_SMSMessage *	SMS,
		unsigned char *	buffer,
		GSM_SMSMessageLayout	Layout
	)

Decodes SMS frame.

Definition at line 807 of file gsmsms.c.

 {
         GSM_DateTime    zerodt = {0,0,0,0,0,0,0};
         size_t pos;
         GSM_Error error;
 
 #ifdef DEBUG
         if (Layout.firstbyte == 255) {
                 smfprintf(di, "ERROR: firstbyte in SMS layout not set\n");
                 return ERR_UNKNOWN;
         }
         if (Layout.TPDCS     != 255) smfprintf(di, "TPDCS     : %02x %i\n",buffer[Layout.TPDCS]    ,buffer[Layout.TPDCS]);
         if (Layout.TPMR      != 255) smfprintf(di, "TPMR      : %02x %i\n",buffer[Layout.TPMR]     ,buffer[Layout.TPMR]);
         if (Layout.TPPID     != 255) smfprintf(di, "TPPID     : %02x %i\n",buffer[Layout.TPPID]    ,buffer[Layout.TPPID]);
         if (Layout.TPUDL     != 255) smfprintf(di, "TPUDL     : %02x %i\n",buffer[Layout.TPUDL]    ,buffer[Layout.TPUDL]);
         if (Layout.firstbyte != 255) smfprintf(di, "FirstByte : %02x %i\n",buffer[Layout.firstbyte],buffer[Layout.firstbyte]);
         if (Layout.Text      != 255 && Layout.TPUDL     != 255 && buffer[Layout.TPUDL] > 0) {
                 smfprintf(di, "Text      : %02x %i\n",buffer[Layout.Text]     ,buffer[Layout.Text]);
         }
 #endif
 
         GSM_SetDefaultReceivedSMSData(SMS);
 
         if (Layout.SMSCNumber!=255) {
                 pos = Layout.SMSCNumber;
                 error = GSM_UnpackSemiOctetNumber(di, SMS->SMSC.Number, buffer, &pos, 1000, FALSE);
                 if (error != ERR_NONE) {
                         return error;
                 }
                 smfprintf(di, "SMS center number : \"%s\"\n",DecodeUnicodeString(SMS->SMSC.Number));
         }
         if ((buffer[Layout.firstbyte] & 0x80)!=0) SMS->ReplyViaSameSMSC=TRUE;
 #ifdef DEBUG
         if (SMS->ReplyViaSameSMSC) smfprintf(di, "SMS centre set for reply\n");
 #endif
         if (Layout.Number!=255) {
                 pos = Layout.Number;
                 error = GSM_UnpackSemiOctetNumber(di, SMS->Number, buffer, &pos, 1000, TRUE);
                 if (error != ERR_NONE) {
                         return error;
                 }
                 smfprintf(di, "Remote number : \"%s\"\n",DecodeUnicodeString(SMS->Number));
         }
         if (Layout.TPDCS != 255) {
                 /* Get message coding */
                 SMS->Coding = GSM_GetMessageCoding(di, buffer[Layout.TPDCS]);
         }
         if (Layout.Text != 255 && Layout.TPDCS!=255 && Layout.TPUDL!=255 && buffer[Layout.TPUDL] > 0) {
                 GSM_DecodeSMSFrameText(di, SMS, buffer, Layout);
         }
         if (Layout.DateTime != 255) {
                 GSM_DecodeSMSDateTime(di, &SMS->DateTime,buffer+(Layout.DateTime));
         } else {
                 SMS->DateTime = zerodt;
         }
         if (Layout.SMSCTime != 255 && Layout.TPStatus != 255) {
                 /* GSM 03.40 section 9.2.3.11 (TP-Service-Centre-Time-Stamp) */
                 smfprintf(di, "SMSC response date: ");
                 GSM_DecodeSMSDateTime(di, &SMS->SMSCTime, buffer+(Layout.SMSCTime));
                 GSM_DecodeSMSFrameStatusReportData(di, SMS,buffer,Layout);
         } else {
                 SMS->SMSCTime = zerodt;
         }
         SMS->Class = -1;
         if (Layout.TPDCS != 255) {
                 /* GSM 03.40 section 9.2.3.10 (TP-Data-Coding-Scheme) and GSM 03.38 section 4 */
                 if ((buffer[Layout.TPDCS] & 0xD0) == 0x10) {
                         /* bits 7..4 set to 00x1 */
                         if ((buffer[Layout.TPDCS] & 0xC) == 0xC) {
                                 smfprintf(di, "WARNING: reserved alphabet value in TPDCS\n");
                         } else {
                                 SMS->Class = (buffer[Layout.TPDCS] & 3);
                         }
                 } else if ((buffer[Layout.TPDCS] & 0xF0) == 0xF0) {
                         /* bits 7..4 set to 1111 */
                         if ((buffer[Layout.TPDCS] & 8) == 8) {
                                 smfprintf(di, "WARNING: set reserved bit 3 in TPDCS\n");
                         } else {
                                 SMS->Class = (buffer[Layout.TPDCS] & 3);
                         }
                 }
         }
         smfprintf(di, "SMS class: %i\n",SMS->Class);
 
         SMS->MessageReference = 0;
         if (Layout.TPMR != 255) SMS->MessageReference = buffer[Layout.TPMR];
 
         SMS->ReplaceMessage = 0;
         if (Layout.TPPID != 255) {
                 if (buffer[Layout.TPPID] > 0x40 && buffer[Layout.TPPID] < 0x48) {
                         SMS->ReplaceMessage = buffer[Layout.TPPID] - 0x40;
                 }
         }
         SMS->RejectDuplicates = FALSE;
         if ((buffer[Layout.firstbyte] & 0x04)==0x04) SMS->RejectDuplicates = TRUE;
 
         return ERR_NONE;
 }

§ GSM_DecodeSMSFrameStatusReportData()

GSM_Error GSM_DecodeSMSFrameStatusReportData	(	GSM_Debug_Info *	di,
		GSM_SMSMessage *	SMS,
		unsigned char *	buffer,
		GSM_SMSMessageLayout	Layout
	)

Decodes SMS frame for status report.

Definition at line 503 of file gsmsms.c.

References GSM_DecodeSMSStatusReportData(), and GSM_SMSMessageLayout::TPStatus.

Referenced by GSM_DecodeSMSFrame().

 {
         return GSM_DecodeSMSStatusReportData(di, SMS, buffer[Layout.TPStatus]);
 }

§ GSM_DecodeSMSFrameText()

GSM_Error GSM_DecodeSMSFrameText	(	GSM_Debug_Info *	di,
		GSM_SMSMessage *	SMS,
		unsigned char *	buffer,
		GSM_SMSMessageLayout	Layout
	)

Decodes SMS frame in textual representation.

Definition at line 316 of file gsmsms.c.

References GSM_SMSMessage::Coding, DecodeDefault(), DecodeUnicodeSpecialNOKIAChars(), DecodeUnicodeString(), DumpMessageText(), ERR_CORRUPTED, ERR_NONE, GSM_SMSMessageLayout::firstbyte, GSM_DecodeUDHHeader(), GSM_UnpackEightBitsToSeven(), GSM_UDHHeader::Length, GSM_SMSMessage::Length, smfprintf(), SMS_Coding_8bit, SMS_Coding_Default_No_Compression, SMS_Coding_Unicode_No_Compression, GSM_UDHHeader::Text, GSM_SMSMessage::Text, GSM_SMSMessageLayout::Text, GSM_SMSMessageLayout::TPUDL, TRUE, and GSM_SMSMessage::UDH.

Referenced by GSM_DecodeSMSFrame().

 {
         int             off=0;          /* length of the User Data Header */
         int             w,i;
         unsigned char   output[1024];
 
         SMS->UDH.Length = 0;
         /* UDH header available */
         if (buffer[Layout.firstbyte] & 64) {
                 /* Length of UDH header */
                 off = (buffer[Layout.Text] + 1);
                 if (off > buffer[Layout.TPUDL]) {
                         return ERR_CORRUPTED;
                 }
                 SMS->UDH.Length = off;
                 smfprintf(di, "UDH header available (length %i)\n",off);
 
                 /* Copy UDH header into SMS->UDH */
                 for (i = 0; i < off; i++) {
                         SMS->UDH.Text[i] = buffer[Layout.Text + i];
                 }
 
                 GSM_DecodeUDHHeader(di, &SMS->UDH);
         }
 
         switch (SMS->Coding) {
                 case SMS_Coding_Default_No_Compression:
                         i = 0;
                         do {
                                 i+=7;
                                 w=(i-off)%i;
                         } while (w<0);
                         SMS->Length=buffer[Layout.TPUDL] - (off*8 + w) / 7;
                         if (SMS->Length < 0) {
                                 smfprintf(di, "No SMS text!\n");
                                 SMS->Length = 0;
                                 break;
                         }
                         GSM_UnpackEightBitsToSeven(w, buffer[Layout.TPUDL]-off, SMS->Length, buffer+(Layout.Text+off), output);
                         smfprintf(di, "7 bit SMS, length %i\n",SMS->Length);
                         DecodeDefault (SMS->Text, output, SMS->Length, TRUE, NULL);
                         smfprintf(di, "%s\n",DecodeUnicodeString(SMS->Text));
                         break;
                 case SMS_Coding_8bit:
                         SMS->Length=buffer[Layout.TPUDL] - off;
                         memcpy(SMS->Text,buffer+(Layout.Text+off),SMS->Length);
 #ifdef DEBUG
                         smfprintf(di, "8 bit SMS, length %i\n",SMS->Length);
                         DumpMessageText(di, SMS->Text, SMS->Length);
 #endif
                         break;
                 case SMS_Coding_Unicode_No_Compression:
                         SMS->Length=(buffer[Layout.TPUDL] - off) / 2;
                         DecodeUnicodeSpecialNOKIAChars(SMS->Text,buffer+(Layout.Text+off), SMS->Length);
 #ifdef DEBUG
                         smfprintf(di, "Unicode SMS, length %i\n",SMS->Length);
                         DumpMessageText(di, buffer+(Layout.Text+off), SMS->Length*2);
                         smfprintf(di, "%s\n",DecodeUnicodeString(SMS->Text));
 #endif
                         break;
                 default:
                         SMS->Length=0;
                         break;
         }
 
         return ERR_NONE;
 }

§ GSM_DecodeUDHHeader()

void GSM_DecodeUDHHeader	(	GSM_Debug_Info *	di,
		GSM_UDHHeader *	UDH
	)

Decodes UDH header.

Definition at line 121 of file gsmsms.c.

References GSM_UDHHeader::AllParts, DumpMessageText(), FALSE, GSM_UDHHeader::ID16bit, GSM_UDHHeader::ID8bit, GSM_UDHHeader::Length, GSM_UDHHeader::PartNumber, smfprintf(), GSM_UDHHeader::Text, TRUE, GSM_UDHHeader::Type, UDH_ConcatenatedMessages, UDH_ConcatenatedMessages16bit, UDH_DisableEmail, UDH_DisableFax, UDH_DisableVoice, UDH_EnableEmail, UDH_EnableFax, UDH_EnableVoice, UDH_MMSIndicatorLong, UDH_NokiaCalendarLong, UDH_NokiaCallerLogo, UDH_NokiaOperatorLogo, UDH_NokiaOperatorLogoLong, UDH_NokiaPhonebookLong, UDH_NokiaProfileLong, UDH_NokiaRingtone, UDH_NokiaRingtoneLong, UDH_NokiaWAP, UDH_NokiaWAPLong, UDH_NoUDH, UDH_UserUDH, and UDH_VoidSMS.

Referenced by GSM_DecodePDUFrame(), and GSM_DecodeSMSFrameText().

 {
         int     i, tmp, w;
         gboolean        UDHOK;
 
         UDH->Type       = UDH_UserUDH;
         UDH->ID8bit     = -1;
         UDH->ID16bit    = -1;
         UDH->PartNumber = -1;
         UDH->AllParts   = -1;
 
         i=-1;
         while (UDHHeaders[++i].Type != UDH_NoUDH) {
 
                 tmp=UDHHeaders[i].Length;
                 /* if length is the same */
                 if (tmp==UDH->Text[0]) {
 
                         if (tmp == 0x05) {
                                 /* three last bytes can be different for such UDH */
                                 tmp = tmp - 3;
                         }
                         if (tmp == 0x0b) {
                                 /* three last bytes can be different for such UDH */
                                 tmp = tmp - 3;
                         }
                         if (tmp == 0x06 && UDH->Text[1] == 0x08) {
                                 tmp=tmp-4;
                         }
 
                         UDHOK = TRUE;
                         for (w = 0; w < tmp; w++) {
                                 if (UDHHeaders[i].Text[w] != UDH->Text[w + 1]) {
                                         UDHOK = FALSE;
                                         break;
                                 }
                         }
                         if (UDHOK) {
                                 UDH->Type=UDHHeaders[i].Type;
 
                                 if (UDHHeaders[i].ID8bit !=-1) {
                                         UDH->ID8bit = UDH->Text[UDHHeaders[i].ID8bit+1];
                                 }
                                 if (UDHHeaders[i].ID16bit !=-1) {
                                         UDH->ID16bit = UDH->Text[UDHHeaders[i].ID16bit+1]*256+UDH->Text[UDHHeaders[i].ID16bit+2];
                                 }
                                 if (UDHHeaders[i].PartNumber !=-1) {
                                         UDH->PartNumber = UDH->Text[UDHHeaders[i].PartNumber+1];
                                 }
                                 if (UDHHeaders[i].AllParts !=-1) {
                                         UDH->AllParts = UDH->Text[UDHHeaders[i].AllParts+1];
                                 }
                                 break;
                         }
                 }
         }
 
 #ifdef DEBUG
         smfprintf(di, "Type of UDH: ");
         switch (UDH->Type) {
         case UDH_ConcatenatedMessages:
                 smfprintf(di, "Concatenated (linked) message");
                 break;
         case UDH_ConcatenatedMessages16bit:
                 smfprintf(di, "Concatenated (linked) message");
                 break;
         case UDH_DisableVoice:
                 smfprintf(di, "Disables voice indicator");
                 break;
         case UDH_EnableVoice:
                 smfprintf(di, "Enables voice indicator");
                 break;
         case UDH_DisableFax:
                 smfprintf(di, "Disables fax indicator");
                 break;
         case UDH_EnableFax:
                 smfprintf(di, "Enables fax indicator");
                 break;
         case UDH_DisableEmail:
                 smfprintf(di, "Disables email indicator");
                 break;
         case UDH_EnableEmail:
                 smfprintf(di, "Enables email indicator");
                 break;
         case UDH_VoidSMS:
                 smfprintf(di, "Void SMS");
                 break;
         case UDH_NokiaWAP:
                 smfprintf(di, "Nokia WAP Bookmark");
                 break;
         case UDH_NokiaOperatorLogoLong:
                 smfprintf(di, "Nokia operator logo");
                 break;
         case UDH_NokiaWAPLong:
                 smfprintf(di, "Nokia WAP Bookmark or WAP/MMS Settings");
                 break;
         case UDH_NokiaRingtone:
                 smfprintf(di, "Nokia ringtone");
                 break;
         case UDH_NokiaRingtoneLong:
                 smfprintf(di, "Nokia ringtone");
                 break;
         case UDH_NokiaOperatorLogo:
                 smfprintf(di, "Nokia GSM operator logo");
                 break;
         case UDH_NokiaCallerLogo:
                 smfprintf(di, "Nokia caller logo");
                 break;
         case UDH_NokiaProfileLong:
                 smfprintf(di, "Nokia profile");
                 break;
         case UDH_NokiaCalendarLong:
                 smfprintf(di, "Nokia calendar note");
                 break;
         case UDH_NokiaPhonebookLong:
                 smfprintf(di, "Nokia phonebook entry");
                 break;
         case UDH_UserUDH:
                 smfprintf(di, "User UDH");
                 break;
         case UDH_MMSIndicatorLong:
                 smfprintf(di, "MMS indicator");
                 break;
         case UDH_NoUDH:
                 break;
         }
         if (UDH->ID8bit != -1) {
                 smfprintf(di, ", ID 8 bit %i", UDH->ID8bit);
         }
         if (UDH->ID16bit != -1) {
                 smfprintf(di, ", ID 16 bit %i", UDH->ID16bit);
         }
         if (UDH->PartNumber != -1 && UDH->AllParts != -1) {
                 smfprintf(di, ", part %i of %i",UDH->PartNumber,UDH->AllParts);
         }
         smfprintf(di, "\n");
         DumpMessageText(di, UDH->Text, UDH->Length);
 #endif
 }

§ GSM_DeleteSMS()

GSM_Error GSM_DeleteSMS	(	GSM_StateMachine *	s,
		GSM_SMSMessage *	sms
	)

Deletes SMS.

Parameters

	s	State machine pointer.
[in]	sms	SMS structure with SMS location and folder.

Returns: Error code.

Deletes SMS.

Definition at line 726 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone_Functions::DeleteSMS, GSM_Phone::Functions, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, and PRINT_SMS_INFO.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
         PRINT_SMS_INFO();
 
         err = s->Phone.Functions->DeleteSMS(s, sms);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_DeleteSMSFolder()

GSM_Error GSM_DeleteSMSFolder	(	GSM_StateMachine *	s,
		int	ID
	)

Deletes SMS folder.

Parameters

	s	State machine pointer.
[in]	ID	ID of SMS folder to delete.

Returns: Error code.

Deletes SMS folder.

Definition at line 832 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone_Functions::DeleteSMSFolder, GSM_Phone::Functions, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
 
         err = s->Phone.Functions->DeleteSMSFolder(s, ID);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_EncodeMultiPartSMS()

GSM_Error GSM_EncodeMultiPartSMS	(	GSM_Debug_Info *	di,
		GSM_MultiPartSMSInfo *	Info,
		GSM_MultiSMSMessage *	SMS
	)

Encodes multi part SMS from "readable" format.

Returns: Error code.

Definition at line 500 of file gsmmulti.c.

 {
         unsigned char   *Buffer;
         unsigned char   *Buffer2;
         size_t          buffer_size = GSM_MAX_SMS_LENGTH * 2 * GSM_MAX_MULTI_SMS;
         int             i, Class = -1, j;
         size_t p;
         size_t Length = 0, smslen;
         GSM_Error       error;
         GSM_Coding_Type Coding  = SMS_Coding_8bit;
         GSM_UDH         UDH     = UDH_NoUDH;
         GSM_UDHHeader   UDHHeader;
         gboolean                EMS     = FALSE;
         int             textnum = 0;
 
         if (Info->EntriesNum == 0) return ERR_EMPTY;
 
         Buffer = malloc(buffer_size);
         if (Buffer == NULL) {
                 return ERR_MOREMEMORY;
         }
         Buffer2 = malloc(buffer_size);
         if (Buffer2 == NULL) {
                 free(Buffer);
                 return ERR_MOREMEMORY;
         }
 
         SMS->Number = 0;
 
         if (Info->Entries[0].ID == SMS_AlcatelSMSTemplateName) {
                 Buffer[Length++] = 0x00; /* number of elements */
                 for (i=1;i<Info->EntriesNum;i++) {
                 switch (Info->Entries[i].ID) {
                 case SMS_EMSSound10:
                 case SMS_EMSSound12:
                 case SMS_EMSSonyEricssonSound:
                 case SMS_EMSSound10Long:
                 case SMS_EMSSound12Long:
                 case SMS_EMSSonyEricssonSoundLong:
                 case SMS_EMSVariableBitmap:
                 case SMS_EMSAnimation:
                 case SMS_EMSVariableBitmapLong:
                         break;
                 case SMS_EMSPredefinedSound:
                         Buffer[0]++;
                         Buffer[Length++]        = 0x01;         /* type of data */
                         Buffer[Length++]        = 1 % 256;      /* len */
                         Buffer[Length++]        = 1 / 256;      /* len */
                         Buffer[Length++]        = Info->Entries[i].Number;
                         break;
                 case SMS_EMSPredefinedAnimation:
                         Buffer[0]++;
                         Buffer[Length++]        = 0x02;         /* type of data */
                         Buffer[Length++]        = 1 % 256;      /* len */
                         Buffer[Length++]        = 1 / 256;      /* len */
                         Buffer[Length++]        = Info->Entries[i].Number;
                         break;
                 case SMS_ConcatenatedTextLong:
                         Buffer[0]++;
                         p       = UnicodeLength(Info->Entries[i].Buffer);
                         EncodeDefault(Buffer2, Info->Entries[i].Buffer, &p, TRUE, NULL);
                         Buffer[Length++]        = 0x00;         /* type of data */
                         Length                  = Length + 2;
                         smslen                  = GSM_PackSevenBitsToEight(0, Buffer2, Buffer+Length, p);
                         Buffer[Length-2]        = smslen % 256; /* len */
                         Buffer[Length-1]        = smslen / 256; /* len */
                         Length                  = Length + smslen;
                         break;
                 default:
                         error = ERR_UNKNOWN;
                         goto out;
                 }
                 }
                 Buffer[0] = Buffer[0] * 2;
                 error = GSM_EncodeAlcatelMultiPartSMS(di, SMS,Buffer,Length,Info->Entries[0].Buffer,ALCATELTDD_SMSTEMPLATE);
                 goto out;
         }
 
         for (i=0;i<Info->EntriesNum;i++) {
                 switch (Info->Entries[i].ID) {
                 case SMS_EMSPredefinedAnimation:
                 case SMS_EMSPredefinedSound:
                 case SMS_EMSSound10:
                 case SMS_EMSSound12:
                 case SMS_EMSSonyEricssonSound:
                 case SMS_EMSSound10Long:
                 case SMS_EMSSound12Long:
                 case SMS_EMSSonyEricssonSoundLong:
                 case SMS_EMSFixedBitmap:
                 case SMS_EMSVariableBitmap:
                 case SMS_EMSAnimation:
                 case SMS_EMSVariableBitmapLong:
                         EMS = TRUE;
                         break;
                 case SMS_ConcatenatedTextLong:
                 case SMS_ConcatenatedTextLong16bit:
 
                         /* This covers situation, when somebody will call function
                          * with two or more SMS_Concatenated.... entries only.
                          * It will be still only linked sms, but functions below
                          * will pack only first entry according to own limits.
                          * We redirect to EMS functions, because they are more generic
                          * here and will handle it correctly and produce linked sms
                          * from all entries
                          */
                         textnum ++;
                         if (textnum > 1) EMS = TRUE;
 
                         if (Info->Entries[i].Left   || Info->Entries[i].Right      ||
                             Info->Entries[i].Center || Info->Entries[i].Large      ||
                             Info->Entries[i].Small  || Info->Entries[i].Bold       ||
                             Info->Entries[i].Italic || Info->Entries[i].Underlined ||
                             Info->Entries[i].Strikethrough) {
                                 EMS = TRUE;
                         }
                 default:
                         break;
                 }
                 if (EMS) break;
         }
         if (EMS) {
                 error=GSM_EncodeEMSMultiPartSMS(di, Info,SMS,UDH_NoUDH);
                 if (error != ERR_NONE) {
                         goto out;
                 }
                 if (SMS->Number != 1) {
                         SMS->Number = 0;
                         for (i=0;i<Info->EntriesNum;i++) {
                                 if (Info->Entries[i].ID == SMS_ConcatenatedTextLong16bit) {
                                         error = GSM_EncodeEMSMultiPartSMS(di, Info,SMS,UDH_ConcatenatedMessages);
                                         goto out;
                                 }
                         }
                         error = GSM_EncodeEMSMultiPartSMS(di, Info,SMS,UDH_ConcatenatedMessages16bit);
                 }
                 goto out;
         }
 
         if (Info->EntriesNum != 1) {
                 error = ERR_UNKNOWN;
                 goto out;
         }
 
         switch (Info->Entries[0].ID) {
         case SMS_AlcatelMonoBitmapLong:
                 Buffer[0] = Info->Entries[0].Bitmap->Bitmap[0].BitmapWidth;
                 Buffer[1] = Info->Entries[0].Bitmap->Bitmap[0].BitmapHeight;
                 PHONE_EncodeBitmap(GSM_AlcatelBMMIPicture, Buffer+2, &Info->Entries[0].Bitmap->Bitmap[0]);
                 Length = PHONE_GetBitmapSize(GSM_AlcatelBMMIPicture,Info->Entries[0].Bitmap->Bitmap[0].BitmapWidth,Info->Entries[0].Bitmap->Bitmap[0].BitmapHeight)+2;
                 error = GSM_EncodeAlcatelMultiPartSMS(di, SMS,Buffer,Length,Info->Entries[0].Bitmap->Bitmap[0].Text,ALCATELTDD_PICTURE);
                 goto out;
         case SMS_AlcatelMonoAnimationLong:
                 /* Number of sequence words */
                 Buffer[0] = (Info->Entries[0].Bitmap->Number+1) % 256;
                 Buffer[1] = (Info->Entries[0].Bitmap->Number+1) / 256;
                 /* Picture display time 1 second (1 = 100ms) */
                 Buffer[2] = 10 % 256;
                 Buffer[3] = 10 / 256 + 0xF0;
 
                 Length    = 4;
                 j         = 0;
 
                 /* Offsets to bitmaps */
                 for (i=0;i<Info->Entries[0].Bitmap->Number;i++) {
                         Buffer[Length++] = (4+j+Info->Entries[0].Bitmap->Number*2) % 256;
                         Buffer[Length++] = (4+j+Info->Entries[0].Bitmap->Number*2) / 256;
                         j += PHONE_GetBitmapSize(GSM_AlcatelBMMIPicture,Info->Entries[0].Bitmap->Bitmap[i].BitmapWidth,Info->Entries[0].Bitmap->Bitmap[i].BitmapHeight)+2;
                 }
 
                 /* Bitmaps */
                 for (i=0;i<Info->Entries[0].Bitmap->Number;i++) {
                         Buffer[Length++] = Info->Entries[0].Bitmap->Bitmap[i].BitmapWidth;
                         Buffer[Length++] = Info->Entries[0].Bitmap->Bitmap[i].BitmapHeight;
                         PHONE_EncodeBitmap(GSM_AlcatelBMMIPicture, Buffer+Length, &Info->Entries[0].Bitmap->Bitmap[i]);
                         Length += PHONE_GetBitmapSize(GSM_AlcatelBMMIPicture,Info->Entries[0].Bitmap->Bitmap[i].BitmapWidth,Info->Entries[0].Bitmap->Bitmap[i].BitmapHeight);
                 }
                 error = GSM_EncodeAlcatelMultiPartSMS(di, SMS,Buffer,Length,Info->Entries[0].Bitmap->Bitmap[0].Text,ALCATELTDD_ANIMATION);
                 goto out;
         case SMS_MMSIndicatorLong:
                 Class   = 1;
                 UDH     = UDH_MMSIndicatorLong;
                 GSM_EncodeMMSIndicatorSMSText(Buffer,&Length,Info->Entries[0].MMSIndicator);
                 break;
         case SMS_WAPIndicatorLong:
                 Class   = 1;
                 UDH     = UDH_MMSIndicatorLong;
                 GSM_EncodeWAPIndicatorSMSText(Buffer,&Length,Info->Entries[0].MMSIndicator->Title,Info->Entries[0].MMSIndicator->Address);
                 break;
         case SMS_NokiaRingtoneLong:
         case SMS_NokiaRingtone:
                 UDH     = UDH_NokiaRingtone;
                 Class   = 1;
                 /* 7 = length of UDH_NokiaRingtone UDH header */
                 Length  = GSM_MAX_8BIT_SMS_LENGTH-7;
                 Info->Entries[0].RingtoneNotes = GSM_EncodeNokiaRTTLRingtone(Info->Entries[0].Ringtone,Buffer,&Length);
                 if (Info->Entries[0].ID == SMS_NokiaRingtone) break;
                 if (Info->Entries[0].RingtoneNotes != Info->Entries[0].Ringtone->NoteTone.NrCommands) {
                         UDH    = UDH_NokiaRingtoneLong;
                         Length = (GSM_MAX_8BIT_SMS_LENGTH-12)*3;
                         Info->Entries[0].RingtoneNotes = GSM_EncodeNokiaRTTLRingtone(Info->Entries[0].Ringtone,Buffer,&Length);
                 }
                 break;
         case SMS_NokiaOperatorLogoLong:
                 if (Info->Entries[0].Bitmap->Bitmap[0].BitmapWidth > 72 || Info->Entries[0].Bitmap->Bitmap[0].BitmapHeight > 14) {
                         UDH     = UDH_NokiaOperatorLogoLong;
                         Class   = 1;
                         NOKIA_EncodeNetworkCode(Buffer, Info->Entries[0].Bitmap->Bitmap[0].NetworkCode);
                         Length = Length + 3;
                         NOKIA_CopyBitmap(GSM_Nokia7110OperatorLogo, &Info->Entries[0].Bitmap->Bitmap[0], Buffer, &Length);
                         break;
                 }
         case SMS_NokiaOperatorLogo:
                 UDH     = UDH_NokiaOperatorLogo;
                 Class   = 1;
                 NOKIA_EncodeNetworkCode(Buffer, Info->Entries[0].Bitmap->Bitmap[0].NetworkCode);
                 Length = Length + 3;
                 NOKIA_CopyBitmap(GSM_NokiaOperatorLogo, &Info->Entries[0].Bitmap->Bitmap[0], Buffer, &Length);
                 break;
         case SMS_NokiaCallerLogo:
                 UDH     = UDH_NokiaCallerLogo;
                 Class   = 1;
                 NOKIA_CopyBitmap(GSM_NokiaCallerLogo, &Info->Entries[0].Bitmap->Bitmap[0], Buffer, &Length);
                 break;
         case SMS_NokiaProfileLong:
         case SMS_NokiaPictureImageLong:
         case SMS_NokiaScreenSaverLong:
                 Class   = 1;
                 UDH     = UDH_NokiaProfileLong;
                 GSM_EncodeSMS30MultiPartSMS(Info,Buffer,&Length);
                 break;
         case SMS_NokiaWAPBookmarkLong:
                 Class   = 1;
                 NOKIA_EncodeWAPBookmarkSMSText(Buffer,&Length,Info->Entries[0].Bookmark);
                 /* 7 = length of UDH_NokiaWAP UDH header */
                 if (Length>(GSM_MAX_8BIT_SMS_LENGTH-7)) {
                         UDH=UDH_NokiaWAPLong;
                 } else {
                         UDH=UDH_NokiaWAP;
                 }
                 break;
         case SMS_NokiaWAPSettingsLong:
                 Class   = 1;
                 UDH     = UDH_NokiaWAPLong;
                 NOKIA_EncodeWAPMMSSettingsSMSText(Buffer,&Length,Info->Entries[0].Settings,FALSE);
                 break;
         case SMS_NokiaMMSSettingsLong:
                 Class   = 1;
                 UDH     = UDH_NokiaWAPLong;
                 NOKIA_EncodeWAPMMSSettingsSMSText(Buffer,&Length,Info->Entries[0].Settings,TRUE);
                 break;
         case SMS_NokiaVCARD10Long:
                 Coding = SMS_Coding_Default_No_Compression;
                 UDH = UDH_NokiaPhonebookLong;
                 error = GSM_EncodeVCARD(di, Buffer, buffer_size, &Length, Info->Entries[0].Phonebook, TRUE, Nokia_VCard10);
                 if (error != ERR_NONE) {
                         goto out;
                 }
                 memcpy(Buffer2,Buffer,Length);
                 EncodeUnicode(Buffer,Buffer2,Length);
                 break;
         case SMS_NokiaVCARD21Long:
                 error = GSM_EncodeVCARD(di, Buffer, buffer_size, &Length, Info->Entries[0].Phonebook, TRUE, Nokia_VCard21);
                 if (error != ERR_NONE) {
                         goto out;
                 }
                 Coding = SMS_Coding_Default_No_Compression;
                 UDH = UDH_NokiaPhonebookLong;
                 memcpy(Buffer2,Buffer,Length);
                 EncodeUnicode(Buffer,Buffer2,Length);
                 break;
         case SMS_VCARD10Long:
                 error = GSM_EncodeVCARD(di, Buffer, buffer_size, &Length,Info->Entries[0].Phonebook,TRUE,Nokia_VCard10);
                 if (error != ERR_NONE) {
                         goto out;
                 }
                 if (Length>GSM_MAX_SMS_CHARS_LENGTH) UDH = UDH_ConcatenatedMessages;
                 Coding = SMS_Coding_Default_No_Compression;
                 memcpy(Buffer2,Buffer,Length);
                 EncodeUnicode(Buffer,Buffer2,Length);
                 break;
         case SMS_VCARD21Long:
                 error = GSM_EncodeVCARD(di, Buffer, buffer_size, &Length,Info->Entries[0].Phonebook,TRUE,Nokia_VCard21);
                 if (error != ERR_NONE) {
                         goto out;
                 }
                 if (Length>GSM_MAX_SMS_CHARS_LENGTH) UDH = UDH_ConcatenatedMessages;
                 Coding = SMS_Coding_Default_No_Compression;
                 memcpy(Buffer2,Buffer,Length);
                 EncodeUnicode(Buffer,Buffer2,Length);
                 break;
         case SMS_NokiaVCALENDAR10Long:
                 error=GSM_EncodeVCALENDAR(Buffer, buffer_size,&Length,Info->Entries[0].Calendar,TRUE,Nokia_VCalendar);
                 if (error != ERR_NONE) {
                         goto out;
                 }
                 Coding = SMS_Coding_Default_No_Compression;
                 /* Is 1 SMS ? 8 = length of ..SCKE4 */
                 if (Length <= GSM_MAX_SMS_CHARS_LENGTH - 8) {
                         sprintf(Buffer,"//SCKE4 ");
                         Length = 8;
                 } else {
                         UDH = UDH_NokiaCalendarLong;
                 }
                 memcpy(Buffer2,Buffer,Length);
                 EncodeUnicode(Buffer,Buffer2,Length);
                 break;
         case SMS_NokiaVTODOLong:
                 error=GSM_EncodeVTODO(Buffer, buffer_size,&Length,Info->Entries[0].ToDo,TRUE,Nokia_VToDo);
                 if (error != ERR_NONE) {
                         goto out;
                 }
                 UDH = UDH_NokiaCalendarLong;
                 Coding = SMS_Coding_Default_No_Compression;
                 memcpy(Buffer2,Buffer,Length);
                 EncodeUnicode(Buffer,Buffer2,Length);
                 break;
         case SMS_DisableVoice:
         case SMS_DisableFax:
         case SMS_DisableEmail:
         case SMS_EnableVoice:
         case SMS_EnableFax:
         case SMS_EnableEmail:
         case SMS_VoidSMS:
         case SMS_Text:
                 Class = Info->Class;
                 switch (Info->Entries[0].ID) {
                         case SMS_DisableVoice   : UDH = UDH_DisableVoice; break;
                         case SMS_DisableFax     : UDH = UDH_DisableFax;   break;
                         case SMS_DisableEmail   : UDH = UDH_DisableEmail; break;
                         case SMS_EnableVoice    : UDH = UDH_EnableVoice;  break;
                         case SMS_EnableFax      : UDH = UDH_EnableFax;    break;
                         case SMS_EnableEmail    : UDH = UDH_EnableEmail;  break;
                         case SMS_VoidSMS        : UDH = UDH_VoidSMS;      break;
                         case SMS_Text           : UDH = UDH_NoUDH;        break;
                         default                 :                         break;
                 }
                 UDHHeader.Type = UDH;
                 GSM_EncodeUDHHeader(di, &UDHHeader);
                 memcpy(Buffer,Info->Entries[0].Buffer,UnicodeLength(Info->Entries[0].Buffer)*2+2);
                 if (Info->UnicodeCoding) {
                         Coding = SMS_Coding_Unicode_No_Compression;
                         Length = UnicodeLength(Info->Entries[0].Buffer);
                         if (Length > (size_t)(140 - UDHHeader.Length) / 2) {
                                 Length = (140 - UDHHeader.Length) / 2;
                         }
                 } else {
                         Coding = SMS_Coding_Default_No_Compression;
                         FindDefaultAlphabetLen(Info->Entries[0].Buffer,&Length,&smslen,(GSM_MAX_8BIT_SMS_LENGTH-UDHHeader.Length)*8/7);
                 }
                 break;
         case SMS_ConcatenatedAutoTextLong:
         case SMS_ConcatenatedAutoTextLong16bit:
                 smslen = UnicodeLength(Info->Entries[0].Buffer);
                 memcpy(Buffer,Info->Entries[0].Buffer,smslen*2);
                 EncodeDefault(Buffer2, Buffer, &smslen, TRUE, NULL);
                 DecodeDefault(Buffer,  Buffer2, smslen, TRUE, NULL);
 #ifdef DEBUG
                 if (di->dl == DL_TEXTALL || di->dl == DL_TEXTALLDATE) {
                         smfprintf(di, "Info->Entries[0].Buffer:\n");
                         DumpMessage(di, Info->Entries[0].Buffer, UnicodeLength(Info->Entries[0].Buffer)*2);
                         smfprintf(di, "Buffer:\n");
                         DumpMessage(di, Buffer, UnicodeLength(Buffer)*2);
                 }
 #endif
                 Info->UnicodeCoding = FALSE;
                 for (smslen = 0; smslen < UnicodeLength(Info->Entries[0].Buffer) * 2; smslen++) {
                         if (Info->Entries[0].Buffer[smslen] != Buffer[smslen]) {
                                 Info->UnicodeCoding = TRUE;
                                 smfprintf(di, "Setting to Unicode %ld\n", (long)smslen);
                                 break;
                         }
                 }
                 /* No break here - we go to the SMS_ConcatenatedTextLong */
         case SMS_ConcatenatedTextLong:
         case SMS_ConcatenatedTextLong16bit:
                 Class = Info->Class;
                 if (Info->Entries[0].Buffer == NULL) {
                         Buffer[0] = 0;
                         Buffer[1] = 0;
                 } else {
                         memcpy(Buffer,Info->Entries[0].Buffer,UnicodeLength(Info->Entries[0].Buffer)*2+2);
                 }
                 UDH = UDH_NoUDH;
                 if (Info->UnicodeCoding) {
                         Coding = SMS_Coding_Unicode_No_Compression;
                         Length = UnicodeLength(Buffer);
                         if (Info->Entries[0].ID == SMS_ConcatenatedTextLong16bit ||
                             Info->Entries[0].ID == SMS_ConcatenatedAutoTextLong16bit) {
                                 if (Length>70) UDH=UDH_ConcatenatedMessages16bit;
                         } else {
                                 if (Length>70) UDH=UDH_ConcatenatedMessages;
                         }
                 } else {
                         Coding = SMS_Coding_Default_No_Compression;
                         FindDefaultAlphabetLen(Buffer,&Length,&smslen,5000);
                         if (Info->Entries[0].ID == SMS_ConcatenatedTextLong16bit ||
                             Info->Entries[0].ID == SMS_ConcatenatedAutoTextLong16bit) {
                                 if (smslen>GSM_MAX_SMS_CHARS_LENGTH) UDH=UDH_ConcatenatedMessages16bit;
                         } else {
                                 if (smslen>GSM_MAX_SMS_CHARS_LENGTH) UDH=UDH_ConcatenatedMessages;
                         }
                 }
         default:
                 break;
         }
         GSM_MakeMultiPartSMS(di, SMS,Buffer,Length,UDH,Coding,Class,Info->ReplaceMessage);
         error = ERR_NONE;
 out:
         free(Buffer);
         free(Buffer2);
         return error;
 }

§ GSM_EncodeSMSFrame()

GSM_Error GSM_EncodeSMSFrame	(	GSM_Debug_Info *	di,
		GSM_SMSMessage *	SMS,
		unsigned char *	buffer,
		GSM_SMSMessageLayout	Layout,
		int *	length,
		gboolean	clear
	)

Encodes SMS frame.

Definition at line 1008 of file gsmsms.c.

Referenced by PHONE_EncodeSMSFrame().

 {
         int i;
 
         if (clear) {
                 /* Cleaning up to the SMS text */
                 for (i=0;i<Layout.Text;i++) buffer[i] = 0;
         }
 
         /* GSM 03.40 section 9.2.3.1 (TP-Message-Type-Indicator) */
         switch (SMS->PDU) {
                 case SMS_Submit:
                         buffer[Layout.firstbyte] |= 0x01;
                         break;
                 /* SMS_Status_Report when Submit sms should have delivery report */
                 /* We DON'T CREATE FRAME FOR REAL SMS_STATUS_REPORT              */
                 case SMS_Status_Report:
                         buffer[Layout.firstbyte] |= 0x01;
                         /* GSM 03.40 section 9.2.3.5 (TP-Status-Raport-Request) */
                         /* Set when want delivery report from SMSC */
                         buffer[Layout.firstbyte] |= 0x20;
                         break;
                 case SMS_Deliver:
                         buffer[Layout.firstbyte] |= 0x00;
         }
 
         /* GSM 03.40 section 9.2.3.17 (TP-Reply-Path) */
         if (SMS->ReplyViaSameSMSC) buffer[Layout.firstbyte] |= 0x80;
 
         if (Layout.Number!=255) {
                 buffer[Layout.Number] = GSM_PackSemiOctetNumber(SMS->Number,buffer+(Layout.Number+1),TRUE);
                 smfprintf(di, "Recipient number \"%s\"\n",DecodeUnicodeString(SMS->Number));
         }
         if (Layout.SMSCNumber!=255) {
                 buffer[Layout.SMSCNumber]=GSM_PackSemiOctetNumber(SMS->SMSC.Number,buffer+(Layout.SMSCNumber+1), FALSE);
                 smfprintf(di, "SMSC number \"%s\"\n",DecodeUnicodeString(SMS->SMSC.Number));
         }
 
         /* Message Class*/
         /* GSM 03.40 section 9.2.3.10 (TP-Data-Coding-Scheme) and GSM 03.38 section 4 */
         if (Layout.TPDCS != 255) {
                 if (SMS->Class >= 0 && SMS->Class <= 3) buffer[Layout.TPDCS] |= SMS->Class | (1 << 4);
                 smfprintf(di, "SMS class %i\n",SMS->Class);
         }
 
         if (Layout.TPVP != 255) {
                 /* GSM 03.40 section 9.2.3.3 (TP-Validity-Period-Format) */
                 /* Bits 4 and 3: 10. TP-VP field present and integer represent (relative) */
                 buffer[Layout.firstbyte] |= 0x10;
                 buffer[Layout.TPVP]=((unsigned char)SMS->SMSC.Validity.Relative);
                 smfprintf(di, "SMS validity %02x\n",SMS->SMSC.Validity.Relative);
         }
 
         if (Layout.DateTime != 255) {
                 GSM_EncodeSMSDateTime(di, &SMS->DateTime, buffer+Layout.DateTime);
         }
 
         if (Layout.TPMR != 255) {
                 smfprintf(di, "TPMR: %02x %i\n",SMS->MessageReference,SMS->MessageReference);
                 buffer[Layout.TPMR] = SMS->MessageReference;
         }
 
         if (SMS->RejectDuplicates) {
                 /* GSM 03.40 section 9.2.3.25 (TP Reject Duplicates) */
                 buffer[Layout.firstbyte] |= 0x04;
         }
 
         if (Layout.TPPID != 255) {
                 buffer[Layout.TPPID] = 0;
                 if (SMS->ReplaceMessage > 0 && SMS->ReplaceMessage < 8) {
                         buffer[Layout.TPPID] = 0x40 + SMS->ReplaceMessage;
                 }
         }
 
         /* size is the length of the data in octets including UDH */
         *length=GSM_EncodeSMSFrameText(di, SMS,buffer,Layout);
 /*      if (*length == 0) return GE_UNKNOWN; */
         *length += Layout.Text;
 
         return ERR_NONE;
 }

§ GSM_EncodeUDHHeader()

void GSM_EncodeUDHHeader	(	GSM_Debug_Info *	di,
		GSM_UDHHeader *	UDH
	)

Encodes UDH header.

GSM 03.40 section 9.2.3.24

Definition at line 1151 of file gsmsms.c.

References GSM_UDHHeader::AllParts, GSM_UDHHeader::ID16bit, GSM_UDHHeader::ID8bit, GSM_UDHHeader::Length, GSM_UDHHeader::PartNumber, smfprintf(), GSM_UDHHeader::Text, TRUE, GSM_UDHHeader::Type, UDH_NoUDH, and UDH_UserUDH.

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

 {
         int i=0;
 
         if (UDH->Type == UDH_NoUDH) {
                 UDH->Length = 0;
                 return;
         }
         if (UDH->Type == UDH_UserUDH) {
                 UDH->Length = UDH->Text[0] + 1;
                 return;
         }
         while (TRUE) {
                 if (UDHHeaders[i].Type==UDH_NoUDH) {
                         smfprintf(di, "Not supported UDH type\n");
                         break;
                 }
                 if (UDHHeaders[i].Type!=UDH->Type) {
                         i++;
                         continue;
                 }
                 /* UDH Length */
                 UDH->Text[0] = UDHHeaders[i].Length;
                 memcpy(UDH->Text+1, UDHHeaders[i].Text, UDHHeaders[i].Length);
                 UDH->Length     = UDH->Text[0] + 1;
 
                 if (UDHHeaders[i].ID8bit != -1) {
                         UDH->Text[UDHHeaders[i].ID8bit+1] = UDH->ID8bit % 256;
                 } else {
                         UDH->ID8bit = -1;
                 }
                 if (UDHHeaders[i].ID16bit != -1) {
                         UDH->Text[UDHHeaders[i].ID16bit+1] = UDH->ID16bit / 256;
                         UDH->Text[UDHHeaders[i].ID16bit+2] = UDH->ID16bit % 256;
                 } else {
                         UDH->ID16bit = -1;
                 }
                 if (UDHHeaders[i].PartNumber != -1) {
                         UDH->Text[UDHHeaders[i].PartNumber+1] = UDH->PartNumber;
                 } else {
                         UDH->PartNumber = -1;
                 }
                 if (UDHHeaders[i].AllParts != -1) {
                         UDH->Text[UDHHeaders[i].AllParts+1] = UDH->AllParts;
                 } else {
                         UDH->AllParts = -1;
                 }
                 break;
         }
 }

§ GSM_FreeMultiPartSMSInfo()

void GSM_FreeMultiPartSMSInfo ( GSM_MultiPartSMSInfo * Info )

Frees any allocated structures inside GSM_MultiPartSMSInfo.

Definition at line 952 of file gsmmulti.c.

References GSM_MultiPartSMSEntry::Bitmap, GSM_MultiPartSMSEntry::Bookmark, GSM_MultiPartSMSEntry::Buffer, GSM_MultiPartSMSEntry::Calendar, GSM_MultiPartSMSInfo::Entries, GSM_MAX_MULTI_SMS, GSM_MultiPartSMSEntry::MMSIndicator, GSM_MultiPartSMSEntry::Phonebook, GSM_MultiPartSMSEntry::Ringtone, GSM_MultiPartSMSEntry::Settings, and GSM_MultiPartSMSEntry::ToDo.

 {
         int i;
 
         for (i=0;i<GSM_MAX_MULTI_SMS;i++) {
                 free(Info->Entries[i].Ringtone);
                 Info->Entries[i].Ringtone = NULL;
                 free(Info->Entries[i].Bitmap);
                 Info->Entries[i].Bitmap = NULL;
                 free(Info->Entries[i].Bookmark);
                 Info->Entries[i].Bookmark = NULL;
                 free(Info->Entries[i].Settings);
                 Info->Entries[i].Settings = NULL;
                 free(Info->Entries[i].MMSIndicator);
                 Info->Entries[i].MMSIndicator = NULL;
                 free(Info->Entries[i].Phonebook);
                 Info->Entries[i].Phonebook = NULL;
                 free(Info->Entries[i].Calendar);
                 Info->Entries[i].Calendar = NULL;
                 free(Info->Entries[i].ToDo);
                 Info->Entries[i].ToDo = NULL;
                 free(Info->Entries[i].Buffer);
                 Info->Entries[i].Buffer = NULL;
         }
 }

§ GSM_GetNextSMS()

GSM_Error GSM_GetNextSMS	(	GSM_StateMachine *	s,
		GSM_MultiSMSMessage *	sms,
		gboolean	start
	)

Reads next (or first if start set) SMS message. This might be faster for some phones than using GSM_GetSMS for each message.

Please note that this commend does not have to mark message as read in phone. To do so, you have to call GSM_GetSMS.

Parameters

	s	State machine pointer.
[in,out]	sms	SMS message data read from phone, for subsequent reads, location and folder might be used by phone driver to determine reading state.
[in]	start	Whether we start reading from beginning.

Returns: Error code.

Reads next (or first if start set) SMS message. This might be faster for some phones than using GSM_GetSMS for each message.

Definition at line 683 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, GSM_Phone_Functions::GetNextSMS, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, PRINT_MSMS_INFO, and PRINT_START.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
         PRINT_START();
         PRINT_MSMS_INFO();
 
         err = s->Phone.Functions->GetNextSMS(s, sms, start);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_GetSMS()

GSM_Error GSM_GetSMS	(	GSM_StateMachine *	s,
		GSM_MultiSMSMessage *	sms
	)

Reads SMS message.

Parameters

	s	State machine pointer.
[in,out]	sms	SMS message data read from phone, location and folder should be set.

Returns: Error code.

Reads SMS message.

Definition at line 668 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, GSM_Phone_Functions::GetSMS, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, and PRINT_MSMS_INFO.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
         PRINT_MSMS_INFO();
 
         err = s->Phone.Functions->GetSMS(s, sms);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_GetSMSC()

GSM_Error GSM_GetSMSC	(	GSM_StateMachine *	s,
		GSM_SMSC *	smsc
	)

Gets SMS Service Center number and SMS settings.

Parameters

	s	State machine pointer.
[in,out]	smsc	SMSC structure, should contain location.

Returns: Error code.

Gets SMS Service Center number and SMS settings.

Definition at line 628 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, GSM_Phone_Functions::GetSMSC, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
 
         err = s->Phone.Functions->GetSMSC(s, smsc);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_GetSMSFolders()

GSM_Error GSM_GetSMSFolders	(	GSM_StateMachine *	s,
		GSM_SMSFolders *	folders
	)

Returns SMS folders information.

Parameters

	s	State machine pointer.
[out]	folders	folders Pointer to folders structure, which will be filled in.

Returns: Error code.

Returns SMS folders information.

Definition at line 806 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, GSM_Phone_Functions::GetSMSFolders, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
 
         err = s->Phone.Functions->GetSMSFolders(s, folders);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_GetSMSStatus()

GSM_Error GSM_GetSMSStatus	(	GSM_StateMachine *	s,
		GSM_SMSMemoryStatus *	status
	)

Gets information about SMS memory (read/unread/size of memory for both SIM and phone).

Parameters

	s	State machine pointer.
[out]	status	Pointer to SMS status structure.

Returns: Error code.

Gets information about SMS memory (read/unread/size of memory for both SIM and phone).

Definition at line 655 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, GSM_Phone_Functions::GetSMSStatus, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
 
         err = s->Phone.Functions->GetSMSStatus(s, status);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_LinkSMS()

GSM_Error GSM_LinkSMS	(	GSM_Debug_Info *	di,
		GSM_MultiSMSMessage **	INPUT,
		GSM_MultiSMSMessage **	OUTPUT,
		gboolean	ems
	)

Links SMS messages according to IDs.

Returns: Error code.

Definition at line 1395 of file gsmmulti.c.

References GSM_UDHHeader::AllParts, GSM_SiemensOTASMSInfo::DataName, GSM_SiemensOTASMSInfo::DataType, GSM_SMSMessage::DateTime, GSM_DateTime::Day, DecodeUnicodeString(), ERR_MOREMEMORY, ERR_NONE, FALSE, GSM_DecodeSiemensOTASMS(), GSM_SMS_OTHER_NUMBERS, GSM_DateTime::Hour, GSM_UDHHeader::ID16bit, GSM_UDHHeader::ID8bit, GSM_DateTime::Minute, GSM_DateTime::Month, GSM_MultiSMSMessage::Number, GSM_SMSMessage::OtherNumbersNum, GSM_SiemensOTASMSInfo::PacketNum, GSM_SiemensOTASMSInfo::PacketsNum, GSM_UDHHeader::PartNumber, GSM_DateTime::Second, GSM_SiemensOTASMSInfo::SequenceID, smfprintf(), GSM_MultiSMSMessage::SMS, SMS_Deliver, GSM_UDHHeader::Text, TRUE, GSM_UDHHeader::Type, GSM_SMSMessage::UDH, UDH_ConcatenatedMessages, UDH_ConcatenatedMessages16bit, UDH_NoUDH, UDH_UserUDH, UnicodeLength(), and GSM_DateTime::Year.

 {
         gboolean                        *InputMessagesSorted, copyit,OtherNumbers[GSM_SMS_OTHER_NUMBERS+1],wrong=FALSE;
         int                     i,OutputMessagesNum,z,w,m,p;
         int                     j;
         GSM_SiemensOTASMSInfo   SiemensOTA,SiemensOTA2;
 
         i = 0;
         while (InputMessages[i] != NULL) i++;
 
         OutputMessagesNum = 0;
         OutputMessages[0] = NULL;
 
         if (i == 0) {
                 return ERR_NONE;
         }
 
         InputMessagesSorted = calloc(i, sizeof(gboolean));
         if (InputMessagesSorted == NULL) return ERR_MOREMEMORY;
 
         if (ems) {
                 for (i = 0; InputMessages[i] != NULL; i++) {
                         if (InputMessages[i]->SMS[0].UDH.Type == UDH_UserUDH) {
                                 w=1;
                                 while (w < InputMessages[i]->SMS[0].UDH.Length) {
                                         switch(InputMessages[i]->SMS[0].UDH.Text[w]) {
                                         case 0x00:
                                                 smfprintf(di, "Adding ID to user UDH - linked SMS with 8 bit ID\n");
                                                 InputMessages[i]->SMS[0].UDH.ID8bit     = InputMessages[i]->SMS[0].UDH.Text[w+2];
                                                 InputMessages[i]->SMS[0].UDH.ID16bit    = -1;
                                                 InputMessages[i]->SMS[0].UDH.AllParts   = InputMessages[i]->SMS[0].UDH.Text[w+3];
                                                 InputMessages[i]->SMS[0].UDH.PartNumber = InputMessages[i]->SMS[0].UDH.Text[w+4];
                                                 break;
                                         case 0x08:
                                                 smfprintf(di, "Adding ID to user UDH - linked SMS with 16 bit ID\n");
                                                 InputMessages[i]->SMS[0].UDH.ID8bit     = -1;
                                                 InputMessages[i]->SMS[0].UDH.ID16bit    = InputMessages[i]->SMS[0].UDH.Text[w+2]*256+InputMessages[i]->SMS[0].UDH.Text[w+3];
                                                 InputMessages[i]->SMS[0].UDH.AllParts   = InputMessages[i]->SMS[0].UDH.Text[w+4];
                                                 InputMessages[i]->SMS[0].UDH.PartNumber = InputMessages[i]->SMS[0].UDH.Text[w+5];
                                                 break;
                                         default:
                                                 smfprintf(di, "Block %02x\n",InputMessages[i]->SMS[0].UDH.Text[w]);
                                         }
                                         smfprintf(di, "id8: %i, id16: %i, part: %i, parts count: %i\n",
                                                 InputMessages[i]->SMS[0].UDH.ID8bit,
                                                 InputMessages[i]->SMS[0].UDH.ID16bit,
                                                 InputMessages[i]->SMS[0].UDH.PartNumber,
                                                 InputMessages[i]->SMS[0].UDH.AllParts);
                                         w=w+InputMessages[i]->SMS[0].UDH.Text[w+1]+2;
                                 }
                         }
                 }
         }
 
         i=0;
         while (InputMessages[i]!=NULL) {
                 /* If this one SMS was sorted earlier, do not touch */
                 if (InputMessagesSorted[i]) {
                         i++;
                         continue;
                 }
                 /* We have 1'st part of SIEMENS sms. It's single.
                  * We will try to find other parts
                  */
                 if (GSM_DecodeSiemensOTASMS(di, &SiemensOTA,&InputMessages[i]->SMS[0]) &&
                     SiemensOTA.PacketNum == 1) {
                         OutputMessages[OutputMessagesNum] = (GSM_MultiSMSMessage *)malloc(sizeof(GSM_MultiSMSMessage));
                         if (OutputMessages[OutputMessagesNum] == NULL) {
                                 free(InputMessagesSorted);
                                 InputMessagesSorted=NULL;
                                 return ERR_MOREMEMORY;
                         }
                         OutputMessages[OutputMessagesNum+1] = NULL;
 
                         memcpy(&OutputMessages[OutputMessagesNum]->SMS[0],&InputMessages[i]->SMS[0],sizeof(GSM_SMSMessage));
                         OutputMessages[OutputMessagesNum]->Number = 1;
                         InputMessagesSorted[i]  = TRUE;
                         j               = 1;
                         /* We're searching for other parts in sequence */
                         while (j!=(int)SiemensOTA.PacketsNum) {
                                 z=0;
                                 while(InputMessages[z]!=NULL) {
                                         /* This was sorted earlier or is not single */
                                         if (InputMessagesSorted[z] || InputMessages[z]->Number != 1) {
                                                 z++;
                                                 continue;
                                         }
                                         if (!GSM_DecodeSiemensOTASMS(di, &SiemensOTA2,&InputMessages[z]->SMS[0])) {
                                                 z++;
                                                 continue;
                                         }
                                         if (SiemensOTA2.SequenceID != SiemensOTA.SequenceID ||
                                             (int)SiemensOTA2.PacketNum != j+1 ||
                                             SiemensOTA2.PacketsNum != SiemensOTA.PacketsNum ||
                                             strcmp(SiemensOTA2.DataType,SiemensOTA.DataType) ||
                                             strcmp(SiemensOTA2.DataName,SiemensOTA.DataName)) {
                                                 z++;
                                                 continue;
                                         }
                                         /* For SMS_Deliver compare also SMSC and Sender numbers */
                                         if (InputMessages[z]->SMS[0].PDU == SMS_Deliver &&
                                             strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].SMSC.Number),DecodeUnicodeString(InputMessages[i]->SMS[0].SMSC.Number))) {
                                                 z++;
                                                 continue;
                                         }
                                         if (InputMessages[z]->SMS[0].PDU == SMS_Deliver &&
                                             InputMessages[z]->SMS[0].OtherNumbersNum!=InputMessages[i]->SMS[0].OtherNumbersNum) {
                                                 z++;
                                                 continue;
                                         }
                                         if (InputMessages[z]->SMS[0].PDU == SMS_Deliver) {
                                                 for (m=0;m<GSM_SMS_OTHER_NUMBERS+1;m++) {
                                                         OtherNumbers[m]=FALSE;
                                                 }
                                                 for (m=0;m<InputMessages[z]->SMS[0].OtherNumbersNum+1;m++) {
                                                         wrong=TRUE;
                                                         for (p=0;p<InputMessages[i]->SMS[0].OtherNumbersNum+1;p++) {
                                                                 if (OtherNumbers[p]) continue;
                                                                 if (m==0 && p==0 && !strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].Number),DecodeUnicodeString(InputMessages[i]->SMS[0].Number))) {
                                                                         OtherNumbers[0]=TRUE;
                                                                         wrong=FALSE;
                                                                         break;
                                                                 }
                                                                 if (m==0 && p!=0 && !strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].Number),DecodeUnicodeString(InputMessages[i]->SMS[0].OtherNumbers[p-1]))) {
                                                                         OtherNumbers[p]=TRUE;
                                                                         wrong=FALSE;
                                                                         break;
                                                                 }
                                                                 if (m!=0 && p==0 && !strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].OtherNumbers[m-1]),DecodeUnicodeString(InputMessages[i]->SMS[0].Number))) {
                                                                         OtherNumbers[0]=TRUE;
                                                                         wrong=FALSE;
                                                                         break;
                                                                 }
                                                                 if (m!=0 && p!=0 && !strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].OtherNumbers[m-1]),DecodeUnicodeString(InputMessages[i]->SMS[0].OtherNumbers[p-1]))) {
                                                                         OtherNumbers[p]=TRUE;
                                                                         wrong=FALSE;
                                                                         break;
                                                                 }
                                                         }
                                                         if (wrong) break;
                                                 }
                                                 if (wrong) {
                                                         z++;
                                                         continue;
                                                 }
                                         }
                                         /* DCT4 Outbox: SMS Deliver. Empty number and SMSC. We compare dates */
                                         if (InputMessages[z]->SMS[0].PDU == SMS_Deliver                 &&
                                             UnicodeLength(InputMessages[z]->SMS[0].SMSC.Number)==0      &&
                                             UnicodeLength(InputMessages[z]->SMS[0].Number)==0           &&
                                             (InputMessages[z]->SMS[0].DateTime.Day    != InputMessages[i]->SMS[0].DateTime.Day    ||
                                              InputMessages[z]->SMS[0].DateTime.Month  != InputMessages[i]->SMS[0].DateTime.Month  ||
                                              InputMessages[z]->SMS[0].DateTime.Year   != InputMessages[i]->SMS[0].DateTime.Year   ||
                                              InputMessages[z]->SMS[0].DateTime.Hour   != InputMessages[i]->SMS[0].DateTime.Hour   ||
                                              InputMessages[z]->SMS[0].DateTime.Minute != InputMessages[i]->SMS[0].DateTime.Minute ||
                                              InputMessages[z]->SMS[0].DateTime.Second != InputMessages[i]->SMS[0].DateTime.Second)) {
                                                 z++;
                                                 continue;
                                         }
                                         smfprintf(di, "Found Siemens SMS %i\n",j);
                                         /* We found correct sms. Copy it */
                                         memcpy(&OutputMessages[OutputMessagesNum]->SMS[j],&InputMessages[z]->SMS[0],sizeof(GSM_SMSMessage));
                                         OutputMessages[OutputMessagesNum]->Number++;
                                         InputMessagesSorted[z]=TRUE;
                                         break;
                                 }
                                 /* Incomplete sequence */
                                 if (OutputMessages[OutputMessagesNum]->Number==j) {
                                         smfprintf(di, "Incomplete sequence\n");
                                         break;
                                 }
                                 j++;
                         }
                         OutputMessagesNum++;
                         i = 0;
                         continue;
                 }
                 /* We have some next Siemens sms from sequence */
                 if (GSM_DecodeSiemensOTASMS(di, &SiemensOTA,&InputMessages[i]->SMS[0]) &&
                     SiemensOTA.PacketNum > 1) {
                         j = 0;
                         while (InputMessages[j]!=NULL) {
                                 if (InputMessagesSorted[j]) {
                                         j++;
                                         continue;
                                 }
                                 /* We have some not unassigned first sms from sequence.
                                  * We can't touch other sms from sequences
                                  */
                                 if (GSM_DecodeSiemensOTASMS(di, &SiemensOTA,&InputMessages[j]->SMS[0]) &&
                                     SiemensOTA.PacketNum == 1) {
                                         break;
                                 }
                                 j++;
                         }
                         if (InputMessages[j]==NULL) {
                                 OutputMessages[OutputMessagesNum] = (GSM_MultiSMSMessage *)malloc(sizeof(GSM_MultiSMSMessage));
                                 if (OutputMessages[OutputMessagesNum] == NULL) {
                                         free(InputMessagesSorted);
                                         InputMessagesSorted=NULL;
                                         return ERR_MOREMEMORY;
                                 }
                                 OutputMessages[OutputMessagesNum+1] = NULL;
 
                                 memcpy(OutputMessages[OutputMessagesNum],InputMessages[i],sizeof(GSM_MultiSMSMessage));
                                 InputMessagesSorted[i]=TRUE;
                                 OutputMessagesNum++;
                                 i = 0;
                                 continue;
                         } else i++;
                 }
                 copyit = FALSE;
                 /* If we have:
                  * - linked sms returned by phone driver
                  * - sms without linking
                  * we copy it to OutputMessages
                  */
                 if (InputMessages[i]->Number                    != 1            ||
                     InputMessages[i]->SMS[0].UDH.Type           == UDH_NoUDH    ||
                     InputMessages[i]->SMS[0].UDH.PartNumber     == -1) {
                         copyit = TRUE;
                 }
                 /* If we have unknown UDH, we copy it to OutputMessages */
                 if (InputMessages[i]->SMS[0].UDH.Type == UDH_UserUDH) {
                         if (!ems) copyit = TRUE;
                         if (ems && InputMessages[i]->SMS[0].UDH.PartNumber == -1) copyit = TRUE;
                 }
                 if (copyit) {
                         OutputMessages[OutputMessagesNum] = (GSM_MultiSMSMessage *)malloc(sizeof(GSM_MultiSMSMessage));
                         if (OutputMessages[OutputMessagesNum] == NULL) {
                                 free(InputMessagesSorted);
                                 InputMessagesSorted=NULL;
                                 return ERR_MOREMEMORY;
                         }
                         OutputMessages[OutputMessagesNum+1] = NULL;
 
                         memcpy(OutputMessages[OutputMessagesNum],InputMessages[i],sizeof(GSM_MultiSMSMessage));
                         InputMessagesSorted[i]=TRUE;
                         OutputMessagesNum++;
                         i = 0;
                         continue;
                 }
                 /* We have 1'st part of linked sms. It's single.
                  * We will try to find other parts
                  */
                 if (InputMessages[i]->SMS[0].UDH.PartNumber == 1) {
                         OutputMessages[OutputMessagesNum] = (GSM_MultiSMSMessage *)malloc(sizeof(GSM_MultiSMSMessage));
                         if (OutputMessages[OutputMessagesNum] == NULL) {
                                 free(InputMessagesSorted);
                                 InputMessagesSorted=NULL;
                                 return ERR_MOREMEMORY;
                         }
                         OutputMessages[OutputMessagesNum+1] = NULL;
 
                         memcpy(&OutputMessages[OutputMessagesNum]->SMS[0],&InputMessages[i]->SMS[0],sizeof(GSM_SMSMessage));
                         OutputMessages[OutputMessagesNum]->Number = 1;
                         InputMessagesSorted[i]  = TRUE;
                         j               = 1;
                         /* We're searching for other parts in sequence */
                         while (j != InputMessages[i]->SMS[0].UDH.AllParts) {
                                 z=0;
                                 while(InputMessages[z]!=NULL) {
                                         /* This was sorted earlier or is not single */
                                         if (InputMessagesSorted[z] || InputMessages[z]->Number != 1) {
                                                 z++;
                                                 continue;
                                         }
                                         if (ems && InputMessages[i]->SMS[0].UDH.Type != UDH_ConcatenatedMessages &&
                                             InputMessages[i]->SMS[0].UDH.Type != UDH_ConcatenatedMessages16bit   &&
                                             InputMessages[i]->SMS[0].UDH.Type != UDH_UserUDH                     &&
                                             InputMessages[z]->SMS[0].UDH.Type != UDH_ConcatenatedMessages        &&
                                             InputMessages[z]->SMS[0].UDH.Type != UDH_ConcatenatedMessages16bit   &&
                                             InputMessages[z]->SMS[0].UDH.Type != UDH_UserUDH) {
                                                 if (InputMessages[z]->SMS[0].UDH.Type != InputMessages[i]->SMS[0].UDH.Type) {
                                                         z++;
                                                         continue;
                                                 }
                                         }
                                         if (!ems && InputMessages[z]->SMS[0].UDH.Type != InputMessages[i]->SMS[0].UDH.Type) {
                                                 z++;
                                                 continue;
                                         }
                                         smfprintf(di, "compare %i         %i %i %i %i",
                                                 j+1,
                                                 InputMessages[i]->SMS[0].UDH.ID8bit,
                                                 InputMessages[i]->SMS[0].UDH.ID16bit,
                                                 InputMessages[i]->SMS[0].UDH.PartNumber,
                                                 InputMessages[i]->SMS[0].UDH.AllParts);
                                         smfprintf(di, "         %i %i %i %i\n",
                                                 InputMessages[z]->SMS[0].UDH.ID8bit,
                                                 InputMessages[z]->SMS[0].UDH.ID16bit,
                                                 InputMessages[z]->SMS[0].UDH.PartNumber,
                                                 InputMessages[z]->SMS[0].UDH.AllParts);
                                         if (InputMessages[z]->SMS[0].UDH.ID8bit      != InputMessages[i]->SMS[0].UDH.ID8bit     ||
                                                         InputMessages[z]->SMS[0].UDH.ID16bit     != InputMessages[i]->SMS[0].UDH.ID16bit        ||
                                                         InputMessages[z]->SMS[0].UDH.AllParts    != InputMessages[i]->SMS[0].UDH.AllParts       ||
                                                         (InputMessages[z]->SMS[0].UDH.PartNumber) != j + 1) {
                                                 z++;
                                                 continue;
                                         }
                                         /* For SMS_Deliver compare also SMSC and Sender numbers */
                                         if (InputMessages[z]->SMS[0].PDU == SMS_Deliver &&
                                             strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].SMSC.Number),DecodeUnicodeString(InputMessages[i]->SMS[0].SMSC.Number))) {
                                                 z++;
                                                 continue;
                                         }
                                         if (InputMessages[z]->SMS[0].PDU == SMS_Deliver &&
                                             InputMessages[z]->SMS[0].OtherNumbersNum!=InputMessages[i]->SMS[0].OtherNumbersNum) {
                                                 z++;
                                                 continue;
                                         }
                                         if (InputMessages[z]->SMS[0].PDU == SMS_Deliver) {
                                                 for (m=0;m<GSM_SMS_OTHER_NUMBERS+1;m++) {
                                                         OtherNumbers[m]=FALSE;
                                                 }
                                                 for (m=0;m<InputMessages[z]->SMS[0].OtherNumbersNum+1;m++) {
                                                         wrong=TRUE;
                                                         for (p=0;p<InputMessages[i]->SMS[0].OtherNumbersNum+1;p++) {
                                                                 if (OtherNumbers[p]) continue;
                                                                 if (m==0 && p==0 && !strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].Number),DecodeUnicodeString(InputMessages[i]->SMS[0].Number))) {
                                                                         OtherNumbers[0]=TRUE;
                                                                         wrong=FALSE;
                                                                         break;
                                                                 }
                                                                 if (m==0 && p!=0 && !strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].Number),DecodeUnicodeString(InputMessages[i]->SMS[0].OtherNumbers[p-1]))) {
                                                                         OtherNumbers[p]=TRUE;
                                                                         wrong=FALSE;
                                                                         break;
                                                                 }
                                                                 if (m!=0 && p==0 && !strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].OtherNumbers[m-1]),DecodeUnicodeString(InputMessages[i]->SMS[0].Number))) {
                                                                         OtherNumbers[0]=TRUE;
                                                                         wrong=FALSE;
                                                                         break;
                                                                 }
                                                                 if (m!=0 && p!=0 && !strcmp(DecodeUnicodeString(InputMessages[z]->SMS[0].OtherNumbers[m-1]),DecodeUnicodeString(InputMessages[i]->SMS[0].OtherNumbers[p-1]))) {
                                                                         OtherNumbers[p]=TRUE;
                                                                         wrong=FALSE;
                                                                         break;
                                                                 }
                                                         }
                                                         if (wrong) break;
                                                 }
                                                 if (wrong) {
                                                         z++;
                                                         continue;
                                                 }
                                         }
                                         /* DCT4 Outbox: SMS Deliver. Empty number and SMSC. We compare dates */
                                         if (InputMessages[z]->SMS[0].PDU == SMS_Deliver                 &&
                                             UnicodeLength(InputMessages[z]->SMS[0].SMSC.Number)==0      &&
                                             UnicodeLength(InputMessages[z]->SMS[0].Number)==0           &&
                                             (InputMessages[z]->SMS[0].DateTime.Day    != InputMessages[i]->SMS[0].DateTime.Day    ||
                                              InputMessages[z]->SMS[0].DateTime.Month  != InputMessages[i]->SMS[0].DateTime.Month  ||
                                              InputMessages[z]->SMS[0].DateTime.Year   != InputMessages[i]->SMS[0].DateTime.Year   ||
                                              InputMessages[z]->SMS[0].DateTime.Hour   != InputMessages[i]->SMS[0].DateTime.Hour   ||
                                              InputMessages[z]->SMS[0].DateTime.Minute != InputMessages[i]->SMS[0].DateTime.Minute ||
                                              InputMessages[z]->SMS[0].DateTime.Second != InputMessages[i]->SMS[0].DateTime.Second)) {
                                                 z++;
                                                 continue;
                                         }
                                         /* We found correct sms. Copy it */
                                         memcpy(&OutputMessages[OutputMessagesNum]->SMS[j],&InputMessages[z]->SMS[0],sizeof(GSM_SMSMessage));
                                         OutputMessages[OutputMessagesNum]->Number++;
                                         InputMessagesSorted[z]=TRUE;
                                         break;
                                 }
                                 /* Incomplete sequence */
                                 if (OutputMessages[OutputMessagesNum]->Number==j) {
                                         smfprintf(di, "Incomplete sequence\n");
                                         break;
                                 }
                                 j++;
                         }
                         OutputMessagesNum++;
                         i = 0;
                         continue;
                 }
                 /* We have some next linked sms from sequence */
                 if (InputMessages[i]->SMS[0].UDH.PartNumber > 1) {
                         j = 0;
                         while (InputMessages[j]!=NULL) {
                                 if (InputMessagesSorted[j]) {
                                         j++;
                                         continue;
                                 }
                                 /* We have some not unassigned first sms from sequence.
                                  * We can't touch other sms from sequences
                                  */
                                 if (InputMessages[j]->SMS[0].UDH.PartNumber == 1) break;
                                 j++;
                         }
                         if (InputMessages[j]==NULL) {
                                 OutputMessages[OutputMessagesNum] = (GSM_MultiSMSMessage *)malloc(sizeof(GSM_MultiSMSMessage));
                                 if (OutputMessages[OutputMessagesNum] == NULL) {
                                         free(InputMessagesSorted);
                                         InputMessagesSorted=NULL;
                                         return ERR_MOREMEMORY;
                                 }
                                 OutputMessages[OutputMessagesNum+1] = NULL;
 
                                 memcpy(OutputMessages[OutputMessagesNum],InputMessages[i],sizeof(GSM_MultiSMSMessage));
                                 InputMessagesSorted[i]=TRUE;
                                 OutputMessagesNum++;
                                 i = 0;
                                 continue;
                         } else i++;
                 }
         }
         free(InputMessagesSorted);
         InputMessagesSorted=NULL;
         return ERR_NONE;
 }

§ GSM_SendSavedSMS()

GSM_Error GSM_SendSavedSMS	(	GSM_StateMachine *	s,
		int	Folder,
		int	Location
	)

Sends SMS already saved in phone.

Parameters

	s	State machine pointer.
[in]	Folder	Folder, where message is stored.
[in]	Location	Location, where message is stored.

Returns: Error code.

Sends SMS already saved in phone.

Definition at line 753 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, GSM_Phone_Functions::SendSavedSMS, and smprintf().

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
         smprintf(s, "Location = %d, Folder = %d\n", Location, Folder);
 
         err = s->Phone.Functions->SendSavedSMS(s, Folder, Location);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_SendSMS()

GSM_Error GSM_SendSMS	(	GSM_StateMachine *	s,
		GSM_SMSMessage *	sms
	)

Sends SMS.

Parameters

	s	State machine pointer.
[in]	sms	SMS structure with SMS data to send.

Returns: Error code.

Sends SMS.

Definition at line 740 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, and GSM_Phone_Functions::SendSMS.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
 
         err = s->Phone.Functions->SendSMS(s, sms);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_SetDefaultReceivedSMSData()

void GSM_SetDefaultReceivedSMSData ( GSM_SMSMessage * SMS )

Sets default content for SMS except for changing locations. Use this for clearing structure while keeping location of message.

Parameters

SMS	Pointer to structure which should be cleaned up.

Definition at line 1092 of file gsmsms.c.

References GSM_UDHHeader::AllParts, GSM_SMSMessage::Class, GSM_SMSMessage::Coding, GSM_SMSMessage::DateTime, GSM_SMSC::DefaultNumber, GSM_SMSMessage::DeliveryStatus, FALSE, GSM_SMSValidity::Format, GSM_SMSC::Format, GSM_UDHHeader::ID16bit, GSM_UDHHeader::ID8bit, GSM_UDHHeader::Length, GSM_SMSMessage::Length, GSM_SMSC::Location, GSM_SMSMessage::MessageReference, GSM_SMSC::Name, GSM_SMSMessage::Name, GSM_SMSC::Number, GSM_SMSMessage::Number, GSM_SMSMessage::OtherNumbersNum, GSM_UDHHeader::PartNumber, GSM_SMSMessage::RejectDuplicates, GSM_SMSValidity::Relative, GSM_SMSMessage::ReplaceMessage, GSM_SMSMessage::ReplyViaSameSMSC, SMS_Coding_8bit, SMS_FORMAT_Text, SMS_VALID_Max_Time, SMS_Validity_NotAvailable, GSM_SMSMessage::SMSC, GSM_UDHHeader::Text, GSM_SMSMessage::Text, GSM_UDHHeader::Type, GSM_SMSMessage::UDH, UDH_NoUDH, GSM_SMSC::Validity, and GSM_DateTime::Year.

Referenced by GSM_DecodePDUFrame(), GSM_DecodeSMSFrame(), and GSM_SetDefaultSMSData().

 {
         SMS->UDH.Type                   = UDH_NoUDH;
         SMS->UDH.Length                 = 0;
         SMS->UDH.Text[0]                = 0;
         SMS->UDH.ID8bit                 = 0;
         SMS->UDH.ID16bit                = 0;
         SMS->UDH.PartNumber             = -1;
         SMS->UDH.AllParts               = 0;
         SMS->Coding                     = SMS_Coding_8bit;
         SMS->Length                     = 0;
         SMS->SMSC.Location              = 0;
         SMS->SMSC.DefaultNumber[0]      = 0;
         SMS->SMSC.DefaultNumber[1]      = 0;
         SMS->SMSC.Number[0]             = 0;
         SMS->SMSC.Number[1]             = 0;
         SMS->SMSC.Name[0]               = 0;
         SMS->SMSC.Name[1]               = 0;
         SMS->SMSC.Validity.Format       = SMS_Validity_NotAvailable;
         SMS->SMSC.Validity.Relative     = SMS_VALID_Max_Time;
         SMS->SMSC.Format                = SMS_FORMAT_Text;
         SMS->Number[0]                  = 0;
         SMS->Number[1]                  = 0;
         SMS->OtherNumbersNum            = 0;
         SMS->Name[0]                    = 0;
         SMS->Name[1]                    = 0;
         SMS->ReplyViaSameSMSC           = FALSE;
         SMS->Class                      = 0;
         SMS->Text[0]                    = 0;
         SMS->Text[1]                    = 0;
         SMS->RejectDuplicates           = FALSE;
         SMS->MessageReference           = 0;
         SMS->ReplaceMessage             = 0;
         SMS->DeliveryStatus             = 0;
         SMS->DateTime.Year = 0;
 }

§ GSM_SetDefaultSMSData()

void GSM_SetDefaultSMSData ( GSM_SMSMessage * SMS )

Sets default content for SMS. Use this for clearing structure.

Parameters

SMS	Pointer to structure which should be cleaned up.

Definition at line 1129 of file gsmsms.c.

References GSM_SMSMessage::DateTime, FALSE, GSM_SMSMessage::Folder, GSM_SMSValidity::Format, GSM_GetCurrentDateTime(), GSM_SetDefaultReceivedSMSData(), GSM_SMSMessage::InboxFolder, GSM_SMSC::Location, GSM_SMSMessage::Location, GSM_SMSMessage::Memory, GSM_SMSMessage::PDU, GSM_SMSValidity::Relative, SMS_Submit, SMS_UnSent, SMS_VALID_Max_Time, SMS_Validity_RelativeFormat, GSM_SMSMessage::SMSC, GSM_SMSMessage::SMSCTime, GSM_SMSMessage::State, and GSM_SMSC::Validity.

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

 {
         GSM_SetDefaultReceivedSMSData(SMS);
 
         SMS->SMSC.Validity.Format       = SMS_Validity_RelativeFormat;
         SMS->SMSC.Validity.Relative     = SMS_VALID_Max_Time;
         SMS->SMSC.Location              = 1;
 
         /* This part is required to save SMS */
         SMS->State                      = SMS_UnSent;
         SMS->PDU                        = SMS_Submit;
         SMS->Location                   = 0;
         SMS->Memory                     = 0;
         SMS->Folder                     = 0x02; /*Outbox*/
         SMS->InboxFolder                = FALSE;
         GSM_GetCurrentDateTime (&SMS->DateTime);
         GSM_GetCurrentDateTime (&SMS->SMSCTime);
 }

§ GSM_SetFastSMSSending()

GSM_Error GSM_SetFastSMSSending	(	GSM_StateMachine *	s,
		gboolean	enable
	)

Configures fast SMS sending.

Parameters

	s	State machine pointer.
[in]	enable	Whether to enable notifications.

Returns: Error code.

Configures fast SMS sending.

Definition at line 767 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, and GSM_Phone_Functions::SetFastSMSSending.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
 
         err = s->Phone.Functions->SetFastSMSSending(s, enable);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_SetIncomingSMS()

GSM_Error GSM_SetIncomingSMS	(	GSM_StateMachine *	s,
		gboolean	enable
	)

Enable/disable notification on incoming SMS.

Parameters

	s	State machine pointer.
[in]	enable	Whether to enable notifications.

Returns: Error code.

Enable/disable notification on incoming SMS.

Definition at line 780 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, and GSM_Phone_Functions::SetIncomingSMS.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
 
         err = s->Phone.Functions->SetIncomingSMS(s, enable);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_SetSMS()

GSM_Error GSM_SetSMS	(	GSM_StateMachine *	s,
		GSM_SMSMessage *	sms
	)

Sets SMS.

Parameters

	s	State machine pointer.
[in]	sms	SMS message data.

Returns: Error code.

Sets SMS.

Definition at line 698 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, PRINT_SMS_INFO, and GSM_Phone_Functions::SetSMS.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
         PRINT_SMS_INFO();
 
         err = s->Phone.Functions->SetSMS(s, sms);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_SetSMSC()

GSM_Error GSM_SetSMSC	(	GSM_StateMachine *	s,
		GSM_SMSC *	smsc
	)

Sets SMS Service Center number and SMS settings.

Parameters

	s	State machine pointer.
[in]	smsc	SMSC structure.

Returns: Error code.

Sets SMS Service Center number and SMS settings.

Definition at line 641 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, and GSM_Phone_Functions::SetSMSC.

 {
         GSM_Error err;
 
         CHECK_PHONE_CONNECTION();
 
         err = s->Phone.Functions->SetSMSC(s, smsc);
         PRINT_LOG_ERROR(err);
         return err;
 }

§ GSM_SMSCounter()

void GSM_SMSCounter	(	GSM_Debug_Info *	di,
		unsigned char *	MessageBuffer,
		GSM_UDH	UDHType,
		GSM_Coding_Type	Coding,
		int *	SMSNum,
		size_t *	CharsLeft
	)

Calculates number of messages and free chars needed for text.

Parameters

	di	Debug settings.
[in]	MessageBuffer	Actual message text in unicode.
[in]	UDHType	UDH type.
[in]	Coding	GSM Encoding type.
[out]	SMSNum	Number of messages needed to store the text.
[out]	CharsLeft	Number of free chars in the message.

Definition at line 355 of file gsmmulti.c.

References FALSE, GSM_Find_Free_Used_SMS2(), GSM_MakeMultiPartSMS(), GSM_MultiSMSMessage::Number, GSM_MultiSMSMessage::SMS, and UnicodeLength().

 {
         size_t                  UsedText=0,FreeBytes=0;
         GSM_MultiSMSMessage     MultiSMS;
 
         MultiSMS.Number = 0;
         GSM_MakeMultiPartSMS(di, &MultiSMS,MessageBuffer,UnicodeLength(MessageBuffer),UDHType,Coding,-1,FALSE);
         GSM_Find_Free_Used_SMS2(
                 di, Coding, &(MultiSMS.SMS[MultiSMS.Number-1]),
                 &UsedText, CharsLeft, &FreeBytes
         );
         *SMSNum = MultiSMS.Number;
 }

§ PHONE_EncodeSMSFrame()

GSM_Error PHONE_EncodeSMSFrame	(	GSM_StateMachine *	s,
		GSM_SMSMessage *	SMS,
		unsigned char *	buffer,
		GSM_SMSMessageLayout	Layout,
		int *	length,
		gboolean	clear
	)

Encodes SMS frame according to layout.

Returns: Error code.

Definition at line 58 of file pfunc.c.

References ERR_EMPTYSMSC, ERR_GETTING_SMSC, ERR_NONE, GSM_Phone::Functions, GSM_Phone_Functions::GetSMSC, GSM_EncodeSMSFrame(), GSM_GetDI(), GSM_SMSC::Location, GSM_SMSC::Number, GSM_SMSMessage::PDU, _GSM_StateMachine::Phone, smprintf(), SMS_Deliver, and GSM_SMSMessage::SMSC.

Referenced by DUMMY_SendSMS().

 {
         GSM_Error error;
 
         if (SMS->SMSC.Location != 0) {
                 smprintf(s, "Getting SMSC from phone, location %d\n", SMS->SMSC.Location);
                 error = s->Phone.Functions->GetSMSC(s, &SMS->SMSC);
                 if (error != ERR_NONE) {
                         return ERR_GETTING_SMSC;
                 }
                 SMS->SMSC.Location = 0;
         }
         if (SMS->PDU == SMS_Deliver) {
                 if (SMS->SMSC.Number[0] == 0x00 && SMS->SMSC.Number[1] == 0x00) {
                         smprintf(s,"No SMSC in SMS Deliver\n");
                         return ERR_EMPTYSMSC;
                 }
         }
         return GSM_EncodeSMSFrame(GSM_GetDI(s), SMS, buffer, Layout, length, clear);
 }

Variable Documentation

§ PHONE_SMSDeliver

GSM_SMSMessageLayout PHONE_SMSDeliver

Layout for deliver message.

Definition at line 16 of file pfunc.c.

Referenced by DUMMY_SendSMS().

§ PHONE_SMSStatusReport

GSM_SMSMessageLayout PHONE_SMSStatusReport

Layout for status report message.

Definition at line 30 of file pfunc.c.

§ PHONE_SMSSubmit

GSM_SMSMessageLayout PHONE_SMSSubmit

Layout for submit message.

Definition at line 23 of file pfunc.c.

Referenced by DUMMY_SendSMS().

Data Structures

Enumerations

Functions

Variables

Detailed Description

Enumeration Type Documentation

§ EncodeMultiPartSMSID

§ GSM_Coding_Type

§ GSM_SMS_State

§ GSM_SMSFormat

§ GSM_SMSMessageType

§ GSM_UDH

§ GSM_ValidityPeriod

§ GSM_ValidityPeriodFormat

Function Documentation

§ GSM_AddSMS()

§ GSM_AddSMSFolder()

§ GSM_ClearMultiPartSMSInfo()

§ GSM_DecodeMultiPartSMS()

§ GSM_DecodePDUFrame()

§ GSM_DecodeSiemensOTASMS()

§ GSM_DecodeSMSFrame()

§ GSM_DecodeSMSFrameStatusReportData()

§ GSM_DecodeSMSFrameText()

§ GSM_DecodeUDHHeader()

§ GSM_DeleteSMS()

§ GSM_DeleteSMSFolder()

§ GSM_EncodeMultiPartSMS()

§ GSM_EncodeSMSFrame()

§ GSM_EncodeUDHHeader()

§ GSM_FreeMultiPartSMSInfo()

§ GSM_GetNextSMS()

§ GSM_GetSMS()

§ GSM_GetSMSC()

§ GSM_GetSMSFolders()

§ GSM_GetSMSStatus()

§ GSM_LinkSMS()

§ GSM_SendSavedSMS()

§ GSM_SendSMS()

§ GSM_SetDefaultReceivedSMSData()

§ GSM_SetDefaultSMSData()

§ GSM_SetFastSMSSending()

§ GSM_SetIncomingSMS()

§ GSM_SetSMS()

§ GSM_SetSMSC()

§ GSM_SMSCounter()

§ PHONE_EncodeSMSFrame()

Variable Documentation

§ PHONE_SMSDeliver

§ PHONE_SMSStatusReport

§ PHONE_SMSSubmit