updated to latest gammu version

5 files changed, 33 insertions, 14 deletions

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,27 +1,30 @@
 /* (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);
 }
@@ -373,115 +376,116 @@ GSM_Error DCT3_SetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm, unsigned char msg
 	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;
@@ -1187,53 +1191,53 @@ GSM_Error DCT3_SetWAPSettings(GSM_StateMachine *s, GSM_MultiWAPSettings *setting
 		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;
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,29 +1,31 @@
 /* (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);
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,28 +1,30 @@
 /* (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,
@@ -106,48 +108,49 @@ static void N6110_EncodeUnicode(GSM_StateMachine *s, unsigned char *dest, const
                                 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). */
@@ -803,48 +806,49 @@ static GSM_Error N6110_SetRingtone(GSM_StateMachine *s, GSM_Ringtone *Ringtone,
                                 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;
@@ -1503,85 +1507,87 @@ static GSM_Error N6110_ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachi
                         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;
@@ -2422,50 +2428,50 @@ static GSM_Error N6110_GetNextCalendarNote(GSM_StateMachine *s, GSM_CalendarEntr
                 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);
@@ -2786,48 +2792,49 @@ GSM_Phone_Functions N6110Phone = {
         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     */
@@ -2840,45 +2847,45 @@ GSM_Phone_Functions N6110Phone = {
         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,26 +1,29 @@
 /* (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)
 {
@@ -505,48 +508,49 @@ static GSM_Error N7110_ReplyGetRingtone(GSM_Protocol_Message msg, GSM_StateMachi
 	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)
 {
@@ -1626,48 +1630,49 @@ GSM_Phone_Functions N7110Phone = {
 	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	*/
@@ -1680,45 +1685,45 @@ GSM_Phone_Functions N7110Phone = {
 	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
@@ -298,48 +298,49 @@ GSM_Phone_Functions N9210Phone = {
 	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	*/
@@ -352,45 +353,45 @@ GSM_Phone_Functions N9210Phone = {
 	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:
  */