114643df2303f123330119c803aeca2d81d92dbb
[gnokii.git] / common / gsm-sms.c
1 /*
2
3   $Id$
4
5   G N O K I I
6
7   A Linux/Unix toolset and driver for Nokia mobile phones.
8
9   Copyright (C) 2001 Pawe¬≥ Kot <pkot@linuxnews.pl>
10
11   Released under the terms of the GNU GPL, see file COPYING for more details.
12
13   Library for parsing and creating Short Messages (SMS).
14
15   $Log$
16   Revision 1.1.1.2  2001/11/27 22:01:13  short
17   :pserver:cvs@pserver.samba.org:/cvsroot - gnokii - Tue Nov 27 22:58 CET 2001
18
19   Revision 1.14  2001/11/27 12:19:00  pkot
20   Cleanup, indentation, ANSI complaint preprocesor symbols (Jan Kratochvil, me)
21
22   Revision 1.13  2001/11/23 22:07:44  machek
23   Fix SMS receiving to work, again. Unfortunately, it is not possible to
24   reuse much of gsm-sms.c...
25
26   Revision 1.12  2001/11/22 17:56:53  pkot
27   smslib update. sms sending
28
29   Revision 1.11  2001/11/20 16:22:22  pkot
30   First attempt to read Picture Messages. They should appear when you enable DEBUG. Nokia seems to break own standards. :/ (Markus Plail)
31
32   Revision 1.10  2001/11/19 13:09:40  pkot
33   Begin work on sms sending
34
35   Revision 1.9  2001/11/18 00:54:32  pkot
36   Bugfixes. I18n of the user responses. UDH support in libsms. Business Card UDH Type
37
38   Revision 1.8  2001/11/17 20:19:29  pkot
39   smslib cleanups, fixes and debugging
40
41   Revision 1.7  2001/11/15 12:15:04  pkot
42   smslib updates. begin work on sms in 6100 series
43
44   Revision 1.6  2001/11/14 18:21:19  pkot
45   Fixing some problems with UDH and Unicode, but still doesn't work yet :-(
46
47   Revision 1.5  2001/11/14 14:26:18  pkot
48   Changed offset of DCS field to the right value in 6210/7110
49
50   Revision 1.4  2001/11/14 11:26:18  pkot
51   Getting SMS in 6210/7110 does finally work in some cases :)
52
53   Revision 1.3  2001/11/13 16:12:20  pkot
54   Preparing libsms to get to work. 6210/7110 SMS and SMS Folder updates
55
56   Revision 1.2  2001/11/09 14:25:04  pkot
57   DEBUG cleanups
58
59   Revision 1.1  2001/11/08 16:23:21  pkot
60   New version of libsms. Not functional yet, but it reasonably stable API.
61
62   Revision 1.1  2001/07/09 23:06:26  pkot
63   Moved sms.* files from my hard disk to CVS
64
65 */
66
67 #include <stdlib.h>
68 #include <string.h>
69
70 #include "gsm-common.h"
71 #include "gsm-encoding.h"
72 #include "gsm-bitmaps.h"
73
74 struct udh_data {
75         unsigned int length;
76         char *header;
77 };
78
79 /* Number of header specific octets in SMS header (before data) */
80 static unsigned short DataOffset[] = {
81         4, /* SMS Deliver */
82         3, /* SMS Deliver Report */
83         5, /* SMS Submit */
84         3, /* SMS Submit Report */
85         3, /* SMS Command */
86         3  /* SMS Status Report */
87 };
88
89 /* User data headers */
90 static struct udh_data headers[] = {
91         { 0x00, "" },
92         { 0x05, "\x00\x03\x01\x00\x00" },     /* Concatenated messages */
93         { 0x06, "\x05\x04\x15\x82\x00\x00" }, /* Operator logos */
94         { 0x06, "\x05\x04\x15\x83\x00\x00" }, /* Caller logos */
95         { 0x06, "\x05\x04\x15\x81\x00\x00" }, /* Ringtones */
96         { 0x04, "\x03\x01\x00\x00" },         /* Voice Messages */
97         { 0x04, "\x03\x01\x01\x00" },         /* Fax Messages */
98         { 0x04, "\x03\x01\x02\x00" },         /* Email Messages */
99         { 0x06, "\x05\x04\x23\xf4\x00\x00" }, /* Business Card */
100         { 0x00, "" }
101 };
102
103
104 /***
105  *** Util functions
106  ***/
107
108 /* This function implements packing of numbers (SMS Center number and
109    destination number) for SMS sending function. */
110 static int SemiOctetPack(char *Number, unsigned char *Output, SMS_NumberType type)
111 {
112         unsigned char *IN = Number;  /* Pointer to the input number */
113         unsigned char *OUT = Output; /* Pointer to the output */
114         int count = 0; /* This variable is used to notify us about count of already
115                           packed numbers. */
116
117         /* The first byte in the Semi-octet representation of the address field is
118            the Type-of-Address. This field is described in the official GSM
119            specification 03.40 version 6.1.0, section 9.1.2.5, page 33. We support
120            only international and unknown number. */
121
122         *OUT++ = type;
123         if (type == SMS_International) IN++; /* Skip '+' */
124         if ((type == SMS_Unknown) && (*IN == '+')) IN++; /* Optional '+' in Unknown number type */
125
126         /* The next field is the number. It is in semi-octet representation - see
127            GSM scpecification 03.40 version 6.1.0, section 9.1.2.3, page 31. */
128         while (*IN) {
129                 if (count & 0x01) {
130                         *OUT = *OUT | ((*IN - '0') << 4);
131                         OUT++;
132                 }
133                 else
134                         *OUT = *IN - '0';
135                 count++; IN++;
136         }
137
138         /* We should also fill in the most significant bits of the last byte with
139            0x0f (1111 binary) if the number is represented with odd number of
140            digits. */
141         if (count & 0x01) {
142                 *OUT = *OUT | 0xf0;
143                 OUT++;
144         }
145
146         return (2 * (OUT - Output - 1) - (count % 2));
147 }
148
149 char *GetBCDNumber(u8 *Number)
150 {
151         static char Buffer[20] = "";
152         int length = Number[0]; /* This is the length of BCD coded number */
153         int count, Digit;
154
155         memset(Buffer, 0, 20);
156         switch (Number[1]) {
157         case SMS_Alphanumeric:
158                 Unpack7BitCharacters(0, length, length, Number+2, Buffer);
159                 Buffer[length] = 0;
160                 break;
161         case SMS_International:
162                 sprintf(Buffer, "+");
163         case SMS_Unknown:
164         case SMS_National:
165         case SMS_Network:
166         case SMS_Subscriber:
167         case SMS_Abbreviated:
168         default:
169                 for (count = 0; count < length - 1; count++) {
170                         Digit = Number[count+2] & 0x0f;
171                         if (Digit < 10) sprintf(Buffer, "%s%d", Buffer, Digit);
172                         Digit = Number[count+2] >> 4;
173                         if (Digit < 10) sprintf(Buffer, "%s%d", Buffer, Digit);
174                 }
175                 break;
176         }
177         return Buffer;
178 }
179
180 static char *PrintDateTime(u8 *Number) 
181 {
182         static char Buffer[23] = "";
183
184         memset(Buffer, 0, 23);
185         if (Number[0] < 70) sprintf(Buffer, "20");
186         else sprintf(Buffer, "19");
187         sprintf(Buffer, "%s%d%d-", Buffer, Number[0] & 0x0f, Number[0] >> 4);
188         sprintf(Buffer, "%s%d%d-", Buffer, Number[1] & 0x0f, Number[1] >> 4);
189         sprintf(Buffer, "%s%d%d ", Buffer, Number[2] & 0x0f, Number[2] >> 4);
190         sprintf(Buffer, "%s%d%d:", Buffer, Number[3] & 0x0f, Number[3] >> 4);
191         sprintf(Buffer, "%s%d%d:", Buffer, Number[4] & 0x0f, Number[4] >> 4);
192         sprintf(Buffer, "%s%d%d",  Buffer, Number[5] & 0x0f, Number[5] >> 4);
193         if (Number[6] & 0x08) 
194                 sprintf(Buffer, "%s-", Buffer);
195         else
196                 sprintf(Buffer, "%s+", Buffer);
197         sprintf(Buffer, "%s%02d00", Buffer, (10 * (Number[6] & 0x07) + (Number[6] >> 4)) / 4);
198
199         return Buffer;
200 }
201
202 SMS_DateTime *UnpackDateTime(u8 *Number, SMS_DateTime *dt)
203 {
204         dt->Year     =  10 * (Number[0] & 0x0f) + (Number[0] >> 4);
205         if (dt->Year < 70) dt->Year += 2000;
206         else dt->Year += 1900;
207         dt->Month    =  10 * (Number[1] & 0x0f) + (Number[1] >> 4);
208         dt->Day      =  10 * (Number[2] & 0x0f) + (Number[2] >> 4);
209         dt->Hour     =  10 * (Number[3] & 0x0f) + (Number[3] >> 4);
210         dt->Minute   =  10 * (Number[4] & 0x0f) + (Number[4] >> 4);
211         dt->Second   =  10 * (Number[5] & 0x0f) + (Number[5] >> 4);
212         dt->Timezone = (10 * (Number[6] & 0x07) + (Number[6] >> 4)) / 4;
213         if (Number[6] & 0x08) dt->Timezone = -dt->Timezone;
214
215         return dt;
216 }
217
218 /***
219  *** ENCODING SMS
220  ***/
221
222 static GSM_Error EncodeData(GSM_SMSMessage *SMS, char *dcs, char *message)
223 {
224         SMS_AlphabetType al;
225         unsigned short length = strlen(SMS->MessageText);
226
227         switch (SMS->DCS.Type) {
228         case SMS_GeneralDataCoding:
229                 switch (SMS->DCS.u.General.Class) {
230                 case 1: dcs[0] |= 0xf0; break;
231                 case 2: dcs[0] |= 0xf1; break;
232                 case 3: dcs[0] |= 0xf2; break;
233                 case 4: dcs[0] |= 0xf3; break;
234                 default: break;
235                 }
236                 if (SMS->DCS.u.General.Compressed) {
237                         /* Compression not supported yet */
238                         /* dcs[0] |= 0x20; */
239                 }
240                 al = SMS->DCS.u.General.Alphabet;
241                 break;
242         case SMS_MessageWaiting:
243                 al = SMS->DCS.u.MessageWaiting.Alphabet;
244                 if (SMS->DCS.u.MessageWaiting.Discard) dcs[0] |= 0xc0;
245                 else if (SMS->DCS.u.MessageWaiting.Alphabet == SMS_UCS2) dcs[0] |= 0xe0;
246                 else dcs[0] |= 0xd0;
247
248                 if (SMS->DCS.u.MessageWaiting.Active) dcs[0] |= 0x08;
249                 dcs[0] |= (SMS->DCS.u.MessageWaiting.Type & 0x03);
250
251                 break;
252         default:
253                 return GE_SMSWRONGFORMAT;
254         }
255         switch (al) {
256         case SMS_DefaultAlphabet:
257                 Pack7BitCharacters((7 - (SMS->UDH_Length % 7)) % 7, SMS->MessageText, message);
258                 SMS->Length = 8 * SMS->UDH_Length + (7 - (SMS->UDH_Length % 7)) % 7 + length;
259                 break;
260         case SMS_8bit:
261                 dcs[0] |= 0xf4;
262                 memcpy(message, SMS->MessageText + 1, SMS->MessageText[0]);
263                 SMS->Length = SMS->UDH_Length + SMS->MessageText[0];
264                 break;
265         case SMS_UCS2:
266                 dcs[0] |= 0x08;
267                 EncodeUnicode(message, SMS->MessageText, length);
268                 SMS->Length = length;
269                 break;
270         default:
271                 return GE_SMSWRONGFORMAT;
272         }
273         return GE_NONE;
274 }
275
276 /* This function encodes the UserDataHeader as described in:
277    - GSM 03.40 version 6.1.0 Release 1997, section 9.2.3.24
278    - Smart Messaging Specification, Revision 1.0.0, September 15, 1997
279 */
280 static GSM_Error EncodeUDH(SMS_UDHInfo UDHi, char *UDH)
281 {
282         unsigned char pos;
283
284         pos = UDH[0];
285         switch (UDHi.Type) {
286         case SMS_NoUDH:
287                 break;
288         case SMS_VoiceMessage:
289         case SMS_FaxMessage:
290         case SMS_EmailMessage:
291                 UDH[pos+4] = UDHi.u.SpecialSMSMessageIndication.MessageCount;
292                 if (UDHi.u.SpecialSMSMessageIndication.Store) UDH[pos+3] |= 0x80;
293         case SMS_ConcatenatedMessages:
294         case SMS_OpLogo:
295         case SMS_CallerIDLogo:
296         case SMS_Ringtone:
297                 UDH[0] += headers[UDHi.Type].length;
298                 memcpy(UDH+pos+1, headers[UDHi.Type].header, headers[UDHi.Type].length);
299                 break;
300         default:
301                 dprintf("Not supported User Data Header type\n");
302                 break;
303         }
304         return GE_NONE;
305 }
306
307 static GSM_Error EncodeSMSSubmitHeader(GSM_SMSMessage *SMS, char *frame)
308 {
309         GSM_Error error = GE_NONE;
310
311         /* Standard Header: */
312         memcpy(frame, "\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x00", 24);
313
314         /* Reply Path */
315         if (SMS->ReplyViaSameSMSC) frame[0] |= 0x80;
316
317         /* User Data Header Indicator */
318         if (SMS->UDH_No) frame[0] |= 0x40;
319
320         /* Status (Delivery) Report Request */
321         if (SMS->ReportStatus) frame[0] |= 0x20;
322
323         /* Validity Period Format: mask - 0x00, 0x10, 0x08, 0x18 */
324         frame[0] |= ((SMS->Validity.VPF & 0x03) << 3);
325
326         /* Reject Duplicates */
327         if (SMS->RejectDuplicates) frame[0] |= 0x04;
328
329         /* Message Type is already set */
330
331         /* Message Reference */
332         /* Can we set this? */
333
334         /* Protocol Identifier */
335         /* FIXME: allow to change this in better way.
336            currently only 0x5f == `Return Call Message' is used */
337         if (SMS->PID) frame[3] = SMS->PID;
338
339         /* Data Coding Scheme */
340         switch (SMS->DCS.Type) {
341         case SMS_GeneralDataCoding:
342                 if (SMS->DCS.u.General.Compressed) frame[4] |= 0x20;
343                 if (SMS->DCS.u.General.Class) frame[4] |= (0x10 | (SMS->DCS.u.General.Class - 1));
344                 frame[4] |= ((SMS->DCS.u.General.Alphabet & 0x03) << 2);
345                 break;
346         case SMS_MessageWaiting:
347                 if (SMS->DCS.u.MessageWaiting.Discard) frame[4] |= 0xc0;
348                 else if (SMS->DCS.u.MessageWaiting.Alphabet == SMS_UCS2) frame[4] |= 0xe0;
349                 else frame[4] |= 0xd0;
350                 if (SMS->DCS.u.MessageWaiting.Active) frame[4] |= 0x80;
351                 frame[4] |= (SMS->DCS.u.MessageWaiting.Type & 0x03);
352                 break;
353         default:
354                 dprintf("Wrong Data Coding Scheme (DCS) format\n");
355                 return GE_SMSWRONGFORMAT;
356         }
357
358         /* Destination Address */
359         frame[5] = SemiOctetPack(SMS->RemoteNumber.number, frame + 6, SMS->RemoteNumber.type);
360
361         /* Validity Period */
362         switch (SMS->Validity.VPF) {
363         case SMS_EnhancedFormat:
364                 break;
365         case SMS_RelativeFormat:
366                 break;
367         case SMS_AbsoluteFormat:
368                 break;
369         default:
370                 break;
371         }
372
373         return error;
374 }
375
376 static GSM_Error EncodeSMSDeliverHeader()
377 {
378         return GE_NONE;
379 }
380
381 static GSM_Error EncodeSMSHeader(GSM_SMSMessage *SMS, char *frame)
382 /* We can create either SMS DELIVER (for saving in Inbox) or SMS SUBMIT
383    (for sending or saving in Outbox) message */
384 {
385         /* Set SMS type */
386         frame[12] |= (SMS->Type >> 1);
387         switch (SMS->Type) {
388         case SMS_Submit: /* we send SMS or save it in Outbox */
389                 return EncodeSMSSubmitHeader(SMS, frame);
390         case SMS_Deliver: /* we save SMS in Inbox */
391                 return EncodeSMSDeliverHeader(SMS, frame);
392         default: /* we don't create other formats of SMS */
393                 return GE_SMSWRONGFORMAT;
394         }
395 }
396
397 /* This function encodes SMS as described in:
398    - GSM 03.40 version 6.1.0 Release 1997, section 9
399 */
400 int EncodePDUSMS(GSM_SMSMessage *SMS, char *message)
401 {
402         GSM_Error error = GE_NONE;
403         int i;
404
405         dprintf("Sending SMS to %s via message center %s\n", SMS->RemoteNumber.number, SMS->MessageCenter.Number);
406
407         /* SMSC number */
408         dprintf("%d %s\n", SMS->MessageCenter.Type, SMS->MessageCenter.Number);
409         message[0] = SemiOctetPack(SMS->MessageCenter.Number, message + 1, SMS->MessageCenter.Type);
410         if (message[0] % 2) message[0]++;
411         message[0] = message[0] / 2 + 1;
412
413         /* Common Header */
414         error = EncodeSMSHeader(SMS, message + 12);
415         if (error != GE_NONE) return error;
416
417         /* User Data Header - if present */
418 //      for (i = 0; i < SMS->UDH_No; i++) {
419 //              error = EncodeUDH(SMS->UDH[i], message + 24);
420 //              if (error != GE_NONE) return error;
421 //      }
422         SMS->UDH_Length = 0;
423
424         /* User Data */
425         EncodeData(SMS, message + 14, message + 36 + SMS->UDH_Length);
426         message[16] = SMS->Length;
427         return SMS->Length + 35;
428 }
429
430 /* This function does simple SMS encoding - no PDU coding */
431 GSM_Error EncodeTextSMS()
432 {
433         return GE_NONE;
434 }
435
436 /***
437  *** DECODING SMS
438  ***/
439
440 static GSM_Error SMSStatus(unsigned char status, GSM_SMSMessage *SMS)
441 {
442         if (status < 0x03) {
443                 strcpy(SMS->MessageText, _("Delivered"));
444                 switch (status) {
445                 case 0x00:
446                         dprintf("SM received by the SME");
447                         break;
448                 case 0x01:
449                         dprintf("SM forwarded by the SC to the SME but the SC is unable to confirm delivery");
450                         break;
451                 case 0x02:
452                         dprintf("SM replaced by the SC");
453                         break;
454                 }
455                 SMS->Length = strlen(_("Delivered"));
456         } else if (status & 0x40) {
457
458                 strcpy(SMS->MessageText, _("Failed"));
459
460                 /* more detailed reason only for debug */
461
462                 if (status & 0x20) {
463                         dprintf("Temporary error, SC is not making any more transfer attempts\n");
464
465                         switch (status) {
466                         case 0x60:
467                                 dprintf("Congestion");
468                                 break;
469                         case 0x61:
470                                 dprintf("SME busy");
471                                 break;
472                         case 0x62:
473                                 dprintf("No response from SME");
474                                 break;
475                         case 0x63:
476                                 dprintf("Service rejected");
477                                 break;
478                         case 0x64:
479                                 dprintf("Quality of service not aviable");
480                                 break;
481                         case 0x65:
482                                 dprintf("Error in SME");
483                                 break;
484                         default:
485                                 dprintf("Reserved/Specific to SC: %x", status);
486                                 break;
487                         }
488                 } else {
489                         dprintf("Permanent error, SC is not making any more transfer attempts\n");
490                         switch (status) {
491                         case 0x40:
492                                 dprintf("Remote procedure error");
493                                 break;
494                         case 0x41:
495                                 dprintf("Incompatibile destination");
496                                 break;
497                         case 0x42:
498                                 dprintf("Connection rejected by SME");
499                                 break;
500                         case 0x43:
501                                 dprintf("Not obtainable");
502                                 break;
503                         case 0x44:
504                                 dprintf("Quality of service not aviable");
505                                 break;
506                         case 0x45:
507                                 dprintf("No internetworking available");
508                                 break;
509                         case 0x46:
510                                 dprintf("SM Validity Period Expired");
511                                 break;
512                         case 0x47:
513                                 dprintf("SM deleted by originating SME");
514                                 break;
515                         case 0x48:
516                                 dprintf("SM Deleted by SC Administration");
517                                 break;
518                         case 0x49:
519                                 dprintf("SM does not exist");
520                                 break;
521                         default:
522                                 dprintf("Reserved/Specific to SC: %x", status);
523                                 break;
524                         }
525                 }
526                 SMS->Length = strlen(_("Failed"));
527         } else if (status & 0x20) {
528                 strcpy(SMS->MessageText, _("Pending"));
529
530                 /* more detailed reason only for debug */
531                 dprintf("Temporary error, SC still trying to transfer SM\n");
532                 switch (status) {
533                 case 0x20:
534                         dprintf("Congestion");
535                         break;
536                 case 0x21:
537                         dprintf("SME busy");
538                         break;
539                 case 0x22:
540                         dprintf("No response from SME");
541                         break;
542                 case 0x23:
543                         dprintf("Service rejected");
544                         break;
545                 case 0x24:
546                         dprintf("Quality of service not aviable");
547                         break;
548                 case 0x25:
549                         dprintf("Error in SME");
550                         break;
551                 default:
552                         dprintf("Reserved/Specific to SC: %x", status);
553                         break;
554                 }
555                 SMS->Length = strlen(_("Pending"));
556         } else {
557                 strcpy(SMS->MessageText, _("Unknown"));
558
559                 /* more detailed reason only for debug */
560                 dprintf("Reserved/Specific to SC: %x", status);
561                 SMS->Length = strlen(_("Unknown"));
562         }
563         dprintf("\n");
564         return GE_NONE;
565 }
566
567 static GSM_Error DecodeData(char *message, char *output, int length, int size, int udhlen, SMS_DataCodingScheme dcs)
568 {
569         /* Unicode */
570         if ((dcs.Type & 0x08) == 0x08) {
571                 dprintf("Unicode message\n");
572                 length = (length - udhlen)/2;
573                 DecodeUnicode(output, message, length);
574         } else {
575                 /* 8bit SMS */
576                 if ((dcs.Type & 0xf4) == 0xf4) {
577                         dprintf("8bit message\n");
578                         memcpy(output, message, length);
579                 /* 7bit SMS */
580                 } else {
581                         dprintf("Default Alphabet\n");
582                         length = length - (udhlen * 8 + ((7-(udhlen%7))%7)) / 7;
583                         Unpack7BitCharacters((7-udhlen)%7, size, length, message, output);
584                         DecodeAscii(output, output, length);
585                 }
586         }
587         dprintf("%s\n", output);
588         return GE_NONE;
589 }
590
591 /* This function decodes UDH as described in:
592    - GSM 03.40 version 6.1.0 Release 1997, section 9.2.3.24
593    - Smart Messaging Specification, Revision 1.0.0, September 15, 1997
594 */
595 static GSM_Error DecodeUDH(char *message, GSM_SMSMessage *SMS)
596 {
597         unsigned char length, pos, nr;
598
599         SMS->UDH_Length = length = message[0] + 1;
600         pos = 1;
601         nr = 0;
602         while (length > 1) {
603                 unsigned char udh_length;
604
605                 udh_length = message[pos+1];
606                 switch (message[pos]) {
607                 case 0x00: // Concatenated short messages
608                         dprintf("Concatenated messages\n");
609                         SMS->UDH[nr].Type = SMS_ConcatenatedMessages;
610                         SMS->UDH[nr].u.ConcatenatedShortMessage.ReferenceNumber = message[pos + 2];
611                         SMS->UDH[nr].u.ConcatenatedShortMessage.MaximumNumber   = message[pos + 3];
612                         SMS->UDH[nr].u.ConcatenatedShortMessage.CurrentNumber   = message[pos + 4];
613                         break;
614                 case 0x01: // Special SMS Message Indication
615                         switch (message[pos + 2] & 0x03) {
616                         case 0x00:
617                                 dprintf("Voice Message\n");
618                                 SMS->UDH[nr].Type = SMS_VoiceMessage;
619                                 break;
620                         case 0x01:
621                                 dprintf("Fax Message\n");
622                                 SMS->UDH[nr].Type = SMS_FaxMessage;
623                                 break;
624                         case 0x02:
625                                 dprintf("Email Message\n");
626                                 SMS->UDH[nr].Type = SMS_EmailMessage;
627                                 break;
628                         default:
629                                 dprintf("Unknown\n");
630                                 SMS->UDH[nr].Type = SMS_UnknownUDH;
631                                 break;
632                         }
633                         SMS->UDH[nr].u.SpecialSMSMessageIndication.Store = (message[pos + 2] & 0x80) >> 7;
634                         SMS->UDH[nr].u.SpecialSMSMessageIndication.MessageCount = message[pos + 3];
635                         break;
636                 case 0x04: // Application port addression scheme, 8 bit address
637                         break;
638                 case 0x05: // Application port addression scheme, 16 bit address
639                         switch (((0x00ff & message[pos + 2]) << 8) | (0x00ff & message[pos + 3])) {
640                         case 0x1581:
641                                 dprintf("Ringtone\n");
642                                 SMS->UDH[nr].Type = SMS_Ringtone;
643                                 break;
644                         case 0x1582:
645                                 dprintf("Operator Logo\n");
646                                 SMS->UDH[nr].Type = SMS_OpLogo;
647                                 break;
648                         case 0x1583:
649                                 dprintf("Caller Icon\n");
650                                 SMS->UDH[nr].Type = SMS_CallerIDLogo;
651                                 break;
652                         case 0x23f4:
653                                 dprintf("Business Card\n");
654                                 SMS->UDH[nr].Type = SMS_BusinessCard;
655                                 break;
656                         default:
657                                 dprintf("Unknown\n");
658                                 SMS->UDH[nr].Type = SMS_UnknownUDH;
659                                 break;
660                         }
661                         break;
662                 case 0x06: // SMSC Control Parameters
663                         break;
664                 case 0x07: // UDH Source Indicator
665                         break;
666                 default:
667                         break;
668                 }
669                 length -= (udh_length + 2);
670                 pos += (udh_length + 2);
671                 nr++;
672         }
673         SMS->UDH_No = nr;
674
675         return GE_NONE;
676 }
677
678 static GSM_Error DecodeSMSHeader(unsigned char *message, GSM_SMSMessage *SMS)
679 {
680         /* Short Message Type */
681         switch (SMS->Type = message[2]) {
682         case SMS_Deliver:
683                 dprintf("Mobile Terminated message:\n");
684                 break;
685         case SMS_Delivery_Report:
686                 dprintf("Delivery Report:\n");
687                 UnpackDateTime(message + 34 + DataOffset[SMS->Type], &(SMS->SMSCTime));
688                 dprintf("\tDelivery date: %s\n", PrintDateTime(message + 34 + DataOffset[SMS->Type]));
689                 break;
690         case SMS_Submit:
691                 dprintf("Mobile Originated message:\n");
692                 break;
693         default:
694                 dprintf("Not supported message type:\n");
695                 break;
696         }
697
698         /* Short Message location in memory */
699         SMS->Number = message[1];
700         dprintf("\tLocation: %d\n", SMS->Number);
701
702         /* Short Message Center */
703         strcpy(SMS->MessageCenter.Number, GetBCDNumber(message + 3));
704         dprintf("\tSMS center number: %s\n", SMS->MessageCenter.Number);
705         SMS->ReplyViaSameSMSC = false;
706         if (SMS->RemoteNumber.number[0] == 0 && (message[6] & 0x80)) {
707                 SMS->ReplyViaSameSMSC = true;
708         }
709
710         /* Remote number */
711         message[15+DataOffset[SMS->Type]] = ((message[15+DataOffset[SMS->Type]])+1)/2+1;
712         dprintf("\tRemote number (recipient or sender): %s\n", GetBCDNumber(message + 15 + DataOffset[SMS->Type]));
713         strcpy(SMS->RemoteNumber.number, GetBCDNumber(message + 15 + DataOffset[SMS->Type]));
714
715         UnpackDateTime(message + 27 + DataOffset[SMS->Type], &(SMS->Time));
716         dprintf("\tDate: %s\n", PrintDateTime(message + 27 + DataOffset[SMS->Type]));
717
718         /* Message length */
719         SMS->Length = message[14+DataOffset[SMS->Type]];
720
721         /* Data Coding Scheme */
722         if (SMS->Type != SMS_Delivery_Report && SMS->Type != SMS_Picture)
723                 SMS->DCS.Type = message[13 + DataOffset[SMS->Type]];
724         else
725                 SMS->DCS.Type = 0;
726
727         /* User Data Header */
728         if (message[15] & 0x40) { /* UDH header available */
729                 dprintf("UDH found\n");
730                 DecodeUDH(message + 34 + DataOffset[SMS->Type], SMS);
731         } else {                    /* No UDH */
732                 dprintf("No UDH\n");
733                 SMS->UDH_No = 0;
734         }
735
736         return GE_NONE;
737 }
738
739 /* This function decodes SMS as described in:
740    - GSM 03.40 version 6.1.0 Release 1997, section 9
741 */
742 GSM_Error DecodePDUSMS(unsigned char *message, GSM_SMSMessage *SMS, int MessageLength)
743 {
744         int size;
745         GSM_Bitmap bitmap;
746
747         DecodeSMSHeader(message, SMS);
748         switch (SMS->Type) {
749         case SMS_Delivery_Report:
750                 SMSStatus(message[17], SMS);
751                 break;
752         case SMS_Picture:
753                 dprintf("Picture!!!\n");
754                 GSM_ReadSMSBitmap(SMS_Picture, message + 41, NULL, &bitmap);
755                 GSM_PrintBitmap(&bitmap);
756                 size = MessageLength - 45 - bitmap.size;
757                 SMS->Length = message[45 + bitmap.size];
758                 printf("%d %d %d\n", SMS->Length, bitmap.size, size);
759                 DecodeData(message + 46 + bitmap.size,
760                            (unsigned char *)&(SMS->MessageText),
761                            SMS->Length, size, 0, SMS->DCS);
762                 SMS->MessageText[SMS->Length] = 0;
763                 break;
764         default:
765                 size = MessageLength -
766                            34 -                    /* Header Length */
767                            DataOffset[SMS->Type] - /* offset */
768                            SMS->UDH_Length -       /* UDH Length */
769                            5;                      /* checksum */
770                 DecodeData(message + 34 + DataOffset[SMS->Type] + SMS->UDH_Length,
771                            (unsigned char *)&(SMS->MessageText),
772                            SMS->Length, size, SMS->UDH_Length, SMS->DCS);
773                 /* Just in case */
774                 SMS->MessageText[SMS->Length] = 0;
775                 break;
776         }
777
778         return GE_NONE;
779 }
780
781 /* This function does simple SMS decoding - no PDU coding */
782 GSM_Error DecodeTextSMS(unsigned char *message, GSM_SMSMessage *SMS)
783 {
784         return GE_NONE;
785 }