1 files changed, 12 insertions, 5 deletions

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,52 +1,54 @@
 /* (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;
@@ -82,96 +84,97 @@ static struct N6110_Lang_Char N6110_Lang_Table[] = {
 {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;
                 }
@@ -779,96 +782,97 @@ static GSM_Error N6110_SetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone,
                                      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) {
@@ -1479,133 +1483,135 @@ static GSM_Error N6110_ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachi
         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:
@@ -2398,98 +2404,98 @@ static GSM_Error N6110_ReplyGetNextCalendar(GSM_Protocol_Message msg, GSM_StateM
                         }
                 }
                 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;
@@ -2762,123 +2768,124 @@ GSM_Phone_Functions N6110Phone = {
         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:
  */