include/gammu-message.h

   1 /**
   2  * \file gammu-message.h
   3  * \author Michal Čihař
   4  *
   5  * Message data and functions.
   6  */
   7 #ifndef __gammu_message_h
   8 #define __gammu_message_h
   9
  10 #include <gammu-limits.h>
  11 #include <gammu-memory.h>
  12 #include <gammu-datetime.h>
  13 #include <gammu-ringtone.h>
  14 #include <gammu-bitmap.h>
  15 #include <gammu-wap.h>
  16 #include <gammu-calendar.h>
  17 #include <gammu-file.h>
  18 #include <gammu-debug.h>
  19
  20 /**
  21  * \defgroup Message Messages
  22  * Messages manipulations.
  23  */
  24
  25 /**
  26  * \defgroup USSD USSD messages
  27  * USSD messages manipulations.
  28  * \ingroup Message
  29  */
  30
  31 /**
  32  * \defgroup CB CB messages
  33  * Cell broadcast messages manipulations.
  34  * \ingroup Message
  35  */
  36
  37 /**
  38  * \defgroup SMS SMS messages
  39  * SMS messages manipulations.
  40  * \ingroup Message
  41  */
  42
  43 /**
  44  * \defgroup MMS MMS messages
  45  * MMS messages manipulations.
  46  * \ingroup Message
  47  */
  48
  49 /**
  50  * MMS message class.
  51  */
  52 typedef enum {
  53         /**
  54          * None class specified.
  55          */
  56         GSM_MMS_None = 0,
  57         /**
  58          * Personal message.
  59          */
  60         GSM_MMS_Personal = 1,
  61         /**
  62          * Advertisement message.
  63          */
  64         GSM_MMS_Advertisement,
  65         /**
  66          * Informational message.
  67          */
  68         GSM_MMS_Info,
  69         /**
  70          * Automatic message class.
  71          */
  72         GSM_MMS_Auto,
  73 } GSM_MMS_Class;
  74
  75 /**
  76  * MMS indicator data.
  77  *
  78  * \ingroup MMS
  79  */
  80 typedef struct {
  81         /**
  82          * Message address (URL for download).
  83          */
  84         char Address[500];
  85         /**
  86          * Message title (subject).
  87          */
  88         char Title[200];
  89         /**
  90          * Message sender.
  91          */
  92         char Sender[200];
  93         /**
  94          * Message size, if 0 it won't be decoded or was not decoded.
  95          */
  96         size_t MessageSize;
  97         /**
  98          * Class of a message.
  99          */
 100         GSM_MMS_Class Class;
 101 } GSM_MMSIndicator;
 102
 103 /**
 104  * Structure for Cell Broadcast messages.
 105  *
 106  * \ingroup CB
 107  */
 108 typedef struct {
 109         /**
 110          * Channel number.
 111          */
 112         int Channel;
 113         /**
 114          * Message text.
 115          */
 116         char Text[300];
 117 } GSM_CBMessage;
 118
 119 /**
 120  * Status of USSD message.
 121  *
 122  * \ingroup USSD
 123  */
 124 typedef enum {
 125         /**
 126          * Unknown status
 127          */
 128         USSD_Unknown = 1,
 129         /**
 130          * No action is needed, maybe network initiated USSD
 131          */
 132         USSD_NoActionNeeded,
 133         /**
 134          * Reply is expected
 135          */
 136         USSD_ActionNeeded,
 137         /**
 138          * USSD dialog terminated
 139          */
 140         USSD_Terminated,
 141         /**
 142          * Another client replied
 143          */
 144         USSD_AnotherClient,
 145         /**
 146          * Operation not supported
 147          */
 148         USSD_NotSupported,
 149         /**
 150          * Network timeout
 151          */
 152         USSD_Timeout,
 153 } GSM_USSDStatus;
 154
 155 /**
 156  * Structure for USSD messages.
 157  *
 158  * \ingroup USSD
 159  */
 160 typedef struct {
 161         /**
 162          * Message text.
 163          */
 164         unsigned char Text[2 * (GSM_MAX_USSD_LENGTH + 1)];
 165         /**
 166          * Message status.
 167          */
 168         GSM_USSDStatus Status;
 169 } GSM_USSDMessage;
 170
 171 /**
 172  * Status of SMS memory.
 173  *
 174  * \ingroup SMS
 175  */
 176 typedef struct {
 177         /**
 178          * Number of unread messages on SIM.
 179          */
 180         int SIMUnRead;
 181         /**
 182          * Number of all saved messages (including unread) on SIM.
 183          */
 184         int SIMUsed;
 185         /**
 186          * Number of all possible messages on SIM.
 187          */
 188         int SIMSize;
 189         /**
 190          * Number of used templates (62xx/63xx/7110/etc.).
 191          */
 192         int TemplatesUsed;
 193         /**
 194          * Number of unread messages in phone.
 195          */
 196         int PhoneUnRead;
 197         /**
 198          * Number of all saved messages in phone.
 199          */
 200         int PhoneUsed;
 201         /**
 202          * Number of all possible messages on phone.
 203          */
 204         int PhoneSize;
 205 } GSM_SMSMemoryStatus;
 206
 207 /**
 208  * Enum defines format of SMS messages. See GSM 03.40 section 9.2.3.9
 209  *
 210  * \ingroup SMS
 211  */
 212 typedef enum {
 213         SMS_FORMAT_Pager = 1,
 214         SMS_FORMAT_Fax,
 215         SMS_FORMAT_Email,
 216         SMS_FORMAT_Text
 217             /* Some values not handled here */
 218 } GSM_SMSFormat;
 219
 220 /**
 221  * Enum defines some the most often used validity lengths for SMS messages
 222  * for relative validity format. See GSM 03.40 section 9.2.3.12.1 - it gives
 223  * more values.
 224  *
 225  * \ingroup SMS
 226  */
 227 typedef enum {
 228         SMS_VALID_1_Hour = 0x0b,
 229         SMS_VALID_6_Hours = 0x47,
 230         SMS_VALID_1_Day = 0xa7,
 231         SMS_VALID_3_Days = 0xa9,
 232         SMS_VALID_1_Week = 0xad,
 233         SMS_VALID_Max_Time = 0xff
 234 } GSM_ValidityPeriod;
 235
 236 /**
 237  * Enum defines format of validity period for SMS messages.
 238  * See GSM 03.40 section 9.2.3.12
 239  *
 240  * \ingroup SMS
 241  */
 242 typedef enum {
 243         SMS_Validity_NotAvailable = 1,
 244         SMS_Validity_RelativeFormat
 245             /* Specification gives also other possibilities */
 246 } GSM_ValidityPeriodFormat;
 247
 248 /**
 249  * Structure for validity of SMS messages
 250  *
 251  * \ingroup SMS
 252  */
 253 typedef struct {
 254         GSM_ValidityPeriodFormat Format;
 255         /**
 256          * Value defines period for relative format
 257          */
 258         GSM_ValidityPeriod Relative;
 259 } GSM_SMSValidity;
 260
 261 /**
 262  * Structure for SMSC (SMS Center) information.
 263  *
 264  * \ingroup SMS
 265  */
 266 typedef struct {
 267         /**
 268          * Number of the SMSC on SIM
 269          */
 270         int Location;
 271         /**
 272          * Name of the SMSC
 273          */
 274         unsigned char Name[(GSM_MAX_SMSC_NAME_LENGTH + 1) * 2];
 275         /**
 276          * SMSC phone number.
 277          */
 278         unsigned char Number[(GSM_MAX_NUMBER_LENGTH + 1) * 2];
 279         /**
 280          * Validity of SMS messages.
 281          */
 282         GSM_SMSValidity Validity;
 283         /**
 284          * Format of sent SMS messages.
 285          */
 286         GSM_SMSFormat Format;
 287         /**
 288          * Default recipient number. In old DCT3 ignored
 289          */
 290         unsigned char DefaultNumber[(GSM_MAX_NUMBER_LENGTH + 1) * 2];
 291 } GSM_SMSC;
 292
 293 /**
 294  * Status of SMS message.
 295  *
 296  * \ingroup SMS
 297  */
 298 typedef enum {
 299         SMS_Sent = 1,
 300         SMS_UnSent,
 301         SMS_Read,
 302         SMS_UnRead
 303 } GSM_SMS_State;
 304
 305 /**
 306  * Coding type of SMS.
 307  *
 308  * \ingroup SMS
 309  */
 310 typedef enum {
 311         /**
 312          * Unicode
 313          */
 314         SMS_Coding_Unicode_No_Compression = 1,
 315         SMS_Coding_Unicode_Compression,
 316         /**
 317          * Default GSM alphabet.
 318          */
 319         SMS_Coding_Default_No_Compression,
 320         SMS_Coding_Default_Compression,
 321         /**
 322          * 8-bit.
 323          */
 324         SMS_Coding_8bit
 325 } GSM_Coding_Type;
 326
 327 /**
 328  * Converts SMS coding to string.
 329  *
 330  * \return Pointer to static string, NULL on failure.
 331  */
 332 const char *GSM_SMSCodingToString(GSM_Coding_Type type);
 333
 334 /**
 335  * Converts SMS coding to type.
 336  */
 337 GSM_Coding_Type GSM_StringToSMSCoding(const char *s);
 338
 339 /**
 340  * Types of UDH (User Data Header).
 341  *
 342  * \ingroup SMS
 343  */
 344 typedef enum {
 345         UDH_NoUDH = 1,
 346         /**
 347          * Linked SMS.
 348          */
 349         UDH_ConcatenatedMessages,
 350         /**
 351          * Linked SMS with 16 bit reference.
 352          */
 353         UDH_ConcatenatedMessages16bit,
 354         UDH_DisableVoice,
 355         UDH_DisableFax,
 356         UDH_DisableEmail,
 357         UDH_EnableVoice,
 358         UDH_EnableFax,
 359         UDH_EnableEmail,
 360         UDH_VoidSMS,
 361         UDH_NokiaRingtone,
 362         UDH_NokiaRingtoneLong,
 363         UDH_NokiaOperatorLogo,
 364         UDH_NokiaOperatorLogoLong,
 365         UDH_NokiaCallerLogo,
 366         UDH_NokiaWAP,
 367         UDH_NokiaWAPLong,
 368         UDH_NokiaCalendarLong,
 369         UDH_NokiaProfileLong,
 370         UDH_NokiaPhonebookLong,
 371         UDH_UserUDH,
 372         UDH_MMSIndicatorLong
 373 } GSM_UDH;
 374
 375 /**
 376  * Structure for User Data Header.
 377  *
 378  * \ingroup SMS
 379  */
 380 typedef struct {
 381         /**
 382          * UDH type.
 383          */
 384         GSM_UDH Type;
 385         /**
 386          * UDH length.
 387          */
 388         int Length;
 389         /**
 390          * UDH text.
 391          */
 392         unsigned char Text[GSM_MAX_UDH_LENGTH];
 393         /**
 394          * 8-bit ID, when required (-1 otherwise).
 395          */
 396         int ID8bit;
 397         /**
 398          * 16-bit ID, when required (-1 otherwise).
 399          */
 400         int ID16bit;
 401         /**
 402          * Number of current part.
 403          */
 404         int PartNumber;
 405         /**
 406          * Total number of parts.
 407          */
 408         int AllParts;
 409 } GSM_UDHHeader;
 410
 411 /**
 412  * TP-Message-Type-Indicator. See GSM 03.40 section 9.2.3.1.
 413  *
 414  * \ingroup SMS
 415  */
 416 typedef enum {
 417         /**
 418          * SMS in Inbox.
 419          */
 420         SMS_Deliver = 1,
 421         /**
 422          * Delivery Report
 423          */
 424         SMS_Status_Report,
 425         /**
 426          * SMS for sending or in Outbox
 427          */
 428         SMS_Submit
 429             /* specification gives more */
 430 } GSM_SMSMessageType;
 431
 432 /**
 433  * SMS message data.
 434  *
 435  * \ingroup SMS
 436  */
 437 typedef struct {
 438         /**
 439          * Message to be replaced.
 440          */
 441         unsigned char ReplaceMessage;
 442         /**
 443          * Whether to reject duplicates.
 444          */
 445         gboolean RejectDuplicates;
 446         /**
 447          * UDH (User Data Header)
 448          */
 449         GSM_UDHHeader UDH;
 450         /**
 451          * Sender or recipient number.
 452          */
 453         unsigned char Number[(GSM_MAX_NUMBER_LENGTH + 1) * 2];
 454
 455         unsigned char
 456          OtherNumbers[GSM_SMS_OTHER_NUMBERS][(GSM_MAX_NUMBER_LENGTH + 1) * 2];
 457         int OtherNumbersNum;
 458
 459         /**
 460          * SMSC (SMS Center)
 461          */
 462         GSM_SMSC SMSC;
 463         /**
 464          * For saved SMS: where exactly it's saved (SIM/phone)
 465          */
 466         GSM_MemoryType Memory;
 467         /**
 468          * For saved SMS: location of SMS in memory.
 469          */
 470         int Location;
 471         /**
 472          * For saved SMS: number of folder, where SMS is saved
 473          */
 474         int Folder;
 475         /**
 476          * For saved SMS: whether SMS is really in Inbox.
 477          */
 478         gboolean InboxFolder;
 479         /**
 480          * Length of the SMS message.
 481          */
 482         int Length;
 483         /**
 484          * Status (read/unread/...) of SMS message.
 485          */
 486         GSM_SMS_State State;
 487         /**
 488          * Name in Nokia with SMS memory (6210/7110, etc.) Ignored in other.
 489          */
 490         unsigned char Name[(GSM_MAX_SMS_NAME_LENGTH + 1) * 2];
 491         /**
 492          * Text for SMS.
 493          */
 494         unsigned char Text[(GSM_MAX_SMS_LENGTH + 1) * 2];
 495         /**
 496          * Type of message.
 497          */
 498         GSM_SMSMessageType PDU;
 499         /**
 500          * Type of coding.
 501          */
 502         GSM_Coding_Type Coding;
 503         /**
 504          * Date and time, when SMS was saved or sent
 505          */
 506         GSM_DateTime DateTime;
 507         /**
 508          * Date of SMSC response in DeliveryReport messages.
 509          */
 510         GSM_DateTime SMSCTime;
 511         /**
 512          * In delivery reports: status.
 513          */
 514         unsigned char DeliveryStatus;
 515         /**
 516          * Indicates whether "Reply via same center" is set.
 517          */
 518         gboolean ReplyViaSameSMSC;
 519         /**
 520          * SMS class (0 is flash SMS, 1 is normal one).
 521          */
 522         signed char Class;
 523         /**
 524          * Message reference.
 525          */
 526         unsigned char MessageReference;
 527 } GSM_SMSMessage;
 528
 529 /* In layouts are saved locations for some SMS part. Below are listed
 530  * specs, which describe them
 531  *
 532  * \ingroup SMS
 533  */
 534 typedef struct {
 535         /**
 536          * TP-User-Data. GSM 03.40 section 9.2.3.24.
 537          */
 538         unsigned char Text;
 539         /**
 540          * - In SMS-Deliver:       TP-Originating-Address. GSM 03.40 section 9.2.3.7.
 541          * - In SMS-Submit:        TP-Destination-Address. GSM 03.40 section 9.2.3.8.
 542          * - In SMS-Status-Report: TP-Recipient-Address.   GSM 03.40 section 9.2.3.14.
 543          */
 544         unsigned char Number;
 545         /**
 546          * SMSC number
 547          */
 548         unsigned char SMSCNumber;
 549         /**
 550          * TP-Data-Coding-Scheme. GSM 03.40 section 9.2.3.10.
 551          * Contains alphabet type, SMS class (and some others)
 552          */
 553         unsigned char TPDCS;
 554         /**
 555          * - For SMS-Submit:        TP-Validity-Period. GSM 03.40 section 9.2.3.12.
 556          * - For SMS-Status-Report: TP-Discharge Time.  GSM 03.40 section 9.2.3.13.
 557          */
 558         unsigned char DateTime;
 559         /**
 560          * TP-Service-Centre-Time-Stamp in SMS-Status-Report. GSM 03.40 section 9.2.3.11.
 561          */
 562         unsigned char SMSCTime;
 563         /**
 564          * TP-Status in SMS-Status-Report. GSM 03.40 section 9.2.3.15.
 565          */
 566         unsigned char TPStatus;
 567         /**
 568          * TP-User-Data-Length. GSM 03.40 section 9.2.3.16.
 569          */
 570         unsigned char TPUDL;
 571         /**
 572          * TP-Validity Period in SMS-Submit. GSM 03.40 section 9.2.3.12.
 573          */
 574         unsigned char TPVP;
 575         /**
 576          * Byte contains in SMS-Deliver:
 577          * - TP-Message-Type-Indicator     (2 bits) GSM 03.40 section 9.2.3.1
 578          * - TP-More-Messages-To-Send      (1 bit). GSM 03.40 section 9.2.3.2
 579          * - TP-Reply-Path                 (1 bit). GSM 03.40 section 9.2.3.17
 580          * - TP-User-Data-Header-Indicator (1 bit). GSM 03.40 section 9.2.3.23
 581          * - TP-Status-Report-Indicator    (1 bit). GSM 03.40 section 9.2.3.4
 582          *
 583          * Byte contains in SMS-Submit:
 584          * - TP-Message-Type-Indicator     (2 bits) GSM 03.40 section 9.2.3.1
 585          * - TP-Reject-Duplicates          (1 bit). GSM 03.40 section
 586          * - TP-Validity-Period-Format     (2 bits).GSM 03.40 section 9.2.3.3
 587          * - TP-Reply-Path                 (1 bit). GSM 03.40 section 9.2.3.17
 588          * - TP-User-Data-Header-Indicator (1 bit). GSM 03.40 section 9.2.3.23
 589          * - TP-Status-Report-Request      (1 bit). GSM 03.40 section 9.2.3.5
 590          */
 591         unsigned char firstbyte;
 592         /**
 593          * TP-Message Reference in SMS-Submit. GSM 03.40 section 9.2.3.6
 594          */
 595         unsigned char TPMR;
 596         /**
 597          * TP-Protocol-Identifier. GSM 03.40 section 9.2.3.9
 598          */
 599         unsigned char TPPID;
 600 } GSM_SMSMessageLayout;
 601
 602 /**
 603  * Decodes PDU data.
 604  *
 605  * \param di Debug information structure.
 606  * \param SMS Pointer where to store parsed message.
 607  * \param buffer PDU data.
 608  * \param length Length of PDU data.
 609  * \param final_pos Optional pointer where end position will be stored.
 610  * \param SMSC Whether PDU includes SMSC data.
 611  *
 612  * \ingroup SMS
 613  */
 614 GSM_Error GSM_DecodePDUFrame(GSM_Debug_Info *di, GSM_SMSMessage *SMS,
 615                         const unsigned char *buffer, size_t length,
 616                         size_t *final_pos, gboolean SMSC);
 617
 618 /**
 619  * Decodes SMS frame.
 620  *
 621  * \ingroup SMS
 622  */
 623 GSM_Error GSM_DecodeSMSFrame(GSM_Debug_Info * di, GSM_SMSMessage * SMS,
 624                              unsigned char *buffer,
 625                              GSM_SMSMessageLayout Layout);
 626
 627 /**
 628  * Finds out coding type based on TPDCS header byte as defined by GSM
 629  * 03.38.
 630  */
 631 GSM_Coding_Type GSM_GetMessageCoding(GSM_Debug_Info * di, const char TPDCS);
 632
 633 /**
 634  * Encodes SMS frame.
 635  *
 636  * \ingroup SMS
 637  */
 638 GSM_Error GSM_EncodeSMSFrame(GSM_Debug_Info * di, GSM_SMSMessage * SMS,
 639                              unsigned char *buffer, GSM_SMSMessageLayout Layout,
 640                              int *length, gboolean clear);
 641
 642 /**
 643  * Decodes SMS frame for status report.
 644  *
 645  * \ingroup SMS
 646  */
 647 GSM_Error GSM_DecodeSMSFrameStatusReportData(GSM_Debug_Info * di,
 648                                              GSM_SMSMessage * SMS,
 649                                              unsigned char *buffer,
 650                                              GSM_SMSMessageLayout Layout);
 651
 652 /**
 653  * Decodes SMS frame in textual representation.
 654  *
 655  * \ingroup SMS
 656  */
 657 GSM_Error GSM_DecodeSMSFrameText(GSM_Debug_Info * di, GSM_SMSMessage * SMS,
 658                                  unsigned char *buffer,
 659                                  GSM_SMSMessageLayout Layout);
 660
 661 /**
 662  * Decodes UDH header.
 663  *
 664  * \ingroup SMS
 665  */
 666 void GSM_DecodeUDHHeader(GSM_Debug_Info * di, GSM_UDHHeader * UDH);
 667
 668 /**
 669  * Encodes UDH header.
 670  *
 671  * \ingroup SMS
 672  */
 673 void GSM_EncodeUDHHeader(GSM_Debug_Info * di, GSM_UDHHeader * UDH);
 674
 675 /**
 676  * Sets default content for SMS except for changing locations.
 677  * Use this for clearing structure while keeping location of message.
 678  *
 679  * \param SMS Pointer to structure which should be cleaned up.
 680  *
 681  * \ingroup SMS
 682  */
 683 void GSM_SetDefaultReceivedSMSData(GSM_SMSMessage * SMS);
 684
 685 /**
 686  * Sets default content for SMS. Use this for clearing structure.
 687  *
 688  * \param SMS Pointer to structure which should be cleaned up.
 689  *
 690  * \ingroup SMS
 691  */
 692 void GSM_SetDefaultSMSData(GSM_SMSMessage * SMS);
 693
 694 /**
 695  * Information about SMS folder.
 696  *
 697  * \ingroup SMS
 698  */
 699 typedef struct {
 700         /**
 701          * Whether it is inbox.
 702          */
 703         gboolean InboxFolder;
 704         /**
 705          * Whether it is outbox.
 706          */
 707         gboolean OutboxFolder;
 708         /**
 709          * Where exactly it's saved.
 710          */
 711         GSM_MemoryType Memory;
 712         /**
 713          * Name of the folder
 714          */
 715         unsigned char Name[(GSM_MAX_SMS_FOLDER_NAME_LEN + 1) * 2];
 716 } GSM_OneSMSFolder;
 717
 718 /**
 719  * List of SMS folders.
 720  *
 721  * \ingroup SMS
 722  */
 723 typedef struct {
 724         /**
 725          * Array of structures holding information about each folder.
 726          */
 727         GSM_OneSMSFolder Folder[GSM_MAX_SMS_FOLDERS];
 728         /**
 729          * Number of SMS folders.
 730          */
 731         int Number;
 732 } GSM_SMSFolders;
 733
 734 /**
 735  * Siemens OTA data.
 736  *
 737  * \ingroup SMS
 738  */
 739 typedef struct {
 740         unsigned long SequenceID;
 741         unsigned int PacketsNum;
 742         unsigned int PacketNum;
 743         unsigned long AllDataLen;
 744
 745         unsigned char DataType[10];
 746         unsigned char DataName[40];
 747         unsigned int DataLen;
 748         unsigned char Data[140];
 749 } GSM_SiemensOTASMSInfo;
 750
 751 /**
 752  * Decodes Siemens OTA data.
 753  *
 754  * \ingroup SMS
 755  */
 756 gboolean GSM_DecodeSiemensOTASMS(GSM_Debug_Info * di,
 757                              GSM_SiemensOTASMSInfo * Info,
 758                              GSM_SMSMessage * SMS);
 759
 760 /**
 761  * Multiple SMS messages, used for Smart Messaging 3.0/EMS.
 762  *
 763  * \ingroup SMS
 764  */
 765 typedef struct {
 766         /**
 767          * Number of messages.
 768          */
 769         int Number;
 770         /**
 771          * Array of SMSes.
 772          */
 773         GSM_SMSMessage SMS[GSM_MAX_MULTI_SMS];
 774 } GSM_MultiSMSMessage;
 775
 776 /**
 777  * Information about MMS folder.
 778  *
 779  * \ingroup MMS
 780  */
 781 typedef struct {
 782         /**
 783          * Whether it is really inbox.
 784          */
 785         gboolean InboxFolder;
 786         /**
 787          * Name for MMS folder.
 788          */
 789         char Name[(GSM_MAX_MMS_FOLDER_NAME_LEN + 1) * 2];
 790 } GSM_OneMMSFolder;
 791
 792 /**
 793  * List of MMS folders.
 794  *
 795  * \ingroup MMS
 796  */
 797 typedef struct {
 798         /**
 799          * Number of MMS folders.
 800          */
 801         unsigned char Number;
 802         /**
 803          * Array of structures holding information about each folder.
 804          */
 805         GSM_OneMMSFolder Folder[GSM_MAX_MMS_FOLDERS];
 806 } GSM_MMSFolders;
 807
 808 /**
 809  * Layout for submit message.
 810  *
 811  * \ingroup SMS
 812  */
 813 extern GSM_SMSMessageLayout PHONE_SMSSubmit;
 814
 815 /**
 816  * Layout for deliver message.
 817  *
 818  * \ingroup SMS
 819  */
 820 extern GSM_SMSMessageLayout PHONE_SMSDeliver;
 821
 822 /**
 823  * Layout for status report message.
 824  *
 825  * \ingroup SMS
 826  */
 827 extern GSM_SMSMessageLayout PHONE_SMSStatusReport;
 828
 829 /**
 830  * ID during packing SMS for Smart Messaging 3.0, EMS and other
 831  *
 832  * \ingroup SMS
 833  */
 834 typedef enum {
 835         /**
 836          * 1 text SMS.
 837          */
 838         SMS_Text = 1,
 839         /**
 840          * Contacenated SMS, when longer than 1 SMS.
 841          */
 842         SMS_ConcatenatedTextLong,
 843         /**
 844          * Contacenated SMS, auto Default/Unicode coding.
 845          */
 846         SMS_ConcatenatedAutoTextLong,
 847         SMS_ConcatenatedTextLong16bit,
 848         SMS_ConcatenatedAutoTextLong16bit,
 849         /**
 850          * Nokia profile = Name, Ringtone, ScreenSaver
 851          */
 852         SMS_NokiaProfileLong,
 853         /**
 854          * Nokia Picture Image + (text)
 855          */
 856         SMS_NokiaPictureImageLong,
 857         /**
 858          * Nokia screen saver + (text)
 859          */
 860         SMS_NokiaScreenSaverLong,
 861         /**
 862          * Nokia ringtone - old SM2.0 format, 1 SMS
 863          */
 864         SMS_NokiaRingtone,
 865         /**
 866          * Nokia ringtone contacenated, when very long
 867          */
 868         SMS_NokiaRingtoneLong,
 869         /**
 870          * Nokia 72x14 operator logo, 1 SMS
 871          */
 872         SMS_NokiaOperatorLogo,
 873         /**
 874          * Nokia 72x14 op logo or 78x21 in 2 SMS
 875          */
 876         SMS_NokiaOperatorLogoLong,
 877         /**
 878          * Nokia 72x14 caller logo, 1 SMS
 879          */
 880         SMS_NokiaCallerLogo,
 881         /**
 882          * Nokia WAP bookmark in 1 or 2 SMS
 883          */
 884         SMS_NokiaWAPBookmarkLong,
 885         /**
 886          * Nokia WAP settings in 2 SMS
 887          */
 888         SMS_NokiaWAPSettingsLong,
 889         /**
 890          * Nokia MMS settings in 2 SMS
 891          */
 892         SMS_NokiaMMSSettingsLong,
 893         /**
 894          * Nokia VCARD 1.0 - only name and default number
 895          */
 896         SMS_NokiaVCARD10Long,
 897         /**
 898          * Nokia VCARD 2.1 - all numbers + text
 899          */
 900         SMS_NokiaVCARD21Long,
 901         /**
 902          * Nokia VCALENDAR 1.0 - can be in few sms
 903          */
 904         SMS_NokiaVCALENDAR10Long,
 905         SMS_NokiaVTODOLong,
 906         SMS_VCARD10Long,
 907         SMS_VCARD21Long,
 908         SMS_DisableVoice,
 909         SMS_DisableFax,
 910         SMS_DisableEmail,
 911         SMS_EnableVoice,
 912         SMS_EnableFax,
 913         SMS_EnableEmail,
 914         SMS_VoidSMS,
 915         /**
 916          * IMelody 1.0
 917          */
 918         SMS_EMSSound10,
 919         /**
 920          * IMelody 1.2
 921          */
 922         SMS_EMSSound12,
 923         /**
 924          * IMelody without header - SonyEricsson extension
 925          */
 926         SMS_EMSSonyEricssonSound,
 927         /**
 928          * IMelody 1.0 with UPI.
 929          */
 930         SMS_EMSSound10Long,
 931         /**
 932          * IMelody 1.2 with UPI.
 933          */
 934         SMS_EMSSound12Long,
 935         /**
 936          * IMelody without header with UPI.
 937          */
 938         SMS_EMSSonyEricssonSoundLong,
 939         SMS_EMSPredefinedSound,
 940         SMS_EMSPredefinedAnimation,
 941         SMS_EMSAnimation,
 942         /**
 943          * Fixed bitmap of size 16x16 or 32x32.
 944          */
 945         SMS_EMSFixedBitmap,
 946         SMS_EMSVariableBitmap,
 947         SMS_EMSVariableBitmapLong,
 948         /**
 949          * MMS message indicator.
 950          */
 951         SMS_MMSIndicatorLong,
 952         SMS_WAPIndicatorLong,
 953         /**
 954          * Variable bitmap with black and white colors
 955          */
 956         SMS_AlcatelMonoBitmapLong,
 957         /**
 958          * Variable animation with black and white colors
 959          */
 960         SMS_AlcatelMonoAnimationLong,
 961         SMS_AlcatelSMSTemplateName,
 962         /**
 963          * Siemens OTA
 964          */
 965         SMS_SiemensFile
 966 } EncodeMultiPartSMSID;
 967
 968 /**
 969  * Entry of multipart SMS.
 970  *
 971  * \ingroup SMS
 972  */
 973 typedef struct {
 974         EncodeMultiPartSMSID ID;
 975
 976         int Number;
 977         GSM_Ringtone *Ringtone;
 978         GSM_MultiBitmap *Bitmap;
 979         GSM_WAPBookmark *Bookmark;
 980         GSM_WAPSettings *Settings;
 981         GSM_MMSIndicator *MMSIndicator;
 982         GSM_MemoryEntry *Phonebook;
 983         GSM_CalendarEntry *Calendar;
 984         GSM_ToDoEntry *ToDo;
 985         GSM_File *File;
 986         gboolean Protected;
 987
 988         unsigned char *Buffer;
 989         gboolean Left;
 990         gboolean Right;
 991         gboolean Center;
 992         gboolean Large;
 993         gboolean Small;
 994         gboolean Bold;
 995         gboolean Italic;
 996         gboolean Underlined;
 997         gboolean Strikethrough;
 998
 999         /* Return values */
1000         int RingtoneNotes;
1001 } GSM_MultiPartSMSEntry;
1002
1003 /**
1004  * Multipart SMS information.
1005  *
1006  * \ingroup SMS
1007  */
1008 typedef struct {
1009         int EntriesNum;
1010         gboolean UnicodeCoding;
1011         int Class;
1012         unsigned char ReplaceMessage;
1013         gboolean Unknown;
1014         GSM_MultiPartSMSEntry Entries[GSM_MAX_MULTI_SMS];
1015 } GSM_MultiPartSMSInfo;
1016
1017 /**
1018  * Encodes SMS frame according to layout.
1019  *
1020  * \return Error code.
1021  *
1022  * \ingroup SMS
1023  */
1024 GSM_Error PHONE_EncodeSMSFrame(GSM_StateMachine * s, GSM_SMSMessage * SMS,
1025                                unsigned char *buffer,
1026                                GSM_SMSMessageLayout Layout, int *length,
1027                                gboolean clear);
1028
1029 /**
1030  * Encodes multi part SMS from "readable" format.
1031  *
1032  * \return Error code.
1033  *
1034  * \ingroup SMS
1035  */
1036 GSM_Error GSM_EncodeMultiPartSMS(GSM_Debug_Info * di,
1037                                  GSM_MultiPartSMSInfo * Info,
1038                                  GSM_MultiSMSMessage * SMS);
1039
1040 /**
1041  * Decodes multi part SMS to "readable" format.
1042  *
1043  * \ingroup SMS
1044  */
1045 gboolean GSM_DecodeMultiPartSMS(GSM_Debug_Info * di,
1046                             GSM_MultiPartSMSInfo * Info,
1047                             GSM_MultiSMSMessage * SMS, gboolean ems);
1048
1049 /**
1050  * Clears @ref GSM_MultiPartSMSInfo to default values.
1051  *
1052  * \ingroup SMS
1053  */
1054 void GSM_ClearMultiPartSMSInfo(GSM_MultiPartSMSInfo * Info);
1055
1056 /**
1057  * Frees any allocated structures inside @ref GSM_MultiPartSMSInfo.
1058  *
1059  * \ingroup SMS
1060  */
1061 void GSM_FreeMultiPartSMSInfo(GSM_MultiPartSMSInfo * Info);
1062
1063 /**
1064  * Links SMS messages according to IDs.
1065  *
1066  * \return Error code.
1067  *
1068  * \ingroup SMS
1069  */
1070 GSM_Error GSM_LinkSMS(GSM_Debug_Info * di,
1071                       GSM_MultiSMSMessage ** INPUT,
1072                       GSM_MultiSMSMessage ** OUTPUT, gboolean ems);
1073
1074 /**
1075  * MMS address type.
1076  *
1077  * \ingroup MMS
1078  */
1079 typedef enum {
1080         MMSADDRESS_PHONE,
1081         MMSADDRESS_UNKNOWN
1082 } MMSAddressType;
1083
1084 /**
1085  * MMS entry.
1086  *
1087  * \ingroup MMS
1088  */
1089 typedef struct {
1090         GSM_File File;
1091         /**
1092          * CT in Unicode
1093          */
1094         unsigned char ContentType[400];
1095         /**
1096          * Smil ID in Unicode
1097          */
1098         unsigned char SMIL[400];
1099 } GSM_EncodedMultiPartMMSEntry;
1100
1101 /**
1102  * MMS part.
1103  *
1104  * \ingroup MMS
1105  */
1106 typedef struct {
1107         int EntriesNum;
1108
1109         /**
1110          * in Unicode
1111          */
1112         unsigned char Source[200];
1113         MMSAddressType SourceType;
1114         /**
1115          * in Unicode
1116          */
1117         unsigned char Destination[200];
1118         MMSAddressType DestinationType;
1119         /**
1120          * in Unicode
1121          */
1122         unsigned char CC[200];
1123         MMSAddressType CCType;
1124
1125         /**
1126          * in Unicode
1127          */
1128         unsigned char Subject[200];
1129         /**
1130          * CT in Unicode
1131          */
1132         unsigned char ContentType[400];
1133         /**
1134          * no Unicode
1135          */
1136         unsigned char MSGType[50];
1137
1138         gboolean DateTimeAvailable;
1139         GSM_DateTime DateTime;
1140
1141         gboolean MMSReportAvailable;
1142         gboolean MMSReport;
1143         /**
1144          * Subparts.
1145          */
1146         GSM_EncodedMultiPartMMSEntry Entries[GSM_MAX_MULTI_MMS];
1147 } GSM_EncodedMultiPartMMSInfo;
1148
1149 /**
1150  * Decodes MMS data.
1151  *
1152  * \ingroup MMS
1153  */
1154 GSM_Error GSM_DecodeMMSFileToMultiPart(GSM_Debug_Info * di, GSM_File * file,
1155                                        GSM_EncodedMultiPartMMSInfo * info);
1156
1157 /**
1158  * Clears MMS data, used to initialize structure.
1159  *
1160  * \ingroup MMS
1161  */
1162 GSM_Error GSM_ClearMMSMultiPart(GSM_EncodedMultiPartMMSInfo * info);
1163
1164 /**
1165  * Gets SMS Service Center number and SMS settings.
1166  *
1167  * \param s State machine pointer.
1168  * \param[in,out] smsc SMSC structure, should contain location.
1169  *
1170  * \return Error code.
1171  *
1172  * \ingroup SMS
1173  */
1174 GSM_Error GSM_GetSMSC(GSM_StateMachine * s, GSM_SMSC * smsc);
1175
1176 /**
1177  * Sets SMS Service Center number and SMS settings.
1178  *
1179  * \param s State machine pointer.
1180  * \param[in] smsc SMSC structure.
1181  *
1182  * \return Error code.
1183  *
1184  * \ingroup SMS
1185  */
1186 GSM_Error GSM_SetSMSC(GSM_StateMachine * s, GSM_SMSC * smsc);
1187
1188 /**
1189  * Gets information about SMS memory (read/unread/size of memory for
1190  * both SIM and phone).
1191  *
1192  * \param s State machine pointer.
1193  * \param[out] status Pointer to SMS status structure.
1194  *
1195  * \return Error code.
1196  *
1197  * \ingroup SMS
1198  */
1199 GSM_Error GSM_GetSMSStatus(GSM_StateMachine * s, GSM_SMSMemoryStatus * status);
1200
1201 /**
1202  * Reads SMS message.
1203  *
1204  * \param s State machine pointer.
1205  * \param[in,out] sms SMS message data read from phone, location and
1206  * folder should be set.
1207  *
1208  * \return Error code.
1209  *
1210  * \ingroup SMS
1211  */
1212 GSM_Error GSM_GetSMS(GSM_StateMachine * s, GSM_MultiSMSMessage * sms);
1213
1214 /**
1215  * Reads next (or first if start set) SMS message. This might be
1216  * faster for some phones than using \ref GSM_GetSMS for each message.
1217  *
1218  * Please note that this commend does not have to mark message as read
1219  * in phone. To do so, you have to call \ref GSM_GetSMS.
1220  *
1221  * \param s State machine pointer.
1222  * \param[in,out] sms SMS message data read from phone, for subsequent
1223  * reads, location and folder might be used by phone driver to determine
1224  * reading state.
1225  * \param[in] start Whether we start reading from beginning.
1226  *
1227  * \return Error code.
1228  *
1229  * \ingroup SMS
1230  */
1231 GSM_Error GSM_GetNextSMS(GSM_StateMachine * s, GSM_MultiSMSMessage * sms,
1232                          gboolean start);
1233 /**
1234  * Sets SMS.
1235  *
1236  * \param s State machine pointer.
1237  * \param[in] sms SMS message data.
1238  *
1239  * \return Error code.
1240  *
1241  * \ingroup SMS
1242  */
1243 GSM_Error GSM_SetSMS(GSM_StateMachine * s, GSM_SMSMessage * sms);
1244
1245 /**
1246  * Adds SMS to specified folder.
1247  *
1248  * \param s State machine pointer.
1249  * \param[in,out] sms SMS message data, location will be updated.
1250  *
1251  * \return Error code.
1252  *
1253  * \ingroup SMS
1254  */
1255 GSM_Error GSM_AddSMS(GSM_StateMachine * s, GSM_SMSMessage * sms);
1256
1257 /**
1258  * Deletes SMS.
1259  *
1260  * \param s State machine pointer.
1261  * \param[in] sms SMS structure with SMS location and folder.
1262  *
1263  * \return Error code.
1264  *
1265  * \ingroup SMS
1266  */
1267 GSM_Error GSM_DeleteSMS(GSM_StateMachine * s, GSM_SMSMessage * sms);
1268
1269 /**
1270  * Sends SMS.
1271  *
1272  * \param s State machine pointer.
1273  * \param[in] sms SMS structure with SMS data to send.
1274  *
1275  * \return Error code.
1276  *
1277  * \ingroup SMS
1278  */
1279 GSM_Error GSM_SendSMS(GSM_StateMachine * s, GSM_SMSMessage * sms);
1280
1281 /**
1282  * Sends SMS already saved in phone.
1283  *
1284  * \param s State machine pointer.
1285  * \param[in] Folder Folder, where message is stored.
1286  * \param[in] Location Location, where message is stored.
1287  *
1288  * \return Error code.
1289  *
1290  * \ingroup SMS
1291  */
1292 GSM_Error GSM_SendSavedSMS(GSM_StateMachine * s, int Folder, int Location);
1293
1294 /**
1295  * Configures fast SMS sending.
1296  *
1297  * \param s State machine pointer.
1298  * \param[in] enable Whether to enable notifications.
1299  *
1300  * \return Error code.
1301  *
1302  * \ingroup SMS
1303  */
1304 GSM_Error GSM_SetFastSMSSending(GSM_StateMachine * s, gboolean enable);
1305
1306 /**
1307  * Enable/disable notification on incoming SMS.
1308  *
1309  * \param s State machine pointer.
1310  * \param[in] enable Whether to enable notifications.
1311  *
1312  * \return Error code.
1313  *
1314  * \ingroup SMS
1315  */
1316 GSM_Error GSM_SetIncomingSMS(GSM_StateMachine * s, gboolean enable);
1317
1318 /**
1319  * Gets network information from phone.
1320  *
1321  * \param s State machine pointer.
1322  * \param[in] enable Whether to enable notifications.
1323  *
1324  * \return Error code.
1325  *
1326  * \ingroup CB
1327  */
1328 GSM_Error GSM_SetIncomingCB(GSM_StateMachine * s, gboolean enable);
1329
1330 /**
1331  * Returns SMS folders information.
1332  *
1333  * \param s State machine pointer.
1334  * \param[out] folders folders Pointer to folders structure, which will be
1335  * filled in.
1336  *
1337  * \return Error code.
1338  *
1339  * \ingroup SMS
1340  */
1341 GSM_Error GSM_GetSMSFolders(GSM_StateMachine * s, GSM_SMSFolders * folders);
1342
1343 /**
1344  * Creates SMS folder.
1345  *
1346  * \param s State machine pointer.
1347  * \param[in] name Name of SMS folder which should be created.
1348  *
1349  * \return Error code.
1350  *
1351  * \ingroup SMS
1352  */
1353 GSM_Error GSM_AddSMSFolder(GSM_StateMachine * s, unsigned char *name);
1354
1355 /**
1356  * Deletes SMS folder.
1357  *
1358  * \param s State machine pointer.
1359  * \param[in] ID ID of SMS folder to delete.
1360  *
1361  * \return Error code.
1362  *
1363  * \ingroup SMS
1364  */
1365 GSM_Error GSM_DeleteSMSFolder(GSM_StateMachine * s, int ID);
1366
1367 /**
1368  * Lists MMS folders.
1369  *
1370  * \param s State machine pointer.
1371  * \param folders Pointer to structure, whehe folder information will be
1372  * stored.
1373  *
1374  * \return Error code.
1375  *
1376  * \ingroup MMS
1377  */
1378 GSM_Error GSM_GetMMSFolders(GSM_StateMachine * s, GSM_MMSFolders * folders);
1379
1380 /**
1381  * Retrieves next part of MMS file information.
1382  *
1383  * \param s State machine pointer.
1384  * \param[in,out] FileID File ID will be stored here, might be
1385  * used for consequent reads.
1386  * \param[in,out] MMSFolder MMS folder ID will be stored here, might be
1387  * used for consequent reads.
1388  * \param[in] start Whether to start reading.
1389  *
1390  * \return Error code.
1391  *
1392  * \ingroup MMS
1393  */
1394 GSM_Error GSM_GetNextMMSFileInfo(GSM_StateMachine * s, unsigned char *FileID,
1395                                  int *MMSFolder, gboolean start);
1396 /**
1397  * Activates/deactivates noticing about incoming USSDs (UnStructured Supplementary Services).
1398  *
1399  * \param s State machine pointer.
1400  * \param[in] enable Whether to enable notifications.
1401  *
1402  * \return Error code.
1403  *
1404  * \ingroup USSD
1405  */
1406 GSM_Error GSM_SetIncomingUSSD(GSM_StateMachine * s, gboolean enable);
1407
1408 /**
1409  * Calculates number of messages and free chars needed for text.
1410  *
1411  * \param di Debug settings.
1412  * \param[in] MessageBuffer Actual message text in unicode.
1413  * \param[in] UDHType UDH type.
1414  * \param[in] Coding GSM Encoding type.
1415  * \param[out] SMSNum Number of messages needed to store the text.
1416  * \param[out] CharsLeft Number of free chars in the message.
1417  *
1418  * \ingroup SMS
1419  */
1420 void GSM_SMSCounter(GSM_Debug_Info *di, unsigned char *MessageBuffer,
1421         GSM_UDH UDHType, GSM_Coding_Type Coding, int *SMSNum, size_t *CharsLeft);
1422
1423 #endif
1424
1425 /* Editor configuration
1426  * vim: noexpandtab sw=8 ts=8 sts=8 tw=72:
1427  */