updated to latest gammu version

21 files changed, 1216 insertions, 312 deletions

diff --git a/gammu/emb/common/phone/alcatel/alcatel.c b/gammu/emb/common/phone/alcatel/alcatel.c
index f004ad4..3821f13 100644
--- a/gammu/emb/common/phone/alcatel/alcatel.c
+++ b/gammu/emb/common/phone/alcatel/alcatel.c
@@ -1,731 +1,734 @@
 /* (c) 2002-2004 by Michal Cihar */
 
 /*
  * High level functions for communication with Alcatel One Touch 501 and
  * compatible mobile phone.
  *
  * This code implements functions to communicate with Alcatel phones,
  * currently seem to work:
  *  - BE5 series (501/701)
  *  - BF5 series (715)
  *  - BH4 series (535/735)
- * For some functions it uses normal AT  mode (not implemented here, look at 
- * ../at/atgen.[ch]) for others it  switches into binary mode and initialises 
- * underlaying protocol (see ../../protocol/alcatel/alcabus.[ch]) and 
+ * For some functions it uses normal AT  mode (not implemented here, look at
+ * ../at/atgen.[ch]) for others it  switches into binary mode and initialises
+ * underlaying protocol (see ../../protocol/alcatel/alcabus.[ch]) and
  * communicates over it. Don't ask me why Alcatel uses such silly thing...
  *
  * Notes for future features:
  * - max phone number length is 61 (BE5)
  * - max name length is 50 (BE5)
  */
 
 #include "../../gsmstate.h"
 
 #ifdef GSM_ENABLE_ALCATEL
 #ifdef GSM_ENABLE_ATGEN
 
 #include <string.h>
 #include <time.h>
 
 #include "../../gsmcomon.h"
 #include "../../misc/coding/coding.h"
 #include "../../misc/misc.h"
 #include "../../service/sms/gsmsms.h"
 #include "../pfunc.h"
 #include "alcatel.h"
 
 /* Timeout for GSM_WaitFor calls. */
         #define ALCATEL_TIMEOUT                 64
 
 /* Some magic numbers for protocol follow */
 
 /* synchronisation types (for everything except begin transfer): */
         #define ALCATEL_SYNC_TYPE_CALENDAR0x64
         #define ALCATEL_SYNC_TYPE_TODO  0x68
         #define ALCATEL_SYNC_TYPE_CONTACTS0x6C
 
 /* synchronisation types (for begin transfer): */
         #define ALCATEL_BEGIN_SYNC_CALENDAR0x00
         #define ALCATEL_BEGIN_SYNC_TODO         0x02
         #define ALCATEL_BEGIN_SYNC_CONTACTS0x01
 
 /* category types */
         #define ALCATEL_LIST_TODO_CAT   0x9B
         #define ALCATEL_LIST_CONTACTS_CAT0x96
 
 
 /* We need lot of ATGEN functions, because Alcatel is an AT device. */
 
 extern GSM_Reply_Function ALCATELReplyFunctions[];
 extern GSM_Reply_Function ATGENReplyFunctions[];
 
         extern GSM_Error ATGEN_Initialise       (GSM_StateMachine *s);
         extern GSM_Error ATGEN_Terminate        (GSM_StateMachine *s);
         extern GSM_Error ATGEN_GetIMEI                  (GSM_StateMachine *s);
         extern GSM_Error ATGEN_GetFirmware      (GSM_StateMachine *s);
         extern GSM_Error ATGEN_GetModel                 (GSM_StateMachine *s);
         extern GSM_Error ATGEN_GetDateTime      (GSM_StateMachine *s, GSM_DateTime *date_time);
         extern GSM_Error ATGEN_GetMemory        (GSM_StateMachine *s, GSM_MemoryEntry *entry);
         extern GSM_Error ATGEN_GetNextMemory    (GSM_StateMachine *s, GSM_MemoryEntry *entry, bool start);
         extern GSM_Error ATGEN_SetMemory        (GSM_StateMachine *s, GSM_MemoryEntry *entry);
         extern GSM_Error ATGEN_AddMemory        (GSM_StateMachine *s, GSM_MemoryEntry *entry);
         extern GSM_Error ATGEN_DeleteMemory     (GSM_StateMachine *s, GSM_MemoryEntry *entry);
         extern GSM_Error ATGEN_GetMemoryStatus  (GSM_StateMachine *s, GSM_MemoryStatus *Status);
         extern GSM_Error ATGEN_GetSMSC          (GSM_StateMachine *s, GSM_SMSC *smsc);
         extern GSM_Error ATGEN_SetSMSC          (GSM_StateMachine *s, GSM_SMSC *smsc);
         extern GSM_Error ATGEN_GetSMSFolders    (GSM_StateMachine *s, GSM_SMSFolders *folders);
         extern GSM_Error ATGEN_GetSMSStatus     (GSM_StateMachine *s, GSM_SMSMemoryStatus *status);
         extern GSM_Error ATGEN_GetSMS           (GSM_StateMachine *s, GSM_MultiSMSMessage *sms);
         extern GSM_Error ATGEN_GetNextSMS       (GSM_StateMachine *s, GSM_MultiSMSMessage *sms, bool start);
         extern GSM_Error ATGEN_SendSavedSMS     (GSM_StateMachine *s, int Folder, int Location);
         extern GSM_Error ATGEN_SendSMS          (GSM_StateMachine *s, GSM_SMSMessage *sms);
         extern GSM_Error ATGEN_DeleteSMS        (GSM_StateMachine *s, GSM_SMSMessage *sms);
         extern GSM_Error ATGEN_AddSMS           (GSM_StateMachine *s, GSM_SMSMessage *sms);
         extern GSM_Error ATGEN_GetBatteryCharge         (GSM_StateMachine *s, GSM_BatteryCharge *bat);
         extern GSM_Error ATGEN_GetSignalQuality         (GSM_StateMachine *s, GSM_SignalQuality *sig);
         extern GSM_Error ATGEN_DialVoice        (GSM_StateMachine *s, char *number, GSM_CallShowNumber ShowNumber);
         extern GSM_Error ATGEN_AnswerCall       (GSM_StateMachine *s, int ID, bool all);
         extern GSM_Error ATGEN_CancelCall       (GSM_StateMachine *s, int ID, bool all);
         extern GSM_Error ATGEN_SetDateTime      (GSM_StateMachine *s, GSM_DateTime *date_time);
         extern GSM_Error ATGEN_EnterSecurityCode(GSM_StateMachine *s, GSM_SecurityCode Code);
         extern GSM_Error ATGEN_GetSecurityStatus(GSM_StateMachine *s, GSM_SecurityCodeType *Status);
         extern GSM_Error ATGEN_ResetPhoneSettings(GSM_StateMachine *s, GSM_ResetSettingsType Type);
         extern GSM_Error ATGEN_SendDTMF                 (GSM_StateMachine *s, char *sequence);
         extern GSM_Error ATGEN_GetSIMIMSI       (GSM_StateMachine *s, char *IMSI);
         extern GSM_Error ATGEN_HandleCMSError   (GSM_StateMachine *s);
         extern GSM_Error ATGEN_GetNetworkInfo   (GSM_StateMachine *s, GSM_NetworkInfo *netinfo);
         extern GSM_Error ATGEN_Reset            (GSM_StateMachine *s, bool hard);
         extern GSM_Error ATGEN_PressKey                 (GSM_StateMachine *s, GSM_KeyCode Key, bool Press);
         extern GSM_Error ATGEN_GetDisplayStatus         (GSM_StateMachine *s, GSM_DisplayFeatures *features);
         extern GSM_Error ATGEN_SetAutoNetworkLogin(GSM_StateMachine *s);
         extern GSM_Error ATGEN_DeleteAllMemory  (GSM_StateMachine *s, GSM_MemoryType type);
 
         extern GSM_Error ATGEN_DispatchMessage  (GSM_StateMachine *s);
+        extern GSM_Error ATGEN_SetFastSMSSending(GSM_StateMachine *s, bool enable);
         extern GSM_Error ATGEN_SetIncomingCB    (GSM_StateMachine *s, bool enable);
         extern GSM_Error ATGEN_SetIncomingSMS   (GSM_StateMachine *s, bool enable);
 
 /**
  * Alcatel uses some 8-bit characters in contacts, calendar etc.. This table
  * attempts to decode it, it is probably not complete, here are just chars
  * that I found...
  */
 unsigned char GSM_AlcatelAlphabet[] =
 {
         /*      in phone        unicode                 description*/
                 0x80,           0x00,0x20,      /* empty */
                 0x81,           0x00,0x20,      /* empty*/
                 0x82,           0x00,0x20,      /* empty*/
                 0x83,           0x00,0x20,      /* empty*/
-        
+
                 0x84,           0x00,0xe7,      /* c cedilla*/
                 0x85,           0x20,0x26,      /* ...  */
                 0x86,           0x03,0xc0,      /* pi   */
                 0x87,           0x01,0x3e,      /* l caron*/
                 0x88,           0x00,0xc0,      /* A grave*/
                 0x89,           0x00,0xc1,      /* A acute*/
                 0x8a,           0x00,0xc2,      /* A circumflex*/
                 0x8b,           0x00,0xc3,      /* A tilde*/
                 0x8c,           0x00,0xc8,      /* E grave*/
                 0x8d,           0x00,0xca,      /* E circumflex*/
                 0x8e,           0x00,0xcb,      /* E diaresis*/
                 0x8f,           0x00,0xcc,      /* I grave*/
                 0x90,           0x00,0xcd,      /* I acute*/
                 0x91,           0x00,0xd0,      /* ETH  */
                 0x92,           0x00,0xd2,      /* O grave*/
                 0x93,           0x00,0xd3,      /* O acute*/
                 0x94,           0x00,0xd4,      /* O circumflex*/
                 0x95,           0x00,0xd5,      /* O tilde*/
                 0x96,           0x00,0xd9,      /* U grave*/
                 0x97,           0x00,0xda,      /* U acute*/
                 0x98,           0x00,0xe1,      /* a acute*/
                 0x99,           0x00,0xe2,      /* a circumflex*/
                 0x9a,           0x00,0xe3,      /* a tilde*/
                 0x9b,           0x00,0xea,      /* e circumflex*/
                 0x9c,           0x00,0xeb,      /* e diaresis*/
                 0x9d,           0x00,0xed,      /* i acute*/
                 0x9e,           0x00,0xee,      /* i circumflex*/
                 0x9f,           0x00,0xef,      /* i diaresis*/
                 0xa0,           0x00,0xf3,      /* o acute*/
                 0xa1,           0x00,0xf4,      /* o circumflex*/
                 0xa2,           0x00,0xf5,      /* o tilde*/
                 0xa3,           0x00,0xfa,      /* u acute*/
                 0xa4,           0x00,0xa2,      /* cent         */
                 0xa5,           0x00,0x5b,      /* [    */
                 0xa6,           0x01,0x59,      /* r caron*/
                 0xa7,           0x01,0x0d,      /* c caron*/
                 0xa8,           0x01,0x61,      /* s caron*/
                 0xa9,           0x01,0x1b,      /* e caron*/
                 0xaa,           0x01,0x6f,      /* u ring*/
                 0xab,           0x00,0xfd,      /* y acute*/
                 0xac,           0x00,0xf0,      /* eth  */
                 0xad,           0x01,0x07,      /* c acute*/
                 0xae,           0x01,0x19,      /* e ogonek*/
                 0xaf,           0x01,0x05,      /* a ogonek*/
                 0xb0,           0x01,0x7c,      /* z dot*/
                 0xb1,           0x01,0x7a,      /* z acute*/
                 0xb2,           0x01,0x5b,      /* s acute*/
                 0xb3,           0x01,0x44,      /* n acute*/
                 0xb4,           0x01,0x42,      /* l stroke*/
 
                 0xb5,           0x00,0x20,      /* empty*/
-        
+
                 0xb6,           0x01,0x48,      /* n caron*/
                 0xb7,           0x01,0x65,      /* t caron*/
-        
+
                 0xb8,           0x00,0x20,      /* empty*/
-        
+
                 0xb9,           0x01,0x7e,      /* z caron*/
                 0xba,           0x01,0xe7,      /* g caron*/
-        
+
                 0xbb,           0x00,0x20,      /* empty*/
                 0xbc,           0x00,0x20,      /* empty*/
-        
+
                 0xbd,           0x1e,0x20,      /* G macron*/
                 0xbe,           0x1e,0x21,      /* g macron*/
                 0xbf,           0x01,0x5e,      /* S cedilla*/
                 0xc0,           0x01,0x5f,      /* s cedilla*/
                 0xc1,           0x01,0x2f,      /* i ogonek*/ /* FIXME: not sure with this, it look like normal i */
                 0xc2,           0x01,0x31,      /* i dotless*/
                 0xc3,           0x01,0x68,      /* U tilde*/
                 0xc4,           0x01,0x50,      /* O dbl acute*/
                 0xc5,           0x01,0x69,      /* u tilde*/
                 0xc6,           0x01,0x51,      /* o dbl acute*/
                 0xc7,           0x27,0xa9,      /* =>   */
                 0xc8,           0x27,0xa8,      /* filled =>*/
                 0xc9,           0x00,0xd7,      /* x    */
                 0xca,           0x00,0x5d,      /* ]    */
                 0xcb,           0x26,0x0f,      /* phone*/
                 0xcc,           0x01,0x0f,      /* d caron*/
-        
+
                 0xcd,           0x00,0x20,      /* empty*/
 
                 0xce,           0x00,0x7e,      /* ~    */
                 0xcf,           0x00,0x5c,      /* \    */
                 0xd0,           0x00,0x5e,      /* ^    */
-        
+
                 0xd1,           0x00,0x20,      /* empty*/
-        
+
                 0xd2,           0x00,0x7b,      /* {    */
                 0xd3,           0x00,0x7c,      /* |    */
                 0xd4,           0x00,0x7d,      /* }    */
-        
+
                 0xd5,           0x00,0x20,      /* empty*/
-        
+
                 0xd6,           0x01,0x63,      /* t cedilla*/
-        
+
                 0xd7,           0x00,0x20,      /* empty*/
                 0xd8,           0x00,0x20,      /* empty*/
                 0xd9,           0x00,0x20,      /* empty*/
                 0xda,           0x00,0x20,      /* empty*/
                 0xdb,           0x00,0x20,      /* empty*/
                 0xdc,           0x00,0x20,      /* empty*/
                 0xdd,           0x00,0x20,      /* empty*/
                 0xde,           0x00,0x20,      /* empty*/
                 0xdf,           0x00,0x20,      /* empty*/
                 0xe0,           0x00,0x20,      /* empty*/
-        
+
                 0xe1,           0x00,0x20,      /* two candles*/ /* FIXME */
-        
+
                 0xe2,           0x00,0x20,      /* empty*/
                 0xe3,           0x00,0x20,      /* empty*/
                 0xe4,           0x00,0x20,      /* empty*/
-        
+
                 0xe5,           0x01,0xce,      /* a caron*/
                 0xe6,           0x01,0x01,      /* a macron*/
                 0xe7,           0x01,0x13,      /* e macron*/
                 0xe8,           0x01,0x2b,      /* i macron*/
                 0xe9,           0x01,0x4d,      /* o macron*/
                 0xea,           0x01,0x6b,      /* u macron*/
                 0xeb,           0x00,0x41,      /* A    */
                 0xec,           0x00,0x40,      /* @    */
                 0xed,           0x00,0x20,/* some strange char :-) */ /* FIXME */
-        
+
                 0xee,           0x00,0x20,      /* big key stroken*/ /* FIXME */
                 0xef,           0x00,0x20,      /* big key*/ /* FIXME */
-        
+
                 0xf0,           0x00,0x20,      /* empty*/
-        
+
                 0xf1,           0x00,0x31,      /* 1    */
                 0xf2,           0x00,0x21,      /* bold !*/
                 0xf3,           0x26,0x0e,      /* black phone*/
                 0xf4,           0x00,0x26,      /* &    */
                 0xf5,           0x23,0x7e,      /* bell         */
                 0xf6,           0x26,0x6a,      /* note         */
-        
+
                 0xf7,           0x27,0x13,      /* okay inv*/ /* FIXME */
                 0xf8,           0x27,0x13,      /* okay         */
-        
+
                 0xf9,           0x00,0x20,      /* empty*/
-        
+
                 0xfa,           0x00,0x20,      /* key  */ /* FIXME */
-        
+
                 0xfb,           0x00,0x20,      /* empty*/
-        
+
                 0xfc,           0x20,0xac,      /* Euro         */
                 0xfd,           0x21,0x97,      /* NE arrow*/
                 0xfe,           0x21,0x98,      /* SE arrow*/
 
                 0xff,           0x00,0x20,      /* empty*/
-        
+
                 0x00,   0x00,0x00
 };
 
 /* This is being called from atgen */
         GSM_Error ALCATEL_ProtocolVersionReply(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 char            *str, *str2;
 /*
  * Reply received here looks like:
  * 1 "AT+CPROT=?"
  * 2 "+CPROT: 0,"V1.0",1"
  * 3 "+CPROT: 16,"V1.1",16"
  * 4 "OK"
  */
         switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
                 case AT_Reply_OK:
                         str = strstr(msg.Buffer, "\"V");
                         if (str == NULL) return ERR_UNKNOWNRESPONSE;
                         str += 2;
                         while((str2 = strstr(str, "\"V")) != NULL) str = str2 + 2;
                         if (strncmp(str, "1.0", 3) == 0) {
                                 s->Phone.Data.Priv.ALCATEL.ProtocolVersion = V_1_0;
                         } else if (strncmp(str, "1.1", 3) == 0) {
                                 s->Phone.Data.Priv.ALCATEL.ProtocolVersion = V_1_1;
                         } else {
                                 smprintf(s, "Unknown protocol version. Please send debug log and phone info to author.\n");
                                 return ERR_NOTIMPLEMENTED;
                         }
                         return ERR_NONE;
                 case AT_Reply_Error:
                 case AT_Reply_CMSError:
                         return ATGEN_HandleCMSError(s);
                 default:
                         return ERR_UNKNOWNRESPONSE;
         }
 }
 
 static GSM_Error ALCATEL_SetBinaryMode(GSM_StateMachine *s)
 {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
 
         if (Priv->Mode == ModeBinary) return ERR_NONE;
 
         dbgprintf ("Changing to binary mode\n");
 
         error=GSM_WaitFor (s, "AT+IFC=2,2\r", 11, 0x02, 4, ID_SetFlowControl);
         if (error != ERR_NONE) return error;
-        
+
         error=GSM_WaitFor (s, "AT+CPROT=?\r", 11, 0x02, 4, ID_AlcatelProtocol);
         if (error != ERR_NONE) return error;
 
         if (Priv->ProtocolVersion == V_1_0) {
                 error=GSM_WaitFor (s, "AT+CPROT=16,\"V1.0\",16\r", 22, 0x00, 4, ID_AlcatelConnect);
         } else {
                 error=GSM_WaitFor (s, "AT+CPROT=16,\"V1.1\",16\r", 22, 0x00, 4, ID_AlcatelConnect);
         }
-        
+
         if (error == ERR_TIMEOUT && s->Speed != 19200) {
                 smprintf(s, "HINT: Try changing speed to 19200, it is sometimes needed for Alcatel binary mode.\n");
         }
-        
+
         if (error != ERR_NONE) return error;
 
         dbgprintf ("Changing protocol to Alcabus\n");
 
         s->Protocol.Functions = &ALCABUSProtocol;
         error = s->Protocol.Functions->Initialise(s);
         if (error != ERR_NONE) {
                 s->Protocol.Functions = &ATProtocol;
                 return error;
         }
                 s->Phone.Functions->ReplyFunctions= ALCATELReplyFunctions;
                 Priv->Mode                      = ModeBinary;
                 Priv->BinaryItem                = 0;
                 Priv->BinaryType                = 0;
                 Priv->BinaryState               = StateAttached;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GoToBinaryState(GSM_StateMachine *s, GSM_Alcatel_BinaryState state, GSM_Alcatel_BinaryType type, int item) {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
                 unsigned char   attach_buffer[] = {0x00, 0x00, 0x7C ,0x20};
                 unsigned char   detach_buffer[] = {0x00, 0x01, 0x7C ,0x00};
                 unsigned char   start_buffer[] =
                                         {0x00, 0x04, 0x7C, 0x80, /* 4 byte database id follows */
                                          0x12, 0x34, 0x56, 0x78};
                 unsigned char   end_buffer[] =
                                         {0x00, 0x04, 0x7C, 0x82,
                                                  0x00,          /* type */
                                          0x00, 0x00, 0x00, 0x00}; /* TimeStamp */
                 unsigned char   close_buffer[] =
                                         {0x00, 0x04,
                                                  0x00,                   /*type */
                                          0x23, 0x01};
                 unsigned char   select1_buffer[] =
                                         {0x00, 0x00,
                                                  0x00,                   /*type */
                                          0x20};
                 unsigned char   select2_buffer[] =
                                         {0x00, 0x04,
                                                  0x00,                   /*type */
                                          0x22, 0x01, 0x00};
                 unsigned char   begin_buffer[] =
                                         {0x00, 0x04, 0x7C, 0x81,
                                                  0x00,           /*type */
                                          0x00, 0x85, 0x00};
                 unsigned char   commit_buffer[] =
-                                        {0x00, 0x04, 
+                                        {0x00, 0x04,
                                                  0x00,                  /*type */
                                          0x20, 0x01};
 
         smprintf(s, "Alcatel state switcher: %d -> %d, %d -> %d, %d -> %d\n", Priv->BinaryState, state, Priv->BinaryType, type, Priv->BinaryItem, item);
         error = ALCATEL_SetBinaryMode(s);
         if (error != ERR_NONE) return error;
 
         /* Do we need to do anything? */
         if ((state == Priv->BinaryState) && (type == Priv->BinaryType) && (item == Priv->BinaryItem)) return ERR_NONE;
 
         /* We're editing, but the next state is not the same. so commit editing */
         if (Priv->BinaryState == StateEdit) {
                 /* Something has changed, we will have to reread fields! */
                 Priv->CurrentFieldsItem  = -1;
                 switch (Priv->BinaryType) {
                         case TypeCalendar:
                                 commit_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                                 break;
                         case TypeContacts:
                                 commit_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                                 break;
                         case TypeToDo:
                                 commit_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                                 break;
                 }
                 dbgprintf ("Commiting edited record\n");
                 error=GSM_WaitFor (s, commit_buffer, 5, 0x02, ALCATEL_TIMEOUT, ID_AlcatelCommit);
                 if (error != ERR_NONE) return error;
                 error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelCommit2);
                 if (error != ERR_NONE) return error;
                 Priv->BinaryState = StateSession;
                 Priv->BinaryItem = 0;
         }
 
         /* Do we want to edit something of same type? */
         if ((state == StateEdit) && (type == Priv->BinaryType)) {
                 /* Edit state doesn't need any switching, it is needed only for
                  * indication that e have to commit record before we switch to other
                  * mode.
                  */
                 Priv->BinaryState = StateEdit;
                 Priv->BinaryItem = item;
                 return ERR_NONE;
         }
 
         /* Now we can be only in Attached or Session state, so if states and types matches, just keep them as they are */
         if ((state == Priv->BinaryState) && (type == Priv->BinaryType)) {
                 return ERR_NONE;
         }
 
         /* Do we need to close session? */
         if (Priv->BinaryState == StateSession) {
                 dbgprintf ("Ending session\n");
                 switch (Priv->BinaryType) {
                         case TypeCalendar:
                                         end_buffer[4] = ALCATEL_BEGIN_SYNC_CALENDAR;
                                 break;
                         case TypeContacts:
                                         end_buffer[4] = ALCATEL_BEGIN_SYNC_CONTACTS;
                                 break;
                         case TypeToDo:
                                         end_buffer[4] = ALCATEL_BEGIN_SYNC_TODO;
                                 break;
                 }
                 error=GSM_WaitFor (s, end_buffer, 9, 0x02, ALCATEL_TIMEOUT, ID_AlcatelEnd);
                 if (error != ERR_NONE) return error;
-                
+
                 switch (Priv->BinaryType) {
                         case TypeCalendar:
                                 close_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                                 break;
                         case TypeContacts:
                                 close_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                                 break;
                         case TypeToDo:
                                 close_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                                 break;
                 }
                 dbgprintf ("Closing session\n");
                 error=GSM_WaitFor (s, close_buffer, 5, 0x02, ALCATEL_TIMEOUT, ID_AlcatelClose);
                 if (error != ERR_NONE) return error;
 
                 dbgprintf ("Detaching binary mode\n");
                 GSM_WaitFor (s, detach_buffer, 4, 0x02, ALCATEL_TIMEOUT, ID_AlcatelDetach);
 
                 Priv->BinaryState = StateAttached;
                 Priv->BinaryType = 0;
         }
 
         /* Do we need to open session? */
         if (state == StateSession || state == StateEdit) {
                 dbgprintf ("Starting session for %s\n",
                                 (type == TypeCalendar ? "Calendar" :
                                 (type == TypeToDo ? "Todo" :
                                 (type == TypeContacts ? "Contacts" :
                                 "Unknown!"))));
                 /* Fill up buffers */
                 switch (type) {
                         case TypeCalendar:
                                         select1_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                                         select2_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                                         begin_buffer[4] = ALCATEL_BEGIN_SYNC_CALENDAR;
                                 break;
                         case TypeContacts:
                                         select1_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                                         select2_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                                         begin_buffer[4] = ALCATEL_BEGIN_SYNC_CONTACTS;
                                 break;
                         case TypeToDo:
                                         select1_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                                         select2_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                                         begin_buffer[4] = ALCATEL_BEGIN_SYNC_TODO;
                                 break;
                 }
                 dbgprintf ("Attaching in binary mode\n");
 
                 /* Communicate */
                 error=GSM_WaitFor (s, attach_buffer, 4, 0x02, ALCATEL_TIMEOUT, ID_AlcatelAttach);
                 if (error != ERR_NONE) return error;
 
                 smprintf(s,"Start session\n");
                 error=GSM_WaitFor (s, start_buffer, 8, 0x02, ALCATEL_TIMEOUT, ID_AlcatelStart);
                 if (error != ERR_NONE) return error;
 
                 smprintf(s,"Select type\n");
                 error=GSM_WaitFor (s, select1_buffer, 4, 0x02, ALCATEL_TIMEOUT, ID_AlcatelSelect1);
                 if (error != ERR_NONE) return error;
                 error=GSM_WaitFor (s, select2_buffer, 6, 0x02, ALCATEL_TIMEOUT, ID_AlcatelSelect2);
                 if (error != ERR_NONE) return error;
                 error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelSelect3);
                 if (error != ERR_NONE) return error;
 
                 smprintf(s,"Begin transfer\n");
                 error=GSM_WaitFor (s, begin_buffer, 8, 0x02, ALCATEL_TIMEOUT, ID_AlcatelBegin1);
                 if (error != ERR_NONE) return error;
                 error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelBegin2);
                 if (error != ERR_NONE) return error;
 
                 Priv->BinaryState = StateSession;
                 Priv->BinaryType = type;
                 /* Do we want to edit something of same type? */
                 if ((state == StateEdit) && (type == Priv->BinaryType)) {
                         Priv->BinaryState = StateEdit;
                         Priv->BinaryItem = item;
                         return ERR_NONE;
                 }
         }
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_SetATMode(GSM_StateMachine *s)
 {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
 
         if (Priv->Mode == ModeAT) return ERR_NONE;
 
         error = ALCATEL_GoToBinaryState(s, StateAttached, 0, 0);
         if (error != ERR_NONE) return error;
 
         error = s->Protocol.Functions->Terminate(s);
         if (error != ERR_NONE) return error;
 
         dbgprintf ("Changing protocol to AT\n");
                 s->Protocol.Functions           = &ATProtocol;
                 s->Phone.Functions->ReplyFunctions= ATGENReplyFunctions;
                 Priv->Mode                      = ModeAT;
+                s->Phone.Data.Priv.ATGEN.PBKCharset= 0;
+                s->Phone.Data.Priv.ATGEN.PBKMemory= 0;
 
         my_sleep(100);
 
         /* In case we don't send AT command short after closing binary mode,
          * phone takes VERY long to react next time. The error code in
          * intetionally ignored.
          */
         GSM_WaitFor (s, "AT\r", 3, 0x00, 0, ID_IncomingFrame);
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_Initialise(GSM_StateMachine *s)
 {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
 
                 Priv->Mode                      = ModeAT;
 
                 Priv->CalendarItems             = NULL;
                 Priv->ContactsItems             = NULL;
                 Priv->ToDoItems                         = NULL;
                 Priv->CalendarItemsCount        = 0;
                 Priv->ToDoItemsCount            = 0;
                 Priv->ContactsItemsCount        = 0;
                 Priv->CurrentFields[0]          = 0;
                 Priv->CurrentFieldsCount        = 0;
                 Priv->CurrentFieldsItem                 = 0;
                 Priv->CurrentFieldsType                 = 0;
                 Priv->ProtocolVersion           = V_1_0;
                 Priv->CurrentFieldsItem                 = -1;
 
                 Priv->CurrentCategoriesCount    = 0;
                 Priv->CurrentCategoriesType     = 0;
 
                 s->Protocol.Functions           = &ATProtocol;
                 s->Phone.Functions->ReplyFunctions= ATGENReplyFunctions;
 
         if (ATGEN_Initialise(s) != ERR_NONE || GSM_WaitFor (s, "AT\r", 3, 0x00, 2, ID_IncomingFrame) != ERR_NONE) {
                 smprintf(s,"AT initialisation failed, trying to stop binary mode...\n");
                         s->Protocol.Functions   = &ALCABUSProtocol;
                 error = s->Protocol.Functions->Terminate(s);
                         s->Protocol.Functions   = &ATProtocol;
 
                 error = ATGEN_Initialise(s);
                 if (error != ERR_NONE) return error;
         }
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_Terminate(GSM_StateMachine *s)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         free(Priv->CalendarItems);
         free(Priv->ContactsItems);
         free(Priv->ToDoItems);
         error = ALCATEL_SetATMode(s);
         return ATGEN_Terminate(s);
 }
 
 /* finds whether id is set in the phone */
 static GSM_Error ALCATEL_IsIdAvailable(GSM_StateMachine *s, int id) {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i;
 
         if (id > ALCATEL_MAX_LOCATION) return ERR_INVALIDLOCATION;
 
         switch (Priv->BinaryType) {
                 case TypeCalendar:
                                 Priv->CurrentList = &(Priv->CalendarItems);
                                 Priv->CurrentCount = &(Priv->CalendarItemsCount);
                         break;
                 case TypeContacts:
                                 Priv->CurrentList = &(Priv->ContactsItems);
                                 Priv->CurrentCount = &(Priv->ContactsItemsCount);
                         break;
                 case TypeToDo:
                                 Priv->CurrentList = &(Priv->ToDoItems);
                                 Priv->CurrentCount = &(Priv->ToDoItemsCount);
                         break;
         }
-        
+
         for (i=0; i<*Priv->CurrentCount; i++) {
                 if ((*Priv->CurrentList)[i] == id) return ERR_NONE;
         }
-        
+
         return ERR_EMPTY;
 }
 
 /* finds next id that is available in the phone */
 static GSM_Error ALCATEL_GetNextId(GSM_StateMachine *s, int *id) {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i = 0;
                 int             next = ALCATEL_MAX_LOCATION;
 
         switch (Priv->BinaryType) {
                 case TypeCalendar:
                                 Priv->CurrentList = &(Priv->CalendarItems);
                                 Priv->CurrentCount = &(Priv->CalendarItemsCount);
                         break;
                 case TypeContacts:
                                 Priv->CurrentList = &(Priv->ContactsItems);
                                 Priv->CurrentCount = &(Priv->ContactsItemsCount);
                         break;
                 case TypeToDo:
                                 Priv->CurrentList = &(Priv->ToDoItems);
                                 Priv->CurrentCount = &(Priv->ToDoItemsCount);
                         break;
         }
 
         for (i=0; i<*Priv->CurrentCount; i++) {
                 if (((*Priv->CurrentList)[i] > *id) && ((*Priv->CurrentList)[i] < next )) {
                         next = (*Priv->CurrentList)[i];
                 }
         }
         if (next == ALCATEL_MAX_LOCATION) {
                 return ERR_EMPTY;
         } else {
                 *id = next;
                 return ERR_NONE;
         }
 }
 
 static GSM_Error ALCATEL_ReplyGetIds(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             count,i,pos;
 
                 count    = msg.Buffer[10];
         *Priv->CurrentCount += count;
 
         *Priv->CurrentList = (int *)realloc(*Priv->CurrentList, (*Priv->CurrentCount + 1)* sizeof(int));
         if (*Priv->CurrentList == NULL) return ERR_MOREMEMORY;
 
         for (i = 0; i < count; i++) {
                 pos = 11 + (4 * i);
                 (*Priv->CurrentList)[*Priv->CurrentCount - count + i] = msg.Buffer[pos + 3] +
                                                         (msg.Buffer[pos + 2] << 8) +
                                                         (msg.Buffer[pos + 1] << 16) +
                                                         (msg.Buffer[pos] << 24);
         }
         (*Priv->CurrentList)[*Priv->CurrentCount] = 0;
 
         /* If last byte is 0, then we transmitted all items */
         Priv->TransferCompleted = msg.Buffer[4 + msg.Buffer[4]] == 0;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetAvailableIds(GSM_StateMachine *s, bool refresh)
 {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
                 int             i;
                 unsigned char   buffer[] =
                                         {0x00, 0x04,
                                                  0x00,                  /*type */
                                          0x2F, 0x01};
 
         if (Priv->BinaryState != StateSession) return ERR_UNKNOWN;
 
         switch (Priv->BinaryType) {
                 case TypeCalendar:
                                 buffer[2]       = ALCATEL_SYNC_TYPE_CALENDAR;
                                 Priv->CurrentList= &(Priv->CalendarItems);
                                 Priv->CurrentCount= &(Priv->CalendarItemsCount);
                         break;
                 case TypeContacts:
                                 buffer[2]       = ALCATEL_SYNC_TYPE_CONTACTS;
                                 Priv->CurrentList= &(Priv->ContactsItems);
                                 Priv->CurrentCount= &(Priv->ContactsItemsCount);
                         break;
                 case TypeToDo:
                                 buffer[2]       = ALCATEL_SYNC_TYPE_TODO;
                                 Priv->CurrentList= &(Priv->ToDoItems);
                                 Priv->CurrentCount= &(Priv->ToDoItemsCount);
                         break;
         }
 
         if (*Priv->CurrentList != NULL) {
                 if (!refresh) return ERR_NONE;
                 free(*Priv->CurrentList);
                 *Priv->CurrentList = NULL;
@@ -753,193 +756,193 @@ static GSM_Error ALCATEL_GetAvailableIds(GSM_StateMachine *s, bool refresh)
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_ReplyGetFields(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i;
 
         if (msg.Buffer[14] > GSM_PHONEBOOK_ENTRIES) {
                 smprintf(s, "WARNING: Field list truncated, you should increase GSM_PHONEBOOK_ENTRIES to at least %d\n", msg.Buffer[14]);
                 Priv->CurrentFieldsCount = GSM_PHONEBOOK_ENTRIES;
         } else {
                 Priv->CurrentFieldsCount = msg.Buffer[14];
         }
 
         Priv->CurrentFields[Priv->CurrentFieldsCount] = 0;
 
         for (i = 0; i < Priv->CurrentFieldsCount; i++) {
                 Priv->CurrentFields[i] = msg.Buffer[15 + i];
         }
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetFields(GSM_StateMachine *s, int id) {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
                 int             i;
                 unsigned char   buffer[] =
                                         {0x00, 0x04,
                                                  0x00,                  /* type */
                                          0x30, 0x01,
                                          0x00, 0x00, 0x00, 0x00}; /* item */
 
         if (Priv->BinaryState != StateSession) return ERR_UNKNOWN;
         if ((Priv->CurrentFieldsItem == id) && (Priv->CurrentFieldsType == Priv->BinaryType)) return ERR_NONE;
 
         smprintf(s,"Reading item fields (%d)\n", id);
 
         buffer[5] = (id >> 24);
         buffer[6] = ((id >> 16) & 0xff);
         buffer[7] = ((id >> 8) & 0xff);
         buffer[8] = (id & 0xff);
 
         switch (Priv->BinaryType) {
                 case TypeCalendar:
                         buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                         break;
                 case TypeContacts:
                         buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                         break;
                 case TypeToDo:
                         buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                         break;
         }
 
         Priv->CurrentFieldsItem = id;
         Priv->CurrentFieldsType = Priv->BinaryType;
 
         error=GSM_WaitFor (s, buffer, 9, 0x02, ALCATEL_TIMEOUT, ID_AlcatelGetFields1);
         if (error != ERR_NONE) return error;
         error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelGetFields2);
         if (error != ERR_NONE) return error;
 
         i = 0;
         smprintf(s,"Received %d fields: ", Priv->CurrentFieldsCount);
         for (i=0; i < Priv->CurrentFieldsCount; i++) {
                 smprintf(s,"%x ", Priv->CurrentFields[i]);
         }
         smprintf(s,"\n");
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_ReplyGetFieldValue(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
                 unsigned char   *buffer = &(msg.Buffer[16]);
 
         if (buffer[1] == 0x05 && buffer[2] == 0x67) {
                 /* date */
                         Priv->ReturnType        = Alcatel_date;
                         Priv->ReturnDateTime.Day= buffer[4];
                         Priv->ReturnDateTime.Month= buffer[5];
                         Priv->ReturnDateTime.Year= buffer[7] + (buffer[6] << 8);
                         Priv->ReturnDateTime.Timezone= 0; /* FIXME: how to acquire this? */
 
                         Priv->ReturnDateTime.Hour= 0;
                         Priv->ReturnDateTime.Minute= 0;
                         Priv->ReturnDateTime.Second= 0;
         } else if (buffer[1] == 0x06 && buffer[2] == 0x68) {
                 /* time */
                         Priv->ReturnType        = Alcatel_time;
                         Priv->ReturnDateTime.Hour= buffer[4];
                         Priv->ReturnDateTime.Minute= buffer[5];
                         Priv->ReturnDateTime.Second= buffer[6];
-                
+
                         Priv->ReturnDateTime.Day= 0;
                         Priv->ReturnDateTime.Month= 0;
                         Priv->ReturnDateTime.Year= 0;
                         Priv->ReturnDateTime.Timezone= 0;
         } else if (buffer[1] == 0x08 && buffer[2] == 0x3C) {
                 /* string */
                 Priv->ReturnType = Alcatel_string;
                 if (GSM_PHONEBOOK_TEXT_LENGTH < buffer[3])
                         smprintf(s, "WARNING: Text truncated, you should increase GSM_PHONEBOOK_TEXT_LENGTH to at least %d\n", buffer[3] + 1);
                 if (Priv->ProtocolVersion == V_1_0) {
                         DecodeDefault( Priv->ReturnString, buffer + 4, MIN(GSM_PHONEBOOK_TEXT_LENGTH, buffer[3]), false, GSM_AlcatelAlphabet);
                 } else if(Priv->ProtocolVersion == V_1_1 && (buffer[4] & 0x80)) {
                         memcpy(Priv->ReturnString, buffer + 5, buffer[3]);
                         Priv->ReturnString[buffer[3] + 1] = 0;
                         Priv->ReturnString[buffer[3] + 2] = 0;
                         ReverseUnicodeString(Priv->ReturnString);
                 } else {
                         DecodeDefault( Priv->ReturnString, buffer + 4, MIN(GSM_PHONEBOOK_TEXT_LENGTH, buffer[3]), false, GSM_AlcatelAlphabet);
                 }
         } else if (buffer[1] == 0x07 && buffer[2] == 0x3C) {
                 /* phone */
                 Priv->ReturnType = Alcatel_phone;
                 if (GSM_PHONEBOOK_TEXT_LENGTH < buffer[3])
                         smprintf(s, "WARNING: Text truncated, you should increase GSM_PHONEBOOK_TEXT_LENGTH to at least %d\n", buffer[3] + 1);
                 if (Priv->ProtocolVersion == V_1_0) {
                         DecodeDefault( Priv->ReturnString, buffer + 4, MIN(GSM_PHONEBOOK_TEXT_LENGTH, buffer[3]), false, GSM_AlcatelAlphabet);
                 } else if(Priv->ProtocolVersion == V_1_1 && (buffer[4] & 0x80)) {
                         memcpy(Priv->ReturnString, buffer + 5, buffer[3]);
                         Priv->ReturnString[buffer[3] + 1] = 0;
                         Priv->ReturnString[buffer[3] + 2] = 0;
                         ReverseUnicodeString(Priv->ReturnString);
                 } else {
                         DecodeDefault( Priv->ReturnString, buffer + 4, MIN(GSM_PHONEBOOK_TEXT_LENGTH, buffer[3]), false, GSM_AlcatelAlphabet);
                 }
         } else if (buffer[1] == 0x03 && buffer[2] == 0x3B) {
                 /* boolean */
                 Priv->ReturnType = Alcatel_bool;
                 Priv->ReturnInt = buffer[3];
         } else if (buffer[1] == 0x02 && buffer[2] == 0x3A) {
                 /* integer */
                 Priv->ReturnType = Alcatel_int;
                 Priv->ReturnInt = buffer[6] + (buffer[5] << 8) + (buffer[4] << 16) + (buffer[3] << 24);
         } else if (buffer[1] == 0x04 && buffer[2] == 0x38) {
                 /* enumeration */
                         Priv->ReturnType = Alcatel_enum;
                         Priv->ReturnInt = buffer[3];
         } else if (buffer[1] == 0x00 && buffer[2] == 0x38) {
                 /* byte */
                         Priv->ReturnType = Alcatel_byte;
                         Priv->ReturnInt = buffer[3];
         } else {
                 smprintf(s, "WARNING: Uknown data type received (%02X,%02X)\n", buffer[1], buffer[2]);
                 return ERR_UNKNOWNRESPONSE;
         }
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetFieldValue(GSM_StateMachine *s, int id, int field)
 {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
                 unsigned char   buffer[] =
                                         {0x00, 0x04,
                                                  0x00,                          /* type */
                                          0x1f, 0x01,
                                                  0x00, 0x00, 0x00, 0x00,/* here follows 4byte id */
                                                  0x00};                         /* field */
 
         smprintf(s,"Reading item value (%08x.%02x)\n", id, field);
 
         switch (Priv->BinaryType) {
                 case TypeCalendar:
                         buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                         break;
                 case TypeContacts:
                         buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                         break;
                 case TypeToDo:
                         buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                         break;
         }
 
         buffer[5] = (id >> 24);
         buffer[6] = ((id >> 16) & 0xff);
         buffer[7] = ((id >> 8) & 0xff);
         buffer[8] = (id & 0xff);
         buffer[9] = (field & 0xff);
 
         error=GSM_WaitFor (s, buffer, 10, 0x02, ALCATEL_TIMEOUT, ID_AlcatelGetFieldValue1);
         if (error != ERR_NONE) return error;
         error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelGetFieldValue2);
         if (error != ERR_NONE) return error;
 
         return ERR_NONE;
 }
 
@@ -1003,469 +1006,469 @@ static GSM_Error ALCATEL_GetAvailableCategoryIds(GSM_StateMachine *s) {
 
         error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelGetCategories2);
         if (error != ERR_NONE) return error;
 
         i = 0;
         smprintf(s,"Received %d ids: ", Priv->CurrentCategoriesCount);
         for (i=0; i < Priv->CurrentCategoriesCount; i++) {
                 smprintf(s,"%i ", Priv->CurrentCategories[i]);
         }
         smprintf(s,"\n");
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_IsCategoryIdAvailable(GSM_StateMachine *s, int id) {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i = 0;
 
         if (Priv->CurrentCategoriesType != Priv->BinaryType) return ERR_UNKNOWN;
 
         for (i = 0; i< Priv->CurrentCategoriesCount; i++) {
                 if (Priv->CurrentCategories[i] == id) return ERR_NONE;
         }
         return ERR_EMPTY;
 }
 
 static GSM_Error ALCATEL_ReplyAddCategoryText(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
 
         Priv->ReturnInt = msg.Buffer[12];
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_AddCategoryText(GSM_StateMachine *s, const unsigned char *str) {
                 unsigned char   buffer[200] = {0x00, 0x04, 0x00 /*type*/, 0x0d, 0x00 /*list*/, 0x0b };
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
                 int             len;
 
         smprintf(s,"Creating category\n");
         len = UnicodeLength(str);
         EncodeDefault(buffer + 8, str, &len, true, GSM_AlcatelAlphabet);
         buffer[6] = len + 1;
         buffer[7] = len;
 
         switch (Priv->BinaryType) {
                 case TypeContacts:
                         buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                         buffer[4] = ALCATEL_LIST_CONTACTS_CAT;
                         break;
                 case TypeToDo:
                         buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                         buffer[4] = ALCATEL_LIST_TODO_CAT;
                         break;
                 default:
                         return ERR_NOTSUPPORTED;
         }
 
         error=GSM_WaitFor (s, buffer, 8 + len, 0x02, ALCATEL_TIMEOUT, ID_AlcatelAddCategoryText1);
         if (error != ERR_NONE) return error;
         error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelAddCategoryText2);
         if (error != ERR_NONE) return error;
 
         /* Refresh list */
         Priv->CurrentCategoriesType = 0;
         return ALCATEL_GetAvailableCategoryIds(s);
 }
 
 static GSM_Error ALCATEL_ReplyGetCategoryText(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
         int len;
 
         len = msg.Buffer[14];
         if (len > GSM_MAX_CATEGORY_NAME_LENGTH) {
                 smprintf(s, "WARNING: Category name truncated, you should increase GSM_MAX_CATEGORY_NAME_LENGTH to at least %d\n", len);
         }
         if (Priv->ProtocolVersion == V_1_0) {
                 DecodeDefault( Priv->ReturnString, msg.Buffer + 15, MIN(GSM_MAX_CATEGORY_NAME_LENGTH, len), false, GSM_AlcatelAlphabet);
         } else if(Priv->ProtocolVersion == V_1_1 && (msg.Buffer[15] & 0x80)) {
                 memcpy(Priv->ReturnString, msg.Buffer + 16, len);
                 Priv->ReturnString[len + 1] = 0;
                 Priv->ReturnString[len + 2] = 0;
                 ReverseUnicodeString(Priv->ReturnString);
         } else {
                 DecodeDefault( Priv->ReturnString, msg.Buffer + 15, MIN(GSM_MAX_CATEGORY_NAME_LENGTH, len), false, GSM_AlcatelAlphabet);
         }
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetCategoryText(GSM_StateMachine *s, int id) {
                 unsigned char   buffer[] = {0x00, 0x04, 0x00 /*type*/, 0x0c, 0x00 /*list*/, 0x0A, 0x01, 0x00 /*item*/ };
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
-        
+
         if (Priv->CurrentCategoriesCache[id][0] != '\000' || Priv->CurrentCategoriesCache[id][1] != '\000') {
                 CopyUnicodeString(Priv->ReturnString, Priv->CurrentCategoriesCache[id]);
                 return ERR_NONE;
         }
-        
+
         smprintf(s,"Reading category %d\n", id);
 
         switch (Priv->BinaryType) {
                 case TypeContacts:
                         buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                         buffer[4] = ALCATEL_LIST_CONTACTS_CAT;
                         break;
                 case TypeToDo:
                         buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                         buffer[4] = ALCATEL_LIST_TODO_CAT;
                         break;
                 default:
                         return ERR_NOTSUPPORTED;
         }
 
         buffer[7] = (id & 0xff);
 
         error=GSM_WaitFor (s, buffer, 8, 0x02, ALCATEL_TIMEOUT, ID_AlcatelGetCategoryText1);
         if (error != ERR_NONE) return error;
         error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelGetCategoryText2);
         if (error != ERR_NONE) return error;
-        
+
         CopyUnicodeString(Priv->CurrentCategoriesCache[id], Priv->ReturnString);
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_DeleteField(GSM_StateMachine *s, int id, int field) {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
                 unsigned char   buffer[] =
                                         {0x00, 0x04,
                                                  0x00,                          /* type */
                                          0x26, 0x01,
                                                  0x00, 0x00, 0x00, 0x00,/* here follows 4byte id */
                                          0x65, 0x01,
                                                  0x00,                  /* field */
                                          0x01};
 
         smprintf(s,"Deleting field (%08x.%02x)\n", id, field);
 
         switch (Priv->BinaryType) {
                 case TypeCalendar:
                         buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                         break;
                 case TypeContacts:
                         buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                         break;
                 case TypeToDo:
                         buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                         break;
         }
 
         buffer[5] = (id >> 24);
         buffer[6] = ((id >> 16) & 0xff);
         buffer[7] = ((id >> 8) & 0xff);
         buffer[8] = (id & 0xff);
         buffer[11] = (field & 0xff);
 
         error=GSM_WaitFor (s, buffer, 13, 0x02, ALCATEL_TIMEOUT, ID_AlcatelDeleteField);
         if (error != ERR_NONE) return error;
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_DeleteItem(GSM_StateMachine *s, int id) {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
                 unsigned char   buffer[] =
                                         {0x00, 0x04,
                                                  0x00,                          /* type */
                                          0x27, 0x01,
                                                  0x00, 0x00, 0x00, 0x00,/* here follows 4byte id */
                                          0x42};
 
         smprintf(s,"Deleting item (%08x)\n", id);
 
         switch (Priv->BinaryType) {
                 case TypeCalendar:
                         buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                         break;
                 case TypeContacts:
                         buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                         break;
                 case TypeToDo:
                         buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                         break;
         }
 
         buffer[5] = (id >> 24);
         buffer[6] = ((id >> 16) & 0xff);
         buffer[7] = ((id >> 8) & 0xff);
         buffer[8] = (id & 0xff);
 
         error=GSM_WaitFor (s, buffer, 10, 0x02, ALCATEL_TIMEOUT, ID_AlcatelDeleteItem1);
         if (error != ERR_NONE) return error;
 
         error=GSM_WaitFor (s, 0, 0, 0x0, ALCATEL_TIMEOUT, ID_AlcatelDeleteItem2);
         if (error != ERR_NONE) return error;
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_ReplyDeleteItem(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         if (msg.Buffer[8] != 0x25) return ERR_UNKNOWNRESPONSE;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_BuildWriteBuffer(unsigned char * buffer, GSM_Alcatel_FieldType type, int field, void *data) {
                 int             len;
-        
+
         buffer[1] = field & 0xff;
-        
+
         switch(type) {
                 case Alcatel_date:
                         if (!CheckDate((GSM_DateTime *)data)) return ERR_INVALIDDATETIME;
 
                         buffer[3] = 0x05;
                         buffer[4] = 0x67;
 
                         buffer[0] = 0x09;
                         buffer[5] = 0x04;
                         buffer[6] = ((GSM_DateTime *)data)->Day & 0xff;
                         buffer[7] = ((GSM_DateTime *)data)->Month & 0xff;
                         buffer[8] = ((GSM_DateTime *)data)->Year >> 8;
                         buffer[9] = ((GSM_DateTime *)data)->Year & 0xff;
                         buffer[10] = 0x00;
                         break;
                 case Alcatel_time:
                         if (!CheckTime((GSM_DateTime *)data)) return ERR_INVALIDDATETIME;
 
                         buffer[3] = 0x06;
                         buffer[4] = 0x68;
 
                         buffer[0] = 0x08;
                         buffer[5] = 0x03;
                         buffer[6] = ((GSM_DateTime *)data)->Hour & 0xff;
                         buffer[7] = ((GSM_DateTime *)data)->Minute & 0xff;
                         buffer[8] = ((GSM_DateTime *)data)->Second & 0xff;
                         buffer[9] = 0x00;
                         break;
                 case Alcatel_string:
                         buffer[3] = 0x08;
                         buffer[4] = 0x3c;
 
                         len = MIN(UnicodeLength((char *)data),62);
                         EncodeDefault(buffer + 6, (char *)data, &len, true, GSM_AlcatelAlphabet);
                         buffer[5] = len;
                         buffer[0] = 5 + len;
                         buffer[6 + len] = 0x00;
                         break;
                 case Alcatel_phone:
                         buffer[3] = 0x07;
                         buffer[4] = 0x3c;
 
                         len = MIN(UnicodeLength((char *)data),50);
                         EncodeDefault(buffer + 6, (char *)data, &len, true, GSM_AlcatelAlphabet);
                         buffer[5] = len;
                         buffer[0] = 5 + len;
                         buffer[6 + len] = 0x00;
                         break;
                 case Alcatel_enum:
                         buffer[3] = 0x04;
                         buffer[4] = 0x38;
 
                         buffer[0] = 0x05;
                         buffer[5] = *(int *)data & 0xff;
                         buffer[6] = 0x00;
                         break;
                 case Alcatel_bool:
                         buffer[3] = 0x03;
                         buffer[4] = 0x3b;
 
                         buffer[0] = 0x05;
                         buffer[5] = *(int *)data & 0xff;
                         buffer[6] = 0x00;
                         break;
                 case Alcatel_int:
                         buffer[3] = 0x02;
                         buffer[4] = 0x3a;
 
                         buffer[0] = 0x08;
                         buffer[5] = *(unsigned int *)data >> 24;
                         buffer[6] = (*(unsigned int *)data >> 16) & 0xff;
                         buffer[7] = (*(unsigned int *)data >> 8) & 0xff;
                         buffer[8] = *(unsigned int *)data & 0xff;
                         buffer[9] = 0x00;
                         break;
                 case Alcatel_byte:
                         buffer[3] = 0x00;
                         buffer[4] = 0x38;
 
                         buffer[0] = 0x05;
                         buffer[5] = *(int *)data & 0xff;
                         buffer[6] = 0x00;
                         break;
         }
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_CreateField(GSM_StateMachine *s, GSM_Alcatel_FieldType type, int field, void *data) {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
                 unsigned char   buffer[200] =
                                         {0x00, 0x04,
                                                  0x00,                          /* type */
                                          0x25, 0x01, 0x65,
                                                  0x00,                  /* length of remaining part */
                                                  0x00,                  /* field */
                                                  0x37};                         /* data follows here */
 
         smprintf(s,"Creating field (%02x)\n", field);
 
         switch (Priv->BinaryType) {
                 case TypeCalendar:
                         buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                         break;
                 case TypeContacts:
                         buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                         break;
                 case TypeToDo:
                         buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                         break;
         }
         error = ALCATEL_BuildWriteBuffer(buffer + 6, type, field, data);
         if (error != ERR_NONE) return error;
-        
+
         error = GSM_WaitFor (s, buffer, 8 + buffer[6], 0x02, ALCATEL_TIMEOUT, ID_AlcatelCreateField);
         if (error != ERR_NONE) return error;
-        
+
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_UpdateField(GSM_StateMachine *s, GSM_Alcatel_FieldType type, int id, int field, void *data) {
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
                 unsigned char   buffer[200] =
                                         {0x00, 0x04,
                                                  0x00,                          /* type */
-                                         0x26, 0x01, 
+                                         0x26, 0x01,
                                                  0x00, 0x00, 0x00, 0x00,/* id */
                                          0x65,
                                                  0x00,                  /* length of remaining part */
                                                  0x00,                  /* field */
                                                  0x37};                         /* data follows here */
 
         smprintf(s,"Updating field (%08x.%02x)\n", id, field);
-        
+
         buffer[5] = (id >> 24);
         buffer[6] = ((id >> 16) & 0xff);
         buffer[7] = ((id >> 8) & 0xff);
         buffer[8] = (id & 0xff);
 
         switch (Priv->BinaryType) {
                 case TypeCalendar:
                         buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                         break;
                 case TypeContacts:
                         buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                         break;
                 case TypeToDo:
                         buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                         break;
         }
         error = ALCATEL_BuildWriteBuffer(buffer + 10, type, field, data);
         if (error != ERR_NONE) return error;
-        
+
         error = GSM_WaitFor (s, buffer, 12 + buffer[10], 0x02, ALCATEL_TIMEOUT, ID_AlcatelUpdateField);
         if (error != ERR_NONE) return error;
-        
+
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetManufacturer(GSM_StateMachine *s)
 {
         strcpy(s->Phone.Data.Manufacturer, "Alcatel");
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetIMEI (GSM_StateMachine *s)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetIMEI(s);
 }
 
 static GSM_Error ALCATEL_GetFirmware(GSM_StateMachine *s)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetFirmware(s);
 }
 
 static GSM_Error ALCATEL_GetModel(GSM_StateMachine *s)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetModel(s);
 }
 
 static GSM_Error ALCATEL_GetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetDateTime(s, date_time);
 }
 
 static GSM_Error ALCATEL_GetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i;
                 int             j = 0;
 
         if (entry->MemoryType == MEM_ME) {
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
                 if ((error = ALCATEL_IsIdAvailable(s, entry->Location))!= ERR_NONE) {
                         entry->EntriesNum = 0;
                         return error;
                 }
                 if ((error = ALCATEL_GetFields(s, entry->Location))!= ERR_NONE) return error;
 
                 entry->EntriesNum = Priv->CurrentFieldsCount;
 
                 for (i=0; i<Priv->CurrentFieldsCount; i++) {
                         if ((error = ALCATEL_GetFieldValue(s, entry->Location, Priv->CurrentFields[i]))!= ERR_NONE) return error;
                         entry->Entries[i].VoiceTag   = 0;
                         entry->Entries[i].SMSList[0] = 0;
                         switch (Priv->CurrentFields[i]) {
                                 case 0:
                                         if (Priv->ReturnType != Alcatel_string) {
                                         smprintf(s,"WARNING: Received unexpected type %02X for field 0, ignoring\n", Priv->ReturnType);
                                                 entry->EntriesNum--;
                                                 j++;
                                                 break;
                                         }
                                         entry->Entries[i - j].EntryType = PBK_Text_LastName;
                                         CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
                                         break;
                                 case 1:
                                         if (Priv->ReturnType != Alcatel_string) {
                                                 smprintf(s,"WARNING: Received unexpected type %02X for field 1, ignoring\n", Priv->ReturnType);
                                                 entry->EntriesNum--;
                                                 j++;
                                                 break;
                                         }
                                         entry->Entries[i - j].EntryType = PBK_Text_FirstName;
                                         CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
                                         break;
                                 case 2:
                                         if (Priv->ReturnType != Alcatel_string) {
                                                 smprintf(s,"WARNING: Received unexpected type %02X for field 2, ignoring\n", Priv->ReturnType);
                                                 entry->EntriesNum--;
                                                 j++;
                                                 break;
                                         }
                                         entry->Entries[i - j].EntryType = PBK_Text_Company;
                                         CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
                                         break;
                                 case 3:
                                         if (Priv->ReturnType != Alcatel_string) {
@@ -1650,789 +1653,789 @@ static GSM_Error ALCATEL_GetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
                                 case 21:
                                         if (Priv->ReturnType != Alcatel_string) {
                                                 smprintf(s,"WARNING: Received unexpected type %02X for field 21, ignoring\n", Priv->ReturnType);
                                                 entry->EntriesNum--;
                                                 j++;
                                                 break;
                                         }
                                         entry->Entries[i - j].EntryType = PBK_Text_Custom1;
                                         CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
                                         break;
                                 case 22:
                                         if (Priv->ReturnType != Alcatel_string) {
                                                 smprintf(s,"WARNING: Received unexpected type %02X for field 22, ignoring\n", Priv->ReturnType);
                                                 entry->EntriesNum--;
                                                 j++;
                                                 break;
                                         }
                                         entry->Entries[i - j].EntryType = PBK_Text_Custom2;
                                         CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
                                         break;
                                 case 23:
                                         if (Priv->ReturnType != Alcatel_string) {
                                                 smprintf(s,"WARNING: Received unexpected type %02X for field 23, ignoring\n", Priv->ReturnType);
                                                 entry->EntriesNum--;
                                                 j++;
                                                 break;
                                         }
                                         entry->Entries[i - j].EntryType = PBK_Text_Custom3;
                                         CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
                                         break;
                                 case 24:
                                         if (Priv->ReturnType != Alcatel_string) {
                                                 smprintf(s,"WARNING: Received unexpected type %02X for field 24, ignoring\n", Priv->ReturnType);
                                                 entry->EntriesNum--;
                                                 j++;
                                                 break;
                                         }
                                         entry->Entries[i - j].EntryType = PBK_Text_Custom4;
                                         CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
                                         break;
                                 case 25:
                                         if (Priv->ReturnType != Alcatel_int) {
                                                 smprintf(s,"WARNING: Received unexpected type %02X for field 25, ignoring\n", Priv->ReturnType);
                                                 entry->EntriesNum--;
                                                 j++;
                                                 break;
                                         }
                                         if (Priv->ReturnInt != 0) {
                                                 entry->Entries[i - j].EntryType = PBK_PictureID;
                                                 entry->Entries[i - j].Number = Priv->ReturnInt;
                                         } else {
                                                 entry->EntriesNum--;
                                                 j++;
                                         }
                                         break;
                                 default:
                                         entry->EntriesNum--;
                                         j++;
                                         smprintf(s,"WARNING: Received unknown field %02X, ignoring. Type = %02X. Value = ", Priv->CurrentFields[i], Priv->ReturnType);
                                         switch (Priv->ReturnType) {
                                                 case Alcatel_date:
                                                         smprintf(s, "%d.%d.%d", Priv->ReturnDateTime.Day, Priv->ReturnDateTime.Month, Priv->ReturnDateTime.Year);
                                                         break;
                                                 case Alcatel_time:
                                                         smprintf(s, "%d:%d:%d", Priv->ReturnDateTime.Hour, Priv->ReturnDateTime.Minute, Priv->ReturnDateTime.Second);
                                                         break;
                                                 case Alcatel_string:
                                                 case Alcatel_phone:
                                                         smprintf(s, "\"%s\"",DecodeUnicodeString(Priv->ReturnString));
                                                         break;
                                                 case Alcatel_enum:
                                                 case Alcatel_bool:
                                                 case Alcatel_int:
                                                 case Alcatel_byte:
                                                         smprintf(s, "%d", Priv->ReturnInt);
                                                         break;
                                         }
                                         smprintf(s,"\n");
                         }
                 }
                 return ERR_NONE;
         } else {
                 if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
                 return ATGEN_GetMemory(s, entry);
         }
 }
 
 static GSM_Error ALCATEL_GetNextMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry, bool start)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         if (entry->MemoryType == MEM_ME) {
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
                 if (Priv->ContactsItemsCount == 0) return ERR_EMPTY;
-                
+
                 if (start) entry->Location = 0;
                 if ((error = ALCATEL_GetNextId(s, &(entry->Location))) != ERR_NONE) return error;
 
                 return ALCATEL_GetMemory(s, entry);
         } else {
                 if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
                 return ATGEN_GetNextMemory(s, entry, start);
         }
 }
 
 static GSM_Error ALCATEL_AddMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             NamePosition = -1;
                 bool            NameSet = false;
                 int             i;
 
 
         if (entry->MemoryType == MEM_ME) {
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeContacts, 0))!= ERR_NONE) return error;
                 for (i = 0; i < entry->EntriesNum; i++) {
                         switch (entry->Entries[i].EntryType) {
-                                case PBK_Number_General: 
+                                case PBK_Number_General:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_phone, 8, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Number_Mobile:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_phone, 12, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Number_Work:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_phone, 7, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Number_Fax: 
+                                case PBK_Number_Fax:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_phone, 9, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Number_Home:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_phone, 13, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Number_Pager:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_phone, 11, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Number_Other:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_phone, 10, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Note:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 4, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Email:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 14, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Email2:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 15, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_LastName:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 0, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         NameSet = true;
                                         break;
                                 case PBK_Text_FirstName:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 1, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         NameSet = true;
                                         break;
                                 case PBK_Text_Company:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 2, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_JobTitle: 
+                                case PBK_Text_JobTitle:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 3, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Category: 
+                                case PBK_Category:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_byte, 5, &(entry->Entries[i].Number))) != ERR_NONE) return error;
                                         break;
-                                case PBK_Private: 
+                                case PBK_Private:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_bool, 6, &(entry->Entries[i].Number))) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_StreetAddress:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 16, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_City:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 17, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_State:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 18, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Zip:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 19, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Country:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 20, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Custom1:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 21, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Custom2:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 22, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Custom3:
-                                        if ((error = ALCATEL_CreateField(s, Alcatel_string, 23, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                        if ((error = ALCATEL_CreateField(s, Alcatel_string, 23, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Custom4:
                                         if ((error = ALCATEL_CreateField(s, Alcatel_string, 24, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_PictureID: 
+                                case PBK_PictureID:
                                         if (s->Phone.Data.Priv.ALCATEL.ProtocolVersion == V_1_1) {
                                                if ((error = ALCATEL_CreateField(s, Alcatel_int, 25, &(entry->Entries[i].Number))) != ERR_NONE) return error;
                                         } else {
                                                 smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", entry->Entries[i].EntryType);
                                         }
                                         break;
 
                                 case PBK_Text_Name: NamePosition = i; break;
                                 /* Following fields are not supported: */
                                 case PBK_Text_UserID:
                                 case PBK_SMSListID:
                                 case PBK_RingtoneFileSystemID:
                                 case PBK_Date:
                                 case PBK_Caller_Group:
                                 case PBK_RingtoneID:
                                 case PBK_Text_Postal:
                                 case PBK_Text_URL:
                                         smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", entry->Entries[i].EntryType);
                                         break;
                         }
                 }
                 if (NamePosition != -1) {
                         if (NameSet) {
                                 smprintf(s,"WARNING: Ignoring name, not supported by phone\n");
                         } else {
                                 if ((error = ALCATEL_CreateField(s, Alcatel_string, 1, entry->Entries[i].Text)) != ERR_NONE) return error;
                         }
                 }
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 entry->Location = Priv->CommitedRecord;
                 /* Refresh list */
                 if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
                 return ERR_NONE;
         } else {
                 if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
                 return ATGEN_AddMemory(s, entry);
         }
 }
 
 static GSM_Error ALCATEL_SetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             NamePosition = -1;
                 bool            NameSet = false;
                 int             i;
                 bool            UpdatedFields[26];
 
         if (entry->Location == 0) return ERR_INVALIDLOCATION;
 
         if (entry->MemoryType == MEM_ME) {
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 /* Save modified entry */
                 if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
                 if ((error = ALCATEL_IsIdAvailable(s, entry->Location))!= ERR_NONE) {
                         /* Entry doesn't exist, we will create new one */
                         return ALCATEL_AddMemory(s, entry);
                 }
                 /* Get fields for current item */
                 if ((error = ALCATEL_GetFields(s, entry->Location))!= ERR_NONE) return error;
-                
+
                 for (i = 0; i < 26; i++) { UpdatedFields[i] = false; }
-                
+
                 if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeContacts, entry->Location))!= ERR_NONE) return error;
                 for (i = 0; i < entry->EntriesNum; i++) {
                         switch (entry->Entries[i].EntryType) {
-                                case PBK_Number_General: 
-                                        UpdatedFields[8] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 8, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                case PBK_Number_General:
+                                        UpdatedFields[8] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 8, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Number_Mobile: 
-                                        UpdatedFields[12] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 12, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                case PBK_Number_Mobile:
+                                        UpdatedFields[12] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 12, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Number_Work: 
-                                        UpdatedFields[7] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 7, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                case PBK_Number_Work:
+                                        UpdatedFields[7] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 7, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Number_Fax: 
-                                        UpdatedFields[9] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 9, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                case PBK_Number_Fax:
+                                        UpdatedFields[9] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 9, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Number_Home: 
-                                        UpdatedFields[13] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 13, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                case PBK_Number_Home:
+                                        UpdatedFields[13] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 13, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Number_Pager: 
-                                        UpdatedFields[11] = true; 
+                                case PBK_Number_Pager:
+                                        UpdatedFields[11] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 11, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Number_Other:
                                         UpdatedFields[10] = true;
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 10, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 10, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_Note: 
+                                case PBK_Text_Note:
                                         UpdatedFields[4] = true;
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 4, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 4, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_Email: 
-                                        UpdatedFields[14] = true; 
+                                case PBK_Text_Email:
+                                        UpdatedFields[14] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 14, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_Email2: 
-                                        UpdatedFields[15] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 15, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                case PBK_Text_Email2:
+                                        UpdatedFields[15] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 15, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_LastName: 
-                                        UpdatedFields[0] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 0, entry->Entries[i].Text)) != ERR_NONE) return error; NameSet = true; 
+                                case PBK_Text_LastName:
+                                        UpdatedFields[0] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 0, entry->Entries[i].Text)) != ERR_NONE) return error; NameSet = true;
                                         break;
-                                case PBK_Text_FirstName: 
-                                        UpdatedFields[1] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 1, entry->Entries[i].Text)) != ERR_NONE) return error; NameSet = true; 
+                                case PBK_Text_FirstName:
+                                        UpdatedFields[1] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 1, entry->Entries[i].Text)) != ERR_NONE) return error; NameSet = true;
                                         break;
                                 case PBK_Text_Company:
-                                        UpdatedFields[2] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 2, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                        UpdatedFields[2] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 2, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_JobTitle: 
+                                case PBK_Text_JobTitle:
                                         UpdatedFields[3] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 3, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Category:
-                                        UpdatedFields[5] = true; 
+                                        UpdatedFields[5] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_byte, entry->Location, 5, &(entry->Entries[i].Number))) != ERR_NONE) return error;
                                         break;
                                 case PBK_Private:
                                         UpdatedFields[6] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_bool, entry->Location, 6, &(entry->Entries[i].Number))) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_StreetAddress: 
+                                case PBK_Text_StreetAddress:
                                         UpdatedFields[16] = true;
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 16, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 16, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_City: 
-                                        UpdatedFields[17] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 17, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                case PBK_Text_City:
+                                        UpdatedFields[17] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 17, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_State: 
-                                        UpdatedFields[18] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 18, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                case PBK_Text_State:
+                                        UpdatedFields[18] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 18, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_Zip: 
-                                        UpdatedFields[19] = true; 
-                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 19, entry->Entries[i].Text)) != ERR_NONE) return error; 
+                                case PBK_Text_Zip:
+                                        UpdatedFields[19] = true;
+                                        if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 19, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Country:
                                         UpdatedFields[20] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 20, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Custom1:
                                         UpdatedFields[21] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 21, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
-                                case PBK_Text_Custom2: 
+                                case PBK_Text_Custom2:
                                         UpdatedFields[22] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 22, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Custom3:
                                         UpdatedFields[23] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 23, entry->Entries[i].Text)) != ERR_NONE) return error;
                                         break;
                                 case PBK_Text_Custom4:
-                                        UpdatedFields[24] = true; 
+                                        UpdatedFields[24] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 24, entry->Entries[i].Text)) != ERR_NONE) return error
                                                 ; break;
-                                case PBK_PictureID: 
+                                case PBK_PictureID:
                                         if (s->Phone.Data.Priv.ALCATEL.ProtocolVersion == V_1_1) {
                                                UpdatedFields[25] = true;
                                                if ((error = ALCATEL_UpdateField(s, Alcatel_int, entry->Location, 25, &(entry->Entries[i].Number))) != ERR_NONE) return error;
                                         } else {
                                                 smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", entry->Entries[i].EntryType);
                                         }
                                         break;
 
                                 case PBK_Text_Name: NamePosition = i; break;
                                 /* Following fields are not supported: */
                                 case PBK_SMSListID:
                                 case PBK_Text_UserID:
                                 case PBK_RingtoneFileSystemID:
                                 case PBK_Date:
                                 case PBK_Caller_Group:
                                 case PBK_RingtoneID:
                                 case PBK_Text_Postal:
                                 case PBK_Text_URL:
                                         smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", entry->Entries[i].EntryType);
                                         break;
                         }
                 }
                 if (NamePosition != -1) {
                         if (NameSet) {
                                 smprintf(s,"WARNING: Ignoring name, not supported by phone\n");
                         } else {
                                 UpdatedFields[1] = true; if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 1, entry->Entries[i].Text)) != ERR_NONE) return error;
                         }
                 }
                 /* If we didn't update some field, we have to delete it... */
                 for (i=0; i<Priv->CurrentFieldsCount; i++) {
                         if (!UpdatedFields[Priv->CurrentFields[i]]) if ((error = ALCATEL_DeleteField(s, entry->Location, Priv->CurrentFields[i])) != ERR_NONE) return error;
                 }
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 entry->Location = Priv->CommitedRecord;
                 return ERR_NONE;
         } else {
                 if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
                 return ATGEN_SetMemory(s, entry);
         }
 }
 
 static GSM_Error ALCATEL_DeleteMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
                 GSM_Error       error;
 
         if (entry->MemoryType == MEM_ME) {
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
                 if ((error = ALCATEL_IsIdAvailable(s, entry->Location))!= ERR_NONE) {
                         /* Entry was empty => no error */
                         return ERR_NONE;
                 }
                 /* Do real delete */
                 error = ALCATEL_DeleteItem(s, entry->Location);
                 if (error != ERR_NONE) return error;
-                
+
                 /* Refresh list */
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
-                
+
                 return ERR_NONE;
         } else {
                 if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
                 return ATGEN_DeleteMemory(s, entry);
         }
 }
 
 static GSM_Error ALCATEL_DeleteAllMemory(GSM_StateMachine *s, GSM_MemoryType type)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i;
 
         if (type == MEM_ME) {
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
 
                 for (i=0; i<Priv->ContactsItemsCount; i++) {
                         error =  ALCATEL_DeleteItem(s, Priv->ContactsItems[i]);
                         if (error != ERR_NONE) return error;
                 }
 
                 /* Refresh list */
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
 
                 return ERR_NONE;
         } else {
                 if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
                 return ATGEN_DeleteAllMemory(s, type);
         }
 }
 
 static GSM_Error ALCATEL_GetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetSMSC(s, smsc);
 }
 
 
 static GSM_Error ALCATEL_GetMemoryStatus(GSM_StateMachine *s, GSM_MemoryStatus *Status)
 {
                 GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_Error       error;
 
         if (Status->MemoryType == MEM_ME) {
                 if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
                 if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
                 Status->MemoryUsed = Priv->ContactsItemsCount;
                 Status->MemoryFree = ALCATEL_FREE_MEMORY;
                 return ERR_NONE;
         } else {
                 if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
                 return ATGEN_GetMemoryStatus(s, Status);
         }
 }
 
 static GSM_Error ALCATEL_GetSMS(GSM_StateMachine *s, GSM_MultiSMSMessage *sms)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetSMS(s, sms);
 }
 
 static GSM_Error ALCATEL_DeleteSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_DeleteSMS(s, sms);
 }
 
 static GSM_Error ALCATEL_AddSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_AddSMS(s, sms);
 }
 
 static GSM_Error ALCATEL_GetBatteryCharge(GSM_StateMachine *s, GSM_BatteryCharge *bat)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetBatteryCharge(s, bat);
 }
 
 static GSM_Error ALCATEL_GetSignalStrength(GSM_StateMachine *s, GSM_SignalQuality *sig)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetSignalQuality(s, sig);
 }
 
 static GSM_Error ALCATEL_GetSMSFolders(GSM_StateMachine *s, GSM_SMSFolders *folders)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetSMSFolders(s, folders);
 }
 
 static GSM_Error ALCATEL_GetNextSMS(GSM_StateMachine *s, GSM_MultiSMSMessage *sms, bool start)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetNextSMS(s, sms, start);
 }
 
 static GSM_Error ALCATEL_GetSMSStatus(GSM_StateMachine *s, GSM_SMSMemoryStatus *status)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetSMSStatus(s, status);
 }
 
 static GSM_Error ALCATEL_DialVoice(GSM_StateMachine *s, char *number, GSM_CallShowNumber ShowNumber)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_DialVoice(s, number, ShowNumber);
 }
 
 static GSM_Error ALCATEL_AnswerCall(GSM_StateMachine *s, int ID, bool all)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_AnswerCall(s,ID,all);
 }
 
 static GSM_Error ALCATEL_GetNetworkInfo(GSM_StateMachine *s, GSM_NetworkInfo *netinfo)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetNetworkInfo(s, netinfo);
 }
 
 static GSM_Error ALCATEL_GetDisplayStatus(GSM_StateMachine *s, GSM_DisplayFeatures *features)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetDisplayStatus(s, features);
 }
-        
+
 static GSM_Error ALCATEL_SetAutoNetworkLogin(GSM_StateMachine *s)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_SetAutoNetworkLogin(s);
 }
 
 static GSM_Error ALCATEL_PressKey(GSM_StateMachine *s, GSM_KeyCode Key, bool Press)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_PressKey(s, Key, Press);
 }
 
 static GSM_Error ALCATEL_Reset(GSM_StateMachine *s, bool hard)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_Reset(s, hard);
 }
 
 static GSM_Error ALCATEL_CancelCall(GSM_StateMachine *s, int ID, bool all)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_CancelCall(s,ID,all);
 }
 
 static GSM_Error ALCATEL_SendSavedSMS(GSM_StateMachine *s, int Folder, int Location)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_SendSavedSMS(s, Folder, Location);
 }
 
 static GSM_Error ALCATEL_SendSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_SendSMS(s, sms);
 }
 
 static GSM_Error ALCATEL_SetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_SetDateTime(s, date_time);
 }
 
 static GSM_Error ALCATEL_SetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_SetSMSC(s, smsc);
 }
 
 static GSM_Error ALCATEL_EnterSecurityCode(GSM_StateMachine *s, GSM_SecurityCode Code)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_EnterSecurityCode(s, Code);
 }
 
 static GSM_Error ALCATEL_GetSecurityStatus(GSM_StateMachine *s, GSM_SecurityCodeType *Status)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetSecurityStatus(s, Status);
 }
 
 static GSM_Error ALCATEL_ResetPhoneSettings(GSM_StateMachine *s, GSM_ResetSettingsType Type)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_ResetPhoneSettings(s, Type);
 }
 
 static GSM_Error ALCATEL_SendDTMF(GSM_StateMachine *s, char *sequence)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_SendDTMF(s, sequence);
 }
 
 static GSM_Error ALCATEL_GetSIMIMSI(GSM_StateMachine *s, char *IMSI)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_GetSIMIMSI(s, IMSI);
 }
 
 static GSM_Error ALCATEL_GetCalendarStatus(GSM_StateMachine *s, GSM_CalendarStatus *status)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
-        
+
         status->Used = 0;
-        
+
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
 
         status->Used = Priv->CalendarItemsCount;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
                 GSM_Error       error;
                 GSM_DateTime    *dt = NULL;
                 GSM_DateTime    evdate;
                 bool            evdateused = true;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i;
                 int             j=0;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
         if ((error = ALCATEL_IsIdAvailable(s, Note->Location))!= ERR_NONE) {
                 Note->EntriesNum = 0;
                 return error;
         }
         if ((error = ALCATEL_GetFields(s, Note->Location))!= ERR_NONE) return error;
 
         Note->EntriesNum = Priv->CurrentFieldsCount;
 
         for (i=0; i < Priv->CurrentFieldsCount; i++) {
                 if ((error = ALCATEL_GetFieldValue(s, Note->Location, Priv->CurrentFields[i]))!= ERR_NONE) return error;
                 switch (Priv->CurrentFields[i]) {
                         case 0:
                                 if (Priv->ReturnType != Alcatel_date) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckDate(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 j++;
                                 Note->EntriesNum--;
                                 evdate = Priv->ReturnDateTime;
                                 evdateused = false;
                                 break;
                         case 1:
                                 if (Priv->ReturnType != Alcatel_time) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckTime(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 Note->Entries[i-j].EntryType = CAL_START_DATETIME;
                                 Note->Entries[i-j].Date = Priv->ReturnDateTime;
                                 Note->Entries[i-j].Date.Day = evdate.Day;
                                 Note->Entries[i-j].Date.Month = evdate.Month;
                                 Note->Entries[i-j].Date.Year = evdate.Year;
                                 Note->Entries[i-j].Date.Timezone = evdate.Timezone;
                                 evdateused = true;
                                 break;
                         case 2:
                                 if (Priv->ReturnType != Alcatel_time) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckTime(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 Note->Entries[i-j].EntryType = CAL_END_DATETIME;
                                 Note->Entries[i-j].Date = Priv->ReturnDateTime;
                                 Note->Entries[i-j].Date.Day = evdate.Day;
                                 Note->Entries[i-j].Date.Month = evdate.Month;
                                 Note->Entries[i-j].Date.Year = evdate.Year;
                                 Note->Entries[i-j].Date.Timezone = evdate.Timezone;
                                 evdateused = true;
                                 break;
                         case 3:
                                 if (Priv->ReturnType != Alcatel_date) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         Note->EntriesNum--;
                                         j++;
                                         break;
@@ -2634,652 +2637,652 @@ static GSM_Error ALCATEL_GetCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Not
                                 }
                                 Note->Entries[i-j].EntryType = CAL_REPEAT_STARTDATE;
                                 Note->Entries[i-j].Date = Priv->ReturnDateTime;
                                 break;
                         case 19:
                                 if (Priv->ReturnType != Alcatel_date) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckDate(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 Note->Entries[i-j].EntryType = CAL_REPEAT_STOPDATE;
                                 Note->Entries[i-j].Date = Priv->ReturnDateTime;
                                 break;
                         case 20:
                                 if (Priv->ReturnType != Alcatel_date) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckDate(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 /* This entry had always same value as the 3rd (alarm date) */
                                 j++;
                                 Note->EntriesNum--;
                                 break;
                         case 21:
                                 if (Priv->ReturnType != Alcatel_time) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckTime(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
                                         Note->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 /* This entry had always same value as the 4th (alarm time) */
                                 j++;
                                 Note->EntriesNum--;
                                 break;
                         default:
                                 Note->EntriesNum--;
                                 j++;
                                 smprintf(s,"WARNING: Received unknown field %02X, ignoring. Type = %02X. Value = ", Priv->CurrentFields[i], Priv->ReturnType);
                                 switch (Priv->ReturnType) {
                                         case Alcatel_date:
                                                 smprintf(s, "%d.%d.%d", Priv->ReturnDateTime.Day, Priv->ReturnDateTime.Month, Priv->ReturnDateTime.Year);
                                                 break;
                                         case Alcatel_time:
                                                 smprintf(s, "%d:%d:%d", Priv->ReturnDateTime.Hour, Priv->ReturnDateTime.Minute, Priv->ReturnDateTime.Second);
                                                 break;
                                         case Alcatel_string:
                                         case Alcatel_phone:
                                                 smprintf(s, "\"%s\"",DecodeUnicodeString(Priv->ReturnString));
                                                 break;
                                         case Alcatel_enum:
                                         case Alcatel_bool:
                                         case Alcatel_int:
                                         case Alcatel_byte:
                                                 smprintf(s, "%d", Priv->ReturnInt);
                                                 break;
                                 }
                                 smprintf(s,"\n");
                 }
         }
         /* The event didn't have start/stop time -> we need only date */
         if (!evdateused) {
                 Note->EntriesNum++;
                 Note->Entries[i-j].EntryType = CAL_START_DATETIME;
                 Note->Entries[i-j].Date = evdate;
         }
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetNextCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
         if (Priv->CalendarItemsCount == 0) return ERR_EMPTY;
-        
+
         if (start) Note->Location = 0;
         if ((error = ALCATEL_GetNextId(s, &(Note->Location))) != ERR_NONE) return error;
 
         return ALCATEL_GetCalendar(s, Note);
 }
 
 
 static GSM_Error ALCATEL_DeleteCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
                 GSM_Error       error;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         /* Delete Calendar */
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
         if ((error = ALCATEL_IsIdAvailable(s, Note->Location))!= ERR_NONE) {
                 /* Entry was empty => no error */
                 return ERR_NONE;
         }
         error = ALCATEL_DeleteItem(s, Note->Location);
         if (error != ERR_NONE) return error;
         /* Refresh list */
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
         return ERR_NONE;
 }
 
 
 static GSM_Error ALCATEL_AddCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
                 GSM_Error       error;
                 unsigned int    val;
                 bool            contact_set = false;
                 bool            phone_set = false;
                 bool            date_set = false;
                 bool            repeating = false;
                 int             i;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeCalendar, 0))!= ERR_NONE) return error;
-        
+
         for (i = 0; i < Note->EntriesNum; i++) {
                 switch (Note->Entries[i].EntryType) {
                         case CAL_START_DATETIME:
                                 if (!date_set) {
                                         if ((error = ALCATEL_CreateField(s, Alcatel_date, 0, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         date_set = true;
                                 }
                                 if ((error = ALCATEL_CreateField(s, Alcatel_time, 1, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 break;
                         case CAL_END_DATETIME:
                                 if (!date_set) {
                                         if ((error = ALCATEL_CreateField(s, Alcatel_date, 0, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         date_set = true;
                                 }
                                 if ((error = ALCATEL_CreateField(s, Alcatel_time, 2, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 break;
                         case CAL_ALARM_DATETIME:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_date, 3, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 if ((error = ALCATEL_CreateField(s, Alcatel_time, 4, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 if (Note->Type == GSM_CAL_ALARM || Note->Type == GSM_CAL_DAILY_ALARM) {
                                         if ((error = ALCATEL_CreateField(s, Alcatel_date, 20, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         if ((error = ALCATEL_CreateField(s, Alcatel_time, 21, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 }
                                 break;
                         case CAL_TEXT:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_string, 5, Note->Entries[i].Text)) != ERR_NONE) return error;
                                 break;
                         case CAL_PRIVATE:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_bool, 6, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                 break;
                         case CAL_CONTACTID:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_int, 8, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                 contact_set = true;
                                 break;
                         case CAL_PHONE:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_phone, 9, Note->Entries[i].Text)) != ERR_NONE) return error;
                                 phone_set = true;
-                                break;               
+                                break;
                         case CAL_REPEAT_DAYOFWEEK:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_byte, 10, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_DAY:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_byte, 11, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_WEEKOFMONTH:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_byte, 12, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_MONTH:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_byte, 13, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_FREQUENCY:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_byte, 17, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                          case CAL_REPEAT_STARTDATE:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_date, 18, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_STOPDATE:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_date, 19, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_SILENT_ALARM_DATETIME:
                         case CAL_RECURRANCE:
                         case CAL_LOCATION:
                                 smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", Note->Entries[i].EntryType);
                                 break;
                 }
         }
-        
+
         switch (Note->Type) {
                 case GSM_CAL_CALL:
                         val = 3;
                         break;
                 case GSM_CAL_BIRTHDAY:
                         val = 2;
                         break;
                 case GSM_CAL_ALARM:
                         val = 4;
                         break;
                 case GSM_CAL_DAILY_ALARM:
                         val = 5;
                         break;
                 default:
                         if (repeating) {
                                 val = 9;
                         } else {
                                 val = 0;
                         }
         }
         if ((error = ALCATEL_CreateField(s, Alcatel_enum, 7, &val)) != ERR_NONE) return error;
 
         if (!contact_set) {
                 if (phone_set) {
                         val = 0xffffffff;
                 } else {
                         val = 0;
                 }
                 if ((error = ALCATEL_CreateField(s, Alcatel_int, 8, &val)) != ERR_NONE) return error;
         }
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         Note->Location = Priv->CommitedRecord;
         /* Refresh list */
         if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_SetCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
                 GSM_Error       error;
                 unsigned int    val;
                 bool            contact_set = false;
                 bool            phone_set = false;
                 bool            date_set = false;
                 bool            repeating = false;
                 int             i;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 bool            UpdatedFields[22];
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
         if ((error = ALCATEL_IsIdAvailable(s, Note->Location))!= ERR_NONE) {
                 /* Entry doesn't exist, we will create new one */
                 return ALCATEL_AddCalendar(s, Note);
         }
         /* Get fields for current item */
         if ((error = ALCATEL_GetFields(s, Note->Location))!= ERR_NONE) return error;
-        
+
         for (i = 0; i < 22; i++) { UpdatedFields[i] = false; }
 
         if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeCalendar, Note->Location))!= ERR_NONE) return error;
-        
+
         for (i = 0; i < Note->EntriesNum; i++) {
                 switch (Note->Entries[i].EntryType) {
                         case CAL_START_DATETIME:
                                 if (!date_set) {
-                                        UpdatedFields[0] = true; 
+                                        UpdatedFields[0] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 0, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         date_set = true;
                                 }
                                 UpdatedFields[1] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_time, Note->Location, 1, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 break;
                         case CAL_END_DATETIME:
                                 if (!date_set) {
                                         UpdatedFields[0] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 0, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         date_set = true;
                                 }
                                 UpdatedFields[2] = true; if ((error = ALCATEL_UpdateField(s, Alcatel_time, Note->Location, 2, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 break;
                         case CAL_ALARM_DATETIME:
                                 UpdatedFields[3] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 3, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 UpdatedFields[4] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_time, Note->Location, 4, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 if (Note->Type == GSM_CAL_ALARM || Note->Type == GSM_CAL_DAILY_ALARM) {
                                         UpdatedFields[20] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 20, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         UpdatedFields[21] = true;
                                         if ((error = ALCATEL_UpdateField(s, Alcatel_time, Note->Location, 21, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                 }
                                 break;
                         case CAL_TEXT:
                                 UpdatedFields[5] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_string, Note->Location, 5, Note->Entries[i].Text)) != ERR_NONE) return error;
                                 break;
                         case CAL_PRIVATE:
                                 UpdatedFields[6] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_bool, Note->Location, 6, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                 break;
                         case CAL_CONTACTID:
                                 UpdatedFields[8] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_int, Note->Location, 8, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                 contact_set = true;
                                 break;
                         case CAL_PHONE:
                                 UpdatedFields[9] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_phone, Note->Location, 9, Note->Entries[i].Text)) != ERR_NONE) return error;
                                 phone_set = true;
-                                break;               
+                                break;
                         case CAL_REPEAT_DAYOFWEEK:
                                 UpdatedFields[10] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 10, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_DAY:
                                 UpdatedFields[11] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 11, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_WEEKOFMONTH:
                                 UpdatedFields[12] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 12, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_MONTH:
                                 UpdatedFields[13] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 13, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_FREQUENCY:
                                 UpdatedFields[17] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 17, &(Note->Entries[i].Number))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                          case CAL_REPEAT_STARTDATE:
                                 UpdatedFields[18] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 18, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_REPEAT_STOPDATE:
                                 UpdatedFields[19] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 19, &(Note->Entries[i].Date))) != ERR_NONE) return error;
                                         repeating       = true;
                                 break;
                         case CAL_SILENT_ALARM_DATETIME:
                         case CAL_RECURRANCE:
                         case CAL_LOCATION:
                                 smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", Note->Entries[i].EntryType);
                                 break;
                 }
         }
-        
+
         switch (Note->Type) {
                 case GSM_CAL_CALL:
                         val = 3;
                         break;
                 case GSM_CAL_BIRTHDAY:
                         val = 2;
                         break;
                 case GSM_CAL_ALARM:
                         val = 4;
                         break;
                 case GSM_CAL_DAILY_ALARM:
                         val = 5;
                         break;
                 default:
                         if (repeating) {
                                 val = 9;
                         } else {
                                 val = 0;
                         }
         }
         UpdatedFields[7] = true;
         if ((error = ALCATEL_UpdateField(s, Alcatel_enum, Note->Location, 7, &val)) != ERR_NONE) return error;
 
         if (!contact_set) {
                 if (phone_set) {
                         val = 0xffffffff;
                 } else {
                         val = 0;
                 }
                 UpdatedFields[8] = true;
                 if ((error = ALCATEL_UpdateField(s, Alcatel_int, Note->Location, 8, &val)) != ERR_NONE) return error;
         }
         /* If we didn't update some field, we have to delete it... */
         for (i=0; i<Priv->CurrentFieldsCount; i++) {
                 if (!UpdatedFields[Priv->CurrentFields[i]]) if ((error = ALCATEL_DeleteField(s, Note->Location, Priv->CurrentFields[i])) != ERR_NONE) return error;
         }
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_DeleteAllCalendar (GSM_StateMachine *s)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
 
         for (i=0; i<Priv->CalendarItemsCount; i++) {
                 error =  ALCATEL_DeleteItem(s, Priv->CalendarItems[i]);
                 if (error != ERR_NONE) return error;
         }
 
         /* Refresh list */
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
 
         return ERR_NONE;
 }
 
 
 static GSM_Error ALCATEL_GetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm)
 {
                 GSM_Error       error;
                 GSM_CalendarEntryNote;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i;
                 bool            Found = false;
                 bool            DateSet = false;
                 int             alarm_number = alarm->Location;
                 static GSM_DateTimenulldt = {0,0,0,0,0,0,0};
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
-        
+
         for (i=0; i<Priv->CalendarItemsCount; i++) {
                 if ((error = ALCATEL_GetFieldValue(s, Priv->CalendarItems[i], 7))!= ERR_NONE) return error;
                 if (Priv->ReturnType != Alcatel_enum) {
                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                         continue;
                 }
                 if (Priv->ReturnInt == 4 || Priv->ReturnInt == 5) {
                         alarm_number--;
                         if (alarm_number == 0) {
                                 Found = true;
                                 break;
                         }
                 }
         }
 
         if (!Found) return ERR_EMPTY;
 
         Note.Location = Priv->CalendarItems[i];
-        
+
         if ((error = ALCATEL_GetCalendar(s, &Note))!= ERR_NONE) return error;
 
         if (Note.Type == GSM_CAL_ALARM) {
                 alarm->Repeating = false;
         } else {
                 alarm->Repeating = true;
         }
-        
+
         alarm->Text[0] = 0; alarm->Text[1] = 0;
 
 
         for (i = 0; i < Note.EntriesNum; i++) {
                 if (Note.Entries[i].EntryType == CAL_TEXT) {
                         CopyUnicodeString(alarm->Text, Note.Entries[i].Text);
                 } else if (Note.Entries[i].EntryType == CAL_ALARM_DATETIME) {
                         alarm->DateTime = Note.Entries[i].Date;
                         DateSet = false;
                 }
         }
         if (!DateSet) {
                 alarm->DateTime = nulldt;
         }
 
         return ERR_NONE;
 }
 
 
 static GSM_Error ALCATEL_SetAlarm (GSM_StateMachine *s, GSM_Alarm *alarm)
 {
                 GSM_Error       error;
                 GSM_CalendarEntryNote;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 GSM_DateTime    dt;
                 int             i;
                 bool            Found = false;
                 int             alarm_number = alarm->Location;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
 
         for (i=0; i<Priv->CalendarItemsCount; i++) {
                 if ((error = ALCATEL_GetFieldValue(s, Priv->CalendarItems[i], 7))!= ERR_NONE) return error;
                 if (Priv->ReturnType != Alcatel_enum) {
                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                         continue;
                 }
                 if (Priv->ReturnInt == 4 || Priv->ReturnInt == 5) {
                         alarm_number--;
                         if (alarm_number == 0) {
                                 Found = true;
                                 break;
                         }
                 }
         }
-        
+
         if (Found) {
                 Note.Location = Priv->CalendarItems[i];
         }
 
         Note.EntriesNum = 1;
 
         Note.Entries[0].EntryType = CAL_ALARM_DATETIME;
         Note.Entries[0].Date = alarm->DateTime;
 
         if (alarm->Repeating) {
                 Note.Type = GSM_CAL_DAILY_ALARM;
                 GSM_GetCurrentDateTime(&dt);
                 Note.Entries[0].Date.Day = dt.Day;
                 Note.Entries[0].Date.Month = dt.Month;
                 Note.Entries[0].Date.Year = dt.Year;
         } else {
                 Note.Type = GSM_CAL_ALARM;
         }
 
         if (alarm->Text[0] != 0 || alarm->Text[1] != 0) {
                 Note.EntriesNum++;
                 Note.Entries[1].EntryType = CAL_TEXT;
                 CopyUnicodeString(Note.Entries[1].Text, alarm->Text);
         }
 
         if (Found) {
                 return ALCATEL_SetCalendar(s, &Note);
         } else {
                 return ALCATEL_AddCalendar(s, &Note);
         }
 }
 
 
 static GSM_Error ALCATEL_GetToDoStatus(GSM_StateMachine *s, GSM_ToDoStatus *status)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
-        
+
         status->Used = 0;
-        
+
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
 
         status->Used = Priv->ToDoItemsCount;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
 {
                 GSM_Error       error;
                 GSM_DateTime    *dt = NULL;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i;
                 int             j=0;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
         if ((error = ALCATEL_IsIdAvailable(s, ToDo->Location))!= ERR_NONE) {
                 ToDo->EntriesNum = 0;
                 return error;
         }
         if ((error = ALCATEL_GetFields(s, ToDo->Location))!= ERR_NONE) return error;
 
         ToDo->EntriesNum = Priv->CurrentFieldsCount;
 
         for (i=0; i < Priv->CurrentFieldsCount; i++) {
                 if ((error = ALCATEL_GetFieldValue(s, ToDo->Location, Priv->CurrentFields[i]))!= ERR_NONE) return error;
                 switch (Priv->CurrentFields[i]) {
                         case 0:
                                 if (Priv->ReturnType != Alcatel_date) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckDate(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 ToDo->Entries[i-j].EntryType = TODO_END_DATETIME;
                                 ToDo->Entries[i-j].Date = Priv->ReturnDateTime;
                                 break;
                         case 1:
                                 if (Priv->ReturnType != Alcatel_bool) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 ToDo->Entries[i-j].EntryType = TODO_COMPLETED;
                                 ToDo->Entries[i-j].Number = Priv->ReturnInt;
                                 break;
                         case 2:
                                 if (Priv->ReturnType != Alcatel_date) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckDate(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (dt == NULL) {
                                         ToDo->Entries[i-j].EntryType = TODO_ALARM_DATETIME;
                                         ToDo->Entries[i-j].Date = Priv->ReturnDateTime;
                                         dt = &(ToDo->Entries[i-j].Date);
                                 } else {
                                         j++;
                                         ToDo->EntriesNum--;
                                         dt->Day = Priv->ReturnDateTime.Day;
                                         dt->Month = Priv->ReturnDateTime.Month;
                                         dt->Year = Priv->ReturnDateTime.Year;
                                         dt->Timezone = Priv->ReturnDateTime.Timezone;
                                         dt = NULL;
                                 }
                                 break;
                         case 3:
                                 if (Priv->ReturnType != Alcatel_time) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckTime(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (dt == NULL) {
                                         ToDo->Entries[i-j].EntryType = TODO_ALARM_DATETIME;
@@ -3358,634 +3361,643 @@ static GSM_Error ALCATEL_GetToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
                         case 8:
                                 if (Priv->ReturnType != Alcatel_int) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 /* 0xffffffff indicates that there is phone, 0 means none */
                                 if (Priv->ReturnInt == 0xffffffff || Priv->ReturnInt == 0) {
                                         j++;
                                         ToDo->EntriesNum--;
                                 } else {
                                         ToDo->Entries[i-j].EntryType = TODO_CONTACTID;
                                         ToDo->Entries[i-j].Number = Priv->ReturnInt;
                                 }
                                 break;
                         case 9:
                                 if (Priv->ReturnType != Alcatel_phone) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 ToDo->Entries[i-j].EntryType = TODO_PHONE;
                                 CopyUnicodeString(ToDo->Entries[i-j].Text, Priv->ReturnString);
                                 break;
                         case 10:
                                 if (Priv->ReturnType != Alcatel_date) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckDate(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 /* This entry had always same value as the 2nd (alarm date) */
                                 j++;
                                 ToDo->EntriesNum--;
                                 break;
                         case 11:
                                 if (Priv->ReturnType != Alcatel_time) {
                                         smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 if (!CheckTime(&(Priv->ReturnDateTime))) {
                                         smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
                                         ToDo->EntriesNum--;
                                         j++;
                                         break;
                                 }
                                 /* This entry had always same value as the 3rd (alarm time) */
                                 j++;
                                 ToDo->EntriesNum--;
                                 break;
                         default:
                                 ToDo->EntriesNum--;
                                 j++;
                                 smprintf(s,"WARNING: Received unknown field %02X, ignoring. Type = %02X. Value = ", Priv->CurrentFields[i], Priv->ReturnType);
                                 switch (Priv->ReturnType) {
                                         case Alcatel_date:
                                                 smprintf(s, "%d.%d.%d", Priv->ReturnDateTime.Day, Priv->ReturnDateTime.Month, Priv->ReturnDateTime.Year);
                                                 break;
                                         case Alcatel_time:
                                                 smprintf(s, "%d:%d:%d", Priv->ReturnDateTime.Hour, Priv->ReturnDateTime.Minute, Priv->ReturnDateTime.Second);
                                                 break;
                                         case Alcatel_string:
                                         case Alcatel_phone:
                                                 smprintf(s, "\"%s\"",DecodeUnicodeString(Priv->ReturnString));
                                                 break;
                                         case Alcatel_enum:
                                         case Alcatel_bool:
                                         case Alcatel_int:
                                         case Alcatel_byte:
                                                 smprintf(s, "%d", Priv->ReturnInt);
                                                 break;
                                 }
                                 smprintf(s,"\n");
                 }
         }
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetNextToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo, bool start)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
         if (Priv->ToDoItemsCount == 0) return ERR_EMPTY;
-        
+
         if (start) ToDo->Location = 0;
         if ((error = ALCATEL_GetNextId(s, &(ToDo->Location))) != ERR_NONE) return error;
 
         return ALCATEL_GetToDo(s, ToDo);
 }
 
 static GSM_Error ALCATEL_DeleteAllToDo (GSM_StateMachine *s)
 {
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                 int             i;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
 
         for (i=0; i<Priv->ToDoItemsCount; i++) {
                 error =  ALCATEL_DeleteItem(s, Priv->ToDoItems[i]);
                 if (error != ERR_NONE) return error;
         }
 
         /* Refresh list */
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_AddToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
 {
                 GSM_Error       error;
                 unsigned int    val;
                 bool            contact_set = false;
                 bool            phone_set = false;
                 int             i;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeToDo, 0))!= ERR_NONE) return error;
-        
+
         switch (ToDo->Priority) {
                 case GSM_Priority_High:
                         val = 0;
                         break;
                 case GSM_Priority_Low:
                         val = 2;
                         break;
                 case GSM_Priority_Medium:
                 default:
                         val = 1;
                         break;
         }
         /* This one seems to be byte for BF5 and enum for BE5 */
         if (s->Phone.Data.Priv.ALCATEL.ProtocolVersion == V_1_1) {
                if ((error = ALCATEL_CreateField(s, Alcatel_byte, 7, &val)) != ERR_NONE) return error;
         } else {
                if ((error = ALCATEL_CreateField(s, Alcatel_enum, 7, &val)) != ERR_NONE) return error;
         }
 
         for (i = 0; i < ToDo->EntriesNum; i++) {
                 switch (ToDo->Entries[i].EntryType) {
                         case TODO_END_DATETIME:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_date, 0, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
                                 break;
                         case TODO_COMPLETED:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_bool, 1, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
                                 break;
-                        case TODO_ALARM_DATETIME: 
+                        case TODO_ALARM_DATETIME:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_date, 2, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
                                 if ((error = ALCATEL_CreateField(s, Alcatel_time, 3, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
                                 if ((error = ALCATEL_CreateField(s, Alcatel_date, 10, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
                                 if ((error = ALCATEL_CreateField(s, Alcatel_time, 11, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
                                 break;
                         case TODO_TEXT:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_string, 4, ToDo->Entries[i].Text)) != ERR_NONE) return error;
                                 break;
                         case TODO_PRIVATE:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_bool, 5, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
                                 break;
                         case TODO_CATEGORY:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_byte, 6, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
                                 break;
                         case TODO_CONTACTID:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_int, 8, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
                                 contact_set = true;
                                 break;
                         case TODO_PHONE:
                                 if ((error = ALCATEL_CreateField(s, Alcatel_phone, 9, ToDo->Entries[i].Text)) != ERR_NONE) return error;
                                 phone_set = true;
                                 break;
                         default:
                                 break;
                 }
         }
         if (!contact_set) {
                 if (phone_set) {
                         val = 0xffffffff;
                 } else {
                         val = 0;
                 }
                 if ((error = ALCATEL_CreateField(s, Alcatel_int, 8, &val)) != ERR_NONE) return error;
         }
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         ToDo->Location = Priv->CommitedRecord;
         /* Refresh list */
         if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_SetToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
 {
                 GSM_Error       error;
                 unsigned int    val;
                 bool            contact_set = false;
                 bool            phone_set = false;
                 bool            UpdatedFields[12];
                 int             i;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         /* Save modified ToDo */
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
         if ((error = ALCATEL_IsIdAvailable(s, ToDo->Location))!= ERR_NONE) {
                 /* Entry doesn't exist, we will create new one */
                 return ALCATEL_AddToDo(s, ToDo);
         }
         /* Get fields for current item */
         if ((error = ALCATEL_GetFields(s, ToDo->Location))!= ERR_NONE) return error;
-        
+
         for (i = 0; i < 12; i++) { UpdatedFields[i] = false; }
-        
+
         if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeToDo, ToDo->Location))!= ERR_NONE) return error;
 
         switch (ToDo->Priority) {
                 case GSM_Priority_High:
                         val = 0;
                         break;
                 case GSM_Priority_Low:
                         val = 2;
                         break;
                 case GSM_Priority_Medium:
                 default:
                         val = 1;
                         break;
         }
         /* This one seems to be byte for BF5 and enum for BE5 */
         if (s->Phone.Data.Priv.ALCATEL.ProtocolVersion == V_1_1) {
                if ((error = ALCATEL_UpdateField(s, Alcatel_byte, ToDo->Location, 7, &val)) != ERR_NONE) return error;
         } else {
                if ((error = ALCATEL_UpdateField(s, Alcatel_enum, ToDo->Location, 7, &val)) != ERR_NONE) return error;
         }
         UpdatedFields[7] = true;
 
         for (i = 0; i < ToDo->EntriesNum; i++) {
                 switch (ToDo->Entries[i].EntryType) {
                         case TODO_END_DATETIME:
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_date, ToDo->Location, 0, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
-                                UpdatedFields[0] = true; 
+                                UpdatedFields[0] = true;
                                 break;
                         case TODO_COMPLETED:
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_bool, ToDo->Location, 1, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
-                                UpdatedFields[1] = true; 
+                                UpdatedFields[1] = true;
                                 break;
-                        case TODO_ALARM_DATETIME: 
+                        case TODO_ALARM_DATETIME:
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_date, ToDo->Location, 2, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
-                                UpdatedFields[2] = true; 
+                                UpdatedFields[2] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_time, ToDo->Location, 3, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
-                                UpdatedFields[3] = true; 
+                                UpdatedFields[3] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_date, ToDo->Location, 10, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
-                                UpdatedFields[10] = true; 
+                                UpdatedFields[10] = true;
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_time, ToDo->Location, 11, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
-                                UpdatedFields[11] = true; 
+                                UpdatedFields[11] = true;
                                 break;
                         case TODO_TEXT:
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_string, ToDo->Location, 4, ToDo->Entries[i].Text)) != ERR_NONE) return error;
-                                UpdatedFields[4] = true; 
+                                UpdatedFields[4] = true;
                                 break;
                         case TODO_PRIVATE:
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_bool, ToDo->Location, 5, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
-                                UpdatedFields[5] = true; 
+                                UpdatedFields[5] = true;
                                 break;
                         case TODO_CATEGORY:
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_byte, ToDo->Location, 6, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
-                                UpdatedFields[6] = true; 
+                                UpdatedFields[6] = true;
                                 break;
                         case TODO_CONTACTID:
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_int, ToDo->Location, 8, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
-                                UpdatedFields[8] = true; 
+                                UpdatedFields[8] = true;
                                 contact_set = true;
                                 break;
                         case TODO_PHONE:
                                 if ((error = ALCATEL_UpdateField(s, Alcatel_phone, ToDo->Location, 9, ToDo->Entries[i].Text)) != ERR_NONE) return error;
-                                UpdatedFields[9] = true; 
+                                UpdatedFields[9] = true;
                                 phone_set = true;
                                 break;
                         default:
                                 break;
                 }
         }
         if (!contact_set) {
                 if (phone_set) {
                         val = 0xffffffff;
                 } else {
                         val = 0;
                 }
                 if ((error = ALCATEL_UpdateField(s, Alcatel_int, ToDo->Location, 8, &val)) != ERR_NONE) return error;
                 UpdatedFields[8] = true;
         }
 
 
         /* If we didn't update some field, we have to delete it... */
         for (i=0; i<Priv->CurrentFieldsCount; i++) {
                 if (!UpdatedFields[Priv->CurrentFields[i]]) if ((error = ALCATEL_DeleteField(s, ToDo->Location, Priv->CurrentFields[i])) != ERR_NONE) return error;
         }
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_DeleteToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
 {
                 GSM_Error       error;
 
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         /* Delete ToDo */
         if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
         if ((error = ALCATEL_IsIdAvailable(s, ToDo->Location))!= ERR_NONE) {
                 /* Entry was empty => no error */
                 return ERR_NONE;
         }
         error = ALCATEL_DeleteItem(s, ToDo->Location);
         if (error != ERR_NONE) return error;
         /* Refresh list */
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetCategoryStatus(GSM_StateMachine *s, GSM_CategoryStatus *Status)
 {
                 GSM_Alcatel_BinaryTypetype;
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         switch (Status->Type) {
                 case Category_ToDo: type = TypeToDo; break;
                 case Category_Phonebook: type = TypeContacts; break;
                 default: return ERR_NOTSUPPORTED;
         }
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, type, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableCategoryIds(s))!= ERR_NONE) return error;
 
         Status->Used = Priv->CurrentCategoriesCount;
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetCategory(GSM_StateMachine *s, GSM_Category *Category)
 {
                 GSM_Alcatel_BinaryTypetype;
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         switch (Category->Type) {
                 case Category_ToDo: type = TypeToDo; break;
                 case Category_Phonebook: type = TypeContacts; break;
                 default: return ERR_NOTSUPPORTED;
         }
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, type, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetAvailableCategoryIds(s))!= ERR_NONE) return error;
         if ((error = ALCATEL_IsCategoryIdAvailable(s, Category->Location))!= ERR_NONE) return error;
         if ((error = ALCATEL_GetCategoryText(s, Category->Location))!= ERR_NONE) return error;
 
         CopyUnicodeString(Category->Name, Priv->ReturnString);
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_AddCategory(GSM_StateMachine *s, GSM_Category *Category)
 {
                 GSM_Alcatel_BinaryTypetype;
                 GSM_Error       error;
                 GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
 
         switch (Category->Type) {
                 case Category_ToDo: type = TypeToDo; break;
                 case Category_Phonebook: type = TypeContacts; break;
                 default: return ERR_NOTSUPPORTED;
         }
         if ((error = ALCATEL_GoToBinaryState(s, StateSession, type, 0))!= ERR_NONE) return error;
         if ((error = ALCATEL_AddCategoryText(s, Category->Name))!= ERR_NONE) return error;
 
         Category->Location = Priv->ReturnInt;
 
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_GetProductCode(GSM_StateMachine *s, char *value)
 {
        strcpy(value, s->Phone.Data.ModelInfo->model);
        return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_DispatchMessage(GSM_StateMachine *s)
 {
         if (s->Phone.Data.Priv.ALCATEL.Mode == ModeBinary) {
                 return GSM_DispatchMessage(s);
         } else {
                 return ATGEN_DispatchMessage(s);
         }
 }
 
 static GSM_Error ALCATEL_ReplyGeneric(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         /* All error values are just VERY wild guesses, but these seems to work
          * almost as expected ...
          */
         switch (msg.Buffer[8]) {
                 case 0x00: /* no error */
                         return ERR_NONE;
                 case 0x10: /* same thing opened in phone menus */
                         return ERR_INSIDEPHONEMENU;
                 case 0x13:
                         /* This appears in more cases:
                                  *- phone needs PIN code
                                  *- we want to close not opened session
                          * For normal users the second case shouldn't occur...
                          */
                         return ERR_SECURITYERROR;
                 case 0x14: /* Bad data */
                 case 0x2f: /* Closing session when not opened */
                 case 0x1f: /* Bad in/out counter in packet/ack */
                 case 0x0e: /* Openning session when not closed */
                 case 0x0C: /* Bad id (item/database) */
                 case 0x11: /* Bad list id */
                 case 0x2A: /* Nonexistant field/item id */
                 case 0x35: /* Too long text */
                         return ERR_BUG;
                 case 0x23: /* Session opened */
                 case 0x80: /* Transfer started */
                         return ERR_NONE;
                 case 0x82: /* Transfer canceled */
                         return ERR_CANCELED;
                 default:
                         smprintf(s, "WARNING: Packet seems to indicate some status by %02X, ignoring!\n", msg.Buffer[8]);
                         return ERR_NONE;
         }
 }
 
 static GSM_Error ALCATEL_ReplyCommit(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         s->Phone.Data.Priv.ALCATEL.CommitedRecord = msg.Buffer[12] + (msg.Buffer[11] << 8) + (msg.Buffer[10] << 16) + (msg.Buffer[9] << 24);
         smprintf(s, "Created record %08x\n", s->Phone.Data.Priv.ALCATEL.CommitedRecord);
         return ERR_NONE;
 }
 
 static GSM_Error ALCATEL_SetIncomingCB (GSM_StateMachine *s, bool enable)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_SetIncomingCB(s, enable);
 }
 
 static GSM_Error ALCATEL_SetIncomingSMS (GSM_StateMachine *s, bool enable)
 {
         GSM_Error error;
 
         if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
         return ATGEN_SetIncomingSMS(s, enable);
 }
 
+static GSM_Error ALCATEL_SetFastSMSSending(GSM_StateMachine *s, bool enable)
+{
+        GSM_Error error;
+
+        if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+        return ATGEN_SetFastSMSSending(s, enable);
+}
+
 static GSM_Reply_Function ALCATELReplyFunctions[] = {
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelAttach      },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelDetach      },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelCommit      },
         {ALCATEL_ReplyCommit,           "\x02",0x00,0x00, ID_AlcatelCommit2     },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelEnd                 },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelClose       },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelStart       },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelSelect1     },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelSelect2     },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelSelect3     },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelBegin1      },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelBegin2      },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelGetIds1     },
         {ALCATEL_ReplyGetIds,           "\x02",0x00,0x00, ID_AlcatelGetIds2     },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelGetCategories1},
         {ALCATEL_ReplyGetCategories,    "\x02",0x00,0x00, ID_AlcatelGetCategories2},
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelGetCategoryText1},
         {ALCATEL_ReplyGetCategoryText,  "\x02",0x00,0x00, ID_AlcatelGetCategoryText2},
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelAddCategoryText1},
         {ALCATEL_ReplyAddCategoryText,  "\x02",0x00,0x00, ID_AlcatelAddCategoryText2},
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelGetFields1  },
         {ALCATEL_ReplyGetFields,        "\x02",0x00,0x00, ID_AlcatelGetFields2  },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelGetFieldValue1},
         {ALCATEL_ReplyGetFieldValue,    "\x02",0x00,0x00, ID_AlcatelGetFieldValue2},
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelDeleteField         },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelDeleteItem1         },
         {ALCATEL_ReplyDeleteItem,       "\x02",0x00,0x00, ID_AlcatelDeleteItem2         },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelCreateField         },
         {ALCATEL_ReplyGeneric,          "\x02",0x00,0x00, ID_AlcatelUpdateField         },
         {NULL,                          "\x00",0x00,0x00, ID_None               }
 };
 
 GSM_Phone_Functions ALCATELPhone = {
         /* AFAIK, any 50[0123] phone should work, but I'm not sure whether all
          * they were ever really released, if yes add them here also.
          */
         "alcatel|OT501|OT701|OT715|OT535|OT735|BE5|BF5|BH4",
         ALCATELReplyFunctions,
         ALCATEL_Initialise,
         ALCATEL_Terminate,
         ALCATEL_DispatchMessage,
                 NOTSUPPORTED,                   /*      ShowStartInfo   */
         ALCATEL_GetManufacturer,
         ALCATEL_GetModel,
         ALCATEL_GetFirmware,
         ALCATEL_GetIMEI,
                 NOTSUPPORTED,                   /*      GetOriginalIMEI         */
                 NOTSUPPORTED,                   /*      GetManufactureMonth*/
         ALCATEL_GetProductCode,
                 NOTSUPPORTED,                   /*      GetHardware     */
                 NOTSUPPORTED,                   /*      GetPPM          */
         ALCATEL_GetSIMIMSI,
         ALCATEL_GetDateTime,
         ALCATEL_SetDateTime,
         ALCATEL_GetAlarm,
         ALCATEL_SetAlarm,
                 NOTSUPPORTED,                   /*      GetLocale       */
                 NOTSUPPORTED,                   /*      SetLocale       */
         ALCATEL_PressKey,
         ALCATEL_Reset,
         ALCATEL_ResetPhoneSettings,
         ALCATEL_EnterSecurityCode,
         ALCATEL_GetSecurityStatus,
         ALCATEL_GetDisplayStatus,
         ALCATEL_SetAutoNetworkLogin,
         ALCATEL_GetBatteryCharge,
         ALCATEL_GetSignalStrength,
         ALCATEL_GetNetworkInfo,
         ALCATEL_GetCategory,
         ALCATEL_AddCategory,
         ALCATEL_GetCategoryStatus,
         ALCATEL_GetMemoryStatus,
         ALCATEL_GetMemory,
         ALCATEL_GetNextMemory,
         ALCATEL_SetMemory,
         ALCATEL_AddMemory,
         ALCATEL_DeleteMemory,
         ALCATEL_DeleteAllMemory,
                 NOTSUPPORTED,                   /*      GetSpeedDial    */
                 NOTSUPPORTED,                   /*      SetSpeedDial    */
         ALCATEL_GetSMSC,
         ALCATEL_SetSMSC,
         ALCATEL_GetSMSStatus,
         ALCATEL_GetSMS,
         ALCATEL_GetNextSMS,
                 NOTSUPPORTED,                   /*      SetSMS          */
         ALCATEL_AddSMS,
         ALCATEL_DeleteSMS,
         ALCATEL_SendSMS,
         ALCATEL_SendSavedSMS,
+        ALCATEL_SetFastSMSSending,
         ALCATEL_SetIncomingSMS,
         ALCATEL_SetIncomingCB,
         ALCATEL_GetSMSFolders,
                 NOTSUPPORTED,                   /*      AddSMSFolder    */
                 NOTSUPPORTED,                   /*      DeleteSMSFolder         */
         ALCATEL_DialVoice,
         ALCATEL_AnswerCall,
         ALCATEL_CancelCall,
                 NOTSUPPORTED,                   /*      HoldCall        */
                 NOTSUPPORTED,                   /*      UnholdCall      */
                 NOTSUPPORTED,                   /*      ConferenceCall          */
                 NOTSUPPORTED,                   /*      SplitCall       */
                 NOTSUPPORTED,                   /*      TransferCall    */
                 NOTSUPPORTED,                   /*      SwitchCall      */
                 NOTSUPPORTED,                   /*      GetCallDivert   */
                 NOTSUPPORTED,                   /*      SetCallDivert   */
                 NOTSUPPORTED,                   /*      CancelAllDiverts*/
                 NONEFUNCTION,                   /*      SetIncomingCall         */
                 NOTSUPPORTED,                   /*      SetIncomingUSSD         */
         ALCATEL_SendDTMF,
                 NOTSUPPORTED,                   /*      GetRingtone     */
                 NOTSUPPORTED,                   /*      SetRingtone     */
                 NOTSUPPORTED,                   /*      GetRingtonesInfo*/
                 NOTSUPPORTED,                   /*      DeleteUserRingtones*/
                 NOTSUPPORTED,                   /*      PlayTone        */
                 NOTSUPPORTED,                   /*      GetWAPBookmark  */
                 NOTSUPPORTED,                   /*      SetWAPBookmark  */
                 NOTSUPPORTED,                   /*      DeleteWAPBookmark*/
                 NOTSUPPORTED,                   /*      GetWAPSettings  */
                 NOTSUPPORTED,                   /*      SetWAPSettings  */
                 NOTSUPPORTED,                   /*      GetMMSSettings  */
                 NOTSUPPORTED,                   /*      SetMMSSettings  */
                 NOTSUPPORTED,                   /*      GetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      GetChatSettings         */
                 NOTSUPPORTED,                   /*      SetChatSettings         */
                 NOTSUPPORTED,                   /*      GetBitmap       */
                 NOTSUPPORTED,                   /*      SetBitmap       */
         ALCATEL_GetToDoStatus,
         ALCATEL_GetToDo,
         ALCATEL_GetNextToDo,
         ALCATEL_SetToDo,
         ALCATEL_AddToDo,
         ALCATEL_DeleteToDo,
         ALCATEL_DeleteAllToDo,
         ALCATEL_GetCalendarStatus,
         ALCATEL_GetCalendar,
         ALCATEL_GetNextCalendar,
         ALCATEL_SetCalendar,
         ALCATEL_AddCalendar,
         ALCATEL_DeleteCalendar,
         ALCATEL_DeleteAllCalendar,
                 NOTSUPPORTED,                   /*      GetCalendarSettings*/
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTSUPPORTED,                   /*      GetNote                 */
+                NOTSUPPORTED,                   /*      GetNextNote     */
                 NOTSUPPORTED,                   /*      GetProfile      */
                 NOTSUPPORTED,                   /*      SetProfile      */
                 NOTSUPPORTED,                   /*      GetFMStation    */
                 NOTSUPPORTED,                   /*      SetFMStation    */
                 NOTSUPPORTED,                   /*      ClearFMStations         */
                 NOTSUPPORTED,                   /*      GetNextFileFolder*/
                 NOTSUPPORTED,                   /*      GetFilePart     */
                 NOTSUPPORTED,                   /*      AddFilePart     */
                 NOTSUPPORTED,                   /*      GetFileSystemStatus*/
                 NOTSUPPORTED,                   /*      DeleteFile      */
                 NOTSUPPORTED,                   /*      AddFolder       */
                 NOTSUPPORTED,                   /*      GetGPRSAccessPoint*/
                 NOTSUPPORTED                    /*      SetGPRSAccessPoint*/
 };
 
 #endif
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/at/atgen.c b/gammu/emb/common/phone/at/atgen.c
index 1834f15..ba23eb2 100644
--- a/gammu/emb/common/phone/at/atgen.c
+++ b/gammu/emb/common/phone/at/atgen.c
@@ -1,579 +1,624 @@
 /* (c) 2002-2004 by Marcin Wiacek and Michal Cihar */
                                            
 #include "../../gsmstate.h"
 
 #ifdef GSM_ENABLE_ATGEN
 
 #include <string.h>
 #include <time.h>
 #include <ctype.h>
 
 #include "../../gsmcomon.h"
 #include "../../misc/coding/coding.h"
 #include "../../service/sms/gsmsms.h"
 #include "../pfunc.h"
+
 #include "atgen.h"
 
+#include "samsung.h"
+#include "siemens.h"
+#include "sonyeric.h"
+
 #ifdef GSM_ENABLE_ALCATEL
-        extern GSM_Error ALCATEL_ProtocolVersionReply(GSM_Protocol_Message msg, GSM_StateMachine *s);
+GSM_Error ALCATEL_ProtocolVersionReply (GSM_Protocol_Message, GSM_StateMachine *);
 #endif
 
-        extern GSM_Error ATGEN_CMS35ReplyGetBitmap(GSM_Protocol_Message msg, GSM_StateMachine *s);
-        extern GSM_Error ATGEN_CMS35ReplySetBitmap(GSM_Protocol_Message msg, GSM_StateMachine *s);
-        extern GSM_Error ATGEN_CMS35ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s);
-        extern GSM_Error ATGEN_CMS35ReplySetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s);
-        extern GSM_Error ATGEN_CMS35ReplyGetNextCal(GSM_Protocol_Message msg, GSM_StateMachine *s);
-        extern GSM_Error ATGEN_CMS35ReplySetCalendar(GSM_Protocol_Message msg, GSM_StateMachine *s);
-        extern GSM_Error ATGEN_CMS35ReplyDeleteCalendar(GSM_Protocol_Message msg, GSM_StateMachine *s);
-        extern GSM_Error ATGEN_SL45ReplyGetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s);
-
-        extern GSM_Error ATGEN_GetRingtone      (GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone);
-        extern GSM_Error ATGEN_SetRingtone      (GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength);
-        extern GSM_Error ATGEN_GetBitmap        (GSM_StateMachine *s, GSM_Bitmap *Bitmap);
-        extern GSM_Error ATGEN_SetBitmap        (GSM_StateMachine *s, GSM_Bitmap *Bitmap);
-        extern GSM_Error SIEMENS_GetNextCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start);
-        extern GSM_Error SIEMENS_AddCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note);
-        extern GSM_Error SIEMENS_DelCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note);
-
-        extern GSM_Error SONYERIC_GetNextCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start);
-        extern GSM_Error SONYERIC_GetNextToDo   (GSM_StateMachine *s, GSM_ToDoEntry *ToDo, bool start);
-        extern GSM_Error SONYERIC_GetToDoStatus         (GSM_StateMachine *s, GSM_ToDoStatus *status);
-        extern GSM_Error SONYERIC_AddCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note);
-        extern GSM_Error SONYERIC_AddToDo       (GSM_StateMachine *s, GSM_ToDoEntry *ToDo);
-        extern GSM_Error SONYERIC_DeleteAllToDo         (GSM_StateMachine *s);
-        extern GSM_Error SONYERIC_DelCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note);
-        extern GSM_Error SONYERIC_GetCalendarStatus(GSM_StateMachine *s, GSM_CalendarStatus *Status);
 
 typedef struct {
         int     Number;
         char    Text[60];
 } ATErrorCode;
 
 static ATErrorCode CMSErrorCodes[] = {
         /*
          * Error codes not specified here were either undefined or reserved in my
          * copy of specifications, if you have newer one, please fill in the gaps.
          */
         /* 0...127 from GSM 04.11 Annex E-2 */
         {1,    "Unassigned (unallocated) number"},
         {8,    "Operator determined barring"},
         {10,   "Call barred"},
         {21,   "Short message transfer rejected"},
         {27,   "Destination out of service"},
         {28,   "Unidentified subscriber"},
         {29,   "Facility rejected"},
         {30,   "Unknown subscriber"},
         {38,   "Network out of order"},
         {41,   "Temporary failure"},
         {42,   "Congestion"},
         {47,   "Resources unavailable, unspecified"},
         {50,   "Requested facility not subscribed"},
         {69,   "Requested facility not implemented"},
         {81,   "Invalid short message transfer reference value"},
         {95,   "Invalid message, unspecified"},
         {96,   "Invalid mandatory information"},
         {97,   "Message type non-existent or not implemented"},
         {98,   "Message not compatible with short message protocol state"},
         {99,   "Information element non-existent or not implemented"},
         {111,  "Protocol error, unspecified"},
         {127,  "Interworking, unspecified"},
         /* 128...255 from GSM 03.40 subclause 9.2.3.22 */
         {0x80, "Telematic interworking not supported"},
         {0x81, "Short message Type 0 not supported"},
         {0x82, "Cannot replace short message"},
         {0x8F, "Unspecified TP-PID error"},
         {0x90, "Data coding scheme (alphabet) not supported"},
         {0x91, "Message class not supported"},
         {0x9F, "Unspecified TP-DCS error"},
         {0xA0, "Command cannot be actioned"},
         {0xA1, "Command unsupported"},
         {0xAF, "Unspecified TP-Command error"},
         {0xB0, "TPDU not supported"},
         {0xC0, "SC busy"},
         {0xC1, "No SC subscription"},
         {0xC2, "SC system failure"},
         {0xC3, "Invalid SME address"},
         {0xC4, "Destination SME barred"},
         {0xC5, "SM Rejected-Duplicate SM"},
         {0xC6, "TP-VPF not supported"},
         {0xC7, "TP-VP not supported"},
         {0xD0, "SIM SMS storage full"},
         {0xD1, "No SMS storage capability in SIM"},
         {0xD2, "Error in MS"},
         {0xD3, "Memory Capacity Exceede"},
         {0xD4, "SIM Application Toolkit Busy"},
         {0xFF, "Unspecified error cause"},
         /* 300...511 from GSM 07.05 subclause 3.2.5 */
         {300,  "ME failure"},
         {301,  "SMS service of ME reserved"},
         {302,  "operation not allowed"},
         {303,  "operation not supported"},
         {304,  "invalid PDU mode parameter"},
         {305,  "invalid text mode parameter"},
         {310,  "SIM not inserted"},
         {311,  "SIM PIN required"},
         {312,  "PH-SIM PIN required"},
         {313,  "SIM failure"},
         {314,  "SIM busy"},
         {315,  "SIM wrong"},
         {316,  "SIM PUK required"},
         {317,  "SIM PIN2 required"},
         {318,  "SIM PUK2 required"},
         {320,  "memory failure"},
         {321,  "invalid memory index"},
         {322,  "memory full"},
         {330,  "SMSC address unknown"},
         {331,  "no network service"},
         {332,  "network timeout"},
         {340,  "no CNMA acknowledgement expected"},
         {500,  "unknown error"},
         /* > 512 are manufacturer specific according to GSM 07.05 subclause 3.2.5 */
         {-1,   ""}
 };
 
 static ATErrorCode CMEErrorCodes[] = {
         /* CME Error codes from GSM 07.07 section 9.2 */
         {0,   "phone failure"},
         {1,   "no connection to phone"},
         {2,   "phone-adaptor link reserved"},
         {3,   "operation not allowed"},
         {4,   "operation not supported"},
         {5,   "PH-SIM PIN required"},
         {10,  "SIM not inserted"},
         {11,  "SIM PIN required"},
         {12,  "SIM PUK required"},
         {13,  "SIM failure"},
         {14,  "SIM busy"},
         {15,  "SIM wrong"},
         {16,  "incorrect password"},
         {17,  "SIM PIN2 required"},
         {18,  "SIM PUK2 required"},
         {20,  "memory full"},
         {21,  "invalid index"},
         {22,  "not found"},
         {23,  "memory failure"},
         {24,  "text string too long"},
         {25,  "invalid characters in text string"},
         {26,  "dial string too long"},
         {27,  "invalid characters in dial string"},
         {30,  "no network service"},
         {31,  "network timeout"},
         {100, "unknown"},
 };
 
 
 GSM_Error ATGEN_HandleCMEError(GSM_StateMachine *s)
 {
         GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
 
         if (Priv->ErrorCode == 0) {
                 smprintf(s, "CME Error occured, but it's type not detected\n");
         } else if (Priv->ErrorText == NULL) {
                 smprintf(s, "CME Error %i, no description available\n", Priv->ErrorCode);
         } else {
                 smprintf(s, "CME Error %i: \"%s\"\n", Priv->ErrorCode, Priv->ErrorText);
         }
         /* For error codes descriptions see table a bit above */
         switch (Priv->ErrorCode) {
+                case -1:
+                        return ERR_EMPTY;
                 case 3:
                         return ERR_PERMISSION;
                 case 4:
                         return ERR_NOTSUPPORTED;
                 case 5:
                 case 11:
                 case 12:
                 case 16:
                 case 17:
                 case 18:
                         return ERR_SECURITYERROR;
                 case 20:
                         return ERR_FULL;
                 case 21:
                         return ERR_INVALIDLOCATION;
                 case 22:
                         return ERR_EMPTY;
                 case 23:
                         return ERR_MEMORY;
                 case 24:
                 case 25:
                 case 26:
                 case 27:
                         return ERR_INVALIDDATA;
                 default:
                         return ERR_UNKNOWN;
         }
 }
 
 GSM_Error ATGEN_HandleCMSError(GSM_StateMachine *s)
 {
         GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
 
         if (Priv->ErrorCode == 0) {
                 smprintf(s, "CMS Error occured, but it's type not detected\n");
         } else if (Priv->ErrorText == NULL) {
                 smprintf(s, "CMS Error %i, no description available\n", Priv->ErrorCode);
         } else {
                 smprintf(s, "CMS Error %i: \"%s\"\n", Priv->ErrorCode, Priv->ErrorText);
         }
         /* For error codes descriptions see table a bit above */
         switch (Priv->ErrorCode) {
         case 304:
                     return ERR_NOTSUPPORTED; 
         case 305:
                     return ERR_BUG; 
         case 311:
         case 312:
         case 316:
         case 317:
         case 318:
                     return ERR_SECURITYERROR;
         case 322:
                     return ERR_FULL;
         case 321:
                     return ERR_INVALIDLOCATION;
         default:
                 return ERR_UNKNOWN;
         }
 }
 
 /* FIXME: Function doesn't respect quoting of parameters and thus +FOO:
  *        "ab","cd,ef" will consider as three arguments: "ab" >> "cd >> ef"
  */
 int ATGEN_ExtractOneParameter(unsigned char *input, unsigned char *output)
 {
         int position=0;
 
         while (*input!=',' && *input!=0x0d && *input!=0x00) {
                 *output=*input;
                         input++;
                         output++;
                 position++;
         }
         *output=0;
         position++;
         return position;
 }
 
 void ATGEN_DecodeDateTime(GSM_DateTime *dt, unsigned char *input)
 {
-        dt->Year=2000+(*input-'0')*10;     input++;
+        /* Samsung phones report year as %d instead of %02d */
+        if (input[2] == '/') {
+                dt->Year=(*input-'0')*10;
+                input++;
+        } else {
+                dt->Year=0;
+        }
+
         dt->Year=dt->Year+(*input-'0');    input++;
+        dt->Year+=2000;
 
         input++;
         dt->Month=(*input-'0')*10;         input++;
         dt->Month=dt->Month+(*input-'0');  input++;
 
         input++;
         dt->Day=(*input-'0')*10;           input++;
         dt->Day=dt->Day+(*input-'0');      input++;
 
         input++;
         dt->Hour=(*input-'0')*10;          input++;
         dt->Hour=dt->Hour+(*input-'0');    input++;
 
         input++;
         dt->Minute=(*input-'0')*10;        input++;
         dt->Minute=dt->Minute+(*input-'0');input++;
 
         input++;
         dt->Second=(*input-'0')*10;        input++;
         dt->Second=dt->Second+(*input-'0');input++;
 
         if (input!=NULL) {
                 input++;
                 dt->Timezone=(*input-'0')*10;          input++;
                 dt->Timezone=dt->Timezone+(*input-'0');input++;
                 input=input-2;
                 if (*input=='-') dt->Timezone=-dt->Timezone;
         }
 }
 
 GSM_Error ATGEN_DispatchMessage(GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData     *Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_Protocol_Message    *msg= s->Phone.Data.RequestMsg;
                 int                     i= 0, j, k;
         char                    *err, *line;
                 ATErrorCode     *ErrorCodes = NULL;
 
         SplitLines(msg->Buffer, msg->Length, &Priv->Lines, "\x0D\x0A", 2, true);
 
         /* Find number of lines */
         while (Priv->Lines.numbers[i*2+1] != 0) {
                 /* FIXME: handle special chars correctly */
                 smprintf(s, "%i \"%s\"\n",i+1,GetLineString(msg->Buffer,Priv->Lines,i+1));
                 i++;
         }
 
                 Priv->ReplyState = AT_Reply_Unknown;
                 Priv->ErrorText     = NULL;
                 Priv->ErrorCode     = 0;
 
         line = GetLineString(msg->Buffer,Priv->Lines,i);
                 if (!strcmp(line,"OK"))         Priv->ReplyState = AT_Reply_OK;
                 if (!strcmp(line,"> "))         Priv->ReplyState = AT_Reply_SMSEdit;
                 if (!strcmp(line,"CONNECT"))Priv->ReplyState = AT_Reply_Connect;
                 if (!strcmp(line,"ERROR"  ))Priv->ReplyState = AT_Reply_Error;
         if (!strncmp(line,"+CME ERROR:",11)) {
                 Priv->ReplyState = AT_Reply_CMEError;
                 ErrorCodes = CMEErrorCodes;
         }
         if (!strncmp(line,"+CMS ERROR:",11)) {
                 Priv->ReplyState = AT_Reply_CMSError;
                 ErrorCodes = CMSErrorCodes;
         }
+
+        /* FIXME: Samsung phones can answer +CME ERROR:-1 meaning empty location */
+        if (Priv->ReplyState == AT_Reply_CMEError && Priv->Manufacturer == AT_Samsung) {
+                err = line + 11;
+                Priv->ErrorCode = atoi(err);
+
+                if (Priv->ErrorCode == -1) {
+                        Priv->ErrorText = "[Samsung] Empty location";
+                        return GSM_DispatchMessage(s);
+                }
+        }
+
         if (Priv->ReplyState == AT_Reply_CMEError || Priv->ReplyState == AT_Reply_CMSError) {
                 j = 0;
                 /* One char behind +CM[SE] ERROR */
                 err = line + 12;
                 while (err[j] && !isalnum(err[j])) j++;
                 if (isdigit(err[j])) {
                         Priv->ErrorCode = atoi(&(err[j]));
                         k = 0;
                         while (ErrorCodes[k].Number != -1) {
                                 if (ErrorCodes[k].Number == Priv->ErrorCode) {
                                         Priv->ErrorText = (char *)&(ErrorCodes[k].Text);
                                         break;
                                 }
                                 k++;
                         }
                 } else if (isalpha(err[j])) {
                         k = 0;
                         while (ErrorCodes[k].Number != -1) {
                                 if (!strncmp(err + j, ErrorCodes[k].Text, strlen(ErrorCodes[k].Text))) {
                                         Priv->ErrorCode = ErrorCodes[k].Number;
                                         Priv->ErrorText = (char *)&(ErrorCodes[k].Text);
                                         break;
                                 }
                                 k++;
                         }
                 }
         }
         return GSM_DispatchMessage(s);
 }
 
 GSM_Error ATGEN_GenericReply(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
                 case AT_Reply_OK:
                 case AT_Reply_Connect:
                         return ERR_NONE;
                 case AT_Reply_Error:
                         return ERR_UNKNOWN;
                 case AT_Reply_CMSError:
                         return ATGEN_HandleCMSError(s);
                 case AT_Reply_CMEError:
                         return ATGEN_HandleCMEError(s);
                 default:
                         break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
+GSM_Error ATGEN_ReplyGetUSSD(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+                unsigned char buffer[2000],buffer2[4000];
+                int     i = 10;
+
+                /* Ugly hack */
+        while (msg.Buffer[i]!=13) i++;
+        i = i - 6;
+        memcpy(buffer,msg.Buffer+10,i-11);
+        buffer[i-11] = 0x00;
+
+        smprintf(s, "USSD reply: \"%s\"\n",buffer);
+
+        if (s->Phone.Data.EnableIncomingUSSD && s->User.IncomingUSSD!=NULL) {
+                EncodeUnicode(buffer2,buffer,strlen(buffer));
+                s->User.IncomingUSSD(s->CurrentConfig->Device, buffer2);
+        }
+
+        return ERR_NONE;
+}
+
+GSM_Error ATGEN_SetIncomingUSSD(GSM_StateMachine *s, bool enable)
+{
+        GSM_Error error;
+
+        if (enable) {
+                smprintf(s, "Enabling incoming USSD\n");
+                error=GSM_WaitFor (s, "AT+CUSD=1\r", 10, 0x00, 3, ID_SetUSSD);
+        } else {
+                smprintf(s, "Disabling incoming USSD\n");
+                error=GSM_WaitFor (s, "AT+CUSD=0\r", 10, 0x00, 3, ID_SetUSSD);
+        }
+        if (error==ERR_NONE) s->Phone.Data.EnableIncomingUSSD = enable;
+        return error;
+}
+
 GSM_Error ATGEN_ReplyGetModel(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_Phone_Data  *Data = &s->Phone.Data;
 
         if (s->Phone.Data.Priv.ATGEN.ReplyState != AT_Reply_OK) return ERR_NOTSUPPORTED;
 
         if (strlen(GetLineString(msg.Buffer, Priv->Lines, 2)) <= MAX_MODEL_LENGTH) {
                 CopyLineString(Data->Model, msg.Buffer, Priv->Lines, 2);
 
                 /* Sometimes phone adds this before manufacturer (Sagem) */
                 if (strncmp("+CGMM: ", Data->Model, 7) == 0) {
                         memmove(Data->Model, Data->Model + 7, strlen(Data->Model + 7) + 1);
                 }
 
                 Data->ModelInfo = GetModelData(NULL,Data->Model,NULL);
                 if (Data->ModelInfo->number[0] == 0) Data->ModelInfo = GetModelData(NULL,NULL,Data->Model);
                 if (Data->ModelInfo->number[0] == 0) Data->ModelInfo = GetModelData(Data->Model,NULL,NULL);
 
                 if (Data->ModelInfo->number[0] != 0) strcpy(Data->Model,Data->ModelInfo->number);
 
                         if (strstr(msg.Buffer,"Nokia")) Priv->Manufacturer = AT_Nokia;
                         else if (strstr(msg.Buffer,"M20")) Priv->Manufacturer = AT_Siemens;
                         else if (strstr(msg.Buffer,"MC35")) Priv->Manufacturer = AT_Siemens;
+                        else if (strstr(msg.Buffer,"TC35")) Priv->Manufacturer = AT_Siemens;
                         else if (strstr(msg.Buffer, "iPAQ")) Priv->Manufacturer = AT_HP;
 
                         if (strstr(msg.Buffer,"M20"))   strcpy(Data->Model,"M20");
                         else if (strstr(msg.Buffer,"MC35")) strcpy(Data->Model,"MC35");
+                        else if (strstr(msg.Buffer,"TC35")) strcpy(Data->Model,"TC35");
                         else if (strstr(msg.Buffer, "iPAQ")) strcpy(Data->Model,"iPAQ");
         } else {
                 smprintf(s, "WARNING: Model name too long, increase MAX_MODEL_LENGTH to at least %zd\n", strlen(GetLineString(msg.Buffer, Priv->Lines, 2)));
         }
 
         return ERR_NONE;
 }
 
 GSM_Error ATGEN_GetModel(GSM_StateMachine *s)
 {
         GSM_Error error;
 
         if (s->Phone.Data.Model[0] != 0) return ERR_NONE;
 
         smprintf(s, "Getting model\n");
         error=GSM_WaitFor (s, "AT+CGMM\r", 8, 0x00, 3, ID_GetModel);
         if (error==ERR_NONE) {
                 if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL ||
                     s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE) {
                         smprintf(s, "[Connected model  - \"%s\"]\n",s->Phone.Data.Model);
                 }
         }
         return error;
 }
 
 GSM_Error ATGEN_ReplyGetManufacturer(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
 
         switch (Priv->ReplyState) {
         case AT_Reply_OK:
                 smprintf(s, "Manufacturer info received\n");
                 Priv->Manufacturer = AT_Unknown;
                 if (strlen(GetLineString(msg.Buffer, Priv->Lines, 2)) <= MAX_MANUFACTURER_LENGTH) {
                         CopyLineString(s->Phone.Data.Manufacturer, msg.Buffer, Priv->Lines, 2);
                 } else {
                         smprintf(s, "WARNING: Manufacturer name too long, increase MAX_MANUFACTURER_LENGTH to at least %zd\n", strlen(GetLineString(msg.Buffer, Priv->Lines, 2)));
                         s->Phone.Data.Manufacturer[0] = 0;
                 }
                 /* Sometimes phone adds this before manufacturer (Sagem) */
                 if (strncmp("+CGMI: ", s->Phone.Data.Manufacturer, 7) == 0) {
                         memmove(s->Phone.Data.Manufacturer, s->Phone.Data.Manufacturer + 7, strlen(s->Phone.Data.Manufacturer + 7) + 1);
                 }
                 if (strstr(msg.Buffer,"Falcom")) {
                         smprintf(s, "Falcom\n");
                         strcpy(s->Phone.Data.Manufacturer,"Falcom");
                         Priv->Manufacturer = AT_Falcom;
                         if (strstr(msg.Buffer,"A2D")) {
                                 strcpy(s->Phone.Data.Model,"A2D");
                                 s->Phone.Data.ModelInfo = GetModelData(NULL,s->Phone.Data.Model,NULL);
                                 smprintf(s, "Model A2D\n");
                         }
                 }
                 if (strstr(msg.Buffer,"Nokia")) {
                         smprintf(s, "Nokia\n");
                         strcpy(s->Phone.Data.Manufacturer,"Nokia");
                         Priv->Manufacturer = AT_Nokia;
                 }
                 if (strstr(msg.Buffer,"SIEMENS")) {
                         smprintf(s, "Siemens\n");
                         strcpy(s->Phone.Data.Manufacturer,"Siemens");
                         Priv->Manufacturer = AT_Siemens;
                 }
                 if (strstr(msg.Buffer,"ERICSSON")) {
                         smprintf(s, "Ericsson\n");
                         strcpy(s->Phone.Data.Manufacturer,"Ericsson");
                         Priv->Manufacturer = AT_Ericsson;
                 }
                 if (strstr(msg.Buffer,"iPAQ")) {
                         smprintf(s, "iPAQ\n");
                         strcpy(s->Phone.Data.Manufacturer,"HP");
                         Priv->Manufacturer = AT_HP;
                 }
                 if (strstr(msg.Buffer,"ALCATEL")) {
                         smprintf(s, "Alcatel\n");
                         strcpy(s->Phone.Data.Manufacturer,"Alcatel");
                         Priv->Manufacturer = AT_Alcatel;
                 }
                 if (strstr(msg.Buffer,"SAGEM")) {
                         smprintf(s, "Sagem\n");
                         strcpy(s->Phone.Data.Manufacturer,"Sagem");
                         Priv->Manufacturer = AT_Sagem;
                 }
+                if (strstr(msg.Buffer,"Samsung")) {
+                        smprintf(s, "Samsung\n");
+                        strcpy(s->Phone.Data.Manufacturer,"Samsung");
+                        Priv->Manufacturer = AT_Samsung;
+                }
                 return ERR_NONE;
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
         default:
                 break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_GetManufacturer(GSM_StateMachine *s)
 {
         if (s->Phone.Data.Manufacturer[0] != 0) return ERR_NONE;
 
         return GSM_WaitFor (s, "AT+CGMI\r", 8, 0x00, 4, ID_GetManufacturer);
 }
 
 GSM_Error ATGEN_ReplyGetFirmwareCGMR(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 unsigned int    i = 0;
 
         strcpy(s->Phone.Data.Version,"unknown");
         s->Phone.Data.VerNum = 0;
         if (Priv->ReplyState == AT_Reply_OK) {
                 CopyLineString(s->Phone.Data.Version, msg.Buffer, Priv->Lines, 2);
                 /* Sometimes phone adds this before manufacturer (Sagem) */
                 if (strncmp("+CGMR: ", s->Phone.Data.Version, 7) == 0) {
                         memmove(s->Phone.Data.Version, s->Phone.Data.Version + 7, strlen(s->Phone.Data.Version + 7) + 1);
                 }
         }
         if (Priv->Manufacturer == AT_Ericsson) {
                 while (1) {
                         if (s->Phone.Data.Version[i] == 0x20) {
                                 s->Phone.Data.Version[i] = 0x00;
                                 break;
                         }
                         if (i == strlen(s->Phone.Data.Version)) break;
                         i++;
                 }
         }
         smprintf(s, "Received firmware version: \"%s\"\n",s->Phone.Data.Version);
         GSM_CreateFirmwareNumber(s);
         return ERR_NONE;
 }
 
 GSM_Error ATGEN_ReplyGetFirmwareATI(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
 
         switch (Priv->ReplyState) {
         case AT_Reply_OK:
         //      strcpy(Data->Version,"0.00");
         //      *Data->VersionNum=0;
         //      if (Data->Priv.ATGEN.ReplyState==AT_Reply_OK) {
         //              CopyLineString(Data->Version, msg.Buffer, Priv->Lines, 2);
         //      }
         //      smprintf(s, "Received firmware version: \"%s\"\n",Data->Version);
         //      GSM_CreateFirmwareNumber(Data);
         //      return ERR_NONE;
         case AT_Reply_Error:
                 return ERR_NOTSUPPORTED;
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
         default:
                 break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_GetFirmware(GSM_StateMachine *s)
 {
         GSM_Error error;
 
         if (s->Phone.Data.Version[0] != 0) return ERR_NONE;
 
         error=ATGEN_GetManufacturer(s);
         if (error != ERR_NONE) return error;
 
         //smprintf(s, "Getting firmware - method 1\n");
         //error=GSM_WaitFor (s, "ATI\r", 4, 0x00, 3, ID_GetFirmware);
         //if (error != ERR_NONE) {
                 smprintf(s, "Getting firmware - method 2\n");
                 error=GSM_WaitFor (s, "AT+CGMR\r", 8, 0x00, 3, ID_GetFirmware);
         //}
         if (error==ERR_NONE) {
                 if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL ||
                     s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE) {
                         smprintf(s, "[Firmware version - \"%s\"]\n",s->Phone.Data.Version);
                 }
         }
         return error;
 }
 
 GSM_Error ATGEN_Initialise(GSM_StateMachine *s)
 {
         GSM_Phone_ATGENData     *Priv = &s->Phone.Data.Priv.ATGEN;
@@ -581,468 +626,479 @@ GSM_Error ATGEN_Initialise(GSM_StateMachine *s)
             char                    buff[2];
 
                 Priv->SMSMode           = 0;
                 Priv->Manufacturer      = 0;
                 Priv->PhoneSMSMemory    = 0;
                 Priv->CanSaveSMS        = false;
                 Priv->SIMSMSMemory      = 0;
                 Priv->SMSMemory                 = 0;
                 Priv->PBKMemory                 = 0;
                 Priv->PBKSBNR           = 0;
                 Priv->PBKCharset        = 0;
                 Priv->UCS2CharsetFailed         = false;
                 Priv->NonUCS2CharsetFailed= false;
                 Priv->PBKMemories[0]    = 0;
                 Priv->FirstCalendarPos  = 0;
                 Priv->NextMemoryEntry   = 0;
                 Priv->FirstMemoryEntry  = 0;
                 Priv->file.Used         = 0;
                 Priv->file.Buffer       = NULL;
                 Priv->OBEX              = false;
                 Priv->MemorySize        = 0;
                 Priv->TextLength        = 0;
                 Priv->NumberLength      = 0;
 
                 Priv->ErrorText                 = NULL;
 
         if (s->ConnectionType != GCT_IRDAAT && s->ConnectionType != GCT_BLUEAT) {
                 /* We try to escape AT+CMGS mode, at least Siemens M20
                  * then needs to get some rest
                  */
                 smprintf(s, "Escaping SMS mode\n");
                 error = s->Protocol.Functions->WriteMessage(s, "\x1B\r", 2, 0x00);
                 if (error!=ERR_NONE) return error;
 
                     /* Grab any possible garbage */
                     while (s->Device.Functions->ReadDevice(s, buff, 2) > 0) my_sleep(10);
         }
 
             /* When some phones (Alcatel BE5) is first time connected, it needs extra
               * time to react, sending just AT wakes up the phone and it then can react
               * to ATE1. We don't need to check whether this fails as it is just to
               * wake up the phone and does nothing.
               */
             smprintf(s, "Sending simple AT command to wake up some devices\n");
         GSM_WaitFor (s, "AT\r", 3, 0x00, 2, ID_IncomingFrame);
 
         smprintf(s, "Enabling echo\n");
         error = GSM_WaitFor (s, "ATE1\r", 5, 0x00, 3, ID_EnableEcho);
         if (error != ERR_NONE) return error;
         
         smprintf(s, "Enabling CME errors\n");
         /* Try numeric errors */
         if (GSM_WaitFor (s, "AT+CMEE=1\r", 10, 0x00, 3, ID_EnableErrorInfo) != ERR_NONE) {
                 /* Try textual errors */
                 if (GSM_WaitFor (s, "AT+CMEE=2\r", 10, 0x00, 3, ID_EnableErrorInfo) != ERR_NONE) {
                         smprintf(s, "CME errors could not be enabled, some error types won't be detected.\n");
                 }
         }
 
         error = ATGEN_GetModel(s);
         if (error != ERR_NONE) return error;
 
         if (!IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_SLOWWRITE)) {
                 s->Protocol.Data.AT.FastWrite = true;
         }
 
         return error;
 }
 
 GSM_Error ATGEN_SetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
 {
         unsigned char req[50];
 
         if (smsc->Location!=1) return ERR_NOTSUPPORTED;
 
         sprintf(req, "AT+CSCA=\"%s\"\r",DecodeUnicodeString(smsc->Number));
 
         smprintf(s, "Setting SMSC\n");
         return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_SetSMSC);
 }
 
 GSM_Error ATGEN_ReplyGetSMSMemories(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
         case AT_Reply_OK:
                 /* Reply here is:
                  * (memories for reading)[, (memories for writing)[, (memories for storing received messages)]]
                  * each memory is in quotes, 
                  * Example: ("SM"), ("SM"), ("SM")
                  *
                  * We need to get from this supported memories. For this case
                  * we assume, that just appearence of memory makes it
                  * available for everything. Then we need to find out whether
                  * phone supports writing to memory. This is done by searching
                  * for "), (", which will appear between lists.
                  */
-                s->Phone.Data.Priv.ATGEN.CanSaveSMS = (strstr(msg.Buffer, "), (") != NULL);
+                s->Phone.Data.Priv.ATGEN.CanSaveSMS = false;
+                if (strstr(msg.Buffer, "), (") != NULL || strstr(msg.Buffer, "),(") != NULL) {
+                        s->Phone.Data.Priv.ATGEN.CanSaveSMS = true;
+                }
+
                 if (strstr(msg.Buffer, "\"SM\"") != NULL) s->Phone.Data.Priv.ATGEN.SIMSMSMemory = AT_AVAILABLE;
                 else s->Phone.Data.Priv.ATGEN.SIMSMSMemory = AT_NOTAVAILABLE;
+
                 if (strstr(msg.Buffer, "\"ME\"") != NULL) s->Phone.Data.Priv.ATGEN.PhoneSMSMemory = AT_AVAILABLE;
                 else s->Phone.Data.Priv.ATGEN.PhoneSMSMemory = AT_NOTAVAILABLE;
-                smprintf(s, "Available SMS memories received, ME = %d, SM = %d\n", s->Phone.Data.Priv.ATGEN.PhoneSMSMemory, s->Phone.Data.Priv.ATGEN.SIMSMSMemory);
+
+                smprintf(s, "Available SMS memories received, ME = %d, SM = %d, cansavesms =", s->Phone.Data.Priv.ATGEN.PhoneSMSMemory, s->Phone.Data.Priv.ATGEN.SIMSMSMemory);
+                if (s->Phone.Data.Priv.ATGEN.CanSaveSMS) smprintf(s, "true");
+                smprintf(s, "\n");
                 return ERR_NONE;
         case AT_Reply_Error:
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
+        case AT_Reply_CMEError:
+                return ATGEN_HandleCMEError(s);
         default:
                 return ERR_UNKNOWNRESPONSE;
         }
 }
 
 GSM_Error ATGEN_GetSMSMemories(GSM_StateMachine *s)
 {
         smprintf(s, "Getting available SMS memories\n");
         return GSM_WaitFor (s, "AT+CPMS=?\r", 10, 0x00, 4, ID_GetSMSMemories);
 }
 
 GSM_Error ATGEN_SetSMSMemory(GSM_StateMachine *s, bool SIM)
 {
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 char            req[] = "AT+CPMS=\"XX\",\"XX\"\r";
                 int             reqlen = 18;
                 GSM_Error       error;
         
         if ((SIM && Priv->SIMSMSMemory == 0) || (!SIM && Priv->PhoneSMSMemory == 0)) {
                 /* We silently ignore error here, because when this fails, we can try to setmemory anyway */
                 ATGEN_GetSMSMemories(s);
         }
         
         /* If phone can not save SMS, don't try to set memory for saving */
         if (!Priv->CanSaveSMS) {
                 req[12] = '\r';
                 reqlen = 13;
         }
         
         if (SIM) {
                 if (Priv->SMSMemory == MEM_SM) return ERR_NONE;
                 if (Priv->SIMSMSMemory == AT_NOTAVAILABLE) return ERR_NOTSUPPORTED;
 
                 req[9]  = 'S'; req[10] = 'M';
                 req[14] = 'S'; req[15] = 'M';
                 
                 smprintf(s, "Setting SMS memory type to SM\n");
                 error=GSM_WaitFor (s, req, reqlen, 0x00, 3, ID_SetMemoryType);
                 if (Priv->SIMSMSMemory == 0 && error == ERR_NONE) {
                         Priv->SIMSMSMemory = AT_AVAILABLE;
                 }
                 if (error == ERR_NOTSUPPORTED) {
                         smprintf(s, "Can't access SIM card?\n");
                         return ERR_SECURITYERROR;
                 }
                 if (error != ERR_NONE) return error;
                 Priv->SMSMemory = MEM_SM;
         } else {
                 if (Priv->SMSMemory == MEM_ME) return ERR_NONE;
                 if (Priv->PhoneSMSMemory == AT_NOTAVAILABLE) return ERR_NOTSUPPORTED;
                 
                 req[9]  = 'M'; req[10] = 'E';
                 req[14] = 'M'; req[15] = 'E';
 
                 smprintf(s, "Setting SMS memory type to ME\n");
                 error=GSM_WaitFor (s, req, reqlen, 0x00, 3, ID_SetMemoryType);
                 if (Priv->PhoneSMSMemory == 0 && error == ERR_NONE) {
                         Priv->PhoneSMSMemory = AT_AVAILABLE;
                 }
                 if (error == ERR_NONE) Priv->SMSMemory = MEM_ME;
         }
         return error;
 }
 
 GSM_Error ATGEN_GetSMSMode(GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_Error       error;
 
         if (Priv->SMSMode != 0) return ERR_NONE;
 
         smprintf(s, "Trying SMS PDU mode\n");
         error=GSM_WaitFor (s, "AT+CMGF=0\r", 10, 0x00, 3, ID_GetSMSMode);
         if (error==ERR_NONE) {
                 Priv->SMSMode = SMS_AT_PDU;
                 return ERR_NONE;
         }
 
         smprintf(s, "Trying SMS text mode\n");
         error=GSM_WaitFor (s, "AT+CMGF=1\r", 10, 0x00, 3, ID_GetSMSMode);
         if (error==ERR_NONE) {
                 smprintf(s, "Enabling displaying all parameters in text mode\n");
                 error=GSM_WaitFor (s, "AT+CSDH=1\r", 10, 0x00, 3, ID_GetSMSMode);
                 if (error == ERR_NONE) Priv->SMSMode = SMS_AT_TXT;
         }
 
         return error;
 }
 
 GSM_Error ATGEN_GetSMSLocation(GSM_StateMachine *s, GSM_SMSMessage *sms, unsigned char *folderid, int *location)
 {
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 int             ifolderid, maxfolder;
                 GSM_Error       error;
 
         if (Priv->PhoneSMSMemory == 0) {
                 error = ATGEN_SetSMSMemory(s, false);
                 if (error != ERR_NONE && error != ERR_NOTSUPPORTED) return error;
         }
         if (Priv->SIMSMSMemory == 0) {
                 error = ATGEN_SetSMSMemory(s, true);
                 if (error != ERR_NONE && error != ERR_NOTSUPPORTED) return error;
         }
         
         if (Priv->SIMSMSMemory != AT_AVAILABLE && Priv->PhoneSMSMemory != AT_AVAILABLE) {
                 /* No SMS memory at all */
                 return ERR_NOTSUPPORTED;
         }
         if (Priv->SIMSMSMemory == AT_AVAILABLE && Priv->PhoneSMSMemory == AT_AVAILABLE) {
                 /* Both available */
                 maxfolder = 2;
         } else {
                 /* One available */
                 maxfolder = 1;
         }
 
         /* simulate flat SMS memory */
         if (sms->Folder == 0x00) {
                 ifolderid = sms->Location / PHONE_MAXSMSINFOLDER;
                 if (ifolderid + 1 > maxfolder) return ERR_NOTSUPPORTED;
                 *folderid = ifolderid + 1;
                 *location = sms->Location - ifolderid * PHONE_MAXSMSINFOLDER;
         } else {
                 if (sms->Folder > 2 * maxfolder) return ERR_NOTSUPPORTED;
                 *folderid = sms->Folder <= 2 ? 1 : 2;
                 *location = sms->Location;
         }
         smprintf(s, "SMS folder %i & location %i -> ATGEN folder %i & location %i\n",
                 sms->Folder,sms->Location,*folderid,*location);
 
         if (Priv->SIMSMSMemory == AT_AVAILABLE && *folderid == 1) {
                 return ATGEN_SetSMSMemory(s, true);
         } else {
                 return ATGEN_SetSMSMemory(s, false);
         }
 }
 
 void ATGEN_SetSMSLocation(GSM_StateMachine *s, GSM_SMSMessage *sms, unsigned char folderid, int location)
 {
                 sms->Folder= 0;
                 sms->Location= (folderid - 1) * PHONE_MAXSMSINFOLDER + location;
         smprintf(s, "ATGEN folder %i & location %i -> SMS folder %i & location %i\n",
                 folderid,location,sms->Folder,sms->Location);
 }
 
 GSM_Error ATGEN_ReplyGetSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData     *Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_SMSMessage          *sms= &s->Phone.Data.GetSMSMessage->SMS[0];
                 int             current = 0, current2, i;
                 unsigned char   buffer[300],smsframe[800];
                 unsigned char   firstbyte, TPDCS, TPUDL, TPStatus;
                 GSM_Error       error;
 
         switch (Priv->ReplyState) {
         case AT_Reply_OK:
                 if (Priv->Lines.numbers[4] == 0x00) return ERR_EMPTY;
                         s->Phone.Data.GetSMSMessage->Number      = 1;
                         s->Phone.Data.GetSMSMessage->SMS[0].Name[0] = 0;
                         s->Phone.Data.GetSMSMessage->SMS[0].Name[1]= 0;
                 switch (Priv->SMSMode) {
                 case SMS_AT_PDU:
                         CopyLineString(buffer, msg.Buffer, Priv->Lines, 2);
                         switch (buffer[7]) {
                                         case '0': sms->State = SMS_UnRead; break;
                                         case '1': sms->State = SMS_Read;break;
                                         case '2': sms->State = SMS_UnSent;break;
                                         default : sms->State = SMS_Sent;break;//case '3'
                         }
                         DecodeHexBin (buffer, GetLineString(msg.Buffer,Priv->Lines,3), strlen(GetLineString(msg.Buffer,Priv->Lines,3)));
                         /* Siemens MC35 (only ?) */
                         if (strstr(msg.Buffer,"+CMGR: 0,,0")!=NULL) return ERR_EMPTY;
                         /* Siemens M20 */
                         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_M20SMS)) {
-                                if (buffer[1]!=NUMBER_UNKNOWN && buffer[1]!=NUMBER_INTERNATIONAL &&
-                                    buffer[1]!=NUMBER_ALPHANUMERIC) {
+                                /* we check for the most often visible */
+                                if (buffer[1]!=NUMBER_UNKNOWN_NUMBERING_PLAN_ISDN && buffer[1]!=NUMBER_INTERNATIONAL_NUMBERING_PLAN_ISDN &&
+                                    buffer[1]!=NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN) {
                                         /* Seems to be Delivery Report */
                                         smprintf(s, "SMS type - status report (M20 style)\n");
                                                 sms->PDU  = SMS_Status_Report;
                                                 sms->Folder      = 1;/*INBOX SIM*/
                                         sms->InboxFolder = true;
 
                                         smsframe[12]=buffer[current++];
                                         smsframe[PHONE_SMSStatusReport.TPMR]=buffer[current++];
                                         current2=((buffer[current])+1)/2+1;
                                         for(i=0;i<current2+1;i++) smsframe[PHONE_SMSStatusReport.Number+i]=buffer[current++];
                                         for(i=0;i<7;i++) smsframe[PHONE_SMSStatusReport.DateTime+i]=buffer[current++];
                                         smsframe[0] = 0;
                                         for(i=0;i<7;i++) smsframe[PHONE_SMSStatusReport.SMSCTime+i]=buffer[current++];
                                         smsframe[PHONE_SMSStatusReport.TPStatus]=buffer[current];
                                         GSM_DecodeSMSFrame(sms,smsframe,PHONE_SMSStatusReport);
                                                 return ERR_NONE;                                
                                 }
                         }
                         /* We use locations from SMS layouts like in ../phone2.c(h) */
                         for(i=0;i<buffer[0]+1;i++) smsframe[i]=buffer[current++];
                         smsframe[12]=buffer[current++];
                         /* See GSM 03.40 section 9.2.3.1 */
                         switch (smsframe[12] & 0x03) {
                         case 0x00:
                                 smprintf(s, "SMS type - deliver\n");
                                         sms->PDU  = SMS_Deliver;
                                 if (Priv->SMSMemory == MEM_SM) {
                                         sms->Folder = 1; /*INBOX SIM*/ 
                                 } else {
                                         sms->Folder = 3; /*INBOX ME*/ 
                                 }
                                 sms->InboxFolder = true;
                                 current2=((buffer[current])+1)/2+1;
                                 if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_M20SMS)) {
-                                        if (buffer[current+1]==NUMBER_ALPHANUMERIC) {
+                                        if (buffer[current+1]==NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN) {
                                                 smprintf(s, "Trying to read alphanumeric number\n");
                                                 for(i=0;i<4;i++) smsframe[PHONE_SMSDeliver.Number+i]=buffer[current++];
                                                 current+=6;
                                                 for(i=0;i<current2-3;i++) smsframe[PHONE_SMSDeliver.Number+i+4]=buffer[current++];
                                         } else {
                                                 for(i=0;i<current2+1;i++) smsframe[PHONE_SMSDeliver.Number+i]=buffer[current++];
                                         }
                                 } else {
                                         for(i=0;i<current2+1;i++) smsframe[PHONE_SMSDeliver.Number+i]=buffer[current++];
                                 }
                                 smsframe[PHONE_SMSDeliver.TPPID] = buffer[current++];
                                 smsframe[PHONE_SMSDeliver.TPDCS] = buffer[current++];
                                 for(i=0;i<7;i++) smsframe[PHONE_SMSDeliver.DateTime+i]=buffer[current++];
                                 smsframe[PHONE_SMSDeliver.TPUDL] = buffer[current++];
                                 for(i=0;i<smsframe[PHONE_SMSDeliver.TPUDL];i++) smsframe[i+PHONE_SMSDeliver.Text]=buffer[current++];
                                 GSM_DecodeSMSFrame(sms,smsframe,PHONE_SMSDeliver);
                                 return ERR_NONE;
                         case 0x01:
                                 smprintf(s, "SMS type - submit\n");
                                         sms->PDU  = SMS_Submit;
                                 if (Priv->SMSMemory == MEM_SM) {
                                         sms->Folder = 2; /*OUTBOX SIM*/ 
                                         smprintf(s, "Outbox SIM\n");
                                 } else {
                                         sms->Folder = 4; /*OUTBOX ME*/ 
                                 }
                                 sms->InboxFolder = false;
                                 smsframe[PHONE_SMSSubmit.TPMR] = buffer[current++];
                                 current2=((buffer[current])+1)/2+1;
                                 if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_M20SMS)) {
-                                        if (buffer[current+1]==NUMBER_ALPHANUMERIC) {
+                                        if (buffer[current+1]==NUMBER_ALPHANUMERIC_NUMBERING_PLAN_UNKNOWN) {
                                                 smprintf(s, "Trying to read alphanumeric number\n");
                                                 for(i=0;i<4;i++) smsframe[PHONE_SMSSubmit.Number+i]=buffer[current++];
                                                 current+=6;
                                                 for(i=0;i<current2-3;i++) smsframe[PHONE_SMSSubmit.Number+i+4]=buffer[current++];
                                         } else {
                                                 for(i=0;i<current2+1;i++) smsframe[PHONE_SMSSubmit.Number+i]=buffer[current++];
                                         }
                                 } else {
                                         for(i=0;i<current2+1;i++) smsframe[PHONE_SMSSubmit.Number+i]=buffer[current++];
                                 }
                                 smsframe[PHONE_SMSSubmit.TPPID] = buffer[current++];
                                 smsframe[PHONE_SMSSubmit.TPDCS] = buffer[current++];
                                 /* See GSM 03.40 9.2.3.3 - TPVP can not exist in frame */
                                 if ((smsframe[12] & 0x18)!=0) current++; //TPVP is ignored now
                                 smsframe[PHONE_SMSSubmit.TPUDL] = buffer[current++];
                                 for(i=0;i<smsframe[PHONE_SMSSubmit.TPUDL];i++) smsframe[i+PHONE_SMSSubmit.Text]=buffer[current++];
                                 GSM_DecodeSMSFrame(sms,smsframe,PHONE_SMSSubmit);
                                 return ERR_NONE;
                         case 0x02:
                                 smprintf(s, "SMS type - status report\n");
                                         sms->PDU  = SMS_Status_Report;
                                         sms->Folder      = 1;/*INBOX SIM*/
                                 sms->InboxFolder = true;
-                                smprintf(s, "TPMR is %02x\n",buffer[current]);
+                                smprintf(s, "TPMR is %d\n",buffer[current]);
                                 smsframe[PHONE_SMSStatusReport.TPMR] = buffer[current++];
                                 current2=((buffer[current])+1)/2+1;
                                 for(i=0;i<current2+1;i++) smsframe[PHONE_SMSStatusReport.Number+i]=buffer[current++];
                                 for(i=0;i<7;i++) smsframe[PHONE_SMSStatusReport.DateTime+i]=buffer[current++];
                                 for(i=0;i<7;i++) smsframe[PHONE_SMSStatusReport.SMSCTime+i]=buffer[current++];
                                 smsframe[PHONE_SMSStatusReport.TPStatus]=buffer[current];
                                 GSM_DecodeSMSFrame(sms,smsframe,PHONE_SMSStatusReport);
                                 return ERR_NONE;
                         }
                         break;
                 case SMS_AT_TXT:
                         current = 0;
                         while (msg.Buffer[current]!='"') current++;
                         current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                         if (!strcmp(buffer,"\"0\"") || !strcmp(buffer,"\"REC UNREAD\"")) {
                                 smprintf(s, "SMS type - deliver\n");
                                         sms->State  = SMS_UnRead;
                                         sms->PDU  = SMS_Deliver;
                                 if (Priv->SMSMemory == MEM_SM) {
                                         sms->Folder = 1; /*INBOX SIM*/ 
                                 } else {
                                         sms->Folder = 3; /*INBOX ME*/ 
                                 }
                                 sms->InboxFolder = true;
                         } else if (!strcmp(buffer,"\"1\"") || !strcmp(buffer,"\"REC READ\"")) {
                                 smprintf(s, "SMS type - deliver\n");
                                         sms->State  = SMS_Read;
                                         sms->PDU  = SMS_Deliver;
                                 if (Priv->SMSMemory == MEM_SM) {
                                         sms->Folder = 1; /*INBOX SIM*/ 
                                 } else {
                                         sms->Folder = 3; /*INBOX ME*/ 
                                 }
                                 sms->InboxFolder = true;
                         } else if (!strcmp(buffer,"\"2\"") || !strcmp(buffer,"\"STO UNSENT\"")) {
                                 smprintf(s, "SMS type - submit\n");
                                         sms->State  = SMS_UnSent;
                                         sms->PDU  = SMS_Submit;
                                 if (Priv->SMSMemory == MEM_SM) {
                                         sms->Folder = 2; /*OUTBOX SIM*/ 
                                 } else {
                                         sms->Folder = 4; /*OUTBOX ME*/ 
                                 }
                                 sms->InboxFolder = false;
                         } else if (!strcmp(buffer,"\"3\"") || !strcmp(buffer,"\"STO SENT\"")) {
                                 smprintf(s, "SMS type - submit\n");
                                         sms->State  = SMS_Sent;
                                         sms->PDU  = SMS_Submit;
                                 if (Priv->SMSMemory == MEM_SM) {
                                         sms->Folder = 2; /*OUTBOX SIM*/ 
                                 } else {
                                         sms->Folder = 4; /*OUTBOX ME*/ 
                                 }
                                 sms->InboxFolder = false;
                         }
                         current += ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                         /* It's delivery report according to Nokia AT standards */
                         if (sms->Folder==1 && buffer[0]!=0 && buffer[0]!='"') {
                                 /* ??? */
                                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                                 /* format of sender number */
                                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                                 /* Sender number */
                                 /* FIXME: support for all formats */
                                 EncodeUnicode(sms->Number,buffer+1,strlen(buffer)-2);
                                 smprintf(s, "Sender \"%s\"\n",DecodeUnicodeString(sms->Number));
                                 /* ??? */
                                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                                 /* Sending datetime */
                                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                                 i = strlen(buffer);
                                 buffer[i] = ',';
                                 i++;
                                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer+i);
                                 smprintf(s, "\"%s\"\n",buffer);
                                 ATGEN_DecodeDateTime(&sms->DateTime, buffer+1);
                                 /* Date of SMSC response */
                                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                                 i = strlen(buffer);
                                 buffer[i] = ',';
                                 i++;
                                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer+i);
                                 smprintf(s, "\"%s\"\n",buffer);
                                 ATGEN_DecodeDateTime(&sms->SMSCTime, buffer+1);
                                 /* TPStatus */
                                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                                 TPStatus=atoi(buffer);
                                 buffer[PHONE_SMSStatusReport.TPStatus] = TPStatus;
                                 error=GSM_DecodeSMSFrameStatusReportData(sms, buffer, PHONE_SMSStatusReport);
                                 if (error!=ERR_NONE) return error;
                                 /* NO SMSC number */
                                 sms->SMSC.Number[0]=0;
                                 sms->SMSC.Number[1]=0;
                                 sms->PDU = SMS_Status_Report;
                                 sms->ReplyViaSameSMSC=false;
                         } else {
@@ -1547,339 +1603,352 @@ GSM_Error ATGEN_AddSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
                 } else {
                         state = 2;
                         if (sms->State == SMS_Read || sms->State == SMS_Sent) state = 3;
                 }
                 /* Siemens M20 */
                 if (IsPhoneFeatureAvailable(Phone->ModelInfo, F_M20SMS)) {
                         /* No (good and 100% working) support for alphanumeric numbers */
                         if (sms->Number[1]!='+' && (sms->Number[1]<'0' || sms->Number[1]>'9')) {
                                 EncodeUnicode(sms->Number,"123",3);
                                 error = ATGEN_MakeSMSFrame(s, sms, hexreq, &current, &current2);
                                 if (error != ERR_NONE) return error;
                         }
                 }
                 sprintf(buffer, "AT+CMGW=%i,%i\r",current,state);
                 break;
         case SMS_AT_TXT:
                 if (sms->PDU == SMS_Deliver) {
                         statetxt = "REC UNREAD";
                         if (sms->State == SMS_Read || sms->State == SMS_Sent) statetxt = "REC READ";
                 } else {
                         statetxt = "STO UNSENT";
                         if (sms->State == SMS_Read || sms->State == SMS_Sent) statetxt = "STO SENT";
                 }
                 /* Siemens M20 */
                 if (IsPhoneFeatureAvailable(Phone->ModelInfo, F_M20SMS)) {
                         /* No (good and 100% working) support for alphanumeric numbers */
                         /* FIXME: Try to autodetect support for <stat> (statetxt) parameter although:
                          * Siemens M20 supports +CMGW <stat> specification but on my model it just
                          * reports ERROR (and <stat> is not respected).
                          * Fortunately it will write "+CMGW: <index>\n" before and the message gets written
                          */
                         if (sms->Number[1]!='+' && (sms->Number[1]<'0' || sms->Number[1]>'9')) {
                                 sprintf(buffer, "AT+CMGW=\"123\",,\"%s\"\r",statetxt);
                         } else {
                                 sprintf(buffer, "AT+CMGW=\"%s\",,\"%s\"\r",DecodeUnicodeString(sms->Number),statetxt);
                         }
                 } else {
                         sprintf(buffer, "AT+CMGW=\"%s\",,\"%s\"\r",DecodeUnicodeString(sms->Number),statetxt);
                 }
         }
 
         Phone->SaveSMSMessage = sms;
         
         for (reply=0;reply<s->ReplyNum;reply++) {
                 if (reply!=0) {
                         if (s->di.dl==DL_TEXT || s->di.dl==DL_TEXTALL || s->di.dl==DL_TEXTERROR ||
                             s->di.dl==DL_TEXTDATE || s->di.dl==DL_TEXTALLDATE || s->di.dl==DL_TEXTERRORDATE) {
                             smprintf(s, "[Retrying %i]\n", reply+1);
                         }
                 }
                         s->Protocol.Data.AT.EditMode = true;
                         Replies                 = s->ReplyNum;
                         s->ReplyNum             = 1;
                 smprintf(s,"Waiting for modem prompt\n");
                 error=GSM_WaitFor (s, buffer, strlen(buffer), 0x00, 3, ID_SaveSMSMessage);
                         s->ReplyNum              = Replies;
                 if (error == ERR_NONE) {
                                 Phone->DispatchError = ERR_TIMEOUT;
                                 Phone->RequestID = ID_SaveSMSMessage;
                         smprintf(s, "Saving SMS\n");
                         error = s->Protocol.Functions->WriteMessage(s, hexreq, current2, 0x00);
                         if (error!=ERR_NONE) return error;
                         my_sleep(500);
                         /* CTRL+Z ends entering */
                         error = s->Protocol.Functions->WriteMessage(s, "\x1A", 1, 0x00);
                         if (error!=ERR_NONE) return error;
                         error = GSM_WaitForOnce(s, NULL, 0x00, 0x00, 4);
                         if (error != ERR_TIMEOUT) return error;
                 } else {
                         smprintf(s, "Escaping SMS mode\n");
                         error2 = s->Protocol.Functions->WriteMessage(s, "\x1B\r", 2, 0x00);
                         if (error2 != ERR_NONE) return error2;
                         return error;
                 }
         }
 
         return Phone->DispatchError;
 }
 
 GSM_Error ATGEN_ReplySendSMS(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 char            *start;
 
         if (s->Protocol.Data.AT.EditMode) {
                 if (s->Phone.Data.Priv.ATGEN.ReplyState != AT_Reply_SMSEdit) {
                         return ERR_UNKNOWN;
                 }
                 s->Protocol.Data.AT.EditMode = false;
                 return ERR_NONE;
         }
 
         switch (Priv->ReplyState) {
         case AT_Reply_OK:
                 smprintf(s, "SMS sent OK\n");
                 if (s->User.SendSMSStatus!=NULL) {
-                        start = strstr(msg.Buffer, "+CMGW: ");
+                        start = strstr(msg.Buffer, "+CMGS: ");
                         if (start != NULL) {
                                 s->User.SendSMSStatus(s->CurrentConfig->Device,0,atoi(start+7));
                         } else {
-                                s->User.SendSMSStatus(s->CurrentConfig->Device,0,0);
+                                s->User.SendSMSStatus(s->CurrentConfig->Device,0,-1);
                         }
                 }
                 return ERR_NONE;
         case AT_Reply_CMSError:
                 smprintf(s, "Error %i\n",Priv->ErrorCode);
-                if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,Priv->ErrorCode,0);
+                if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,Priv->ErrorCode,-1);
                 return ATGEN_HandleCMSError(s);
         case AT_Reply_Error:
                 return ERR_UNKNOWN;
         default:
                 return ERR_UNKNOWNRESPONSE;
         }
 }
 
 GSM_Error ATGEN_SendSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
 {
                 GSM_Error       error,error2;
                 int             current, current2, Replies;
                 unsigned char   buffer[1000], hexreq[1000];
                 GSM_Phone_Data  *Phone = &s->Phone.Data;
 
         if (sms->PDU == SMS_Deliver) sms->PDU = SMS_Submit;
 
         error = ATGEN_MakeSMSFrame(s, sms, hexreq, &current, &current2);
         if (error != ERR_NONE) return error;
 
         switch (Phone->Priv.ATGEN.SMSMode) {
         case SMS_AT_PDU:
                 sprintf(buffer, "AT+CMGS=%i\r",current);
                 break;
         case SMS_AT_TXT:
                 sprintf(buffer, "AT+CMGS=\"%s\"\r",DecodeUnicodeString(sms->Number));
         }
 
                 s->Protocol.Data.AT.EditMode = true;
                 Replies                 = s->ReplyNum;
                 s->ReplyNum             = 1;
         smprintf(s,"Waiting for modem prompt\n");
         error=GSM_WaitFor (s, buffer, strlen(buffer), 0x00, 3, ID_IncomingFrame);
                 s->ReplyNum              = Replies;
         if (error == ERR_NONE) {
                 smprintf(s, "Sending SMS\n");
                 error = s->Protocol.Functions->WriteMessage(s, hexreq, current2, 0x00);
                 if (error!=ERR_NONE) return error;
                 my_sleep(500);
                 /* CTRL+Z ends entering */
                 error=s->Protocol.Functions->WriteMessage(s, "\x1A", 1, 0x00);
                 my_sleep(100);
                 return error;
         } else {
                 smprintf(s, "Escaping SMS mode\n");
                 error2=s->Protocol.Functions->WriteMessage(s, "\x1B\r", 2, 0x00);
                 if (error2 != ERR_NONE) return error2;
         }
         return error;
 }
 
 GSM_Error ATGEN_SendSavedSMS(GSM_StateMachine *s, int Folder, int Location)
 {
                 GSM_Error error;
                 int     location;
                 unsigned charsmsfolder;
                 unsigned charreq[100];
                 GSM_MultiSMSMessagemsms;
 
         msms.Number = 0;
                 msms.SMS[0].Folder = Folder;
                 msms.SMS[0].Location = Location;
 
         /* By reading SMS we check if it is really inbox/outbox */
         error = ATGEN_GetSMS(s, &msms);
         if (error != ERR_NONE) return error;
 
         /* Can not send from other folder that outbox */
         if (msms.SMS[0].Folder != 2 && msms.SMS[0].Folder != 4) return ERR_NOTSUPPORTED;
 
         error=ATGEN_GetSMSLocation(s, &msms.SMS[0], &smsfolder, &location);
         if (error != ERR_NONE) return error;
 
                 sprintf(req, "AT+CMSS=%i\r",location);
         return s->Protocol.Functions->WriteMessage(s, req, strlen(req), 0x00);
 }
 
 GSM_Error ATGEN_ReplyGetDateTime_Alarm(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 int                     current= 19;
                 GSM_Phone_Data  *Data = &s->Phone.Data;
 
         switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
         case AT_Reply_OK:
                 if (msg.Buffer[current]==0x0d || msg.Buffer[current-1]==0x0d) {
                         smprintf(s, "Not set in phone\n");
                         return ERR_EMPTY;
                 } else {
                         if (Data->RequestID == ID_GetDateTime) {
                                 ATGEN_DecodeDateTime(Data->DateTime, msg.Buffer+current);
                         } else {
                                 ATGEN_DecodeDateTime(&(Data->Alarm->DateTime), msg.Buffer+current);
                         }
                         return ERR_NONE;
                 }
         case AT_Reply_Error:
                 return ERR_NOTSUPPORTED;
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
         default:
                 break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_GetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
 {
         s->Phone.Data.DateTime=date_time;
         smprintf(s, "Getting date & time\n");
         return GSM_WaitFor (s, "AT+CCLK?\r", 9, 0x00, 4, ID_GetDateTime);
 }
 
 GSM_Error ATGEN_SetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
 {
         char req[128];
 
         sprintf(req, "AT+CCLK=\"%02i/%02i/%02i,%02i:%02i:%02i+00\"\r",
                      date_time->Year-2000,date_time->Month,date_time->Day,
                      date_time->Hour,date_time->Minute,date_time->Second);
 
         smprintf(s, "Setting date & time\n");
         return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_SetDateTime);
 }
 
 GSM_Error ATGEN_GetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm)
 {
         if (alarm->Location != 1) return ERR_NOTSUPPORTED;
 
         alarm->Repeating = true;
         alarm->Text[0] = 0; alarm->Text[1] = 0;
 
         s->Phone.Data.Alarm = alarm;
         smprintf(s, "Getting alarm\n");
         return GSM_WaitFor (s, "AT+CALA?\r", 9, 0x00, 4, ID_GetAlarm);
 }
 
+/* R320 only takes HH:MM. Do other phones understand full date? */
+GSM_Error ATGEN_SetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm)
+{
+        char req[20];
+
+        if (alarm->Location != 1) return ERR_INVALIDLOCATION;
+
+        sprintf(req, "AT+CALA=\"%02i:%02i\"\r",alarm->DateTime.Hour,alarm->DateTime.Minute);
+
+        smprintf(s, "Setting Alarm\n");
+        return GSM_WaitFor (s, req, strlen(req), 0x00, 3, ID_SetAlarm);
+}
+
 GSM_Error ATGEN_ReplyGetSMSC(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_SMSC        *SMSC = s->Phone.Data.SMSC;
                 int             current;
                 int             len;
                 unsigned char   buffer[100];
 
         switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
         case AT_Reply_OK:
                 smprintf(s, "SMSC info received\n");
 
                 current = 0;
                 while (msg.Buffer[current]!='"') current++;
 
                 /* SMSC number */
                 /* FIXME: support for all formats */
                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                 /* 
                  * Some phones return this as unicode encoded when they are
                  * switched to UCS2 mode, so we try to solve this correctly.
                  */
                         len     = strlen(buffer + 1) - 1;
                 buffer[len + 1] = 0;
                 if ((len > 20) && (len % 4 == 0) && (strchr(buffer + 1, '+') == NULL)) {
                         /* This is probably unicode encoded number */
                         DecodeHexUnicode(SMSC->Number,buffer + 1,len);
                 } else  {
                         EncodeUnicode(SMSC->Number,buffer + 1,len);
                 }
                 smprintf(s, "Number: \"%s\"\n",DecodeUnicodeString(SMSC->Number));
 
                 /* Format of SMSC number */
                 current+=ATGEN_ExtractOneParameter(msg.Buffer+current, buffer);
                 smprintf(s, "Format %s\n",buffer);
                 /* International number */
                 if (!strcmp(buffer,"145")) {
                         sprintf(buffer+1,"%s",DecodeUnicodeString(SMSC->Number));
                         if (strlen(buffer+1)!=0 && buffer[1] != '+') {
                                 /* Sony Ericsson issue */
                                 /* International number is without + */
                                 buffer[0] = '+';
                                 EncodeUnicode(SMSC->Number,buffer,strlen(buffer));
                         }
                 }
                 
                         SMSC->Format    = SMS_FORMAT_Text;
                 SMSC->Validity.Format = SMS_Validity_RelativeFormat;
                         SMSC->Validity.Relative= SMS_VALID_Max_Time;
                         SMSC->Name[0]   = 0;
                         SMSC->Name[1]   = 0;
                         SMSC->DefaultNumber[0]= 0;
                         SMSC->DefaultNumber[1]= 0;
                 return ERR_NONE;
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
         default:
                 break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_GetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
 {
         if (smsc->Location==0x00 || smsc->Location!=0x01) return ERR_INVALIDLOCATION;
         
         s->Phone.Data.SMSC=smsc;
         smprintf(s, "Getting SMSC\n");
         return GSM_WaitFor (s, "AT+CSCA?\r", 9, 0x00, 4, ID_GetSMSC);
 }
 
 GSM_Error ATGEN_ReplyGetNetworkLAC_CID(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_NetworkInfo         *NetworkInfo = s->Phone.Data.NetworkInfo;
                 GSM_Lines       Lines;
                 int             i=0;
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 char            *answer;
 
           if (s->Phone.Data.RequestID == ID_IncomingFrame) {
                 smprintf(s, "Incoming LAC & CID info\n");
                 return ERR_NONE;
         }
 
         switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
         case AT_Reply_OK:
                 break;
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
         default:
                 return ERR_UNKNOWNRESPONSE;
         }
 
         SplitLines(GetLineString(msg.Buffer,Priv->Lines,2),
                 strlen(GetLineString(msg.Buffer,Priv->Lines,2)),
                 &Lines, ",", 1, true);
 
@@ -2109,552 +2178,592 @@ GSM_Error ATGEN_ReplyGetCPBSMemoryStatus(GSM_Protocol_Message msg, GSM_StateMach
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_ReplyGetCPBRMemoryInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 char            *pos;
  
          switch (Priv->ReplyState) {
          case AT_Reply_OK:
                 smprintf(s, "Memory info received\n");
                 /* Parse +CPBR: (first-last),max_number_len,max_name_len */ 
 
                 /* Parse first location */
                 pos = strchr(msg.Buffer, '(');
                 if (!pos) return ERR_UNKNOWN;
                 pos++;
                 Priv->FirstMemoryEntry = atoi(pos);
 
                 /* Parse last location*/
                 pos = strchr(pos, '-');
                 if (!pos) return ERR_UNKNOWN;
                 pos++;
                 Priv->MemorySize = atoi(pos) + 1 - Priv->FirstMemoryEntry;
 
                 /* Parse number length*/
                 pos = strchr(pos, ',');
                 if (!pos) return ERR_UNKNOWN;
                 pos++;
                 Priv->NumberLength = atoi(pos);
 
                 /* Parse text length*/
                 pos = strchr(pos, ',');
                 if (!pos) return ERR_UNKNOWN;
                 pos++;
                 Priv->TextLength = atoi(pos);
 
                 return ERR_NONE;
         case AT_Reply_Error:
                 return ERR_UNKNOWN;
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
          default:
                 return ERR_UNKNOWNRESPONSE;
         }
 }
 
 GSM_Error ATGEN_ReplyGetCPBRMemoryStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_MemoryStatus*MemoryStatus = s->Phone.Data.MemoryStatus;
                 int             line=0;
                 char            *str;
                 int             cur;
 
         switch (Priv->ReplyState) {
         case AT_Reply_OK:
                 smprintf(s, "Memory entries received\n");
                 /* Walk through lines with +CPBR: */
                 while (Priv->Lines.numbers[line*2+1]!=0) {
                         str = GetLineString(msg.Buffer,Priv->Lines,line+1);
                         if (strncmp(str, "+CPBR: ", 7) == 0) {
                                 MemoryStatus->MemoryUsed++;
                                 if (sscanf(str, "+CPBR: %d,", &cur) == 1) {
                                         cur -= Priv->FirstMemoryEntry - 1;
                                         if (cur == Priv->NextMemoryEntry || Priv->NextMemoryEntry == 0)
                                                 Priv->NextMemoryEntry = cur + 1;
                                 }
                         }
                         line++;
                 }
                 return ERR_NONE;
         case AT_Reply_Error:
                 return ERR_UNKNOWN;
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
         default:
                 return ERR_UNKNOWNRESPONSE;
         }
 }
 
 GSM_Error ATGEN_GetMemoryInfo(GSM_StateMachine *s, GSM_MemoryStatus *Status, GSM_AT_NeededMemoryInfo NeededInfo)
 {
                 GSM_Error       error;
                 char            req[20];
                 int             start;
                 int             end;
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
 
         smprintf(s, "Getting memory information\n");
         
                 Priv->MemorySize        = 0;
                 Priv->TextLength        = 0;
                 Priv->NumberLength      = 0;
 
         error = GSM_WaitFor (s, "AT+CPBR=?\r", 10, 0x00, 4, ID_GetMemoryStatus);
+        if (Priv->Manufacturer == AT_Samsung)
+                error = GSM_WaitFor (s, "", 0, 0x00, 4, ID_GetMemoryStatus);
         if (error != ERR_NONE) return error;
         if (NeededInfo == AT_Total || NeededInfo == AT_Sizes || NeededInfo == AT_First) return ERR_NONE;
 
         smprintf(s, "Getting memory status by reading values\n");
         
                 s->Phone.Data.MemoryStatus= Status;
                 Status->MemoryUsed      = 0;
                 Status->MemoryFree      = 0;
                 start                   = Priv->FirstMemoryEntry;
                 Priv->NextMemoryEntry   = 0;
         while (1) {
                         end= start + 20;
                 if (end > Priv->MemorySize) end = Priv->MemorySize;
                 sprintf(req, "AT+CPBR=%i,%i\r", start, end);
                         error= GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetMemoryStatus);
                 if (error != ERR_NONE) return error;
                 if (NeededInfo == AT_NextEmpty && Priv->NextMemoryEntry != 0 && Priv->NextMemoryEntry != end + 1) return ERR_NONE;
                 if (end == Priv->MemorySize) {
                         Status->MemoryFree = Priv->MemorySize - Status->MemoryUsed;
                         return ERR_NONE;
                 }
                 start = end + 1;
         }
 }
 
 GSM_Error ATGEN_GetMemoryStatus(GSM_StateMachine *s, GSM_MemoryStatus *Status)
 {
         GSM_Error error;
 
         error = ATGEN_SetPBKMemory(s, Status->MemoryType);
         if (error != ERR_NONE) return error;
 
         s->Phone.Data.MemoryStatus=Status;
 
         /* in some phones doesn't work or doesn't return memory status inside */
         /* Some workaround for buggy mobile, that hangs after "AT+CPBS?" for other
          * memory than SM.
          */
         if (!IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_BROKENCPBS) || (Status->MemoryType == MEM_SM)) {
                 smprintf(s, "Getting memory status\n");
                 error=GSM_WaitFor (s, "AT+CPBS?\r", 9, 0x00, 4, ID_GetMemoryStatus);
                 if (error == ERR_NONE) return ERR_NONE;
         }
 
         return ATGEN_GetMemoryInfo(s, Status, AT_Status);
 }
 
 GSM_Error ATGEN_SetPBKCharset(GSM_StateMachine *s, bool PreferUnicode)
 {
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_Error       error;
 
         /* Have we already selected something? */
         if (Priv->PBKCharset!=0) {
                 /* If we want unicode charset and we have it already or setting of it
                  * failed, we have nothing to do. */
                 if (PreferUnicode  && (Priv->PBKCharset==AT_PBK_UCS2 || Priv->UCS2CharsetFailed)) return ERR_NONE;
 
                 /* If we don't need unicode charset and we have some (or have unicode
                  * charset when other failed), we have nothing to do. */
                 if (!PreferUnicode && (Priv->PBKCharset!=AT_PBK_UCS2 || Priv->NonUCS2CharsetFailed)) return ERR_NONE;
         }
 
         error=ATGEN_GetManufacturer(s);
         if (error != ERR_NONE) return error;
 
+        /* Samsung (and Sagem?) phones use only PCCP437? */
+        if (Priv->Manufacturer == AT_Samsung) {
+                Priv->PBKCharset = AT_PBK_PCCP437;
+                return ERR_NONE;
+        }
+
         if (PreferUnicode && !Priv->UCS2CharsetFailed) {
                 smprintf(s, "Setting charset to UCS2\n");
                 error=GSM_WaitFor (s, "AT+CSCS=\"UCS2\"\r", 15, 0x00, 3, ID_SetMemoryCharset);
                 if (error == ERR_NONE) {
                         Priv->PBKCharset = AT_PBK_UCS2;
                         return ERR_NONE;
                 } else {
                         Priv->UCS2CharsetFailed = true;
                 }
         }
         
         smprintf(s, "Setting charset to HEX\n");
         error=GSM_WaitFor (s, "AT+CSCS=\"HEX\"\r", 14, 0x00, 3, ID_SetMemoryCharset);
         /* Falcom replies OK for HEX mode and send everything
          * in normal format */
         if (error == ERR_NONE && Priv->Manufacturer != AT_Falcom) {
                 Priv->PBKCharset = AT_PBK_HEX;
                 return ERR_NONE;
         }
 
         smprintf(s, "Setting charset to GSM\n");
         error=GSM_WaitFor (s, "AT+CSCS=\"GSM\"\r", 14, 0x00, 3, ID_SetMemoryCharset);
         if (error == ERR_NONE) {
                 Priv->PBKCharset = AT_PBK_GSM;
                 return ERR_NONE;
         }
 
         if (!Priv->UCS2CharsetFailed) {
                 Priv->NonUCS2CharsetFailed = true;
                 smprintf(s, "Setting charset to UCS2\n");
                 error=GSM_WaitFor (s, "AT+CSCS=\"UCS2\"\r", 15, 0x00, 3, ID_SetMemoryCharset);
                 if (error == ERR_NONE) {
                         Priv->PBKCharset = AT_PBK_UCS2;
                         return ERR_NONE;
                 } else {
                         Priv->UCS2CharsetFailed = true;
                 }
         }
 
                 return error;
 }
 
 GSM_Error ATGEN_ReplyGetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_MemoryEntry         *Memory = s->Phone.Data.Memory;
                 char            *pos;
                 unsigned char   buffer[500],buffer2[500];
                 int             len;
 
         switch (Priv->ReplyState) {
         case AT_Reply_OK:
                 smprintf(s, "Phonebook entry received\n");
                 Memory->EntriesNum = 0;
                 if (Priv->Lines.numbers[4]==0) return ERR_EMPTY;
                 pos = strstr(msg.Buffer, "+CPBR:");
                 if (pos == NULL) return ERR_UNKNOWN;
                 /* Go after +CPBR: */
                 pos += 6; 
 
                 /* Location */
                 while (*pos && !isdigit(*pos)) pos++;
                 Memory->Location = atoi(pos) + 1 - Priv->FirstMemoryEntry;
                 smprintf(s, "Location: %d\n", Memory->Location);
                         
                 /* Number */
                 while (*pos != '"') pos++;
                 pos += ATGEN_ExtractOneParameter(pos, buffer);
                 smprintf(s, "Number: %s\n",buffer);
                 Memory->EntriesNum++;
                 Memory->Entries[0].EntryType  = PBK_Number_General;
                 Memory->Entries[0].VoiceTag   = 0;
                 Memory->Entries[0].SMSList[0] = 0;
 
                 len = strlen(buffer + 1) - 1;
                 if (Priv->PBKCharset == AT_PBK_HEX && (len > 10) && (len % 2 == 0) && (strchr(buffer + 1, '+') == NULL)) {
                         /* This is probably hex encoded number */
                         DecodeHexBin(buffer2, buffer+1, len);
                         DecodeDefault(Memory->Entries[0].Text ,buffer2, strlen(buffer2), false, NULL);
                 } else if (Priv->PBKCharset == AT_PBK_UCS2 && (len > 20) && (len % 4 == 0) && (strchr(buffer + 1, '+') == NULL)) {
                         /* This is probably unicode encoded number */
                         DecodeHexUnicode(Memory->Entries[0].Text, buffer + 1,len);
                 } else  {
                         EncodeUnicode(Memory->Entries[0].Text, buffer + 1, len);
                 }
                 
                 /* Number format */
                 pos += ATGEN_ExtractOneParameter(pos, buffer);
                 smprintf(s, "Number format: %s\n",buffer);
 
                 /* International number */
                 if (!strcmp(buffer,"145")) {
                         sprintf(buffer+1,"%s",DecodeUnicodeString(Memory->Entries[0].Text));
                         if (strlen(buffer+1)!=0 && buffer[1] != '+') {
                                 /* Sony Ericsson issue */
                                 /* International number is without + */
                                 buffer[0] = '+';
                                 EncodeUnicode(Memory->Entries[0].Text,buffer,strlen(buffer));
                         }
                 }
 
                 /* Name */
                 pos += ATGEN_ExtractOneParameter(pos, buffer);
                 smprintf(s, "Name text: %s\n",buffer);
                 Memory->EntriesNum++;
                 Memory->Entries[1].EntryType=PBK_Text_Name;
                 switch (Priv->PBKCharset) {
                 case AT_PBK_HEX:
                         DecodeHexBin(buffer2,buffer+1,strlen(buffer)-2);
                         DecodeDefault(Memory->Entries[1].Text,buffer2,strlen(buffer2),false,NULL);
                         break;
                 case AT_PBK_GSM:
                         DecodeDefault(Memory->Entries[1].Text,buffer+1,strlen(buffer)-2,false,NULL);
                                 break;          
                 case AT_PBK_UCS2:
                         DecodeHexUnicode(Memory->Entries[1].Text,buffer+1,strlen(buffer+1) - 1);
                                 break;          
+                case AT_PBK_PCCP437:
+                        /* FIXME: correctly decode PCCP437 */
+                        DecodeDefault(Memory->Entries[1].Text,buffer+1,strlen(buffer)-2,false,NULL);
+                        break;
+                }
+
+                /* Samsung number type */
+                if (Priv->Manufacturer == AT_Samsung) {
+                        int type;
+
+                        pos += ATGEN_ExtractOneParameter(pos, buffer);
+                        smprintf(s, "Number type: %s\n",buffer);
+                        type = strtoul(buffer, NULL, 0);
+                        switch (type) {
+                        case 0:
+                                Memory->Entries[0].EntryType = PBK_Number_Mobile;
+                                break;
+                        case 1:
+                                Memory->Entries[0].EntryType = PBK_Number_Work;
+                                break;
+                        case 2:
+                                Memory->Entries[0].EntryType = PBK_Number_Home;
+                                break;
+                        case 3:
+                                Memory->Entries[0].EntryType = PBK_Text_Email;
+                                break;
+                        default:
+                                Memory->Entries[0].EntryType = PBK_Number_General;
+                        }
                 }
+
                 return ERR_NONE;
         case AT_Reply_CMEError:
                 return ATGEN_HandleCMEError(s);
         case AT_Reply_Error:
                 smprintf(s, "Error - too high location ?\n");
                 return ERR_INVALIDLOCATION;
         case AT_Reply_CMSError:
                  return ATGEN_HandleCMSError(s);
         default:
                 break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_PrivGetMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry, int endlocation)
 {
                 GSM_Error       error;
                 unsigned char   req[20];
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
 
         if (entry->Location==0x00) return ERR_INVALIDLOCATION;
 
         if (entry->MemoryType == MEM_ME) {
                 if (Priv->PBKSBNR == 0) {
                         sprintf(req, "AT^SBNR=?\r");
                         smprintf(s, "Checking availablity of SBNR\n");
                         error=GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetMemory);
                         switch (error) {
                         case ERR_NONE:
                                 Priv->PBKSBNR = AT_SBNR_AVAILABLE;
                                 break;
                         case ERR_UNKNOWN:
                         case ERR_NOTSUPPORTED:
                                 Priv->PBKSBNR = AT_SBNR_NOTAVAILABLE;
                                 break;
                         default:
                                 return error;
                         }
                 }
                 if (Priv->PBKSBNR == AT_SBNR_AVAILABLE) {
                         sprintf(req, "AT^SBNR=vcf,%i\r",entry->Location-1);
                         s->Phone.Data.Memory=entry;
                         smprintf(s, "Getting phonebook entry\n");
                         return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetMemory);
                 }
         }
 
         error=ATGEN_GetManufacturer(s);
         if (error != ERR_NONE) return error;
 
         error=ATGEN_SetPBKMemory(s, entry->MemoryType);
         if (error != ERR_NONE) return error;
 
         if (Priv->FirstMemoryEntry == 0) {
                 error = ATGEN_GetMemoryInfo(s, NULL, AT_First);
                 if (error != ERR_NONE) return error;
         }
 
 
         error=ATGEN_SetPBKCharset(s, true); /* For reading we prefer unicode */
         if (error != ERR_NONE) return error;
 
         if (endlocation == 0) {
                 sprintf(req, "AT+CPBR=%i\r", entry->Location + Priv->FirstMemoryEntry - 1);
         } else {
                 sprintf(req, "AT+CPBR=%i,%i\r", entry->Location + Priv->FirstMemoryEntry - 1, endlocation + Priv->FirstMemoryEntry - 1);
         }
 
         s->Phone.Data.Memory=entry;
         smprintf(s, "Getting phonebook entry\n");
         return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetMemory);
 }
 
 GSM_Error ATGEN_GetMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
         return ATGEN_PrivGetMemory(s, entry, 0);
 }
 
 GSM_Error ATGEN_GetNextMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry, bool start)
 {
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_Error       error;
                 int             step = 0;
 
         if (Priv->MemorySize == 0) {
                 error = ATGEN_GetMemoryInfo(s, NULL, AT_Total);
                 if (error != ERR_NONE) return error;
         }
 
         if (start) {
                 entry->Location = 1;
         } else {
                 entry->Location++;
         }
         while ((error = ATGEN_PrivGetMemory(s, entry, step == 0 ? 0 : MIN(Priv->MemorySize, entry->Location + step))) == ERR_EMPTY) {
                 entry->Location += step + 1;
                 if (entry->Location > Priv->MemorySize) break;
                 /* SNBR works only for one location */
                 if (entry->MemoryType != MEM_ME || Priv->PBKSBNR != AT_SBNR_AVAILABLE) step = MIN(step + 2, 20);
         }
         if (error == ERR_INVALIDLOCATION) return ERR_EMPTY;
         return error;
 }
 
 GSM_Error ATGEN_DeleteAllMemory(GSM_StateMachine *s, GSM_MemoryType type)
 {
                 GSM_Error       error;
                 unsigned char   req[100];
                 int             i;
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
 
         error = ATGEN_SetPBKMemory(s, type);
         if (error != ERR_NONE) return error;
 
         if (Priv->MemorySize == 0) {
                 error = ATGEN_GetMemoryInfo(s, NULL, AT_Total);
                 if (error != ERR_NONE) return error;
         }
 
         if (Priv->FirstMemoryEntry == 0) {
                 error = ATGEN_GetMemoryInfo(s, NULL, AT_First);
                 if (error != ERR_NONE) return error;
         }
 
 
         smprintf(s, "Deleting all phonebook entries\n");
         for (i = Priv->FirstMemoryEntry; i < Priv->FirstMemoryEntry + Priv->MemorySize; i++) {
                 sprintf(req, "AT+CPBW=%d\r",i);
                 error = GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_SetMemory);
                 if (error != ERR_NONE) return error;
         }
         return ERR_NONE;
 }
 
 GSM_Error ATGEN_ReplyDialVoice(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
         case AT_Reply_OK:
                 smprintf(s, "Dial voice OK\n");
                 return ERR_NONE;
         case AT_Reply_Error:
                 smprintf(s, "Dial voice error\n");
                 return ERR_UNKNOWN;
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
         default:
                 break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_DialVoice(GSM_StateMachine *s, char *number, GSM_CallShowNumber ShowNumber)
 {
         char req[39] = "ATDT";  
 
         if (ShowNumber != GSM_CALL_DefaultNumberPresence) return ERR_NOTSUPPORTED;
         if (strlen(number) > 32) return (ERR_UNKNOWN);
 
         strcat(req, number);
         strcat(req, ";\r");
 
         smprintf(s, "Making voice call\n");
         return GSM_WaitFor (s, req, 4+2+strlen(number), 0x00, 5, ID_DialVoice);
 }
 
 GSM_Error ATGEN_ReplyEnterSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
         case AT_Reply_OK:
                 smprintf(s, "Security code was OK\n");
                 return ERR_NONE;
         case AT_Reply_Error:
                 smprintf(s, "Incorrect security code\n");
                 return ERR_SECURITYERROR;
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
+        case AT_Reply_CMEError:
+                return ATGEN_HandleCMEError(s);
         default:
                 break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_EnterSecurityCode(GSM_StateMachine *s, GSM_SecurityCode Code)
 {
         unsigned char req[50];
 
         switch (Code.Type) {
         case SEC_Pin :
                 sprintf(req, "AT+CPIN=\"%s\"\r" , Code.Code);
                 break;
         case SEC_Pin2 : 
                 if (s->Phone.Data.Priv.ATGEN.Manufacturer == AT_Siemens) {
                         sprintf(req, "AT+CPIN2=\"%s\"\r", Code.Code);
                 } else {
                         sprintf(req, "AT+CPIN=\"%s\"\r" , Code.Code);
                 }
                 break;
         default : return ERR_NOTIMPLEMENTED;
         }
 
         smprintf(s, "Entering security code\n");
         return GSM_WaitFor (s, req, strlen(req), 0x00, 6, ID_EnterSecurityCode);
 }
 
 GSM_Error ATGEN_ReplyGetSecurityStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_SecurityCodeType *Status = s->Phone.Data.SecurityStatus;
 
         smprintf(s, "Security status received - ");
         if (strstr(msg.Buffer,"READY")) {
                 *Status = SEC_None;
                 smprintf(s, "nothing to enter\n");
                 return ERR_NONE;
         }
         if (strstr(msg.Buffer,"PH_SIM PIN")) {
                 smprintf(s, "no SIM inside or other error\n");
                 return ERR_UNKNOWN;
         }
         if (strstr(msg.Buffer,"SIM PIN2")) {
                 *Status = SEC_Pin2;
                 smprintf(s, "waiting for PIN2\n");
                 return ERR_NONE;
         }
         if (strstr(msg.Buffer,"SIM PUK2")) {
                 *Status = SEC_Puk2;
                 smprintf(s, "waiting for PUK2\n");
                 return ERR_NONE;
         }
         if (strstr(msg.Buffer,"SIM PIN")) {
                 *Status = SEC_Pin;
                 smprintf(s, "waiting for PIN\n");
                 return ERR_NONE;
         }
         if (strstr(msg.Buffer,"SIM PUK")) {
                 *Status = SEC_Puk;
                 smprintf(s, "waiting for PUK\n");
                 return ERR_NONE;
         }
         smprintf(s, "unknown\n");
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_GetSecurityStatus(GSM_StateMachine *s, GSM_SecurityCodeType *Status)
 {
         s->Phone.Data.SecurityStatus=Status;
 
         smprintf(s, "Getting security code status\n");
         /* Please note, that A2D doesn't return OK on the end.
           * Because of it ReplyGetSecurityStatus is called after receiving line
          * with +CPIN:
          */
         return GSM_WaitFor (s, "AT+CPIN?\r", 9, 0x00, 4, ID_GetSecurityStatus);
 }
 
 GSM_Error ATGEN_AnswerCall(GSM_StateMachine *s, int ID, bool all)
 {
         if (all) {
                 smprintf(s, "Answering all calls\n");
                 return GSM_WaitFor (s, "ATA\r", 4, 0x00, 4, ID_AnswerCall);
         }
         return ERR_NOTSUPPORTED;
 }
 
 GSM_Error ATGEN_ReplyCancelCall(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Call call;
 
         switch(s->Phone.Data.Priv.ATGEN.ReplyState) {
         case AT_Reply_OK:
                  smprintf(s, "Calls canceled\n");
             call.CallIDAvailable = false;
                     call.Status  = GSM_CALL_CallLocalEnd;
@@ -2831,192 +2940,198 @@ GSM_Error ATGEN_ReplySetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
         case AT_Reply_CMSError:
                 return ATGEN_HandleCMSError(s);
         case AT_Reply_CMEError:
                 return ATGEN_HandleCMEError(s);
         case AT_Reply_Error:
                 return ERR_INVALIDDATA;
         default:
                 return ERR_UNKNOWNRESPONSE;
         }
 }
 
 GSM_Error ATGEN_DeleteMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
                 GSM_Error       error;
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 unsigned char   req[100];
 
         if (entry->Location < 1) return ERR_INVALIDLOCATION;
 
         error = ATGEN_SetPBKMemory(s, entry->MemoryType);
         if (error != ERR_NONE) return error;
 
         if (Priv->FirstMemoryEntry == 0) {
                 error = ATGEN_GetMemoryInfo(s, NULL, AT_First);
                 if (error != ERR_NONE) return error;
         }
 
         sprintf(req, "AT+CPBW=%d\r",entry->Location + Priv->FirstMemoryEntry - 1);
 
         smprintf(s, "Deleting phonebook entry\n");
         return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_SetMemory);
 }
 
 GSM_Error ATGEN_PrivSetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
         /* REQUEST_SIZE should be big enough to handle all possibl cases
          * correctly, especially with unicode entries */
         #define REQUEST_SIZE((4 * GSM_PHONEBOOK_TEXT_LENGTH) + 30)
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 int             Group, Name, Number,NumberType=0, len;
                 GSM_Error       error;
                 unsigned char   req[REQUEST_SIZE + 1];
                 unsigned char   name[2*(GSM_PHONEBOOK_TEXT_LENGTH + 1)];
                 unsigned char   uname[2*(GSM_PHONEBOOK_TEXT_LENGTH + 1)];
                 unsigned char   number[GSM_PHONEBOOK_TEXT_LENGTH + 1];
                 int             reqlen;
                 bool            PreferUnicode = false;
 
         if (entry->Location == 0) return ERR_INVALIDLOCATION;
 
         error = ATGEN_SetPBKMemory(s, entry->MemoryType);
         if (error != ERR_NONE) return error;
 
         GSM_PhonebookFindDefaultNameNumberGroup(entry, &Name, &Number, &Group);
 
         name[0] = 0;
         if (Name != -1) {
                 len = UnicodeLength(entry->Entries[Name].Text);
 
                 /* Compare if we would loose some information when not using
                  * unicode */
                 EncodeDefault(name, entry->Entries[Name].Text, &len, true, NULL);
                 DecodeDefault(uname, name, len, true, NULL);
                 if (!mywstrncmp(uname, entry->Entries[Name].Text, len)) {
                         /* Get maximal text length */
                         if (Priv->TextLength == 0) {
                                 ATGEN_GetMemoryInfo(s, NULL, AT_Sizes);
                         }
                         
                         /* I char stored in GSM alphabet takes 7 bits, one
                          * unicode 16, if storing in unicode would truncate
                          * text, do not use it, otherwise we will use it */
                         if ((Priv->TextLength != 0) && ((Priv->TextLength * 7 / 16) <= len)) {
                                 PreferUnicode = false;
                         } else {
                                 PreferUnicode = true;
                         }
                 }
 
                 error = ATGEN_SetPBKCharset(s, PreferUnicode);
                 if (error != ERR_NONE) return error;
 
                 switch (Priv->PBKCharset) {
                 case AT_PBK_HEX:
                         EncodeHexBin(name, DecodeUnicodeString(entry->Entries[Name].Text), UnicodeLength(entry->Entries[Name].Text));
                         len = strlen(name);
                         break;
                 case AT_PBK_GSM:
                         smprintf(s, "str: %s\n", DecodeUnicodeString(entry->Entries[Name].Text));
                         len = UnicodeLength(entry->Entries[Name].Text);
                         EncodeDefault(name, entry->Entries[Name].Text, &len, true, NULL);
                         break;
                 case AT_PBK_UCS2:
                         EncodeHexUnicode(name, entry->Entries[Name].Text, UnicodeLength(entry->Entries[Name].Text));
                         len = strlen(name);
                         break;
+                case AT_PBK_PCCP437:
+                        /* FIXME: correctly decode PCCP437 */
+                        smprintf(s, "str: %s\n", DecodeUnicodeString(entry->Entries[Name].Text));
+                        len = UnicodeLength(entry->Entries[Name].Text);
+                        EncodeDefault(name, entry->Entries[Name].Text, &len, true, NULL);
+                        break;
                 }
         } else {
                 smprintf(s, "WARNING: No usable name found!\n");
                 len = 0;
         }
 
         if (Number != -1) {
                 GSM_PackSemiOctetNumber(entry->Entries[Number].Text, number, false);
                 NumberType = number[0];
                 sprintf(number,"%s",DecodeUnicodeString(entry->Entries[Number].Text));
         } else {
                 smprintf(s, "WARNING: No usable number found!\n");
                 number[0] = 0;
         }
 
         if (Priv->FirstMemoryEntry == 0) {
                 error = ATGEN_GetMemoryInfo(s, NULL, AT_First);
                 if (error != ERR_NONE) return error;
         }
 
         /* We can't use here:
          * sprintf(req, "AT+CPBW=%d, \"%s\", %i, \"%s\"\r",
          *         entry->Location, number, NumberType, name);
          * because name can contain 0 when using GSM alphabet.
          */
         sprintf(req, "AT+CPBW=%d, \"%s\", %i, \"", entry->Location + Priv->FirstMemoryEntry - 1, number, NumberType);
         reqlen = strlen(req);
         if (reqlen + len > REQUEST_SIZE - 2) {
                 smprintf(s, "WARNING: Text truncated to fit in buffer!\n");
                 len = REQUEST_SIZE - 2 - reqlen;
         }
         memcpy(req + reqlen, name, len);
         reqlen += len;
         memcpy(req + reqlen, "\"\r", 2);
         reqlen += 2;
 
         smprintf(s, "Writing phonebook entry\n");
         return GSM_WaitFor (s, req, reqlen, 0x00, 4, ID_SetMemory);
 #undef REQUEST_SIZE
 }
 
 GSM_Error ATGEN_SetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
         if (entry->Location == 0) return ERR_INVALIDLOCATION;
         return ATGEN_PrivSetMemory(s, entry);
 }
 
 GSM_Error ATGEN_AddMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
                 GSM_Error       error;
                 GSM_MemoryStatusStatus;
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
 
         /* Find out empty location */
         error = ATGEN_GetMemoryInfo(s, &Status, AT_NextEmpty);
         if (error != ERR_NONE) return error;
         if (Priv->NextMemoryEntry == 0) return ERR_FULL;
         entry->Location = Priv->NextMemoryEntry;
 
         return ATGEN_PrivSetMemory(s, entry);
 }
 
 /* Use ATGEN_ExtractOneParameter ?? */
 void Extract_CLIP_number(char *dest, char *buf)
 {
                 char *start, *stop;
                 int i = 0;
 
         stop = strstr(buf, ",");
         if (stop != NULL) {
                 start = strstr(buf, ":");
                 if (start != NULL) { 
                         for (start = start + 2; start + i < stop;  i++)
                         dest[i] = start[i];
                         }
         }
         dest[i] = 0; /* end the number */
         
         return;
 }
 
 GSM_Error ATGEN_ReplyIncomingCallInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 char            num[128];
                 GSM_Call        call;
 
         smprintf(s, "Incoming call info\n");
         if (s->Phone.Data.EnableIncomingCall && s->User.IncomingCall!=NULL) {
                         call.CallIDAvailable = false;
                         num[0]                  = 0;
                 if (strstr(msg.Buffer, "RING")) {
                         call.Status = GSM_CALL_IncomingCall;
                         Extract_CLIP_number(num, msg.Buffer);
                 } else if (strstr(msg.Buffer, "NO CARRIER")) {
                         call.Status = GSM_CALL_CallEnd;
                 } else if (strstr(msg.Buffer, "COLP:")) {
@@ -3159,511 +3274,589 @@ GSM_Error ATGEN_ReplyGetSignalQuality(GSM_Protocol_Message msg, GSM_StateMachine
                 GSM_SignalQuality*Signal = s->Phone.Data.SignalQuality;
                 int             i;
                 char            *pos;
 
                 Signal->SignalStrength = -1;
                 Signal->SignalPercent = -1;
                 Signal->BitErrorRate = -1;
     
         switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
         case AT_Reply_OK:
             smprintf(s, "Signal quality info received\n");
             i = atoi(msg.Buffer+15);
             if (i != 99) {
                 /* from GSM 07.07 section 8.5 */
                 Signal->SignalStrength = 2 * i - 113;
 
                 /* FIXME: this is wild guess and probably will be phone dependant */
                 Signal->SignalPercent = 15 * i;
                 if (Signal->SignalPercent > 100) Signal->SignalPercent = 100;
             }
             pos = strchr(msg.Buffer + 15, ',');
             if (pos != NULL) {
                 i = atoi(pos + 1);
                 /* from GSM 05.08 section 8.2.4 */
                 switch (i) {
                     case 0: Signal->BitErrorRate =  0; break; /* 0.14 */
                     case 1: Signal->BitErrorRate =  0; break; /* 0.28 */
                     case 2: Signal->BitErrorRate =  1; break; /* 0.57 */
                     case 3: Signal->BitErrorRate =  1; break; /* 1.13 */
                     case 4: Signal->BitErrorRate =  2; break; /* 2.26 */
                     case 5: Signal->BitErrorRate =  5; break; /* 4.53 */
                     case 6: Signal->BitErrorRate =  9; break; /* 9.05 */
                     case 7: Signal->BitErrorRate = 18; break; /* 18.10 */
                 }
             }
             return ERR_NONE;
         case AT_Reply_CMSError:
             return ATGEN_HandleCMSError(s);
         default:
             break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error ATGEN_GetSignalQuality(GSM_StateMachine *s, GSM_SignalQuality *sig)
 {
         s->Phone.Data.SignalQuality = sig;
         smprintf(s, "Getting signal quality info\n");
         return GSM_WaitFor (s, "AT+CSQ\r", 7, 0x00, 4, ID_GetSignalQuality);
 }
 
 /* When use AT+CPIN?, A2D returns it without OK and because of it Gammu
    parses answer without it.
    MC35 and other return OK after answer for AT+CPIN?. Here we handle it.
    Any better idea ?
  */
 GSM_Error ATGEN_ReplyOK(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         return ERR_NONE;
 }
 
 static GSM_Error ATGEN_GetNextCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start)
 {
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
         
         if (Priv->Manufacturer==AT_Siemens ) return SIEMENS_GetNextCalendar(s,Note,start);
         if (Priv->Manufacturer==AT_Ericsson) return SONYERIC_GetNextCalendar(s,Note,start);
         return ERR_NOTSUPPORTED;
 }
 
 GSM_Error ATGEN_Terminate(GSM_StateMachine *s)
 {
         GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
 
         free(Priv->file.Buffer);
         return ERR_NONE;
 }
 
 GSM_Error ATGEN_AddCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
         GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
 
         if (Priv->Manufacturer==AT_Siemens)  return SIEMENS_AddCalendarNote(s, Note);
         if (Priv->Manufacturer==AT_Ericsson) return SONYERIC_AddCalendarNote(s, Note);
         return ERR_NOTSUPPORTED;
 }
 
 GSM_Error ATGEN_DelCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
         GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
 
         if (Priv->Manufacturer==AT_Siemens)  return SIEMENS_DelCalendarNote(s, Note);
         if (Priv->Manufacturer==AT_Ericsson) return SONYERIC_DelCalendarNote(s, Note);
         return ERR_NOTSUPPORTED;
 }
 
+
+GSM_Error ATGEN_GetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
+{
+                GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
+
+        if (Priv->Manufacturer==AT_Siemens) return SIEMENS_GetBitmap(s, Bitmap);
+        if (Priv->Manufacturer==AT_Samsung) return SAMSUNG_GetBitmap(s, Bitmap);
+        return ERR_NOTSUPPORTED;
+}
+
+GSM_Error ATGEN_SetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
+{
+                GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
+
+        if (Priv->Manufacturer==AT_Siemens) return SIEMENS_SetBitmap(s, Bitmap);
+        if (Priv->Manufacturer==AT_Samsung) return SAMSUNG_SetBitmap(s, Bitmap);
+        return ERR_NOTSUPPORTED;
+}
+
+GSM_Error ATGEN_GetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone)
+{
+                GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
+
+        if (Priv->Manufacturer==AT_Siemens) return SIEMENS_GetRingtone(s, Ringtone, PhoneRingtone);
+        if (Priv->Manufacturer==AT_Samsung) return SAMSUNG_GetRingtone(s, Ringtone, PhoneRingtone);
+        return ERR_NOTSUPPORTED;
+}
+
+GSM_Error ATGEN_SetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength)
+{
+                GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
+
+        if (Priv->Manufacturer==AT_Siemens) return SIEMENS_SetRingtone(s, Ringtone, maxlength);
+        if (Priv->Manufacturer==AT_Samsung) return SAMSUNG_SetRingtone(s, Ringtone, maxlength);
+        return ERR_NOTSUPPORTED;
+}
+
 GSM_Error ATGEN_PressKey(GSM_StateMachine *s, GSM_KeyCode Key, bool Press)
 {
                 GSM_Errorerror;
                 unsigned char Frame[] = "AT+CKPD=\"?\"\r";
 
         if (Press) {
                 switch (Key) {
                                 case GSM_KEY_1                  : Frame[9] = '1'; break;
                                 case GSM_KEY_2          : Frame[9] = '2'; break;
                                 case GSM_KEY_3          : Frame[9] = '3'; break;
                                 case GSM_KEY_4          : Frame[9] = '4'; break;
                                 case GSM_KEY_5          : Frame[9] = '5'; break;
                                 case GSM_KEY_6          : Frame[9] = '6'; break;
                                 case GSM_KEY_7          : Frame[9] = '7'; break;
                                 case GSM_KEY_8          : Frame[9] = '8'; break;
                                 case GSM_KEY_9          : Frame[9] = '9'; break;
                                 case GSM_KEY_0          : Frame[9] = '0'; break;
                                 case GSM_KEY_HASH       : Frame[9] = '#'; break;
                                 case GSM_KEY_ASTERISK   : Frame[9] = '*'; break;
                                 case GSM_KEY_POWER      : return ERR_NOTSUPPORTED;
                                 case GSM_KEY_GREEN      : Frame[9] = 'S'; break;
                                 case GSM_KEY_RED        : Frame[9] = 'E'; break;
                                 case GSM_KEY_INCREASEVOLUME: Frame[9] = 'U'; break;
                                 case GSM_KEY_DECREASEVOLUME: Frame[9] = 'D'; break;
                                 case GSM_KEY_UP                 : Frame[9] = '^'; break;
                                 case GSM_KEY_DOWN       : Frame[9] = 'V'; break;
                                 case GSM_KEY_MENU       : Frame[9] = 'F'; break;
                                 case GSM_KEY_NAMES      : Frame[9] = 'C'; break;
                                 default                         : return ERR_NOTSUPPORTED;
                 }
                 smprintf(s, "Pressing key\n");
                 error = GSM_WaitFor (s, Frame, 12, 0x00, 4, ID_PressKey);
                 if (error != ERR_NONE) return error;
 
                 /* Strange. My T310 needs it */
                 return GSM_WaitFor (s, "ATE1\r", 5, 0x00, 4, ID_EnableEcho);
         } else {
                 return ERR_NONE;
         }
 }
 
 #ifdef GSM_ENABLE_CELLBROADCAST
 
 GSM_Error ATGEN_ReplyIncomingCB(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_CBMessage CB;
                 int     i,j;
                 char    Buffer[300],Buffer2[300];
 
         smprintf(s, "CB received\n");
         return ERR_NONE;
 
         DecodeHexBin (Buffer,msg.Buffer+6,msg.Length-6);
         DumpMessage(stdout, di.dl ,Buffer,msg.Length-6);
 
         CB.Channel = Buffer[4];
 
         for (j=0;j<msg.Length;j++) {
         smprintf(s, "j=%i\n",j);
         i=GSM_UnpackEightBitsToSeven(0, msg.Buffer[6], msg.Buffer[6], msg.Buffer+j, Buffer2);
         //i = msg.Buffer[6] - 1;
         //while (i!=0) {
         //      if (Buffer[i] == 13) i = i - 1; else break;
         //}
         DecodeDefault(CB.Text, Buffer2, msg.Buffer[6], false, NULL);
         smprintf(s, "Channel %i, text \"%s\"\n",CB.Channel,DecodeUnicodeString(CB.Text));
         }
         if (s->Phone.Data.EnableIncomingCB && s->User.IncomingCB!=NULL) {
                 s->User.IncomingCB(s->CurrentConfig->Device,CB);
         }
         return ERR_NONE;
 }
 
 #endif
 
 GSM_Error ATGEN_SetIncomingCB(GSM_StateMachine *s, bool enable)
 {
 #ifdef GSM_ENABLE_CELLBROADCAST
         if (s->Phone.Data.EnableIncomingCB!=enable) {
                         s->Phone.Data.EnableIncomingCB = enable;
                 if (enable) {
                         smprintf(s, "Enabling incoming CB\n");
                         return GSM_WaitFor(s, "AT+CNMI=3,,2\r", 13, 0x00, 4, ID_SetIncomingCB);
                 } else {
                         smprintf(s, "Disabling incoming CB\n");
                         return GSM_WaitFor(s, "AT+CNMI=3,,0\r", 13, 0x00, 4, ID_SetIncomingCB);
                 }
         }
         return ERR_NONE;
 #else
         return ERR_SOURCENOTAVAILABLE;
 #endif
 }
 
+GSM_Error ATGEN_SetFastSMSSending(GSM_StateMachine *s, bool enable)
+{
+        if (enable) {
+                smprintf(s, "Enabling fast SMS sending\n");
+                return GSM_WaitFor(s, "AT+CMMS=2\r", 10, 0x00, 4, ID_SetFastSMSSending);
+        } else {
+                smprintf(s, "Disabling fast SMS sending\n");
+                return GSM_WaitFor(s, "AT+CMMS=0\r", 10, 0x00, 4, ID_SetFastSMSSending);
+        }
+}
+
 GSM_Error ATGEN_IncomingSMSInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Incoming SMS\n");
         return ERR_NONE;
 }
 
 GSM_Error ATGEN_IncomingSMSDeliver(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_Data  *Data = &s->Phone.Data;
                 GSM_SMSMessage          sms;
                 int             current = 0, current2, i=0;
                 unsigned char   buffer[300],smsframe[800];
 
         smprintf(s, "Incoming SMS received (Deliver)\n");
         if (Data->EnableIncomingSMS && s->User.IncomingSMS!=NULL) {
                         sms.State  = SMS_UnRead;
                 sms.InboxFolder  = true;
                         sms.PDU  = SMS_Deliver;
 
                 /* T310 with larger SMS goes crazy and mix this incoming
                  * frame with normal answers. PDU is always last frame
                  * We find its' number and parse it */
                 while (Data->Priv.ATGEN.Lines.numbers[i*2+1] != 0) {
                         /* FIXME: handle special chars correctly */
                         i++;
                 }
                 DecodeHexBin (buffer,
                         GetLineString(msg.Buffer,Data->Priv.ATGEN.Lines,i),
                         strlen(GetLineString(msg.Buffer,Data->Priv.ATGEN.Lines,i)));
 
                 /* We use locations from SMS layouts like in ../phone2.c(h) */
                 for(i=0;i<buffer[0]+1;i++) smsframe[i]=buffer[current++];
                 smsframe[12]=buffer[current++];
 
                 current2=((buffer[current])+1)/2+1;
                 for(i=0;i<current2+1;i++) smsframe[PHONE_SMSDeliver.Number+i]=buffer[current++];
                 smsframe[PHONE_SMSDeliver.TPPID] = buffer[current++];
                 smsframe[PHONE_SMSDeliver.TPDCS] = buffer[current++];
                 for(i=0;i<7;i++) smsframe[PHONE_SMSDeliver.DateTime+i]=buffer[current++];
                 smsframe[PHONE_SMSDeliver.TPUDL] = buffer[current++];
                 for(i=0;i<smsframe[PHONE_SMSDeliver.TPUDL];i++) smsframe[i+PHONE_SMSDeliver.Text]=buffer[current++];
                 GSM_DecodeSMSFrame(&sms,smsframe,PHONE_SMSDeliver);
 
                 s->User.IncomingSMS(s->CurrentConfig->Device,sms);
         }
         return ERR_NONE;
 }
 
 /* I don't have phone able to do it and can't fill it */
 GSM_Error ATGEN_IncomingSMSReport(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Incoming SMS received (Report)\n");
         return ERR_NONE;
 }
 
 GSM_Error ATGEN_SetIncomingSMS(GSM_StateMachine *s, bool enable)
 {
         /* Nokia returns OK, but doesn't return anything */
         if (s->Phone.Data.Priv.ATGEN.Manufacturer == AT_Nokia) return ERR_NOTSUPPORTED;
 
         if (s->Phone.Data.EnableIncomingSMS!=enable) {
                 s->Phone.Data.EnableIncomingSMS = enable;
                 if (enable) {
                         smprintf(s, "Enabling incoming SMS\n");
 
                         /* Delivery reports */
                         GSM_WaitFor(s, "AT+CNMI=3,,,1\r", 14, 0x00, 4, ID_SetIncomingSMS);
 
                         /* SMS deliver */
                         return GSM_WaitFor(s, "AT+CNMI=3,3\r", 12, 0x00, 4, ID_SetIncomingSMS);
                 } else {
                         smprintf(s, "Disabling incoming SMS\n");
                         return GSM_WaitFor(s, "AT+CNMI=3,0\r", 12, 0x00, 4, ID_SetIncomingSMS);
                 }
         }
         return ERR_NONE;
 }
 
+GSM_Error ATGEN_GetLocale(GSM_StateMachine *s, GSM_Locale *locale)
+{
+        if (s->Phone.Data.Priv.ATGEN.Manufacturer==AT_Ericsson) return ERICSSON_GetLocale(s,locale);
+        return ERR_NOTSUPPORTED;
+}
+
+GSM_Error ATGEN_SetLocale(GSM_StateMachine *s, GSM_Locale *locale)
+{
+        if (s->Phone.Data.Priv.ATGEN.Manufacturer==AT_Ericsson) return ERICSSON_SetLocale(s,locale);
+        return ERR_NOTSUPPORTED;
+}
+
 GSM_Reply_Function ATGENReplyFunctions[] = {
         {ATGEN_GenericReply,            "AT\r"                  ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_GenericReply,            "ATE1"                          ,0x00,0x00,ID_EnableEcho },
         {ATGEN_GenericReply,            "AT+CMEE="              ,0x00,0x00,ID_EnableErrorInfo },
         {ATGEN_GenericReply,            "AT+CKPD="              ,0x00,0x00,ID_PressKey   },
         {ATGEN_ReplyGetSIMIMSI,                 "AT+CIMI"               ,0x00,0x00,ID_GetSIMIMSI },
         {ATGEN_GenericReply,            "AT*EOBEX"              ,0x00,0x00,ID_SetOBEX    },
 
+        {ERICSSON_ReplyGetDateLocale,   "*ESDF:"                ,0x00,0x00,ID_GetLocale          },
+        {ERICSSON_ReplyGetTimeLocale,   "*ESTF:"                ,0x00,0x00,ID_GetLocale           },
+        {ATGEN_GenericReply,            "AT*ESDF="              ,0x00,0x00,ID_SetLocale          },
+        {ATGEN_GenericReply,            "AT*ESTF="              ,0x00,0x00,ID_SetLocale          },
+
 #ifdef GSM_ENABLE_CELLBROADCAST
         {ATGEN_ReplyIncomingCB,                 "+CBM:"                 ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_GenericReply,            "AT+CNMI"               ,0x00,0x00,ID_SetIncomingCB },
 #endif
 
         {ATGEN_IncomingBattery,                 "_OBS:"                  ,0x00,0x00,ID_IncomingFrame      },
         {ATGEN_ReplyGetBatteryCharge,   "AT+CBC"                ,0x00,0x00,ID_GetBatteryCharge },
 
         {ATGEN_ReplyGetModel,           "AT+CGMM"       ,0x00,0x00,ID_GetModel           },
         {ATGEN_ReplyGetManufacturer,    "AT+CGMI"               ,0x00,0x00,ID_GetManufacturer },
         {ATGEN_ReplyGetFirmwareCGMR,    "AT+CGMR"               ,0x00,0x00,ID_GetFirmware },
         {ATGEN_ReplyGetFirmwareATI,     "ATI"                   ,0x00,0x00,ID_GetFirmware },
         {ATGEN_ReplyGetIMEI,            "AT+CGSN"               ,0x00,0x00,ID_GetIMEI     },
 
         {ATGEN_ReplySendSMS,            "AT+CMGS"               ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_ReplySendSMS,            "AT+CMSS"               ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_GenericReply,            "AT+CNMI"               ,0x00,0x00,ID_SetIncomingSMS },
         {ATGEN_GenericReply,            "AT+CMGF"               ,0x00,0x00,ID_GetSMSMode },
         {ATGEN_GenericReply,            "AT+CSDH"               ,0x00,0x00,ID_GetSMSMode },
         {ATGEN_ReplyGetSMSMessage,      "AT+CMGR"               ,0x00,0x00,ID_GetSMSMessage },
         {ATGEN_GenericReply,            "AT+CPMS"               ,0x00,0x00,ID_SetMemoryType },
         {ATGEN_ReplyGetSMSStatus,       "AT+CPMS"               ,0x00,0x00,ID_GetSMSStatus },
         {ATGEN_ReplyGetSMSMemories,     "AT+CPMS=?"             ,0x00,0x00,ID_GetSMSMemories },
         {ATGEN_ReplyAddSMSMessage,      "AT+CMGW"               ,0x00,0x00,ID_SaveSMSMessage },
         {ATGEN_GenericReply,            "AT+CSMP"               ,0x00,0x00,ID_SetSMSParameters },
         {ATGEN_GenericReply,            "AT+CSCA"               ,0x00,0x00,ID_SetSMSC    },
         {ATGEN_ReplyGetSMSC,            "AT+CSCA?"              ,0x00,0x00,ID_GetSMSC    },
         {ATGEN_ReplyDeleteSMSMessage,   "AT+CMGD"               ,0x00,0x00,ID_DeleteSMSMessage },
         {ATGEN_GenericReply,            "ATE1"                  ,0x00,0x00,ID_SetSMSParameters },
         {ATGEN_GenericReply,            "\x1b\x0D"              ,0x00,0x00,ID_SetSMSParameters },
+        {ATGEN_GenericReply,            "AT+CMMS"       ,0x00,0x00,ID_SetFastSMSSending  },
         {ATGEN_IncomingSMSInfo,                 "+CMTI:"                ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_IncomingSMSDeliver,      "+CMT:"                 ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_IncomingSMSReport,       "+CDS:"                 ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_IncomingSMSCInfo,        "^SCN:"                         ,0x00,0x00,ID_IncomingFrame },
 
         {ATGEN_ReplyGetDateTime_Alarm,  "AT+CCLK?"              ,0x00,0x00,ID_GetDateTime },
         {ATGEN_GenericReply,            "AT+CCLK="              ,0x00,0x00,ID_SetDateTime },
+        {ATGEN_GenericReply,            "AT+CALA="              ,0x00,0x00,ID_SetAlarm   },
         {ATGEN_ReplyGetDateTime_Alarm,  "AT+CALA?"              ,0x00,0x00,ID_GetAlarm   },
 
         {ATGEN_ReplyGetNetworkLAC_CID,  "AT+CREG?"              ,0x00,0x00,ID_GetNetworkInfo },
         {ATGEN_GenericReply,            "AT+CREG=2"             ,0x00,0x00,ID_GetNetworkInfo },
         {ATGEN_GenericReply,            "AT+COPS="              ,0x00,0x00,ID_GetNetworkInfo },
         {ATGEN_GenericReply,            "AT+COPS="      ,0x00,0x00,ID_SetAutoNetworkLogin},
         {ATGEN_ReplyGetNetworkCode,     "AT+COPS"               ,0x00,0x00,ID_GetNetworkInfo },
         {ATGEN_ReplyGetSignalQuality,   "AT+CSQ"                ,0x00,0x00,ID_GetSignalQuality },
         {ATGEN_IncomingNetworkLevel,    "_OSIGQ:"               ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_IncomingGPRS,            "+CGREG:"        ,0x00,0x00,ID_IncomingFrame      },
         {ATGEN_ReplyGetNetworkLAC_CID,  "+CREG:"                ,0x00,0x00,ID_IncomingFrame },
 
         {ATGEN_ReplyGetPBKMemories,     "AT+CPBS=?"             ,0x00,0x00,ID_SetMemoryType },
         {ATGEN_GenericReply,            "AT+CPBS="              ,0x00,0x00,ID_SetMemoryType },
         {ATGEN_ReplyGetCPBSMemoryStatus,"AT+CPBS?"              ,0x00,0x00,ID_GetMemoryStatus },
+// /* Samsung phones reply +CPBR: after OK --claudio*/
         {ATGEN_ReplyGetCPBRMemoryInfo,  "AT+CPBR=?"             ,0x00,0x00,ID_GetMemoryStatus },
+        {ATGEN_ReplyGetCPBRMemoryInfo,  "+CPBR:"                ,0x00,0x00,ID_GetMemoryStatus },
         {ATGEN_ReplyGetCPBRMemoryStatus,"AT+CPBR="              ,0x00,0x00,ID_GetMemoryStatus },
         {ATGEN_GenericReply,            "AT+CSCS="              ,0x00,0x00,ID_SetMemoryCharset },
         {ATGEN_ReplyGetMemory,          "AT+CPBR="              ,0x00,0x00,ID_GetMemory          },
         {ATGEN_GenericReply,            "AT^SBNR=?"             ,0x00,0x00,ID_GetMemory          },
-        {ATGEN_SL45ReplyGetMemory,      "AT^SBNR"               ,0x00,0x00,ID_GetMemory          },
+        {SIEMENS_ReplyGetMemory,        "AT^SBNR"               ,0x00,0x00,ID_GetMemory          },
         {ATGEN_ReplySetMemory,          "AT+CPBW"               ,0x00,0x00,ID_SetMemory          },
 
-        {ATGEN_CMS35ReplyGetBitmap,     "AT^SBNR=\"bmp\""       ,0x00,0x00,ID_GetBitmap           },
-        {ATGEN_CMS35ReplySetBitmap,     "AT^SBNW=\"bmp\""       ,0x00,0x00,ID_SetBitmap           },
+        {SIEMENS_ReplyGetBitmap,        "AT^SBNR=\"bmp\""       ,0x00,0x00,ID_GetBitmap           },
+        {SIEMENS_ReplySetBitmap,        "AT^SBNW=\"bmp\""       ,0x00,0x00,ID_SetBitmap           },
 
-        {ATGEN_CMS35ReplyGetRingtone,   "AT^SBNR=\"mid\""       ,0x00,0x00,ID_GetRingtone },
-        {ATGEN_CMS35ReplySetRingtone,   "AT^SBNW=\"mid\""       ,0x00,0x00,ID_SetRingtone },
+        {SIEMENS_ReplyGetRingtone,      "AT^SBNR=\"mid\""       ,0x00,0x00,ID_GetRingtone },
+        {SIEMENS_ReplySetRingtone,      "AT^SBNW=\"mid\""       ,0x00,0x00,ID_SetRingtone },
 
-        {ATGEN_CMS35ReplyGetNextCal,    "AT^SBNR=\"vcs\""       ,0x00,0x00,ID_GetCalendarNote },
-        {ATGEN_CMS35ReplySetCalendar,   "AT^SBNW=\"vcs\""       ,0x00,0x00,ID_SetCalendarNote },
-        {ATGEN_CMS35ReplyDeleteCalendar,"AT^SBNW=\"vcs\"",0x00,0x00,ID_DeleteCalendarNote },
+        {SIEMENS_ReplyGetNextCalendar,  "AT^SBNR=\"vcs\""       ,0x00,0x00,ID_GetCalendarNote },
+        {SIEMENS_ReplyAddCalendarNote,  "AT^SBNW=\"vcs\""       ,0x00,0x00,ID_SetCalendarNote },
+        {SIEMENS_ReplyDelCalendarNote,  "AT^SBNW=\"vcs\"",0x00,0x00,ID_DeleteCalendarNote },
 
         {ATGEN_ReplyEnterSecurityCode,  "AT+CPIN="              ,0x00,0x00,ID_EnterSecurityCode },
         {ATGEN_ReplyEnterSecurityCode,  "AT+CPIN2="             ,0x00,0x00,ID_EnterSecurityCode },
         {ATGEN_ReplyGetSecurityStatus,  "AT+CPIN?"              ,0x00,0x00,ID_GetSecurityStatus },
         {ATGEN_ReplyOK,                         "OK"                    ,0x00,0x00,ID_IncomingFrame },
 
         {ATGEN_GenericReply,            "AT+VTS"                ,0x00,0x00,ID_SendDTMF   },
         {ATGEN_ReplyCancelCall,                 "AT+CHUP"               ,0x00,0x00,ID_CancelCall },
         {ATGEN_ReplyDialVoice,          "ATDT"                  ,0x00,0x00,ID_DialVoice          },
         {ATGEN_ReplyCancelCall,                 "ATH"                   ,0x00,0x00,ID_CancelCall },
+        {ATGEN_GenericReply,            "AT+CUSD"               ,0x00,0x00,ID_SetUSSD    },
+        {ATGEN_ReplyGetUSSD,            "+CUSD"                         ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_GenericReply,            "AT+CLIP=1"      ,0x00,0x00,ID_IncomingFrame      },
         {ATGEN_ReplyIncomingCallInfo,   "+CLIP"                         ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_ReplyIncomingCallInfo,   "+COLP"                 ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_ReplyIncomingCallInfo,   "RING"                  ,0x00,0x00,ID_IncomingFrame },
         {ATGEN_ReplyIncomingCallInfo,   "NO CARRIER"            ,0x00,0x00,ID_IncomingFrame },
 
         {ATGEN_ReplyReset,              "AT^SRESET"             ,0x00,0x00,ID_Reset      },
         {ATGEN_ReplyReset,              "AT+CFUN=1,1"           ,0x00,0x00,ID_Reset      },
         {ATGEN_ReplyResetPhoneSettings, "AT&F"          ,0x00,0x00,ID_ResetPhoneSettings },
 
+        {SAMSUNG_ReplyGetBitmap,        "AT+IMGR="              ,0x00,0x00,ID_GetBitmap           },
+        {SAMSUNG_ReplySetBitmap,        "SDNDCRC ="             ,0x00,0x00,ID_SetBitmap          },
+
+        {SAMSUNG_ReplyGetRingtone,      "AT+MELR="              ,0x00,0x00,ID_GetRingtone },
+        {SAMSUNG_ReplySetRingtone,      "SDNDCRC ="             ,0x00,0x00,ID_SetRingtone },
+
 #ifdef GSM_ENABLE_ALCATEL
 /*  Why do I give Alcatel specific things here? It's simple, Alcatel needs
  *  some AT commands to start it's binary mode, so this needs to be in AT
  *  related stuff. 
  *
  *  XXX: AT+IFC could later move outside this ifdef, because it is not Alcatel
  *  specific and it's part of ETSI specifications 
  */
         {ATGEN_GenericReply,            "AT+IFC"                ,0x00,0x00,ID_SetFlowControl   },
         {ALCATEL_ProtocolVersionReply,  "AT+CPROT=?"     ,0x00,0x00,ID_AlcatelProtocol    },
         {ATGEN_GenericReply,            "AT+CPROT"              ,0x00,0x00,ID_AlcatelConnect },
 #endif
 
         {NULL,                          "\x00"                  ,0x00,0x00,ID_None       }
 };                                                                                      
 
 GSM_Phone_Functions ATGENPhone = {
-        "A2D|iPAQ|at|M20|S25|MC35|C35i|5110|5130|5190|5210|6110|6130|6150|6190|6210|6250|6310|6310i|6510|7110|8210|8250|8290|8310|8390|8850|8855|8890|8910|9110|9210",
+        "A2D|iPAQ|at|M20|S25|MC35|TC35|C35i|S300|5110|5130|5190|5210|6110|6130|6150|6190|6210|6250|6310|6310i|6510|7110|8210|8250|8290|8310|8390|8850|8855|8890|8910|9110|9210",
         ATGENReplyFunctions,
         ATGEN_Initialise,
         ATGEN_Terminate,
         ATGEN_DispatchMessage,
                 NOTSUPPORTED,                   /*      ShowStartInfo   */
         ATGEN_GetManufacturer,
         ATGEN_GetModel,
         ATGEN_GetFirmware,
         ATGEN_GetIMEI,
                 NOTSUPPORTED,                   /*      GetOriginalIMEI         */
                 NOTSUPPORTED,                   /*      GetManufactureMonth*/
                 NOTSUPPORTED,                   /*      GetProductCode  */
                 NOTSUPPORTED,                   /*      GetHardware     */
                 NOTSUPPORTED,                   /*      GetPPM          */
         ATGEN_GetSIMIMSI,
         ATGEN_GetDateTime,
         ATGEN_SetDateTime,
         ATGEN_GetAlarm,
-                NOTIMPLEMENTED,                         /*      SetAlarm        */
-                NOTSUPPORTED,                   /*      GetLocale       */
-                NOTSUPPORTED,                   /*      SetLocale       */
+        ATGEN_SetAlarm,
+        ATGEN_GetLocale,
+        ATGEN_SetLocale,
         ATGEN_PressKey,
         ATGEN_Reset,
         ATGEN_ResetPhoneSettings,
         ATGEN_EnterSecurityCode,
         ATGEN_GetSecurityStatus,
         ATGEN_GetDisplayStatus,
         ATGEN_SetAutoNetworkLogin,
         ATGEN_GetBatteryCharge,
         ATGEN_GetSignalQuality,
         ATGEN_GetNetworkInfo,
                 NOTSUPPORTED,                   /*      GetCategory     */
                 NOTSUPPORTED,                   /*      AddCategory     */
                 NOTSUPPORTED,                   /*      GetCategoryStatus */
         ATGEN_GetMemoryStatus,
         ATGEN_GetMemory,
         ATGEN_GetNextMemory,
         ATGEN_SetMemory,
         ATGEN_AddMemory,
         ATGEN_DeleteMemory,
         ATGEN_DeleteAllMemory,
                 NOTSUPPORTED,                   /*      GetSpeedDial    */
                 NOTSUPPORTED,                   /*      SetSpeedDial    */
         ATGEN_GetSMSC,
         ATGEN_SetSMSC,
         ATGEN_GetSMSStatus,
         ATGEN_GetSMS,
         ATGEN_GetNextSMS,
                 NOTSUPPORTED,                   /*      SetSMS          */
         ATGEN_AddSMS,
         ATGEN_DeleteSMS,
         ATGEN_SendSMS,
         ATGEN_SendSavedSMS,
+        ATGEN_SetFastSMSSending,
         ATGEN_SetIncomingSMS,
         ATGEN_SetIncomingCB,
         ATGEN_GetSMSFolders,
                 NOTSUPPORTED,                   /*      AddSMSFolder    */
                 NOTSUPPORTED,                   /*      DeleteSMSFolder         */
         ATGEN_DialVoice,
         ATGEN_AnswerCall,
         ATGEN_CancelCall,
                 NOTSUPPORTED,                   /*      HoldCall        */
                 NOTSUPPORTED,                   /*      UnholdCall      */
                 NOTSUPPORTED,                   /*      ConferenceCall          */
                 NOTSUPPORTED,                   /*      SplitCall       */
                 NOTSUPPORTED,                   /*      TransferCall    */
                 NOTSUPPORTED,                   /*      SwitchCall      */
                 NOTSUPPORTED,                   /*      GetCallDivert   */
                 NOTSUPPORTED,                   /*      SetCallDivert   */
                 NOTSUPPORTED,                   /*      CancelAllDiverts*/
                 NONEFUNCTION,                   /*      SetIncomingCall         */
-                NOTSUPPORTED,                   /*      SetIncomingUSSD         */
+        ATGEN_SetIncomingUSSD,
         ATGEN_SendDTMF,
         ATGEN_GetRingtone,
         ATGEN_SetRingtone,
                 NOTSUPPORTED,                   /*      GetRingtonesInfo*/
                 NOTSUPPORTED,                   /*      DeleteUserRingtones*/
                 NOTSUPPORTED,                   /*      PlayTone        */
                 NOTSUPPORTED,                   /*      GetWAPBookmark  */
                 NOTSUPPORTED,                   /*      SetWAPBookmark          */
                 NOTSUPPORTED,                   /*      DeleteWAPBookmark */
                 NOTSUPPORTED,                   /*      GetWAPSettings          */
                 NOTSUPPORTED,                   /*      SetWAPSettings          */
                 NOTSUPPORTED,                   /*      GetMMSSettings  */
                 NOTSUPPORTED,                   /*      SetMMSSettings  */
                 NOTSUPPORTED,                   /*      GetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      GetChatSettings         */
                 NOTSUPPORTED,                   /*      SetChatSettings         */
                 ATGEN_GetBitmap,                /*      GetBitmap       */
                 ATGEN_SetBitmap,                /*      SetBitmap       */
         SONYERIC_GetToDoStatus,
                 NOTSUPPORTED,                   /*      GetToDo                 */
         SONYERIC_GetNextToDo,
                 NOTSUPPORTED,                   /*      SetToDo                 */
         SONYERIC_AddToDo,
                 NOTSUPPORTED,                   /*      DeleteToDo      */
         SONYERIC_DeleteAllToDo,
         SONYERIC_GetCalendarStatus,
                 NOTIMPLEMENTED,                         /*      GetCalendar     */
             ATGEN_GetNextCalendar,
                 NOTIMPLEMENTED,                         /*      SetCalendar     */
         ATGEN_AddCalendarNote,
         ATGEN_DelCalendarNote,
                 NOTIMPLEMENTED,                         /*      DeleteAllCalendar*/
                 NOTSUPPORTED,                   /*      GetCalendarSettings*/
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTSUPPORTED,                   /*      GetNote                 */
+                NOTSUPPORTED,                   /*      GetNextNote     */
                 NOTSUPPORTED,                   /*      GetProfile      */
                 NOTSUPPORTED,                   /*      SetProfile      */
                 NOTSUPPORTED,                   /*      GetFMStation        */
                 NOTSUPPORTED,                   /*      SetFMStation        */
                 NOTSUPPORTED,                   /*      ClearFMStations       */
                 NOTSUPPORTED,                   /*      GetNextFileFolder*/
                 NOTSUPPORTED,                   /*      GetFilePart     */
                 NOTSUPPORTED,                   /*      AddFile                 */
                 NOTSUPPORTED,                   /*      GetFileSystemStatus*/
                 NOTSUPPORTED,                   /*      DeleteFile      */
                 NOTSUPPORTED,                   /*      AddFolder       */
                 NOTSUPPORTED,                   /*      GetGPRSAccessPoint*/
                 NOTSUPPORTED                    /*      SetGPRSAccessPoint*/
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/at/atgen.h b/gammu/emb/common/phone/at/atgen.h
index 0e08ee4..bb5c559 100644
--- a/gammu/emb/common/phone/at/atgen.h
+++ b/gammu/emb/common/phone/at/atgen.h
@@ -1,110 +1,116 @@
 /* (c) 2002-2004 by Marcin Wiacek and Michal Cihar */
 
 #ifndef atgen_h
 #define atgen_h
 
 #include "../../gsmcomon.h"
 #include "../../gsmstate.h"
 #include "../../service/sms/gsmsms.h"
 
 #ifndef GSM_USED_AT
 #  define GSM_USED_AT
 #endif
 #ifndef GSM_USED_BLUEAT
 #  define GSM_USED_BLUEAT
 #endif
 #ifndef GSM_USED_IRDAAT
 #  define GSM_USED_IRDAAT
 #endif
 
 #define MAX_VCALENDAR_LOCATION 50
 
 typedef enum {
         SMS_AT_PDU = 1,
         SMS_AT_TXT
 } GSM_AT_SMS_Modes;
 
 typedef enum {
         AT_Reply_OK = 1,
         AT_Reply_Connect,
         AT_Reply_Error,
         AT_Reply_Unknown,
         AT_Reply_CMSError,
         AT_Reply_CMEError,
         AT_Reply_SMSEdit
 } GSM_AT_Reply_State;
 
 typedef enum {
         AT_Nokia = 1,
         AT_Alcatel,
         AT_Siemens,
         AT_HP,
         AT_Falcom,
         AT_Ericsson,
         AT_Sagem,
+        AT_Samsung,
         AT_Unknown
 } GSM_AT_Manufacturer;
 
 typedef enum {
         AT_PBK_HEX = 1,
         AT_PBK_GSM,
-        AT_PBK_UCS2
+        AT_PBK_UCS2,
+        AT_PBK_PCCP437
 } GSM_AT_PBK_Charset;
 
 typedef enum {
         AT_AVAILABLE = 1,
         AT_NOTAVAILABLE
 } GSM_AT_SMSMemory;
 
 typedef enum {
         AT_SBNR_AVAILABLE = 1,
         AT_SBNR_NOTAVAILABLE
 } GSM_AT_SBNR;
 
 typedef enum {
         AT_Status,
         AT_NextEmpty,
         AT_Total,
         AT_First,
         AT_Sizes
 } GSM_AT_NeededMemoryInfo;
 
         #define AT_PBK_MAX_MEMORIES200
 
 typedef struct {
                 GSM_AT_Manufacturer     Manufacturer;           /* Who is manufacturer                                  */
                 GSM_Lines               Lines;                  /* Allow to simply get each line in response            */
                 GSM_AT_Reply_State      ReplyState;             /* What response type - error, OK, etc.                 */
                 int                     ErrorCode;              /* Error codes from responses                           */
                 char                    *ErrorText;                     /* Error description                                    */
 
                 GSM_MemoryType          PBKMemory;              /* Last read PBK memory                                         */
                 char                    PBKMemories[AT_PBK_MAX_MEMORIES + 1]; /* Supported by phone PBK memories        */
                 int                     NextMemoryEntry;        /* Next empty memory entry                              */
                 int                     FirstMemoryEntry;       /* First memory entry to be read                        */
                 GSM_AT_PBK_Charset      PBKCharset;             /* Last read PBK charset                                */
                 bool                    UCS2CharsetFailed;      /* Whether setting of UCS2 charset has already failed   */
                 bool                    NonUCS2CharsetFailed;   /* Whether setting of non-UCS2 charset has already failed */
                 GSM_AT_SBNR     PBKSBNR;
                 int             NumberLength;
                 int             TextLength;
                 int             MemorySize;
 
                 GSM_SMSMemoryStatusLastSMSStatus;
                 int             LastSMSRead;
                 int             FirstCalendarPos;
                 bool            CanSaveSMS;
                 GSM_AT_SMSMemory        PhoneSMSMemory;                 /* Is phone SMS memory available ?                      */
                 GSM_AT_SMSMemory        SIMSMSMemory;           /* Is SIM SMS memory available ?                        */
                 GSM_MemoryType          SMSMemory;              /* Last read SMS memory                                 */
                 GSM_AT_SMS_Modes        SMSMode;                /* PDU or TEXT mode for SMS ?                           */
 
                 bool            OBEX;
                 GSM_File        file;
 } GSM_Phone_ATGENData;
 
+        GSM_Error ATGEN_HandleCMSError(GSM_StateMachine *);
+        GSM_Error ATGEN_HandleCMEError(GSM_StateMachine *);
+        GSM_Error ATGEN_DispatchMessage(GSM_StateMachine *);
+
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/at/samsung.c b/gammu/emb/common/phone/at/samsung.c
new file mode 100644
index 0000000..55a42e5
--- a/dev/null
+++ b/gammu/emb/common/phone/at/samsung.c
@@ -0,0 +1,447 @@
+/* Samsung-specific functions
+ * Copyright (C) 2004 Claudio Matsuoka <cmatsuoka@gmail.com>
+ * Tested with S300 only!
+ */
+                                           
+#include "../../gsmstate.h"
+
+#ifdef GSM_ENABLE_ATGEN
+
+#include <string.h>
+#include <time.h>
+#include <ctype.h>
+
+#include "../../misc/coding/coding.h"
+#include "../../gsmcomon.h"
+#include "../../service/sms/gsmsms.h"
+#include "../pfunc.h"
+
+#include "atgen.h"
+#include "samsung.h"
+
+/* Binary frame size */
+#define BLKSZ 1024
+
+struct ModelRes {
+        char *model;
+        int width;
+        int height;
+};
+
+static struct ModelRes modres[] = {
+        { "S100", 128, 128 },
+        { "S200", 128, 113 },
+        { "S300", 128,  97 },
+        { "S500", 128, 128 },
+        { "T100", 128, 128 },
+        { "E700", 128, 128 },
+        { NULL, 0, 0 }
+};
+
+/*
+ * CRC functions from the Granch SBNI12 Linux driver by
+ * Denis I. Timofeev <timofeev@granch.ru>
+ */
+static unsigned int crc32tab[] = {
+        0xD202EF8D,  0xA505DF1B,  0x3C0C8EA1,  0x4B0BBE37,
+        0xD56F2B94,  0xA2681B02,  0x3B614AB8,  0x4C667A2E,
+        0xDCD967BF,  0xABDE5729,  0x32D70693,  0x45D03605,
+        0xDBB4A3A6,  0xACB39330,  0x35BAC28A,  0x42BDF21C,
+        0xCFB5FFE9,  0xB8B2CF7F,  0x21BB9EC5,  0x56BCAE53,
+        0xC8D83BF0,  0xBFDF0B66,  0x26D65ADC,  0x51D16A4A,
+        0xC16E77DB,  0xB669474D,  0x2F6016F7,  0x58672661,
+        0xC603B3C2,  0xB1048354,  0x280DD2EE,  0x5F0AE278,
+        0xE96CCF45,  0x9E6BFFD3,  0x0762AE69,  0x70659EFF,
+        0xEE010B5C,  0x99063BCA,  0x000F6A70,  0x77085AE6,
+        0xE7B74777,  0x90B077E1,  0x09B9265B,  0x7EBE16CD,
+        0xE0DA836E,  0x97DDB3F8,  0x0ED4E242,  0x79D3D2D4,
+        0xF4DBDF21,  0x83DCEFB7,  0x1AD5BE0D,  0x6DD28E9B,
+        0xF3B61B38,  0x84B12BAE,  0x1DB87A14,  0x6ABF4A82,
+        0xFA005713,  0x8D076785,  0x140E363F,  0x630906A9,
+        0xFD6D930A,  0x8A6AA39C,  0x1363F226,  0x6464C2B0,
+        0xA4DEAE1D,  0xD3D99E8B,  0x4AD0CF31,  0x3DD7FFA7,
+        0xA3B36A04,  0xD4B45A92,  0x4DBD0B28,  0x3ABA3BBE,
+        0xAA05262F,  0xDD0216B9,  0x440B4703,  0x330C7795,
+        0xAD68E236,  0xDA6FD2A0,  0x4366831A,  0x3461B38C,
+        0xB969BE79,  0xCE6E8EEF,  0x5767DF55,  0x2060EFC3,
+        0xBE047A60,  0xC9034AF6,  0x500A1B4C,  0x270D2BDA,
+        0xB7B2364B,  0xC0B506DD,  0x59BC5767,  0x2EBB67F1,
+        0xB0DFF252,  0xC7D8C2C4,  0x5ED1937E,  0x29D6A3E8,
+        0x9FB08ED5,  0xE8B7BE43,  0x71BEEFF9,  0x06B9DF6F,
+        0x98DD4ACC,  0xEFDA7A5A,  0x76D32BE0,  0x01D41B76,
+        0x916B06E7,  0xE66C3671,  0x7F6567CB,  0x0862575D,
+        0x9606C2FE,  0xE101F268,  0x7808A3D2,  0x0F0F9344,
+        0x82079EB1,  0xF500AE27,  0x6C09FF9D,  0x1B0ECF0B,
+        0x856A5AA8,  0xF26D6A3E,  0x6B643B84,  0x1C630B12,
+        0x8CDC1683,  0xFBDB2615,  0x62D277AF,  0x15D54739,
+        0x8BB1D29A,  0xFCB6E20C,  0x65BFB3B6,  0x12B88320,
+        0x3FBA6CAD,  0x48BD5C3B,  0xD1B40D81,  0xA6B33D17,
+        0x38D7A8B4,  0x4FD09822,  0xD6D9C998,  0xA1DEF90E,
+        0x3161E49F,  0x4666D409,  0xDF6F85B3,  0xA868B525,
+        0x360C2086,  0x410B1010,  0xD80241AA,  0xAF05713C,
+        0x220D7CC9,  0x550A4C5F,  0xCC031DE5,  0xBB042D73,
+        0x2560B8D0,  0x52678846,  0xCB6ED9FC,  0xBC69E96A,
+        0x2CD6F4FB,  0x5BD1C46D,  0xC2D895D7,  0xB5DFA541,
+        0x2BBB30E2,  0x5CBC0074,  0xC5B551CE,  0xB2B26158,
+        0x04D44C65,  0x73D37CF3,  0xEADA2D49,  0x9DDD1DDF,
+        0x03B9887C,  0x74BEB8EA,  0xEDB7E950,  0x9AB0D9C6,
+        0x0A0FC457,  0x7D08F4C1,  0xE401A57B,  0x930695ED,
+        0x0D62004E,  0x7A6530D8,  0xE36C6162,  0x946B51F4,
+        0x19635C01,  0x6E646C97,  0xF76D3D2D,  0x806A0DBB,
+        0x1E0E9818,  0x6909A88E,  0xF000F934,  0x8707C9A2,
+        0x17B8D433,  0x60BFE4A5,  0xF9B6B51F,  0x8EB18589,
+        0x10D5102A,  0x67D220BC,  0xFEDB7106,  0x89DC4190,
+        0x49662D3D,  0x3E611DAB,  0xA7684C11,  0xD06F7C87,
+        0x4E0BE924,  0x390CD9B2,  0xA0058808,  0xD702B89E,
+        0x47BDA50F,  0x30BA9599,  0xA9B3C423,  0xDEB4F4B5,
+        0x40D06116,  0x37D75180,  0xAEDE003A,  0xD9D930AC,
+        0x54D13D59,  0x23D60DCF,  0xBADF5C75,  0xCDD86CE3,
+        0x53BCF940,  0x24BBC9D6,  0xBDB2986C,  0xCAB5A8FA,
+        0x5A0AB56B,  0x2D0D85FD,  0xB404D447,  0xC303E4D1,
+        0x5D677172,  0x2A6041E4,  0xB369105E,  0xC46E20C8,
+        0x72080DF5,  0x050F3D63,  0x9C066CD9,  0xEB015C4F,
+        0x7565C9EC,  0x0262F97A,  0x9B6BA8C0,  0xEC6C9856,
+        0x7CD385C7,  0x0BD4B551,  0x92DDE4EB,  0xE5DAD47D,
+        0x7BBE41DE,  0x0CB97148,  0x95B020F2,  0xE2B71064,
+        0x6FBF1D91,  0x18B82D07,  0x81B17CBD,  0xF6B64C2B,
+        0x68D2D988,  0x1FD5E91E,  0x86DCB8A4,  0xF1DB8832,
+        0x616495A3,  0x1663A535,  0x8F6AF48F,  0xF86DC419,
+        0x660951BA,  0x110E612C,  0x88073096,  0xFF000000
+};
+
+static unsigned int GetCRC(char *data, int size)
+{
+        unsigned int crc = 0;
+
+        while (size--)
+                crc = crc32tab[(crc ^ *data++) & 0xff] ^ ((crc >> 8) & 0x00FFFFFF);
+
+        return crc;
+}
+
+/*
+ * Frame transfer
+ */
+
+static GSM_Error WaitFor(GSM_StateMachine *s, char *t, int ttl)
+{
+                char    readbuf[100];
+                int     n;
+                unsigned int sec;
+        GSM_DateTime    Date;
+
+        GSM_GetCurrentDateTime (&Date);
+        sec = Date.Second;
+
+        n = s->Device.Functions->ReadDevice(s, readbuf, 80);
+        readbuf[n] = 0;
+        while (strstr(readbuf, t) == NULL && (sec + ttl) >= Date.Second) {
+                my_sleep(5000);
+                n = s->Device.Functions->ReadDevice(s, readbuf, 80);
+                readbuf[n] = 0;
+                GSM_GetCurrentDateTime (&Date);
+        }
+
+        return (sec + ttl) >= Date.Second ? ERR_NONE : ERR_TIMEOUT;
+}
+
+static GSM_Error SetSamsungFrame(GSM_StateMachine *s, unsigned char *buff, int size, GSM_Phone_RequestID id)
+{
+                GSM_Phone_Data  *Phone = &s->Phone.Data;
+                GSM_Error       error;
+                int             i, count;
+
+        count = size / BLKSZ;
+        
+        for (i = 0; i < count; i++) {
+                error = WaitFor(s, ">", 4);
+                if (error!=ERR_NONE) return error;
+
+                error = s->Protocol.Functions->WriteMessage(s,
+                        buff + i * BLKSZ, BLKSZ, 0x00);
+                if (error!=ERR_NONE) return error;
+        }
+
+        error = WaitFor(s, ">", 4);
+         if (error!=ERR_NONE) return error;
+        error = s->Protocol.Functions->WriteMessage(s,
+                buff + i * BLKSZ, size%BLKSZ, 0x00);
+        if (error!=ERR_NONE) return error;
+
+        error = GSM_WaitFor(s, "", 0, 0x00, 4, id);
+        if (error!=ERR_NONE) return error;
+
+        return Phone->DispatchError;
+}
+
+/* Answer format for binary data transfer
+ *
+ * SDNDCRC = 0xa : RECEIVECRC = 0xcbf53a1c : BINSIZE = 5
+ * CRCERR
+ */
+static GSM_Error ReplySetSamsungFrame(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+                unsigned long   txcrc, rxcrc;
+                int             binsize;
+                char            *pos;
+
+        /* Parse SDNDCRC */
+        pos = strchr(msg.Buffer, '=');
+        if (!pos) return ERR_UNKNOWN;
+        pos++;
+        txcrc = strtoul(pos, NULL, 0);
+        smprintf(s, "Sent CRC     : 0x%lx\n", txcrc);
+
+        /* Parse RECEIVECRC */
+        pos = strchr(pos, '=');
+        if (!pos) return ERR_UNKNOWN;
+        pos++;
+        rxcrc = strtoul(pos, NULL, 0);
+        smprintf(s, "Reveived CRC : 0x%lx\n", rxcrc);
+
+        /* Parse BINSIZE */
+        pos = strchr(pos, '=');
+        if (!pos) return ERR_UNKNOWN;
+        pos++;
+        binsize = strtoul(pos, NULL, 0);
+        smprintf(s, "Binary size  : %d\n", binsize);
+
+        return txcrc == rxcrc ? ERR_NONE : ERR_WRONGCRC;
+}
+  
+/*
+ * Bitmaps
+ */
+
+GSM_Error SAMSUNG_ReplyGetBitmap(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+                GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
+                unsigned char   buffer[32];
+                char            *pos;
+                int             location, count;
+ 
+         switch (Priv->ReplyState) {
+         case AT_Reply_OK:
+                smprintf(s, "Bitmap info received\n");
+                /* Parse +IMGR:location,name,0,0,0,0 */
+
+                /* Parse location */
+                pos = strchr(msg.Buffer, ':');
+                if (!pos) return ERR_UNKNOWN;
+                pos++;
+                location = atoi(pos);
+                smprintf(s, "Location : %d\n", location);
+
+                /* Parse name */
+                pos = strchr(pos, '"');
+                if (!pos) return ERR_UNKNOWN;
+                pos++;
+                for (count = 0; count < 31; count++) {
+                        if (pos[count] == '"')
+                                break;
+                        buffer[count] = pos[count];
+                }
+                buffer[count] = 0;
+                smprintf(s, "Name     : %s\n", buffer);
+                s->Phone.Data.Bitmap->Name = malloc((strlen(buffer) + 1) * 2);
+                if (s->Phone.Data.Bitmap->Name == NULL)
+                        return ERR_MOREMEMORY;
+                EncodeUnicode(s->Phone.Data.Bitmap->Name, buffer, strlen(buffer));
+
+                s->Phone.Data.Bitmap->Location = location;
+
+                return ERR_NONE;
+        case AT_Reply_Error:
+                return ERR_UNKNOWN;
+        case AT_Reply_CMSError:
+                return ATGEN_HandleCMSError(s);
+        case AT_Reply_CMEError:
+                return ATGEN_HandleCMEError(s);
+         default:
+                return ERR_UNKNOWNRESPONSE;
+        }
+}
+
+GSM_Error SAMSUNG_ReplySetBitmap(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+        smprintf(s, "Bitmap sent\n");
+        return ReplySetSamsungFrame(msg, s); 
+}
+
+GSM_Error SAMSUNG_GetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
+{
+        unsigned char req[100];
+
+        s->Phone.Data.Bitmap=Bitmap;
+        smprintf(s, "Getting bitmap\n");
+        sprintf(req, "AT+IMGR=%d\r", Bitmap->Location-1);
+        return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetBitmap);
+}
+
+GSM_Error SAMSUNG_SetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
+{
+                unsigned charreq[100];
+                unsigned longcrc;
+                GSM_Errorerror;
+                char    name[50], *dot, *model;
+        GSM_Phone_Data  *Data = &s->Phone.Data;
+                int     i;
+
+        s->Phone.Data.Bitmap = Bitmap;
+        smprintf(s, "Setting bitmap\n");
+
+        if (Bitmap->Type != GSM_PictureBinary) {
+                smprintf(s, "Invalid picture type\n");
+                return ERR_INVALIDDATA;
+        }
+
+        if (Bitmap->BinaryPic.Type != PICTURE_GIF) {
+                smprintf(s, "Invalid binary picture type\n");
+                return ERR_INVALIDDATA;
+        }
+
+        /* Check if picture size matches phone model */
+        model = GetModelData(NULL,Data->Model,NULL)->model;
+        smprintf(s, "Checking picture size for %s\n", model);
+        for (i = 0; modres[i].model; i++) {
+                if (!strcmp(model, modres[i].model)) {
+                        if (Bitmap->BitmapWidth != modres[i].width ||
+                            Bitmap->BitmapHeight != modres[i].height) {
+                                smprintf(s, "Model %s must use %d x %d picture size\n",
+                                        modres[i].model, modres[i].width,
+                                        modres[i].height);
+                                return ERR_INVALIDDATA;
+                        }
+                        break;
+                }
+        }
+        if (modres[i].model == NULL) {
+                smprintf(s, "Model \"%s\" is not supported.\n", Data->Model);
+                return ERR_NOTSUPPORTED;
+        }
+
+        crc = GetCRC(Bitmap->BinaryPic.Buffer, Bitmap->BinaryPic.Length);
+
+        /* Remove extension from file name */
+        strncpy(name, DecodeUnicodeString(Bitmap->Name), 50);
+        if ((dot = strrchr(name, '.')) != NULL)
+                *dot = 0;
+
+        sprintf(req, "AT+IMGW=0,\"%s\",2,0,0,0,0,100,%d,%u\r", name,
+                Bitmap->BinaryPic.Length, (unsigned int)crc);
+
+        error = s->Protocol.Functions->WriteMessage(s, req, strlen(req), 0x00);
+        if (error!=ERR_NONE) return error;
+
+        return SetSamsungFrame(s, Bitmap->BinaryPic.Buffer,
+                Bitmap->BinaryPic.Length, ID_SetBitmap);
+}
+
+/*
+ * Ringtones
+ */
+
+GSM_Error SAMSUNG_ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+                GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
+                unsigned char   buffer[32];
+                char            *pos;
+                int             location, length, count;
+ 
+         switch (Priv->ReplyState) {
+         case AT_Reply_OK:
+                smprintf(s, "Ringtone info received\n");
+                /* Parse +MELR:location,name,size */
+
+                /* Parse location */
+                pos = strchr(msg.Buffer, ':');
+                if (!pos) return ERR_UNKNOWN;
+                pos++;
+                location = atoi(pos);
+                smprintf(s, "Location : %d\n", location);
+
+                /* Parse name */
+                pos = strchr(pos, '"');
+                if (!pos) return ERR_UNKNOWN;
+                pos++;
+                /* Ringtone.Name size is 20 chars */
+                for (count = 0; count < 19; count++) {
+                        if (pos[count] == '"')
+                                break;
+                        buffer[count] = pos[count];
+                }
+                buffer[count] = 0;
+                smprintf(s, "Name     : %s\n", buffer);
+                EncodeUnicode(s->Phone.Data.Ringtone->Name,buffer,strlen(buffer));
+
+                /* Parse ringtone length */
+                pos = strchr(pos, ',');
+                if (!pos) return ERR_UNKNOWN;
+                pos++;
+                length = atoi(pos);
+                smprintf(s, "Length   : %d\n", length);
+
+                /* S300 ringtones are always MMF */
+                s->Phone.Data.Ringtone->Format = RING_MMF;
+                s->Phone.Data.Ringtone->Location = location;
+                s->Phone.Data.Ringtone->BinaryTone.Length = length;
+
+                return ERR_NONE;
+        case AT_Reply_Error:
+                return ERR_UNKNOWN;
+        case AT_Reply_CMSError:
+                return ATGEN_HandleCMSError(s);
+        case AT_Reply_CMEError:
+                return ATGEN_HandleCMEError(s);
+         default:
+                return ERR_UNKNOWNRESPONSE;
+        }
+}
+
+GSM_Error SAMSUNG_GetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone)
+{
+        unsigned char req[100];
+
+        s->Phone.Data.Ringtone = Ringtone;
+        smprintf(s, "Getting ringtone\n");
+        sprintf(req, "AT+MELR=%d\r", Ringtone->Location-1);
+        return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetRingtone);
+}
+
+GSM_Error SAMSUNG_ReplySetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+        smprintf(s, "Ringtone sent\n");
+        return ReplySetSamsungFrame(msg, s); 
+}
+  
+GSM_Error SAMSUNG_SetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength)
+{
+                unsigned charreq[100];
+                unsigned longcrc;
+                GSM_Errorerror;
+                char    name[50], *dot;
+
+        s->Phone.Data.Ringtone = Ringtone;
+        smprintf(s, "Setting ringtone\n");
+
+        if (Ringtone->Format != RING_MMF) {
+                smprintf(s, "Not MMF ringtone\n");
+                return ERR_INVALIDDATA;
+        }
+
+        /* Remove extension from file name */
+        strncpy(name, DecodeUnicodeString(Ringtone->Name), 50);
+        if ((dot = strrchr(name, '.')) != NULL) *dot = 0;
+
+        crc = GetCRC(Ringtone->BinaryTone.Buffer, Ringtone->BinaryTone.Length);
+        sprintf(req, "AT+MELW=0,\"%s\",4,%d,%u\r", name,
+                Ringtone->BinaryTone.Length, (unsigned int)crc);
+
+        error = s->Protocol.Functions->WriteMessage(s, req, strlen(req), 0x00);
+        if (error!=ERR_NONE) return error;
+
+        return SetSamsungFrame(s, Ringtone->BinaryTone.Buffer,
+                Ringtone->BinaryTone.Length, ID_SetRingtone);
+}
+
+#endif
diff --git a/gammu/emb/common/phone/at/samsung.h b/gammu/emb/common/phone/at/samsung.h
new file mode 100644
index 0000000..3b2947c
--- a/dev/null
+++ b/gammu/emb/common/phone/at/samsung.h
@@ -0,0 +1,16 @@
+#ifndef samsung_h
+#define samsung_h
+
+#include "../../gsmstate.h"
+
+        GSM_Error SAMSUNG_ReplyGetRingtone(GSM_Protocol_Message, GSM_StateMachine *);
+        GSM_Error SAMSUNG_ReplySetRingtone(GSM_Protocol_Message, GSM_StateMachine *);
+        GSM_Error SAMSUNG_ReplyGetBitmap(GSM_Protocol_Message, GSM_StateMachine *);
+        GSM_Error SAMSUNG_ReplySetBitmap(GSM_Protocol_Message, GSM_StateMachine *);
+        GSM_Error SAMSUNG_GetRingtone   (GSM_StateMachine *, GSM_Ringtone *, bool);
+        GSM_Error SAMSUNG_SetRingtone   (GSM_StateMachine *, GSM_Ringtone *, int *);
+        GSM_Error SAMSUNG_GetBitmap     (GSM_StateMachine *, GSM_Bitmap *);
+        GSM_Error SAMSUNG_SetBitmap     (GSM_StateMachine *, GSM_Bitmap *);
+        GSM_Error SAMSUNG_GetCallLogs   (GSM_StateMachine *, GSM_MemoryEntry *, int);
+
+#endif
diff --git a/gammu/emb/common/phone/at/siemens.c b/gammu/emb/common/phone/at/siemens.c
index ab7dd2c..7f66cf8 100644
--- a/gammu/emb/common/phone/at/siemens.c
+++ b/gammu/emb/common/phone/at/siemens.c
@@ -1,320 +1,316 @@
 /* (c) 2002-2003 by Walek */
                                            
 #include "../../gsmstate.h"
 
 #ifdef GSM_ENABLE_ATGEN
 
 #include <string.h>
 #include <time.h>
 #include <ctype.h>
 
 #include "../../misc/coding/coding.h"
 #include "../../gsmcomon.h"
 #include "../../service/sms/gsmsms.h"
 #include "../pfunc.h"
 
-extern GSM_Error ATGEN_HandleCMSError(GSM_StateMachine *s);
+#include "atgen.h"
+#include "siemens.h"
 
-GSM_Error ATGEN_CMS35ReplySetFunction (GSM_Protocol_Message msg, GSM_StateMachine *s,char *function)
-{
-        if (s->Protocol.Data.AT.EditMode) {
-            s->Protocol.Data.AT.EditMode = false;
-            return ERR_NONE;
-        }
-        dbgprintf ("Written %s",function);
-          if (s->Phone.Data.Priv.ATGEN.ReplyState == AT_Reply_OK){
-                dbgprintf (" - OK\n");
-                return ERR_NONE;
-        } else {
-                dbgprintf (" - error\n");
-                return ERR_UNKNOWN;
-        }
-}
 
-GSM_Error GetSiemensFrame(GSM_Protocol_Message msg, GSM_StateMachine *s, char *templ,
+static GSM_Error GetSiemensFrame(GSM_Protocol_Message msg, GSM_StateMachine *s, char *templ,
                             unsigned char *buffer, int *len)
 {
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 int             i=2, pos=0, length=0;
                 unsigned char   buf[512];
 
         if (strstr(GetLineString(msg.Buffer,Priv->Lines,2),"OK")) return ERR_EMPTY;
         if (!strstr(GetLineString(msg.Buffer,Priv->Lines,2),templ)) return ERR_UNKNOWN;
 
         while (1) {
                 if (Priv->Lines.numbers[i*2+1]==0) break;
                 if ((!strstr(GetLineString(msg.Buffer,Priv->Lines,i+1),templ)) && 
                     (strstr(GetLineString(msg.Buffer,Priv->Lines,i),templ))){
                         length = strlen(GetLineString(msg.Buffer,Priv->Lines,i+1));
                         DecodeHexBin(buf, GetLineString(msg.Buffer,Priv->Lines,i+1),length);
                         length = length/2;
                         memcpy (buffer+pos,buf,length);
                         pos+=length;
                 } 
                 i++;
         }
         *len = pos;
                return ERR_NONE;
 }
 
-GSM_Error SetSiemensFrame (GSM_StateMachine *s, unsigned char *buff, char *templ,
+static GSM_Error SetSiemensFrame (GSM_StateMachine *s, unsigned char *buff, char *templ,
                             int Location, GSM_Phone_RequestID RequestID, int len)
 {
                 GSM_Phone_Data  *Phone = &s->Phone.Data;
                 GSM_Error       error;
                 unsigned char   req[20],req1[512],hexreq[2096];
                 int             MaxFrame,CurrentFrame,size,sz,pos=0;
 
         EncodeHexBin(hexreq,buff,len);
                 size = len * 2;
         MaxFrame = size / 352;
         if (size % 352) MaxFrame++;
 
         for (CurrentFrame=0;CurrentFrame<MaxFrame;CurrentFrame++) {
                 pos=CurrentFrame*352;
                  if (pos+352 < size) sz = 352; else sz = size - pos;
                 sprintf(req, "AT^SBNW=\"%s\",%i,%i,%i\r",templ,Location,CurrentFrame+1,MaxFrame);
                 s->Protocol.Data.AT.EditMode = true;
                 error = GSM_WaitFor (s, req, strlen(req), 0x00, 3, RequestID);
                 s->Phone.Data.DispatchError=ERR_TIMEOUT;
                 s->Phone.Data.RequestID=RequestID;
                      if (error!=ERR_NONE) return error;
                  memcpy (req1,hexreq+pos,sz);
                  error = s->Protocol.Functions->WriteMessage(s, req1, sz, 0x00);
                  if (error!=ERR_NONE) return error;
                 error = s->Protocol.Functions->WriteMessage(s,"\x1A", 1, 0x00);
                  if (error!=ERR_NONE) return error;
                 error = GSM_WaitForOnce(s, NULL, 0x00, 0x00, 4);
                  if (error == ERR_TIMEOUT) return error;
          }
          return Phone->DispatchError;
 }
 
-GSM_Error ATGEN_CMS35ReplyGetBitmap(GSM_Protocol_Message msg, GSM_StateMachine *s)
+GSM_Error SIEMENS_ReplyGetBitmap(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 unsigned char   buffer[4096];
                 int             length;
                 GSM_Error       error;
         
         error = GetSiemensFrame(msg,s,"bmp",buffer,&length);
         if (error!=ERR_NONE) return error;
         dbgprintf ("Operator logo received lenght=%i\n",length);
         error = BMP2Bitmap (buffer,NULL,s->Phone.Data.Bitmap);
         if (error==ERR_NONE) return error;
         else return ERR_UNKNOWN;
 }
 
-GSM_Error ATGEN_CMS35ReplySetBitmap(GSM_Protocol_Message msg, GSM_StateMachine *s)
+GSM_Error SIEMENS_ReplySetFunction (GSM_Protocol_Message msg, GSM_StateMachine *s,char *function)
 {
-            return ATGEN_CMS35ReplySetFunction (msg, s, "Operator Logo");

+        if (s->Protocol.Data.AT.EditMode) {
+            s->Protocol.Data.AT.EditMode = false;
+            return ERR_NONE;
+        }
+        dbgprintf ("Written %s",function);
+          if (s->Phone.Data.Priv.ATGEN.ReplyState == AT_Reply_OK){
+                dbgprintf (" - OK\n");
+                return ERR_NONE;
+        } else {
+                dbgprintf (" - error\n");
+                return ERR_UNKNOWN;
+        }
 }
 
-GSM_Error ATGEN_GetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
+GSM_Error SIEMENS_ReplySetBitmap(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+            return SIEMENS_ReplySetFunction (msg, s, "Operator Logo");

+}
+
+GSM_Error SIEMENS_GetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
 {
         unsigned char req[32];
 
-        if (s->Phone.Data.Priv.ATGEN.Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
         if (Bitmap->Type!=GSM_OperatorLogo) return ERR_NOTSUPPORTED;
         if (Bitmap->Location-1 < 0) Bitmap->Location++;
         s->Phone.Data.Bitmap=Bitmap;
         sprintf(req, "AT^SBNR=\"bmp\",%i\r", Bitmap->Location-1);
         smprintf(s, "Getting Bitmap\n");
         return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetBitmap);
 }
 
-GSM_Error ATGEN_SetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
+GSM_Error SIEMENS_SetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
 {
                 unsigned char buffer[4096];
                 int     length;
                 GSM_Errorerror;
         
-        if (s->Phone.Data.Priv.ATGEN.Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
         if (Bitmap->Type!=GSM_OperatorLogo) return ERR_NOTSUPPORTED;
 
         error = Bitmap2BMP (buffer,NULL,Bitmap);
         if (error!=ERR_NONE) return error;
         length = 0x100 * buffer[3] + buffer[2];
         buffer[58]=0xff; buffer[59]=0xff; buffer[60]=0xff;
         if (Bitmap->Location-1 < 0) Bitmap->Location++;
         s->Phone.Data.Bitmap=Bitmap;
         return SetSiemensFrame(s, buffer,"bmp",Bitmap->Location-1,
                                 ID_SetBitmap,length);
 }
 
-GSM_Error ATGEN_CMS35ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
+GSM_Error SIEMENS_ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 unsigned char   buffer[32];
                 int             length;
                 GSM_Error       error;
 
         error = GetSiemensFrame(msg,s,"mid",s->Phone.Data.Ringtone->NokiaBinary.Frame,&length);
         if (error!=ERR_NONE) return error;
         dbgprintf ("Midi ringtone received\n");
         
                 s->Phone.Data.Ringtone->Format          = RING_MIDI;
                 s->Phone.Data.Ringtone->NokiaBinary.Length= length;
         sprintf(buffer,"Individual");
         EncodeUnicode (s->Phone.Data.Ringtone->Name,buffer,strlen(buffer));
         return ERR_NONE;
 }
 
-GSM_Error ATGEN_GetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone)
+GSM_Error SIEMENS_GetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone)
 {
         unsigned char req[32];
 
-        if (s->Phone.Data.Priv.ATGEN.Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
-        
         s->Phone.Data.Ringtone=Ringtone;
         sprintf(req, "AT^SBNR=\"mid\",%i\r", Ringtone->Location-1);
         smprintf(s, "Getting RingTone\n");
         return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetRingtone);
 }
 
-GSM_Error ATGEN_CMS35ReplySetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
+GSM_Error SIEMENS_ReplySetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
-        return ATGEN_CMS35ReplySetFunction (msg, s, "Ringtone");
+        return SIEMENS_ReplySetFunction (msg, s, "Ringtone");
 }
   
-GSM_Error ATGEN_SetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength)
+GSM_Error SIEMENS_SetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength)
 {
         GSM_Phone_Data *Phone = &s->Phone.Data;
          
-        if (s->Phone.Data.Priv.ATGEN.Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
-
         if (Ringtone->Location==255) Ringtone->Location=1; 
         if (Ringtone->Location-1 > 1) return ERR_INVALIDLOCATION;
 
                 s->Phone.Data.Ringtone= Ringtone;
                 Phone->Ringtone         = Ringtone;
         return SetSiemensFrame(s, Ringtone->NokiaBinary.Frame,"mid",Ringtone->Location-1,
                                 ID_SetRingtone,Ringtone->NokiaBinary.Length);
 }
 
-GSM_Error ATGEN_CMS35ReplyGetNextCal(GSM_Protocol_Message msg, GSM_StateMachine *s)
+GSM_Error SIEMENS_ReplyGetNextCalendar(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_Data  *Data = &s->Phone.Data;
                 GSM_CalendarEntry*Calendar = Data->Cal;
                 GSM_ToDoEntry   ToDo;
                 GSM_Error       error;
                 unsigned char   buffer[354];
                 int             len, pos=0;
 
         if (Data->Priv.ATGEN.ReplyState != AT_Reply_OK) return ERR_UNKNOWN;
 
         error = GetSiemensFrame(msg,s,"vcs",buffer,&len);
         if (error!=ERR_NONE) return error;
         error=GSM_DecodeVCALENDAR_VTODO(buffer,&pos,Calendar,&ToDo,Siemens_VCalendar,0);
         
          return error;
 }
 
 GSM_Error SIEMENS_GetNextCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start)
 {
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_Error       error;
                 unsigned char   req[32];
                 int             Location;
 
         if (Priv->Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
         
         if (start) Note->Location=Priv->FirstCalendarPos;
                 s->Phone.Data.Cal = Note;
                 Note->EntriesNum = 0;
         smprintf(s, "Getting VCALENDAR\n");
         Location = Note->Location;
         while (1){
                 Location++;
                 sprintf(req, "AT^SBNR=\"vcs\",%i\r",Location);  
                 error = GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_GetCalendarNote);
                 if ((error!=ERR_NONE) && (error!=ERR_EMPTY)) return ERR_INVALIDLOCATION;
                         Note->Location          = Location;
                         Priv->FirstCalendarPos = Location;
                 if (Location > MAX_VCALENDAR_LOCATION) return ERR_EMPTY;
                 if (error==ERR_NONE) return error;
         }
         return error;
 }
 
-GSM_Error ATGEN_CMS35ReplySetCalendar(GSM_Protocol_Message msg, GSM_StateMachine *s)
+GSM_Error SIEMENS_ReplyAddCalendarNote(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
-    return ATGEN_CMS35ReplySetFunction (msg, s, "Calendar Note");
+    return SIEMENS_ReplySetFunction (msg, s, "Calendar Note");
 }
 
-GSM_Error ATGEN_CMS35ReplyDeleteCalendar(GSM_Protocol_Message msg, GSM_StateMachine *s)
+GSM_Error SIEMENS_ReplyDelCalendarNote(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
         
         if (Data->Cal->Location > MAX_VCALENDAR_LOCATION) return ERR_UNKNOWN;
         
         if (Data->Priv.ATGEN.ReplyState== AT_Reply_OK) {
                 smprintf(s, "Calendar note deleted\n");
                 return ERR_NONE;
         } else {
                 smprintf(s, "Can't delete calendar note\n");
                 return ERR_UNKNOWN;
         }
 }
 
 GSM_Error SIEMENS_DelCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
         unsigned char req[32];
 
         if (s->Phone.Data.Priv.ATGEN.Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
         s->Phone.Data.Cal = Note;
         sprintf(req, "AT^SBNW=\"vcs\",%i,0\r",Note->Location);
         smprintf(s, "Deleting calendar note\n");
         return GSM_WaitFor (s, req, strlen(req), 0x00, 4, ID_DeleteCalendarNote);
 }
 
 GSM_Error SIEMENS_AddCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_Error       error;
                 unsigned char   req[500];
                 int             size=0;
 
         if (Priv->Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
         //      if (Note->Location==0x00) return ERR_INVALIDLOCATION;
 
         s->Phone.Data.Cal = Note;
         error=GSM_EncodeVCALENDAR(req,&size,Note,true,Siemens_VCalendar);
                 
         return SetSiemensFrame (s,req,"vcs",Note->Location,ID_SetCalendarNote,size);
 }
 
 /* (c) by Timo Teras */
-GSM_Error ATGEN_SL45ReplyGetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
+GSM_Error SIEMENS_ReplyGetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
 #ifndef ENABLE_LGPL
                 GSM_Phone_ATGENData *Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_MemoryEntry         *Memory = s->Phone.Data.Memory;
                 unsigned char   buffer[500],buffer2[500];
 
         switch (Priv->ReplyState) {
         case AT_Reply_OK:
                 smprintf(s, "Phonebook entry received\n");
                 CopyLineString(buffer, msg.Buffer, Priv->Lines, 3);
                 DecodeHexBin(buffer2,buffer,strlen(buffer));
                 Memory->EntriesNum = 0;
                 DecodeVCARD21Text(buffer2, Memory);
                 if (Memory->EntriesNum == 0) return ERR_EMPTY;
                 return ERR_NONE;
         case AT_Reply_Error:
                 smprintf(s, "Error - too high location ?\n");
                 return ERR_INVALIDLOCATION;
         case AT_Reply_CMSError:
                  return ATGEN_HandleCMSError(s);
         default:
                 break;
         }
         return ERR_UNKNOWNRESPONSE;
 #else
         return ERR_NOTIMPLEMENTED;
 #endif
 }
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/at/sonyeric.c b/gammu/emb/common/phone/at/sonyeric.c
index 4b2670a..8eeb39b 100644
--- a/gammu/emb/common/phone/at/sonyeric.c
+++ b/gammu/emb/common/phone/at/sonyeric.c
@@ -1,411 +1,520 @@
 /* (c) 2003 by Marcin Wiacek */
                                            
 #include "../../gsmstate.h"
 
 #ifdef GSM_ENABLE_ATGEN
 
 #include <string.h>
 #include <time.h>
 #include <ctype.h>
 
 #include "../../gsmcomon.h"
 #include "../../misc/coding/coding.h"
 
-        extern GSM_Reply_Function       ATGENReplyFunctions[];
-        extern GSM_Error ATGEN_DispatchMessage(GSM_StateMachine *s);
+#include "atgen.h"
+#include "sonyeric.h"
 
 #ifdef GSM_ENABLE_OBEXGEN
 
-        extern GSM_Reply_Function       OBEXGENReplyFunctions[];
-        extern GSM_Error OBEXGEN_GetFilePart(GSM_StateMachine *s, GSM_File *File);
-        extern GSM_Error OBEXGEN_AddFilePart(GSM_StateMachine *s, GSM_File *File, int *Pos);
-        extern GSM_Error OBEXGEN_Disconnect(GSM_StateMachine *s);
+#include "../obex/obexgen.h"
 
-#if defined(GSM_ENABLE_BLUEOBEX) || defined(GSM_ENABLE_IRDAOBEX)
+        extern GSM_Reply_FunctionOBEXGENReplyFunctions[];
+        extern GSM_Reply_FunctionATGENReplyFunctions[];
 
 static GSM_Error SONYERIC_SetOBEXMode(GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_Error       error;
 
         if (Priv->OBEX) return ERR_NONE;
 
         dbgprintf ("Changing to OBEX\n");
 
         error=GSM_WaitFor (s, "AT*EOBEX\r", 9, 0x00, 4, ID_SetOBEX);
         if (error != ERR_NONE) return error;
 
         error = s->Protocol.Functions->Terminate(s);
         if (error != ERR_NONE) return error;
 
         s->Protocol.Functions = &OBEXProtocol;
         error = s->Protocol.Functions->Initialise(s);
         if (error != ERR_NONE) {
                 s->Protocol.Functions = &ATProtocol;
                 return error;
         }
         strcpy(s->CurrentConfig->Model,"seobex");
                 s->Phone.Data.Priv.OBEXGEN.Service = 0;
                 s->Phone.Functions->DispatchMessage= GSM_DispatchMessage;
                 s->Phone.Functions->ReplyFunctions= OBEXGENReplyFunctions;
                 Priv->OBEX                      = true;
         return ERR_NONE;
 }
 
 static GSM_Error SONYERIC_SetATMode(GSM_StateMachine *s)
 {
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 GSM_Error       error;
 
         if (!Priv->OBEX) return ERR_NONE;
 
         dbgprintf ("Changing to AT\n");
 
         error = OBEXGEN_Disconnect(s);
         if (error != ERR_NONE) return error;
 
         error = s->Protocol.Functions->Terminate(s);
         if (error != ERR_NONE) return error;
 
         s->Protocol.Functions = &ATProtocol;
         error = s->Protocol.Functions->Initialise(s);
         if (error != ERR_NONE) {
                 s->Protocol.Functions = &OBEXProtocol;
                 return error;
         }
         strcpy(s->CurrentConfig->Model,"at");
                 s->Phone.Functions->DispatchMessage= ATGEN_DispatchMessage;
                 s->Phone.Functions->ReplyFunctions= ATGENReplyFunctions;
                 Priv->OBEX                      = false;
         return ERR_NONE;
 }
 
 static GSM_Error SONYERIC_GetFile(GSM_StateMachine *s, GSM_File *File, unsigned char *FileName)
 {
         GSM_Error error;
 
         strcpy(File->ID_FullName,FileName);
                 File->Used = 0;
         if (File->Buffer != NULL) free(File->Buffer);
                 File->Buffer = NULL;
 
         error = SONYERIC_SetOBEXMode(s);
         if (error != ERR_NONE) return error;
 
         error = ERR_NONE;
         while (error == ERR_NONE) error = OBEXGEN_GetFilePart(s,File);
         if (error != ERR_EMPTY) return error;
 
         return SONYERIC_SetATMode(s);
 }
 
 static GSM_Error SONYERIC_SetFile(GSM_StateMachine *s, unsigned char *FileName, unsigned char *Buffer, int Length)
 {
                 GSM_Errorerror;
                 GSM_File File;
                 int     Pos = 0;
 
         error = SONYERIC_SetOBEXMode(s);
         if (error != ERR_NONE) return error;
 
         strcpy(File.ID_FullName,FileName);
         EncodeUnicode(File.Name,FileName,strlen(FileName));
                 File.Used = Length;
                 File.Buffer = malloc(Length);
         memcpy(File.Buffer,Buffer,Length);
 
         error = ERR_NONE;
         while (error == ERR_NONE) error = OBEXGEN_AddFilePart(s,&File,&Pos);
         free(File.Buffer);
         if (error != ERR_EMPTY) return error;
 
         return SONYERIC_SetATMode(s);
 }
 
 #endif
 
 GSM_Error SONYERIC_GetNextCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start)
 {
-#if defined(GSM_ENABLE_BLUEOBEX) || defined(GSM_ENABLE_IRDAOBEX)
+#ifdef GSM_ENABLE_OBEXGEN
                 GSM_Error       error;
                 GSM_ToDoEntry   ToDo;
                 int             Pos, num, Loc;
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
 
         if (start) {
                 error = SONYERIC_GetFile(s, &Priv->file, "telecom/cal.vcs");
                 if (error != ERR_NONE) return error;
 
                 Note->Location = 1;
         } else {
                 Note->Location++;
         }
         smprintf(s, "Getting calendar note %i\n",Note->Location);
 
         Loc = Note->Location;
         Pos = 0;
         num = 0;
         while (1) {
                 error = GSM_DecodeVCALENDAR_VTODO(Priv->file.Buffer, &Pos, Note, &ToDo, SonyEricsson_VCalendar, SonyEricsson_VToDo);
                 if (error == ERR_EMPTY) break;
                 if (error != ERR_NONE) return error;
                         if (Note->EntriesNum != 0) {            
                         num++;
                         if (num == Loc) return ERR_NONE;
                 }
         }
         return ERR_EMPTY;
 #else
         return ERR_SOURCENOTAVAILABLE;
 #endif
 }
 
 GSM_Error SONYERIC_GetNextToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo, bool start)
 {
-#if defined(GSM_ENABLE_BLUEOBEX) || defined(GSM_ENABLE_IRDAOBEX)
+#ifdef GSM_ENABLE_OBEXGEN
                 GSM_Error       error;
                 GSM_CalendarEntryCalendar;
                 int             Pos, num, Loc;
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
 
         if (Priv->Manufacturer!=AT_Ericsson) return ERR_NOTSUPPORTED;
 
         if (start) {
                 error = SONYERIC_GetFile(s, &Priv->file, "telecom/cal.vcs");
                 if (error != ERR_NONE) return error;
 
                 ToDo->Location = 1;
         } else {
                 ToDo->Location++;
         }
         smprintf(s,"Getting ToDo %i\n",ToDo->Location);
 
                 Loc = ToDo->Location;
         Pos = 0;
         num = 0;
         while (1) {
                 error = GSM_DecodeVCALENDAR_VTODO(Priv->file.Buffer, &Pos, &Calendar, ToDo, SonyEricsson_VCalendar, SonyEricsson_VToDo);
                 if (error == ERR_EMPTY) break;
                 if (error != ERR_NONE) return error;
                         if (ToDo->EntriesNum != 0) {            
                         num++;
                         if (num == Loc) return ERR_NONE;
                 }
         }
 
         return ERR_EMPTY;
 #else
         return ERR_SOURCENOTAVAILABLE;
 #endif
 }
 
 GSM_Error SONYERIC_GetToDoStatus(GSM_StateMachine *s, GSM_ToDoStatus *status)
 {
-#if defined(GSM_ENABLE_BLUEOBEX) || defined(GSM_ENABLE_IRDAOBEX)
+#ifdef GSM_ENABLE_OBEXGEN
                 GSM_Error       error;
                 GSM_ToDoEntry   ToDo;
                 GSM_CalendarEntry Calendar;
                 int             Pos;
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
 
         if (Priv->Manufacturer!=AT_Ericsson) return ERR_NOTSUPPORTED;
 
         smprintf(s,"Getting ToDo status\n");
 
         error = SONYERIC_GetFile(s, &Priv->file, "telecom/cal.vcs");
         if (error != ERR_NONE) return error;
 
                 status->Used = 0;
                 Pos     = 0;
         while (1) {
                 error = GSM_DecodeVCALENDAR_VTODO(Priv->file.Buffer, &Pos, &Calendar, &ToDo, SonyEricsson_VCalendar, SonyEricsson_VToDo);
                 if (error == ERR_EMPTY) break;
                 if (error != ERR_NONE) return error;
                 if (ToDo.EntriesNum != 0) status->Used++;
         }
         
         return ERR_NONE;
 #else
         return ERR_SOURCENOTAVAILABLE;
 #endif
 }
 
 GSM_Error SONYERIC_AddCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
-#if defined(GSM_ENABLE_BLUEOBEX) || defined(GSM_ENABLE_IRDAOBEX)
+#ifdef GSM_ENABLE_OBEXGEN
                 unsigned char   req[5000];
                 int             size=0;
 
         smprintf(s,"Adding calendar note\n");
 
         GSM_EncodeVCALENDAR(req,&size,Note,true,SonyEricsson_VCalendar);
 
         return SONYERIC_SetFile(s, "telecom/cal/luid/.vcs", req, size);
 #else
         return ERR_SOURCENOTAVAILABLE;
 #endif
 }
 
 GSM_Error SONYERIC_AddToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
 {
-#if defined(GSM_ENABLE_BLUEOBEX) || defined(GSM_ENABLE_IRDAOBEX)
+#ifdef GSM_ENABLE_OBEXGEN
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 unsigned char   req[5000];
                 int             size=0;
 
         if (Priv->Manufacturer!=AT_Ericsson) return ERR_NOTSUPPORTED;
 
         smprintf(s,"Adding ToDo\n");
 
         GSM_EncodeVTODO(req,&size,ToDo,true,SonyEricsson_VToDo);
 
         return SONYERIC_SetFile(s, "telecom/cal/luid/.vcs", req, size);
 #else
         return ERR_SOURCENOTAVAILABLE;
 #endif
 }
 
 GSM_Error SONYERIC_DeleteAllToDo(GSM_StateMachine *s)
 {
-#if defined(GSM_ENABLE_BLUEOBEX) || defined(GSM_ENABLE_IRDAOBEX)
+#ifdef GSM_ENABLE_OBEXGEN
                 GSM_Error       error;
                 int             Pos,Level = 0,Used;
                 unsigned char   *Buf;
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 unsigned char   Line[2000];
 
         if (Priv->Manufacturer!=AT_Ericsson) return ERR_NOTSUPPORTED;
 
         smprintf(s,"Deleting all ToDo\n");
 
         error = SONYERIC_GetFile(s, &Priv->file, "telecom/cal.vcs");
         if (error != ERR_NONE) return error;
 
         Pos  = 0;
         Buf  = NULL;
         Used = 0;
         while (1) {
                 MyGetLine(Priv->file.Buffer, &Pos, Line, Priv->file.Used);
                 if (strlen(Line) == 0) break;
                 dbgprintf("Line is %s,%i,%i\n",Line,Priv->file.Used,Pos);
                 switch (Level) {
                 case 0:
                         if (strstr(Line,"BEGIN:VTODO")) {
                                 Level = 2;
                                 break;
                         }
                         Buf=(unsigned char *)realloc(Buf,Used+strlen(Line)+3);
                         strcpy(Buf+Used,Line);
                         Used=Used+strlen(Line)+3;
                         Buf[Used-3] = 13;
                         Buf[Used-2] = 10;
                         Buf[Used-1] = 0x00;
                         break;
                 case 2: /* ToDo note */
                         if (strstr(Line,"END:VTODO")) {
                                 Level = 0;
                         }
                         break;
                 }
         }
 
         error = SONYERIC_SetFile(s, "telecom/cal.vcs", Buf, Used);
         //if (Buf != NULL) free(Buf);
         return error;
 #else
         return ERR_SOURCENOTAVAILABLE;
 #endif
 }
 
 GSM_Error SONYERIC_DelCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
-#if defined(GSM_ENABLE_BLUEOBEX) || defined(GSM_ENABLE_IRDAOBEX)
+#ifdef GSM_ENABLE_OBEXGEN
                 GSM_Error       error;
                 int             Pos,Level = 0,Loc=0,Used;
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                 unsigned char   Line[2000];
                 unsigned char   *Buf;
 
         smprintf(s, "Deleting calendar note %i\n",Note->Location);
 
         error = SONYERIC_GetFile(s, &Priv->file, "telecom/cal.vcs");
         if (error != ERR_NONE) return error;
 
         Pos  = 0;
         Buf  = NULL;
         Used = 0;
         while (1) {
                 MyGetLine(Priv->file.Buffer, &Pos, Line, Priv->file.Used);
                 if (strlen(Line) == 0) break;
                 dbgprintf("Line is %s,%i,%i\n",Line,Priv->file.Used,Pos);
                 switch (Level) {
                 case 0:
                         if (strstr(Line,"BEGIN:VEVENT")) {
                                 Loc++;
                                 if (Loc == Note->Location) {
                                         Level = 1;
                                         break;
                                 }
                         }
                         Buf=(unsigned char *)realloc(Buf,Used+strlen(Line)+3);
                         strcpy(Buf+Used,Line);
                         Used=Used+strlen(Line)+3;
                         Buf[Used-3] = 13;
                         Buf[Used-2] = 10;
                         Buf[Used-1] = 0x00;
                         break;
                 case 1: /* Calendar note */
                         if (strstr(Line,"END:VEVENT")) {
                                 Level = 0;
                         }
                         break;
                 }
         }
 
         DumpMessage(s->di.df, s->di.dl, Buf, Used);
 
         error = SONYERIC_SetFile(s, "telecom/cal.vcs", Buf, Used);
         if (Buf != NULL) free(Buf);
         return error;
 #else
         return ERR_SOURCENOTAVAILABLE;
 #endif
 }
 
 GSM_Error SONYERIC_GetCalendarStatus(GSM_StateMachine *s, GSM_CalendarStatus *Status)
 {
-#if defined(GSM_ENABLE_BLUEOBEX) || defined(GSM_ENABLE_IRDAOBEX)
+#ifdef GSM_ENABLE_OBEXGEN
                 GSM_Error       error;
                 GSM_ToDoEntry   ToDo;
                 GSM_CalendarEntry Calendar;
                 int             Pos;
                 GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
 
         if (Priv->Manufacturer!=AT_Ericsson) return ERR_NOTSUPPORTED;
 
         smprintf(s, "Getting calendar status\n");
 
         error = SONYERIC_GetFile(s, &Priv->file, "telecom/cal.vcs");
         if (error != ERR_NONE) return error;
 
                 Status->Used = 0;
                 Pos     = 0;
         while (1) {
                 error = GSM_DecodeVCALENDAR_VTODO(Priv->file.Buffer, &Pos, &Calendar, &ToDo, SonyEricsson_VCalendar, SonyEricsson_VToDo);
                 if (error == ERR_EMPTY) break;
                 if (error != ERR_NONE) return error;
                 if (Calendar.EntriesNum != 0) Status->Used++;
         }
         
         return ERR_NONE;
 #else
         return ERR_SOURCENOTAVAILABLE;
 #endif
 }
 
-#endif
+GSM_Error ERICSSON_ReplyGetDateLocale(GSM_Protocol_Message msg, GSM_StateMachine *s)
+        { /*Author: Peter Ondraska, based on code by Marcin Wiacek and Michal Cihar
+        License: Whatever the current maintainer of gammulib chooses, as long as there
+        is an easy way to obtain the source under GPL, otherwise the author's parts
+        of this function are GPL 2.0.
+  */
+                GSM_Locale*locale = s->Phone.Data.Locale;
+                char    format;
+
+        switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
+        case AT_Reply_OK:
+                smprintf(s, "Date settings received\n");
+                format=atoi(msg.Buffer);
+                switch (format) {
+                                case 0: locale->DateFormat = GSM_Date_OFF;
+                                        locale->DateSeparator = 0;
+                                break;
+                                case 1: locale->DateFormat = GSM_Date_DDMMMYY;
+                                        locale->DateSeparator = '-';
+                                break;
+                                case 2: locale->DateFormat = GSM_Date_DDMMYY;
+                                        locale->DateSeparator = '-';
+                                break;
+                                case 3: locale->DateFormat = GSM_Date_MMDDYY;
+                                        locale->DateSeparator = '/';
+                                break;
+                                case 4: locale->DateFormat = GSM_Date_DDMMYY;
+                                        locale->DateSeparator = '/';
+                                break;
+                                case 5: locale->DateFormat = GSM_Date_DDMMYY;
+                                        locale->DateSeparator = '.';
+                                break;
+                                case 6: locale->DateFormat = GSM_Date_YYMMDD;
+                                        locale->DateSeparator = 0;
+                                break;
+                                case 7: locale->DateFormat = GSM_Date_YYMMDD;
+                                        locale->DateSeparator = '-';
+                                break;
+                        default:return ERR_UNKNOWNRESPONSE;
+                }
+        default: 
+                return ERR_NOTSUPPORTED;
+        }
+}
+
+GSM_Error ERICSSON_ReplyGetTimeLocale(GSM_Protocol_Message msg, GSM_StateMachine *s)
+        { /*Author: Peter Ondraska
+        License: Whatever the current maintainer of gammulib chooses, as long as there
+        is an easy way to obtain the source under GPL, otherwise the author's parts
+        of this function are GPL 2.0.
+  */
+        char format;
+
+        switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
+        case AT_Reply_OK:
+                smprintf(s, "Time settings received\n");
+                format=atoi(msg.Buffer);
+                switch (format) {
+                case 1:
+                case 2: s->Phone.Data.Locale->AMPMTime=(format==2);
+                        return ERR_NONE;
+                default:return ERR_UNKNOWNRESPONSE;
+                }
+        default: return ERR_NOTSUPPORTED;
+        }
+}
+
+GSM_Error ERICSSON_GetLocale(GSM_StateMachine *s, GSM_Locale *locale)
+{
+        GSM_Error error;
+
+        s->Phone.Data.Locale = locale;
+
+        smprintf(s, "Getting date format\n");
+        error=GSM_WaitFor (s, "AT+ESDF?\r", 9, 0x00, 3, ID_GetLocale);
+        if (error!=ERR_NONE) return error;
+
+        smprintf(s, "Getting time format\n");
+        return GSM_WaitFor (s, "AT+ESTF?\r", 9, 0x00, 3, ID_GetLocale);
+}
+
+
+GSM_Error ERICSSON_SetLocale(GSM_StateMachine *s, GSM_Locale *locale)
+        { /*Author: Peter Ondraska
+        License: Whatever the current maintainer of gammulib chooses, as long as there
+        is an easy way to obtain the source under GPL, otherwise the author's parts
+        of this function are GPL 2.0.
+  */
+        /* this is not yet supported by gammu.c */
+                intformat=0;
+                charreq[12];
+
+        if (locale->DateFormat==GSM_Date_OFF) { format=0; } else
+        if ((locale->DateFormat==GSM_Date_DDMMMYY)&&(locale->DateSeparator=='-')) { format=1; } else
+        if ((locale->DateFormat==GSM_Date_DDMMYY)&&(locale->DateSeparator=='-')) { format=2; } else
+        if ((locale->DateFormat==GSM_Date_MMDDYY)&&(locale->DateSeparator=='/')) { format=3; } else
+        if ((locale->DateFormat==GSM_Date_DDMMYY)&&(locale->DateSeparator=='/')) { format=4; } else
+        if ((locale->DateFormat==GSM_Date_DDMMYY)&&(locale->DateSeparator=='.')) { format=5; } else
+        if ((locale->DateFormat==GSM_Date_YYMMDD)&&(locale->DateSeparator==0)) { format=6; } else
+        if ((locale->DateFormat==GSM_Date_YYMMDD)&&(locale->DateSeparator=='-')) { format=7; }
+        else { return ERR_NOTSUPPORTED; } /* ERR_WRONGINPUT */
+
+        sprintf(req,"AT+ESDF=%i\r",format);
+        smprintf(s, "Setting date format\n");
+        return GSM_WaitFor (s, req, strlen(req), 0x00, 3, ID_SetLocale);
+
+        if (locale->AMPMTime) { format=2; } else { format=1; }
+        sprintf(req,"AT+ESTF=%i\r",format);
+        smprintf(s, "Setting time format\n");
+        return GSM_WaitFor (s, req, strlen(req), 0x00, 3, ID_SetLocale);
+}
+
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/dct3/dct3func.c b/gammu/emb/common/phone/nokia/dct3/dct3func.c
index beef33c..17cd0a4 100644
--- a/gammu/emb/common/phone/nokia/dct3/dct3func.c
+++ b/gammu/emb/common/phone/nokia/dct3/dct3func.c
@@ -1,99 +1,102 @@
 /* (c) 2001-2004 by Marcin Wiacek */
-/* based on some work from Markus Plail, Pavel Janik, others and Gnokii */
 /* resetting DCT4 phones settings (c) by Walek */
+/* based on some Markus Plail, Pavel Janik & others work from Gnokii (www.gnokii.org)
+ * (C) 1999-2000 Hugh Blemings & Pavel Janik ml. (C) 2001-2004 Pawel Kot 
+ * GNU GPL version 2 or later
+ */
 
 #include <string.h> /* memcpy only */
 #include <stdio.h>
 #include <ctype.h>
 
 #include "../../../gsmstate.h"
 #include "../../../misc/coding/coding.h"
 #include "../../../service/sms/gsmsms.h"
 #include "../../pfunc.h"
 #include "../nfunc.h"
 #include "dct3func.h"
 
 #ifdef GSM_ENABLE_NOKIA_DCT3
 
 GSM_Error DCT3_DeleteWAPBookmark(GSM_StateMachine *s, GSM_WAPBookmark *bookmark)
 {
         GSM_Error error;
 
         /* We have to enable WAP frames in phone */
         error=DCT3DCT4_EnableWAPFunctions(s);
         if (error!=ERR_NONE) return error;
 
         return DCT3DCT4_DeleteWAPBookmarkPart(s,bookmark);
 }
 
 GSM_Error DCT3_GetWAPBookmark(GSM_StateMachine *s, GSM_WAPBookmark *bookmark)
 {
         GSM_Error error;
 
         /* We have to enable WAP frames in phone */
         error=DCT3DCT4_EnableWAPFunctions(s);
         if (error!=ERR_NONE) return error;
 
         return DCT3DCT4_GetWAPBookmarkPart(s,bookmark);
 }
 
 GSM_Error DCT3_ReplyPressKey(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
 
         switch (msg.Buffer[2]) {
         case 0x46:
                 smprintf(s, "Pressing key OK\n");
                 if (Data->PressKey) return ERR_NONE;
                 break;
         case 0x47:
                 smprintf(s, "Releasing key OK\n");
                 if (!Data->PressKey) return ERR_NONE;
                 break;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error DCT3_PressKey(GSM_StateMachine *s, GSM_KeyCode Key, bool Press)
 {
         unsigned char PressReq[]   = {0x00, 0x01, 0x46, 0x00, 0x01,
                                               0x0a};    /* Key code */
         unsigned char ReleaseReq[] = {0x00, 0x01, 0x47, 0x00, 0x01, 0x0c};
 
         if (Press) {
                 PressReq[5] = Key;
                 s->Phone.Data.PressKey = true;
                 smprintf(s, "Pressing key\n");
                 return GSM_WaitFor (s, PressReq, 6, 0xd1, 4, ID_PressKey);
         } else {
                 s->Phone.Data.PressKey = false;
                 smprintf(s, "Releasing key\n");
                 return GSM_WaitFor (s, ReleaseReq, 6, 0xd1, 4, ID_PressKey);
         }
 }
 
 GSM_Error DCT3_ReplyPlayTone(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Tone played\n");
         return ERR_NONE;
 }
 
 GSM_Error DCT3_PlayTone(GSM_StateMachine *s, int Herz, unsigned char Volume, bool start)
 {
                 GSM_Error error;
                 unsigned char req[] = {0x00,0x01,0x8f,
                                          0x00,  /* Volume */
                                          0x00,  /* HerzLo */
                                          0x00};         /* HerzHi */
 
         if (start) {
                 error=DCT3_EnableSecurity (s, 0x01);
                 if (error!=ERR_NONE) return error;
         }
 
         /* For Herz==255*255 we have silent */  
         if (Herz!=255*255) {
                 req[3]=Volume;
                 req[5]=Herz%256;
                 req[4]=Herz/256;
         } else {
@@ -301,259 +304,260 @@ GSM_Error DCT3_ReplyGetAlarm(GSM_Protocol_Message msg, GSM_StateMachine *s)
         if (msg.Buffer[8]==0x02) {
                 smprintf(s, "set to %02i:%02i\n", msg.Buffer[9], msg.Buffer[10]);
                         Data->Alarm->Repeating          = true;
                         Data->Alarm->Text[0]    = 0;
                         Data->Alarm->Text[1]    = 0;
                         Data->Alarm->DateTime.Hour= msg.Buffer[9];
                         Data->Alarm->DateTime.Minute= msg.Buffer[10];
                         Data->Alarm->DateTime.Second= 0;
                 return ERR_NONE;
         }
         smprintf(s, "not set\n");
         return ERR_EMPTY;
 }
 
 GSM_Error DCT3_GetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm, unsigned char msgtype)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x6d};
 
         if (alarm->Location!=1) return ERR_NOTSUPPORTED;
 
         s->Phone.Data.Alarm=alarm;
         smprintf(s, "Getting alarm\n");
         return GSM_WaitFor (s, req, 4, msgtype, 4, ID_GetAlarm);
 }
 
 GSM_Error DCT3_ReplySetDateTime(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Date & time: ");
         if (msg.Buffer[4]==0x01) {
                 smprintf(s, "set OK\n");
                 return ERR_NONE;
         }
         smprintf(s, "error setting\n");
         return ERR_UNKNOWN;
 }
 
 GSM_Error DCT3_SetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time, unsigned char msgtype)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x60, 0x01, 0x01, 0x07,
                                        0x00, 0x00,      /* Year         */
                                        0x00,            /* Month        */
                                        0x00,            /* Day                          */      
                                        0x00,            /* Hour         */
                                        0x00,            /* Minute       */
                                        0x00};   /* Unknown. Not seconds */
 
         NOKIA_EncodeDateTime(s, req+7, date_time);
         smprintf(s, "Setting date & time\n");
         return GSM_WaitFor (s, req, 14, msgtype, 4, ID_SetDateTime);
 }
 
 GSM_Error DCT3_ReplySetAlarm(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Alarm: ");
         if (msg.Buffer[4]==0x01) {
                 smprintf(s, "set OK\n");
                 return ERR_NONE;
         }
         smprintf(s, "error setting\n");
         return ERR_UNKNOWN;
 }
 
 GSM_Error DCT3_SetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm, unsigned char msgtype)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x6b, 0x01, 0x20, 0x03,
                                0x02,      /* Unknown. Not for enabling/disabling */
                                        0x00,      /* Hour                        */
                                        0x00,      /* Minute                      */
                                        0x00};     /* Unknown. Not seconds        */
 
         if (alarm->Location != 1) return ERR_NOTSUPPORTED;
 
         req[8] = alarm->DateTime.Hour;
         req[9] = alarm->DateTime.Minute;
 
         smprintf(s, "Setting alarm\n");
         return GSM_WaitFor (s, req, 11, msgtype, 4, ID_SetAlarm);
 }
 
 GSM_Error DCT3_ReplyGetSMSC(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 int     i;
                 GSM_Phone_Data*Data = &s->Phone.Data;
 
         switch (msg.Buffer[3]) {
         case 0x34:
                 smprintf(s, "SMSC received\n");
                 Data->SMSC->Format = SMS_FORMAT_Text;
                 switch (msg.Buffer[6]) {
                                 case 0x00: Data->SMSC->Format = SMS_FORMAT_Text; break;
                                 case 0x22: Data->SMSC->Format = SMS_FORMAT_Fax; break;
                                 case 0x26: Data->SMSC->Format = SMS_FORMAT_Pager;break;
                                 case 0x32: Data->SMSC->Format = SMS_FORMAT_Email;break;
                 }
                         Data->SMSC->Validity.Format = SMS_Validity_RelativeFormat;
                         Data->SMSC->Validity.Relative= msg.Buffer[8];
+                if (msg.Buffer[8] == 0x00) Data->SMSC->Validity.Relative = SMS_VALID_Max_Time;
         
                 i=33;
                 while (msg.Buffer[i]!=0) {i++;}
                 i=i-33;
                 if (i>GSM_MAX_SMSC_NAME_LENGTH) {
                         smprintf(s, "Too long name\n");
                         return ERR_UNKNOWNRESPONSE;
                 }
                 EncodeUnicode(Data->SMSC->Name,msg.Buffer+33,i);
                 smprintf(s, "Name \"%s\"\n", DecodeUnicodeString(Data->SMSC->Name));
         
                 GSM_UnpackSemiOctetNumber(Data->SMSC->DefaultNumber,msg.Buffer+9,true);
                 smprintf(s, "Default number \"%s\"\n", DecodeUnicodeString(Data->SMSC->DefaultNumber));
 
                 GSM_UnpackSemiOctetNumber(Data->SMSC->Number,msg.Buffer+21,false);
                 smprintf(s, "Number \"%s\"\n", DecodeUnicodeString(Data->SMSC->Number));
         
                 return ERR_NONE;
         case 0x35:
                 smprintf(s, "Getting SMSC failed\n");
                 return ERR_INVALIDLOCATION;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error DCT3_GetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x33, 0x64,
                                        0x00};   /* Location */
 
         if (smsc->Location==0x00) return ERR_INVALIDLOCATION;
         
         req[5]=smsc->Location;
 
         s->Phone.Data.SMSC=smsc;
         smprintf(s, "Getting SMSC\n");
         return GSM_WaitFor (s, req, 6, 0x02, 4, ID_GetSMSC);
 }
 
 GSM_Error DCT3_ReplyGetNetworkInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 int     count;
                 GSM_Phone_Data*Data = &s->Phone.Data;
 #ifdef DEBUG
         GSM_NetworkInfo NetInfo;
                 char    name[100];
 
         smprintf(s, "Network info received\n");
-        smprintf(s, "   Status                    : ");
+        smprintf(s, "Status                 : ");
         switch (msg.Buffer[8]) {
                         case 0x01: smprintf(s, "home network");                         break;
                         case 0x02: smprintf(s, "roaming network");              break;
                         case 0x03: smprintf(s, "requesting network");           break;
                         case 0x04: smprintf(s, "not registered in the network");break;
                 default  : smprintf(s, "unknown");
         }
         smprintf(s, "\n");
-        smprintf(s, "Network selection         : %s\n", msg.Buffer[9]==1?"manual":"automatic");
+        smprintf(s, "Network selection      : %s\n", msg.Buffer[9]==1?"manual":"automatic");
         if (msg.Buffer[8]<0x03) {
                 sprintf(NetInfo.CID, "%02x%02x", msg.Buffer[10], msg.Buffer[11]);
                 smprintf(s, "CID                    : %s\n", NetInfo.CID);
 
                 sprintf(NetInfo.LAC, "%02x%02x", msg.Buffer[12], msg.Buffer[13]);
                 smprintf(s, "LAC                    : %s\n", NetInfo.LAC);
 
-                smprintf(s, "Network code           : %s\n", NetInfo.NetworkCode);
                 NOKIA_DecodeNetworkCode(msg.Buffer+14,NetInfo.NetworkCode);
+                smprintf(s, "Network code           : %s\n", NetInfo.NetworkCode);
                 smprintf(s, "Network name for Gammu : %s ",
                                 DecodeUnicodeString(GSM_GetNetworkName(NetInfo.NetworkCode)));
                 smprintf(s, "(%s)\n",DecodeUnicodeString(GSM_GetCountryName(NetInfo.NetworkCode)));
 
                 if (msg.Length>18) {
                         if (msg.Buffer[18]==0x00) {
                                 /* In 6210 name is in "normal" Unicode */
                                 memcpy(name,msg.Buffer+18,msg.Buffer[17]*2);
                                         name[msg.Buffer[17]*2]=0x00;
                                 name[msg.Buffer[17]*2+1]=0x00;
                                 smprintf(s, "Network name for phone : %s\n",DecodeUnicodeString(name));
                         } else {
                                 /* In 9210 first 0x00 is cut from Unicode string */
                                 name[0] = 0;
                                 memcpy(name+1,msg.Buffer+18,msg.Buffer[17]*2);
                                 name[msg.Buffer[17]*2+1]=0x00;
                                 name[msg.Buffer[17]*2+2]=0x00;
                                 smprintf(s, "Network name for phone : %s\n",DecodeUnicodeString(name));
                         }
                 }
         }
 #endif
         if (Data->RequestID==ID_GetNetworkInfo) {
                 Data->NetworkInfo->NetworkName[0] = 0x00;
                 Data->NetworkInfo->NetworkName[1] = 0x00;
                         Data->NetworkInfo->State   = 0;
                 switch (msg.Buffer[8]) {
                                 case 0x01: Data->NetworkInfo->State = GSM_HomeNetwork;  break;
                                 case 0x02: Data->NetworkInfo->State = GSM_RoamingNetwork;break;
                                 case 0x03: Data->NetworkInfo->State = GSM_RequestingNetwork;break;
                                 case 0x04: Data->NetworkInfo->State = GSM_NoNetwork;    break;
                 }
                 if (Data->NetworkInfo->State == GSM_HomeNetwork || Data->NetworkInfo->State == GSM_RoamingNetwork) {
                         if (msg.Buffer[18]==0x00) {
                                 /* In 6210 name is in "normal" Unicode */
                                 memcpy(Data->NetworkInfo->NetworkName,msg.Buffer+18,msg.Buffer[17]*2);
                                 Data->NetworkInfo->NetworkName[msg.Buffer[17]*2]   = 0x00;
                                 Data->NetworkInfo->NetworkName[msg.Buffer[17]*2+1] = 0x00;
                         } else {
                                 /* In 9210 first 0x00 is cut from Unicode string */
                                 Data->NetworkInfo->NetworkName[0] = 0;
                                 memcpy(Data->NetworkInfo->NetworkName+1,msg.Buffer+18,msg.Buffer[17]*2);
                                 Data->NetworkInfo->NetworkName[msg.Buffer[17]*2+1]=0x00;
                                 Data->NetworkInfo->NetworkName[msg.Buffer[17]*2+2]=0x00;
                         }
                         NOKIA_DecodeNetworkCode(msg.Buffer+14,Data->NetworkInfo->NetworkCode);
                         sprintf(Data->NetworkInfo->CID, "%02x%02x", msg.Buffer[10], msg.Buffer[11]);
                         sprintf(Data->NetworkInfo->LAC, "%02x%02x", msg.Buffer[12], msg.Buffer[13]);
                 }
         }
         /* 6210/6250/7110 */
         if (Data->RequestID==ID_GetBitmap) {
                 if (msg.Buffer[4]==0x02) {
                         smprintf(s, "Operator logo available\n");
                         count = 7;
                         /* skip network info */
                         count += msg.Buffer[count];
                         count ++;
                                 Data->Bitmap->BitmapWidth= msg.Buffer[count++];
                                 Data->Bitmap->BitmapHeight= msg.Buffer[count++];
                         count+=4;
                         PHONE_DecodeBitmap(GSM_Nokia7110OperatorLogo,msg.Buffer+count,Data->Bitmap);
                         NOKIA_DecodeNetworkCode(msg.Buffer+14,Data->Bitmap->NetworkCode);
                 } else {
                                 Data->Bitmap->BitmapWidth= 78;
                                 Data->Bitmap->BitmapHeight= 21;
                         GSM_ClearBitmap(Data->Bitmap);
                         strcpy(Data->Bitmap->NetworkCode,"000 00");
                 }
         }
         return ERR_NONE;
 }
 
 GSM_Error DCT3_GetNetworkInfo(GSM_StateMachine *s, GSM_NetworkInfo *netinfo)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x70};
 
         s->Phone.Data.NetworkInfo=netinfo;
         smprintf(s, "Getting network info\n");
         return GSM_WaitFor (s, req, 4, 0x0a, 4, ID_GetNetworkInfo);
 }
 
 GSM_Error DCT3_ReplyDialCommand(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Answer for call commands\n");
         return ERR_NONE;
 }
 
 GSM_Error DCT3_DialVoice(GSM_StateMachine *s, char *number, GSM_CallShowNumber ShowNumber)
 {
                 unsigned inti = 0;
                 GSM_Errorerror;
                 unsigned char req[100] = {0x00, 0x01, 0x7c,
                                             0x01};      /* call command */
 
         if (ShowNumber != GSM_CALL_DefaultNumberPresence) return ERR_NOTSUPPORTED;
@@ -1115,197 +1119,197 @@ GSM_Error DCT3_SetWAPSettings(GSM_StateMachine *s, GSM_MultiWAPSettings *setting
         /* Data */
         if (phone1 != -1) {
                 pos = 4;
                 memset(SetReq2 + pos, 0, 200 - pos);
                 SetReq2[pos++] = phone1;
                 SetReq2[pos++] = 0x02; 
                 SetReq2[pos++] = 0x01; /* GSMdata */
                 if (loc1 != -1) {
                         if (!settings->Settings[loc1].IsNormalAuthentication) SetReq2[pos] = 0x01;
                 }
                 pos++;
                 if (loc1 != -1) {
                         if (settings->Settings[loc1].IsISDNCall) SetReq2[pos] = 0x01;
                 }
                 pos++;
                 if (loc1 != -1) {
                         switch (settings->Settings[loc1].Speed) {
                                 case WAPSETTINGS_SPEED_9600  : SetReq2[pos++] = 0x01; break;
                                 case WAPSETTINGS_SPEED_14400 : SetReq2[pos++] = 0x02; break;
                                         default                      : SetReq2[pos++] = 0x02; break;
                         }
                         switch (settings->Settings[loc1].Speed) {
                                 case WAPSETTINGS_SPEED_9600  : SetReq2[pos++] = 0x01; break;
                                 case WAPSETTINGS_SPEED_14400 : SetReq2[pos++] = 0x02; break;
                                         default                      : SetReq2[pos++] = 0x02; break;
                         }
                 } else pos+=2;
                 if (loc1 != -1) {
                         /* IP */
                         pos += NOKIA_SetUnicodeString(s, SetReq2 + pos, settings->Settings[loc1].IPAddress, false);
                         /* Number */
                         pos += NOKIA_SetUnicodeString(s, SetReq2 + pos, settings->Settings[loc1].DialUp, false);
                         /* Username  */
                         pos += NOKIA_SetUnicodeString(s, SetReq2 + pos, settings->Settings[loc1].User, false);
                         /* Password */
                                 pos += NOKIA_SetUnicodeString(s, SetReq2 + pos, settings->Settings[loc1].Password, false);      
                 } else pos+=5;
                 memcpy(SetReq2 + pos, "\x80\x00\x00\x00\x00\x00\x00\x00", 8);
                 pos += 8;
                 smprintf(s, "Writing WAP settings part 2 (Data bearer)\n");
                 error=GSM_WaitFor (s, SetReq2, pos, 0x3f, 4, ID_SetConnectSet);
                 if (error != ERR_NONE) return error;
         }
         /* SMS */
         if (phone2 != -1) {
                 pos = 4;
                 memset(SetReq2 + pos, 0, 200 - pos);
                 SetReq2[pos++] = phone2;
                 SetReq2[pos++] = 0x02; 
                 SetReq2[pos++] = 0x00; /* SMS */
                 if (loc2 != -1) {
                         /* Service number */
                         pos += NOKIA_SetUnicodeString(s, SetReq2 + pos, settings->Settings[loc2].Service, false);
                         /* Server number */
                         pos += NOKIA_SetUnicodeString(s, SetReq2 + pos, settings->Settings[loc2].Server, false);
                 } else pos += 2;
                 memcpy(SetReq2 + pos, "\x80\x00\x00\x00\x00\x00\x00\x00", 8);
                 pos += 8;
                 smprintf(s, "Writing WAP settings part 2 (SMS bearer)\n");
                 error=GSM_WaitFor (s, SetReq2, pos, 0x3f, 4, ID_SetConnectSet);
                 if (error != ERR_NONE) return error;
         }
         /* USSD */
         if (phone3 != -1) {
                 pos = 4;
                 memset(SetReq2 + pos, 0, 200 - pos);
                 SetReq2[pos++] = phone3;
                 SetReq2[pos++] = 0x02; 
                 SetReq2[pos++] = 0x02; /* USSD */
                 if (loc3 != -1) {
                         if (!settings->Settings[loc3].IsIP) SetReq2[pos] = 0x01;
                 }
                 pos++;
                 if (loc3 != -1) {
                         /* Service number or IP address */
                         pos += NOKIA_SetUnicodeString(s, SetReq2 + pos, settings->Settings[loc3].Service, false);
                         /* Code number */
                         pos += NOKIA_SetUnicodeString(s, SetReq2 + pos, settings->Settings[loc3].Code, false);
                 } else pos+=2;
                 memcpy(SetReq2 + pos, "\x80\x00\x00\x00\x00\x00\x00\x00", 8);
                 pos += 8;
                 smprintf(s, "Writing WAP settings part 2 (USSD bearer)\n");
                 error=GSM_WaitFor (s, SetReq2, pos, 0x3f, 4, ID_SetConnectSet);
                 if (error != ERR_NONE) return error;
         }
         error = DCT3DCT4_SetActiveConnectSet(s, settings);
         if (error != ERR_NONE) return error;
 
         return DCT3DCT4_DisableConnectionFunctions(s);
 }
 
 GSM_Error DCT3_ReplySendSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
         case 0x02:
                 smprintf(s, "SMS sent OK\n");
-                if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,0,0);
+                if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,0,msg.Buffer[5]);
                 return ERR_NONE;
         case 0x03:
                 smprintf(s, "Error %i\n",msg.Buffer[6]);
-                if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,msg.Buffer[6],0);
+                if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,msg.Buffer[6],-1);
                 return ERR_NONE;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 GSM_Error DCT3_SendSMSMessage(GSM_StateMachine *s, GSM_SMSMessage *sms)
 {
                 int             length;
                 GSM_Error       error;
                 unsigned char   req[256] = {N6110_FRAME_HEADER, 0x01, 0x02, 0x00};
 
         error=PHONE_EncodeSMSFrame(s,sms,req+6,PHONE_SMSSubmit,&length, true);
         if (error != ERR_NONE) return error;
 
         smprintf(s, "Sending sms\n");
         return s->Protocol.Functions->WriteMessage(s, req, 6+length, 0x02);
 }
 
 GSM_Error DCT3_ReplyNetmonitor(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
         case 0x00:
                 smprintf(s, "Netmonitor correctly set\n");
                 break;
         default:
                 smprintf(s, "Menu %i\n",msg.Buffer[3]);
                 smprintf(s, "%s\n",msg.Buffer+4);
                 strcpy(s->Phone.Data.Netmonitor,msg.Buffer+4);
                         break;  
         }
         return ERR_NONE;
 }
 
 GSM_Error DCT3_Netmonitor(GSM_StateMachine *s, int testnumber, char *value)
 {
                 GSM_Error error;
                 unsigned char req[] = {0x00, 0x01, 0x7e,
                                          0x00};         /* Test number */
 
         value[0] = 0;
 
         error=DCT3_EnableSecurity (s, 0x01);
         if (error != ERR_NONE) return error;
 
         req[3] = testnumber;
 
         smprintf(s, "Getting netmonitor test\n");
         s->Phone.Data.Netmonitor = value;
         return GSM_WaitFor (s, req, 4, 0x40, 4, ID_Netmonitor);
 }
 
 GSM_Error DCT3_GetManufactureMonth(GSM_StateMachine *s, char *value)
 {
                 GSM_Error error;
 
         error=DCT3_EnableSecurity (s, 0x01);
         if (error != ERR_NONE) return error;
         return NOKIA_GetPhoneString(s,"\x00\x01\xCC\x02",4,0x40,value,ID_GetManufactureMonth,5);
 }
 
 GSM_Error DCT3_GetProductCode(GSM_StateMachine *s, char *value)
 {
                 GSM_Error error;
 
         if (strlen(s->Phone.Data.ProductCodeCache)!=0) {
                 strcpy(value,s->Phone.Data.ProductCodeCache);
                 return ERR_NONE;
         }
 
         error=DCT3_EnableSecurity (s, 0x01);
         if (error != ERR_NONE) return error;
         return NOKIA_GetPhoneString(s,"\x00\x01\xCA\x01",4,0x40,value,ID_GetProductCode,5);
 }
 
 GSM_Error DCT3_GetOriginalIMEI(GSM_StateMachine *s, char *value)
 {
                 GSM_Error error;
 
         error=DCT3_EnableSecurity (s, 0x01);
         if (error != ERR_NONE) return error;
         return NOKIA_GetPhoneString(s,"\x00\x01\xCC\x01",4,0x40,value,ID_GetOriginalIMEI,5);
 }
 
 GSM_Error DCT3_GetHardware(GSM_StateMachine *s, char *value)
 {
                 GSM_Error error;
 
         if (strlen(s->Phone.Data.HardwareCache)!=0) {
                 strcpy(value,s->Phone.Data.HardwareCache);
                 return ERR_NONE;
         }
 
         error=DCT3_EnableSecurity (s, 0x01);
         if (error != ERR_NONE) return error;
         return NOKIA_GetPhoneString(s,"\x00\x01\xC8\x05",4,0x40,value,ID_GetHardware,5);
 }
diff --git a/gammu/emb/common/phone/nokia/dct3/dct3func.h b/gammu/emb/common/phone/nokia/dct3/dct3func.h
index 66b67ec..18b2026 100644
--- a/gammu/emb/common/phone/nokia/dct3/dct3func.h
+++ b/gammu/emb/common/phone/nokia/dct3/dct3func.h
@@ -1,78 +1,80 @@
 /* (c) 2002-2003 by Marcin Wiacek */
 
 #ifndef phone_nokia_dct3_h
 #define phone_nokia_dct3_h
 
+#include "../ncommon.h"
+
         GSM_Error DCT3_ReplyPressKey    (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyPlayTone    (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyEnableSecurity(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyGetIMEI     (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyGetSMSC     (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplySIMLogin    (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplySIMLogout   (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyGetDateTime         (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyGetAlarm    (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplySetDateTime         (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplySetAlarm    (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyDialCommand         (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyGetWAPBookmark(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyGetNetworkInfo(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplySendSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplySetSMSC     (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyGetWAPSettings(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplySetWAPSettings(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyNetmonitor  (GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyDeleteSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error N71_92_ReplyGetSignalQuality(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error N71_92_ReplyGetBatteryCharge(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error N71_92_ReplyPhoneSetting(GSM_Protocol_Message msg, GSM_StateMachine *s);
 GSM_Error N61_71_ReplyResetPhoneSettings(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error N61_91_ReplySetOpLogo         (GSM_Protocol_Message msg, GSM_StateMachine *s);
 #ifdef GSM_ENABLE_CELLBROADCAST
         GSM_Error DCT3_ReplySetIncomingCB(GSM_Protocol_Message msg, GSM_StateMachine *s);
         GSM_Error DCT3_ReplyIncomingCB  (GSM_Protocol_Message msg, GSM_StateMachine *s);
 #endif
 
         GSM_Error DCT3_DeleteWAPBookmark(GSM_StateMachine *s, GSM_WAPBookmark *bookmark);
         GSM_Error DCT3_GetWAPBookmark   (GSM_StateMachine *s, GSM_WAPBookmark *bookmark);
         GSM_Error DCT3_PressKey                 (GSM_StateMachine *s, GSM_KeyCode Key, bool Press);
         GSM_Error DCT3_PlayTone                 (GSM_StateMachine *s, int Herz, unsigned char Volume, bool start);
         GSM_Error DCT3_EnableSecurity           (GSM_StateMachine *s, unsigned char       status);
         GSM_Error DCT3_GetIMEI          (GSM_StateMachine *s);
         GSM_Error DCT3_GetSMSC                  (GSM_StateMachine *s, GSM_SMSC            *smsc         );
         GSM_Error DCT3_GetNetworkInfo           (GSM_StateMachine *s, GSM_NetworkInfo     *netinfo);
         GSM_Error DCT3_DialVoice                (GSM_StateMachine *s, char                *number, GSM_CallShowNumber ShowNumber);
         GSM_Error DCT3_Reset                    (GSM_StateMachine *s, bool                hard  );
         GSM_Error DCT3_CancelCall       (GSM_StateMachine *s, int ID, bool all);
         GSM_Error DCT3_AnswerAllCalls   (GSM_StateMachine *s);
         GSM_Error DCT3_SendSMSMessage           (GSM_StateMachine *s, GSM_SMSMessage      *sms  );
         GSM_Error DCT3_GetAlarm                         (GSM_StateMachine *s, GSM_Alarm                   *alarm,unsigned char msgtype);
         GSM_Error DCT3_GetDateTime              (GSM_StateMachine *s, GSM_DateTime        *date_time,   unsigned char   msgtype);
         GSM_Error DCT3_SetAlarm                         (GSM_StateMachine *s, GSM_Alarm                   *alarm, unsigned char msgtype);
         GSM_Error DCT3_SetDateTime              (GSM_StateMachine *s, GSM_DateTime        *date_time,   unsigned char   msgtype);
         GSM_Error DCT3_SetIncomingCB            (GSM_StateMachine *s, bool                enable);
         GSM_Error DCT3_GetSMSStatus             (GSM_StateMachine *s, GSM_SMSMemoryStatus *status);
         GSM_Error DCT3_SetSMSC                  (GSM_StateMachine *s, GSM_SMSC            *smsc         );
         GSM_Error DCT3_GetWAPSettings           (GSM_StateMachine *s, GSM_MultiWAPSettings        *settings);
         GSM_Error DCT3_SetWAPSettings   (GSM_StateMachine *s, GSM_MultiWAPSettings *settings);
         GSM_Error DCT3_SetWAPBookmark           (GSM_StateMachine *s, GSM_WAPBookmark  *bookmark);
         GSM_Error DCT3_Netmonitor               (GSM_StateMachine *s, int                 testnumber,   char            *value);
         GSM_Error DCT3_GetManufactureMonth      (GSM_StateMachine *s, char                *value);
         GSM_Error DCT3_GetProductCode   (GSM_StateMachine *s, char *value);
         GSM_Error DCT3_GetOriginalIMEI  (GSM_StateMachine *s, char *value);
         GSM_Error DCT3_GetHardware      (GSM_StateMachine *s, char *value);
         GSM_Error DCT3_GetPPM           (GSM_StateMachine *s, char *value);
         GSM_Error N61_71_ResetPhoneSettings(GSM_StateMachine *s, GSM_ResetSettingsType Type);
         GSM_Error N71_92_GetBatteryCharge(GSM_StateMachine *s, GSM_BatteryCharge *bat);
         GSM_Error N71_92_GetSignalQuality(GSM_StateMachine *s, GSM_SignalQuality *sig);
         GSM_Error N71_92_GetPhoneSetting(GSM_StateMachine *s, int Request, int Setting);
         GSM_Error N71_92_GetDateTime            (GSM_StateMachine *s, GSM_DateTime        *date_time);
         GSM_Error N71_92_SetDateTime            (GSM_StateMachine *s, GSM_DateTime        *date_time);
 
         GSM_Error DCT3_DecodeSMSFrame   (GSM_StateMachine *s, GSM_SMSMessage *SMS, unsigned char *buffer);
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/dct3/n6110.c b/gammu/emb/common/phone/nokia/dct3/n6110.c
index 263d12b..dac6c12 100644
--- a/gammu/emb/common/phone/nokia/dct3/n6110.c
+++ b/gammu/emb/common/phone/nokia/dct3/n6110.c
@@ -1,225 +1,228 @@
 /* (c) 2001-2004 by Marcin Wiacek */
-/* based on some work from Markus Plail and Gnokii */
-/* Authentication function (c) 1999 or earlier by Pavel Janik */
 /* 5210 calendar IDs by Frederick Ros */
+/* based on some Markus Plail, Pavel Janik & others work from Gnokii (www.gnokii.org)
+ * (C) 1999-2000 Hugh Blemings & Pavel Janik ml. (C) 2001-2004 Pawel Kot 
+ * GNU GPL version 2 or later
+ */
 
 #include "../../../gsmstate.h"
 
 #ifdef GSM_ENABLE_NOKIA6110
 
 #include <string.h>
 
 #include "../../../../cfg/config.h"
 #include "../../../misc/coding/coding.h"
 #include "../../../service/sms/gsmsms.h"
 #include "../../../gsmcomon.h"
 #include "../../pfunc.h"
 #include "../nfunc.h"
 #include "n6110.h"
 #include "dct3func.h"
 
 static unsigned char N6110_MEMORY_TYPES[] = {
         MEM_ME, 0x02,
         MEM_SM, 0x03,
         MEM_ON, 0x05,
         MEM_DC, 0x07,
         MEM_RC, 0x08,
         MEM_MC, 0x09,
         MEM_VM, 0x0b,
           0x00, 0x00
 };
 
 static GSM_Error N6110_ReplyGetPhoneLanguage(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         N6110_Language lang = N6110_Auto;
 
         if (msg.Buffer[3] == 0x15) return ERR_NONE;
 
         smprintf(s, "Phone language is %02x\n",msg.Buffer[6]);
         switch (msg.Buffer[6]) {
                 case 0x21: lang = N6110_Europe; break; //Polish
         }
         s->Phone.Data.Priv.N6110.PhoneLanguage = lang;
         return ERR_NONE;
 }
 
 static GSM_Error N6110_GetPhoneLanguage(GSM_StateMachine *s)
 {
         unsigned char feat_req[] = {N6110_FRAME_HEADER, 0x13, 0x01,
                                     0x00,               /* Profile location */
                                     0x00};              /* Feature number   */
 
         s->Phone.Data.Priv.N6110.PhoneLanguage = N6110_Auto;
 
         feat_req[5] = 0; 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_PROFILES33)) {
                 feat_req[6] = 0x1E;
         } else {
                 feat_req[6] = 0x21;
         }
         smprintf(s, "Getting profile feature\n");
         return GSM_WaitFor (s, feat_req, 7, 0x05, 4, ID_GetLanguage);
 }
 
 struct N6110_Lang_Char {
         N6110_Language  Lang;
         unsigned char   Phone;
         unsigned char   Unicode1;
         unsigned char   Unicode2;
 };
 
 static struct N6110_Lang_Char N6110_Lang_Table[] = {
 {N6110_Europe,0x13,0x01,0x04},//Latin capital letter a with ogonek
 {N6110_Europe,0x14,0x01,0x05},//Latin small   letter a with ogonek
 {N6110_Europe,0x15,0x01,0x06},//Latin capital letter c with acute
 {N6110_Europe,0x17,0x01,0x07},//Latin small   letter c with acute
 {N6110_Europe,0x1D,0x01,0x18},//Latin capital letter e with ogonek
 {N6110_Europe,0x1E,0x01,0x19},//Latin small   letter e with ogonek
 {N6110_Europe,0x83,0x00,0xD3},//Latin capital letter o with acute
 {N6110_Europe,0x8E,0x01,0x41},//Latin capital letter l with stroke
 {N6110_Europe,0x90,0x01,0x42},//Latin small   letter l with stroke
 {N6110_Europe,0x92,0x01,0x43},//Latin capital letter n with acute
 {N6110_Europe,0x93,0x01,0x44},//Latin small   letter n with acute
 {N6110_Europe,0x9A,0x00,0xF3},//Latin small   letter o with acute
 {N6110_Europe,0xB2,0x20,0xAC},//euro
 {N6110_Europe,0xB5,0x01,0x5A},//Latin capital letter s with acute
 {N6110_Europe,0xB6,0x01,0x5B},//Latin small   letter s with acute
 {N6110_Europe,0xE7,0x01,0x79},//Latin capital letter z with acute
 {N6110_Europe,0xEE,0x01,0x7A},//Latin small   letter z with acute
 {N6110_Europe,0xF4,0x01,0x7C},//Latin small   letter z with dot above
 {N6110_Europe,0xF0,0x01,0x7B},//Latin capital letter z with dot above
 {0,0,0,0}
 };
 
 static void N6110_EncodeUnicode(GSM_StateMachine *s, unsigned char *dest, const unsigned char *src, int len)
 {
         int                     i_len = 0, o_len, i;
         wchar_t                 wc;
         GSM_Phone_N6110Data     *Priv = &s->Phone.Data.Priv.N6110;
         bool                    found;
  
         for (o_len = 0; i_len < len; o_len++) {
                 found = false;
                 if (Priv->PhoneLanguage != N6110_Auto) {
                         i       = 0;
                         while(1) {
                                 if (N6110_Lang_Table[i].Lang == 0) break;
                                 if (N6110_Lang_Table[i].Lang == Priv->PhoneLanguage &&
                                     N6110_Lang_Table[i].Phone == src[i_len]) {
                                         dest[o_len*2]           = N6110_Lang_Table[i].Unicode1;
                                         dest[(o_len*2)+1]       = N6110_Lang_Table[i].Unicode2;
                                         i_len++;
                                         found = true;
                                         break;
                                 } 
                                 i++;
                         }
                 }
                 if (!found) {
                         i_len += EncodeWithUnicodeAlphabet(&src[i_len], &wc);
                         dest[o_len*2]           = (wc >> 8) & 0xff;
                         dest[(o_len*2)+1]       = wc & 0xff;
                 }
         }
         dest[o_len*2]           = 0;
         dest[(o_len*2)+1]       = 0;
 }
 
 #ifndef ENABLE_LGPL
 
+/* Pavel Janik */
 /* This function provides Nokia authentication protocol.
  * Nokia authentication protocol is used in the communication between Nokia
  * mobile phones (e.g. Nokia 6110) and Nokia Cellular Data Suite software,
  * commercially sold by Nokia Corp.
  * The authentication scheme is based on the token send by the phone to the
  * software. The software does it's magic (see the function
  * N6110_GetNokiaAuthentication) and returns the result back to the phone.
  * If the result is correct the phone responds with the message "Accessory
  * connected!" displayed on the LCD. Otherwise it will display "Accessory not
  * supported" and some functions will not be available for use (?).
  * The specification of the protocol is not publicly available, no comment.
  */
 static void N6110_GetNokiaAuthentication(unsigned char *Imei, unsigned char *MagicBytes, unsigned char *MagicResponse)
 {
         int             i, j, CRC=0;
         unsigned char   Temp[16];       /* This is our temporary working area. */
 
         /* Here we put FAC (Final Assembly Code) and serial number into our area. */
         Temp[0]  = Imei[6];             Temp[1]  = Imei[7];
         Temp[2]  = Imei[8];             Temp[3]  = Imei[9];
         Temp[4]  = Imei[10];            Temp[5]  = Imei[11];
         Temp[6]  = Imei[12];            Temp[7]  = Imei[13];
 
         /* And now the TAC (Type Approval Code). */
         Temp[8]  = Imei[2];             Temp[9]  = Imei[3];
         Temp[10] = Imei[4];             Temp[11] = Imei[5];
 
         /* And now we pack magic bytes from the phone. */
         Temp[12] = MagicBytes[0];       Temp[13] = MagicBytes[1];
         Temp[14] = MagicBytes[2];       Temp[15] = MagicBytes[3];
 
         for (i=0; i<=11; i++) if (Temp[i + 1]& 1) Temp[i]<<=1;
         switch (Temp[15] & 0x03) {
                 case 1:
                 case 2:         j = Temp[13] & 0x07;
                                 for (i=0; i<=3; i++) Temp[i+j] ^= Temp[i+12];
                                 break;
                 default:        j = Temp[14] & 0x07;
                                 for (i=0; i<=3; i++) Temp[i + j] |= Temp[i + 12];
         }
         for (i=0; i<=15; i++) CRC ^= Temp[i];
         for (i=0; i<=15; i++) {
                 switch (Temp[15 - i] & 0x06) {
                         case 0: j = Temp[i] | CRC; break;
                         case 2:
                         case 4: j = Temp[i] ^ CRC; break;
                         case 6: j = Temp[i] & CRC; break;
                 }
                 if (j == CRC) j = 0x2c;
                 if (Temp[i] == 0) j = 0;
                 MagicResponse[i] = j;
         }
 }
 
 static GSM_Error N6110_ReplyGetMagicBytes(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_N6110Data     *Priv = &s->Phone.Data.Priv.N6110;
         GSM_Phone_Data          *Data = &s->Phone.Data;
 
         sprintf(Data->IMEI, "%s", msg.Buffer+9);
         sprintf(Data->HardwareCache, "%s", msg.Buffer+39);
         sprintf(Data->ProductCodeCache, "%s", msg.Buffer+31);
 
         smprintf(s, "Message: Mobile phone identification received:\n");
         smprintf(s, "IMEI            : %s\n", msg.Buffer+9);
         smprintf(s, "Model           : %s\n", msg.Buffer+25);
         smprintf(s, "Production Code : %s\n", msg.Buffer+31);
         smprintf(s, "HW              : %s\n", msg.Buffer+39);
         smprintf(s, "Firmware        : %s\n", msg.Buffer+44);
 
         /* These bytes are probably the source of the "Accessory not connected"
          * messages on the phone when trying to emulate NCDS... I hope....
          * UPDATE: of course, now we have the authentication algorithm.
          */
         smprintf(s, "   Magic bytes     : %02x %02x %02x %02x\n", msg.Buffer[50], msg.Buffer[51], msg.Buffer[52], msg.Buffer[53]);
 
         Priv->MagicBytes[0]=msg.Buffer[50];
         Priv->MagicBytes[1]=msg.Buffer[51];
         Priv->MagicBytes[2]=msg.Buffer[52];
         Priv->MagicBytes[3]=msg.Buffer[53];
 
         return ERR_NONE;
 }
 
 static GSM_Error N6110_MakeAuthentication(GSM_StateMachine *s)
 {
         GSM_Phone_N6110Data     *Priv = &s->Phone.Data.Priv.N6110;
         GSM_Error               error;
         unsigned char           connect4[] = {N6110_FRAME_HEADER, 0x10};
         unsigned char           magic_connect[] = {
                 N6110_FRAME_HEADER, 0x12,
                 /* The real magic goes here ... These bytes are filled in
                  * with the function N6110_GetNokiaAuthentication. */
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                 /* NOKIA&GNOKII Accessory */
@@ -731,192 +734,193 @@ static GSM_Error N6110_SetSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
 }
 
 static GSM_Error N6110_AddSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
 {
         sms->Location = 0;
         return N6110_PrivSetSMSMessage(s, sms);
 }
 
 static GSM_Error N6110_ReplySetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
         case 0x37:
                 smprintf(s, "Ringtone set OK\n");
                 return ERR_NONE;
                 break;
         case 0x38:
                 smprintf(s, "Error setting ringtone\n");
                 switch (msg.Buffer[4]) {
                 case 0x7d:
                         smprintf(s, "Too high location ?\n");
                         return ERR_INVALIDLOCATION;
                 default:
                         smprintf(s, "ERROR: unknown %i\n",msg.Buffer[4]);
                 }
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6110_ReplySetBinRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[4]) {
         case 0x00:
                 smprintf(s, "Set at location %i\n",msg.Buffer[3]+1);
                 return ERR_NONE;
         default:
                 smprintf(s, "Invalid location. Too high ?\n");
                 return ERR_INVALIDLOCATION;
         }
 }
 
 static GSM_Error N6110_SetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength)
 {
         GSM_NetworkInfo NetInfo;
         GSM_Error       error;
         int             size=200,current=8;
         GSM_UDHHeader   UDHHeader;
         unsigned char   req[1000] = {N6110_FRAME_HEADER, 0x36,
                                      0x00,              /* Location */
                                      0x00,0x78};
         unsigned char   reqBin[1000] = {0x00,0x01,0xa0,0x00,0x00,0x0c,0x01,0x2c};
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_NORING)) return ERR_NOTSUPPORTED;
         if (Ringtone->Location == 0) return ERR_INVALIDLOCATION;
 
         switch (Ringtone->Format) {
         case RING_NOTETONE:
                 if (Ringtone->Location==255) {
                         /* Only 6110, 6130 and 6150 support it */
                         if (strcmp(s->Phone.Data.Model,"NSE-3") == 0 || strcmp(s->Phone.Data.Model,"NSK-3") == 0 ||
                             strcmp(s->Phone.Data.Model,"NSM-1") == 0) {
                                 req[0] = 0x0c;
                                 req[1] = 0x01;
                                 UDHHeader.Type = UDH_NokiaRingtone;
                                 GSM_EncodeUDHHeader(&UDHHeader);
                                 /* We copy UDH now */
                                 memcpy(req+2,UDHHeader.Text,UDHHeader.Length);
                                 *maxlength=GSM_EncodeNokiaRTTLRingtone(*Ringtone, req+2+UDHHeader.Length, &size);
                                 error = s->Protocol.Functions->WriteMessage(s, req, 2+UDHHeader.Length+size, 0x12);
                                 if (error!=ERR_NONE) return error;
                                 my_sleep(1000);
                                 /* We have to make something (not important, what) now */
                                 /* no answer from phone*/
                                 return DCT3_GetNetworkInfo(s,&NetInfo);
                         } else {
                                 return ERR_NOTSUPPORTED;
                         }
                 }
                 *maxlength=GSM_EncodeNokiaRTTLRingtone(*Ringtone, req+7, &size);
                 req[4] = Ringtone->Location - 1;
                 smprintf(s, "Setting ringtone\n");
                 return GSM_WaitFor (s, req, 7 + size, 0x05, 4, ID_SetRingtone);
         case RING_NOKIABINARY:
                 error=DCT3_EnableSecurity (s, 0x01);
                 if (error!=ERR_NONE) return error;
                 memcpy(reqBin+current,DecodeUnicodeString(Ringtone->Name),UnicodeLength(Ringtone->Name));
                 current += UnicodeLength(Ringtone->Name);
                 reqBin[current++] = 0x00;
                 reqBin[current++] = 0x00;
                 reqBin[current++] = 0x00;/*xxx*/
                 memcpy(reqBin+current,Ringtone->NokiaBinary.Frame,Ringtone->NokiaBinary.Length);
                 current=current+Ringtone->NokiaBinary.Length;
                 reqBin[3]=Ringtone->Location-1;
                 if (!strcmp(s->Phone.Data.ModelInfo->model,"3210")) reqBin[5]=0x10;
                 smprintf(s, "Setting binary ringtone\n");
                 return GSM_WaitFor (s, reqBin, current, 0x40, 4, ID_SetRingtone);
         case RING_MIDI: 
+        case RING_MMF:
                 return ERR_NOTSUPPORTED;
         }
         return ERR_NOTSUPPORTED;
 }
 
 static GSM_Error N6110_ReplyGetOpLogo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         int                     count=5;
         GSM_Phone_Data          *Data = &s->Phone.Data;
 
         smprintf(s, "Operator logo received\n");
         NOKIA_DecodeNetworkCode(msg.Buffer+count,Data->Bitmap->NetworkCode);
         count = count + 3;
         smprintf(s, "Network code           : %s\n", Data->Bitmap->NetworkCode);
         smprintf(s, "Network name for Gammu : %s ",
                         DecodeUnicodeString(GSM_GetNetworkName(Data->Bitmap->NetworkCode)));
         smprintf(s, "(%s)\n",DecodeUnicodeString(GSM_GetCountryName(Data->Bitmap->NetworkCode)));
 
         count = count + 3;              /* We ignore size */
         Data->Bitmap->BitmapWidth       = msg.Buffer[count++];
         Data->Bitmap->BitmapHeight      = msg.Buffer[count++];
         count++;
         PHONE_DecodeBitmap(GSM_NokiaOperatorLogo,msg.Buffer+count,Data->Bitmap);
         return ERR_NONE;
 }
 
 static GSM_Error N6110_ReplyGetStartup(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         int                     i, count = 5;
         GSM_Phone_Data          *Data = &s->Phone.Data;
 
         smprintf(s, "Startup logo & notes received\n");
         for (i=0;i<msg.Buffer[4];i++) {
         switch (msg.Buffer[count++]) {
         case 0x01:
                 smprintf(s, "Startup logo\n");
                 if (Data->Bitmap->Type == GSM_StartupLogo) {
                         Data->Bitmap->BitmapHeight      = msg.Buffer[count++];
                         Data->Bitmap->BitmapWidth       = msg.Buffer[count++];
                         PHONE_DecodeBitmap(GSM_NokiaStartupLogo, msg.Buffer + count, Data->Bitmap);
                 } else {
                         count = count + 2;
                 }
                 count = count + PHONE_GetBitmapSize(GSM_NokiaStartupLogo,0,0);
                 break;
         case 0x02:
                 smprintf(s, "Welcome note\n");
                 if (Data->Bitmap->Type == GSM_WelcomeNote_Text) {
                         EncodeUnicode(Data->Bitmap->Text,msg.Buffer+count, msg.Buffer[count]);
                         smprintf(s, "Text is \"%s\"\n",Data->Bitmap->Text);
                 }
                 count = count + msg.Buffer[count] + 1;
                 break;
         case 0x03:
                 smprintf(s, "Dealer welcome note\n");
                 if (Data->Bitmap->Type == GSM_DealerNote_Text) {
                         EncodeUnicode(Data->Bitmap->Text,msg.Buffer+count, msg.Buffer[count]);
                         smprintf(s, "Text is \"%s\"\n",Data->Bitmap->Text);
                 }
                 count = count + msg.Buffer[count] + 1;
                 break;
         default:
                 smprintf(s, "Unknown block\n");
                 return ERR_UNKNOWNRESPONSE;
                 break;          
         }
         }
         return ERR_NONE;
 }
 
 static GSM_Error N6110_ReplyGetCallerLogo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         int                     count;
         GSM_Phone_Data          *Data = &s->Phone.Data;
 
         switch (msg.Buffer[3]) {
         case 0x11:
                 smprintf(s, "Caller group info received\n");
                 EncodeUnicode(Data->Bitmap->Text,msg.Buffer+6,msg.Buffer[5]);
                 smprintf(s, "Name : \"%s\"\n",DecodeUnicodeString(Data->Bitmap->Text));
                 Data->Bitmap->DefaultName = false;
                 if (msg.Buffer[5] == 0x00) Data->Bitmap->DefaultName = true;
                 count                            = msg.Buffer[5] + 6;
                 Data->Bitmap->RingtoneID         = msg.Buffer[count++];
                 Data->Bitmap->DefaultRingtone    = false;
                 Data->Bitmap->FileSystemRingtone = false;
                 if (Data->Bitmap->RingtoneID == 16) Data->Bitmap->DefaultRingtone = true;
                 smprintf(s, "Ringtone ID: %02x\n",Data->Bitmap->RingtoneID);
                 Data->Bitmap->BitmapEnabled=(msg.Buffer[count++]==1);
 #ifdef DEBUG    
                 smprintf(s, "Caller group logo ");
                 if (Data->Bitmap->BitmapEnabled) {
                         smprintf(s, "enabled\n");
                 } else {
                         smprintf(s, "disabled\n");
                 }
@@ -1431,229 +1435,231 @@ static GSM_Error N6110_SetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
                         req[6] = UnicodeLength(entry->Entries[Name].Text);
                         memcpy(req+current,DecodeUnicodeString(entry->Entries[Name].Text),UnicodeLength(entry->Entries[Name].Text));
                         current += UnicodeLength(entry->Entries[Name].Text);
                 } else req[6] = 0;
         } else {
                 if (Name != -1) {
                         req[6] = UnicodeLength(entry->Entries[Name].Text)*2+2;
                         memcpy(req+current,entry->Entries[Name].Text,UnicodeLength(entry->Entries[Name].Text)*2);
                         current += UnicodeLength(entry->Entries[Name].Text)*2;
                 } else req[6] = 0;
                 req[current++]=0x00;
                 req[current++]=0x00;
         }
 
         if (Number != -1) {
                 req[current++]=UnicodeLength(entry->Entries[Number].Text);
                 memcpy(req+current,DecodeUnicodeString(entry->Entries[Number].Text),UnicodeLength(entry->Entries[Number].Text));
                 current += UnicodeLength(entry->Entries[Number].Text);
         } else req[current++] = 0;
 
         /* This allow to save 14 characters name into SIM memory, when
          * no caller group is selected. */
         if (Group == -1) {
                 req[current++] = 0xff;
         } else {
                 req[current++] = entry->Entries[Group].Number-1;
         }
 
         smprintf(s, "Writing phonebook entry\n");
         return GSM_WaitFor (s, req, current, 0x03, 4, ID_SetMemory);
 }
 
 static GSM_Error N6110_DeleteMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
         GSM_MemoryEntry dwa;
 
         dwa.Location   = entry->Location;
         dwa.MemoryType = entry->MemoryType;
         dwa.EntriesNum = 0;
 
         return N6110_SetMemory(s, &dwa);
 }
 
 static GSM_Error N6110_ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data  *Data = &s->Phone.Data;
         char            buffer[2000];
         GSM_Error       error;
         int             i,end,start;
 
         smprintf(s, "Ringtone received\n");
         switch (msg.Buffer[4]) {
         case 0x00:
                 switch (Data->Ringtone->Format) {
                 case RING_NOTETONE:
                         memcpy(buffer,msg.Buffer,msg.Length);
                         i=7;
                         if (buffer[9]==0x4a && buffer[10]==0x3a) i=8;
                         buffer[i]=0x02; 
                         error=GSM_DecodeNokiaRTTLRingtone(Data->Ringtone, buffer+i, msg.Length-i);
                         if (error!=ERR_NONE) return ERR_EMPTY;
                         return ERR_NONE;
                 case RING_NOKIABINARY:
                         i=8;
                         while (msg.Buffer[i]!=0) {
                                 i++;
                                 if (i>msg.Length) return ERR_EMPTY;
                         }
                         EncodeUnicode(Data->Ringtone->Name,msg.Buffer+8,i-8);
                         smprintf(s, "Name \"%s\"\n",DecodeUnicodeString(Data->Ringtone->Name));
                         /* Looking for start && end */
                         end=0;start=0;i=0;
                         while (true) {
                                 if (start!=0) {
                                         if (msg.Buffer[i]==0x07 && msg.Buffer[i+1]==0x0b) {
                                                 end=i+2; break;
                                         }
                                         if (msg.Buffer[i]==0x0e && msg.Buffer[i+1]==0x0b) {
                                                 end=i+2; break;
                                         }
                                 } else {
                                         if (msg.Buffer[i]==0x02 && msg.Buffer[i+1]==0xfc && msg.Buffer[i+2]==0x09) {
                                                 start = i;
                                         }
                                 }
                                 i++;
                                 if (i==msg.Length-3) return ERR_EMPTY;
                         }         
                         /* Copying frame */
                         memcpy(Data->Ringtone->NokiaBinary.Frame,msg.Buffer+start,end-start);
                         Data->Ringtone->NokiaBinary.Length=end-start;
 #ifdef DEBUG
                         if (di.dl == DL_TEXTALL || di.dl == DL_TEXTALLDATE) DumpMessage(di.df, di.dl, Data->Ringtone->NokiaBinary.Frame, Data->Ringtone->NokiaBinary.Length);
 #endif
                         return ERR_NONE;
                 case RING_MIDI: 
+                case RING_MMF: 
                         return ERR_NOTSUPPORTED;
                 }
                 smprintf(s, "Ringtone format is %i\n",Data->Ringtone->Format);          
                 break;
         default:
                 smprintf(s, "Invalid location. Too high ?\n");
                 return ERR_INVALIDLOCATION;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6110_GetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone)
 {
         GSM_Error       error;
         unsigned char   req[] = {0x00, 0x01, 0x9e,
                                  0x00};                 /* location */
 
         if (PhoneRingtone) return ERR_NOTSUPPORTED;
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo,F_NORING)) return ERR_NOTSUPPORTED;
         if (Ringtone->Location == 0) return ERR_INVALIDLOCATION;
 
         if (Ringtone->Format == 0x00) {
                 if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo,F_RING_SM)) {
                         Ringtone->Format = RING_NOTETONE;
                 } else {
                         Ringtone->Format = RING_NOKIABINARY;
                 }
         }
 
         switch (Ringtone->Format) {
         case RING_NOTETONE:
                 if (!IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo,F_RING_SM)) return ERR_NOTSUPPORTED;
                 break;
         case RING_NOKIABINARY:
                 if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo,F_RING_SM)) return ERR_NOTSUPPORTED;
                 break;
         case RING_MIDI: 
+        case RING_MMF:
                 return ERR_NOTSUPPORTED;
         }
 
         error=DCT3_EnableSecurity (s, 0x01);
         if (error!=ERR_NONE) return error;
 
         req[3]=Ringtone->Location-1;
         s->Phone.Data.Ringtone=Ringtone;
         smprintf(s, "Getting (binary) ringtone\n");
         return GSM_WaitFor (s, req, 4, 0x40, 4, ID_GetRingtone);
 }
 
 static GSM_Error N6110_ReplyGetSecurityStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         *s->Phone.Data.SecurityStatus = msg.Buffer[4];
 
 #ifdef DEBUG
         smprintf(s, "Security code status\n");
         switch(msg.Buffer[4]) {
                 case SEC_SecurityCode: smprintf(s, "waiting for Security Code.\n");      break;
                 case SEC_Pin         : smprintf(s, "waiting for PIN.\n");                break;
                 case SEC_Pin2        : smprintf(s, "waiting for PIN2.\n");               break;
                 case SEC_Puk         : smprintf(s, "waiting for PUK.\n");                break;
                 case SEC_Puk2        : smprintf(s, "waiting for PUK2.\n");               break;
                 case SEC_None        : smprintf(s, "nothing to enter.\n");               break;
                 default              : smprintf(s, "ERROR: unknown %i\n",msg.Buffer[4]);
                                        return ERR_UNKNOWNRESPONSE;
         }      
 #endif
         return ERR_NONE;
 }
 
 static GSM_Error N6110_GetSecurityStatus(GSM_StateMachine *s, GSM_SecurityCodeType *Status)
 {
         unsigned char req[4] = {N6110_FRAME_HEADER, 0x07};
 
         s->Phone.Data.SecurityStatus=Status;
         smprintf(s, "Getting security code status\n");
         return GSM_WaitFor (s, req, 4, 0x08, 2, ID_GetSecurityStatus);
 }
 
 static GSM_Error N6110_ReplyEnterSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
         case 0x0b:
                 smprintf(s, "Security code OK\n");
                 return ERR_NONE;
         case 0x0c:
                 switch (msg.Buffer[4]) {
                 case 0x88:
                         smprintf(s, "Wrong code\n");
                         return ERR_SECURITYERROR;
                 case 0x8b:
                         smprintf(s, "Not required\n");
                         return ERR_NONE;
                 default:
                         smprintf(s, "ERROR: unknown %i\n",msg.Buffer[4]);
                 }
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6110_EnterSecurityCode(GSM_StateMachine *s, GSM_SecurityCode Code)
 {
         int             len = 0;
         unsigned char   req[15] = {N6110_FRAME_HEADER, 0x0a,
                                    0x00};       /* Type of code to enter */
                             
         req[4]=Code.Type;
 
         len = strlen(Code.Code);
         memcpy(req+5,Code.Code,len);
         req[5+len]=0x00;
         req[6+len]=0x00;
 
         smprintf(s, "Entering security code\n");
         return GSM_WaitFor (s, req, 7+len, 0x08, 4, ID_EnterSecurityCode);
 }
 
 static GSM_Error N6110_ReplyGetSpeedDial(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
 
         switch (msg.Buffer[3]) {
         case 0x17:
                 smprintf(s, "Speed dial received\n");
                 switch (msg.Buffer[4]) {
                 case 0x02:
                         Data->SpeedDial->MemoryType = MEM_ME;
                         smprintf(s, "ME ");
                         break;
                 case 0x03:
                         Data->SpeedDial->MemoryType = MEM_SM;
                         smprintf(s, "SIM ");
                         break;
                 default:
@@ -2350,194 +2356,194 @@ static GSM_Error N6110_ReplyGetNextCalendar(GSM_Protocol_Message msg, GSM_StateM
                 Entry->EntriesNum++;
 
                 NOKIA_DecodeDateTime(s, msg.Buffer+16, &Entry->Entries[1].Date);
                 if (Entry->Entries[1].Date.Year!=0) {
                         smprintf(s, "Alarm       : %02i-%02i-%04i %02i:%02i:%02i\n",
                                 Entry->Entries[1].Date.Day,Entry->Entries[1].Date.Month,Entry->Entries[1].Date.Year,
                                 Entry->Entries[1].Date.Hour,Entry->Entries[1].Date.Minute,Entry->Entries[1].Date.Second);
                         Entry->Entries[1].EntryType = CAL_ALARM_DATETIME;
                         Entry->EntriesNum++;
                 } else {
                         smprintf(s, "No alarm\n");
                 }
 
                 if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo,F_CAL52) ||
                     IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo,F_CAL82)) {
                         memcpy(Entry->Entries[Entry->EntriesNum].Text,msg.Buffer+24,msg.Buffer[23]);
                         Entry->Entries[Entry->EntriesNum].Text[msg.Buffer[23]  ]=0;
                         Entry->Entries[Entry->EntriesNum].Text[msg.Buffer[23]+1]=0;
                 } else {
                         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo,F_CAL33)) {
                                 /* first char is subset for 33xx and reminders */
                                 if (Entry->Type == GSM_CAL_REMINDER) {
                                         i=1;
                                         smprintf(s, "Subset %i in reminder note !\n",msg.Buffer[24]);
                                 }
                                 SpecialSubSet = true;
                                 switch (msg.Buffer[24]) {
                                         case 2  : Decode3310Subset2(i,msg,&s->Phone.Data); break;
                                         case 3  : Decode3310Subset3(i,msg,&s->Phone.Data); break;
                                         default : SpecialSubSet = false;         break;
                                 }
                         }
                         if (!SpecialSubSet) {
                                 N6110_EncodeUnicode(s,Entry->Entries[Entry->EntriesNum].Text,msg.Buffer+24+i,msg.Buffer[23]-i);
                         }
                 }
                 smprintf(s, "Text \"%s\"\n",DecodeUnicodeString(Entry->Entries[Entry->EntriesNum].Text));
                 if (msg.Buffer[23] != 0x00) {
                         Entry->Entries[Entry->EntriesNum].EntryType = CAL_TEXT;
                         Entry->EntriesNum++;
                 }
 
                 if (Entry->Type == GSM_CAL_CALL) {
                         EncodeUnicode(Entry->Entries[Entry->EntriesNum].Text,msg.Buffer+24+msg.Buffer[23]+1,msg.Buffer[24+msg.Buffer[23]]);
                         smprintf(s, "Phone       : \"%s\"\n",DecodeUnicodeString(Entry->Entries[Entry->EntriesNum].Text));
                         if (msg.Buffer[24+msg.Buffer[23]] != 0x00) {
                                 Entry->Entries[Entry->EntriesNum].EntryType = CAL_PHONE;
                                 Entry->EntriesNum++;
                         }
                 }
                 return ERR_NONE;
         case 0x93:
                 smprintf(s, "Can't get calendar note - too high location?\n");
                 return ERR_INVALIDLOCATION;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6110_GetNextCalendarNote(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start)
 {
         int                             Text, Time, Alarm, Phone, Recurrance, EndTime, Location;
         GSM_Error                       error;
         GSM_DateTime                    date_time;
         GSM_Phone_N6110Data             *Priv = &s->Phone.Data.Priv.N6110;
         unsigned char                   req[] = {N6110_FRAME_HEADER, 0x66,
                                                  0x00};         /* Location */
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_NOCALENDAR)) return ERR_NOTSUPPORTED;
 
         if (start) {
                 Priv->LastCalendarPos = 1;
         } else {
                 Priv->LastCalendarPos++;
         }
 
         Note->Location  = Priv->LastCalendarPos;
         req[4]          = Priv->LastCalendarPos;
 
         s->Phone.Data.Cal=Note;
         smprintf(s, "Getting calendar note\n");
         error=GSM_WaitFor (s, req, 5, 0x13, 4, ID_GetCalendarNote);
 
         GSM_CalendarFindDefaultTextTimeAlarmPhoneRecurrance(Note, &Text, &Time, &Alarm, &Phone, &Recurrance, &EndTime, &Location);
         /* 2090 year is set for example in 3310 */
         if (error == ERR_NONE && Note->Entries[Time].Date.Year == 2090) {
                 error=N6110_GetDateTime(s, &date_time);
                 if (error == ERR_NONE) Note->Entries[Time].Date.Year = date_time.Year;
         }
         return error;
 }
 
 GSM_Error N6110_ReplyUSSDInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         unsigned char   buffer[2000],buffer2[4000];
         int             tmp;
 
-        tmp=GSM_UnpackEightBitsToSeven(0, 82, 82, msg.Buffer+8, buffer);
-        msg.Buffer[tmp] = 0;
+        tmp=GSM_UnpackEightBitsToSeven(0, msg.Buffer[7], 82, msg.Buffer+8, buffer);
+        buffer[tmp] = 0;
 
         smprintf(s, "USSD reply: \"%s\"\n",buffer);
 
         if (s->Phone.Data.EnableIncomingUSSD && s->User.IncomingUSSD!=NULL) {
                 EncodeUnicode(buffer2,buffer,strlen(buffer));
                 s->User.IncomingUSSD(s->CurrentConfig->Device, buffer2);
         }
 
         return ERR_NONE;
 }
 
 GSM_Error N6110_AnswerCall(GSM_StateMachine *s, int ID, bool all)
 {
         GSM_Error       error;
         unsigned char   req1[] = {N6110_FRAME_HEADER, 0x42, 0x05, 0x01,
                                   0x07, 0xa2, 0x88, 0x81, 0x21, 0x15, 0x63, 0xa8,
                                   0x00, 0x00, 0x07, 0xa3, 0xb8, 0x81, 0x20, 0x15,
                                   0x63, 0x80};
 
         if (!all) {
                 smprintf(s, "Answering call part 1\n");
                 error = GSM_WaitFor (s, req1, 24, 0x01, 5, ID_AnswerCall);
                 if (error != ERR_NONE) return error;
                 return DCT3DCT4_AnswerCall(s,ID);
         }
 
         return DCT3_AnswerAllCalls(s);
 }
 
 static GSM_Error N6110_DialVoice(GSM_StateMachine *s, char *number, GSM_CallShowNumber ShowNumber)
 {
         unsigned int    pos = 4;
         unsigned char   req[100] = {N6110_FRAME_HEADER,0x01,
                                     0x0c};      /* Length of number */
 
         if (ShowNumber == GSM_CALL_DefaultNumberPresence) return DCT3_DialVoice(s,number,ShowNumber);
 
         req[pos++] = strlen(number);
         memcpy(req+pos,number,strlen(number));
         pos += strlen(number);
         req[pos++] = 0x05; /* call type: voice - 0x05, data - 0x01 */
         req[pos++] = 0x01;
         req[pos++] = 0x01;
         req[pos++] = 0x05;
         req[pos++] = 0x81;
         switch (ShowNumber) {
         case GSM_CALL_HideNumber:
                 req[pos++] = 0x02;
                 break;
         case GSM_CALL_ShowNumber:
                 req[pos++] = 0x03;
                 break;
         case GSM_CALL_DefaultNumberPresence:
                 req[pos++] = 0x01;
                 break;
         }
         req[pos++] = 0x00;
         req[pos++] = 0x00;
 
         smprintf(s, "Making voice call\n");
         return GSM_WaitFor (s, req, pos, 0x01, 4, ID_DialVoice);
 }
 
 GSM_Error N6110_UnholdCall(GSM_StateMachine *s, int ID)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x24, 0x00, 0x02};
 
         req[4]                  = (unsigned char)ID;
         s->Phone.Data.CallID    = ID;
 
         smprintf(s, "Unholding call\n");
         return GSM_WaitFor (s, req, 6, 0x01, 4, ID_UnholdCall);
 }
 
 GSM_Error N6110_HoldCall(GSM_StateMachine *s, int ID)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x22, 0x00, 0x00};
 
         req[4]                  = (unsigned char)ID;
         s->Phone.Data.CallID    = ID;
 
         smprintf(s, "Unholding call\n");
         return GSM_WaitFor (s, req, 6, 0x01, 4, ID_HoldCall);
 }
 
 /* Joining selected call to current (and making conference) */
 GSM_Error N6110_ConferenceCall(GSM_StateMachine *s, int ID)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x28, 0x00, 0x01};
 
         req[4]                  = (unsigned char)ID;
         s->Phone.Data.CallID    = ID;
 
         smprintf(s, "Conference call\n");
         return GSM_WaitFor (s, req, 6, 0x01, 4, ID_ConferenceCall);
 }
@@ -2714,171 +2720,172 @@ static GSM_Reply_Function N6110ReplyFunctions[] = {
                 {DCT3_ReplyGetWAPSettings,        "\x3f",0x03,0x16,ID_GetConnectSet },
                 {DCT3_ReplyGetWAPSettings,        "\x3f",0x03,0x17,ID_GetConnectSet },
                 {DCT3_ReplySetWAPSettings,        "\x3f",0x03,0x19,ID_SetConnectSet },
                 {DCT3_ReplySetWAPSettings,        "\x3f",0x03,0x1A,ID_SetConnectSet },
                 {DCT3_ReplyGetWAPSettings,        "\x3f",0x03,0x1C,ID_GetConnectSet },
                 {DCT3_ReplyGetWAPSettings,        "\x3f",0x03,0x1D,ID_GetConnectSet },
                 {DCT3_ReplySetWAPSettings,        "\x3f",0x03,0x1F,ID_SetConnectSet },
 
         {DCT3_ReplyEnableSecurity,        "\x40",0x02,0x64,ID_EnableSecurity     },
         {N61_71_ReplyResetPhoneSettings,  "\x40",0x02,0x65,ID_ResetPhoneSettings },
         {DCT3_ReplyGetIMEI,               "\x40",0x02,0x66,ID_GetIMEI            },
         {DCT3_ReplyDialCommand,           "\x40",0x02,0x7C,ID_DialVoice          },
         {DCT3_ReplyDialCommand,           "\x40",0x02,0x7C,ID_CancelCall         },
         {DCT3_ReplyDialCommand,           "\x40",0x02,0x7C,ID_AnswerCall         },
         {DCT3_ReplyNetmonitor,            "\x40",0x02,0x7E,ID_Netmonitor         },
         {DCT3_ReplyPlayTone,              "\x40",0x02,0x8F,ID_PlayTone           },
         {N6110_ReplyGetRingtone,          "\x40",0x02,0x9E,ID_GetRingtone        },
         {N6110_ReplySetBinRingtone,       "\x40",0x02,0xA0,ID_SetRingtone        },
         {NOKIA_ReplyGetPhoneString,       "\x40",0x02,0xC8,ID_GetHardware        },
         {NOKIA_ReplyGetPhoneString,       "\x40",0x02,0xC8,ID_GetPPM             },
         {NOKIA_ReplyGetPhoneString,       "\x40",0x02,0xCA,ID_GetProductCode     },
         {NOKIA_ReplyGetPhoneString,       "\x40",0x02,0xCC,ID_GetManufactureMonth},
         {NOKIA_ReplyGetPhoneString,       "\x40",0x02,0xCC,ID_GetOriginalIMEI    },
 
         {N6110_ReplyGetSetPicture,        "\x47",0x03,0x02,ID_GetBitmap          },
         {N6110_ReplyGetSetPicture,        "\x47",0x03,0x04,ID_SetBitmap          },
         {N6110_ReplyGetSetPicture,        "\x47",0x03,0x05,ID_SetBitmap          },
         {N6110_ReplyGetSetPicture,        "\x47",0x03,0x06,ID_GetBitmap          },
 
 #ifndef ENABLE_LGPL
         {N6110_ReplyGetMagicBytes,        "\x64",0x00,0x00,ID_MakeAuthentication },
 #endif
 
         {DCT3DCT4_ReplyGetModelFirmware,  "\xD2",0x02,0x00,ID_GetModel           },
         {DCT3DCT4_ReplyGetModelFirmware,  "\xD2",0x02,0x00,ID_GetFirmware        },
         {DCT3_ReplyPressKey,              "\xD2",0x02,0x46,ID_PressKey           },
         {DCT3_ReplyPressKey,              "\xD2",0x02,0x47,ID_PressKey           },
 
         {NULL,                            "\x00",0x00,0x00,ID_None               }
 };
 
 GSM_Phone_Functions N6110Phone = {
         "2100|3210|3310|3330|3390|3410|3610|5110|5110i|5130|5190|5210|5510|6110|6130|6150|6190|8210|8250|8290|8850|8855|8890",
         N6110ReplyFunctions,
         N6110_Initialise,
         PHONE_Terminate,
         GSM_DispatchMessage,
         N6110_ShowStartInfo,
         NOKIA_GetManufacturer,
         DCT3DCT4_GetModel,
         DCT3DCT4_GetFirmware,
         DCT3_GetIMEI,
         DCT3_GetOriginalIMEI,
         DCT3_GetManufactureMonth,
         DCT3_GetProductCode,
         DCT3_GetHardware,
         DCT3_GetPPM,
         NOTSUPPORTED,                   /*      GetSIMIMSI              */
         N6110_GetDateTime,
         N6110_SetDateTime,
         N6110_GetAlarm,
         N6110_SetAlarm,
         NOTSUPPORTED,                   /*      GetLocale               */
         NOTSUPPORTED,                   /*      SetLocale               */
         DCT3_PressKey,
         DCT3_Reset,
         N61_71_ResetPhoneSettings,
         N6110_EnterSecurityCode,
         N6110_GetSecurityStatus,
         N6110_GetDisplayStatus,
         NOTIMPLEMENTED,                 /*      SetAutoNetworkLogin     */
         N6110_GetBatteryCharge,
         N6110_GetSignalQuality,
         DCT3_GetNetworkInfo,
         NOTSUPPORTED,                   /*      GetCategory             */
         NOTSUPPORTED,                   /*      AddCategory             */
         NOTSUPPORTED,                   /*      GetCategoryStatus       */
         N6110_GetMemoryStatus,
         N6110_GetMemory,
         NOTIMPLEMENTED,                 /*      GetNextMemory           */
         N6110_SetMemory,
         NOTIMPLEMENTED,                 /*      AddMemory               */
         N6110_DeleteMemory,
         NOTIMPLEMENTED,                 /*      DeleteAllMemory         */
         N6110_GetSpeedDial,
         NOTIMPLEMENTED,                 /*      SetSpeedDial            */
         DCT3_GetSMSC,
         DCT3_SetSMSC,
         DCT3_GetSMSStatus,
         N6110_GetSMSMessage,
         N6110_GetNextSMSMessage,
         N6110_SetSMS,
         N6110_AddSMS,
         N6110_DeleteSMSMessage,
         DCT3_SendSMSMessage,
         NOTSUPPORTED,                   /*      SendSavedSMS            */
+                NOTSUPPORTED,                   /*      SetFastSMSSending*/
         NOKIA_SetIncomingSMS,
         DCT3_SetIncomingCB,
         PHONE_GetSMSFolders,
         NOTSUPPORTED,                   /*      AddSMSFolder            */
         NOTSUPPORTED,                   /*      DeleteSMSFolder         */
         N6110_DialVoice,
         N6110_AnswerCall,
         DCT3_CancelCall,
         N6110_HoldCall,
         N6110_UnholdCall,
         N6110_ConferenceCall,
         N6110_SplitCall,
         N6110_TransferCall,
         N6110_SwitchCall,
         DCT3DCT4_GetCallDivert,
         DCT3DCT4_SetCallDivert,
         DCT3DCT4_CancelAllDiverts,
         NOKIA_SetIncomingCall,
         NOKIA_SetIncomingUSSD,
         DCT3DCT4_SendDTMF,
         N6110_GetRingtone,
         N6110_SetRingtone,
         NOTSUPPORTED,                   /*      GetRingtonesInfo        */
         NOTSUPPORTED,                   /*      DeleteUserRingtones     */
         DCT3_PlayTone,
         DCT3_GetWAPBookmark,
         DCT3_SetWAPBookmark,
         DCT3_DeleteWAPBookmark,
         DCT3_GetWAPSettings,
         DCT3_SetWAPSettings,
         NOTSUPPORTED,                   /*      GetMMSSettings          */
         NOTSUPPORTED,                   /*      SetMMSSettings          */
                 NOTSUPPORTED,                   /*      GetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      GetChatSettings         */
                 NOTSUPPORTED,                   /*      SetChatSettings         */
         N6110_GetBitmap,
         N6110_SetBitmap,
         NOTSUPPORTED,                   /*      GetToDoStatus           */
         NOTSUPPORTED,                   /*      GetToDo                 */
         NOTSUPPORTED,                   /*      GetNextToDo             */
         NOTSUPPORTED,                   /*      SetToDo                 */
         NOTSUPPORTED,                   /*      AddToDo                 */
         NOTSUPPORTED,                   /*      DeleteToDo              */
         NOTSUPPORTED,                   /*      DeleteAllToDo           */
         NOTIMPLEMENTED,                 /*      GetCalendarStatus       */
         NOTIMPLEMENTED,                 /*      GetCalendar             */
         N6110_GetNextCalendarNote,
         NOTIMPLEMENTED,                 /*      SetCalendar             */
         N6110_AddCalendarNote,
         N6110_DeleteCalendarNote,
         NOTIMPLEMENTED,                 /*      DeleteAllCalendar       */
         NOTSUPPORTED,                   /*      GetCalendarSettings     */
         NOTSUPPORTED,                   /*      SetCalendarSettings     */
-        NOTSUPPORTED,                   /*      GetNote                 */
+        NOTSUPPORTED,                   /*      GetNextNote             */
         N6110_GetProfile,
         N6110_SetProfile,
         NOTSUPPORTED,                   /*      GetFMStation            */
         NOTSUPPORTED,                   /*      SetFMStation            */
         NOTSUPPORTED,                   /*      ClearFMStations         */      
         NOTSUPPORTED,                   /*      GetNextFileFolder       */
         NOTSUPPORTED,                   /*      GetFilePart             */
         NOTSUPPORTED,                   /*      AddFile                 */
         NOTSUPPORTED,                   /*      GetFileSystemStatus     */
         NOTSUPPORTED,                   /*      DeleteFile              */
         NOTSUPPORTED,                   /*      AddFolder               */
         NOTSUPPORTED,                   /*      GetGPRSAccessPoint      */
         NOTSUPPORTED                    /*      SetGPRSAccessPoint      */
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/dct3/n7110.c b/gammu/emb/common/phone/nokia/dct3/n7110.c
index 5a02c9c..b597f9b 100644
--- a/gammu/emb/common/phone/nokia/dct3/n7110.c
+++ b/gammu/emb/common/phone/nokia/dct3/n7110.c
@@ -1,98 +1,101 @@
 /* (c) 2001-2004 by Marcin Wiacek */
-/* based on some work from Markus Plail and Gnokii */
+/* based on some Markus Plail work from Gnokii (www.gnokii.org)
+ * (C) 1999-2000 Hugh Blemings & Pavel Janik ml. (C) 2001-2004 Pawel Kot 
+ * GNU GPL version 2 or later
+ */
 
 #include "../../../gsmstate.h"
 
 #ifdef GSM_ENABLE_NOKIA7110
 
 #include <string.h>
 #include <time.h>
 
 #include "../../../misc/coding/coding.h"
 #include "../../../gsmcomon.h"
 #include "../../../service/gsmlogo.h"
 #include "../../pfunc.h"
 #include "../nfunc.h"
 #include "../nfuncold.h"
 #include "n7110.h"
 #include "dct3func.h"
 
 static GSM_Error N7110_GetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm)
 {
         return DCT3_GetAlarm(s, alarm, 0x19);
 }
 
 static GSM_Error N7110_SetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm)
 {
         return DCT3_SetAlarm(s, alarm, 0x19);
 }
 
 static GSM_Error N7110_ReplyGetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
 
         smprintf(s, "Phonebook entry received\n");
         switch (msg.Buffer[6]) {
         case 0x0f:
                 return N71_65_ReplyGetMemoryError(msg.Buffer[10], s);
         default:
                 return N71_65_DecodePhonebook(s, Data->Memory,Data->Bitmap,Data->SpeedDial,msg.Buffer+18,msg.Length-18,false);
         }
         return ERR_UNKNOWN;
 }
 
 static GSM_Error N7110_GetMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
         unsigned char req[] = {N7110_FRAME_HEADER, 0x07, 0x01, 0x01, 0x00, 0x01,
                                        0x02,    /* memory type */
                                0x05,
                                        0x00, 0x00,/* location */
                                0x00, 0x00};
 
         req[9] = NOKIA_GetMemoryType(s, entry->MemoryType,N71_65_MEMORY_TYPES);
         if (req[9]==0xff) return ERR_NOTSUPPORTED;
 
         if (entry->Location==0x00) return ERR_INVALIDLOCATION;
 
         req[10] = entry->Location / 256;
         req[11] = entry->Location % 256;
 
         s->Phone.Data.Memory=entry;
         smprintf(s, "Getting phonebook entry\n");
         return GSM_WaitFor (s, req, 14, 0x03, 4, ID_GetMemory);
 }
 
 static GSM_Error N7110_ReplyGetMemoryStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
 
         smprintf(s, "Memory status received\n");
         /* Quess ;-)) */
         if (msg.Buffer[10]==0x10) {
                 Data->MemoryStatus->MemoryFree = msg.Buffer[14]*256 + msg.Buffer[15];
         } else {
                 Data->MemoryStatus->MemoryFree = msg.Buffer[18];
         }
         smprintf(s, "   Size       : %i\n",Data->MemoryStatus->MemoryFree);
         Data->MemoryStatus->MemoryUsed = msg.Buffer[16]*256 + msg.Buffer[17];
         smprintf(s, "   Used       : %i\n",Data->MemoryStatus->MemoryUsed);
         Data->MemoryStatus->MemoryFree -= Data->MemoryStatus->MemoryUsed;
         smprintf(s, "   Free       : %i\n",Data->MemoryStatus->MemoryFree);
         return ERR_NONE;
 }
 
 static GSM_Error N7110_GetMemoryStatus(GSM_StateMachine *s, GSM_MemoryStatus *Status)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x03, 0x02,
                                        0x05};   /* Memory type */
 
         req[5] = NOKIA_GetMemoryType(s, Status->MemoryType,N71_65_MEMORY_TYPES);
         if (req[5]==0xff) return ERR_NOTSUPPORTED;
 
         s->Phone.Data.MemoryStatus=Status;
         smprintf(s, "Getting memory status\n");
         return GSM_WaitFor (s, req, 6, 0x03, 4, ID_GetMemoryStatus);
 }
 
 static void N7110_GetSMSLocation(GSM_StateMachine *s, GSM_SMSMessage *sms, unsigned char *folderid, int *location)
 {
@@ -433,192 +436,193 @@ static GSM_Error N7110_GetNextSMSMessage(GSM_StateMachine *s, GSM_MultiSMSMessag
                 error=N7110_GetSMSFolders(s,&Priv->LastSMSFolders);
                 if (error!=ERR_NONE) return error;
         } else {
                 N7110_GetSMSLocation(s, &sms->SMS[0], &folderid, &location);
                 for (i=0;i<Priv->LastSMSFolder.Number;i++) {
                         if (Priv->LastSMSFolder.Location[i]==location) break;
                 }
                 /* Is this last location in this folder ? */
                 if (i==Priv->LastSMSFolder.Number-1) {
                         findnextfolder=true;
                 } else {
                         location=Priv->LastSMSFolder.Location[i+1];
                 }
         }
         if (findnextfolder) {
                 Priv->LastSMSFolder.Number=0;
                 while (Priv->LastSMSFolder.Number==0) {
                                 folderid=folderid+0x08;                 
                         /* Too high folder number */
                         if ((folderid/0x08)>Priv->LastSMSFolders.Number) return ERR_EMPTY;
                         /* Get next folder status */
                         error=N7110_GetSMSFolderStatus(s, folderid);
                         if (error!=ERR_NONE) return error;
                         /* First location from this folder */
                         location=Priv->LastSMSFolder.Location[0];
                 }
         }
         N7110_SetSMSLocation(s, &sms->SMS[0], folderid, location);
 
         return N7110_PrivGetSMSMessage(s, sms);
 }
 
 static int N7110_ReturnBinaryRingtoneLocation(char *model)
 {
         if (strcmp(model,"NSE-5") == 0) return 0x72; /* first 0x72 - 7110 */
         if (strcmp(model,"NPE-3") == 0) return 0x89; /* first 0x89 - 6210 */
         if (strcmp(model,"NHM-3") == 0) return 0x89; /* quess for 6250 */
         return 0;
 }
 
 static GSM_Error N7110_ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 int             tmp,i;
                 GSM_Phone_Data  *Data = &s->Phone.Data;
 
         smprintf(s, "Ringtone received\n");
         switch (msg.Buffer[3]) {
         case 0x23:
                 tmp=0;i=4;
                 while (msg.Buffer[i]!=0 || msg.Buffer[i+1]!=0) {
                         tmp++;
                         i=i+2;
                         if (i>msg.Length) return ERR_EMPTY;
                 }
                 memcpy(Data->Ringtone->Name,msg.Buffer+6,tmp*2);
                 smprintf(s, "Name \"%s\"\n",DecodeUnicodeString(Data->Ringtone->Name));
                 /* Looking for end */
                 i=37;
                 while (true) {
                         if (msg.Buffer[i]==0x07 && msg.Buffer[i+1]==0x0b) {
                                 i=i+2; break;
                         }
                         if (msg.Buffer[i]==0x0e && msg.Buffer[i+1]==0x0b) {
                                 i=i+2; break;
                         }
                         i++;
                         if (i==msg.Length) return ERR_EMPTY;
                         }  
                 /* Copying frame */
                 memcpy(Data->Ringtone->NokiaBinary.Frame,msg.Buffer+37,i-37);
                 Data->Ringtone->NokiaBinary.Length=i-37;
                 return ERR_NONE;
         case 0x24:
                 smprintf(s, "Invalid location. Too high ?\n");
                 return ERR_INVALIDLOCATION;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N7110_GetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone)
 {
         unsigned char req[] = {N7110_FRAME_HEADER, 0x22, 0x00, 0x00};
 
         if (PhoneRingtone) return ERR_NOTSUPPORTED;
         if (Ringtone->Format == 0x00) Ringtone->Format = RING_NOKIABINARY;
 
         switch (Ringtone->Format) {
         case RING_NOTETONE:
                 /* In the future get binary and convert */
                 return ERR_NOTSUPPORTED;
         case RING_NOKIABINARY:
                 req[5]=N7110_ReturnBinaryRingtoneLocation(s->Phone.Data.Model)+Ringtone->Location;
                 s->Phone.Data.Ringtone=Ringtone;
                 smprintf(s, "Getting binary ringtone\n");
                 return GSM_WaitFor (s, req, 6, 0x1f, 4, ID_GetRingtone);
         case RING_MIDI:
+        case RING_MMF:
                 return ERR_NOTSUPPORTED;
         }
         return ERR_NOTSUPPORTED;
 }
 
 static GSM_Error N7110_ReplyGetPictureImageInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 int             i;
                 GSM_Phone_N7110Data*Priv = &s->Phone.Data.Priv.N7110;
 
         smprintf(s, "Received info for Picture Images\n");
         smprintf(s, "Number    : %i\n",msg.Buffer[4]*256+msg.Buffer[5]);
         smprintf(s, "Locations :");
         Priv->LastPictureImageFolder.Number=msg.Buffer[4]*256+msg.Buffer[5];
         for (i=0;i<Priv->LastPictureImageFolder.Number;i++) {
                 Priv->LastPictureImageFolder.Location[i]=msg.Buffer[6+i*2]*256+msg.Buffer[7+i*2];
                 smprintf(s, " %i",Priv->LastPictureImageFolder.Location[i]);
         }
         smprintf(s, "\n");
         return ERR_NONE;
 }
 
 static GSM_Error N7110_GetPictureImageLocation(GSM_StateMachine *s, GSM_Bitmap *Bitmap, unsigned char *folder, int *location)
 {
                 GSM_Phone_N7110Data*Priv = &s->Phone.Data.Priv.N7110;
                 GSM_SMSFolders   folders;
                 GSM_Error       error;
                 int             i, j = 0, count = 0;
                 unsigned char   req[] = {N6110_FRAME_HEADER, 0x96,
                                                  0x00,          /* Folder ID */
                                          0x0f, 0x07};
 
         error=N7110_GetSMSFolders (s, &folders);
         if (error!=ERR_NONE) return error;
 
         for (i=0;i<folders.Number;i++) {
                         req[4] = (i+1) * 0x08;/* SMS folder ID */
                 error = GSM_WaitFor (s, req, 7, 0x14, 4, ID_GetBitmap);
                 if (error!=ERR_NONE) return error;
                 for (j=0;j<Priv->LastPictureImageFolder.Number;j++) {
                         count++;
                         if (count==Bitmap->Location) break;
                 }
                 if (count==Bitmap->Location) break;
         }
         if (count!=Bitmap->Location) return ERR_INVALIDLOCATION;
                 *folder                 = (i+1) * 0x08;/* SMS Folder ID */
                 *location= Priv->LastPictureImageFolder.Location[j];
         return ERR_NONE;
 }
 
 static GSM_Error N7110_GetPictureImage(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
 {
                 unsigned char   folder;
                 int             location;
                 GSM_Error       error;
                 unsigned char   req[] = {N6110_FRAME_HEADER, 0x07,
                                                  0x00,                  /* Folder ID */
                                                  0x00, 0x00,    /* Location */
                                          0x00, 0x64};
 
         error = N7110_GetPictureImageLocation(s, Bitmap, &folder, &location);
         switch (error) {
         case ERR_NONE:
                 req[4] = folder;
                 req[5] = location / 256;
                 req[6] = location % 256;
                 return GSM_WaitFor (s, req, 9, 0x14, 4, ID_GetBitmap);
         default:
                 return error;
         }
 }
 
 static GSM_Error N7110_GetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
 {
                 GSM_MemoryEntry         pbk;
                 GSM_Error       error;
                 unsigned char   OpReq[] = {N6110_FRAME_HEADER, 0x70};
 
                 s->Phone.Data.Bitmap=Bitmap;
         switch (Bitmap->Type) {
         case GSM_StartupLogo:
                 smprintf(s, "Getting startup logo\n");
                 return N71_92_GetPhoneSetting(s, ID_GetBitmap, 0x15);
         case GSM_WelcomeNote_Text:
                 smprintf(s, "Getting welcome note\n");
                 return N71_92_GetPhoneSetting(s, ID_GetBitmap, 0x02);
         case GSM_DealerNote_Text:
                 smprintf(s, "Getting dealer note\n");
                 return N71_92_GetPhoneSetting(s, ID_GetBitmap, 0x17);
         case GSM_CallerGroupLogo:
                 pbk.MemoryType = MEM7110_CG;
                 pbk.Location   = Bitmap->Location;
                 smprintf(s, "Getting caller group logo\n");
                 error=N7110_GetMemory(s,&pbk);
                 if (error==ERR_NONE) NOKIA_GetDefaultCallerGroupName(s,Bitmap);
@@ -1554,171 +1558,172 @@ static GSM_Reply_Function N7110ReplyFunctions[] = {
                 {DCT3_ReplyGetWAPSettings,        "\x3f",0x03,0x16,ID_GetConnectSet  },
                 {DCT3_ReplyGetWAPSettings,        "\x3f",0x03,0x17,ID_GetConnectSet  },
                 {DCT3_ReplySetWAPSettings,        "\x3f",0x03,0x19,ID_SetConnectSet  },
                 {DCT3_ReplySetWAPSettings,        "\x3f",0x03,0x1A,ID_SetConnectSet  },
                 {DCT3_ReplyGetWAPSettings,        "\x3f",0x03,0x1C,ID_GetConnectSet  },
                 {DCT3_ReplyGetWAPSettings,        "\x3f",0x03,0x1D,ID_GetConnectSet  },
                 {DCT3_ReplySetWAPSettings,        "\x3f",0x03,0x1F,ID_SetConnectSet  },
 
                 {N7110_ReplyGetProfileFeature,    "\x39",0x03,0x02,ID_GetProfile  },
                 {N7110_ReplySetProfileFeature,    "\x39",0x03,0x04,ID_SetProfile  },
 
                 {DCT3_ReplyEnableSecurity,        "\x40",0x02,0x64,ID_EnableSecurity  },
         {N61_71_ReplyResetPhoneSettings,  "\x40",0x02,0x65,ID_ResetPhoneSettings  },
                 {DCT3_ReplyGetIMEI,               "\x40",0x02,0x66,ID_GetIMEI     },
                 {DCT3_ReplyDialCommand,                   "\x40",0x02,0x7C,ID_DialVoice           },
                 {DCT3_ReplyDialCommand,                   "\x40",0x02,0x7C,ID_CancelCall  },
                 {DCT3_ReplyDialCommand,                   "\x40",0x02,0x7C,ID_AnswerCall  },
                 {DCT3_ReplyNetmonitor,            "\x40",0x02,0x7E,ID_Netmonitor  },
                 {DCT3_ReplyPlayTone,              "\x40",0x02,0x8F,ID_PlayTone    },
                 {NOKIA_ReplyGetPhoneString,       "\x40",0x02,0xC8,ID_GetHardware  },
                 {NOKIA_ReplyGetPhoneString,       "\x40",0x02,0xC8,ID_GetPPM      },
                 {NOKIA_ReplyGetPhoneString,       "\x40",0x02,0xCA,ID_GetProductCode  },
                 {NOKIA_ReplyGetPhoneString,  "\x40",0x02,0xCC,ID_GetManufactureMonth },
                 {NOKIA_ReplyGetPhoneString,       "\x40",0x02,0xCC,ID_GetOriginalIMEI  },
                 {NoneReply,                       "\x40",0x02,0xFF,ID_IncomingFrame  },
 
                 {N71_92_ReplyPhoneSetting,        "\x7a",0x04,0x02,ID_GetBitmap           },
                 {N71_92_ReplyPhoneSetting,        "\x7a",0x04,0x02,ID_SetBitmap           },
                 {N71_92_ReplyPhoneSetting,        "\x7a",0x04,0x15,ID_GetBitmap           },
                 {N71_92_ReplyPhoneSetting,        "\x7a",0x04,0x15,ID_SetBitmap           },
                 {N71_92_ReplyPhoneSetting,        "\x7a",0x04,0x17,ID_GetBitmap           },
                 {N71_92_ReplyPhoneSetting,        "\x7a",0x04,0x17,ID_SetBitmap           },
 
                 {DCT3DCT4_ReplyGetModelFirmware,  "\xD2",0x02,0x00,ID_GetModel    },
                 {DCT3DCT4_ReplyGetModelFirmware,  "\xD2",0x02,0x00,ID_GetFirmware  },
                 {DCT3_ReplyPressKey,              "\xD2",0x02,0x46,ID_PressKey    },
                 {DCT3_ReplyPressKey,              "\xD2",0x02,0x47,ID_PressKey    },
 
                 {NULL,                            "\x00",0x00,0x00,ID_None        }
 };
 
 GSM_Phone_Functions N7110Phone = {
         "6210|6250|7110|7190",
         N7110ReplyFunctions,
         N7110_Initialise,
         PHONE_Terminate,
         GSM_DispatchMessage,
                 NOTSUPPORTED,                   /*      ShowStartInfo   */
         NOKIA_GetManufacturer,
         DCT3DCT4_GetModel,
         DCT3DCT4_GetFirmware,
         DCT3_GetIMEI,
         DCT3_GetOriginalIMEI,
         DCT3_GetManufactureMonth,
         DCT3_GetProductCode,
         DCT3_GetHardware,
         DCT3_GetPPM,
                 NOTSUPPORTED,                   /*      GetSIMIMSI      */
         N71_92_GetDateTime,
         N71_92_SetDateTime,
         N7110_GetAlarm,
         N7110_SetAlarm,
                 NOTSUPPORTED,                   /*      GetLocale       */
                 NOTSUPPORTED,                   /*      SetLocale       */
         DCT3_PressKey,
         DCT3_Reset,
         N61_71_ResetPhoneSettings,
                 NOTSUPPORTED,                   /*      EnterSecurityCode*/
                 NOTSUPPORTED,                   /*      GetSecurityStatus*/
                 NOTSUPPORTED,                   /*      GetDisplayStatus*/
                 NOTIMPLEMENTED,                         /*      SetAutoNetworkLogin*/
         N71_92_GetBatteryCharge,
         N71_92_GetSignalQuality,
         DCT3_GetNetworkInfo,
                 NOTSUPPORTED,                   /*      GetCategory     */
                 NOTSUPPORTED,                   /*      AddCategory     */
                 NOTSUPPORTED,                   /*      GetCategoryStatus */
         N7110_GetMemoryStatus,
         N7110_GetMemory,
                 NOTIMPLEMENTED,                         /*      GetNextMemory   */
         N7110_SetMemory,
                 NOTIMPLEMENTED,                         /*      AddMemory       */
         N7110_DeleteMemory,
                 NOTIMPLEMENTED,                         /*      DeleteAllMemory         */
         N7110_GetSpeedDial,
                 NOTIMPLEMENTED,                         /*      SetSpeedDial    */
         DCT3_GetSMSC,
         DCT3_SetSMSC,
         N7110_GetSMSStatus,
         N7110_GetSMSMessage,
         N7110_GetNextSMSMessage,
         N7110_SetSMS,
         N7110_AddSMS,
         N7110_DeleteSMS,
         DCT3_SendSMSMessage,
                 NOTSUPPORTED,                   /*      SendSavedSMS    */
+                NOTSUPPORTED,                   /*      SetFastSMSSending*/
         N7110_SetIncomingSMS,
         DCT3_SetIncomingCB,
         N7110_GetSMSFolders,
                 NOTIMPLEMENTED,                         /*      AddSMSFolder    */
                 NOTIMPLEMENTED,                         /*      DeleteSMSFolder         */
         DCT3_DialVoice,
         N7110_AnswerCall,
         DCT3_CancelCall,
                 NOTIMPLEMENTED,                         /*      HoldCall        */
                 NOTIMPLEMENTED,                         /*      UnholdCall      */
                 NOTIMPLEMENTED,                         /*      ConferenceCall          */
                 NOTIMPLEMENTED,                         /*      SplitCall       */
                 NOTIMPLEMENTED,                         /*      TransferCall    */
                 NOTIMPLEMENTED,                         /*      SwitchCall      */
                 NOTSUPPORTED,                   /*      GetCallDivert   */
          N7110_SetCallDivert,
          N7110_CancelAllDiverts,
         N7110_SetIncomingCall,
                 N7110_SetIncomingUSSD,  
         DCT3DCT4_SendDTMF,
         N7110_GetRingtone,
         N7110_SetRingtone,
                 NOTSUPPORTED,                   /*      GetRingtonesInfo*/
                 NOTSUPPORTED,                   /*      DeleteUserRingtones*/
         DCT3_PlayTone,
         DCT3_GetWAPBookmark,
         DCT3_SetWAPBookmark,
         DCT3_DeleteWAPBookmark,
         DCT3_GetWAPSettings,
         DCT3_SetWAPSettings,
                 NOTSUPPORTED,                   /*      GetMMSSettings  */
                 NOTSUPPORTED,                   /*      SetMMSSettings  */
                 NOTSUPPORTED,                   /*      GetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      GetChatSettings         */
                 NOTSUPPORTED,                   /*      SetChatSettings         */
         N7110_GetBitmap,
         N7110_SetBitmap,
                 NOTSUPPORTED,                   /*      GetToDoStatus   */
                 NOTSUPPORTED,                   /*      GetToDo                 */
                 NOTSUPPORTED,                   /*      GetNextToDo     */
                 NOTSUPPORTED,                   /*      SetToDo                 */
                 NOTSUPPORTED,                   /*      AddToDo                 */
                 NOTSUPPORTED,                   /*      DeleteToDo      */
                 NOTSUPPORTED,                   /*      DeleteAllToDo   */
         N7110_GetCalendarStatus,
                 NOTIMPLEMENTED,                         /*      GetCalendar     */
             N7110_GetNextCalendar,
                 NOTIMPLEMENTED,                         /*      SetCalendar     */
         N7110_AddCalendar,
         N71_65_DelCalendar,
                 NOTIMPLEMENTED,                         /*      DeleteAllCalendar*/
                 NOTSUPPORTED,                   /*      GetCalendarSettings*/
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTSUPPORTED,                   /*      GetNote                 */
+                NOTSUPPORTED,                   /*      GetNextNote     */
         N7110_GetProfile,
         N7110_SetProfile,
                 NOTSUPPORTED,                   /*      GetFMStation        */
                 NOTSUPPORTED,                   /*      SetFMStation        */
                 NOTSUPPORTED,                   /*      ClearFMStations       */
                 NOTSUPPORTED,                   /*      GetNextFileFolder*/
                 NOTSUPPORTED,                   /*      GetFilePart     */
                 NOTSUPPORTED,                   /*      AddFile                 */
                 NOTSUPPORTED,                   /*      GetFileSystemStatus*/
                 NOTSUPPORTED,                   /*      DeleteFile      */
                 NOTSUPPORTED,                   /*      AddFolder       */
                 NOTSUPPORTED,                   /*      GetGPRSAccessPoint*/
                 NOTSUPPORTED                    /*      SetGPRSAccessPoint*/
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/dct3/n9210.c b/gammu/emb/common/phone/nokia/dct3/n9210.c
index e82d530..ff71ad3 100644
--- a/gammu/emb/common/phone/nokia/dct3/n9210.c
+++ b/gammu/emb/common/phone/nokia/dct3/n9210.c
@@ -226,171 +226,172 @@ static GSM_Reply_Function N9210ReplyFunctions[] = {
                 {DCT3_ReplySetSMSC,             "\x02",0x03,0x31,ID_SetSMSC     },
                 {DCT3_ReplyGetSMSC,             "\x02",0x03,0x34,ID_GetSMSC     },
                 {DCT3_ReplyGetSMSC,             "\x02",0x03,0x35,ID_GetSMSC     },
 
                 {N61_91_ReplySetOpLogo,                 "\x05",0x03,0x31,ID_SetBitmap   },
                 {N61_91_ReplySetOpLogo,                 "\x05",0x03,0x32,ID_SetBitmap   },
 
                 {DCT3_ReplyGetNetworkInfo,      "\x0A",0x03,0x71,ID_GetNetworkInfo},
                 {DCT3_ReplyGetNetworkInfo,      "\x0A",0x03,0x71,ID_IncomingFrame},
                 {N71_92_ReplyGetSignalQuality,  "\x0A",0x03,0x82,ID_GetSignalQuality},
                 {N9210_ReplySetOpLogo,          "\x0A",0x03,0xA4,ID_SetBitmap   },
                 {N9210_ReplySetOpLogo,          "\x0A",0x03,0xB0,ID_SetBitmap   },
 
                 {N71_92_ReplyGetBatteryCharge,  "\x17",0x03,0x03,ID_GetBatteryCharge},
 
                 {DCT3_ReplySetDateTime,                 "\x19",0x03,0x61,ID_SetDateTime         },
                 {DCT3_ReplyGetDateTime,                 "\x19",0x03,0x63,ID_GetDateTime         },
 
                 {DCT3_ReplyEnableSecurity,      "\x40",0x02,0x64,ID_EnableSecurity},
                 {DCT3_ReplyGetIMEI,             "\x40",0x02,0x66,ID_GetIMEI     },
                 {DCT3_ReplyDialCommand,                 "\x40",0x02,0x7C,ID_DialVoice   },
                 {DCT3_ReplyDialCommand,                 "\x40",0x02,0x7C,ID_CancelCall  },
                 {DCT3_ReplyDialCommand,                 "\x40",0x02,0x7C,ID_AnswerCall  },
                 {DCT3_ReplyNetmonitor,          "\x40",0x02,0x7E,ID_Netmonitor  },
                 {NOKIA_ReplyGetPhoneString,     "\x40",0x02,0xC8,ID_GetHardware         },
                 {NOKIA_ReplyGetPhoneString,     "\x40",0x02,0xC8,ID_GetPPM      },
                 {NOKIA_ReplyGetPhoneString,     "\x40",0x02,0xCA,ID_GetProductCode},
                 {NOKIA_ReplyGetPhoneString,     "\x40",0x02,0xCC,ID_GetManufactureMonth},
                 {NOKIA_ReplyGetPhoneString,     "\x40",0x02,0xCC,ID_GetOriginalIMEI},
 
                 {N71_92_ReplyPhoneSetting,      "\x7a",0x04,0x02,ID_GetBitmap   },
                 {N71_92_ReplyPhoneSetting,      "\x7a",0x04,0x02,ID_SetBitmap   },
                 {N71_92_ReplyPhoneSetting,      "\x7a",0x04,0x15,ID_GetBitmap   },
                 {N71_92_ReplyPhoneSetting,      "\x7a",0x04,0x15,ID_SetBitmap   },
 
                 {DCT3DCT4_ReplyGetModelFirmware,"\xD2",0x02,0x00,ID_GetModel    },
                 {DCT3DCT4_ReplyGetModelFirmware,"\xD2",0x02,0x00,ID_GetFirmware         },
 
                 {NULL,                          "\x00",0x00,0x00,ID_None        }
 };
 
 GSM_Phone_Functions N9210Phone = {
         "9210|9210i",
         N9210ReplyFunctions,
         N9210_Initialise,
         PHONE_Terminate,
         GSM_DispatchMessage,
                 NOTSUPPORTED,                   /*      ShowStartInfo   */
         NOKIA_GetManufacturer,
         DCT3DCT4_GetModel,
         DCT3DCT4_GetFirmware,
         DCT3_GetIMEI,
         DCT3_GetOriginalIMEI,
         DCT3_GetManufactureMonth,
         DCT3_GetProductCode,
         DCT3_GetHardware,
         DCT3_GetPPM,
                 NOTSUPPORTED,                   /*      GetSIMIMSI      */
         N71_92_GetDateTime,
         N71_92_SetDateTime,
                 NOTIMPLEMENTED,                         /*      GetAlarm        */
                 NOTIMPLEMENTED,                         /*      SetAlarm        */
                 NOTSUPPORTED,                   /*      GetLocale       */
                 NOTSUPPORTED,                   /*      SetLocale       */
                 NOTIMPLEMENTED,                         /*      PressKey        */
                 NOTIMPLEMENTED,                         /*      Reset           */
                 NOTIMPLEMENTED,                         /*      ResetPhoneSettings*/
                 NOTSUPPORTED,                   /*      EnterSecurityCode*/
                 NOTSUPPORTED,                   /*      GetSecurityStatus*/
                 NOTSUPPORTED,                   /*      GetDisplayStatus*/
                 NOTIMPLEMENTED,                         /*      SetAutoNetworkLogin*/
         N71_92_GetBatteryCharge,
         N71_92_GetSignalQuality,
         DCT3_GetNetworkInfo,
                 NOTSUPPORTED,                   /*      GetCategory     */
                 NOTSUPPORTED,                   /*      AddCategory     */
                 NOTSUPPORTED,                   /*      GetCategoryStatus */
                 NOTIMPLEMENTED,                         /*      GetMemoryStatus         */
                 NOTIMPLEMENTED,                         /*      GetMemory       */
                 NOTIMPLEMENTED,                         /*      GetNextMemory   */
                 NOTIMPLEMENTED,                         /*      SetMemory       */
                 NOTIMPLEMENTED,                         /*      AddMemory       */
                 NOTIMPLEMENTED,                         /*      DeleteMemory    */
                 NOTIMPLEMENTED,                         /*      DeleteAllMemory         */
                 NOTIMPLEMENTED,                         /*      GetSpeedDial    */
                 NOTIMPLEMENTED,                         /*      SetSpeedDial    */
         DCT3_GetSMSC,
                 DCT3_SetSMSC,                   /*      FIXME: test it  */
                 NOTIMPLEMENTED,                         /*      GetSMSStatus    */
                 NOTIMPLEMENTED,                         /*      GetSMS          */
                 NOTIMPLEMENTED,                         /*      GetNextSMS      */
                 NOTIMPLEMENTED,                         /*      SetSMS          */
                 NOTIMPLEMENTED,                         /*      AddSMS          */
                 NOTIMPLEMENTED,                         /*      DeleteSMS       */
         DCT3_SendSMSMessage,
                 NOTSUPPORTED,                   /*      SendSavedSMS    */
+                NOTSUPPORTED,                   /*      SetFastSMSSending*/
         N9210_SetIncomingSMS,
         DCT3_SetIncomingCB,
                 NOTIMPLEMENTED,                         /*      GetSMSFolders   */
                 NOTSUPPORTED,                   /*      AddSMSFolder    */
                 NOTSUPPORTED,                   /*      DeleteSMSFolder         */
         DCT3_DialVoice,
         N9210_AnswerCall,
         DCT3_CancelCall,
                 NOTSUPPORTED,                   /*      HoldCall        */
                 NOTSUPPORTED,                   /*      UnholdCall      */
                 NOTSUPPORTED,                   /*      ConferenceCall          */
                 NOTSUPPORTED,                   /*      SplitCall       */
                 NOTSUPPORTED,                   /*      TransferCall    */
                 NOTSUPPORTED,                   /*      SwitchCall      */
                 NOTSUPPORTED,                   /*      GetCallDivert   */
                 NOTSUPPORTED,                   /*      SetCallDivert   */
                 NOTSUPPORTED,                   /*      CancelAllDiverts*/
                 NOTSUPPORTED,                   /*      SetIncomingCall         */
                 NOTIMPLEMENTED,         /*      SetIncomingUSSD         */
                 NOTSUPPORTED,                   /*      SendDTMF        */
                 NOTIMPLEMENTED,                         /*      GetRingtone     */
                 NOTIMPLEMENTED,                         /*      SetRingtone     */
                 NOTSUPPORTED,                   /*      GetRingtonesInfo*/
                 NOTSUPPORTED,                   /*      DeleteUserRingtones*/
                 NOTSUPPORTED,                   /*      PlayTone        */
                 NOTIMPLEMENTED,                         /*      GetWAPBookmark  */
                 NOTIMPLEMENTED,                         /*      SetWAPBookmark          */
                 NOTIMPLEMENTED,                 /*      DeleteWAPBookmark */
                 NOTIMPLEMENTED,                         /*      GetWAPSettings          */
                 NOTSUPPORTED,                   /*      SetWAPSettings          */
                 NOTSUPPORTED,                   /*      GetMMSSettings  */
                 NOTSUPPORTED,                   /*      SetMMSSettings  */
                 NOTSUPPORTED,                   /*      GetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      GetChatSettings         */
                 NOTSUPPORTED,                   /*      SetChatSettings         */
         N9210_GetBitmap,
         N9210_SetBitmap,
                 NOTSUPPORTED,                   /*      GetToDoStatus   */
                 NOTSUPPORTED,                   /*      GetToDo                 */
                 NOTSUPPORTED,                   /*      GetNextToDo     */
                 NOTSUPPORTED,                   /*      SetToDo                 */
                 NOTSUPPORTED,                   /*      AddToDo                 */
                 NOTSUPPORTED,                   /*      DeleteToDo      */
                 NOTSUPPORTED,                   /*      DeleteAllToDo   */
                 NOTSUPPORTED,                   /*      GetCalendarStatus*/
                 NOTSUPPORTED,                   /*      GetCalendar     */
                 NOTSUPPORTED,                   /*      GetNextCalendar         */
                 NOTSUPPORTED,                   /*      SetCalendar     */
                 NOTSUPPORTED,                   /*      AddCalendar     */
                 NOTSUPPORTED,                   /*      DeleteCalendar  */
                 NOTSUPPORTED,                   /*      DeleteAllCalendar*/
                 NOTSUPPORTED,                   /*      GetCalendarSettings*/
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTSUPPORTED,                   /*      GetNote                 */
+                NOTSUPPORTED,                   /*      GetNextNote     */
                 NOTIMPLEMENTED,                 /*      GetProfile      */
                 NOTSUPPORTED,                   /*      SetProfile      */
                 NOTSUPPORTED,                   /*      GetFMStation        */
                 NOTSUPPORTED,                   /*      SetFMStation        */
                 NOTSUPPORTED,           /*      ClearFMStations         */
                 NOTSUPPORTED,                   /*      GetNextFileFolder*/
                 NOTSUPPORTED,                   /*      GetFilePart     */
                 NOTSUPPORTED,                   /*      AddFile                 */
                 NOTSUPPORTED,                   /*      GetFileSystemStatus*/
                 NOTSUPPORTED,                   /*      DeleteFile      */
                 NOTSUPPORTED,                   /*      AddFolder       */
                 NOTSUPPORTED,                   /*      GetGPRSAccessPoint*/
                 NOTSUPPORTED                    /*      SetGPRSAccessPoint*/
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/dct4/n3320.c b/gammu/emb/common/phone/nokia/dct4/n3320.c
index 51e6f18..9b1d6cd 100644
--- a/gammu/emb/common/phone/nokia/dct4/n3320.c
+++ b/gammu/emb/common/phone/nokia/dct4/n3320.c
@@ -101,171 +101,172 @@ static GSM_Error N3320_GetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
         s->Phone.Data.DateTime=date_time;
         smprintf(s, "Getting date & time\n");
         return GSM_WaitFor (s, req, 6, 0x19, 4, ID_GetDateTime);
 }
 
 static GSM_Error N3320_GetNextCalendar(GSM_StateMachine *s,  GSM_CalendarEntry *Note, bool start)
 {
         return N71_65_GetNextCalendar1(s,Note,start,&s->Phone.Data.Priv.N3320.LastCalendar,&s->Phone.Data.Priv.N3320.LastCalendarYear,&s->Phone.Data.Priv.N3320.LastCalendarPos);
 }
 
 static GSM_Error N3320_GetCalendarStatus(GSM_StateMachine *s, GSM_CalendarStatus *Status)
 {
         GSM_Error error;
 
         /* Method 1 */
         error=N71_65_GetCalendarInfo1(s, &s->Phone.Data.Priv.N3320.LastCalendar);
         if (error!=ERR_NONE) return error;
         Status->Used = s->Phone.Data.Priv.N3320.LastCalendar.Number;
         return ERR_NONE;
 }
 
 static GSM_Error N3320_ReplyGetCalendarInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         return N71_65_ReplyGetCalendarInfo1(msg, s, &s->Phone.Data.Priv.N3320.LastCalendar);
 }
 
 static GSM_Reply_Function N3320ReplyFunctions[] = {
                 {N3320_ReplyGetMemoryStatus,      "\x03",0x03,0x04,ID_GetMemoryStatus  },
                 {N3320_ReplyGetMemory,            "\x03",0x03,0x08,ID_GetMemory           },
 
                 {N71_65_ReplyGetNextCalendar1,    "\x13",0x03,0x1A,ID_GetCalendarNote  },/*method 1*/
                 {N3320_ReplyGetCalendarInfo,  "\x13",0x03,0x3B,ID_GetCalendarNotesInfo},/*method 1*/
 
                 {N3320_ReplyGetDateTime,          "\x19",0x03,0x0B,ID_GetDateTime  },
 
                 {DCT3DCT4_ReplyGetModelFirmware,  "\xD2",0x02,0x00,ID_GetModel    },
                 {DCT3DCT4_ReplyGetModelFirmware,  "\xD2",0x02,0x00,ID_GetFirmware  },
 
                 {NULL,                            "\x00",0x00,0x00,ID_None        }
 };
 
 GSM_Phone_Functions N3320Phone = {
         "3320",
         N3320ReplyFunctions,
                 NONEFUNCTION,                   /*      Initialise      */
                 NONEFUNCTION,                   /*      Terminate       */
         GSM_DispatchMessage,
                 NOTSUPPORTED,                   /*      ShowStartInfo   */
         NOKIA_GetManufacturer,
         DCT3DCT4_GetModel,
         DCT3DCT4_GetFirmware,
                 NOTSUPPORTED,                   /*      GetIMEI                 */
                 NOTSUPPORTED,                   /*      GetOriginalIMEI         */
                 NOTSUPPORTED,                   /*      GetManufactureMonth*/
                 NOTSUPPORTED,                   /*      GetProductCode  */
                 NOTSUPPORTED,                   /*      GetHardware     */
                 NOTSUPPORTED,                   /*      GetPPM          */
                 NOTSUPPORTED,                   /*      GetSIMIMSI      */
         N3320_GetDateTime,
                 NOTSUPPORTED,                   /*      SetDateTime     */
                 NOTSUPPORTED,                   /*      GetAlarm        */
                 NOTSUPPORTED,                   /*      SetAlarm        */
                 NOTSUPPORTED,                   /*      GetLocale       */
                 NOTSUPPORTED,                   /*      SetLocale       */
                 NOTSUPPORTED,                   /*      PressKey        */
                 NOTSUPPORTED,                   /*      Reset           */
                 NOTSUPPORTED,                   /*      ResetPhoneSettings*/
                 NOTSUPPORTED,                   /*      EnterSecurityCode*/
                 NOTSUPPORTED,                   /*      GetSecurityStatus*/
                 NOTSUPPORTED,                   /*      GetDisplayStatus*/
                 NOTSUPPORTED,                   /*      SetAutoNetworkLogin*/
                 NOTSUPPORTED,                   /*      GetBatteryCharge*/
                 NOTSUPPORTED,                   /*      GetSignalQuality*/
                 NOTSUPPORTED,                   /*      GetNetworkInfo  */
                 NOTSUPPORTED,                   /*      GetCategory     */
                 NOTSUPPORTED,                   /*      AddCategory     */
                 NOTSUPPORTED,                   /*      GetCategoryStatus       */
         N3320_GetMemoryStatus,
         N3320_GetMemory,
                 NOTSUPPORTED,                   /*      GetNextMemory   */
                 NOTSUPPORTED,                   /*      SetMemory       */
                 NOTSUPPORTED,                   /*      AddMemory       */
                 NOTSUPPORTED,                   /*      DeleteMemory    */
                 NOTIMPLEMENTED,                         /*      DeleteAllMemory         */
                 NOTSUPPORTED,                   /*      GetSpeedDial    */
                 NOTSUPPORTED,                   /*      SetSpeedDial    */
                 NOTSUPPORTED,                   /*      GetSMSC                 */
                 NOTSUPPORTED,                   /*      SetSMSC                 */
                 NOTSUPPORTED,                   /*      GetSMSStatus    */
                 NOTSUPPORTED,                   /*      GetSMS          */
                 NOTSUPPORTED,                   /*      GetNextSMS      */
                 NOTSUPPORTED,                   /*      SetSMS          */
                 NOTSUPPORTED,                   /*      AddSMS          */
                 NOTSUPPORTED,                   /*      DeleteSMS       */
                 NOTSUPPORTED,                   /*      SendSMS                 */
                 NOTSUPPORTED,                   /*      SendSavedSMS    */
+                NOTSUPPORTED,                   /*      SetFastSMSSending*/
                 NOTSUPPORTED,                   /*      SetIncomingSMS  */
                 NOTSUPPORTED,                   /*      SetIncomingCB   */
                 NOTSUPPORTED,                   /*      GetSMSFolders   */
                 NOTSUPPORTED,                   /*      AddSMSFolder    */
                 NOTSUPPORTED,                   /*      DeleteSMSFolder         */
                 NOTIMPLEMENTED,                         /*      DialVoice       */
                 NOTIMPLEMENTED,                         /*      AnswerCall      */
                 NOTIMPLEMENTED,                         /*      CancelCall      */
                 NOTIMPLEMENTED,                         /*      HoldCall        */
                 NOTIMPLEMENTED,                         /*      UnholdCall      */
                 NOTIMPLEMENTED,                         /*      ConferenceCall          */
                 NOTIMPLEMENTED,                         /*      SplitCall       */
                 NOTIMPLEMENTED,                         /*      TransferCall    */
                 NOTIMPLEMENTED,                         /*      SwitchCall      */
                 NOTSUPPORTED,                   /*      GetCallDivert   */
                 NOTSUPPORTED,                   /*      SetCallDivert   */
                 NOTSUPPORTED,                   /*      CancelAllDiverts*/
                 NOTIMPLEMENTED,                         /*      SetIncomingCall         */
                 NOTIMPLEMENTED,                         /*      SetIncomingUSSD         */
                 NOTSUPPORTED,                   /*      SendDTMF        */
                 NOTSUPPORTED,                   /*      GetRingtone     */
                 NOTSUPPORTED,                   /*      SetRingtone     */
                 NOTSUPPORTED,                   /*      GetRingtonesInfo*/
                 NOTIMPLEMENTED,                         /*      DeleteUserRingtones*/
                 NOTSUPPORTED,                   /*      PlayTone        */
                 NOTSUPPORTED,                   /*      GetWAPBookmark  */
                 NOTSUPPORTED,                   /*      SetWAPBookmark          */
                 NOTSUPPORTED,                   /*      DeleteWAPBookmark */
                 NOTSUPPORTED,                   /*      GetWAPSettings          */
                 NOTSUPPORTED,                   /*      SetWAPSettings          */
                 NOTSUPPORTED,                   /*      GetMMSSettings  */
                 NOTSUPPORTED,                   /*      SetMMSSettings  */
                 NOTSUPPORTED,                   /*      GetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      GetChatSettings         */
                 NOTSUPPORTED,                   /*      SetChatSettings         */
                 NOTSUPPORTED,                   /*      GetBitmap       */
                 NOTSUPPORTED,                   /*      SetBitmap       */
                 NOTSUPPORTED,                   /*      GetToDoStatus   */
                 NOTSUPPORTED,                   /*      GetToDo                 */
                 NOTSUPPORTED,                   /*      GetNextToDo     */
                 NOTSUPPORTED,                   /*      SetToDo                 */
                 NOTSUPPORTED,                   /*      AddToDo                 */
                 NOTSUPPORTED,                   /*      DeleteToDo      */
                 NOTSUPPORTED,                   /*      DeleteAllToDo   */
         N3320_GetCalendarStatus,
                 NOTIMPLEMENTED,                         /*      GetCalendar     */
             N3320_GetNextCalendar,
                 NOTIMPLEMENTED,                         /*      SetCalendar     */
                 NOTSUPPORTED,                   /*      AddCalendar     */
                 NOTSUPPORTED,                   /*      DeleteCalendar  */
                 NOTIMPLEMENTED,                         /*      DeleteAllCalendar*/
                 NOTSUPPORTED,                   /*      GetCalendarSettings*/
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTSUPPORTED,                   /*      GetNote                 */
+                NOTSUPPORTED,                   /*      GetNextNote     */
                 NOTSUPPORTED,                   /*      GetProfile      */
                 NOTSUPPORTED,                   /*      SetProfile      */
                 NOTSUPPORTED,                   /*      GetFMStation        */
                 NOTSUPPORTED,                   /*      SetFMStation        */
                 NOTSUPPORTED,                   /*      ClearFMStations       */
                 NOTSUPPORTED,                   /*      GetNextFileFolder*/
                 NOTSUPPORTED,                   /*      GetFilePart     */
                 NOTIMPLEMENTED,                         /*      AddFilePart     */
                 NOTSUPPORTED,                   /*      GetFileSystemStatus*/
                 NOTIMPLEMENTED,                         /*      DeleteFile      */
                 NOTIMPLEMENTED,                         /*      AddFolder       */
                 NOTSUPPORTED,                   /*      GetGPRSAccessPoint*/
                 NOTSUPPORTED                    /*      SetGPRSAccessPoint*/
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/dct4/n3650.c b/gammu/emb/common/phone/nokia/dct4/n3650.c
index 2da55bf..d4746a7 100644
--- a/gammu/emb/common/phone/nokia/dct4/n3650.c
+++ b/gammu/emb/common/phone/nokia/dct4/n3650.c
@@ -222,171 +222,172 @@ static GSM_Error N3650_GetNextFileFolder(GSM_StateMachine *s, GSM_File *File, bo
         File->Hidden    = false;
 
         return N3650_GetFolderInfo(s, File);
 }
 
 static GSM_Error N3650_Initialise (GSM_StateMachine *s)
 {
                 GSM_Phone_N3650Data *Priv = &s->Phone.Data.Priv.N3650;
                 int             i;
 
         for (i=0;i<10000;i++) {
                 Priv->Files[i] = malloc(sizeof(GSM_File));
                 if (Priv->Files[i] == NULL) return ERR_MOREMEMORY;
         }
         return ERR_NONE;
 }
 
 static GSM_Error N3650_Terminate(GSM_StateMachine *s)
 {
                 GSM_Phone_N3650Data *Priv = &s->Phone.Data.Priv.N3650;
                 int             i;
 
         for (i=0;i<10000;i++) free(Priv->Files[i]);
         return ERR_NONE;
 }
 
 static GSM_Reply_Function N3650ReplyFunctions[] = {
                 {DCT4_ReplySetPhoneMode,          "\x15",0x03,0x64,ID_Reset       },
                 {DCT4_ReplyGetPhoneMode,          "\x15",0x03,0x65,ID_Reset       },
                 {NoneReply,                       "\x15",0x03,0x68,ID_Reset       },
 
                 {DCT4_ReplyGetIMEI,               "\x1B",0x03,0x01,ID_GetIMEI     },
                 {NOKIA_ReplyGetPhoneString,       "\x1B",0x03,0x08,ID_GetHardware  },
                 {NOKIA_ReplyGetPhoneString,       "\x1B",0x03,0x0C,ID_GetProductCode  },
 
                 {N3650_ReplyGetFolderInfo,        "\x58",0x03,0x0C,ID_GetFile     },
                 {N3650_ReplyGetFilePart,          "\x58",0x03,0x0E,ID_GetFile     },
 
                 {NULL,                            "\x00",0x00,0x00,ID_None        }
 };
 
 GSM_Phone_Functions N3650Phone = {
         "3650|NGAGE",
         N3650ReplyFunctions,
         N3650_Initialise,
         N3650_Terminate,
         GSM_DispatchMessage,
                 NOTSUPPORTED,                   /*      ShowStartInfo   */
         NOKIA_GetManufacturer,
         DCT3DCT4_GetModel,
         DCT3DCT4_GetFirmware,
         DCT4_GetIMEI,
                 NOTSUPPORTED,                   /*      GetOriginalIMEI         */
                 NOTSUPPORTED,                   /*      GetManufactureMonth*/
         DCT4_GetProductCode,
         DCT4_GetHardware,
                 NOTSUPPORTED,                   /*      GetPPM          */
                 NOTSUPPORTED,                   /*      GetSIMIMSI      */
                 NOTSUPPORTED,                   /*      GetDateTime     */
                 NOTSUPPORTED,                   /*      SetDateTime     */
                 NOTSUPPORTED,                   /*      GetAlarm        */
                 NOTSUPPORTED,                   /*      SetAlarm        */
                 NOTSUPPORTED,                   /*      GetLocale       */
                 NOTSUPPORTED,                   /*      SetLocale       */
                 NOTSUPPORTED,                   /*      PressKey        */
         DCT4_Reset,
                 NOTSUPPORTED,                   /*      ResetPhoneSettings*/
                 NOTSUPPORTED,                   /*      EnterSecurityCode*/
                 NOTSUPPORTED,                   /*      GetSecurityStatus*/
                 NOTSUPPORTED,                   /*      GetDisplayStatus*/
                 NOTSUPPORTED,                   /*      SetAutoNetworkLogin*/
                 NOTSUPPORTED,                   /*      GetBatteryCharge*/
                 NOTSUPPORTED,                   /*      GetSignalQuality*/
                 NOTSUPPORTED,                   /*      GetNetworkInfo  */
                 NOTSUPPORTED,                   /*      GetCategory     */
                 NOTSUPPORTED,                   /*      AddCategory     */
                 NOTSUPPORTED,                   /*      GetCategoryStatus       */
                 NOTSUPPORTED,                   /*      GetMemoryStatus         */
                 NOTSUPPORTED,                   /*      GetMemory       */
                 NOTSUPPORTED,                   /*      GetNextMemory   */
                 NOTSUPPORTED,                   /*      SetMemory       */
                 NOTSUPPORTED,                   /*      AddMemory       */
                 NOTSUPPORTED,                   /*      DeleteMemory    */
                 NOTIMPLEMENTED,                         /*      DeleteAllMemory         */
                 NOTSUPPORTED,                   /*      GetSpeedDial    */
                 NOTSUPPORTED,                   /*      SetSpeedDial    */
                 NOTSUPPORTED,                   /*      GetSMSC                 */
                 NOTSUPPORTED,                   /*      SetSMSC                 */
                 NOTSUPPORTED,                   /*      GetSMSStatus    */
                 NOTSUPPORTED,                   /*      GetSMS          */
                 NOTSUPPORTED,                   /*      GetNextSMS      */
                 NOTSUPPORTED,                   /*      SetSMS          */
                 NOTSUPPORTED,                   /*      AddSMS          */
                 NOTSUPPORTED,                   /*      DeleteSMS       */
                 NOTSUPPORTED,                   /*      SendSMS                 */
                 NOTSUPPORTED,                   /*      SendSavedSMS    */
+                NOTSUPPORTED,                   /*      SetFastSMSSending*/
                 NOTSUPPORTED,                   /*      SetIncomingSMS  */
                 NOTSUPPORTED,                   /*      SetIncomingCB   */
                 NOTSUPPORTED,                   /*      GetSMSFolders   */
                 NOTSUPPORTED,                   /*      AddSMSFolder    */
                 NOTSUPPORTED,                   /*      DeleteSMSFolder         */
                 NOTIMPLEMENTED,                         /*      DialVoice       */
                 NOTIMPLEMENTED,                         /*      AnswerCall      */
                 NOTIMPLEMENTED,                         /*      CancelCall      */
                 NOTIMPLEMENTED,                         /*      HoldCall        */
                 NOTIMPLEMENTED,                         /*      UnholdCall      */
                 NOTIMPLEMENTED,                         /*      ConferenceCall          */
                 NOTIMPLEMENTED,                         /*      SplitCall       */
                 NOTIMPLEMENTED,                         /*      TransferCall    */
                 NOTIMPLEMENTED,                         /*      SwitchCall      */
                 NOTSUPPORTED,                   /*      GetCallDivert   */
                 NOTSUPPORTED,                   /*      SetCallDivert   */
                 NOTSUPPORTED,                   /*      CancelAllDiverts*/
                 NOTIMPLEMENTED,                         /*      SetIncomingCall         */
                 NOTIMPLEMENTED,                         /*      SetIncomingUSSD         */
                 NOTSUPPORTED,                   /*      SendDTMF        */
                 NOTSUPPORTED,                   /*      GetRingtone     */
                 NOTSUPPORTED,                   /*      SetRingtone     */
                 NOTSUPPORTED,                   /*      GetRingtonesInfo*/
                 NOTIMPLEMENTED,                         /*      DeleteUserRingtones*/
                 NOTSUPPORTED,                   /*      PlayTone        */
                 NOTSUPPORTED,                   /*      GetWAPBookmark  */
                 NOTSUPPORTED,                   /*      SetWAPBookmark          */
                 NOTSUPPORTED,                   /*      DeleteWAPBookmark */
                 NOTSUPPORTED,                   /*      GetWAPSettings          */
                 NOTSUPPORTED,                   /*      SetWAPSettings          */
                 NOTSUPPORTED,                   /*      GetMMSSettings  */
                 NOTSUPPORTED,                   /*      SetMMSSettings  */
                 NOTSUPPORTED,                   /*      GetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      GetChatSettings         */
                 NOTSUPPORTED,                   /*      SetChatSettings         */
                 NOTSUPPORTED,                   /*      GetBitmap       */
                 NOTSUPPORTED,                   /*      SetBitmap       */
                 NOTSUPPORTED,                   /*      GetToDoStatus   */
                 NOTSUPPORTED,                   /*      GetToDo                 */
                 NOTSUPPORTED,                   /*      GetNextToDo     */
                 NOTSUPPORTED,                   /*      SetToDo                 */
                 NOTSUPPORTED,                   /*      AddToDo                 */
                 NOTSUPPORTED,                   /*      DeleteToDo      */
                 NOTSUPPORTED,                   /*      DeleteAllToDo   */
                 NOTIMPLEMENTED,                         /*      GetCalendarStatus*/
                 NOTIMPLEMENTED,                         /*      GetCalendar     */
                 NOTSUPPORTED,                   /*      GetNextCalendar         */
                 NOTIMPLEMENTED,                         /*      SetCalendar     */
                 NOTSUPPORTED,                   /*      AddCalendar     */
                 NOTSUPPORTED,                   /*      DeleteCalendar  */
                 NOTIMPLEMENTED,                         /*      DeleteAllCalendar*/
                 NOTSUPPORTED,                   /*      GetCalendarSettings*/
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTSUPPORTED,                   /*      GetNote                 */
+                NOTSUPPORTED,                   /*      GetNextNote     */
                 NOTSUPPORTED,                   /*      GetProfile      */
                 NOTSUPPORTED,                   /*      SetProfile      */
                 NOTSUPPORTED,                   /*      GetFMStation        */
                 NOTSUPPORTED,                   /*      SetFMStation        */
                 NOTSUPPORTED,                   /*      ClearFMStations       */
         N3650_GetNextFileFolder,
         N3650_GetFilePart,
                 NOTIMPLEMENTED,                         /*      AddFilePart     */
                 NOTSUPPORTED,                   /*      GetFileSystemStatus*/
                 NOTIMPLEMENTED,                         /*      DeleteFile      */
                 NOTIMPLEMENTED,                         /*      AddFolder       */
                 NOTSUPPORTED,                   /*      GetGPRSAccessPoint*/
                 NOTSUPPORTED                    /*      SetGPRSAccessPoint*/
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/dct4/n6510.c b/gammu/emb/common/phone/nokia/dct4/n6510.c
index 67fe492..2208def 100644
--- a/gammu/emb/common/phone/nokia/dct4/n6510.c
+++ b/gammu/emb/common/phone/nokia/dct4/n6510.c
@@ -1,364 +1,369 @@
 /* (c) 2002-2004 by Marcin Wiacek */
-/* based on some work from Markus Plail, Pawel Kot and Gnokii */
+/* based on some Markus Plail, Pawel Kot work from Gnokii (www.gnokii.org)
+ * (C) 1999-2000 Hugh Blemings & Pavel Janik ml. (C) 2001-2004 Pawel Kot 
+ * GNU GPL version 2 or later
+ */
 /* function for making CRC for filesystem (c) 2003 by Michael Schroeder */
 
 #include "../../../gsmstate.h"
 
 #ifdef GSM_ENABLE_NOKIA6510
 
 #include <string.h>
 #include <time.h>
 
 #include "../../../misc/coding/coding.h"
 #include "../../../gsmcomon.h"
 #include "../../../service/gsmlogo.h"
 #include "../nfunc.h"
 #include "../nfuncold.h"
 #include "../../pfunc.h"
 #include "dct4func.h"
 #include "n6510.h"
 
 static GSM_Error N6510_Initialise (GSM_StateMachine *s)
 {
         s->Phone.Data.Priv.N6510.CalendarIconsNum = 0;
 
         /* Enables various things like incoming SMS, call info, etc. */
         return N71_65_EnableFunctions (s, "\x01\x02\x06\x0A\x14\x17\x39", 7);
 }
 
 static GSM_Error N6510_ReplyGetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Phonebook entry received\n");
         switch (msg.Buffer[6]) {
         case 0x0f:
                 return N71_65_ReplyGetMemoryError(msg.Buffer[10], s);
         default:
                 return N71_65_DecodePhonebook(s, s->Phone.Data.Memory, s->Phone.Data.Bitmap, s->Phone.Data.SpeedDial, msg.Buffer+22, msg.Length-22,false);
         }
         return ERR_UNKNOWN;
 }
 
 static GSM_Error N6510_GetMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x07, 0x01, 0x01, 0x00, 0x01,
                                        0xfe, 0x10, /* memory type */
                                0x00, 0x00, 0x00, 0x00, 
                                        0x00, 0x01, /* location */
                                0x00, 0x00, 0x01};
 
         req[9] = NOKIA_GetMemoryType(s, entry->MemoryType,N71_65_MEMORY_TYPES);
         if (req[9]==0xff) return ERR_NOTSUPPORTED;
 
         if (entry->Location==0x00) return ERR_INVALIDLOCATION;
 
         req[14] = entry->Location / 256;
         req[15] = entry->Location % 256;
 
         s->Phone.Data.Memory=entry;
         smprintf(s, "Getting phonebook entry\n");
         return GSM_WaitFor (s, req, 19, 0x03, 4, ID_GetMemory);
 }
 
 static GSM_Error N6510_ReplyGetMemoryStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
 
         smprintf(s, "Memory status received\n");
         /* Quess ;-)) */
         if (msg.Buffer[14]==0x10) {
                 Data->MemoryStatus->MemoryFree = msg.Buffer[18]*256 + msg.Buffer[19];
         } else {
                 Data->MemoryStatus->MemoryFree = msg.Buffer[17];
         }
         smprintf(s, "Size       : %i\n",Data->MemoryStatus->MemoryFree);
         Data->MemoryStatus->MemoryUsed = msg.Buffer[20]*256 + msg.Buffer[21];
         smprintf(s, "Used       : %i\n",Data->MemoryStatus->MemoryUsed);
         Data->MemoryStatus->MemoryFree -= Data->MemoryStatus->MemoryUsed;
         smprintf(s, "Free       : %i\n",Data->MemoryStatus->MemoryFree);
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetMemoryStatus(GSM_StateMachine *s, GSM_MemoryStatus *Status)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x03, 0x02,
                                        0x00,    /* memory type */
                                0x55, 0x55, 0x55, 0x00};
 
         req[5] = NOKIA_GetMemoryType(s, Status->MemoryType,N71_65_MEMORY_TYPES);
         if (req[5]==0xff) return ERR_NOTSUPPORTED;
 
         s->Phone.Data.MemoryStatus=Status;
         smprintf(s, "Getting memory status\n");
         return GSM_WaitFor (s, req, 10, 0x03, 4, ID_GetMemoryStatus);
 }
 
 static GSM_Error N6510_ReplyGetSMSC(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 int             i, current, j;
                 GSM_Phone_Data  *Data = &s->Phone.Data;
 
         switch (msg.Buffer[4]) {
                 case 0x00:
                         smprintf(s, "SMSC received\n");
                         break;
                 case 0x02:
                         smprintf(s, "SMSC empty\n");
                         return ERR_INVALIDLOCATION;
                 default:
                         smprintf(s, "Unknown SMSC state: %02x\n",msg.Buffer[4]);
                         return ERR_UNKNOWNRESPONSE;
         }
         memset(Data->SMSC,0,sizeof(GSM_SMSC));
                 Data->SMSC->Location = msg.Buffer[8];
                 Data->SMSC->Format = SMS_FORMAT_Text;
         switch (msg.Buffer[10]) {
                         case 0x00: Data->SMSC->Format = SMS_FORMAT_Text; break;
                         case 0x22: Data->SMSC->Format = SMS_FORMAT_Fax; break;
                         case 0x26: Data->SMSC->Format = SMS_FORMAT_Pager;break;
                         case 0x32: Data->SMSC->Format = SMS_FORMAT_Email;break;
         }
                 Data->SMSC->Validity.Format= SMS_Validity_RelativeFormat;
                 Data->SMSC->Validity.Relative= msg.Buffer[12];
+        if (msg.Buffer[12] == 0x00) Data->SMSC->Validity.Relative = SMS_VALID_Max_Time;
+
         current = 14;
         for (i=0;i<msg.Buffer[13];i++) {
                 switch (msg.Buffer[current]) {
                 case 0x81:
                         j=current+4;
                         while (msg.Buffer[j]!=0) {j++;}
                         j=j-33;
                         if (j>GSM_MAX_SMSC_NAME_LENGTH) {
                                 smprintf(s, "Too long name\n");
                                 return ERR_UNKNOWNRESPONSE;
                         }
                         CopyUnicodeString(Data->SMSC->Name,msg.Buffer+current+4);
                         smprintf(s, "   Name \"%s\"\n", DecodeUnicodeString(Data->SMSC->Name));
                         break;
                 case 0x82:
                         switch (msg.Buffer[current+2]) {
                         case 0x01:
                                 GSM_UnpackSemiOctetNumber(Data->SMSC->DefaultNumber,msg.Buffer+current+4,true);
                                 smprintf(s, "   Default number \"%s\"\n", DecodeUnicodeString(Data->SMSC->DefaultNumber));
                                 break;
                         case 0x02:
                                 GSM_UnpackSemiOctetNumber(Data->SMSC->Number,msg.Buffer+current+4,false);
                                 smprintf(s, "   Number \"%s\"\n", DecodeUnicodeString(Data->SMSC->Number));
                                 break;
                         default:
                                 smprintf(s, "Unknown SMSC number: %02x\n",msg.Buffer[current+2]);
                                 return ERR_UNKNOWNRESPONSE;
                         }
                         break;
                 default:
                         smprintf(s, "Unknown SMSC block: %02x\n",msg.Buffer[current]);
                         return ERR_UNKNOWNRESPONSE;
                 }
                 current = current + msg.Buffer[current+1];
         }
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x14,
                                        0x01,    /* location */
                                0x00};
 
         if (smsc->Location==0x00) return ERR_INVALIDLOCATION;
         
         req[4]=smsc->Location;
 
         s->Phone.Data.SMSC=smsc;
         smprintf(s, "Getting SMSC\n");
         return GSM_WaitFor (s, req, 6, 0x02, 4, ID_GetSMSC);
 }
 
 static GSM_Error N6510_ReplySetSMSC(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[4]) {
                 case 0x00:
                         smprintf(s, "SMSC set OK\n");
                         return ERR_NONE;
                 case 0x02:
                         smprintf(s, "Invalid SMSC location\n");
                         return ERR_INVALIDLOCATION;
                 default:
                         smprintf(s, "Unknown SMSC state: %02x\n",msg.Buffer[4]);
                         return ERR_UNKNOWNRESPONSE;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_SetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
 {
                 int     count = 13,i;
                 unsigned char req[256] = {N6110_FRAME_HEADER,
                                     0x12, 0x55, 0x01, 0x0B, 0x34,
                                             0x05,               /* Location */
                                     0x00,
                                             0x00,               /* Format */
                                     0x00,
                                             0xFF};              /* Validity*/
 
         req[8]  = smsc->Location;
         switch (smsc->Format) {
                         case SMS_FORMAT_Text:   req[10] = 0x00;break;
                         case SMS_FORMAT_Fax:    req[10] = 0x22;break;
                         case SMS_FORMAT_Pager:  req[10] = 0x26;break;
                         case SMS_FORMAT_Email:  req[10] = 0x32;break;
         }
         req[12]  = smsc->Validity.Relative;
 
         /* We have now blocks. Number of blocks = 3 */
                 req[count++]      = 0x03;
 
         /* -------------- SMSC number ----------------- */
         /* Block type: number */
                 req[count++]     = 0x82; 
         /* Offset to next block */
                 req[count++]     = 0x1A;
          /* Type of number: SMSC number */
                 req[count++]     = 0x02;
         req[count] = GSM_PackSemiOctetNumber(smsc->Number, req+count+2, false) + 1;
         if (req[count]>18) {
                 smprintf(s, "Too long SMSC number in frame\n");
                 return ERR_UNKNOWN;
         }
         req[count+1] = req[count] - 1;
         count += 23;
 
         /* --------------- Default number ------------- */
         /* Block type: number */
                 req[count++]     = 0x82;
         /* Offset to next block */
                 req[count++]     = 0x14;
          /* Type of number: default number */
                 req[count++]     = 0x01;
         req[count] = GSM_PackSemiOctetNumber(smsc->DefaultNumber, req+count+2, true) + 1;
         if (req[count]*2>12) {
                 smprintf(s, "Too long SMSC number in frame\n");
                 return ERR_UNKNOWN;
         }
         req[count+1] = req[count] - 1;
         count += 17;
 
         /* -------------- SMSC name ------------------- */
                 req[count++]     = 0x81;
                 req[count++]     = UnicodeLength(smsc->Name)*2 + 2 + 4;
                 req[count++]     = UnicodeLength(smsc->Name)*2 + 2;
                 req[count++]     = 0x00;
         /* Can't make CopyUnicodeString(req+count,sms->Name) !!!!
          * with MSVC6 count is changed then
          */
         i = count;
         CopyUnicodeString(req+i,smsc->Name);
         count += UnicodeLength(smsc->Name)*2 + 2;
         
         smprintf(s, "Setting SMSC\n");
         return GSM_WaitFor (s, req, count, 0x02, 4, ID_SetSMSC);
 }
 
 static GSM_Error N6510_ReplyGetNetworkInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 int     current = msg.Buffer[7]+7, tmp;
                 GSM_Phone_Data*Data = &s->Phone.Data;
 #ifdef DEBUG
                 char    name[100];
         GSM_NetworkInfo NetInfo;
 
-        smprintf(s, "Network status: ");
+        smprintf(s, "Network status            : ");
         switch (msg.Buffer[8]) {
                         case 0x00 : smprintf(s, "home network\n");      break;
                         case 0x01 : smprintf(s, "roaming network\n");      break;
                         case 0x04 : smprintf(s, "not logged");            break;
                         case 0x06 : smprintf(s, "SIM card rejected\n");         break;
                         case 0x09 : smprintf(s, "not logged");            break;
                         default  : smprintf(s, "unknown %i!\n",msg.Buffer[8]); break;
         }
         if (msg.Buffer[8]==0x00 || msg.Buffer[8] == 0x01) {
                 NOKIA_DecodeNetworkCode(msg.Buffer + (current + 7),NetInfo.NetworkCode);
                 smprintf(s, "Network code              : %s\n", NetInfo.NetworkCode);
                 smprintf(s, "Network name for Gammu    : %s ",
                         DecodeUnicodeString(GSM_GetNetworkName(NetInfo.NetworkCode)));
                 smprintf(s, "(%s)\n",DecodeUnicodeString(GSM_GetCountryName(NetInfo.NetworkCode)));
 
                         sprintf(NetInfo.LAC,"%02x%02x", msg.Buffer[current+1], msg.Buffer[current+2]);
                 smprintf(s, "LAC                       : %s\n", NetInfo.LAC);
 
                 sprintf(NetInfo.CID, "%02x%02x", msg.Buffer[current+5], msg.Buffer[current+6]);
                 smprintf(s, "CID                       : %s\n", NetInfo.CID);
 
                 tmp = 10;
                 NOKIA_GetUnicodeString(s, &tmp, msg.Buffer,name,true);
                 smprintf(s, "Network name for phone    : %s\n",DecodeUnicodeString(name));
         }
 #endif
         if (Data->RequestID==ID_GetNetworkInfo) {
                 Data->NetworkInfo->NetworkName[0] = 0x00;
                 Data->NetworkInfo->NetworkName[1] = 0x00;
                         Data->NetworkInfo->State   = 0;
                 switch (msg.Buffer[8]) {
                                 case 0x00: Data->NetworkInfo->State = GSM_HomeNetwork;  break;
                                 case 0x01: Data->NetworkInfo->State = GSM_RoamingNetwork;break;
                         case 0x04:
                         case 0x06:
                                 case 0x09: Data->NetworkInfo->State = GSM_NoNetwork;    break;
                 }
                 if (Data->NetworkInfo->State == GSM_HomeNetwork || Data->NetworkInfo->State == GSM_RoamingNetwork) {
                         tmp = 10;
                         NOKIA_GetUnicodeString(s, &tmp, msg.Buffer,Data->NetworkInfo->NetworkName,true);
                                 sprintf(Data->NetworkInfo->LAC,         "%02x%02x", msg.Buffer[current+1], msg.Buffer[current+2]);
                                 sprintf(Data->NetworkInfo->CID, "%02x%02x", msg.Buffer[current+5], msg.Buffer[current+6]);
                         NOKIA_DecodeNetworkCode(msg.Buffer + (current+7),Data->NetworkInfo->NetworkCode);
                 }
         }
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetNetworkInfo(GSM_StateMachine *s, GSM_NetworkInfo *netinfo)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x00, 0x00};
 
         s->Phone.Data.NetworkInfo=netinfo;
         smprintf(s, "Getting network info\n");
         return GSM_WaitFor (s, req, 5, 0x0a, 4, ID_GetNetworkInfo);
 }
 
 static GSM_Error N6510_EncodeSMSFrame(GSM_StateMachine *s, GSM_SMSMessage *sms, unsigned char *req, GSM_SMSMessageLayout *Layout, int *length)
 {
                 int             start, count = 0, pos1, pos2, pos3, pos4, pos5;
                 GSM_Error       error;
 
         memset(Layout,255,sizeof(GSM_SMSMessageLayout));
 
                 start            = *length;
 
                 req[count++]     = 0x01;
         if (sms->PDU != SMS_Deliver) {
                         req[count++]  = 0x02;
         } else {
                         req[count++]  = 0x00;
         }
 
                 pos1               = count; count++;
         /* firstbyte set in SMS Layout */
                 Layout->firstbyte  = count; count++;
         if (sms->PDU != SMS_Deliver) {
                         Layout->TPMR  = count; count++;
 
                         Layout->TPPID = count; count++;
 
                 /* TP.DCS set in SMS layout */
                         Layout->TPDCS  = count; count++;
                         req[count++]  = 0x00;
         } else {
                         Layout->TPPID  = count; count++;
                 /* TP.DCS set in SMS layout */
                         Layout->TPDCS  = count; count++;
                 Layout->DateTime = count; count += 7;
                         req[count++]  = 0x55;
                         req[count++]  = 0x55;
                         req[count++]  = 0x55;
         }
 
         /* We have now blocks. Number of blocks = 3 or 4 */
         if (sms->PDU != SMS_Deliver) {
@@ -892,197 +897,197 @@ static GSM_Error N6510_GetBitmap(GSM_StateMachine *s, GSM_Bitmap *Bitmap)
                 GSM_MemoryEntrypbk;
                 GSM_Error       error;
                 int             Location;
 
                 s->Phone.Data.Bitmap=Bitmap;
         switch (Bitmap->Type) {
         case GSM_StartupLogo:
                 Bitmap->BitmapWidth  = 96;
                 Bitmap->BitmapHeight = 65;
                 GSM_ClearBitmap(Bitmap);
                 smprintf(s, "Getting startup logo\n");
                 return GSM_WaitFor (s, reqStartup, 5, 0x7A, 4, ID_GetBitmap);
         case GSM_DealerNote_Text:
                 reqNote[4] = 0x10;
                 smprintf(s, "Getting dealer note\n");
                 return GSM_WaitFor (s, reqNote, 6, 0x7A, 4, ID_GetBitmap);
         case GSM_WelcomeNote_Text:
                 smprintf(s, "Getting welcome note\n");
                 return GSM_WaitFor (s, reqNote, 6, 0x7A, 4, ID_GetBitmap);
         case GSM_CallerGroupLogo:
                 if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_PBK35)) return ERR_NOTSUPPORTED;
                         Bitmap->BitmapWidth   = 72;
                         Bitmap->BitmapHeight  = 14;
                 GSM_ClearBitmap(Bitmap);
                         pbk.MemoryType= MEM7110_CG;
                         pbk.Location= Bitmap->Location;
                 smprintf(s, "Getting caller group logo\n");
                 error=N6510_GetMemory(s,&pbk);
                 if (error==ERR_NONE) NOKIA_GetDefaultCallerGroupName(s, Bitmap);
                 return error;
         case GSM_OperatorLogo:
                 smprintf(s, "Getting operator logo\n");
                 return GSM_WaitFor (s, reqOp, 9, 0x0A, 4, ID_GetBitmap);
         case GSM_PictureImage:
                 return N6510_GetPictureImage(s, Bitmap, &Location);
         default:
                 break;
         }
         return ERR_NOTSUPPORTED;
 }
 
 static GSM_Error N6510_ReplyGetIncSignalQuality(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Network level changed to: %i\n",msg.Buffer[4]);
         return ERR_NONE;
 }
 
 static GSM_Error N6510_ReplyGetSignalQuality(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
 
         smprintf(s, "Network level received: %i\n",msg.Buffer[8]);
                 Data->SignalQuality->SignalStrength = -1;
                 Data->SignalQuality->SignalPercent = ((int)msg.Buffer[8]);
                 Data->SignalQuality->BitErrorRate = -1;
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetSignalQuality(GSM_StateMachine *s, GSM_SignalQuality *sig)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x0B, 0x00, 0x02, 0x00, 0x00, 0x00};
 
         s->Phone.Data.SignalQuality = sig;
         smprintf(s, "Getting network level\n");
         return GSM_WaitFor (s, req, 9, 0x0a, 4, ID_GetSignalQuality);
 }
 
 static GSM_Error N6510_ReplyGetBatteryCharge(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
 
         smprintf(s, "Battery level received: %i\n",msg.Buffer[9]*100/7);
                 Data->BatteryCharge->BatteryPercent = ((int)(msg.Buffer[9]*100/7));
                 Data->BatteryCharge->ChargeState = 0;
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetBatteryCharge(GSM_StateMachine *s, GSM_BatteryCharge *bat)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x0A, 0x02, 0x00};
 
         s->Phone.Data.BatteryCharge = bat;
         smprintf(s, "Getting battery level\n");
         return GSM_WaitFor (s, req, 6, 0x17, 4, ID_GetBatteryCharge);
 }
 
 static GSM_Error N6510_ReplyGetWAPBookmark(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         return DCT3DCT4_ReplyGetWAPBookmark (msg, s, true);
 }
 
 static GSM_Error N6510_ReplyGetOperatorLogo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
 
         smprintf(s, "Operator logo received\n");
+        if (msg.Length == 18) return ERR_EMPTY;
         NOKIA_DecodeNetworkCode(msg.Buffer+12,Data->Bitmap->NetworkCode);
         smprintf(s, "Network code %s\n",Data->Bitmap->NetworkCode);
                 Data->Bitmap->BitmapWidth= msg.Buffer[20];
                 Data->Bitmap->BitmapHeight= msg.Buffer[21];
-        if (msg.Length == 18) return ERR_EMPTY;
         PHONE_DecodeBitmap(GSM_Nokia6510OperatorLogo,msg.Buffer+26,Data->Bitmap);
         return ERR_NONE;
 }
 
 GSM_Error N6510_ReplyDeleteMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Phonebook entry deleted\n");
         return ERR_NONE;
 }
 
 GSM_Error N6510_DeleteMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
         unsigned char req[] = {N7110_FRAME_HEADER, 0x0f, 0x55, 0x01,
                                0x04, 0x55, 0x00, 0x10, 0xFF, 0x02,
                                        0x00, 0x01,              /* location*/
                                0x00, 0x00, 0x00, 0x00,
                                        0x05,                    /* memory type*/
                                0x55, 0x55, 0x55};
 
         req[12] = entry->Location / 256;
         req[13] = entry->Location % 256;
 
         req[18] = NOKIA_GetMemoryType(s, entry->MemoryType,N71_65_MEMORY_TYPES);
         if (req[18]==0xff) return ERR_NOTSUPPORTED;
 
         smprintf(s, "Deleting phonebook entry\n");
         return GSM_WaitFor (s, req, 22, 0x03, 4, ID_SetMemory);
 }
 
 static GSM_Error N6510_SetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
 {
                 int     count = 22, blocks;
                 unsigned char req[500] = {
                 N7110_FRAME_HEADER, 0x0b, 0x00, 0x01, 0x01, 0x00, 0x00, 0x10,
                         0x02, 0x00,     /* memory type */
                         0x00, 0x00,     /* location */
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
         if (entry->Location == 0) return ERR_NOTSUPPORTED;
 
         req[11] = NOKIA_GetMemoryType(s, entry->MemoryType,N71_65_MEMORY_TYPES);
         if (req[11]==0xff) return ERR_NOTSUPPORTED;
 
         req[12] = entry->Location / 256;
         req[13] = entry->Location % 256;
 
         count = count + N71_65_EncodePhonebookFrame(s, req+22, *entry, &blocks, true, IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_VOICETAGS));
         req[21] = blocks;
 
         smprintf(s, "Writing phonebook entry\n");
         return GSM_WaitFor (s, req, count, 0x03, 4, ID_SetMemory);
 }
 
 static GSM_Error N6510_ReplySetOperatorLogo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Operator logo set OK\n");
         return ERR_NONE;
 }
 
 static GSM_Error N6510_SetCallerLogo(GSM_StateMachine *s, GSM_Bitmap *bitmap)
 {
                 char    string[500];
                 int     block=0, i, Width, Height;
                 unsigned int count = 22;
                 unsigned char req[500] = {
                 N6110_FRAME_HEADER, 0x0b, 0x00, 0x01, 0x01, 0x00, 0x00, 0x10,
                         0xfe, 0x10,     /* memory type */
                         0x00, 0x00,     /* location */
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
         req[13] = bitmap->Location;
 
         /* Enabling/disabling logo */
         string[0] = bitmap->BitmapEnabled?1:0;
         string[1] = 0;
         count += N71_65_PackPBKBlock(s, N7110_PBK_LOGOON, 2, block++, string, req + count);
 
         /* Ringtone */
         if (!bitmap->DefaultRingtone) {
                 if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_PBKTONEGAL)) {
                 } else {
                         string[0] = 0x00; 
                         string[1] = 0x00;
                         string[2] = bitmap->RingtoneID;
                         count += N71_65_PackPBKBlock(s, N7110_PBK_RINGTONE_ID, 3, block++, string, req + count);
                         count --;
                         req[count-5] = 8;
                 }
         }
 
         /* Number of group */
         string[0] = bitmap->Location;
         string[1] = 0;
         count += N71_65_PackPBKBlock(s, N7110_PBK_GROUP, 2, block++, string, req + count);
 
         /* Name */
@@ -1672,193 +1677,194 @@ static GSM_Error N6510_GetConnectionSettings(GSM_StateMachine *s, GSM_MultiWAPSe
 
         switch (Type) {
         case N6510_MMS_SETTINGS:
                 smprintf(s, "Getting MMS settings\n");
                 Priv->BearerNumber = 1;
                 break;
         case N6510_WAP_SETTINGS:
                 smprintf(s, "Getting WAP settings\n");
                 Priv->BearerNumber = 2;
                 break;
         case N6510_SYNCML_SETTINGS:
                 smprintf(s, "Getting SyncML settings\n");
                 Priv->BearerNumber = 2;
                 break;
         case N6510_CHAT_SETTINGS:
                 smprintf(s, "Getting Chat settings\n");
                 Priv->BearerNumber = 1;
                 break;
         }
 
         error=GSM_WaitFor (s, req, 5, 0x3f, 4, ID_GetConnectSet);
         if (error != ERR_NONE) {
                 if (error == ERR_INVALIDLOCATION || error == ERR_INSIDEPHONEMENU) {
                         DCT3DCT4_DisableConnectionFunctions(s);
                 }
                 return error;
         }
 
         error=DCT3DCT4_GetActiveConnectSet(s);
         if (error != ERR_NONE) return error;
 
         return DCT3DCT4_DisableConnectionFunctions(s);
 }
 
 static GSM_Error N6510_GetWAPSettings(GSM_StateMachine *s, GSM_MultiWAPSettings *settings)
 {
         return N6510_GetConnectionSettings(s, settings, N6510_WAP_SETTINGS);
 }
 
 static GSM_Error N6510_GetMMSSettings(GSM_StateMachine *s, GSM_MultiWAPSettings *settings)
 {
         return N6510_GetConnectionSettings(s, settings, N6510_MMS_SETTINGS);
 }
 
 static GSM_Error N6510_ReplyGetSyncMLSettings(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_SyncMLSettings *Sett = s->Phone.Data.SyncMLSettings;
 
         smprintf(s, "SyncML settings received OK\n");
         CopyUnicodeString(Sett->User,msg.Buffer+18);
         CopyUnicodeString(Sett->Password,msg.Buffer+86);
         CopyUnicodeString(Sett->PhonebookDataBase,msg.Buffer+130);
         CopyUnicodeString(Sett->CalendarDataBase,msg.Buffer+234);
         CopyUnicodeString(Sett->Server,msg.Buffer+338);
 
         Sett->SyncPhonebook = false;
         Sett->SyncCalendar  = false;
         if ((msg.Buffer[598] & 0x02)==0x02) Sett->SyncCalendar = true;
         if ((msg.Buffer[598] & 0x01)==0x01) Sett->SyncPhonebook = true;
 
         return ERR_NONE;
 }
 
 static GSM_Error N6510_ReplyGetSyncMLName(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_SyncMLSettings *Sett = s->Phone.Data.SyncMLSettings;
 
         smprintf(s, "SyncML names received OK\n");
 
         CopyUnicodeString(Sett->Name,msg.Buffer+18);
 
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetSyncMLSettings(GSM_StateMachine *s, GSM_SyncMLSettings *settings)
 {
                 GSM_Error error;
         //      unsigned char NameReq[] = {N6110_FRAME_HEADER, 0x05,
         //                       0x00, 0x00, 0x00, 0x31, 0x00,
         //                       0x06, 0x00, 0x00, 0x00, 0xDE, 0x00, 0x00};
         //      unsigned char GetActive[] = {N6110_FRAME_HEADER, 0x05,
         //                       0x00, 0x00, 0x00, 0x31, 0x00,
         //                       0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00};
                 unsigned char req[] = {N6110_FRAME_HEADER, 0x05,
                                  0x00, 0x00, 0x00, 0x31, 0x00, 
                                  0x01, //location
                                  0x00, 0x00, 0x02, 0x46, 0x00, 0x00};
 
         settings->Connection.Location = settings->Location;
         error = N6510_GetConnectionSettings(s, &settings->Connection, N6510_SYNCML_SETTINGS);
         if (error != ERR_NONE) return error;
 
         settings->Active = settings->Connection.Active;
 
         settings->Name[0] = 0;
         settings->Name[1] = 0;
-        //s->Phone.Data.SyncMLSettings  = settings;
+        s->Phone.Data.SyncMLSettings  = settings;
+
         //smprintf(s, "Getting SyncML settings name\n");
         //error = GSM_WaitFor (s, NameReq, 16, 0x43, 4, ID_GetSyncMLName);
         //if (error != ERR_NONE) return error;
 
         req[9] = settings->Location - 1;
         smprintf(s, "Getting additional SyncML settings\n");
         return GSM_WaitFor (s, req, 16, 0x43, 4, ID_GetSyncMLSettings);
 }
 
 static GSM_Error N6510_ReplyGetChatSettings(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_ChatSettings *Sett = s->Phone.Data.ChatSettings;
                 int             i;
 
                 Sett->Name[0]   = 0;
                 Sett->Name[1]   = 0;
         Sett->HomePage[0] = 0;
         Sett->HomePage[1] = 0;
                 Sett->User[0]   = 0;
                 Sett->User[1]   = 0;
         Sett->Password[0] = 0;
         Sett->Password[1] = 0;
 
         switch(msg.Buffer[3]) {
         case 0x3B:
                 smprintf(s, "Chat settings received OK\n");
                 memcpy(Sett->Name,msg.Buffer+20,msg.Buffer[12]*2);
                         Sett->Name[msg.Buffer[12]*2]    = 0;
                         Sett->Name[msg.Buffer[12]*2+1]    = 0;
                 memcpy(Sett->HomePage,msg.Buffer+20+msg.Buffer[12]*2,msg.Buffer[15]*2);
                 Sett->HomePage[msg.Buffer[15]*2]   = 0;
                 Sett->HomePage[msg.Buffer[15]*2+1] = 0;
                 i = msg.Buffer[12]*2 + msg.Buffer[15]*2 + 29;
                 memcpy(Sett->User,msg.Buffer+i+3,msg.Buffer[i]*2);
                 Sett->User[msg.Buffer[i]*2]   = 0;
                 Sett->User[msg.Buffer[i]*2+1] = 0;
                 memcpy(Sett->Password,msg.Buffer+i+3+msg.Buffer[i]*2,msg.Buffer[i+1]*2);
                 Sett->Password[msg.Buffer[i+1]*2]   = 0;
                         Sett->Password[msg.Buffer[i+1]*2+1] = 0;        
                 return ERR_NONE;
         case 0x3C:
                 smprintf(s, "Empty chat settings received\n");
                 return ERR_NONE;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_GetChatSettings(GSM_StateMachine *s, GSM_ChatSettings *settings)
 {
                 GSM_Error error;
                 unsigned char req[] = {N6110_FRAME_HEADER, 0x3a,
                                          0x09,          // location
                                  0x01, 0x0e};
 
         settings->Connection.Location = settings->Location;
         error = N6510_GetConnectionSettings(s, &settings->Connection, N6510_CHAT_SETTINGS);
         if (error != ERR_NONE) return error;
 
         settings->Active = settings->Connection.Active;
 
         s->Phone.Data.ChatSettings  = settings;
                 req[4]                      = settings->Location - 1;
         smprintf(s, "Getting additional Chat settings\n");
         return GSM_WaitFor (s, req, 7, 0x3f, 4, ID_GetChatSettings);
 }
 
 static GSM_Error N6510_ReplySetConnectionSettings(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
         case 0x19:
                 smprintf(s, "Connection settings cleaned\n");
                 return ERR_NONE;
         case 0x1a:
                 smprintf(s, "Connection settings setting status\n");
                 switch (msg.Buffer[4]) {
                 case 0x01:
                         smprintf(s, "Security error. Inside phone settings menu\n");
                         return ERR_INSIDEPHONEMENU;
                 case 0x03:
                         smprintf(s, "Invalid location\n");
                         return ERR_INVALIDLOCATION;
                 case 0x05:
                         smprintf(s, "Written OK\n");
                         return ERR_NONE;
                 default:
                         smprintf(s, "ERROR: unknown %i\n",msg.Buffer[4]);
                         return ERR_UNKNOWNRESPONSE;
                 }
         case 0x28:
         case 0x2B:
                 smprintf(s, "Set OK\n");
                 return ERR_NONE;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
@@ -2190,193 +2196,193 @@ static GSM_Error N6510_ReplyGetSMSStatus(GSM_Protocol_Message msg, GSM_StateMach
                 case 0x00:
                         smprintf(s, "Max. in phone memory   : %i\n",msg.Buffer[10]*256+msg.Buffer[11]);
                         smprintf(s, "Used in phone memory   : %i\n",msg.Buffer[12]*256+msg.Buffer[13]);
                         smprintf(s, "Unread in phone memory : %i\n",msg.Buffer[14]*256+msg.Buffer[15]);
                         smprintf(s, "Max. in SIM            : %i\n",msg.Buffer[22]*256+msg.Buffer[23]);
                         smprintf(s, "Used in SIM            : %i\n",msg.Buffer[24]*256+msg.Buffer[25]);
                         smprintf(s, "Unread in SIM          : %i\n",msg.Buffer[26]*256+msg.Buffer[27]);
                                 Data->SMSStatus->PhoneSize= msg.Buffer[10]*256+msg.Buffer[11];
                                 Data->SMSStatus->PhoneUsed= msg.Buffer[12]*256+msg.Buffer[13];
                                 Data->SMSStatus->PhoneUnRead = msg.Buffer[14]*256+msg.Buffer[15];
                                 Data->SMSStatus->SIMSize= msg.Buffer[22]*256+msg.Buffer[23];
                                 Data->SMSStatus->SIMUsed = msg.Buffer[24]*256+msg.Buffer[25];
                                 Data->SMSStatus->SIMUnRead = msg.Buffer[26]*256+msg.Buffer[27];
                         return ERR_NONE;
                 case 0x0f:
                         smprintf(s, "No PIN\n");
                         return ERR_SECURITYERROR;
                 default:
                         smprintf(s, "ERROR: unknown %i\n",msg.Buffer[4]);
                         return ERR_UNKNOWNRESPONSE;
                 }
         case 0x1a:
                 smprintf(s, "Wait a moment. Phone is during power on and busy now\n");
                         return ERR_SECURITYERROR;       
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_GetSMSStatus(GSM_StateMachine *s, GSM_SMSMemoryStatus *status)
 {
                 GSM_Error       error;
                 GSM_Phone_N6510Data*Priv = &s->Phone.Data.Priv.N6510;
         unsigned char req[] = {N6110_FRAME_HEADER, 0x08, 0x00, 0x00};
 
         s->Phone.Data.SMSStatus=status;
         smprintf(s, "Getting SMS status\n");
         error = GSM_WaitFor (s, req, 6, 0x14, 2, ID_GetSMSStatus);
         if (error != ERR_NONE) return error;
 
         /* DCT4 family doesn't show in frame with SMS status info
          * about Templates. We get separately info about this SMS folder.
          */
         error = N6510_GetSMSFolderStatus(s, 0x06);
         if (error != ERR_NONE) return error;
         status->TemplatesUsed = Priv->LastSMSFolder.Number;
 
         return error;
 }
 
 static GSM_Error N6510_ReplyDeleteSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
                 case 0x05:
                         smprintf(s, "SMS deleted OK\n");
                         return ERR_NONE;
                 case 0x06:
                         switch (msg.Buffer[4]) {
                                 case 0x02:
                                         smprintf(s, "Invalid location\n");
                                         return ERR_INVALIDLOCATION;
                                 default:
                                         smprintf(s, "Unknown error: %02x\n",msg.Buffer[4]);
                                         return ERR_UNKNOWNRESPONSE;
                         }
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_DeleteSMSMessage(GSM_StateMachine *s, GSM_SMSMessage *sms)
 {
                 unsigned char   folderid;
                 int             location;
                 unsigned char   req[] = {N6110_FRAME_HEADER, 0x04,
                                                  0x01,          /* 0x01=SM, 0x02=ME */
                                                  0x00,          /* FolderID */
                                                  0x00, 0x02, /* Location */
                                          0x0F, 0x55};
 
         N6510_GetSMSLocation(s, sms, &folderid, &location);
 
         switch (folderid) {
                         case 0x01: req[5] = 0x02;                        break; /* INBOX SIM */
                         case 0x02: req[5] = 0x03;                        break; /* OUTBOX SIM */
                         default          : req[5] = folderid - 1; req[4] = 0x02; break; /* ME folders*/
         }
         req[6]=location / 256;
         req[7]=location;
 
         smprintf(s, "Deleting sms\n");
         return GSM_WaitFor (s, req, 10, 0x14, 4, ID_DeleteSMSMessage);
 }
 
 static GSM_Error N6510_ReplySendSMSMessage(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[8]) {
         case 0x00:
-                smprintf(s, "SMS sent OK, TPMR for sent sms is %02x\n",msg.Buffer[10]);
+                smprintf(s, "SMS sent OK, TPMR for sent sms is %d\n",msg.Buffer[10]);
                 if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,0,msg.Buffer[10]);
                 return ERR_NONE;
         default:
                 smprintf(s, "SMS not sent OK, error code probably %i\n",msg.Buffer[8]);
                 if (s->User.SendSMSStatus!=NULL) s->User.SendSMSStatus(s->CurrentConfig->Device,msg.Buffer[8],msg.Buffer[10]);
                 return ERR_NONE;
         }
 }
 
 static GSM_Error N6510_SendSMSMessage(GSM_StateMachine *s, GSM_SMSMessage *sms)
 {
                 int             length = 11;
                 GSM_Error       error;
                 GSM_SMSMessageLayout Layout;
         unsigned char req [300] = {
                 N6110_FRAME_HEADER, 0x02, 0x00, 0x00, 0x00, 0x55, 0x55};
 
         if (sms->PDU == SMS_Deliver) sms->PDU = SMS_Submit;
         memset(req+9,0x00,sizeof(req) - 9);
         error=N6510_EncodeSMSFrame(s, sms, req + 9, &Layout, &length);
         if (error != ERR_NONE) return error;
 
         smprintf(s, "Sending sms\n");
         return s->Protocol.Functions->WriteMessage(s, req, length + 9, 0x02);
 }
 
 static GSM_Error N6510_ReplyGetSecurityStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_Phone_Data *Data = &s->Phone.Data;
 
         smprintf(s, "Security Code status received: ");
         switch (msg.Buffer[4]) {
                 case 0x01 : smprintf(s, "waiting for Security Code.\n"); *Data->SecurityStatus = SEC_SecurityCode;break;
         case 0x07 :
                 case 0x02 : smprintf(s, "waiting for PIN.\n");           *Data->SecurityStatus = SEC_Pin;       break;
                 case 0x03 : smprintf(s, "waiting for PUK.\n");           *Data->SecurityStatus = SEC_Puk;       break;
                 case 0x05 : smprintf(s, "PIN ok, SIM ok\n");             *Data->SecurityStatus = SEC_None;      break;
                 case 0x06 : smprintf(s, "No input status\n");            *Data->SecurityStatus = SEC_None;      break;
                 case 0x16 : smprintf(s, "No SIM card\n");                *Data->SecurityStatus = SEC_None;      break;
                 case 0x1A : smprintf(s, "SIM card rejected!\n");         *Data->SecurityStatus = SEC_None;      break;
         default   : smprintf(s, "ERROR: unknown %i\n",msg.Buffer[4]);
                     return ERR_UNKNOWNRESPONSE;
         }
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetSecurityStatus(GSM_StateMachine *s, GSM_SecurityCodeType *Status)
 {
         unsigned char req[5] = {N6110_FRAME_HEADER, 0x11, 0x00};
 
         s->Phone.Data.SecurityStatus=Status;
         smprintf(s, "Getting security code status\n");
         return GSM_WaitFor (s, req, 5, 0x08, 2, ID_GetSecurityStatus);
 }
 
 static GSM_Error N6510_ReplyEnterSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
         case 0x08:
                 smprintf(s, "Security code OK\n");
                 return ERR_NONE;
         case 0x09:
                 switch (msg.Buffer[4]) {
                 case 0x06:
                         smprintf(s, "Wrong PIN\n");
                         return ERR_SECURITYERROR;
                 case 0x09:
                         smprintf(s, "Wrong PUK\n");
                         return ERR_SECURITYERROR;
                 default:
                         smprintf(s, "ERROR: unknown %i\n",msg.Buffer[4]);
                 }
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_EnterSecurityCode(GSM_StateMachine *s, GSM_SecurityCode Code)
 {
                 int     len = 0;
                 unsigned char req[15] = {N6110_FRAME_HEADER, 0x07,
                                            0x00};/* Code type */
 
         switch (Code.Type) {
                         case SEC_Pin: req[4] = 0x02; break;
                         case SEC_Puk: req[4] = 0x03; break;/* FIXME */
                         default         : return ERR_NOTSUPPORTED;
         }                            
 
         len = strlen(Code.Code);
         memcpy(req+5,Code.Code,len);
         req[5+len]=0x00;
 
         smprintf(s, "Entering security code\n");
         return GSM_WaitFor (s, req, 6+len, 0x08, 4, ID_EnterSecurityCode);
 }
 
@@ -2677,192 +2683,193 @@ static GSM_Error N6510_ReplyGetRingtonesInfo(GSM_Protocol_Message msg, GSM_State
                 memcpy(Data->RingtonesInfo->Ringtone[i].Name,msg.Buffer+tmp+8,(msg.Buffer[tmp+6]*256+msg.Buffer[tmp+7])*2);
                 smprintf(s, "%5i (%5i). \"%s\"\n",
                         Data->RingtonesInfo->Ringtone[i].ID,
                         Data->RingtonesInfo->Ringtone[i].Group,
                         DecodeUnicodeString(Data->RingtonesInfo->Ringtone[i].Name));
                 tmp = tmp + (msg.Buffer[tmp]*256+msg.Buffer[tmp+1]);
         }
         return ERR_NONE;
 }
 
 static GSM_Error N6510_PrivGetRingtonesInfo(GSM_StateMachine *s, GSM_AllRingtonesInfo *Info, bool AllRingtones)
 {
                 GSM_Errorerror;
                 unsigned char UserReq[8] = {N7110_FRAME_HEADER, 0x07, 0x00, 0x00, 0x00, 0x02};
         //      unsigned char All_Req[9] = {N7110_FRAME_HEADER, 0x07, 0x00, 0x00, 0xFE, 0x00, 0x7D};
                 unsigned char All_Req[8] = {N7110_FRAME_HEADER, 0x07, 0x00, 0x00, 0x00, 0x00};
 
         s->Phone.Data.RingtonesInfo=Info;
         smprintf(s, "Getting binary ringtones ID\n");
         if (AllRingtones) {
         //      error = GSM_WaitFor (s, All_Req, 9, 0x1f, 4, ID_GetRingtonesInfo);
                 error = GSM_WaitFor (s, All_Req, 8, 0x1f, 4, ID_GetRingtonesInfo);
                 if (error == ERR_EMPTY && Info->Number == 0) return ERR_NOTSUPPORTED;
                 return error;
         } else {
                 error = GSM_WaitFor (s, UserReq, 8, 0x1f, 4, ID_GetRingtonesInfo);
                 if (error == ERR_EMPTY && Info->Number == 0) return ERR_NOTSUPPORTED;
                 return error;
         }
 }
 
 static GSM_Error N6510_GetRingtonesInfo(GSM_StateMachine *s, GSM_AllRingtonesInfo *Info)
 {
         return N6510_PrivGetRingtonesInfo(s, Info, true);
 }
 
 static GSM_Error N6510_ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 int             tmp,i;
                 GSM_Phone_Data  *Data = &s->Phone.Data;
 
         smprintf(s, "Ringtone received\n");
         memcpy(Data->Ringtone->Name,msg.Buffer+8,msg.Buffer[7]*2);
         Data->Ringtone->Name[msg.Buffer[7]*2]=0;
         Data->Ringtone->Name[msg.Buffer[7]*2+1]=0;
         smprintf(s, "Name \"%s\"\n",DecodeUnicodeString(Data->Ringtone->Name));
          if (msg.Buffer[msg.Buffer[7]*2+10] == 'M' &&
              msg.Buffer[msg.Buffer[7]*2+11] == 'T' &&
              msg.Buffer[msg.Buffer[7]*2+12] == 'h' &&
              msg.Buffer[msg.Buffer[7]*2+13] == 'd') {
                 smprintf(s,"MIDI\n");
                         tmp = msg.Buffer[7]*2+10;
                         i = msg.Length - 2; /* ?????? */
                 Data->Ringtone->Format = RING_MIDI;
          } else {
                 /* Looking for end */
                 i=8+msg.Buffer[7]*2+3;
                 tmp = i;
                 while (true) {
                         if (msg.Buffer[i]==0x07 && msg.Buffer[i+1]==0x0b) {
                                 i=i+2; break;
                         }
                         i++;
                         if (i==msg.Length) return ERR_EMPTY;
                         }  
         }
         /* Copying frame */
         memcpy(Data->Ringtone->NokiaBinary.Frame,msg.Buffer+tmp,i-tmp);
         Data->Ringtone->NokiaBinary.Length=i-tmp;
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone, bool PhoneRingtone)
 {
                 GSM_AllRingtonesInfo Info;
                 GSM_Error       error;
                 unsigned char   req2[6] = {N7110_FRAME_HEADER, 0x12,
                                                    0x00, 0xe7}; /* Location */
 
         if (Ringtone->Format == 0x00) Ringtone->Format = RING_NOKIABINARY;
 
         switch (Ringtone->Format) {
         case RING_NOTETONE:
                 /* In the future get binary and convert */
                 return ERR_NOTSUPPORTED;
         case RING_NOKIABINARY:
                         s->Phone.Data.Ringtone= Ringtone;
                         Info.Number     = 0;
                 error=N6510_PrivGetRingtonesInfo(s, &Info, PhoneRingtone);
                 if (error != ERR_NONE) return error;
                 if (Ringtone->Location > Info.Number) return ERR_INVALIDLOCATION;
                 req2[4] = Info.Ringtone[Ringtone->Location-1].ID / 256;
                 req2[5] = Info.Ringtone[Ringtone->Location-1].ID % 256;
                 smprintf(s, "Getting binary ringtone\n");
                 return GSM_WaitFor (s, req2, 6, 0x1f, 4, ID_GetRingtone);
         case RING_MIDI:
+        case RING_MMF:
                 return ERR_NOTSUPPORTED;
         }
         return ERR_NOTSUPPORTED;
 }
 
 static GSM_Error N6510_PlayTone(GSM_StateMachine *s, int Herz, unsigned char Volume, bool start)
 {
                 GSM_Error error;
                 unsigned char reqStart[] = {
                 0x00,0x06,0x01,0x00,0x07,0x00 };
                 unsigned char reqPlay[] = {
                 0x00,0x06,0x01,0x14,0x05,0x04,
                 0x00,0x00,0x00,0x03,0x03,0x08,
                 0x00,0x00,0x00,0x01,0x00,0x00,
                 0x03,0x08,0x01,0x00,
                         0x07,0xd0,/*Frequency */
                 0x00,0x00,0x03,0x08,0x02,0x00,0x00,
                         0x05,   /*Volume */
                 0x00,0x00};
                 unsigned char reqOff[] = {
                 0x00,0x06,0x01,0x14,0x05,0x05,
                 0x00,0x00,0x00,0x01,0x03,0x08,
                 0x05,0x00,0x00,0x08,0x00,0x00};
         //      unsigned char reqOff2[] = {
         //      0x00,0x06,0x01,0x14,0x05,0x04,
         //      0x00,0x00,0x00,0x01,0x03,0x08,
         //      0x00,0x00,0x00,0x00,0x00,0x00};
 
         if (start) {
                 smprintf(s, "Enabling sound - part 1\n");
                 error=GSM_WaitFor (s, reqStart, 6, 0x0b, 4, ID_PlayTone);
                 if (error!=ERR_NONE) return error;
                 smprintf(s, "Enabling sound - part 2 (disabling sound command)\n");
                 error=GSM_WaitFor (s, reqOff, 18, 0x0b, 4, ID_PlayTone);
                 if (error!=ERR_NONE) return error;
         }
 
         /* For Herz==255*255 we have silent */  
         if (Herz!=255*255) {
                 reqPlay[23] = Herz%256;
                 reqPlay[22] = Herz/256;
                 reqPlay[31] = Volume;
                 smprintf(s, "Playing sound\n");
                 return GSM_WaitFor (s, reqPlay, 34, 0x0b, 4, ID_PlayTone);
         } else {
                 reqPlay[23] = 0;
                 reqPlay[22] = 0;
                 reqPlay[31] = 0;
                 smprintf(s, "Playing silent sound\n");
                 return GSM_WaitFor (s, reqPlay, 34, 0x0b, 4, ID_PlayTone);
 
         //      smprintf(s, "Disabling sound - part 1\n");
         //      error=GSM_WaitFor (s, reqOff, 18, 0x0b, 4, ID_PlayTone);
         //              if (error!=ERR_NONE) return error;      
         //      smprintf(s, "Disabling sound - part 2\n");
         //      return GSM_WaitFor (s, reqOff2, 18, 0x0b, 4, ID_PlayTone);
         }
 }
 
 static GSM_Error N6510_ReplyGetPPM(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Phone_Data *Data = &s->Phone.Data;
                 int     pos = 6,len;
 
         smprintf(s, "Received phone info\n");
 
         while(pos < msg.Length) {
                 if (msg.Buffer[pos] == 0x55 && msg.Buffer[pos+1] == 0x55) {
                         while(1) {
                                 if (msg.Buffer[pos] != 0x55) break;
                                 pos++;
                         }
                 }
                 len = pos;
                 while(1) {
                         if (msg.Buffer[len] == 0x00 && msg.Buffer[len+1] == 0x00) break;
                         len++;
                 }
                 while(1) {
                         if (msg.Buffer[len] != 0x00) break;
                         len++;
                 }
                 len = len-pos;
                 smprintf(s, "Block with ID %02x",msg.Buffer[pos]);
 #ifdef DEBUG
                 if (di.dl == DL_TEXTALL || di.dl == DL_TEXTALLDATE) DumpMessage(di.df, di.dl, msg.Buffer+pos, len);
 #endif
                 switch (msg.Buffer[pos]) {
                 case 0x49:
                         smprintf(s, "hardware version\n");
                         break;
                 case 0x58:
                         pos += 3;
                         while (msg.Buffer[pos] != 0x00) pos++;
                         Data->PhoneString[0] = msg.Buffer[pos - 1];
                         Data->PhoneString[1] = 0x00;
@@ -2893,701 +2900,740 @@ static GSM_Error N6510_GetSpeedDial(GSM_StateMachine *s, GSM_SpeedDial *SpeedDia
 
                 pbk.MemoryType          = MEM7110_SP;
                 pbk.Location            = SpeedDial->Location;
                 SpeedDial->MemoryLocation = 0;
                 s->Phone.Data.SpeedDial         = SpeedDial;
 
         smprintf(s, "Getting speed dial\n");
         error=N6510_GetMemory(s,&pbk);
         switch (error) {
         case ERR_NOTSUPPORTED:
                 smprintf(s, "No speed dials set in phone\n");
                 return ERR_EMPTY;
         case ERR_NONE:
                 if (SpeedDial->MemoryLocation == 0) {
                         smprintf(s, "Speed dial not assigned or error in firmware\n");
                         return ERR_EMPTY;
                 }
                 return ERR_NONE;
         default:
                 return error;
         }
 }
 
 static GSM_Error N6510_ReplyGetProfile(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 unsigned char *blockstart;
                 int     i,j;
                 GSM_Phone_Data*Data = &s->Phone.Data;
                         
         switch (msg.Buffer[3]) {
         case 0x02: 
         blockstart = msg.Buffer + 7;
         for (i = 0; i < 11; i++) {
                 smprintf(s, "Profile feature %02x ",blockstart[1]);
 #ifdef DEBUG
                 if (di.dl == DL_TEXTALL || di.dl == DL_TEXTALLDATE) DumpMessage(di.df, di.dl, blockstart, blockstart[0]);
 #endif
 
                 switch (blockstart[1]) {
                 case 0x03:
                         smprintf(s, "Ringtone ID\n");
                                 Data->Profile->FeatureID[Data->Profile->FeaturesNumber] = Profile_RingtoneID;
                                 Data->Profile->FeatureValue[Data->Profile->FeaturesNumber] = blockstart[7];
                         if (blockstart[7] == 0x00) {
                                 Data->Profile->FeatureValue[Data->Profile->FeaturesNumber] = blockstart[10];
                         }
                         Data->Profile->FeaturesNumber++;
                         break;
                         case 0x05:/* SMS tone */
                         j = Data->Profile->FeaturesNumber;
                         NOKIA_FindFeatureValue(s, Profile71_65,blockstart[1],blockstart[7],Data,false);
                         if (j == Data->Profile->FeaturesNumber) {
                                         Data->Profile->FeatureID[Data->Profile->FeaturesNumber] = Profile_MessageTone;
                                         Data->Profile->FeatureValue[Data->Profile->FeaturesNumber] = PROFILE_MESSAGE_PERSONAL;
                                 Data->Profile->FeaturesNumber++;
                                         Data->Profile->FeatureID[Data->Profile->FeaturesNumber] = Profile_MessageToneID;
                                         Data->Profile->FeatureValue[Data->Profile->FeaturesNumber] = blockstart[7];
                                 Data->Profile->FeaturesNumber++;
                         }
                         break;
                         case 0x08:/* Caller groups */
                         NOKIA_FindFeatureValue(s, Profile71_65,blockstart[1],blockstart[7],Data,true);
                         break;
                 case 0x0c :
                         CopyUnicodeString(Data->Profile->Name,blockstart + 7);
                         smprintf(s, "profile Name: \"%s\"\n", DecodeUnicodeString(Data->Profile->Name));
                         Data->Profile->DefaultName = false;
                         break;
                 default:
                         NOKIA_FindFeatureValue(s, Profile71_65,blockstart[1],blockstart[7],Data,false);
                 }
                 blockstart = blockstart + blockstart[0];
         }
         return ERR_NONE;
         case 0x06:
                 Data->Profile->Active = false;
                 if (Data->Profile->Location == msg.Buffer[5]) Data->Profile->Active = true;
                 return ERR_NONE;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_GetProfile(GSM_StateMachine *s, GSM_Profile *Profile)
 {
                 unsigned char req[150]    = {N6110_FRAME_HEADER, 0x01, 0x01, 0x0C, 0x01};
                 unsigned charreqActive[] = {N6110_FRAME_HEADER, 0x05};
                 int     i, length = 7;
                 GSM_Errorerror;
 
         /* For now !!! */
         if (!strcmp(s->Phone.Data.ModelInfo->model,"3510")) {
                 if (s->Phone.Data.VerNum>3.37) return ERR_NOTSUPPORTED;
         }
         if (!strcmp(s->Phone.Data.ModelInfo->model,"6230")) {
                 return ERR_NOTSUPPORTED;
         }
+        if (!strcmp(s->Phone.Data.ModelInfo->model,"5140")) {
+                return ERR_NOTSUPPORTED;
+        }
 
         if (Profile->Location>5) return ERR_INVALIDLOCATION;
 
         for (i = 0; i < 0x0a; i++) {
                 req[length++] = 0x04;
                 req[length++] = Profile->Location;
                 req[length++] = i;
                 req[length++] = 0x01;
         }
 
         req[length++] = 0x04;
         req[length++] = Profile->Location;
         req[length++] = 0x0c;
         req[length++] = 0x01;
 
         req[length++] = 0x04;
 
                 Profile->CarKitProfile= false;
                 Profile->HeadSetProfile= false;
 
         Profile->FeaturesNumber = 0;
 
         s->Phone.Data.Profile=Profile;
         smprintf(s, "Getting profile\n");
         error = GSM_WaitFor (s, req, length, 0x39, 4, ID_GetProfile);
         if (error != ERR_NONE) return error;
 
         smprintf(s, "Checking, which profile is active\n");
         return GSM_WaitFor (s, reqActive, 4, 0x39, 4, ID_GetProfile);
 }
 
 static GSM_Error N6510_ReplySetProfile(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 unsigned char *blockstart;
                 int     i;
 
         smprintf(s, "Response to profile writing received!\n");
 
         blockstart = msg.Buffer + 6;
         for (i = 0; i < msg.Buffer[5]; i++) {
                 switch (blockstart[2]) {
                                 case 0x00: smprintf(s, "keypad tone level"); break;
                                 case 0x02: smprintf(s, "call alert");   break;
                                 case 0x03: smprintf(s, "ringtone");     break;
                                 case 0x04: smprintf(s, "ringtone volume"); break;
                                 case 0x05: smprintf(s, "SMS tone");     break;
                                 case 0x06: smprintf(s, "vibration");    break;
                                 case 0x07: smprintf(s, "warning tone level"); break;
                                 case 0x08: smprintf(s, "caller groups"); break;
                                 case 0x09: smprintf(s, "automatic answer"); break;
                                 case 0x0c: smprintf(s, "name");         break;
                         default:
                                 smprintf(s, "Unknown block type %02x", blockstart[2]);
                                 break;
                 }
                 if (msg.Buffer[4] == 0x00) {
                         smprintf(s, ": set OK\n");
                 } else {
                         smprintf(s, ": setting error %i\n", msg.Buffer[4]);
                 }
                 blockstart = blockstart + blockstart[1];
         }
         return ERR_NONE;
 }
 
 static GSM_Error N6510_SetProfile(GSM_StateMachine *s, GSM_Profile *Profile)
 {
                 int     i, length = 7, blocks = 0;
                 bool    found;
                 unsigned charID,Value;
                 unsigned char req[150] = {N6110_FRAME_HEADER, 0x03, 0x01,
                                             0x06,       /* Number of blocks */
                                     0x03};
 
         if (Profile->Location>5) return ERR_INVALIDLOCATION;
 
         for (i=0;i<Profile->FeaturesNumber;i++) {
                 found = false;
                 switch (Profile->FeatureID[i]) {
                         case Profile_RingtoneID:
                                         ID = 0x03;
                                         Value = Profile->FeatureValue[i];
                                         found = true;
                                 break;
                         default:
                                 found=NOKIA_FindPhoneFeatureValue(
                                         s,
                                         Profile71_65,
                                         Profile->FeatureID[i],Profile->FeatureValue[i],
                                         &ID,&Value);
                 }
                 if (found) {
                                 req[length] = 0x09;
                         req[length + 1] = ID;
                         req[length + 2] = Profile->Location;
                         memcpy(req + length + 4, "\x00\x00\x01", 3);
                         req[length + 8] = 0x03;
                         req[length + 3] = req[length + 7] = Value;
                         blocks++;
                         length += 9;
                 }
         }
 
         smprintf(s, "Setting profile\n");
         return GSM_WaitFor (s, req, length, 0x39, 4, ID_SetProfile);
 }
 
 static GSM_Error N6510_ReplyIncomingSMS(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_SMSMessage sms;
 
 #ifdef DEBUG
         smprintf(s, "SMS message received\n");
         N6510_DecodeSMSFrame(s, &sms, msg.Buffer+10);
 #endif
 
         if (s->Phone.Data.EnableIncomingSMS && s->User.IncomingSMS!=NULL) {
                         sms.State  = SMS_UnRead;
                 sms.InboxFolder  = true;
 
                 N6510_DecodeSMSFrame(s, &sms, msg.Buffer+10);
 
                 s->User.IncomingSMS(s->CurrentConfig->Device,sms);
         }
         return ERR_NONE;
 }
 
 static GSM_Error N6510_DialVoice(GSM_StateMachine *s, char *number, GSM_CallShowNumber ShowNumber)
 {
+                unsigned int pos2 = 15;
                 unsigned intpos = 4;
+                unsigned char req2[100] = {N6110_FRAME_HEADER,0x01,
+                                    0x00,0x02,0x07,0x04,
+                                    0x01,  // 1 - voice, 2 - data
+                                    0x00,0x03,
+                                    0x18,  // length of rest + 1
+                                    0x00,0x00,0x00};
                 unsigned char req[100] = {N6110_FRAME_HEADER,0x01,
                                             0x0c};/* Number length */
+                GSM_Errorerror;
+
+        /* USSD not supported */
+        if (number[0] == '*') return ERR_NOTSUPPORTED;
+        if (number[0] == '#') return ERR_NOTSUPPORTED;
 
         req[pos++] = strlen(number);
         EncodeUnicode(req+pos,number,strlen(number));
         pos += strlen(number)*2;
         req[pos++] = 0x05; /* call type: voice - 0x05, data - 0x01 */
         req[pos++] = 0x01;
         req[pos++] = 0x05;
         req[pos++] = 0x00;
         req[pos++] = 0x02;
         req[pos++] = 0x00;
         req[pos++] = 0x00;
         switch (ShowNumber) {
         case GSM_CALL_HideNumber:
                 req[pos++] = 0x02;
                 break;
         case GSM_CALL_ShowNumber:
                 req[pos++] = 0x03;
                 break;
         case GSM_CALL_DefaultNumberPresence:
                 req[pos++] = 0x01;
                 break;
         }
+        smprintf(s, "Making voice call\n");
+        error = GSM_WaitFor (s, req, pos, 0x01, 4, ID_DialVoice);
+        if (error != ERR_NOTSUPPORTED) return error;
+
+        if (ShowNumber != GSM_CALL_DefaultNumberPresence) return ERR_NOTSUPPORTED;
+
+        req2[11] = strlen(number)*2+6;
+        req2[pos2++] = strlen(number);
+        EncodeUnicode(req2+pos2,number,strlen(number));
+        pos2 += strlen(number)*2;
 
         smprintf(s, "Making voice call\n");
-        return GSM_WaitFor (s, req, pos, 0x01, 4, ID_DialVoice);
+        error = GSM_WaitFor (s, req2, pos2, 0x01, 4, ID_DialVoice);
+        if (error == ERR_NOTSUPPORTED) return ERR_NONE;
+        return error;
 }
 
 /* method 3 */
 static GSM_Error N6510_ReplyGetCalendarInfo3(GSM_Protocol_Message msg, GSM_StateMachine *s, GSM_NOKIACalToDoLocations *Last)
 {
         int i=0,j=0;
 
         while (Last->Location[j] != 0x00) j++;
         if (j >= GSM_MAXCALENDARTODONOTES) {
                 smprintf(s, "Increase GSM_MAXCALENDARTODONOTES\n");
                 return ERR_UNKNOWN;
         }
         if (j == 0) {
                 Last->Number=msg.Buffer[8]*256+msg.Buffer[9];
                 smprintf(s, "Number of Entries: %i\n",Last->Number);
         }
         smprintf(s, "Locations: ");
         while (14+(i*4) <= msg.Length) {
                 Last->Location[j++]=msg.Buffer[12+i*4]*256+msg.Buffer[13+i*4];
                 smprintf(s, "%i ",Last->Location[j-1]);
                 i++;
         }
         smprintf(s, "\nNumber of Entries in frame: %i\n",i);
         Last->Location[j] = 0;
         smprintf(s, "\n");
         if (i == 1 && msg.Buffer[12+0*4]*256+msg.Buffer[13+0*4] == 0) return ERR_EMPTY;
         if (i == 0) return ERR_EMPTY;
         return ERR_NONE;
 }
 
 /* method 3 */
-static GSM_Error N6510_GetCalendarInfo3(GSM_StateMachine *s, GSM_NOKIACalToDoLocations *Last, bool Calendar)
+static GSM_Error N6510_GetCalendarInfo3(GSM_StateMachine *s, GSM_NOKIACalToDoLocations *Last, char Type)
 {
-                GSM_Error error;
+                GSM_Error error = ERR_UNKNOWN;
                 int     i;
         unsigned char   req[] = {N6110_FRAME_HEADER, 0x9E, 0xFF, 0xFF, 0x00, 0x00,
                                          0x00, 0x00,/* First location */
-                                         0x00};         /* 0 = calendar, 1 = ToDo in 6610 style */
+                                         0x00};         /* 0 = calendar, 1 = ToDo in 6610 style, 2 = Notes */
 
         Last->Location[0] = 0x00;
                 Last->Number  = 0;
 
-        if (Calendar) {
+                req[10] = Type;
+        if (Type == 0) {
                 smprintf(s, "Getting locations for calendar method 3\n");
                 error = GSM_WaitFor (s, req, 11, 0x13, 4, ID_GetCalendarNotesInfo);
-        } else {
-                req[10] = 0x01;
+        } else if (Type == 1) {
                 smprintf(s, "Getting locations for ToDo method 2\n");
                 error = GSM_WaitFor (s, req, 11, 0x13, 4, ID_GetToDo);
+        } else if (Type == 2) {
+                smprintf(s, "Getting locations for Notes\n");
+                error = GSM_WaitFor (s, req, 11, 0x13, 4, ID_GetNote);
         }
         if (error != ERR_NONE && error != ERR_EMPTY) return error;
 
         while (1) {
                 i=0;
                 while (Last->Location[i] != 0x00) i++;
                 smprintf(s, "i = %i %i\n",i,Last->Number);
                 if (i == Last->Number) break;
                 if (i != Last->Number && error == ERR_EMPTY) {
                         smprintf(s, "Phone doesn't support some notes with this method. Workaround\n");
                         Last->Number = i;
                         break;
                 }
                 req[8] = Last->Location[i-1] / 256;
                 req[9] = Last->Location[i-1] % 256;
-                if (Calendar) {
+                if (Type == 0) {
                         smprintf(s, "Getting locations for calendar method 3\n");
                         error = GSM_WaitFor (s, req, 11, 0x13, 4, ID_GetCalendarNotesInfo);
-                } else {
+                } else if (Type == 1) {
                         smprintf(s, "Getting locations for todo method 2\n");
                         error = GSM_WaitFor (s, req, 11, 0x13, 4, ID_GetToDo);
+                } else if (Type == 2) {
+                        smprintf(s, "Getting locations for Notes\n");
+                        error = GSM_WaitFor (s, req, 11, 0x13, 4, ID_GetNote);
                 }
                 if (error != ERR_NONE && error != ERR_EMPTY) return error;
         }
         return ERR_NONE;
 }
 
 /* method 3 */
 GSM_Error N6510_ReplyGetCalendar3(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_CalendarEntry       *entry = s->Phone.Data.Cal;
                 GSM_DateTime            Date;
                 unsigned long           diff;
                 int                     i;
                 bool                    found = false;
                 GSM_Phone_N6510Data     *Priv = &s->Phone.Data.Priv.N6510;
 
         smprintf(s, "Calendar note received method 3\n");
 
         smprintf(s,"Note type %02i: ",msg.Buffer[27]);
         switch(msg.Buffer[27]) {
                 case 0x00: smprintf(s,"Reminder\n"); entry->Type = GSM_CAL_REMINDER; break;
                 case 0x01: smprintf(s,"Meeting\n");  entry->Type = GSM_CAL_MEETING;  break;
                 case 0x02: smprintf(s,"Call\n");     entry->Type = GSM_CAL_CALL;     break;
                 case 0x04: smprintf(s,"Birthday\n"); entry->Type = GSM_CAL_BIRTHDAY; break;
                 case 0x08: smprintf(s,"Memo\n");     entry->Type = GSM_CAL_MEMO;     break;
                 default  : smprintf(s,"unknown\n");
         }
 
         smprintf(s,"StartTime: %04i-%02i-%02i %02i:%02i\n",
                 msg.Buffer[28]*256+msg.Buffer[29],
                 msg.Buffer[30],msg.Buffer[31],msg.Buffer[32],
                 msg.Buffer[33]);
                 Date.Year       = msg.Buffer[28]*256+msg.Buffer[29];
         if (entry->Type == GSM_CAL_BIRTHDAY) {
                 Date.Year = entry->Entries[0].Date.Year;
                         smprintf(s,"%i\n",Date.Year);   
         }
                 Date.Month = msg.Buffer[30];
                 Date.Day = msg.Buffer[31];
                 Date.Hour = msg.Buffer[32];
                 Date.Minute = msg.Buffer[33];
         /* Garbage seen with 3510i 3.51 */
         if (Date.Month == 0 && Date.Day == 0 && Date.Hour == 0 && Date.Minute == 0) return ERR_EMPTY;
                 Date.Second= 0;
         entry->Entries[0].EntryType = CAL_START_DATETIME;
         memcpy(&entry->Entries[0].Date,&Date,sizeof(GSM_DateTime));
         entry->EntriesNum++;
 
         if (entry->Type != GSM_CAL_BIRTHDAY) {
                 smprintf(s,"EndTime: %04i-%02i-%02i %02i:%02i\n",
                         msg.Buffer[34]*256+msg.Buffer[35],
                         msg.Buffer[36],msg.Buffer[37],msg.Buffer[38],
                         msg.Buffer[39]);
                         Date.Year = msg.Buffer[34]*256+msg.Buffer[35];
                         Date.Month = msg.Buffer[36];
                         Date.Day = msg.Buffer[37];
                         Date.Hour = msg.Buffer[38];
                         Date.Minute = msg.Buffer[39];
                         Date.Second= 0;
                 entry->Entries[1].EntryType = CAL_END_DATETIME;
                 memcpy(&entry->Entries[1].Date,&Date,sizeof(GSM_DateTime));
                 entry->EntriesNum++;
         }
 
         smprintf(s, "Note icon: %02x\n",msg.Buffer[21]);
         for(i=0;i<Priv->CalendarIconsNum;i++) {
                 if (Priv->CalendarIconsTypes[i] == entry->Type) {
                         found = true;
                 }
         }
         if (!found) {
                 Priv->CalendarIconsTypes[Priv->CalendarIconsNum] = entry->Type;
                         Priv->CalendarIcons[Priv->CalendarIconsNum] = msg.Buffer[21];
                 Priv->CalendarIconsNum++;
         }
 
         if (msg.Buffer[14] == 0xFF && msg.Buffer[15] == 0xFF && msg.Buffer[16] == 0xff && msg.Buffer[17] == 0xff)
         {
                 smprintf(s, "No alarm\n");
         } else {
                 diff  = ((unsigned int)msg.Buffer[14]) << 24;
                 diff += ((unsigned int)msg.Buffer[15]) << 16;
                 diff += ((unsigned int)msg.Buffer[16]) << 8;
                 diff += msg.Buffer[17];
 
                 memcpy(&entry->Entries[entry->EntriesNum].Date,&entry->Entries[0].Date,sizeof(GSM_DateTime));
                 GetTimeDifference(diff, &entry->Entries[entry->EntriesNum].Date, false, 60);
                 smprintf(s, "Alarm date   : %02i-%02i-%04i %02i:%02i:%02i\n",
                         entry->Entries[entry->EntriesNum].Date.Day,   entry->Entries[entry->EntriesNum].Date.Month,
                         entry->Entries[entry->EntriesNum].Date.Year,  entry->Entries[entry->EntriesNum].Date.Hour,
                         entry->Entries[entry->EntriesNum].Date.Minute,entry->Entries[entry->EntriesNum].Date.Second);
 
                 entry->Entries[entry->EntriesNum].EntryType = CAL_ALARM_DATETIME;
                 if (msg.Buffer[22]==0x00 && msg.Buffer[23]==0x00 &&
                     msg.Buffer[24]==0x00 && msg.Buffer[25]==0x00)
                 {
                         entry->Entries[entry->EntriesNum].EntryType = CAL_SILENT_ALARM_DATETIME;
                         smprintf(s, "Alarm type   : Silent\n");
                 }
                 entry->EntriesNum++;
         }
 
         N71_65_GetCalendarRecurrance(s, msg.Buffer+40, entry);
 
         if (entry->Type == GSM_CAL_BIRTHDAY) {
                 if (msg.Buffer[42] == 0xff && msg.Buffer[43] == 0xff) {
                         entry->Entries[0].Date.Year = 0;
                 } else {
                         entry->Entries[0].Date.Year = msg.Buffer[42]*256+msg.Buffer[43];
                 }
         }
 
         memcpy(entry->Entries[entry->EntriesNum].Text, msg.Buffer+54, msg.Buffer[51]*2);
         entry->Entries[entry->EntriesNum].Text[msg.Buffer[51]*2]   = 0;
         entry->Entries[entry->EntriesNum].Text[msg.Buffer[51]*2+1] = 0;
                 entry->Entries[entry->EntriesNum].EntryType        = CAL_TEXT;
         entry->EntriesNum++;
         smprintf(s, "Note text: \"%s\"\n",DecodeUnicodeString(entry->Entries[entry->EntriesNum-1].Text));
 
         if (entry->Type == GSM_CAL_CALL) {
                 memcpy(entry->Entries[entry->EntriesNum].Text, msg.Buffer+(54+msg.Buffer[51]*2), msg.Buffer[52]*2);
                 entry->Entries[entry->EntriesNum].Text[msg.Buffer[52]*2]   = 0;
                 entry->Entries[entry->EntriesNum].Text[msg.Buffer[52]*2+1] = 0;
                         entry->Entries[entry->EntriesNum].EntryType        = CAL_PHONE;
                 entry->EntriesNum++;
         }
         if (entry->Type == GSM_CAL_MEETING) {
                 memcpy(entry->Entries[entry->EntriesNum].Text, msg.Buffer+(54+msg.Buffer[51]*2), msg.Buffer[52]*2);
                 entry->Entries[entry->EntriesNum].Text[msg.Buffer[52]*2]   = 0;
                 entry->Entries[entry->EntriesNum].Text[msg.Buffer[52]*2+1] = 0;
                         entry->Entries[entry->EntriesNum].EntryType        = CAL_LOCATION;
                 entry->EntriesNum++;
         }
 
         return ERR_NONE;
 }
 
+static GSM_Error N6510_PrivGetGenericCalendar3(GSM_StateMachine *s, int Location, GSM_Phone_RequestID ID)
+{
+        unsigned char req[] = {N6110_FRAME_HEADER,0x7D,0x00,0x00,0x00,0x00,
+                                       0x00,0x99,/* Location */
+                                       0xff,0xff,0xff,0xff};
+
+        req[8] = Location / 256;
+        req[9] = Location % 256;
+
+        return GSM_WaitFor (s, req, 14, 0x13, 4, ID);
+}
+
 static GSM_Error N6510_PrivGetCalendar3(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start, int *LastCalendarYear)
 {
                 GSM_Error       error;
                 GSM_DateTime    date_time;
-                unsigned char   req[] = {N6110_FRAME_HEADER,0x7D,0x00,0x00,0x00,0x00,
-                                                 0x00,0x99,/* Location */
-                                                 0xff,0xff,0xff,0xff,0x01};
 
         if (start) {
                 /* We have to get current year. It's NOT written in frame for
                  * Birthday
                  */
                 error=s->Phone.Functions->GetDateTime(s,&date_time);
                 switch (error) {
                         case ERR_EMPTY:
                         case ERR_NOTIMPLEMENTED:
                                 GSM_GetCurrentDateTime(&date_time);
                                 break;
                         case ERR_NONE:
                                 break;
                         default:
                                 return error;
                 }
                 *LastCalendarYear = date_time.Year;
         }
 
                 Note->EntriesNum        = 0;
                 Note->Entries[0].Date.Year = *LastCalendarYear;
 
-        req[8] = Note->Location / 256;
-        req[9] = Note->Location % 256;
-                        
         s->Phone.Data.Cal=Note;
         smprintf(s, "Getting calendar note method 3\n");
-        return GSM_WaitFor (s, req, 15, 0x13, 4, ID_GetCalendarNote);
+        return N6510_PrivGetGenericCalendar3(s, Note->Location, ID_GetCalendarNote);
 }
 
 /* method 3 */
 GSM_Error N6510_GetNextCalendar3(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start, GSM_NOKIACalToDoLocations *LastCalendar, int *LastCalendarYear, int *LastCalendarPos)
 {
         GSM_Error error;
                 bool  start2;
 
         if (start) {
-                error=N6510_GetCalendarInfo3(s,LastCalendar,true);
+                error=N6510_GetCalendarInfo3(s,LastCalendar,0);
                 if (error!=ERR_NONE) return error;
                 if (LastCalendar->Number == 0) return ERR_EMPTY;
 
                 *LastCalendarPos = 0;
         } else {
                 (*LastCalendarPos)++;
         }
 
         error  = ERR_EMPTY;
         start2 = start;
         while (error == ERR_EMPTY) {
                 if (*LastCalendarPos >= LastCalendar->Number) return ERR_EMPTY;
         
                 Note->Location = LastCalendar->Location[*LastCalendarPos];
                 error=N6510_PrivGetCalendar3(s, Note, start2, LastCalendarYear);
                 if (error == ERR_EMPTY) (*LastCalendarPos)++;
 
                 start2 = false;
         }
         return error;
 }
 
 static GSM_Error N6510_ReplyGetCalendarInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
         case 0x3B:
                 /* Old method 1 for accessing calendar */
                 return N71_65_ReplyGetCalendarInfo1(msg, s, &s->Phone.Data.Priv.N6510.LastCalendar);
         case 0x9F:
                 smprintf(s, "Info with calendar notes locations received method 3\n");
                 return N6510_ReplyGetCalendarInfo3(msg, s, &s->Phone.Data.Priv.N6510.LastCalendar);
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 /* method 3 */
 GSM_Error N6510_ReplyGetCalendarNotePos3(GSM_Protocol_Message msg, GSM_StateMachine *s,int *FirstCalendarPos)
 {
         smprintf(s, "First calendar location: %i\n",msg.Buffer[8]*256+msg.Buffer[9]);
         *FirstCalendarPos = msg.Buffer[8]*256+msg.Buffer[9];
         return ERR_NONE;
 }
 
 /* method 3 */
 static GSM_Error N6510_GetCalendarNotePos3(GSM_StateMachine *s)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x95, 0x00};
 
         smprintf(s, "Getting first free calendar note location\n");
         return GSM_WaitFor (s, req, 5, 0x13, 4, ID_GetCalendarNotePos);
 }
 
 static GSM_Error N6510_ReplyGetCalendarNotePos(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
         case 0x32:
                 /* Old method 1 for accessing calendar */
                 return N71_65_ReplyGetCalendarNotePos1(msg, s,&s->Phone.Data.Priv.N6510.FirstCalendarPos);
         case 0x96:
                 return N6510_ReplyGetCalendarNotePos3(msg, s,&s->Phone.Data.Priv.N6510.FirstCalendarPos);
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_FindCalendarIconID3(GSM_StateMachine *s, GSM_CalendarEntry *Entry, unsigned char *ID)
 {
                 int                     i,j,LastCalendarYear;
                 GSM_Phone_N6510Data     *Priv = &s->Phone.Data.Priv.N6510;
                 GSM_CalendarEntry       Note;
                 GSM_NOKIACalToDoLocationsLastCalendar1,LastCalendar2;
                 GSM_Error               error;
                 bool                    found;
 
         for(i=0;i<Priv->CalendarIconsNum;i++) {
                 if (Priv->CalendarIconsTypes[i] == Entry->Type) {
                         *ID = Priv->CalendarIcons[i];
                         return ERR_NONE;
                 }
         }
 
         smprintf(s, "Starting finding note ID\n");
 
-        error=N6510_GetCalendarInfo3(s, &Priv->LastCalendar,true);
+        error=N6510_GetCalendarInfo3(s, &Priv->LastCalendar,0);
         memcpy(&LastCalendar1,&Priv->LastCalendar,sizeof(GSM_NOKIACalToDoLocations));
         if (error != ERR_NONE) return error;
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL35) ||
             IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL65) ||
             IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL62)) {
                 error=N71_65_AddCalendar2(s,Entry);
         } else {
                 if (Entry->Type == GSM_CAL_MEETING) {
                         error=N71_65_AddCalendar1(s, Entry, &s->Phone.Data.Priv.N6510.FirstCalendarPos);
                 } else {
                         error=N71_65_AddCalendar2(s,Entry);
                 }
         }
         if (error != ERR_NONE) return error;
 
-        error=N6510_GetCalendarInfo3(s, &Priv->LastCalendar,true);
+        error=N6510_GetCalendarInfo3(s, &Priv->LastCalendar,0);
         memcpy(&LastCalendar2,&Priv->LastCalendar,sizeof(GSM_NOKIACalToDoLocations));
         if (error != ERR_NONE) return error;
 
         smprintf(s,"Number of entries: %i %i\n",LastCalendar1.Number,LastCalendar2.Number);
 
         for(i=0;i<LastCalendar2.Number;i++) {
                 found = true;
                 for(j=0;j<LastCalendar1.Number;j++) {
                         if (LastCalendar1.Location[j] == LastCalendar2.Location[i]) {
                                 found = false;
                                 break;
                         }
                 }
                 if (found) {
                         Note.Location = LastCalendar2.Location[i];
                         error=N6510_PrivGetCalendar3(s, &Note, true, &LastCalendarYear);
                         if (error != ERR_NONE) return error;
 
                         error=N71_65_DelCalendar(s, &Note);
                         if (error != ERR_NONE) return error;
 
                         smprintf(s, "Ending finding note ID\n");
 
                         for(j=0;j<Priv->CalendarIconsNum;j++) {
                                 if (Priv->CalendarIconsTypes[j] == Entry->Type) {
                                         *ID = Priv->CalendarIcons[j];
                                         return ERR_NONE;
                                 }
                         }
                         return ERR_UNKNOWN;
                 }
         }
 
         return ERR_UNKNOWN;
 }
 
 /* method 3 */
 static GSM_Error N6510_ReplyAddCalendar3(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Calendar note added\n");
         return ERR_NONE;
 }
 
 /* method 3 */
 GSM_Error N6510_AddCalendar3(GSM_StateMachine *s, GSM_CalendarEntry *Note, int *FirstCalendarPos)
 {
                 GSM_CalendarNoteTypeNoteType, OldNoteType;
                 time_t          t_time1,t_time2;
                 long            diff;
                 GSM_Error       error;
                 GSM_DateTime    DT,date_time;
                 int             Text, Time, Alarm, Phone, Recurrance, EndTime, Location, count=54;
                 unsigned char   req[5000] = {
                 N6110_FRAME_HEADER, 0x65,
                         0x00,                                   /* 0 = calendar, 1 = todo */
                 0x00, 0x00, 0x00,
                         0x00, 0x00,                             /* location             */
                         0x00, 0x00, 0x00, 0x00,         
                         0xFF, 0xFF, 0xFF, 0xFF,                         /* alarm                */
                 0x80, 0x00, 0x00,
                         0x01,                                   /* note icon            */
                         0xFF, 0xFF, 0xFF, 0xFF,                         /* alarm type           */
                         0x00,                                   /* 0x02 or 0x00         */
                         0x01,                                   /* note type            */
                         0x07, 0xD0, 0x01, 0x12, 0x0C, 0x00,     /* start date/time      */
                         0x07, 0xD0, 0x01, 0x12, 0x0C, 0x00,     /* end date/time        */
                         0x00, 0x00,                             /* recurrance           */
                         0x00, 0x00,                             /* birth year           */
                         0x20,                                   /* ToDo priority        */
                         0x00,                                   /* ToDo completed ?     */
                 0x00, 0x00, 0x00,
                         0x00,                                   /* note text length     */
                         0x00,                                   /* phone length/meeting place*/
                 0x00, 0x00, 0x00};
 
         error=N6510_GetCalendarNotePos3(s);
         if (error!=ERR_NONE) return error;
         req[8] = *FirstCalendarPos/256;
         req[9] = *FirstCalendarPos%256;
 
          NoteType = N71_65_FindCalendarType(Note->Type, s->Phone.Data.ModelInfo);
 
         switch(NoteType) {
                 case GSM_CAL_REMINDER : req[27]=0x00; req[26]=0x02; break;
                 case GSM_CAL_MEETING  : req[27]=0x01; break;
                 case GSM_CAL_CALL     : req[27]=0x02; break;
                 case GSM_CAL_BIRTHDAY : req[27]=0x04; break;
                 case GSM_CAL_MEMO     : req[27]=0x08; break;
                         default           : return ERR_UNKNOWN;
         }
 
         OldNoteType = Note->Type;
         Note->Type  = NoteType;
         error=N6510_FindCalendarIconID3(s, Note, &req[21]);
         Note->Type  = OldNoteType;
         if (error!=ERR_NONE) return error;
@@ -3644,193 +3690,193 @@ GSM_Error N6510_AddCalendar3(GSM_StateMachine *s, GSM_CalendarEntry *Note, int *
                         req[40] = 0xff;
                         req[41] = 0xff;
                 } else {
                         req[40] = Note->Entries[Recurrance].Number / 256;
                         req[41] = Note->Entries[Recurrance].Number % 256;
                 }
         }
 
         if (Alarm != -1) {
                 memcpy(&DT,&Note->Entries[Time].Date,sizeof(GSM_DateTime));
                 if (Note->Entries[Alarm].EntryType == CAL_SILENT_ALARM_DATETIME) {
                         req[22] = 0x00; req[23] = 0x00; req[24] = 0x00; req[25] = 0x00;
                 }
                 if (NoteType == GSM_CAL_BIRTHDAY) DT.Year = date_time.Year;
                 t_time2   = Fill_Time_T(DT,8);
                 t_time1   = Fill_Time_T(Note->Entries[Alarm].Date,8);
                         diff  = (t_time1-t_time2)/60;
 
                 smprintf(s, "  Difference : %li seconds or minutes\n", -diff);
                 req[14] = (unsigned char)(-diff >> 24);
                 req[15] = (unsigned char)(-diff >> 16);
                 req[16] = (unsigned char)(-diff >> 8);
                 req[17] = (unsigned char)(-diff);
         }
 
         if (Text != -1) {
                 req[49] = UnicodeLength(Note->Entries[Text].Text);
                 CopyUnicodeString(req+54,Note->Entries[Text].Text);
                 count+= req[49]*2;
         }
 
         if (Phone != -1 && NoteType == GSM_CAL_CALL) {
                 req[50] = UnicodeLength(Note->Entries[Phone].Text);
                 CopyUnicodeString(req+54+req[49]*2,Note->Entries[Phone].Text);
                 count+= req[50]*2;
         }
 
         if (Location != -1 && NoteType == GSM_CAL_MEETING) {
                 if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL62) ||
                     IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL65) ||
                     IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL35)) {
                 } else {
                         req[50] = UnicodeLength(Note->Entries[Location].Text);
                         CopyUnicodeString(req+54+req[49]*2,Note->Entries[Location].Text);
                         count+= req[50]*2;
                 }
         }
 
         req[count++] = 0x00;
 
         smprintf(s, "Writing calendar note method 3\n");
         return GSM_WaitFor (s, req, count, 0x13, 4, ID_SetCalendarNote);
 }
 
 static GSM_Error N6510_GetNextCalendar(GSM_StateMachine *s,  GSM_CalendarEntry *Note, bool start)
 {
 #ifdef GSM_FORCE_DCT4_CALENDAR_6210
             /* Method 1. Some features missed. Not working with some notes in 3510 */
         return N71_65_GetNextCalendar1(s,Note,start,&s->Phone.Data.Priv.N6510.LastCalendar,&s->Phone.Data.Priv.N6510.LastCalendarYear,&s->Phone.Data.Priv.N6510.LastCalendarPos);
 #endif              
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL62)) {
                 /* Method 1. Some features missed. Not working with some notes in 3510 */
                 return N71_65_GetNextCalendar1(s,Note,start,&s->Phone.Data.Priv.N6510.LastCalendar,&s->Phone.Data.Priv.N6510.LastCalendarYear,&s->Phone.Data.Priv.N6510.LastCalendarPos);
 
                     /* Method 2. In known phones texts of notes cut to 50 chars. Some features missed */
         //      return N71_65_GetNextCalendar2(s,Note,start,&s->Phone.Data.Priv.N6510.LastCalendarYear,&s->Phone.Data.Priv.N6510.LastCalendarPos);
         } else {
                     /* Method 3. All DCT4 features supported. Not supported by 8910 */
                     return N6510_GetNextCalendar3(s,Note,start,&s->Phone.Data.Priv.N6510.LastCalendar,&s->Phone.Data.Priv.N6510.LastCalendarYear,&s->Phone.Data.Priv.N6510.LastCalendarPos);
         }
 }
 
 static GSM_Error N6510_GetCalendarStatus(GSM_StateMachine *s, GSM_CalendarStatus *Status)
 {
         GSM_Error error;
 
 #ifdef GSM_FORCE_DCT4_CALENDAR_6210
         /* Method 1 */
         error=N71_65_GetCalendarInfo1(s, &s->Phone.Data.Priv.N6510.LastCalendar);
         if (error!=ERR_NONE) return error;
         Status->Used = s->Phone.Data.Priv.N6510.LastCalendar.Number;
         return ERR_NONE;
 #endif              
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL62)) {
                 /* Method 1 */
                 error=N71_65_GetCalendarInfo1(s, &s->Phone.Data.Priv.N6510.LastCalendar);
                 if (error!=ERR_NONE) return error;
                 Status->Used = s->Phone.Data.Priv.N6510.LastCalendar.Number;
                 return ERR_NONE;
 
                     /* Method 2 */
         //              return ERR_NOTSUPPORTED;        
         } else {
                 /* Method 3 */
-                error=N6510_GetCalendarInfo3(s,&s->Phone.Data.Priv.N6510.LastCalendar,true);
+                error=N6510_GetCalendarInfo3(s,&s->Phone.Data.Priv.N6510.LastCalendar,0);
                 if (error!=ERR_NONE) return error;
                 Status->Used = s->Phone.Data.Priv.N6510.LastCalendar.Number;
                 return ERR_NONE;
         }
 }
 
 static GSM_Error N6510_AddCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
 #ifdef GSM_FORCE_DCT4_CALENDAR_6210
         return N71_65_AddCalendar2(s,Note);
 #endif
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL62)) {
                 return N71_65_AddCalendar2(s,Note);
         //      return N71_65_AddCalendar1(s, Note, &s->Phone.Data.Priv.N6510.FirstCalendarPos);
         } else {
                 /* Method 3. All DCT4 features supported. Not supported by 8910 */
                 return N6510_AddCalendar3(s, Note, &s->Phone.Data.Priv.N6510.FirstCalendarPos);
         }
 }
 
 static GSM_Error N6510_ReplyLogIntoNetwork(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Probably phone says: I log into network\n");
         return ERR_NONE;
 }
 
 void N6510_EncodeFMFrequency(double freq, unsigned char *buff)
 {
                 double          freq0;
                 unsigned char   buffer[20];
                 unsigned int    i,freq2;
 
         sprintf(buffer,"%.3f",freq);
         for (i=0;i<strlen(buffer);i++) {
                 if (buffer[i] == ',' || buffer[i] == '.') buffer[i] = ' ';
         }
         StringToDouble(buffer, &freq0);
          freq2 = (unsigned int)freq0;
                 dbgprintf("Frequency: %s %i\n",buffer,freq2);
                 freq2= freq2 - 0xffff;
          buff[0] = freq2 / 0x100;
          buff[1] = freq2 % 0x100;
 }
 
 void N6510_DecodeFMFrequency(double *freq, unsigned char *buff)
 {
         unsigned char buffer[20];
 
         sprintf(buffer,"%i.%i",(0xffff + buff[0] * 0x100 + buff[1])/1000,
                                (0xffff + buff[0] * 0x100 + buff[1])%1000);
         dbgprintf("Frequency: %s\n",buffer);
         StringToDouble(buffer, freq);
 }
 
 static GSM_Error N6510_ReplyGetFMStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
           smprintf(s, "getting FM status OK\n");
         memcpy(s->Phone.Data.Priv.N6510.FMStatus,msg.Buffer,msg.Length);
         s->Phone.Data.Priv.N6510.FMStatusLength = msg.Length;
         return ERR_NONE;
 }
    
 static GSM_Error N6510_GetFMStatus(GSM_StateMachine *s)
 {
          unsigned char req[7] = {N6110_FRAME_HEADER, 0x0d, 0x00, 0x00, 0x01};
          
          if (!IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_RADIO)) return ERR_NOTSUPPORTED;
          return GSM_WaitFor (s, req, 7, 0x3E, 2, ID_GetFMStation);
 }
 
 static GSM_Error N6510_ReplyGetFMStation(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 unsigned char name[GSM_MAX_FMSTATION_LENGTH*2+2];
                 int     length;
                 GSM_Phone_Data*Data = &s->Phone.Data;
   
         switch (msg.Buffer[3]) {
         case 0x06:
                   smprintf(s, "Received FM station\n");
                 length = msg.Buffer[8];
                 memcpy(name,msg.Buffer+18,length*2);
                         name[length*2] = 0x00;
                 name[length*2+1] = 0x00;
                 CopyUnicodeString(Data->FMStation->StationName,name);
                 smprintf(s,"Station name: \"%s\"\n",DecodeUnicodeString(Data->FMStation->StationName));
                 N6510_DecodeFMFrequency(&Data->FMStation->Frequency, msg.Buffer+16);
                 return ERR_NONE;
         case 0x16:
                   smprintf(s, "Received FM station. Empty ?\n");
                 return ERR_EMPTY;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_GetFMStation (GSM_StateMachine *s, GSM_FMStation *FMStation)
@@ -3879,276 +3925,312 @@ static GSM_Error N6510_ClearFMStations (GSM_StateMachine *s)
         return GSM_WaitFor (s, req, 7, 0x3E, 2, ID_SetFMStation);
 }
  
 static GSM_Error N6510_SetFMStation (GSM_StateMachine *s, GSM_FMStation *FMStation)
 {
                 unsigned int            len, location;
                 GSM_Error       error;
          unsigned char setstatus[36] = {N6110_FRAME_HEADER,0x11,0x00,0x01,0x01,
                                 0x00,0x00,0x1c,0x00,0x14,0x00,0x00,
                                 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
                                 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
                                 0xff,0xff,0xff,0xff,0xff,0x01};
          unsigned char req[64] = {N6110_FRAME_HEADER, 0x12,0x00,0x01,0x00,
                                         0x00,           // 0x0e + (strlen(name) * 2)
                                         0x00,           // strlen(name)
                                 0x14,0x09,0x00,
                                         0x00,           // location
                                 0x00,0x00,0x01,
                                         0x00,           // freqHi
                                         0x00,           // freqLo
                                 0x01};
 
          if (!IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_RADIO)) return ERR_NOTSUPPORTED;
  
          s->Phone.Data.FMStation = FMStation;
          location = FMStation->Location-1;
 
          error = N6510_GetFMStatus(s);
          if (error != ERR_NONE) return error;
 
          memcpy(setstatus+14,s->Phone.Data.Priv.N6510.FMStatus+14,20);
          setstatus [14+location] = location;
         
          smprintf(s, "Setting FM status %i\n",FMStation->Location);
          error = GSM_WaitFor (s, setstatus, 36 , 0x3E, 2, ID_SetFMStation);
                 if (error != ERR_NONE) return error;
 
          req[12] = location;
 
         /* Name */
                 len = UnicodeLength(FMStation->StationName);
                 req[8] = len;
                 req[7] = 0x0e + len * 2;
          memcpy (req+18,FMStation->StationName,len*2);
 
         /* Frequency */
         N6510_EncodeFMFrequency(FMStation->Frequency, req+16);
 
          smprintf(s, "Setting FM Station %i\n",FMStation->Location);
          return GSM_WaitFor (s, req, 0x13+len*2, 0x3E, 2, ID_SetFMStation);
 }
 
 static GSM_Error N6510_ReplySetLight(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Light set\n");
         return ERR_NONE;
 }
 
 GSM_Error N6510_SetLight(GSM_StateMachine *s, N6510_PHONE_LIGHTS light, bool enable)
 {
         unsigned char req[14] = {
                 N6110_FRAME_HEADER, 0x05,
                         0x01,   /* 0x01 = Display, 0x03 = keypad */
                         0x01,   /* 0x01 = Enable, 0x02 = disable */
                 0x00, 0x00, 0x00, 0x01,
                 0x05, 0x04, 0x02, 0x00};
 
         req[4] = light;
         if (!enable) req[5] = 0x02;
          smprintf(s, "Setting light\n");
         return GSM_WaitFor (s, req, 14, 0x3A, 4, ID_SetLight);
 }
 
 static GSM_Error N6510_ShowStartInfo(GSM_StateMachine *s, bool enable)
 {
         GSM_Error error;
 
         if (enable) {
                 error=N6510_SetLight(s,N6510_LIGHT_DISPLAY,true);
                 if (error != ERR_NONE) return error;
 
                 error=N6510_SetLight(s,N6510_LIGHT_TORCH,true);
                 if (error != ERR_NONE) return error;
 
                 return N6510_SetLight(s,N6510_LIGHT_KEYPAD,true);
         } else {
                 error=N6510_SetLight(s,N6510_LIGHT_DISPLAY,false);
                 if (error != ERR_NONE) return error;
 
                 error=N6510_SetLight(s,N6510_LIGHT_TORCH,false);
                 if (error != ERR_NONE) return error;
 
                 return N6510_SetLight(s,N6510_LIGHT_KEYPAD,false);
         }
 }
 
+static GSM_Error N6510_ReplyGetNoteInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+        return N6510_ReplyGetCalendarInfo3(msg, s, &s->Phone.Data.Priv.N6510.LastNote);
+}
+
+static GSM_Error N6510_ReplyGetNote(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+        smprintf(s, "Note received\n");
+        memcpy(s->Phone.Data.Note->Text,msg.Buffer+54,(msg.Buffer[50]*256+msg.Buffer[51])*2);
+        s->Phone.Data.Note->Text[(msg.Buffer[50]*256+msg.Buffer[51])*2] = 0;
+        s->Phone.Data.Note->Text[(msg.Buffer[50]*256+msg.Buffer[51])*2+1] = 0;
+        return ERR_NONE;
+}
+
+GSM_Error N6510_GetNextNote(GSM_StateMachine *s, GSM_NoteEntry *Note, bool start)
+{
+                GSM_Error               error;
+                GSM_NOKIACalToDoLocations       *LastNote = &s->Phone.Data.Priv.N6510.LastNote;
+
+        if (!IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_NOTES)) return ERR_NOTSUPPORTED;
+
+        if (start) {
+                error=N6510_GetCalendarInfo3(s,LastNote,2);
+                if (error!=ERR_NONE) return error;
+                Note->Location = 1;
+        } else {
+                Note->Location++;
+        }
+                
+        if (Note->Location > LastNote->Number) return ERR_EMPTY;
+
+        s->Phone.Data.Note = Note;
+        smprintf(s, "Getting note\n");
+        return N6510_PrivGetGenericCalendar3(s, LastNote->Location[Note->Location-1], ID_GetNote);
+}
+
 static int N6510_FindFileCheckSum(unsigned char *ptr, int len)
 {
         int acc, i, accx;
  
         accx = 0;
         acc  = 0xffff; 
         while (len--) {
                 accx = (accx & 0xffff00ff) | (acc & 0xff00);
                 acc  = (acc  & 0xffff00ff) | *ptr++ << 8;
                 for (i = 0; i < 8; i++) {
                         acc <<= 1;
                         if (acc & 0x10000)     acc ^= 0x1021; 
                         if (accx & 0x80000000) acc ^= 0x1021; 
                         accx <<= 1;
                 }
         }
         dbgprintf("Checksum from Gammu is %04X\n",(acc & 0xffff));
         return (acc & 0xffff);
 }
 
 static GSM_Error N6510_ReplyGetFileFolderInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_File         *File = s->Phone.Data.FileInfo;
                 GSM_Phone_N6510Data*Priv = &s->Phone.Data.Priv.N6510;
                 int             i;
 
         switch (msg.Buffer[3]) {
         case 0x15:
                 smprintf(s,"File or folder details received\n");
                 CopyUnicodeString(File->Name,msg.Buffer+10);
                 if (!strncmp(DecodeUnicodeString(File->Name),"GMSTemp",7)) return ERR_EMPTY;
                 if (File->Name[0] == 0x00 && File->Name[1] == 0x00) return ERR_UNKNOWN;
 
                 i = msg.Buffer[8]*256+msg.Buffer[9];
                 dbgprintf("%02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
                         msg.Buffer[i-5],msg.Buffer[i-4],msg.Buffer[i-3],
                         msg.Buffer[i-2],msg.Buffer[i-1],msg.Buffer[i],
                         msg.Buffer[i+1],msg.Buffer[i+2],msg.Buffer[i+3]);
 
                         File->Folder = false;
                         if (msg.Buffer[i-5] == 0x00) File->Folder = true;
 
                         File->ReadOnly = false;
                 File->Protected = false;
                         File->System= false;
                         File->Hidden= false;
                         if (msg.Buffer[i+2] == 0x01) File->Protected = true;
                         if (msg.Buffer[i+4] == 0x01) File->ReadOnly = true;
                         if (msg.Buffer[i+5] == 0x01) File->Hidden= true;
                         if (msg.Buffer[i+6] == 0x01) File->System= true;//fixme
 
                 File->ModifiedEmpty = false;
                 NOKIA_DecodeDateTime(s, msg.Buffer+i-22, &File->Modified);
                 if (File->Modified.Year == 0x00) File->ModifiedEmpty = true;
                 dbgprintf("%02x %02x %02x %02x\n",msg.Buffer[i-22],msg.Buffer[i-21],msg.Buffer[i-20],msg.Buffer[i-19]);
 
                 Priv->FileToken = msg.Buffer[i-10]*256+msg.Buffer[i-9];
                 Priv->ParentID  = msg.Buffer[i]*256+msg.Buffer[i+1];
                 smprintf(s,"ParentID is %i\n",Priv->ParentID);
 
                 File->Type = GSM_File_Other;
                 if (msg.Length > 240){
                         i = 227;
                         if (msg.Buffer[i]==0x02 && msg.Buffer[i+2]==0x01)
                                 File->Type = GSM_File_Image_JPG;
                         else if (msg.Buffer[i]==0x02 && msg.Buffer[i+2]==0x02)
                                 File->Type = GSM_File_Image_BMP;
                         else if (msg.Buffer[i]==0x02 && msg.Buffer[i+2]==0x07)
                                 File->Type = GSM_File_Image_BMP;
                         else if (msg.Buffer[i]==0x02 && msg.Buffer[i+2]==0x03)
                                 File->Type = GSM_File_Image_PNG;
                         else if (msg.Buffer[i]==0x02 && msg.Buffer[i+2]==0x05)
                                 File->Type = GSM_File_Image_GIF;
                         else if (msg.Buffer[i]==0x02 && msg.Buffer[i+2]==0x09)
                                 File->Type = GSM_File_Image_WBMP;
                         else if (msg.Buffer[i]==0x04 && msg.Buffer[i+2]==0x01)
                                 File->Type = GSM_File_Sound_AMR;
                         else if (msg.Buffer[i]==0x04 && msg.Buffer[i+2]==0x02)
                                 File->Type = GSM_File_Sound_MIDI;
                         else if (msg.Buffer[i]==0x08 && msg.Buffer[i+2]==0x05)
                                 File->Type = GSM_File_Video_3GP;
                         else if (msg.Buffer[i]==0x10 && msg.Buffer[i+2]==0x01)
                                 File->Type = GSM_File_Java_JAR;
-#if DEVELOP
+#ifdef DEVELOP
                         else if (msg.Buffer[i]==0x00 && msg.Buffer[i+2]==0x01)
                                 File->Type = GSM_File_MMS;
 #endif
                 }
                         return ERR_NONE;
         case 0x2F:
                 smprintf(s,"File or folder used bytes received\n");
                 File->Used = msg.Buffer[6]*256*256*256+
                              msg.Buffer[7]*256*256+
                              msg.Buffer[8]*256+
                              msg.Buffer[9];
                 return ERR_NONE;
         case 0x33:
                 if (s->Phone.Data.RequestID == ID_GetFileInfo) {
                         i = Priv->FilesLocationsUsed-1;
                         while (1) {
                                 if (i==Priv->FilesLocationsCurrent-1) break;
                                 dbgprintf("Copying %i to %i, max %i, current %i\n",
                                         i,i+msg.Buffer[9],
                                         Priv->FilesLocationsUsed,Priv->FilesLocationsCurrent);
                                         Priv->FilesLocations[i+msg.Buffer[9]] = Priv->FilesLocations[i];
                                         Priv->FilesLevels[i+msg.Buffer[9]]= Priv->FilesLevels[i];
                                 i--;
                         }
                         Priv->FilesLocationsUsed += msg.Buffer[9];
                         for (i=0;i<msg.Buffer[9];i++) {
                                         Priv->FilesLocations[Priv->FilesLocationsCurrent+i] = msg.Buffer[13+i*4-1]*256 + msg.Buffer[13+i*4];
                                         Priv->FilesLevels[Priv->FilesLocationsCurrent+i] = File->Level+1;
                                 dbgprintf("%i ",Priv->FilesLocations[Priv->FilesLocationsCurrent+i]);
                         }
                         dbgprintf("\n");
                 }
                 if (msg.Buffer[9] != 0x00) File->Folder = true;
                         return ERR_NONE;        
         case 0x43:
                 Priv->FileCheckSum = msg.Buffer[6] * 256 + msg.Buffer[7];
                 smprintf(s,"File checksum from phone is %04X\n",Priv->FileCheckSum);
                 return ERR_NONE;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_GetFileFolderInfo(GSM_StateMachine *s, GSM_File *File, GSM_Phone_RequestID Request)
 {
                 GSM_Error       error;
                 unsigned char   req[10] = {
                 N7110_FRAME_HEADER,
                 0x14,           /* 0x14 - info, 0x22 - free/total, 0x2E - used, 0x32 - sublocations */
                         0x01,   /* 0x00 for sublocations reverse sorting, 0x01 for free */
                 0x00, 0x00, 0x01,
                         0x00, 0x01};/* Folder or file number */
                 unsigned char   GetCRC[] = {
                 N7110_FRAME_HEADER, 0x42, 0x00, 0x00, 0x00, 0x01,
                         0x00, 0x1E}; /* file ID */
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_NOFILESYSTEM)) return ERR_NOTSUPPORTED;
 
                 s->Phone.Data.FileInfo = File;
                 req[8]          = atoi(File->ID_FullName) / 256;
                 req[9]                  = atoi(File->ID_FullName) % 256;
 
         req[3] = 0x14;
         req[4] = 0x01;
         smprintf(s,"Getting info for file in filesystem\n");
         error=GSM_WaitFor (s, req, 10, 0x6D, 4, Request);
         if (error != ERR_NONE) return error;
 
         if (Request != ID_AddFile) {
                 req[3] = 0x32;
                 req[4] = 0x00;
                 smprintf(s,"Getting subfolders for filesystem\n");
                 error=GSM_WaitFor (s, req, 10, 0x6D, 4, Request);
                 if (error != ERR_NONE) return error;
 
                 if (!File->Folder) {
                         req[3] = 0x2E;
                         req[4] = 0x01;
                         smprintf(s,"Getting used memory for file in filesystem\n");
                         error=GSM_WaitFor (s, req, 10, 0x6D, 4, Request);
                         if (error != ERR_NONE) return error;
 
                         GetCRC[8] = atoi(File->ID_FullName) / 256;
                         GetCRC[9] = atoi(File->ID_FullName) % 256;
                         smprintf(s,"Getting CRC for file in filesystem\n");
                         error=GSM_WaitFor (s, GetCRC, 10, 0x6D, 4, Request);
                 }
         }
         return error;
 }
 
 static GSM_Error N6510_GetNextFileFolder(GSM_StateMachine *s, GSM_File *File, bool start)
 {
                 GSM_Phone_N6510Data*Priv = &s->Phone.Data.Priv.N6510;
                 GSM_Error       error;
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_NOFILESYSTEM)) return ERR_NOTSUPPORTED;
@@ -4305,193 +4387,193 @@ static GSM_Error N6510_GetFilePart(GSM_StateMachine *s, GSM_File *File)
                 GSM_Error       error;
                 unsigned char   req[] = {
                 N7110_FRAME_HEADER, 0x0E, 0x00, 0x00, 0x00, 0x01,
                         0x00, 0x01,     /* Folder or file number */
                         0x00, 0x00, 0x00, 0x00,/* Start from xxx byte */
                 0x00, 0x00,
                         0x03, 0xE8};    /* Read xxx bytes */
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_NOFILESYSTEM)) return ERR_NOTSUPPORTED;
 
         if (File->Used == 0x00) {
                 error = N6510_GetFileFolderInfo(s, File, ID_GetFile);
                 if (error != ERR_NONE) return error;
                 File->Used = 0;
         }
 
                 old             = File->Used;
                 req[8]                  = atoi(File->ID_FullName) / 256;
                 req[9]                  = atoi(File->ID_FullName) % 256;
         req[10]                 = old / (256*256*256);
         req[11]                 = old / (256*256);
         req[12]                 = old / 256;
         req[13]                 = old % 256;
 
                 s->Phone.Data.File = File;
         smprintf(s, "Getting file part from filesystem\n");
         error=GSM_WaitFor (s, req, 18, 0x6D, 4, ID_GetFile);
         if (error != ERR_NONE) return error;
         if (File->Used - old != (0x03 * 256 + 0xE8)) {
                 if (N6510_FindFileCheckSum(File->Buffer, File->Used) != Priv->FileCheckSum) {
                         smprintf(s,"File2 checksum is %i, File checksum is %i\n",N6510_FindFileCheckSum(File->Buffer, File->Used),Priv->FileCheckSum);
                         return ERR_WRONGCRC;
                 }
                 return ERR_EMPTY;
         }
         return ERR_NONE;
 }
 
 static GSM_Error N6510_SetReadOnly(GSM_StateMachine *s, unsigned char *ID, bool enable)
 {
         unsigned char SetAttr[] = {
                 N7110_FRAME_HEADER, 0x18, 0x00, 0x00, 0x00, 0x01,
                         0x00, 0x20};    /* File ID */
 
         if (!enable) SetAttr[4] = 0x06;
 
         SetAttr[8] = atoi(ID) / 256;
         SetAttr[9] = atoi(ID) % 256;
         smprintf(s, "Setting readonly attribute\n");
         return GSM_WaitFor (s, SetAttr, 10, 0x6D, 4, ID_DeleteFile);
 }
 
 static GSM_Error N6510_ReplyAddFileHeader(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         switch (msg.Buffer[3]) {
         case 0x03:
                 smprintf(s,"File header added\n");
                 sprintf(s->Phone.Data.File->ID_FullName,"%i",msg.Buffer[9]);
                 return ERR_NONE;
         case 0x13:
                 return ERR_NONE;
         }
         return ERR_UNKNOWNRESPONSE;
 }
 
 static GSM_Error N6510_ReplyAddFilePart(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         return ERR_NONE;
 }
 
 static GSM_Error N6510_AddFilePart(GSM_StateMachine *s, GSM_File *File, int *Pos)
 {
                 GSM_Phone_N6510Data*Priv = &s->Phone.Data.Priv.N6510;
                 GSM_File        File2;
                 GSM_Error       error;
                 int             j;
                 unsigned char   Header[400] = {
                 N7110_FRAME_HEADER, 0x02, 0x00, 0x00, 0x00, 0x01,
                         0x00, 0x0C,     /* parent folder ID */
                 0x00, 0x00, 0x00, 0xE8};
                 unsigned char   Add[15000] = {
                 N7110_FRAME_HEADER, 0x40, 0x00, 0x00, 0x00, 0x01,
                         0x00, 0x04,     /* file ID */
                 0x00, 0x00, 
                         0x01, 0x28};    /* length */
         unsigned char end[30] = {
                 N7110_FRAME_HEADER, 0x40, 0x00, 0x00, 0x00, 0x01,
                         0x00, 0x04,     /* file ID */
                 0x00, 0x00, 0x00, 0x00};
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_NOFILESYSTEM)) return ERR_NOTSUPPORTED;
 
         s->Phone.Data.File = File;
 
         if (*Pos == 0) {
                 error = N6510_SearchForFileName(s,File);
-                if (error == ERR_NONE) return ERR_INVALIDLOCATION;
+                if (error == ERR_NONE) return ERR_FILEALREADYEXIST;
                 if (error != ERR_EMPTY) return error;
 
                 Header[8] = atoi(File->ID_FullName) / 256;
                 Header[9] = atoi(File->ID_FullName) % 256;
                 memset(Header+14, 0x00, 300);
                 CopyUnicodeString(Header+14,File->Name);
                 Header[222] = File->Used / (256*256*256);
                 Header[223] = File->Used / (256*256);
                 Header[224] = File->Used / 256;
                 Header[225] = File->Used % 256;
                 switch(File->Type) {
                         case GSM_File_Image_JPG    : Header[231]=0x02; Header[233]=0x01; break;
                         case GSM_File_Image_BMP    : Header[231]=0x02; Header[233]=0x02; break;
                         case GSM_File_Image_PNG    : Header[231]=0x02; Header[233]=0x03; break;
                         case GSM_File_Image_GIF    : Header[231]=0x02; Header[233]=0x05; break;
                         case GSM_File_Image_WBMP   : Header[231]=0x02; Header[233]=0x09; break;
                             case GSM_File_Sound_AMR    : Header[231]=0x04; Header[233]=0x01; break;
                             case GSM_File_Sound_MIDI   : Header[231]=0x04; Header[233]=0x05; break; //Header[238]=0x01; 
                             case GSM_File_Sound_NRT    : Header[231]=0x04; Header[233]=0x06; break;
                             case GSM_File_Video_3GP    : Header[231]=0x08; Header[233]=0x05; break;
                             case GSM_File_Java_JAR     : Header[231]=0x10; Header[233]=0x01; break;
 #ifdef DEVELOP
                         case GSM_File_MMS:
                                 Header[214]=0x07;
                                 Header[215]=0xd3;
                                 Header[216]=0x06;
                                 Header[217]=0x01;
                                 Header[218]=0x12;
                                 Header[219]=0x13;
                                 Header[220]=0x29;
                                 Header[233]=0x01;
                                 break;
 #endif
                         default                    : Header[231]=0x01; Header[233]=0x05;
                 }
                 Header[235] = 0x01;
                 Header[236] = atoi(File->ID_FullName) / 256;
                 Header[237] = atoi(File->ID_FullName) % 256;
                 if (File->Protected) Header[238] = 0x01; //Nokia forward lock
                 if (File->Hidden)    Header[241] = 0x01;
                 if (File->System)    Header[242] = 0x01; //fixme
                 smprintf(s, "Adding file header\n");
                 error=GSM_WaitFor (s, Header, 246, 0x6D, 4, ID_AddFile);
                 if (error != ERR_NONE) return error;
         }
 
         j = 1000;
         if (File->Used - *Pos < 1000) j = File->Used - *Pos;
         Add[ 8] = atoi(File->ID_FullName) / 256;
         Add[ 9] = atoi(File->ID_FullName) % 256;
         Add[12] = j / 256;
         Add[13] = j % 256;
         memcpy(Add+14,File->Buffer+(*Pos),j);
         smprintf(s, "Adding file part %i %i\n",*Pos,j);
         error=GSM_WaitFor (s, Add, 14+j, 0x6D, 4, ID_AddFile);
         if (error != ERR_NONE) return error;
         *Pos = *Pos + j;
 
         if (j < 1000) {
                 end[8] = atoi(File->ID_FullName) / 256;
                 end[9] = atoi(File->ID_FullName) % 256;
                 smprintf(s, "Frame for ending adding file\n");
                 error = GSM_WaitFor (s, end, 14, 0x6D, 4, ID_AddFile);
                 if (error != ERR_NONE) return error;
 
                 strcpy(File2.ID_FullName,File->ID_FullName);
                 error = N6510_GetFileFolderInfo(s, &File2, ID_GetFileInfo);
                 if (error != ERR_NONE) return error;
 
                 if (!File->ModifiedEmpty) {
                         Header[3]   = 0x12;
                         Header[4]   = 0x01;
                         Header[12]  = 0x00;
                         Header[13]  = 0xE8;
                         Header[8]   = atoi(File->ID_FullName) / 256;
                         Header[9]   = atoi(File->ID_FullName) % 256;
                         memset(Header+14, 0x00, 300);
                         CopyUnicodeString(Header+14,File->Name);
                         NOKIA_EncodeDateTime(s,Header+214,&File->Modified);
                         /* When you save too big file for phone and it changes
                          * size (some part is cut by firmware), you HAVE to write
                          * here correct file size. In other case filesystem
                          * will be damaged
                          */
                         Header[224] = File2.Used / 256;
                         Header[225] = File2.Used % 256;
                         Header[226] = Priv->FileToken / 256;
                         Header[227] = Priv->FileToken % 256;
                         switch(File->Type) {
                                 case GSM_File_Image_JPG    : Header[231]=0x02; Header[233]=0x01; break;
                                 case GSM_File_Image_BMP    : Header[231]=0x02; Header[233]=0x02; break;
                                 case GSM_File_Image_PNG    : Header[231]=0x02; Header[233]=0x03; break;
                                 case GSM_File_Image_GIF    : Header[231]=0x02; Header[233]=0x05; break;
                                 case GSM_File_Image_WBMP   : Header[231]=0x02; Header[233]=0x09; break;
                                    case GSM_File_Sound_AMR    : Header[231]=0x04; Header[233]=0x01; break;
                                 case GSM_File_Sound_MIDI   : Header[231]=0x04; Header[233]=0x05; break; //Header[238]=0x01; 
@@ -4721,422 +4803,413 @@ static GSM_Error N6510_SetGPRSAccessPoint(GSM_StateMachine *s, GSM_GPRSAccessPoi
                 N7110_FRAME_HEADER, 0x05, 0x00, 0x00, 0x00, 0x2C, 0x00,
                 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00};
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_NOGPRSPOINT)) return ERR_NOTSUPPORTED;
         if (point->Location < 1) return ERR_UNKNOWN;
         if (point->Location > 5) return ERR_INVALIDLOCATION;
 
         s->Phone.Data.GPRSPoint = point;
 
 #ifdef DEVELOP
         error = N6510_EnableGPRSAccessPoint(s);
         if (error != ERR_NONE) return error;
 #endif
 
         smprintf(s, "Getting GPRS access point name\n");
         error=GSM_WaitFor (s, Name, 16, 0x43, 4, ID_SetGPRSPoint);
         if (error != ERR_NONE) return error;
         CopyUnicodeString(buff+18+(point->Location-1)*42,point->Name);
         buff[0] = 0x00;
         buff[1] = 0x01;
         buff[2] = 0x01;
         buff[3] = 0x07;
         smprintf(s, "Setting GPRS access point name\n");
         error=GSM_WaitFor (s, buff, s->Phone.Data.Priv.N6510.GPRSPointsLength, 0x43, 4, ID_SetGPRSPoint);
         if (error != ERR_NONE) return error;
 
         smprintf(s, "Getting GPRS access point URL\n");
         error=GSM_WaitFor (s, URL, 16, 0x43, 4, ID_SetGPRSPoint);
         if (error != ERR_NONE) return error;
         CopyUnicodeString(buff+18+(point->Location-1)*42,point->URL);
         buff[0] = 0x00;
         buff[1] = 0x01;
         buff[2] = 0x01;
         buff[3] = 0x07;
         smprintf(s, "Setting GPRS access point URL\n");
         error=GSM_WaitFor (s, buff, s->Phone.Data.Priv.N6510.GPRSPointsLength, 0x43, 4, ID_SetGPRSPoint);
         if (error != ERR_NONE) return error;
 
         if (point->Active) {
                 smprintf(s, "Getting number of active GPRS access point\n");
                 error=GSM_WaitFor (s, Active, 16, 0x43, 4, ID_SetGPRSPoint);
                 if (error != ERR_NONE) return error;
                 buff[0] = 0x00;
                 buff[1] = 0x01;
                 buff[2] = 0x01;
                 buff[3] = 0x07;
                 buff[18]= point->Location;
                 smprintf(s, "Setting number of active GPRS access point\n");
                 error=GSM_WaitFor (s, buff, s->Phone.Data.Priv.N6510.GPRSPointsLength, 0x43, 4, ID_SetGPRSPoint);
                 if (error != ERR_NONE) return error;
         }
 
         return error;
 }
 
 /* ToDo support - 6310 style */
 static GSM_Error N6510_ReplyGetToDoStatus1(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 int                     i;
                 GSM_NOKIACalToDoLocations*Last = &s->Phone.Data.Priv.N6510.LastToDo;
 
         smprintf(s, "TODO locations received\n");
         Last->Number=msg.Buffer[6]*256+msg.Buffer[7];
         smprintf(s, "Number of Entries: %i\n",Last->Number);
         smprintf(s, "Locations: ");
         for (i=0;i<Last->Number;i++) {
                 Last->Location[i]=msg.Buffer[12+(i*4)]*256+msg.Buffer[(i*4)+13];
                 smprintf(s, "%i ",Last->Location[i]);
         }
         smprintf(s, "\n");
         return ERR_NONE;
 }
 
 /* ToDo support - 6310 style */
 static GSM_Error N6510_GetToDoStatus1(GSM_StateMachine *s, GSM_ToDoStatus *status)
 {
                 GSM_Error               error;
                 GSM_NOKIACalToDoLocations*LastToDo = &s->Phone.Data.Priv.N6510.LastToDo;
         unsigned char reqLoc[] = {
                         N6110_FRAME_HEADER,
                         0x15, 0x01, 0x00, 0x00,
                         0x00, 0x00, 0x00};
 
         smprintf(s, "Getting ToDo locations\n");
         error = GSM_WaitFor (s, reqLoc, 10, 0x55, 4, ID_GetToDo);
         if (error != ERR_NONE) return error;
 
         status->Used = LastToDo->Number;
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetToDoStatus2(GSM_StateMachine *s, GSM_ToDoStatus *status)
 {
                 GSM_NOKIACalToDoLocations*LastToDo = &s->Phone.Data.Priv.N6510.LastToDo;
                 GSM_Error               error;
 
-        error = N6510_GetCalendarInfo3(s,LastToDo,false);
+        error = N6510_GetCalendarInfo3(s,LastToDo,1);
         if (error!=ERR_NONE) return error;
 
         status->Used = LastToDo->Number;
         return ERR_NONE;
 }
 
 static GSM_Error N6510_GetToDoStatus(GSM_StateMachine *s, GSM_ToDoStatus *status)
 {
         status->Used = 0;
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_TODO63)) {
                 return N6510_GetToDoStatus1(s, status);
         } else if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_TODO66)) {
                 return N6510_GetToDoStatus2(s, status);
         } else {
                 return ERR_NOTSUPPORTED;
         }
 }
 
 /* ToDo support - 6310 style */
 static GSM_Error N6510_ReplyGetToDo1(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         GSM_ToDoEntry *Last = s->Phone.Data.ToDo;
 
         smprintf(s, "TODO received method 1\n");
 
         switch (msg.Buffer[4]) {
                         case 1  : Last->Priority = GSM_Priority_High; break;
                 case 2  : Last->Priority = GSM_Priority_Medium; break;
                         case 3  : Last->Priority = GSM_Priority_Low; break;
                         default: return ERR_UNKNOWN;
                 }
         smprintf(s, "Priority: %i\n",msg.Buffer[4]);
 
         CopyUnicodeString(Last->Entries[0].Text,msg.Buffer+14);
          Last->Entries[0].EntryType = TODO_TEXT;
                 Last->EntriesNum         = 1;
         smprintf(s, "Text: \"%s\"\n",DecodeUnicodeString(Last->Entries[0].Text));
 
         return ERR_NONE;
 }
 
 /* ToDo support - 6310 style */
 static GSM_Error N6510_GetNextToDo1(GSM_StateMachine *s, GSM_ToDoEntry *ToDo, bool refresh)
 {
                 GSM_Error               error;
                 GSM_ToDoStatus                  status;
                 GSM_NOKIACalToDoLocations*LastToDo = &s->Phone.Data.Priv.N6510.LastToDo;
         unsigned char reqGet[] = {
                         N6110_FRAME_HEADER,
                         0x03, 0x00, 0x00, 0x80, 0x00,
                                 0x00, 0x17};    /* Location */
 
         if (refresh) {
                 error = N6510_GetToDoStatus(s, &status);
                 if (error != ERR_NONE) return error;
                 ToDo->Location = 1;
         } else {
                 ToDo->Location++;
         }
         if (ToDo->Location > LastToDo->Number) return ERR_EMPTY;
 
         reqGet[8] = LastToDo->Location[ToDo->Location-1] / 256;
         reqGet[9] = LastToDo->Location[ToDo->Location-1] % 256;
                 s->Phone.Data.ToDo = ToDo;
         smprintf(s, "Getting ToDo\n");
         return GSM_WaitFor (s, reqGet, 10, 0x55, 4, ID_GetToDo);
 }
 
 static GSM_Error N6510_ReplyGetToDoStatus2(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         return N6510_ReplyGetCalendarInfo3(msg, s, &s->Phone.Data.Priv.N6510.LastToDo);
 }
 
 /* Similiar to getting calendar method 3 */
 static GSM_Error N6510_ReplyGetToDo2(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_ToDoEntry   *Last = s->Phone.Data.ToDo;
                 GSM_DateTime    Date;
                 unsigned long   diff;
 
         smprintf(s, "ToDo received method 2\n");
 
         switch (msg.Buffer[44]) {
                         case 0x10: Last->Priority = GSM_Priority_Low;   break;
                         case 0x20: Last->Priority = GSM_Priority_Medium; break;
                         case 0x30: Last->Priority = GSM_Priority_High;          break;
                         default : return ERR_UNKNOWN;
                 }
 
         memcpy(Last->Entries[0].Text,msg.Buffer+54,msg.Buffer[51]*2);
         Last->Entries[0].Text[msg.Buffer[51]*2]   = 0;
         Last->Entries[0].Text[msg.Buffer[51]*2+1] = 0;
             Last->Entries[0].EntryType = TODO_TEXT;
         smprintf(s, "Text: \"%s\"\n",DecodeUnicodeString(Last->Entries[0].Text));
 
         smprintf(s,"EndTime: %04i-%02i-%02i %02i:%02i\n",
                 msg.Buffer[34]*256+msg.Buffer[35],
                 msg.Buffer[36],msg.Buffer[37],msg.Buffer[38],
                 msg.Buffer[39]);
                 Date.Year = msg.Buffer[34]*256+msg.Buffer[35];
                 Date.Month = msg.Buffer[36];
                 Date.Day = msg.Buffer[37];
                 Date.Hour = msg.Buffer[38];
                 Date.Minute = msg.Buffer[39];
                 Date.Second= 0;
         Last->Entries[1].EntryType = TODO_END_DATETIME;
         memcpy(&Last->Entries[1].Date,&Date,sizeof(GSM_DateTime));
 
         smprintf(s,"StartTime: %04i-%02i-%02i %02i:%02i\n",
                 msg.Buffer[28]*256+msg.Buffer[29],
                 msg.Buffer[30],msg.Buffer[31],msg.Buffer[32],
                 msg.Buffer[33]);
                 Date.Year       = msg.Buffer[28]*256+msg.Buffer[29];
                 Date.Month = msg.Buffer[30];
                 Date.Day = msg.Buffer[31];
                 Date.Hour = msg.Buffer[32];
                 Date.Minute = msg.Buffer[33];
                 Date.Second= 0;
 
         Last->EntriesNum = 2;
 
         if (msg.Buffer[45] == 0x01) {
                         Last->Entries[2].Number         = msg.Buffer[45];
                         Last->Entries[2].EntryType = TODO_COMPLETED;
                 Last->EntriesNum++;
                 smprintf(s,"Completed\n");
         }
 
-        if (msg.Buffer[14] == 0xFF && msg.Buffer[15] == 0xFF && msg.Buffer[16] == 0xff && msg.Buffer[17] == 0xff)
-        {
+        if (msg.Buffer[14] == 0xFF && msg.Buffer[15] == 0xFF && msg.Buffer[16] == 0xff && msg.Buffer[17] == 0xff) {
                 smprintf(s, "No alarm\n");
         } else {
                 diff  = ((unsigned int)msg.Buffer[14]) << 24;
                 diff += ((unsigned int)msg.Buffer[15]) << 16;
                 diff += ((unsigned int)msg.Buffer[16]) << 8;
                 diff += msg.Buffer[17];
 
                 memcpy(&Last->Entries[Last->EntriesNum].Date,&Date,sizeof(GSM_DateTime));
                 GetTimeDifference(diff, &Last->Entries[Last->EntriesNum].Date, false, 60);
                 smprintf(s, "Alarm date   : %02i-%02i-%04i %02i:%02i:%02i\n",
                         Last->Entries[Last->EntriesNum].Date.Day,   Last->Entries[Last->EntriesNum].Date.Month,
                         Last->Entries[Last->EntriesNum].Date.Year,  Last->Entries[Last->EntriesNum].Date.Hour,
                         Last->Entries[Last->EntriesNum].Date.Minute,Last->Entries[Last->EntriesNum].Date.Second);
 
                 Last->Entries[Last->EntriesNum].EntryType = TODO_ALARM_DATETIME;
                 if (msg.Buffer[22]==0x00 && msg.Buffer[23]==0x00 &&
                     msg.Buffer[24]==0x00 && msg.Buffer[25]==0x00)
                 {
                         Last->Entries[Last->EntriesNum].EntryType = TODO_SILENT_ALARM_DATETIME;
                         smprintf(s, "Alarm type   : Silent\n");
                 }
                 Last->EntriesNum++;
         }
         
         return ERR_NONE;
 }
 
 /* ToDo support - 6610 style */
 static GSM_Error N6510_GetNextToDo2(GSM_StateMachine *s, GSM_ToDoEntry *ToDo, bool refresh)
 {
                 GSM_Error               error;
                 GSM_NOKIACalToDoLocations       *LastToDo = &s->Phone.Data.Priv.N6510.LastToDo;
-        /* The same to getting calendar method 3 */
-                unsigned char           req[] = { 
-                N6110_FRAME_HEADER,0x7D,0x00,0x00,0x00,0x00,
-                        0x00,0x99,              /* Location */
-                        0xff,0xff,0xff,0xff,0x01};
 
         if (refresh) {
-                error=N6510_GetCalendarInfo3(s,LastToDo,false);
+                error=N6510_GetCalendarInfo3(s,LastToDo,1);
                 if (error!=ERR_NONE) return error;
                 ToDo->Location = 1;
         } else {
                 ToDo->Location++;
         }
                 
         if (ToDo->Location > LastToDo->Number) return ERR_EMPTY;
 
-        req[8] = LastToDo->Location[ToDo->Location-1] / 256;
-        req[9] = LastToDo->Location[ToDo->Location-1] % 256;
-                        
                 s->Phone.Data.ToDo = ToDo;
         smprintf(s, "Getting todo method 2\n");
-        return GSM_WaitFor (s, req, 15, 0x13, 4, ID_GetToDo);
+        return N6510_PrivGetGenericCalendar3(s, LastToDo->Location[ToDo->Location-1], ID_GetToDo);
 }
 
 static GSM_Error N6510_GetNextToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo, bool refresh)
 {
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_TODO63)) {
                 return N6510_GetNextToDo1(s, ToDo, refresh);
         } else if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_TODO66)) {
                 return N6510_GetNextToDo2(s, ToDo, refresh);
         } else {
                 return ERR_NOTSUPPORTED;
         }
 }
 
 /* ToDo support - 6310 style */
 static GSM_Error N6510_ReplyDeleteAllToDo1(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "All TODO deleted\n");
         return ERR_NONE;
 }
 
 /* ToDo support - 6310 style */
 static GSM_Error N6510_DeleteAllToDo1(GSM_StateMachine *s)
 {
         unsigned char req[] = {N6110_FRAME_HEADER, 0x11};
 
         if (!IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_TODO63)) {
                 return ERR_NOTSUPPORTED;
         }
 
         smprintf(s, "Deleting all ToDo method 1\n");
         return GSM_WaitFor (s, req, 4, 0x55, 4, ID_DeleteAllToDo);
 }
 
 static GSM_Error N6510_DeleteToDo2(GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
 {
                 GSM_Error               error;
                 GSM_NOKIACalToDoLocations       *LastToDo = &s->Phone.Data.Priv.N6510.LastToDo;
                 GSM_CalendarEntry       Note;
 
         if (!IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_TODO66)) {
                 return ERR_NOTSUPPORTED;
         }
 
-        error=N6510_GetCalendarInfo3(s,LastToDo,false);
+        error=N6510_GetCalendarInfo3(s,LastToDo,1);
         if (error!=ERR_NONE) return error;
 
         smprintf(s, "Deleting ToDo method 2\n");
 
         if (ToDo->Location > LastToDo->Number || ToDo->Location == 0) return ERR_INVALIDLOCATION;
 
         Note.Location = LastToDo->Location[ToDo->Location-1];
         return N71_65_DelCalendar(s,&Note);
 }
 
 /* ToDo support - 6310 style */
 static GSM_Error N6510_ReplyGetToDoFirstLoc1(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "TODO first location received method 1: %02x\n",msg.Buffer[9]);
         s->Phone.Data.ToDo->Location = msg.Buffer[9];
         return ERR_NONE;
 }
 
 /* ToDo support - 6310 style */
 static GSM_Error N6510_ReplyAddToDo1(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "TODO set OK\n");
         return ERR_NONE;
 }
 
 /* ToDo support - 6310 style */
 static GSM_Error N6510_AddToDo1(GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
 {
                 int             Text, Alarm, EndTime, Completed, ulen, Phone;
                 GSM_Error       error;
                 unsigned char           reqLoc[] = {N6110_FRAME_HEADER, 0x0F};
                 unsigned char           reqSet[500] = {
                 N6110_FRAME_HEADER, 0x01,
                         0x03,   /* Priority */
                         0x00,   /* Length of text */
                 0x80,0x00,0x00,
                         0x18};  /* Location */
 
         s->Phone.Data.ToDo = ToDo;
 
         smprintf(s, "Getting first ToDo location\n");
         error = GSM_WaitFor (s, reqLoc, 4, 0x55, 4, ID_SetToDo);
         if (error != ERR_NONE) return error;
         reqSet[9] = ToDo->Location;
 
         switch (ToDo->Priority) {
                         case GSM_Priority_Low: reqSet[4] = 3; break;
                 case GSM_Priority_Medium: reqSet[4] = 2; break;
                         case GSM_Priority_High: reqSet[4] = 1; break;
         }
 
         GSM_ToDoFindDefaultTextTimeAlarmCompleted(ToDo, &Text, &Alarm, &Completed, &EndTime, &Phone);
 
             if (Text == -1) return ERR_NOTSUPPORTED; /* XXX: shouldn't this be handled different way? */
             ulen = UnicodeLength(ToDo->Entries[Text].Text);
         reqSet[5] = ulen+1;
         CopyUnicodeString(reqSet+10,ToDo->Entries[Text].Text);
                 reqSet[10+ulen*2] = 0x00;
                 reqSet[10+ulen*2+1] = 0x00;
         smprintf(s, "Adding ToDo method 1\n");
         return GSM_WaitFor (s, reqSet, 12+ulen*2, 0x55, 4, ID_SetToDo);
 }
 
 static GSM_Error N6510_ReplyAddToDo2(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "ToDo added method 2\n");
         return ERR_NONE;
 }
 
 static GSM_Error N6510_ReplyGetToDoFirstLoc2(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "First ToDo location method 2: %i\n",msg.Buffer[8]*256+msg.Buffer[9]);
         s->Phone.Data.ToDo->Location = msg.Buffer[9];
         return ERR_NONE;
 }
 
 static GSM_Error N6510_AddToDo2(GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
 {
                 GSM_CalendarEntryNote;
                 time_t          t_time1,t_time2;
                 long            diff;
                 GSM_Error       error;
                 GSM_DateTime    DT;
                 int             Text, Alarm, EndTime, Completed, count=54, Phone;
                 unsigned char   reqLoc[] = {N6110_FRAME_HEADER, 0x95, 0x01};
                 unsigned char   req[5000] = {
                 N6110_FRAME_HEADER, 0x65,
                         0x01,                                   /* 0 = calendar, 1 = todo */
                 0x00, 0x00, 0x00,
                         0x00, 0x00,                             /* location             */
                         0x00, 0x00, 0x00, 0x00,         
                         0xFF, 0xFF, 0xFF, 0xFF,                         /* alarm                */
                 0x80, 0x00, 0x00,
                         0x01,                                   /* note icon            */
                         0xFF, 0xFF, 0xFF, 0xFF,                         /* alarm type           */
                         0x00,                                   /* 0x02 or 0x00         */
@@ -5358,425 +5431,434 @@ GSM_Error N6510_CancelCall(GSM_StateMachine *s, int ID, bool all)
 GSM_Error N6510_AnswerCall(GSM_StateMachine *s, int ID, bool all)
 {
         if (all) return ERR_NOTSUPPORTED;
         return DCT3DCT4_AnswerCall(s,ID);
 }
 
 static GSM_Error N6510_ReplyAddSMSFolder(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s,"SMS folder \"%s\" has been added\n",DecodeUnicodeString(msg.Buffer+10));
         return ERR_NONE;
 }
 
 GSM_Error N6510_AddSMSFolder(GSM_StateMachine *s, unsigned char *name) 
 {
         unsigned char req[200] = {N6110_FRAME_HEADER, 0x10, 0x01, 0x00, 0x01,
                                           0x00,         /* Length */
                                   0x00, 0x00};
 
         
         CopyUnicodeString(req+10,name);
         req[7] = UnicodeLength(name)*2 + 6;
 
         smprintf(s, "Adding SMS folder\n");
                 return GSM_WaitFor (s, req, req[7] + 6, 0x14, 4, ID_AddSMSFolder);
 }
 
 static GSM_Error N6510_SetWAPBookmark(GSM_StateMachine *s, GSM_WAPBookmark *bookmark)
 {
                 GSM_Error error;
                 int     count=4, location;
                 unsigned char req[600] = {N6110_FRAME_HEADER, 0x09};
 
         /* We have to enable WAP frames in phone */
         error=N6510_EnableConnectionFunctions(s,N6510_WAP_SETTINGS);
         if (error!=ERR_NONE) return error;
 
         location = bookmark->Location - 1;
         if (bookmark->Location == 0) location = 0xffff;
         req[count++] = (location & 0xff00) >> 8;
         req[count++] = location & 0x00ff;
 
         count += NOKIA_SetUnicodeString(s, req+count, bookmark->Title,   true);
         count += NOKIA_SetUnicodeString(s, req+count, bookmark->Address, true);
 
         req[count++] = 0x00;
         req[count++] = 0x00;
         req[count++] = 0x00;
         req[count++] = 0x00;
 
         smprintf(s, "Setting WAP bookmark\n");
         error = GSM_WaitFor (s, req, count, 0x3f, 4, ID_SetWAPBookmark);
         if (error != ERR_NONE) {
                 if (error == ERR_INSIDEPHONEMENU || error == ERR_EMPTY || error == ERR_FULL) {
                         DCT3DCT4_DisableConnectionFunctions(s);
                 }
                 return error;
         }
 
         return DCT3DCT4_DisableConnectionFunctions(s);
 }
 
 GSM_Error N6510_DeleteWAPBookmark(GSM_StateMachine *s, GSM_WAPBookmark *bookmark)
 {
         GSM_Error error;
 
         /* We have to enable WAP frames in phone */
         error=N6510_EnableConnectionFunctions(s,N6510_WAP_SETTINGS);
         if (error!=ERR_NONE) return error;
 
         return DCT3DCT4_DeleteWAPBookmarkPart(s,bookmark);
 }
 
 GSM_Error N6510_GetWAPBookmark(GSM_StateMachine *s, GSM_WAPBookmark *bookmark)
 {
         GSM_Error error;
 
         /* We have to enable WAP frames in phone */
         error=N6510_EnableConnectionFunctions(s,N6510_WAP_SETTINGS);
         if (error!=ERR_NONE) return error;
 
         return DCT3DCT4_GetWAPBookmarkPart(s,bookmark);
 }
 
 static GSM_Reply_Function N6510ReplyFunctions[] = {
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x02,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x03,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x04,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x05,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x07,ID_AnswerCall  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x07,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x09,ID_CancelCall  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x09,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x0A,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x0B,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x0C,ID_DialVoice           },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x0C,ID_IncomingFrame  },
+                {N71_65_ReplyCallInfo,            "\x01",0x03,0x0F,ID_IncomingFrame  },
+                {N71_65_ReplyCallInfo,            "\x01",0x03,0x10,ID_DialVoice           },
+                {N71_65_ReplyCallInfo,            "\x01",0x03,0x10,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x23,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x25,ID_IncomingFrame  },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x27,ID_IncomingFrame  },
                 {N71_65_ReplySendDTMF,            "\x01",0x03,0x51,ID_SendDTMF    },
                 {N71_65_ReplyCallInfo,            "\x01",0x03,0x53,ID_IncomingFrame  },
                 {N71_65_ReplySendDTMF,            "\x01",0x03,0x59,ID_SendDTMF    },
                 {N71_65_ReplySendDTMF,            "\x01",0x03,0x5E,ID_SendDTMF    },
+                {N71_65_ReplyCallInfo,            "\x01",0x03,0xA6,ID_IncomingFrame  },
+                {N71_65_ReplyCallInfo,            "\x01",0x03,0xD2,ID_IncomingFrame  },
+                {N71_65_ReplyCallInfo,            "\x01",0x03,0xD3,ID_IncomingFrame  },
 
                 {N6510_ReplySendSMSMessage,       "\x02",0x03,0x03,ID_IncomingFrame  },
                 {N6510_ReplyIncomingSMS,          "\x02",0x03,0x04,ID_IncomingFrame  },
                 {N6510_ReplySetSMSC,              "\x02",0x03,0x13,ID_SetSMSC     },
                 {N6510_ReplyGetSMSC,              "\x02",0x03,0x15,ID_GetSMSC     },
 
                 {N6510_ReplyGetMemoryStatus,      "\x03",0x03,0x04,ID_GetMemoryStatus  },
                 {N6510_ReplyGetMemory,            "\x03",0x03,0x08,ID_GetMemory           },
                 {N6510_ReplyDeleteMemory,         "\x03",0x03,0x10,ID_SetMemory           },
                 {N71_65_ReplyWritePhonebook,      "\x03",0x03,0x0C,ID_SetBitmap           },
                 {N71_65_ReplyWritePhonebook,      "\x03",0x03,0x0C,ID_SetMemory           },
 
                 {DCT3DCT4_ReplyCallDivert,        "\x06",0x03,0x02,ID_Divert      },
                 {N71_65_ReplyUSSDInfo,            "\x06",0x03,0x03,ID_IncomingFrame  },
                 {NoneReply,                       "\x06",0x03,0x06,ID_IncomingFrame  },
                 {NoneReply,                       "\x06",0x03,0x09,ID_IncomingFrame  },
 
                 {N6510_ReplyEnterSecurityCode,    "\x08",0x03,0x08,ID_EnterSecurityCode  },
                 {N6510_ReplyEnterSecurityCode,    "\x08",0x03,0x09,ID_EnterSecurityCode  },
                 {N6510_ReplyGetSecurityStatus,    "\x08",0x03,0x12,ID_GetSecurityStatus  },
 
                 {N6510_ReplyGetNetworkInfo,       "\x0A",0x03,0x01,ID_GetNetworkInfo  },
                 {N6510_ReplyGetNetworkInfo,       "\x0A",0x03,0x01,ID_IncomingFrame  },
                 {N6510_ReplyLogIntoNetwork,       "\x0A",0x03,0x02,ID_IncomingFrame  },
                 {N6510_ReplyGetSignalQuality,     "\x0A",0x03,0x0C,ID_GetSignalQuality  },
                 {N6510_ReplyGetIncSignalQuality,  "\x0A",0x03,0x1E,ID_IncomingFrame  },
                 {NoneReply,                       "\x0A",0x03,0x20,ID_IncomingFrame  },
                 {N6510_ReplyGetOperatorLogo,      "\x0A",0x03,0x24,ID_GetBitmap           },
                 {N6510_ReplySetOperatorLogo,      "\x0A",0x03,0x26,ID_SetBitmap           },
 
                 {NoneReply,                       "\x0B",0x03,0x01,ID_PlayTone    },
                 {NoneReply,                       "\x0B",0x03,0x15,ID_PlayTone    },
                 {NoneReply,                       "\x0B",0x03,0x16,ID_PlayTone    },
 
                 {N71_65_ReplyAddCalendar1,        "\x13",0x03,0x02,ID_SetCalendarNote  },
                 {N71_65_ReplyAddCalendar1,        "\x13",0x03,0x04,ID_SetCalendarNote  },
                 {N71_65_ReplyAddCalendar1,        "\x13",0x03,0x06,ID_SetCalendarNote  },
                 {N71_65_ReplyAddCalendar1,        "\x13",0x03,0x08,ID_SetCalendarNote  },
                 {N71_65_ReplyDelCalendar,  "\x13",0x03,0x0C,ID_DeleteCalendarNote  },
                 {N71_65_ReplyGetNextCalendar1,    "\x13",0x03,0x1A,ID_GetCalendarNote  },/*method 1*/
                 {N6510_ReplyGetCalendarNotePos,  "\x13",0x03,0x32,ID_GetCalendarNotePos  },/*method 1*/
                 {N6510_ReplyGetCalendarInfo,  "\x13",0x03,0x3B,ID_GetCalendarNotesInfo},/*method 1*/
 #ifdef DEBUG
                 {N71_65_ReplyGetNextCalendar2,    "\x13",0x03,0x3F,ID_GetCalendarNote  },
 #endif
                 {N71_65_ReplyAddCalendar2,        "\x13",0x03,0x41,ID_SetCalendarNote  },/*method 2*/
                 {N6510_ReplyAddCalendar3,         "\x13",0x03,0x66,ID_SetCalendarNote  },/*method 3*/
                 {N6510_ReplyAddToDo2,             "\x13",0x03,0x66,ID_SetToDo     },
                 {N6510_ReplyGetCalendar3,         "\x13",0x03,0x7E,ID_GetCalendarNote  },/*method 3*/
                 {N6510_ReplyGetToDo2,             "\x13",0x03,0x7E,ID_GetToDo     },
+                {N6510_ReplyGetNote,              "\x13",0x03,0x7E,ID_GetNote     },
         {N6510_ReplyGetCalendarSettings,  "\x13",0x03,0x86,ID_GetCalendarSettings },
                 {N6510_ReplyGetLocale,            "\x13",0x03,0x8A,ID_GetLocale           },
         {N6510_ReplyGetCalendarSettings,  "\x13",0x03,0x8E,ID_GetCalendarSettings },
                 {N6510_ReplyGetCalendarNotePos,  "\x13",0x03,0x96,ID_GetCalendarNotePos  },/*method 3*/
                 {N6510_ReplyGetToDoFirstLoc2,     "\x13",0x03,0x96,ID_SetToDo     },
                 {N6510_ReplyGetCalendarInfo,  "\x13",0x03,0x9F,ID_GetCalendarNotesInfo},/*method 3*/
                 {N6510_ReplyGetToDoStatus2,       "\x13",0x03,0x9F,ID_GetToDo     },
+                {N6510_ReplyGetNoteInfo,          "\x13",0x03,0x9F,ID_GetNote     },
 
                 {N6510_ReplySaveSMSMessage,       "\x14",0x03,0x01,ID_SaveSMSMessage  },
                 {N6510_ReplySetPicture,                   "\x14",0x03,0x01,ID_SetBitmap           },
                 {N6510_ReplyGetSMSMessage,        "\x14",0x03,0x03,ID_GetSMSMessage  },
                 {N6510_ReplyDeleteSMSMessage,     "\x14",0x03,0x05,ID_DeleteSMSMessage  },
                 {N6510_ReplyDeleteSMSMessage,     "\x14",0x03,0x06,ID_DeleteSMSMessage  },
                 {N6510_ReplyGetSMSStatus,         "\x14",0x03,0x09,ID_GetSMSStatus  },
                 {N6510_ReplyGetSMSFolderStatus,  "\x14",0x03,0x0d,ID_GetSMSFolderStatus  },
                 {N6510_ReplyGetSMSMessage,        "\x14",0x03,0x0f,ID_GetSMSMessage  },
                 {N6510_ReplyAddSMSFolder,         "\x14",0x03,0x11,ID_AddSMSFolder  },
                 {N6510_ReplyGetSMSFolders,        "\x14",0x03,0x13,ID_GetSMSFolders  },
                 {N6510_ReplySaveSMSMessage,       "\x14",0x03,0x17,ID_SaveSMSMessage  },
                 {N6510_ReplyGetSMSStatus,         "\x14",0x03,0x1a,ID_GetSMSStatus  },
 
                 {DCT4_ReplySetPhoneMode,          "\x15",0x03,0x64,ID_Reset       },
                 {DCT4_ReplyGetPhoneMode,          "\x15",0x03,0x65,ID_Reset       },
                 {NoneReply,                       "\x15",0x03,0x68,ID_Reset       },
 
                 {N6510_ReplyGetBatteryCharge,     "\x17",0x03,0x0B,ID_GetBatteryCharge  },
 
                 {N6510_ReplySetDateTime,          "\x19",0x03,0x02,ID_SetDateTime  },
                 {N6510_ReplyGetDateTime,          "\x19",0x03,0x0B,ID_GetDateTime  },
                 {N6510_ReplySetAlarm,             "\x19",0x03,0x12,ID_SetAlarm    },
                 {N6510_ReplyGetAlarm,             "\x19",0x03,0x1A,ID_GetAlarm    },
                 {N6510_ReplyGetAlarm,             "\x19",0x03,0x20,ID_GetAlarm    },
 
                 {DCT4_ReplyGetIMEI,               "\x1B",0x03,0x01,ID_GetIMEI     },
                 {NOKIA_ReplyGetPhoneString,       "\x1B",0x03,0x08,ID_GetHardware  },
                 {N6510_ReplyGetPPM,               "\x1B",0x03,0x08,ID_GetPPM      },
                 {NOKIA_ReplyGetPhoneString,       "\x1B",0x03,0x0C,ID_GetProductCode  },
 
         /* 0x1C - vibra */
 
                 {N6510_ReplyGetRingtonesInfo,     "\x1f",0x03,0x08,ID_GetRingtonesInfo  },
                 {N6510_ReplyDeleteRingtones,      "\x1f",0x03,0x11,ID_SetRingtone  },
                 {N6510_ReplyGetRingtone,          "\x1f",0x03,0x13,ID_GetRingtone  },
                 {N6510_ReplySetBinRingtone,       "\x1f",0x03,0x0F,ID_SetRingtone  },
 
         /* 0x23 - voice records */
 
                 {N6510_ReplyGetProfile,                   "\x39",0x03,0x02,ID_GetProfile  },
                 {N6510_ReplySetProfile,                   "\x39",0x03,0x04,ID_SetProfile  },
                 {N6510_ReplyGetProfile,                   "\x39",0x03,0x06,ID_GetProfile  },
 
                 {N6510_ReplySetLight,             "\x3A",0x03,0x06,ID_SetLight    },
 
                 {N6510_ReplyGetFMStation,         "\x3E",0x03,0x06,ID_GetFMStation  },
                 {N6510_ReplyGetFMStatus,          "\x3E",0x03,0x0E,ID_GetFMStation  },
                 {N6510_ReplySetFMStation,         "\x3E",0x03,0x15,ID_SetFMStation  },
                 {N6510_ReplyGetFMStation,         "\x3E",0x03,0x16,ID_GetFMStation  },
 
                 {DCT3DCT4_ReplyEnableConnectFunc, "\x3f",0x03,0x01,ID_EnableConnectFunc  },
                 {DCT3DCT4_ReplyEnableConnectFunc, "\x3f",0x03,0x02,ID_EnableConnectFunc  },
         {DCT3DCT4_ReplyDisableConnectFunc,"\x3f",0x03,0x04,ID_DisableConnectFunc  },
         {DCT3DCT4_ReplyDisableConnectFunc,"\x3f",0x03,0x05,ID_DisableConnectFunc  },
                 {N6510_ReplyGetWAPBookmark,       "\x3f",0x03,0x07,ID_GetWAPBookmark  },
                 {N6510_ReplyGetWAPBookmark,       "\x3f",0x03,0x08,ID_GetWAPBookmark  },
                 {DCT3DCT4_ReplySetWAPBookmark,    "\x3f",0x03,0x0A,ID_SetWAPBookmark  },
                 {DCT3DCT4_ReplySetWAPBookmark,    "\x3f",0x03,0x0B,ID_SetWAPBookmark  },
                 {DCT3DCT4_ReplyDelWAPBookmark,    "\x3f",0x03,0x0D,ID_DeleteWAPBookmark  },
                 {DCT3DCT4_ReplyDelWAPBookmark,    "\x3f",0x03,0x0E,ID_DeleteWAPBookmark  },
                 {DCT3DCT4_ReplyGetActiveConnectSet,"\x3f",0x03,0x10,ID_GetConnectSet  },
                 {DCT3DCT4_ReplySetActiveConnectSet,"\x3f",0x03,0x13,ID_SetConnectSet  },
                 {N6510_ReplyGetConnectionSettings,"\x3f",0x03,0x16,ID_GetConnectSet  },
                 {N6510_ReplyGetConnectionSettings,"\x3f",0x03,0x17,ID_GetConnectSet  },
                 {N6510_ReplySetConnectionSettings,"\x3f",0x03,0x19,ID_SetConnectSet  },
                 {N6510_ReplySetConnectionSettings,"\x3f",0x03,0x1A,ID_SetConnectSet  },
                 {N6510_ReplySetConnectionSettings,"\x3f",0x03,0x28,ID_SetConnectSet  },
                 {N6510_ReplySetConnectionSettings,"\x3f",0x03,0x2B,ID_SetConnectSet  },
                 {N6510_ReplyGetChatSettings,      "\x3f",0x03,0x3B,ID_GetChatSettings  },
                 {N6510_ReplyGetChatSettings,      "\x3f",0x03,0x3C,ID_GetChatSettings  },
 
                 {N6510_ReplyGetOriginalIMEI,      "\x42",0x07,0x00,ID_GetOriginalIMEI  },
         {N6510_ReplyGetManufactureMonth,  "\x42",0x07,0x00,ID_GetManufactureMonth },
                 {N6510_ReplyGetOriginalIMEI,      "\x42",0x07,0x01,ID_GetOriginalIMEI  },
         {N6510_ReplyGetManufactureMonth,  "\x42",0x07,0x02,ID_GetManufactureMonth },
 
                 {N6510_ReplySetOperatorLogo,      "\x43",0x03,0x08,ID_SetBitmap           },
                 {N6510_ReplyGetGPRSAccessPoint,           "\x43",0x03,0x06,ID_GetGPRSPoint  },
                 {N6510_ReplySetGPRSAccessPoint1,  "\x43",0x03,0x06,ID_SetGPRSPoint  },
 #ifdef DEVELOP
                 {N6510_ReplyEnableGPRSAccessPoint,"\x43",0x03,0x06,ID_EnableGPRSPoint  },
 #endif
                 {N6510_ReplyGetSyncMLSettings,    "\x43",0x03,0x06,ID_GetSyncMLSettings  },
                 {N6510_ReplyGetSyncMLName,        "\x43",0x03,0x06,ID_GetSyncMLName  },
                 {NoneReply,                       "\x43",0x03,0x08,ID_SetGPRSPoint  },
 
         /* 0x4A - voice records */
 
         /* 0x53 - simlock */
 
                 {N6510_ReplyAddToDo1,             "\x55",0x03,0x02,ID_SetToDo     },
                 {N6510_ReplyGetToDo1,             "\x55",0x03,0x04,ID_GetToDo     },
                 {N6510_ReplyGetToDoFirstLoc1,     "\x55",0x03,0x10,ID_SetToDo     },
                 {N6510_ReplyDeleteAllToDo1,       "\x55",0x03,0x12,ID_DeleteAllToDo  },
                 {N6510_ReplyGetToDoStatus1,       "\x55",0x03,0x16,ID_GetToDo     },
 
                 {N6510_ReplyAddFileHeader,        "\x6D",0x03,0x03,ID_AddFile     },
                 {N6510_ReplyAddFolder,            "\x6D",0x03,0x05,ID_AddFolder           },
                 {N6510_ReplyGetFilePart,          "\x6D",0x03,0x0F,ID_GetFile     },
                 {N6510_ReplyAddFileHeader,        "\x6D",0x03,0x13,ID_AddFile     },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x15,ID_GetFileInfo  },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x15,ID_GetFile     },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x15,ID_AddFile     },
                 {N6510_ReplyDeleteFile,                   "\x6D",0x03,0x19,ID_DeleteFile  },
                 {N6510_ReplyDeleteFile,                   "\x6D",0x03,0x1F,ID_DeleteFile  },
                 {N6510_ReplyGetFileSystemStatus,  "\x6D",0x03,0x23,ID_FileSystemStatus  },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x2F,ID_GetFileInfo  },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x2F,ID_GetFile     },
                 {N6510_ReplyGetFileSystemStatus,  "\x6D",0x03,0x2F,ID_FileSystemStatus  },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x33,ID_GetFileInfo  },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x33,ID_GetFile     },
                 {N6510_ReplyAddFilePart,          "\x6D",0x03,0x41,ID_AddFile     },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x43,ID_AddFile     },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x43,ID_GetFile     },
                 {N6510_ReplyGetFileFolderInfo,    "\x6D",0x03,0x43,ID_GetFileInfo  },
 
                 {N6510_ReplyStartupNoteLogo,      "\x7A",0x04,0x01,ID_GetBitmap           },
                 {N6510_ReplyStartupNoteLogo,      "\x7A",0x04,0x01,ID_SetBitmap           },
                 {N6510_ReplyStartupNoteLogo,      "\x7A",0x04,0x0F,ID_GetBitmap           },
                 {N6510_ReplyStartupNoteLogo,      "\x7A",0x04,0x0F,ID_SetBitmap           },
                 {N6510_ReplyStartupNoteLogo,      "\x7A",0x04,0x10,ID_GetBitmap           },
                 {N6510_ReplyStartupNoteLogo,      "\x7A",0x04,0x10,ID_SetBitmap           },
                 {N6510_ReplyStartupNoteLogo,      "\x7A",0x04,0x25,ID_SetBitmap           },
 
                 {DCT3DCT4_ReplyGetModelFirmware,  "\xD2",0x02,0x00,ID_GetModel    },
                 {DCT3DCT4_ReplyGetModelFirmware,  "\xD2",0x02,0x00,ID_GetFirmware  },
 
         /* 0xD7 - Bluetooth */
 
                 {N6510_ReplyGetRingtoneID,        "\xDB",0x03,0x02,ID_SetRingtone  },
 
                 {NULL,                            "\x00",0x00,0x00,ID_None        }
 };
 
 GSM_Phone_Functions N6510Phone = {
-        "1100|1100a|1100b|3100|3100b|3108|3200|3200a|3300|3510|3510i|3530|3589i|3590|3595|5100|6100|6200|6220|6230|6310|6310i|6385|6510|6610|6800|7210|7250|7250i|7600|8310|8390|8910|8910i",
+        "1100|1100a|1100b|3100|3100b|3108|3200|3200a|3300|3510|3510i|3530|3589i|3590|3595|5100|5140|6100|6200|6220|6230|6310|6310i|6385|6510|6610|6610i|6800|6810|6820|7210|7250|7250i|7600|8310|8390|8910|8910i",
         N6510ReplyFunctions,
         N6510_Initialise,
                 NONEFUNCTION,                   /*      Terminate       */
         GSM_DispatchMessage,
         N6510_ShowStartInfo,
         NOKIA_GetManufacturer,
         DCT3DCT4_GetModel,
         DCT3DCT4_GetFirmware,
         DCT4_GetIMEI,
         N6510_GetOriginalIMEI,
         N6510_GetManufactureMonth,
         DCT4_GetProductCode,
         DCT4_GetHardware,
         N6510_GetPPM,
                 NOTSUPPORTED,                   /*      GetSIMIMSI      */
         N6510_GetDateTime,
         N6510_SetDateTime,
         N6510_GetAlarm,
         N6510_SetAlarm,
         N6510_GetLocale,
                 NOTSUPPORTED,                   /*      SetLocale       */
         N6510_PressKey,
         DCT4_Reset,
                 NOTIMPLEMENTED,                         /*      ResetPhoneSettings*/
         N6510_EnterSecurityCode,
         N6510_GetSecurityStatus,
                 NOTSUPPORTED,                   /*      GetDisplayStatus*/
                 NOTIMPLEMENTED,                         /*      SetAutoNetworkLogin*/
         N6510_GetBatteryCharge,
         N6510_GetSignalQuality,
         N6510_GetNetworkInfo,
                 NOTSUPPORTED,                   /*      GetCategory     */
                 NOTSUPPORTED,                   /*      AddCategory     */
                 NOTSUPPORTED,                   /*      GetCategoryStatus */
         N6510_GetMemoryStatus,
         N6510_GetMemory,
                 NOTIMPLEMENTED,                         /*      GetNextMemory   */
         N6510_SetMemory,
                 NOTIMPLEMENTED,                         /*      AddMemory       */
         N6510_DeleteMemory,
                 NOTIMPLEMENTED,                         /*      DeleteAllMemory         */
         N6510_GetSpeedDial,
                 NOTIMPLEMENTED,                         /*      SetSpeedDial    */
         N6510_GetSMSC,
         N6510_SetSMSC,
         N6510_GetSMSStatus,
         N6510_GetSMSMessage,
         N6510_GetNextSMSMessage,
         N6510_SetSMS,
         N6510_AddSMS,
         N6510_DeleteSMSMessage,
         N6510_SendSMSMessage,
                 NOTSUPPORTED,                   /*      SendSavedSMS    */
+                NOTSUPPORTED,                   /*      SetFastSMSSending*/
         NOKIA_SetIncomingSMS,
                 NOTIMPLEMENTED,                         /*      SetIncomingCB   */
         N6510_GetSMSFolders,
          N6510_AddSMSFolder,
                 NOTIMPLEMENTED,                         /*      DeleteSMSFolder         */
         N6510_DialVoice,
          N6510_AnswerCall,
          N6510_CancelCall,
                 NOTIMPLEMENTED,                         /*      HoldCall        */
                 NOTIMPLEMENTED,                         /*      UnholdCall      */
                 NOTIMPLEMENTED,                         /*      ConferenceCall          */
                 NOTIMPLEMENTED,                         /*      SplitCall       */
                 NOTIMPLEMENTED,                         /*      TransferCall    */
                 NOTIMPLEMENTED,                         /*      SwitchCall      */
          DCT3DCT4_GetCallDivert,
          DCT3DCT4_SetCallDivert,
          DCT3DCT4_CancelAllDiverts,
         NOKIA_SetIncomingCall,
         NOKIA_SetIncomingUSSD,
         DCT3DCT4_SendDTMF,
         N6510_GetRingtone,
         N6510_SetRingtone,
         N6510_GetRingtonesInfo,
         N6510_DeleteUserRingtones,
         N6510_PlayTone,
         N6510_GetWAPBookmark,
         N6510_SetWAPBookmark,
         N6510_DeleteWAPBookmark,
         N6510_GetWAPSettings,
         N6510_SetWAPSettings,
         N6510_GetMMSSettings,
         N6510_SetMMSSettings,
         N6510_GetSyncMLSettings,
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
         N6510_GetChatSettings,
                 NOTSUPPORTED,                   /*      SetChatSettings         */
         N6510_GetBitmap,
         N6510_SetBitmap,
         N6510_GetToDoStatus,
                 NOTIMPLEMENTED,                         /*      GetToDo                 */
         N6510_GetNextToDo,
                 NOTIMPLEMENTED,                         /*      SetToDo                 */
         N6510_AddToDo,
         N6510_DeleteToDo2,
         N6510_DeleteAllToDo1,
         N6510_GetCalendarStatus,
                 NOTIMPLEMENTED,                         /*      GetCalendar     */
             N6510_GetNextCalendar,
                 NOTIMPLEMENTED,                         /*      SetCalendar     */
         N6510_AddCalendar,
         N71_65_DelCalendar,
                 NOTIMPLEMENTED,                         /*      DeleteAllCalendar*/
         N6510_GetCalendarSettings,
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTIMPLEMENTED,                         /*      GetNote                 */
+        N6510_GetNextNote,
         N6510_GetProfile,
         N6510_SetProfile,
             N6510_GetFMStation,
              N6510_SetFMStation,
          N6510_ClearFMStations,
         N6510_GetNextFileFolder,
         N6510_GetFilePart,
         N6510_AddFilePart,
         N6510_GetFileSystemStatus,
         N6510_DeleteFile,
         N6510_AddFolder,
         N6510_GetGPRSAccessPoint,
         N6510_SetGPRSAccessPoint
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/dct4/n6510.h b/gammu/emb/common/phone/nokia/dct4/n6510.h
index 4717aeb..26623d6 100644
--- a/gammu/emb/common/phone/nokia/dct4/n6510.h
+++ b/gammu/emb/common/phone/nokia/dct4/n6510.h
@@ -1,90 +1,92 @@
 /* (c) 2002-2004 by Marcin Wiacek */
 
 #ifndef n6510_h
 #define n6510_h
 
 #include "../ncommon.h"
 #include "../../../service/sms/gsmsms.h"
 
 typedef enum {
         N6510_MMS_SETTINGS = 0x01,
         N6510_CHAT_SETTINGS,
 
         N6510_WAP_SETTINGS,
         N6510_SYNCML_SETTINGS
 } N6510_Connection_Settings;
 
 typedef enum {
         N6510_LIGHT_DISPLAY = 0x01,
         N6510_LIGHT_KEYPAD  = 0x03,
         N6510_LIGHT_TORCH   = 0x10
 } N6510_PHONE_LIGHTS;
 
 typedef struct {
                 int                     LastCalendarYear;
                 int                     LastCalendarPos;
                 GSM_NOKIACalToDoLocationsLastCalendar;
                 int                     FirstCalendarPos;
                 unsigned char           CalendarIcons[10];
                 GSM_CalendarNoteType    CalendarIconsTypes[10];
                 int                     CalendarIconsNum;
 
                 GSM_NOKIASMSFolder      LastSMSFolder;
                 GSM_SMSFolders          LastSMSFolders;
 
                 GSM_NOKIACalToDoLocationsLastToDo;
 
+                GSM_NOKIACalToDoLocationsLastNote;
+
                 unsigned char                   RingtoneID;/* When set with preview */
 
                 int                     FilesLocations[1000];
                 int                     FilesLevels[1000];
                 int                     FilesLocationsUsed;
                 int                     FilesLocationsCurrent;
                 int                     FileToken;
                 int                     ParentID;
                 int                     FileCheckSum;
 
                 unsigned char           FMStatus[4000];
                 int                     FMStatusLength;
 
                 unsigned char           GPRSPoints[4000];
                 int                     GPRSPointsLength;
 
                 int                     BearerNumber;
 
                 unsigned char           PhoneMode;
 } GSM_Phone_N6510Data;
 
 void N6510_EncodeFMFrequency(double freq, unsigned char *buff);
 void N6510_DecodeFMFrequency(double *freq, unsigned char *buff);
 
 #ifndef GSM_USED_MBUS2
 #  define GSM_USED_MBUS2
 #endif
 #ifndef GSM_USED_FBUS2
 #  define GSM_USED_FBUS2
 #endif
 #ifndef GSM_USED_FBUS2DLR3
 #  define GSM_USED_FBUS2DLR3
 #endif
 #ifndef GSM_USED_FBUS2DKU5
 #  define GSM_USED_FBUS2DKU5
 #endif
 #ifndef GSM_USED_PHONETBLUE
 #  define GSM_USED_PHONETBLUE
 #endif
 #ifndef GSM_USED_IRDAPHONET
 #  define GSM_USED_IRDAPHONET
 #endif
 #ifndef GSM_USED_BLUEPHONET
 #  define GSM_USED_BLUEPHONET
 #endif
 #ifndef GSM_USED_FBUS2PL2303
 #  define GSM_USED_FBUS2PL2303
 #endif
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/nauto.c b/gammu/emb/common/phone/nokia/nauto.c
index bf74bc9..3bb53ec 100644
--- a/gammu/emb/common/phone/nokia/nauto.c
+++ b/gammu/emb/common/phone/nokia/nauto.c
@@ -28,117 +28,117 @@ GSM_Phone_Functions NAUTOPhone = {
         DCT3DCT4_GetFirmware,
                 NOTSUPPORTED,                   /*      GetIMEI                 */
                 NOTSUPPORTED,                   /*      GetOriginalIMEI         */
                 NOTSUPPORTED,                   /*      GetManufactureMonth*/
                 NOTSUPPORTED,                   /*      GetProductCode  */
                 NOTSUPPORTED,                   /*      GetHardware     */
                 NOTSUPPORTED,                   /*      GetPPM          */
                 NOTSUPPORTED,                   /*      GetSIMIMSI      */
                 NOTSUPPORTED,                   /*      GetDateTime     */
                 NOTSUPPORTED,                   /*      SetDateTime     */
                 NOTSUPPORTED,                   /*      GetAlarm        */
                 NOTSUPPORTED,                   /*      SetAlarm        */
                 NOTSUPPORTED,                   /*      GetLocale       */
                 NOTSUPPORTED,                   /*      SetLocale       */
                 NOTSUPPORTED,                   /*      PressKey        */
                 NOTSUPPORTED,                   /*      Reset           */
                 NOTSUPPORTED,                   /*      ResetPhoneSettings*/
                 NOTSUPPORTED,                   /*      EnterSecurityCode*/
                 NOTSUPPORTED,                   /*      GetSecurityStatus*/
                 NOTSUPPORTED,                   /*      GetDisplayStatus*/
                 NOTSUPPORTED,                   /*      SetAutoNetworkLogin*/
                 NOTSUPPORTED,                   /*      GetBatteryCharge*/
                 NOTSUPPORTED,                   /*      GetSignalQuality*/
                 NOTSUPPORTED,                   /*      GetNetworkInfo  */
                 NOTSUPPORTED,                   /*      GetCategory     */
                 NOTSUPPORTED,                   /*      AddCategory     */
                 NOTSUPPORTED,                   /*      GetCategoryStatus       */
                 NOTSUPPORTED,                   /*      GetMemoryStatus         */
                 NOTSUPPORTED,                   /*      GetMemory       */
                 NOTSUPPORTED,                   /*      GetNextMemory   */
                 NOTSUPPORTED,                   /*      SetMemory       */
                 NOTSUPPORTED,                   /*      AddMemory       */
                 NOTSUPPORTED,                   /*      DeleteMemory    */
                 NOTIMPLEMENTED,                         /*      DeleteAllMemory         */
                 NOTSUPPORTED,                   /*      GetSpeedDial    */
                 NOTSUPPORTED,                   /*      SetSpeedDial    */
                 NOTSUPPORTED,                   /*      GetSMSC                 */
                 NOTSUPPORTED,                   /*      SetSMSC                 */
                 NOTSUPPORTED,                   /*      GetSMSStatus    */
                 NOTSUPPORTED,                   /*      GetSMS          */
                 NOTSUPPORTED,                   /*      GetNextSMS      */
                 NOTSUPPORTED,                   /*      SetSMS          */
                 NOTSUPPORTED,                   /*      AddSMS          */
                 NOTSUPPORTED,                   /*      DeleteSMS       */
                 NOTSUPPORTED,                   /*      SendSMSMessage  */
                 NOTSUPPORTED,                   /*      SendSavedSMS    */
                 NOTSUPPORTED,                   /*      SetIncomingSMS  */
                 NOTSUPPORTED,                   /*      SetIncomingCB   */
                 NOTSUPPORTED,                   /*      GetSMSFolders   */
                 NOTSUPPORTED,                   /*      AddSMSFolder    */
                 NOTSUPPORTED,                   /*      DeleteSMSFolder         */
                 NOTSUPPORTED,                   /*      DialVoice       */
                 NOTSUPPORTED,                   /*      AnswerCall      */
                 NOTSUPPORTED,                   /*      CancelCall      */
                 NOTSUPPORTED,                   /*      HoldCall        */
                 NOTSUPPORTED,                   /*      UnholdCall      */
                 NOTSUPPORTED,                   /*      ConferenceCall          */
                 NOTSUPPORTED,                   /*      SplitCall       */
                 NOTSUPPORTED,                   /*      TransferCall    */
                 NOTSUPPORTED,                   /*      SwitchCall      */
                 NOTSUPPORTED,                   /*      GetCallDivert   */
                 NOTSUPPORTED,                   /*      SetCallDivert   */
                 NOTSUPPORTED,                   /*      CancelAllDiverts*/
                 NOTSUPPORTED,                   /*      SetIncomingCall         */
                 NOTSUPPORTED,                   /*      SetIncomingUSSD         */
                 NOTSUPPORTED,                   /*      SendDTMF        */
                 NOTSUPPORTED,                   /*      GetRingtone     */
                 NOTSUPPORTED,                   /*      SetRingtone     */
                 NOTSUPPORTED,                   /*      GetRingtonesInfo*/
                 NOTSUPPORTED,                   /*      DeleteUserRingtones*/
                 NOTSUPPORTED,                   /*      PlayTone        */
                 NOTSUPPORTED,                   /*      GetWAPBookmark  */
                 NOTSUPPORTED,                   /*      SetWAPBookmark          */
                 NOTSUPPORTED,                   /*      DeleteWAPBookmark */
                 NOTSUPPORTED,                   /*      GetWAPSettings          */
                 NOTSUPPORTED,                   /*      SetWAPSettings          */
                 NOTSUPPORTED,                   /*      GetMMSSettings  */
                 NOTSUPPORTED,                   /*      SetMMSSettings  */
                 NOTSUPPORTED,                   /*      GetBitmap       */
                 NOTSUPPORTED,                   /*      SetBitmap       */
                 NOTSUPPORTED,                   /*      GetToDoStatus   */
                 NOTSUPPORTED,                   /*      GetToDo                 */
                 NOTSUPPORTED,                   /*      GetNextToDo     */
                 NOTSUPPORTED,                   /*      SetToDo                 */
                 NOTSUPPORTED,                   /*      AddToDo                 */
                 NOTSUPPORTED,                   /*      DeleteToDo      */
                 NOTSUPPORTED,                   /*      DeleteAllToDo   */
                 NOTSUPPORTED,                   /*      GetCalendarStatus*/
                 NOTSUPPORTED,                   /*      GetCalendar     */
                 NOTSUPPORTED,                   /*      GetNextCalendar         */
                 NOTSUPPORTED,                   /*      SetCalendar     */
                 NOTSUPPORTED,                   /*      AddCalendar     */
                 NOTSUPPORTED,                   /*      DeleteCalendar  */
                 NOTSUPPORTED,                   /*      DeleteAllCalendar*/
                 NOTSUPPORTED,                   /*      GetCalendarSettings*/
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTSUPPORTED,                   /*      GetNote                 */
+                NOTSUPPORTED,                   /*      GetNextNote     */
                 NOTSUPPORTED,                   /*      GetProfile      */
                 NOTSUPPORTED,                   /*      SetProfile      */
                 NOTSUPPORTED,                   /*      GetFMStation        */
                 NOTSUPPORTED,                   /*      SetFMStation        */
                 NOTSUPPORTED,                   /*      ClearFMStations         */
                 NOTSUPPORTED,                   /*      GetNextFileFolder*/
                 NOTSUPPORTED,                   /*      GetFilePart     */
                 NOTSUPPORTED,                   /*      AddFilePart     */
                 NOTSUPPORTED,                   /*      GetFileSystemStatus*/
                 NOTSUPPORTED,                   /*      DeleteFile      */
                 NOTSUPPORTED,                   /*      AddFolder       */
                 NOTSUPPORTED,                   /*      GetGPRSAccessPoint*/
                 NOTSUPPORTED                    /*      SetGPRSAccessPoint*/
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/nokia/nfunc.c b/gammu/emb/common/phone/nokia/nfunc.c
index 3acfb10..d4d8b03 100644
--- a/gammu/emb/common/phone/nokia/nfunc.c
+++ b/gammu/emb/common/phone/nokia/nfunc.c
@@ -1300,221 +1300,235 @@ GSM_Error N71_65_ReplyUSSDInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 
         return ERR_NONE;
 }
 
 GSM_Error NOKIA_SetIncomingUSSD(GSM_StateMachine *s, bool enable)
 {
         s->Phone.Data.EnableIncomingUSSD = enable;
 #ifdef DEBUG
         if (enable) {
                 smprintf(s, "Enabling incoming USSD\n");
         } else {
                 smprintf(s, "Disabling incoming USSD\n");
         }
 #endif
         return ERR_NONE;
 }
 
 GSM_Error NOKIA_SetIncomingCall(GSM_StateMachine *s, bool enable)
 {
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo,F_NOCALLINFO)) return ERR_NOTSUPPORTED;
 
         s->Phone.Data.EnableIncomingCall = enable;
 #ifdef DEBUG
         if (enable) {
                 smprintf(s, "Enabling incoming Call\n");
         } else {
                 smprintf(s, "Disabling incoming Call\n");
         }
 #endif
         return ERR_NONE;
 }
 
 GSM_Error N71_65_ReplyCallInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                 GSM_Call call;
                 int     tmp;
                 unsigned char buffer[200];
 
                 call.Status     = 0;
                 call.CallIDAvailable = true;
         smprintf(s, "Call info, ");
         switch (msg.Buffer[3]) {
         case 0x02:
                 smprintf(s, "Call established, waiting for answer\n");
                 call.Status = GSM_CALL_CallEstablished;
                 break;
         case 0x03:
                 smprintf(s, "Call started\n");
                 smprintf(s, "Call mode  : %i\n",msg.Buffer[5]);//such interpretation is in gnokii
                 tmp = 6;
                 NOKIA_GetUnicodeString(s, &tmp, msg.Buffer,buffer,false);
                 smprintf(s, "Number     : \"%s\"\n",DecodeUnicodeString(buffer));
                 /* FIXME: read name from frame */
 
                 call.Status = GSM_CALL_CallStart;
                         break;          
         case 0x04:
                 smprintf(s, "Remote end hang up\n");
                 smprintf(s, "Cause Type : %i\n",msg.Buffer[5]);//such interpretation is in gnokii
                 smprintf(s, "CC         : %i\n",msg.Buffer[6]);
                 smprintf(s, "MM(?)      : %i\n",msg.Buffer[7]);
                 smprintf(s, "RR(?)      : %i\n",msg.Buffer[8]);
                         call.Status = GSM_CALL_CallRemoteEnd;
                 call.StatusCode = msg.Buffer[6];
                 break;
         case 0x05:
                 smprintf(s, "Incoming call\n");
                 smprintf(s, "Call mode  : %i\n",msg.Buffer[5]);//such interpretation is in gnokii
                 tmp = 6;
                 NOKIA_GetUnicodeString(s, &tmp, msg.Buffer,buffer,false);
                 smprintf(s, "Number     : \"%s\"\n",DecodeUnicodeString(buffer));
                 /* FIXME: read name from frame */
                 call.Status = GSM_CALL_IncomingCall;
                 tmp = 6;
                 NOKIA_GetUnicodeString(s, &tmp, msg.Buffer,call.PhoneNumber,false);
                 break;
         case 0x07:
                 smprintf(s, "Call answer initiated\n");
                 break;
         case 0x09:
                 smprintf(s, "Call released\n");
                 call.Status = GSM_CALL_CallLocalEnd;
                 break;
         case 0x0a:
                 smprintf(s, "Call is being released\n");
                 break;
         case 0x0b:
                 smprintf(s, "Meaning not known\n");
                 call.CallIDAvailable = false;
                 break;
         case 0x0c:
                 smprintf(s, "Audio status\n");
                 if (msg.Buffer[4] == 0x01) smprintf(s, "Audio enabled\n");
                                       else smprintf(s, "Audio disabled\n");
                 call.CallIDAvailable = false;
                 break;
+        case 0x0f:
+        case 0x10:
+                smprintf(s, "Meaning not known\n");
+                call.CallIDAvailable = false;
+                break;
         case 0x23:
                 smprintf(s, "Call held\n");
                 call.Status = GSM_CALL_CallHeld;
                 break;
         case 0x25:
                 smprintf(s, "Call resumed\n");
                 call.Status = GSM_CALL_CallResumed;
                 break;
         case 0x27:
                 smprintf(s, "Call switched\n");
                 call.Status = GSM_CALL_CallSwitched;
                 break;
         case 0x53:
                 smprintf(s, "Outgoing call\n");
                 smprintf(s, "Call mode  : %i\n",msg.Buffer[5]);//such interpretation is in gnokii
                 tmp = 6;
                 NOKIA_GetUnicodeString(s, &tmp, msg.Buffer,buffer,false);
                 smprintf(s, "Number     : \"%s\"\n",DecodeUnicodeString(buffer));
                 /* FIXME: read name from frame */
                 call.Status = GSM_CALL_OutgoingCall;
                 tmp = 6;
                 NOKIA_GetUnicodeString(s, &tmp, msg.Buffer,call.PhoneNumber,false);
                 break;
+        case 0xA6:
+        case 0xD2:
+        case 0xD3:
+                smprintf(s, "Meaning not known\n");
+                call.CallIDAvailable = false;
+                break;
         }
         if (call.CallIDAvailable) smprintf(s, "Call ID    : %d\n",msg.Buffer[4]);
         if (s->Phone.Data.EnableIncomingCall && s->User.IncomingCall!=NULL && call.Status != 0) {
                 if (call.CallIDAvailable) call.CallID = msg.Buffer[4];
                 s->User.IncomingCall(s->CurrentConfig->Device, call);
         }
+        if (s->Phone.Data.RequestID == ID_DialVoice) {
+                if (msg.Buffer[3] == 0x10) return ERR_NOTSUPPORTED;
+        }
         if (s->Phone.Data.RequestID == ID_CancelCall) {
                 if (msg.Buffer[3] == 0x09) {
                         if (s->Phone.Data.CallID == msg.Buffer[4]) return ERR_NONE;
                         /* when we canceled call and see frame about other
                          * call releasing, we don't give ERR_NONE for "our"
                          * call release command
                          */
                         return ERR_NEEDANOTHERANSWER;
                 }
         }
         if (s->Phone.Data.RequestID == ID_AnswerCall) {
                 if (msg.Buffer[3] == 0x07) {
                         if (s->Phone.Data.CallID == msg.Buffer[4]) return ERR_NONE;
                         return ERR_NEEDANOTHERANSWER;
                 }
         }
         return ERR_NONE;
 }
 
 void N71_65_GetCalendarRecurrance(GSM_StateMachine *s, unsigned char *buffer, GSM_CalendarEntry *entry)
 {
         int Recurrance;
 
         Recurrance = buffer[0]*256 + buffer[1];
         /* 8760 hours = 1 year */
         if (Recurrance == 0xffff) Recurrance=8760;
         if (Recurrance != 0) {
                 smprintf(s, "Recurrance   : %i hours\n",Recurrance);
                         entry->Entries[entry->EntriesNum].EntryType= CAL_RECURRANCE;
                         entry->Entries[entry->EntriesNum].Number= Recurrance;
                 entry->EntriesNum++;
         }
 }
 
 /* method 2 */
 GSM_Error N71_65_ReplyAddCalendar2(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
         smprintf(s, "Calendar note added\n");
         return ERR_NONE;
 }
 
 /* method 2 */
 GSM_Error N71_65_AddCalendar2(GSM_StateMachine *s, GSM_CalendarEntry *Note)
 {
                 GSM_CalendarNoteTypeNoteType;
                 time_t          t_time1,t_time2;
                 GSM_DateTime    Date,date_time;
                 GSM_Error       error;
                 long            diff;
                 int             Text, Time, Alarm, Phone, Recurrance, EndTime, Location, length=25;
                 unsigned char   req[5000] = {
                 N6110_FRAME_HEADER,
                 0x40,
                         0x00,                   /* frame length - 7 */
                 0x00,0x00,0x00,0x00,
                         0x00,0x00,0x00,0x00,    /* start time saved as difference */
                         0x00,0x00,0xff,0xff,    /* alarm saved as difference */
                         0x00,                   /* frame length - 7 */
                         0x00,                   /* note type */
                         0x00,0x00,              /* recurrance */
                 0x00,0x00,0x00,0x00,
                         0x00,0x00,0x00,0x00};   /* rest depends on note type */
 
          NoteType = N71_65_FindCalendarType(Note->Type, s->Phone.Data.ModelInfo);
 
         if (IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL62) ||
             IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_CAL65)) {
                 switch(NoteType) {
                 case GSM_CAL_MEETING : req[18] = 0x01; length = 25; break;
                 case GSM_CAL_CALL    : req[18] = 0x02; length = 27; break;
                 case GSM_CAL_BIRTHDAY: req[18] = 0x04; length = 28; break;
                 case GSM_CAL_MEMO    : req[18] = 0x08; length = 25; break;
                 default          : return ERR_UNKNOWN;
                 }
         } else {
                 switch(NoteType) {
                 case GSM_CAL_REMINDER: req[18] = 0x01; length = 25; break;
                 case GSM_CAL_CALL    : req[18] = 0x02; length = 27; break;
                 case GSM_CAL_BIRTHDAY: req[18] = 0x04; length = 28; break;
                 case GSM_CAL_MEMO    : req[18] = 0x08; length = 25; break;
                 default          : return ERR_UNKNOWN;
                 }
         }
 
         GSM_CalendarFindDefaultTextTimeAlarmPhoneRecurrance(Note, &Text, &Time, &Alarm, &Phone, &Recurrance, &EndTime, &Location);
 
         if (Time == -1) return ERR_UNKNOWN;
         if (NoteType != GSM_CAL_BIRTHDAY) {
                         Date.Year       = 2030;         Date.Month = 01; Date.Day    = 01;
                         Date.Hour       = 00;   Date.Minute = 00; Date.Second = 00;
         } else {
                         Date.Year       = 2029; Date.Month      = 12; Date.Day   = 31;
                         Date.Hour       = 22;   Date.Minute = 59; Date.Second = 58;
         }
         t_time1 = Fill_Time_T(Date,8);
         memcpy(&Date,&Note->Entries[Time].Date,sizeof(GSM_DateTime));
diff --git a/gammu/emb/common/phone/obex/obexgen.c b/gammu/emb/common/phone/obex/obexgen.c
index dd14f8e..3106369 100644
--- a/gammu/emb/common/phone/obex/obexgen.c
+++ b/gammu/emb/common/phone/obex/obexgen.c
@@ -681,171 +681,172 @@ static GSM_Error OBEXGEN_AddFolder(GSM_StateMachine *s, GSM_File *File)
                 OBEXGEN_FindNextDir(File->ID_FullName, &Pos, req2);
                 smprintf(s,"%s %i %i\n",DecodeUnicodeString(req2),Pos,strlen(File->ID_FullName));
                 smprintf(s,"Changing path down\n");
                 error=OBEXGEN_ChangePath(s, req2, 2);
                 if (error != ERR_NONE) return error;
                 if (Pos == strlen(File->ID_FullName)) break;
         } while (1);
 
         smprintf(s,"Adding directory\n");
         return OBEXGEN_ChangePath(s, File->Name, 0);
 }
 
 GSM_Reply_Function OBEXGENReplyFunctions[] = {
         /* CONTINUE block */
                 {OBEXGEN_ReplyAddFilePart,      "\x90",0x00,0x00,ID_AddFile             },
                 {OBEXGEN_ReplyGetFilePart,      "\x90",0x00,0x00,ID_GetFile             },
                 {OBEXGEN_ReplyGetFileInfo,      "\x90",0x00,0x00,ID_GetFileInfo                 },
 
         /* OK block */
                 {OBEXGEN_ReplyChangePath,       "\xA0",0x00,0x00,ID_SetPath             },
                 {OBEXGEN_ReplyConnect,          "\xA0",0x00,0x00,ID_Initialise          },
                 {OBEXGEN_ReplyAddFilePart,      "\xA0",0x00,0x00,ID_AddFile             },
                 {OBEXGEN_ReplyGetFilePart,      "\xA0",0x00,0x00,ID_GetFile             },
                 {OBEXGEN_ReplyGetFileInfo,      "\xA0",0x00,0x00,ID_GetFileInfo                 },
 
         /* FOLDER CREATED block */
                 {OBEXGEN_ReplyChangePath,       "\xA1",0x00,0x00,ID_SetPath             },
 
         /* NOT UNDERSTAND block */
                 {OBEXGEN_ReplyAddFilePart,      "\xC0",0x00,0x00,ID_AddFile             },
 
         /* FORBIDDEN block */
                 {OBEXGEN_ReplyChangePath,       "\xC3",0x00,0x00,ID_SetPath             },
                 {OBEXGEN_ReplyGetFilePart,      "\xC3",0x00,0x00,ID_GetFile             },
 
         /* NOT FOUND block */
                 {OBEXGEN_ReplyGetFilePart,      "\xC4",0x00,0x00,ID_GetFile             },
 
                 {NULL,                          "\x00",0x00,0x00,ID_None                }
 };
 
 GSM_Phone_Functions OBEXGENPhone = {
         "obex|seobex",
         OBEXGENReplyFunctions,
         OBEXGEN_Initialise,
                 NONEFUNCTION,                   /*      Terminate       */
         GSM_DispatchMessage,
                 NOTIMPLEMENTED,                         /*      ShowStartInfo   */
                 NONEFUNCTION,                   /*      GetManufacturer         */
                 NONEFUNCTION,                   /*      GetModel        */
                 NONEFUNCTION,                   /*      GetFirmware     */
                 NOTIMPLEMENTED,                         /*      GetIMEI                 */
                 NOTIMPLEMENTED,                         /*      GetOriginalIMEI         */
                 NOTIMPLEMENTED,                         /*      GetManufactureMonth*/
                 NOTIMPLEMENTED,                         /*      GetProductCode  */
                 NOTIMPLEMENTED,                         /*      GetHardware     */
                 NOTIMPLEMENTED,                         /*      GetPPM          */
                 NOTIMPLEMENTED,                         /*      GetSIMIMSI      */
                 NOTIMPLEMENTED,                         /*      GetDateTime     */
                 NOTIMPLEMENTED,                         /*      SetDateTime     */
                 NOTIMPLEMENTED,                         /*      GetAlarm        */
                 NOTIMPLEMENTED,                         /*      SetAlarm        */
                 NOTSUPPORTED,                   /*      GetLocale       */
                 NOTSUPPORTED,                   /*      SetLocale       */
                 NOTIMPLEMENTED,                         /*      PressKey        */
                 NOTIMPLEMENTED,                         /*      Reset           */
                 NOTIMPLEMENTED,                         /*      ResetPhoneSettings*/
                 NOTIMPLEMENTED,                         /*      EnterSecurityCode*/
                 NOTIMPLEMENTED,                         /*      GetSecurityStatus*/
                 NOTIMPLEMENTED,                         /*      GetDisplayStatus*/
                 NOTIMPLEMENTED,                         /*      SetAutoNetworkLogin*/
                 NOTIMPLEMENTED,                         /*      GetBatteryCharge*/
                 NOTIMPLEMENTED,                         /*      GetSignalQuality*/
                 NOTIMPLEMENTED,                         /*      GetNetworkInfo  */
                 NOTIMPLEMENTED,                 /*      GetCategory     */
                 NOTSUPPORTED,                   /*      AddCategory     */
                 NOTIMPLEMENTED,                 /*      GetCategoryStatus       */
                 NOTIMPLEMENTED,                         /*      GetMemoryStatus         */
                 NOTIMPLEMENTED,                         /*      GetMemory       */
                 NOTIMPLEMENTED,                         /*      GetNextMemory   */
                 NOTIMPLEMENTED,                         /*      SetMemory       */
                 NOTIMPLEMENTED,                         /*      AddMemory       */
                 NOTIMPLEMENTED,                         /*      DeleteMemory    */
                 NOTIMPLEMENTED,                         /*      DeleteAllMemory         */
                 NOTIMPLEMENTED,                         /*      GetSpeedDial    */
                 NOTIMPLEMENTED,                         /*      SetSpeedDial    */
                 NOTIMPLEMENTED,                         /*      GetSMSC                 */
                 NOTIMPLEMENTED,                         /*      SetSMSC                 */
                 NOTIMPLEMENTED,                         /*      GetSMSStatus    */
                 NOTIMPLEMENTED,                         /*      GetSMS          */
                 NOTIMPLEMENTED,                         /*      GetNextSMS      */
                 NOTIMPLEMENTED,                         /*      SetSMS          */
                 NOTIMPLEMENTED,                         /*      AddSMS          */
                 NOTIMPLEMENTED,                         /*      DeleteSMS       */
                 NOTIMPLEMENTED,                         /*      SendSMSMessage  */
                 NOTSUPPORTED,                   /*      SendSavedSMS    */
+                NOTSUPPORTED,                   /*      SetFastSMSSending*/
                 NOTIMPLEMENTED,                         /*      SetIncomingSMS  */
                 NOTIMPLEMENTED,                         /*      SetIncomingCB   */
                 NOTIMPLEMENTED,                         /*      GetSMSFolders   */
                 NOTIMPLEMENTED,                         /*      AddSMSFolder    */
                 NOTIMPLEMENTED,                         /*      DeleteSMSFolder         */
                 NOTIMPLEMENTED,                         /*      DialVoice       */
                 NOTIMPLEMENTED,                         /*      AnswerCall      */
                 NOTIMPLEMENTED,                         /*      CancelCall      */
                 NOTIMPLEMENTED,                         /*      HoldCall        */
                 NOTIMPLEMENTED,                         /*      UnholdCall      */
                 NOTIMPLEMENTED,                         /*      ConferenceCall          */
                 NOTIMPLEMENTED,                         /*      SplitCall       */
                 NOTIMPLEMENTED,                         /*      TransferCall    */
                 NOTIMPLEMENTED,                         /*      SwitchCall      */
                 NOTIMPLEMENTED,                         /*      GetCallDivert   */
                 NOTIMPLEMENTED,                         /*      SetCallDivert   */
                 NOTIMPLEMENTED,                         /*      CancelAllDiverts*/
                 NOTIMPLEMENTED,                         /*      SetIncomingCall         */
                 NOTIMPLEMENTED,                         /*      SetIncomingUSSD         */
                 NOTIMPLEMENTED,                         /*      SendDTMF        */
                 NOTIMPLEMENTED,                         /*      GetRingtone     */
                 NOTIMPLEMENTED,                         /*      SetRingtone     */
                 NOTIMPLEMENTED,                         /*      GetRingtonesInfo*/
                 NOTIMPLEMENTED,                         /*      DeleteUserRingtones*/
                 NOTIMPLEMENTED,                         /*      PlayTone        */
                 NOTIMPLEMENTED,                         /*      GetWAPBookmark  */
                 NOTIMPLEMENTED,                         /*      SetWAPBookmark          */
                 NOTIMPLEMENTED,                 /*      DeleteWAPBookmark */
                 NOTIMPLEMENTED,                         /*      GetWAPSettings          */
                 NOTIMPLEMENTED,                         /*      SetWAPSettings          */
                 NOTIMPLEMENTED,                         /*      GetMMSSettings  */
                 NOTIMPLEMENTED,                         /*      SetMMSSettings  */
                 NOTSUPPORTED,                   /*      GetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      GetChatSettings         */
                 NOTSUPPORTED,                   /*      SetChatSettings         */
                 NOTIMPLEMENTED,                         /*      GetBitmap       */
                 NOTIMPLEMENTED,                         /*      SetBitmap       */
                 NOTIMPLEMENTED,                         /*      GetToDoStatus   */
                 NOTIMPLEMENTED,                         /*      GetToDo                 */
                 NOTIMPLEMENTED,                         /*      GetNextToDo     */
                 NOTIMPLEMENTED,                         /*      SetToDo                 */
                 NOTIMPLEMENTED,                         /*      AddToDo                 */
                 NOTIMPLEMENTED,                         /*      DeleteToDo      */
                 NOTIMPLEMENTED,                         /*      DeleteAllToDo   */
                 NOTIMPLEMENTED,                         /*      GetCalendarStatus*/
                 NOTIMPLEMENTED,                         /*      GetCalendar     */
                 NOTIMPLEMENTED,                         /*      GetNextCalendar         */
                 NOTIMPLEMENTED,                         /*      SetCalendar     */
                 NOTIMPLEMENTED,                         /*      AddCalendar     */
                 NOTIMPLEMENTED,                         /*      DeleteCalendar  */
                 NOTIMPLEMENTED,                         /*      DeleteAllCalendar*/
                 NOTSUPPORTED,                   /*      GetCalendarSettings*/
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTSUPPORTED,                   /*      GetNote                 */
+                NOTSUPPORTED,                   /*      GetNextNote     */
                 NOTIMPLEMENTED,                 /*      GetProfile      */
                 NOTIMPLEMENTED,                 /*      SetProfile      */
                 NOTIMPLEMENTED,                         /*      GetFMStation        */
                 NOTIMPLEMENTED,                         /*      SetFMStation        */
                 NOTIMPLEMENTED,                         /*      ClearFMStations       */
         OBEXGEN_GetNextFileFolder,
         OBEXGEN_GetFilePart,
         OBEXGEN_AddFilePart,
                 NOTIMPLEMENTED,                 /*      GetFileSystemStatus*/
         OBEXGEN_DeleteFile,
         OBEXGEN_AddFolder,
                 NOTIMPLEMENTED,                         /*      GetGPRSAccessPoint*/
                 NOTIMPLEMENTED                  /*      SetGPRSAccessPoint*/
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/obex/obexgen.h b/gammu/emb/common/phone/obex/obexgen.h
index 466fef5..b7033de 100644
--- a/gammu/emb/common/phone/obex/obexgen.h
+++ b/gammu/emb/common/phone/obex/obexgen.h
@@ -1,38 +1,42 @@
 /* (c) 2003 by Marcin Wiacek */
 
 #ifndef obexgen_h
 #define obexgen_h
 
 #include "../../gsmcomon.h"
 #include "../../gsmstate.h"
 #include "../../service/gsmmisc.h"
 #include "../../service/sms/gsmsms.h"
 
 #ifndef GSM_USED_IRDAOBEX
 #  define GSM_USED_IRDAOBEX
 #endif
 #ifndef GSM_USED_BLUEOBEX
 #  define GSM_USED_BLUEOBEX
 #endif
 
 typedef enum {
         OBEX_None = 1,
         OBEX_BrowsingFolders
 } OBEX_Service;
 
 typedef struct {
                 int                     FileLev;
                 int                     FilesLocationsUsed;
                 int                     FilesLocationsCurrent;
                 GSM_File                Files[500];
                 bool                    FileLastPart;
 
                 int                     FrameSize;
                 OBEX_Service            Service;
 } GSM_Phone_OBEXGENData;
 
+        GSM_Error OBEXGEN_GetFilePart(GSM_StateMachine *s, GSM_File *File);
+        GSM_Error OBEXGEN_AddFilePart(GSM_StateMachine *s, GSM_File *File, int *Pos);
+        GSM_Error OBEXGEN_Disconnect(GSM_StateMachine *s);
+
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */
diff --git a/gammu/emb/common/phone/symbian/mroutgen.c b/gammu/emb/common/phone/symbian/mroutgen.c
index 2c339be..a7382cf 100644
--- a/gammu/emb/common/phone/symbian/mroutgen.c
+++ b/gammu/emb/common/phone/symbian/mroutgen.c
@@ -50,171 +50,172 @@ unsigned char req0[]={
 0x28,0xCF,0x7D,0x22,0x7D,0x26,0x7D,0x20,0x7D,0x20,
 0x7D,0x20,0x7D,0x20,0x7D,0x27,0x7D,0x22,0x7D,0x28,
 0x7D,0x22,0x82,0xB0};
 
 unsigned char req[]={0x2F,0x45,0x00,0x00,0x34,0x00,0xC6,
                         0x00,0x00,0x0A,0x0D,0x59,0xB4,0xA9,0xFE,0x01,
                         0x44,0xA9,0xFE,0x01,0x0A,0x04,0x09,0x0B,0xB8,
                         0x10,0x00,0x02,0x79,0x69,0x81,0x74,0x99,0x50,
                         0x18,0x60,0x00,0x9D,0x0C,0x00,0x00,0x08,0x00,
                         0x00,0x00,0x12,0x00,0x41,0x00,0x01,0x14,0x00,
                         0x00,0xBA,0x4A};
 
 unsigned char req3[]={0x2D,0x5C,0x0D,0xEC,0x4C,0x10,0x26,0x08,0x00,
 0x00,0x00,0x12,0x00,0x15,0x00,0x01,0x08,0x00,0x00,
 0xAD,0xDE};
 smprintf(s,"writing\n");
         GSM_WaitFor (s, req0, 164, 0x00, 200, ID_Initialise);
 smprintf(s,"writing\n");
         GSM_WaitFor (s, req3, 21, 0x00, 200, ID_Initialise);
         GSM_WaitFor (s, req, 55, 0x00, 200, ID_Initialise);
 
         GSM_WaitFor (s, req2, 15, 0x00, 200, ID_Initialise);
 
 
         while (1) {
                 GSM_ReadDevice(s,false);
         }
 
 
 
         while (1) {
                 GSM_ReadDevice(s,false);
         }
 
 
 return ERR_UNKNOWN;
 }
 
 static GSM_Reply_Function MROUTERGENReplyFunctions[] = {
                 {NULL,                          "\x00",0x00,0x00,ID_None                }
 };
 
 GSM_Phone_Functions MROUTERGENPhone = {
         "mrouter",
         MROUTERGENReplyFunctions,
         MROUTERGEN_Initialise,
                 NONEFUNCTION,                   /*      Terminate       */
         GSM_DispatchMessage,
                 NOTSUPPORTED,                   /*      ShowStartInfo   */
                 NONEFUNCTION,                   /*      GetManufacturer         */
                 NONEFUNCTION,                   /*      GetModel        */
                 NONEFUNCTION,                   /*      GetFirmware     */
                 NOTIMPLEMENTED,                         /*      GetIMEI                 */
                 NOTSUPPORTED,                   /*      GetOriginalIMEI         */
                 NOTSUPPORTED,                   /*      GetManufactureMonth*/
                 NOTSUPPORTED,                   /*      GetProductCode  */
                 NOTSUPPORTED,                   /*      GetHardware     */
                 NOTSUPPORTED,                   /*      GetPPM          */
                 NOTSUPPORTED,                   /*      GetSIMIMSI      */
                 NOTSUPPORTED,                   /*      GetDateTime     */
                 NOTSUPPORTED,                   /*      SetDateTime     */
                 NOTSUPPORTED,                   /*      GetAlarm        */
                 NOTSUPPORTED,                   /*      SetAlarm        */
                 NOTSUPPORTED,                   /*      GetLocale       */
                 NOTSUPPORTED,                   /*      SetLocale       */
                 NOTSUPPORTED,                   /*      PressKey        */
                 NOTSUPPORTED,                   /*      Reset           */
                 NOTSUPPORTED,                   /*      ResetPhoneSettings*/
                 NOTSUPPORTED,                   /*      EnterSecurityCode*/
                 NOTSUPPORTED,                   /*      GetSecurityStatus*/
                 NOTSUPPORTED,                   /*      GetDisplayStatus*/
                 NOTSUPPORTED,                   /*      SetAutoNetworkLogin*/
                 NOTSUPPORTED,                   /*      GetBatteryCharge*/
                 NOTSUPPORTED,                   /*      GetSignalQuality*/
                 NOTSUPPORTED,                   /*      GetNetworkInfo  */
                 NOTSUPPORTED,                   /*      GetCategory     */
                 NOTSUPPORTED,                   /*      GetCategoryStatus       */
                 NOTSUPPORTED,                   /*      GetMemoryStatus         */
                 NOTSUPPORTED,                   /*      GetMemory       */
                 NOTSUPPORTED,                   /*      GetNextMemory   */
                 NOTSUPPORTED,                   /*      SetMemory       */
                 NOTSUPPORTED,                   /*      AddMemory       */
                 NOTSUPPORTED,                   /*      DeleteMemory    */
                 NOTIMPLEMENTED,                         /*      DeleteAllMemory         */
                 NOTSUPPORTED,                   /*      GetSpeedDial    */
                 NOTSUPPORTED,                   /*      SetSpeedDial    */
                 NOTSUPPORTED,                   /*      GetSMSC                 */
                 NOTSUPPORTED,                   /*      SetSMSC                 */
                 NOTSUPPORTED,                   /*      GetSMSStatus    */
                 NOTSUPPORTED,                   /*      GetSMS          */
                 NOTSUPPORTED,                   /*      GetNextSMS      */
                 NOTSUPPORTED,                   /*      SetSMS          */
                 NOTSUPPORTED,                   /*      AddSMS          */
                 NOTSUPPORTED,                   /*      DeleteSMS       */
                 NOTSUPPORTED,                   /*      SendSMSMessage  */
                 NOTSUPPORTED,                   /*      SendSavedSMS    */
+                NOTSUPPORTED,                   /*      SetFastSMSSending*/
                 NOTSUPPORTED,                   /*      SetIncomingSMS  */
                 NOTSUPPORTED,                   /*      SetIncomingCB   */
                 NOTSUPPORTED,                   /*      GetSMSFolders   */
                 NOTSUPPORTED,                   /*      AddSMSFolder    */
                 NOTSUPPORTED,                   /*      DeleteSMSFolder         */
                 NOTSUPPORTED,                   /*      DialVoice       */
                 NOTSUPPORTED,                   /*      AnswerCall      */
                 NOTSUPPORTED,                   /*      CancelCall      */
                 NOTSUPPORTED,                   /*      HoldCall        */
                 NOTSUPPORTED,                   /*      UnholdCall      */
                 NOTSUPPORTED,                   /*      ConferenceCall          */
                 NOTSUPPORTED,                   /*      SplitCall       */
                 NOTSUPPORTED,                   /*      TransferCall    */
                 NOTSUPPORTED,                   /*      SwitchCall      */
                 NOTSUPPORTED,                   /*      GetCallDivert   */
                 NOTSUPPORTED,                   /*      SetCallDivert   */
                 NOTSUPPORTED,                   /*      CancelAllDiverts*/
                 NOTSUPPORTED,                   /*      SetIncomingCall         */
                 NOTSUPPORTED,                   /*      SetIncomingUSSD         */
                 NOTSUPPORTED,                   /*      SendDTMF        */
                 NOTSUPPORTED,                   /*      GetRingtone     */
                 NOTSUPPORTED,                   /*      SetRingtone     */
                 NOTSUPPORTED,                   /*      GetRingtonesInfo*/
                 NOTSUPPORTED,                   /*      DeleteUserRingtones*/
                 NOTSUPPORTED,                   /*      PlayTone        */
                 NOTSUPPORTED,                   /*      GetWAPBookmark  */
                 NOTSUPPORTED,                   /*      SetWAPBookmark          */
                 NOTSUPPORTED,                   /*      DeleteWAPBookmark */
                 NOTSUPPORTED,                   /*      GetWAPSettings          */
                 NOTSUPPORTED,                   /*      SetWAPSettings          */
                 NOTSUPPORTED,                   /*      GetMMSSettings  */
                 NOTSUPPORTED,                   /*      SetMMSSettings  */
                 NOTSUPPORTED,                   /*      GetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      SetSyncMLSettings*/
                 NOTSUPPORTED,                   /*      GetChatSettings         */
                 NOTSUPPORTED,                   /*      SetChatSettings         */
                 NOTSUPPORTED,                   /*      GetBitmap       */
                 NOTSUPPORTED,                   /*      SetBitmap       */
                 NOTSUPPORTED,                   /*      GetToDoStatus   */
                 NOTSUPPORTED,                   /*      GetToDo                 */
                 NOTSUPPORTED,                   /*      GetNextToDo     */
                 NOTSUPPORTED,                   /*      SetToDo                 */
                 NOTSUPPORTED,                   /*      AddToDo                 */
                 NOTSUPPORTED,                   /*      DeleteToDo      */
                 NOTSUPPORTED,                   /*      DeleteAllToDo   */
                 NOTSUPPORTED,                   /*      GetCalendarStatus*/
                 NOTSUPPORTED,                   /*      GetCalendar     */
                 NOTSUPPORTED,                   /*      GetNextCalendar         */
                 NOTSUPPORTED,                   /*      SetCalendar     */
                 NOTSUPPORTED,                   /*      AddCalendar     */
                 NOTSUPPORTED,                   /*      DeleteCalendar  */
                 NOTSUPPORTED,                   /*      DeleteAllCalendar*/
                 NOTSUPPORTED,                   /*      GetCalendarSettings*/
                 NOTSUPPORTED,                   /*      SetCalendarSettings*/
-                NOTSUPPORTED,                   /*      GetNote                 */
+                NOTSUPPORTED,                   /*      GetNextNote     */
                 NOTSUPPORTED,                   /*      GetProfile      */
                 NOTSUPPORTED,                   /*      SetProfile      */
                 NOTSUPPORTED,                   /*      GetFMStation        */
                 NOTSUPPORTED,                   /*      SetFMStation        */
                 NOTSUPPORTED,                   /*      ClearFMStations         */
                 NOTSUPPORTED,                   /*      GetNextFileFolder*/
                 NOTSUPPORTED,                   /*      GetFilePart     */
                 NOTSUPPORTED,                   /*      AddFilePart     */
                 NOTSUPPORTED,                   /*      GetFileSystemStatus*/
                 NOTSUPPORTED,                   /*      DeleteFile      */
                 NOTSUPPORTED,                   /*      AddFolder       */
                 NOTSUPPORTED,                   /*      GetGPRSAccessPoint*/
                 NOTSUPPORTED                    /*      SetGPRSAccessPoint*/
 };
 
 #endif
 
 /* How should editor hadle tabs in this file? Add editor commands here.
  * vim: noexpandtab sw=8 ts=8 sts=8:
  */