gammu-message.h

Go to the documentation of this file.

#ifndef __gammu_message_h
#define __gammu_message_h

#include <gammu-limits.h>
#include <gammu-memory.h>
#include <gammu-datetime.h>
#include <gammu-ringtone.h>
#include <gammu-bitmap.h>
#include <gammu-wap.h>
#include <gammu-calendar.h>
#include <gammu-file.h>
#include <gammu-debug.h>

typedef enum {
        GSM_MMS_None = 0,
        GSM_MMS_Personal = 1,
        GSM_MMS_Advertisement,
        GSM_MMS_Info,
        GSM_MMS_Auto,
} GSM_MMS_Class;

typedef struct {
        char Address[500];
        char Title[200];
        char Sender[200];
        size_t MessageSize;
        GSM_MMS_Class Class;
} GSM_MMSIndicator;

typedef struct {
        int Channel;
        char Text[300];
} GSM_CBMessage;

typedef enum {
        USSD_Unknown = 1,
        USSD_NoActionNeeded,
        USSD_ActionNeeded,
        USSD_Terminated,
        USSD_AnotherClient,
        USSD_NotSupported,
        USSD_Timeout,
} GSM_USSDStatus;

typedef struct {
        unsigned char Text[2 * (GSM_MAX_USSD_LENGTH + 1)];
        GSM_USSDStatus Status;
} GSM_USSDMessage;

typedef struct {
        int SIMUnRead;
        int SIMUsed;
        int SIMSize;
        int TemplatesUsed;
        int PhoneUnRead;
        int PhoneUsed;
        int PhoneSize;
} GSM_SMSMemoryStatus;

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

typedef enum {
        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;

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

typedef struct {
        GSM_ValidityPeriodFormat Format;
        GSM_ValidityPeriod Relative;
} GSM_SMSValidity;

typedef struct {
        int Location;
        unsigned char Name[(GSM_MAX_SMSC_NAME_LENGTH + 1) * 2];
        unsigned char Number[(GSM_MAX_NUMBER_LENGTH + 1) * 2];
        GSM_SMSValidity Validity;
        GSM_SMSFormat Format;
        unsigned char DefaultNumber[(GSM_MAX_NUMBER_LENGTH + 1) * 2];
} GSM_SMSC;

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

typedef enum {
        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;

const char *GSM_SMSCodingToString(GSM_Coding_Type type);

GSM_Coding_Type GSM_StringToSMSCoding(const char *s);

typedef enum {
        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;

typedef struct {
        GSM_UDH Type;
        int Length;
        unsigned char Text[GSM_MAX_UDH_LENGTH];
        int ID8bit;
        int ID16bit;
        int PartNumber;
        int AllParts;
} GSM_UDHHeader;

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

typedef struct {
        unsigned char ReplaceMessage;
        gboolean RejectDuplicates;
        GSM_UDHHeader UDH;
        unsigned char Number[(GSM_MAX_NUMBER_LENGTH + 1) * 2];

        unsigned char
         OtherNumbers[GSM_SMS_OTHER_NUMBERS][(GSM_MAX_NUMBER_LENGTH + 1) * 2];
        int OtherNumbersNum;

        GSM_SMSC SMSC;
        GSM_MemoryType Memory;
        int Location;
        int Folder;
        gboolean InboxFolder;
        int Length;
        GSM_SMS_State State;
        unsigned char Name[(GSM_MAX_SMS_NAME_LENGTH + 1) * 2];
        unsigned char Text[(GSM_MAX_SMS_LENGTH + 1) * 2];
        GSM_SMSMessageType PDU;
        GSM_Coding_Type Coding;
        GSM_DateTime DateTime;
        GSM_DateTime SMSCTime;
        unsigned char DeliveryStatus;
        gboolean ReplyViaSameSMSC;
        signed char Class;
        unsigned char MessageReference;
} GSM_SMSMessage;

/* In layouts are saved locations for some SMS part. Below are listed
 * specs, which describe them
 *
 * \ingroup SMS
 */
typedef struct {
        unsigned char Text;
        unsigned char Number;
        unsigned char SMSCNumber;
        unsigned char TPDCS;
        unsigned char DateTime;
        unsigned char SMSCTime;
        unsigned char TPStatus;
        unsigned char TPUDL;
        unsigned char TPVP;
        unsigned char firstbyte;
        unsigned char TPMR;
        unsigned char TPPID;
} GSM_SMSMessageLayout;

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_Coding_Type GSM_GetMessageCoding(GSM_Debug_Info * di, const char TPDCS);

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);

typedef struct {
        gboolean InboxFolder;
        gboolean OutboxFolder;
        GSM_MemoryType Memory;
        unsigned char Name[(GSM_MAX_SMS_FOLDER_NAME_LEN + 1) * 2];
} GSM_OneSMSFolder;

typedef struct {
        GSM_OneSMSFolder Folder[GSM_MAX_SMS_FOLDERS];
        int Number;
} GSM_SMSFolders;

typedef struct {
        unsigned long SequenceID;
        unsigned int PacketsNum;
        unsigned int PacketNum;
        unsigned long AllDataLen;

        unsigned char DataType[10];
        unsigned char DataName[40];
        unsigned int DataLen;
        unsigned char Data[140];
} GSM_SiemensOTASMSInfo;

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

typedef struct {
        int Number;
        GSM_SMSMessage SMS[GSM_MAX_MULTI_SMS];
} GSM_MultiSMSMessage;

typedef struct {
        gboolean InboxFolder;
        char Name[(GSM_MAX_MMS_FOLDER_NAME_LEN + 1) * 2];
} GSM_OneMMSFolder;

typedef struct {
        unsigned char Number;
        GSM_OneMMSFolder Folder[GSM_MAX_MMS_FOLDERS];
} GSM_MMSFolders;

extern GSM_SMSMessageLayout PHONE_SMSSubmit;

extern GSM_SMSMessageLayout PHONE_SMSDeliver;

extern GSM_SMSMessageLayout PHONE_SMSStatusReport;

typedef enum {
        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;

typedef struct {
        EncodeMultiPartSMSID ID;

        int Number;
        GSM_Ringtone *Ringtone;
        GSM_MultiBitmap *Bitmap;
        GSM_WAPBookmark *Bookmark;
        GSM_WAPSettings *Settings;
        GSM_MMSIndicator *MMSIndicator;
        GSM_MemoryEntry *Phonebook;
        GSM_CalendarEntry *Calendar;
        GSM_ToDoEntry *ToDo;
        GSM_File *File;
        gboolean Protected;

        unsigned char *Buffer;
        gboolean Left;
        gboolean Right;
        gboolean Center;
        gboolean Large;
        gboolean Small;
        gboolean Bold;
        gboolean Italic;
        gboolean Underlined;
        gboolean Strikethrough;

        /* Return values */
        int RingtoneNotes;
} GSM_MultiPartSMSEntry;

typedef struct {
        int EntriesNum;
        gboolean UnicodeCoding;
        int Class;
        unsigned char ReplaceMessage;
        gboolean Unknown;
        GSM_MultiPartSMSEntry Entries[GSM_MAX_MULTI_SMS];
} GSM_MultiPartSMSInfo;

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);

typedef enum {
        MMSADDRESS_PHONE,
        MMSADDRESS_UNKNOWN
} MMSAddressType;

typedef struct {
        GSM_File File;
        unsigned char ContentType[400];
        unsigned char SMIL[400];
} GSM_EncodedMultiPartMMSEntry;

typedef struct {
        int EntriesNum;

        unsigned char Source[200];
        MMSAddressType SourceType;
        unsigned char Destination[200];
        MMSAddressType DestinationType;
        unsigned char CC[200];
        MMSAddressType CCType;

        unsigned char Subject[200];
        unsigned char ContentType[400];
        unsigned char MSGType[50];

        gboolean DateTimeAvailable;
        GSM_DateTime DateTime;

        gboolean MMSReportAvailable;
        gboolean MMSReport;
        GSM_EncodedMultiPartMMSEntry Entries[GSM_MAX_MULTI_MMS];
} GSM_EncodedMultiPartMMSInfo;

GSM_Error GSM_DecodeMMSFileToMultiPart(GSM_Debug_Info * di, GSM_File * file,
                                       GSM_EncodedMultiPartMMSInfo * info);

GSM_Error GSM_ClearMMSMultiPart(GSM_EncodedMultiPartMMSInfo * info);

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_SetIncomingCB(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);

GSM_Error GSM_GetMMSFolders(GSM_StateMachine * s, GSM_MMSFolders * folders);

GSM_Error GSM_GetNextMMSFileInfo(GSM_StateMachine * s, unsigned char *FileID,
                                 int *MMSFolder, gboolean start);
GSM_Error GSM_SetIncomingUSSD(GSM_StateMachine * s, gboolean enable);

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

#endif

/* Editor configuration
 * vim: noexpandtab sw=8 ts=8 sts=8 tw=72:
 */