rendered paste body/* (c) 2006 by Marcin Wiacek */
#include <string.h>
#include <time.h>
#include "../../gsmcomon.h"
#include "../../gsmstate.h"
#include "../../misc/coding/coding.h"
#include "../../service/gsmmisc.h"
#include "../nokia/nfunc.h"
#include "../pfunc.h"
#ifdef GSM_ENABLE_GNAPGEN
unsigned char GNAPGEN_MEMORY_TYPES[] = {
MEM_SM, 0x01,
MEM_ON, 0x03,
MEM_DC, 0x05,
MEM_RC, 0x06,
MEM_MC, 0x07,
0x00, 0x00
};
GSM_Error GNAPGEN_ReplyGetSMSFolderStatus(GSM_Protocol_Message msg, GSM_StateMachine *s) {
GSM_Phone_GNAPGENData *Priv = &s->Phone.Data.Priv.GNAPGEN;
if( msg.Buffer[3] == 17){
smprintf(s, "Invalid memory type");
return ERR_UNKNOWN;
}
int i;
int pos = 10;
Priv->SMSCount = msg.Buffer[8] * 256 + msg.Buffer[9];
dbgprintf("SMS count: %d\n", Priv->SMSCount );
for( i=0; i<Priv->SMSCount; i++ ) {
smprintf(s, "Entry id %d: %d\n", i, msg.Buffer[pos+1] * 256 * 256 + msg.Buffer[pos+2]*256+msg.Buffer[pos+3]);
Priv->SMSIDs[i].byte1 = msg.Buffer[pos];
Priv->SMSIDs[i].byte2 = msg.Buffer[pos+1];
Priv->SMSIDs[i].byte3 = msg.Buffer[pos+2];
Priv->SMSIDs[i].byte4 = msg.Buffer[pos+3];
pos += 4;
}
return ERR_NONE;
}
static GSM_Error GNAPGEN_PrivGetSMSFolderStatus(GSM_StateMachine *s, int folderid)
{
unsigned char req[] = {0, 3,
0,0x0c}; /* folderID c,d,e,f...*/
req[3] = folderid;
return GSM_WaitFor (s, req, 4, 6, 4, ID_GetSMSFolderStatus);
}
static GSM_Error GSM_DecodeSMSDateTime(GSM_DateTime *DT, unsigned char *req)
{
DT->Year = DecodeWithBCDAlphabet(req[0]);
if (DT->Year<90) DT->Year=DT->Year+2000; else DT->Year=DT->Year+1990;
DT->Month = DecodeWithBCDAlphabet(req[1]);
DT->Day = DecodeWithBCDAlphabet(req[2]);
DT->Hour = DecodeWithBCDAlphabet(req[3]);
DT->Minute = DecodeWithBCDAlphabet(req[4]);
DT->Second = DecodeWithBCDAlphabet(req[5]);
/* Base for timezone is GMT. It's in quarters */
DT->Timezone=(10*(req[6]&0x07)+(req[6]>>4))/4;
if (req[6]&0x08) DT->Timezone = -DT->Timezone;
dbgprintf("Decoding date & time: ");
dbgprintf("%s %4d/%02d/%02d ", DayOfWeek(DT->Year, DT->Month, DT->Day),
DT->Year, DT->Month, DT->Day);
dbgprintf("%02d:%02d:%02d %02d00\n", DT->Hour, DT->Minute, DT->Second, DT->Timezone);
return ERR_NONE;
}
GSM_Error GNAPGEN_PrivSetSMSLayout( GSM_SMSMessage *sms, unsigned char *buffer, GSM_SMSMessageLayout *Layout ) {
int position = 0;
// setting sms layout
*Layout = PHONE_SMSDeliver;
Layout->SMSCNumber = 0;
// the pdu type is always behind the smsc number
if( (buffer[0] % 2) == 0 )
position = (buffer[0] / 2) + 1;
else
position = ((buffer[0] +1 ) / 2) + 1;
position++;
Layout->firstbyte = position;
// determine whether the sms was received or sent
switch( buffer[position] & 1 ) {
// SMS-DELIVER (incoming message, received)
case 0:
dbgprintf("Message type: SMS-DELIVER\n");
sms->PDU = SMS_Deliver;
position++;
Layout->Number = position;
if( (buffer[position] % 2) == 0 )
position += (buffer[position] / 2) + 1;
else
position += ((buffer[position] + 1 ) / 2) + 1;
position++;
Layout->TPPID = position;
position++;
Layout->TPDCS = position;
position++;
Layout->DateTime = position;
Layout->SMSCTime = position;
position += 7;
Layout->TPUDL = position;
position++;
Layout->Text = position;
Layout->TPStatus = 255;
Layout->TPVP = 255;
Layout->TPMR = 255;
break;
// SMS-SUBMIT (outgoing message, to be sent)
case 1:
dbgprintf("Message type: SMS-SUBMIT\n");
sms->PDU = SMS_Submit;
position++;
Layout->TPMR = position;
position++;
Layout->Number = position;
if( (buffer[position] % 2) == 0 )
position += (buffer[position] / 2) + 1;
else
position += ((buffer[position] + 1 ) / 2) + 1;
position++;
Layout->TPPID = position;
position++;
Layout->TPDCS = position;
position++;
/* the validity period field length depends on the VP flag set in the pdu-type */
if( buffer[position] & 0x16 ) {
// VP is integer represented
Layout->TPVP = position;
} else if ( buffer[position] & 0x08 ) {
position += 6;
Layout->TPVP = position;
// VP is semi-octet represented
}
position++;
Layout->TPUDL = position;
position++;
Layout->Text = position;
Layout->TPStatus = 255;
Layout->DateTime = 255;
Layout->SMSCTime = 255;
break;
default:
dbgprintf("Unknown message type: (PDU) %d\n", buffer[Layout->firstbyte] );
return ERR_UNKNOWN;
}
return ERR_NONE;
}
GSM_Error GNAPGEN_DecodeSMSFrame(GSM_SMSMessage *SMS, unsigned char *buffer, GSM_SMSMessageLayout *Layout)
{
GSM_DateTime zerodt = {0,0,0,0,0,0,0};
#ifdef DEBUG
if (Layout->firstbyte == 255) {
dbgprintf("ERROR: firstbyte in SMS layout not set\n");
return ERR_UNKNOWN;
}
if (Layout->TPDCS != 255) dbgprintf("TPDCS : %02x %i\n",buffer[Layout->TPDCS] ,buffer[Layout->TPDCS]);
if (Layout->TPMR != 255) dbgprintf("TPMR : %02x %i\n",buffer[Layout->TPMR] ,buffer[Layout->TPMR]);
if (Layout->TPPID != 255) dbgprintf("TPPID : %02x %i\n",buffer[Layout->TPPID] ,buffer[Layout->TPPID]);
if (Layout->TPUDL != 255) dbgprintf("TPUDL : %02x %i\n",buffer[Layout->TPUDL] ,buffer[Layout->TPUDL]);
if (Layout->firstbyte != 255) dbgprintf("FirstByte : %02x %i\n",buffer[Layout->firstbyte],buffer[Layout->firstbyte]);
if (Layout->Text != 255) dbgprintf("Text : %02x %i\n",buffer[Layout->Text] ,buffer[Layout->Text]);
#endif
SMS->UDH.Type = UDH_NoUDH;
SMS->Coding = SMS_Coding_8bit;
SMS->Length = 0;
SMS->SMSC.Location = 0;
SMS->SMSC.DefaultNumber[0] = 0;
SMS->SMSC.DefaultNumber[1] = 0;
SMS->SMSC.Number[0] = 0;
SMS->SMSC.Number[1] = 0;
SMS->SMSC.Name[0] = 0;
SMS->SMSC.Name[1] = 0;
SMS->SMSC.Validity.Format = SMS_Validity_NotAvailable;
SMS->SMSC.Format = SMS_FORMAT_Text;
SMS->Number[0] = 0;
SMS->Number[1] = 0;
SMS->OtherNumbersNum = 0;
SMS->Name[0] = 0;
SMS->Name[1] = 0;
SMS->ReplyViaSameSMSC = false;
if (Layout->SMSCNumber!=255) {
GSM_UnpackSemiOctetNumber(SMS->SMSC.Number,buffer+Layout->SMSCNumber,true);
dbgprintf("SMS center number : \"%s\"\n",DecodeUnicodeString(SMS->SMSC.Number));
}
if ((buffer[Layout->firstbyte] & 0x80)!=0) SMS->ReplyViaSameSMSC=true;
#ifdef DEBUG
if (SMS->ReplyViaSameSMSC) dbgprintf("SMS centre set for reply\n");
#endif
if (Layout->Number!=255) {
GSM_UnpackSemiOctetNumber(SMS->Number,buffer+Layout->Number,true);
dbgprintf("Remote number : \"%s\"\n",DecodeUnicodeString(SMS->Number));
}
if (Layout->Text != 255 && Layout->TPDCS!=255 && Layout->TPUDL!=255) {
GSM_DecodeSMSFrameText(SMS, buffer, *Layout);
}
if (Layout->DateTime != 255) {
GSM_DecodeSMSDateTime(&SMS->DateTime,buffer+(Layout->DateTime));
} else {
SMS->DateTime = zerodt;
}
if (Layout->SMSCTime != 255 && Layout->TPStatus != 255) {
/* GSM 03.40 section 9.2.3.11 (TP-Service-Centre-Time-Stamp) */
dbgprintf("SMSC response date: ");
GSM_DecodeSMSDateTime(&SMS->SMSCTime, buffer+(Layout->SMSCTime));
GSM_DecodeSMSFrameStatusReportData(SMS,buffer,*Layout);
GSM_DecodeSMSDateTime(&SMS->DateTime, buffer+(Layout->SMSCTime));
} else {
SMS->SMSCTime = zerodt;
}
SMS->Class = -1;
if (Layout->TPDCS != 255) {
/* GSM 03.40 section 9.2.3.10 (TP-Data-Coding-Scheme) and GSM 03.38 section 4 */
if ((buffer[Layout->TPDCS] & 0xD0) == 0x10) {
/* bits 7..4 set to 00x1 */
if ((buffer[Layout->TPDCS] & 0xC) == 0xC) {
dbgprintf("WARNING: reserved alphabet value in TPDCS\n");
} else {
SMS->Class = (buffer[Layout->TPDCS] & 3);
}
} else if ((buffer[Layout->TPDCS] & 0xF0) == 0xF0) {
/* bits 7..4 set to 1111 */
if ((buffer[Layout->TPDCS] & 8) == 8) {
dbgprintf("WARNING: set reserved bit 3 in TPDCS\n");
} else {
SMS->Class = (buffer[Layout->TPDCS] & 3);
}
}
dbgprintf("SMS class: %i\n",SMS->Class);
}
SMS->MessageReference = 0;
if (Layout->TPMR != 255) SMS->MessageReference = buffer[Layout->TPMR];
SMS->ReplaceMessage = 0;
if (Layout->TPPID != 255) {
if (buffer[Layout->TPPID] > 0x40 && buffer[Layout->TPPID] < 0x48) {
SMS->ReplaceMessage = buffer[Layout->TPPID] - 0x40;
}
}
SMS->RejectDuplicates = false;
if ((buffer[Layout->firstbyte] & 0x04)==0x04) SMS->RejectDuplicates = true;
return ERR_NONE;
}
static GSM_Error GNAPGEN_ReplyGetSMS(GSM_Protocol_Message msg, GSM_StateMachine *s) {
GSM_SMSMessage *sms = 0;
unsigned char buffer[800];
int numberOfMessages = 0;
int messageLen = 0;
int state = 0;
numberOfMessages = msg.Buffer[4] * 256 + msg.Buffer[5];
s->Phone.Data.GetSMSMessage->Number = numberOfMessages;
switch( msg.Buffer[msg.Length-1] ) {
case 0x01:
state = SMS_Read;
break;
case 0x03:
state = SMS_UnRead;
break;
case 0x05:
state = SMS_Sent;
break;
case 0x07:
state = SMS_UnSent;
break;
}
int i;
int current=6;
GSM_SMSMessageLayout layout;
for( i=0; i<numberOfMessages; i++ ) {
messageLen = msg.Buffer[current] * 256 + msg.Buffer[current+1];
memset( buffer, 0, 800 );
memcpy( buffer, msg.Buffer + current + 2, messageLen );
current += messageLen + 2;
sms = &s->Phone.Data.GetSMSMessage->SMS[i];
sms->State = state;
s->Phone.Data.GetSMSMessage->SMS[i].Name[0] = 0;
s->Phone.Data.GetSMSMessage->SMS[i].Name[1] = 0;
GNAPGEN_PrivSetSMSLayout( sms, buffer, &layout );
GNAPGEN_DecodeSMSFrame(sms,buffer,&layout);
}
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetNextSMS(GSM_StateMachine *s, GSM_MultiSMSMessage *sms, bool start)
{
GSM_Phone_GNAPGENData *Priv = &s->Phone.Data.Priv.GNAPGEN;
GSM_Phone_Data *Data = &s->Phone.Data;
/// @todo remove the folder attribute from the request header since it's not used on the phone
unsigned char req [8] = {0,11,
0x00,0x0c, //folder
0x00,0x10,0x00,0x3F}; //location
if( start ) {
Priv->CurrentFolderNumber = 0;
Priv->CurrentSMSNumber = 0;
}
// retrieve the sms IDs for the given folder
if( Priv->CurrentSMSNumber == 0 )
GNAPGEN_PrivGetSMSFolderStatus(s,Priv->SMSFolderID[Priv->CurrentFolderNumber]);
int i;
for( i=0; i<5; i++ )
GSM_SetDefaultSMSData(&sms->SMS[i]);
// if there are no SMS in current folder, just skip it
bool skipfolder;
do {
if( Priv->SMSCount == 0 ) {
if( (Data->SMSFolders->Number - 1) == Priv->CurrentFolderNumber )
return ERR_EMPTY;
else {
Priv->CurrentSMSNumber = 0;
Priv->CurrentFolderNumber++;
}
GNAPGEN_PrivGetSMSFolderStatus(s,Priv->SMSFolderID[Priv->CurrentFolderNumber]);
skipfolder = true;
} else
skipfolder = false;
} while( skipfolder );
// set location
req[4] = Priv->SMSIDs[Priv->CurrentSMSNumber].byte1;
req[5] = Priv->SMSIDs[Priv->CurrentSMSNumber].byte2;
req[6] = Priv->SMSIDs[Priv->CurrentSMSNumber].byte3;
req[7] = Priv->SMSIDs[Priv->CurrentSMSNumber].byte4;
sms->SMS[0].Folder = Priv->SMSFolderID[Priv->CurrentFolderNumber];
if( Priv->CurrentFolderNumber == 0 )
sms->SMS[0].InboxFolder = true;
sms->SMS[0].Location = ( req[4] * (256*256*256) ) + req[5] * 256 * 256 + req[6] * 256 + req[7];
sms->SMS[0].Memory = MEM_ME;
s->Phone.Data.GetSMSMessage=sms;
GSM_Error error = GSM_WaitFor (s, req, 8, 0x6, 500, ID_GetSMSMessage);
if( error != ERR_NONE )
return error;
if( Priv->CurrentSMSNumber == ( Priv->SMSCount - 1 ) ) {
// last sms in current folder reached, check if there are folders left to checkout
if( Priv->CurrentFolderNumber == (Data->SMSFolders->Number - 1) )
return ERR_UNKNOWN;
else {
Priv->CurrentSMSNumber = 0;
Priv->CurrentFolderNumber++;
}
} else
Priv->CurrentSMSNumber++;
return error;
}
static GSM_Error GNAPGEN_EncodeSMSFrame(GSM_StateMachine *s, GSM_SMSMessage *sms, unsigned char *req, GSM_SMSMessageLayout *Layout, int *length)
{
int start, count = 0;
GSM_Error error;
memset(Layout,255,sizeof(GSM_SMSMessageLayout));
sms->Class = -1;
start = *length;
*Layout = PHONE_SMSSubmit;
// smsc number is semi-octet
Layout->SMSCNumber = count;
dbgprintf("SMSCNumber: %d\n", count );
if( UnicodeLength(sms->SMSC.Number) == 0 )
count += (UnicodeLength(sms->SMSC.Number) / 2) + 1;
else
count += ((UnicodeLength(sms->SMSC.Number) + 1 ) / 2) + 1;
// firstbyte set in SMS Layout
Layout->firstbyte = count;
dbgprintf("firstbyte: %d\n", count);
count++;
if (sms->PDU != SMS_Deliver) {
Layout->TPMR = count;
dbgprintf("TPMR: %d\n", Layout->TPMR);
count++;
}
// Phone number
Layout->Number = count;
dbgprintf("Number: %d\n", count);
if( UnicodeLength(sms->Number) == 0 )
count += (UnicodeLength(sms->Number) / 2) + 1;
else
count += ((UnicodeLength(sms->Number) + 1 ) / 2) + 1;
Layout->TPPID = count;
dbgprintf("TPPID: %d\n", count);
count++;
Layout->TPDCS = count;
dbgprintf("TPDCS: %d\n", count);
count++;
if (sms->PDU == SMS_Deliver) {
Layout->DateTime = count;
dbgprintf("DateTime: %d\n", count);
count += 7;
} else {
Layout->TPVP = count;
dbgprintf("TPVP: %d\n", count);
count++;
}
Layout->TPUDL = count;
dbgprintf("TPUDL: %d\n", count);
count++;
Layout->Text = count;
dbgprintf("Text: %d\n", count);
error = PHONE_EncodeSMSFrame(s,sms,req,*Layout,length,false);
if (error != ERR_NONE) return error;
req[0] = 0x0b;
req[10] = 0x07;
return ERR_NONE;
}
static GSM_Error GNAPGEN_SendSMSMessage(GSM_StateMachine *s, GSM_SMSMessage *sms)
{
int length = 11;
GSM_Error error;
GSM_SMSMessageLayout Layout;
unsigned char req [300] = {0,15};
if (sms->PDU == SMS_Deliver) sms->PDU = SMS_Submit;
memset(req+2,0x00,sizeof(req) - 2);
error=GNAPGEN_EncodeSMSFrame(s, sms, req + 2, &Layout, &length);
if (error != ERR_NONE) return error;
DumpMessage(&s->di, req, length+1);
//return ERR_NONE;
smprintf(s, "Sending sms\n");
return s->Protocol.Functions->WriteMessage(s, req, length + 2, 0x06);
}
GSM_Error GNAPGEN_ReplySetSMS (GSM_Protocol_Message msg, GSM_StateMachine *s) {
/// @todo do something useful here ;)
dbgprintf("SetSMS: got reply\n");
return ERR_NONE;
}
static GSM_Error GNAPGEN_PrivSetSMSMessage(GSM_StateMachine *s, GSM_SMSMessage *sms)
{
int length = 0;
GSM_SMSMessageLayout Layout;
GSM_Error error;
unsigned char req [300] = {0,13,
0x00,0x0c, //folder
0x00,0x10,0x00,0x3F, //location
/*
0x00, 31,
0x07, 0x91, 0x94, 0x71, 0x22, 0x72, 0x30, 0x33, 0x01, 0x00, 0x0B, 0x91, 0x94, 0x61, 0x10, 0x32, 0x54, 0xF6, 0x00, 0x00, 0x04, 0xF4, 0xF2, 0x9C, 0x0E};
*/
0x00, 168,
0x0C, 0x91, 0x94, 0x71, 0x01, 0x67, 0x00, 0x00,
0x04, 0x0C, 0x91, 0x94, 0x71, 0x70, 0x91, 0x10, 0x66, 0x00, 0x00, 0x70, 0x30, 0x32, 0x12, 0x40,
0x35, 0x40, 0x9F, 0xC8, 0x72, 0x1E, 0x84, 0x7C, 0xBB, 0xCB, 0xF9, 0xD0, 0x34, 0x5D, 0x46, 0xD3,
0x41, 0x7E, 0x71, 0x99, 0x0D, 0x32, 0xFB, 0xE5, 0xA0, 0xBA, 0x7B, 0x0E, 0x0A, 0xD7, 0xE7, 0x21,
0x50, 0xD5, 0x4D, 0x06, 0xA1, 0xD3, 0x65, 0x39, 0x68, 0x9E, 0x76, 0x93, 0x41, 0xF5, 0x36, 0xA8,
0xEE, 0x9E, 0x83, 0xE4, 0xF5, 0x36, 0xC8, 0x5D, 0x97, 0x83, 0xEC, 0x6F, 0x36, 0xFB, 0x5C, 0x9E,
0xBF, 0xCD, 0xE6, 0xB2, 0xBB, 0x0C, 0x0A, 0xCE, 0xE7, 0xE9, 0x79, 0xC8, 0x99, 0x2E, 0x83, 0xEE,
0xE9, 0x32, 0xB9, 0x2C, 0x07, 0x05, 0xEB, 0xF3, 0xFB, 0x5E, 0x4E, 0x9F, 0x9B, 0xC3, 0x68, 0x39,
0x3D, 0x04, 0x22, 0x86, 0xEB, 0xED, 0xB2, 0x1B, 0x44, 0x96, 0xFB, 0xC7, 0xEB, 0xB2, 0x9B, 0x45,
0x0E, 0xCF, 0xE7, 0xA0, 0x7B, 0x5A, 0x0E, 0xBA, 0x97, 0xDD, 0xE9, 0xF3, 0x9C, 0x5E, 0x76, 0xCF,
0x41, 0xEE, 0xF7, 0x18, 0x0D, 0x3A, 0x97, 0xEF, 0x69, 0xB7, 0xBB, 0xEC, 0x0E, 0x4D, 0x01, 0x01 };
/*
0x00,29, // pdu length
0x0B,0x91, // sample message
0x44,0x83,0x05,0x61,0x00,0xF5, //Service centre
0x11,0x00,0x0C,0x91,
0x44,0xaa,0xbb,0xcc,0xdd,0xee,//Destination
0x00,0x00,0xAD,0x07,0xD4,0xE2,0x94,0x9A,0x74,0x1E,0x01};
*/
req[3] = sms->Folder;
/// @todo allow existing messages to be edited (not implemented in gnapplet)
if (sms->PDU == SMS_Deliver)
sms->PDU = SMS_Submit;
//memset(req+8,0x00,300-8);
//error = GNAPGEN_EncodeSMSFrame( s, sms, req + 10, &Layout, &length );
length = 170;
req[9] = length;
int i=0;
for( i=10; i<length+10; i++ )
dbgprintf("%x", req[i] );
dbgprintf("\n");
s->Phone.Data.SaveSMSMessage=sms;
return GSM_WaitFor (s, req, length+10, 0x6, 4, ID_SaveSMSMessage);
}
static GSM_Error GNAPGEN_AddSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
{
// N6510_GetSMSLocation(s, sms, &folderid, &location);
// location = 0;
// N6510_SetSMSLocation(s, sms, folderid, location);
return GNAPGEN_PrivSetSMSMessage(s, sms);
}
//-----------------------------------------------------------------------------
static GSM_Error GNAPGEN_ReplyGetSignalQuality(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_Data *Data = &s->Phone.Data;
smprintf(s, "Network level received: %i\n",msg.Buffer[4]);
Data->SignalQuality->SignalStrength = -1;
Data->SignalQuality->SignalPercent = ((int)msg.Buffer[4]);
Data->SignalQuality->BitErrorRate = -1;
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetSignalQuality(GSM_StateMachine *s, GSM_SignalQuality *sig)
{
unsigned char req[] = {0x00,0x03};
s->Phone.Data.SignalQuality = sig;
smprintf(s, "Getting network level\n");
return GSM_WaitFor (s, req, 2, 0x03, 4, ID_GetSignalQuality);
}
static GSM_Error GNAPGEN_ReplyGetBatteryCharge(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_Data *Data = &s->Phone.Data;
smprintf(s, "Battery level received: %i\n",msg.Buffer[4]);
Data->BatteryCharge->BatteryPercent = ((int)(msg.Buffer[4]));
Data->BatteryCharge->ChargeState = 0;
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetBatteryCharge(GSM_StateMachine *s, GSM_BatteryCharge *bat)
{
unsigned char req[] = {0x00, 0x01};
GSM_ClearBatteryCharge(bat);
s->Phone.Data.BatteryCharge = bat;
smprintf(s, "Getting battery level\n");
return GSM_WaitFor (s, req, 2, 0x04, 4, ID_GetBatteryCharge);
}
static GSM_Error GNAPGEN_ReplyGetNetworkInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_Data *Data = &s->Phone.Data;
char buf[100];
#ifdef DEBUG
GSM_NetworkInfo NetInfo;
smprintf(s, "Network status : ");
switch (msg.Buffer[9]) {
case 0x00 : smprintf(s, "home network ?\n"); break;
default : smprintf(s, "unknown %i!\n",msg.Buffer[9]); break;
}
if (msg.Buffer[9]==0x00) {
sprintf(NetInfo.CID, "%02X%02X", msg.Buffer[4], msg.Buffer[5]);
smprintf(s, "CID : %s\n", NetInfo.CID);
sprintf(NetInfo.LAC, "%02X%02X", msg.Buffer[6], msg.Buffer[7]);
smprintf(s, "LAC : %s\n", NetInfo.LAC);
memset(buf,0,sizeof(buf));
memcpy(buf,msg.Buffer+11,msg.Buffer[10]*2);
sprintf(NetInfo.NetworkCode,"%s",DecodeUnicodeString(buf));
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)));
}
#endif
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;
}
if (Data->NetworkInfo->State == GSM_HomeNetwork) {
sprintf(Data->NetworkInfo->CID, "%02X%02X", msg.Buffer[4], msg.Buffer[5]);
sprintf(Data->NetworkInfo->LAC, "%02X%02X", msg.Buffer[6], msg.Buffer[7]);
memset(buf,0,sizeof(buf));
memcpy(buf,msg.Buffer+11,msg.Buffer[10]*2);
sprintf(Data->NetworkInfo->NetworkCode,"%s",DecodeUnicodeString(buf));
}
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetNetworkInfo(GSM_StateMachine *s, GSM_NetworkInfo *netinfo)
{
unsigned char req[] = {0x00, 0x01};
s->Phone.Data.NetworkInfo=netinfo;
smprintf(s, "Getting network info\n");
return GSM_WaitFor (s, req, 2, 0x03, 4, ID_GetNetworkInfo);
}
static GSM_Error GNAPGEN_ReplyGetMemoryStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_Data *Data = &s->Phone.Data;
smprintf(s, "Memory status received\n");
if (msg.Length == 4) return ERR_EMPTY;
Data->MemoryStatus->MemoryUsed = msg.Buffer[8]*256 + msg.Buffer[9];
Data->MemoryStatus->MemoryFree = msg.Buffer[12]*256 + msg.Buffer[13];
smprintf(s, "Free : %i\n",Data->MemoryStatus->MemoryFree);
smprintf(s, "Used : %i\n",Data->MemoryStatus->MemoryUsed);
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetMemoryStatus(GSM_StateMachine *s, GSM_MemoryStatus *Status)
{
unsigned char req[] = {0x00,0x07,0x00,
0x00}; /* memory type */
if (Status->MemoryType != MEM_ME) {
req[3] = NOKIA_GetMemoryType(s, Status->MemoryType,GNAPGEN_MEMORY_TYPES);
if (req[3]==0xff) return ERR_NOTSUPPORTED;
}
s->Phone.Data.MemoryStatus=Status;
smprintf(s, "Getting memory status\n");
return GSM_WaitFor (s, req, 4, 0x02, 4, ID_GetMemoryStatus);
}
static GSM_Error GNAPGEN_ReplyGetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
int i,pos=6,type,subtype,len;
GSM_MemoryEntry *entry = s->Phone.Data.Memory;
entry->EntriesNum=0;
smprintf(s, "Phonebook entry received\n");
for (i=0;i<msg.Buffer[5];i++) {
type = msg.Buffer[pos]*256+msg.Buffer[pos+1];
subtype = msg.Buffer[pos+2]*256+msg.Buffer[pos+3];
pos+=4;
switch (type) {
// name
case 0x07:
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
if (len!=0) {
entry->Entries[entry->EntriesNum].EntryType=PBK_Text_Name;
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
}
pos+=2+len*2;
break;
// email
case 0x08:
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
entry->Entries[entry->EntriesNum].EntryType=PBK_Text_Email;
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
pos+=2+len*2;
break;
// 0x0b is a general identifier for a number
case 0x0B:
switch(subtype) {
// fax
case 0x04:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_Fax;
break;
// work
case 0x06:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_Work;
break;
// mobile
case 0x03:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_Mobile;
break;
// home
case 0x02:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_Home;
break;
// general
case 0x0a: default:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_General;
break;
}
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
pos+=2+len*2;
break;
// date
case 0x13:
entry->Entries[entry->EntriesNum].EntryType=PBK_Date;
NOKIA_DecodeDateTime(s, msg.Buffer+pos, &entry->Entries[entry->EntriesNum].Date);
entry->EntriesNum++;
pos+=2+7;
break;
// note
case 0x0a:
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
entry->Entries[entry->EntriesNum].EntryType=PBK_Text_Note;
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
pos+=2+len*2;
break;
// url
case 0x2c:
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
entry->Entries[entry->EntriesNum].EntryType=PBK_Text_URL;
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
pos+=2+len*2;
break;
default:
smprintf(s, "unknown %i\n",type);
return ERR_UNKNOWN;
}
}
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry)
{
unsigned char req[] = {0x00, 0x01,
0x00, 0x00, /* memory type */
0x00, 0x00, 0x00, 0x00}; /* location */
if (entry->MemoryType != MEM_ME) {
req[3] = NOKIA_GetMemoryType(s, entry->MemoryType,GNAPGEN_MEMORY_TYPES);
if (req[3]==0xff) return ERR_NOTSUPPORTED;
}
if (entry->Location==0x00) return ERR_INVALIDLOCATION;
req[6] = entry->Location / 256;
req[7] = entry->Location % 256;
s->Phone.Data.Memory=entry;
smprintf(s, "Getting phonebook entry\n");
return GSM_WaitFor (s, req, 8, 0x02, 6, ID_GetMemory);
}
static GSM_Error GNAPGEN_ReplySetMemory(GSM_Protocol_Message msg, GSM_StateMachine *s) {
dbgprintf("Got reply: SetMemory()\n");
if( msg.Buffer[4] == 0 )
return ERR_NONE;
else
return ERR_UNKNOWN;
}
static GSM_Error GNAPGEN_SetMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry)
{
unsigned char req[1000] = {0x00, 0x03,
0x00, 0x00, /* memory type */
0x00, 0x00, 0x00, 0x00, /* location */
0x00, 0x00 }; /* number of entries to read */
memset( req + 3,0x00,sizeof(req) - 3 );
if (entry->MemoryType != MEM_ME) {
req[3] = NOKIA_GetMemoryType(s, entry->MemoryType,GNAPGEN_MEMORY_TYPES);
if (req[3]==0xff) return ERR_NOTSUPPORTED;
}
if (entry->Location==0x00) return ERR_INVALIDLOCATION;
req[6] = entry->Location / 256;
req[7] = entry->Location % 256;
// for each entry, 2 bytes are reserved for the entry type,
// 2 bytes for the entry sub-type if available and 64 byte for the actual entry
int currentByte = 10;
int i = 0;
int entryCount = 0;
GSM_SubMemoryEntry *subMemoryEntry;
for( i=0; i< entry->EntriesNum; i++ ) {
subMemoryEntry = &entry->Entries[i];
switch( subMemoryEntry->EntryType ) {
case PBK_Number_Home:
req[currentByte++] = 0x00;
req[currentByte++] = 0x0b;
req[currentByte++] = 0x00;
req[currentByte++] = 0x02;
break;
case PBK_Number_General:
case PBK_Number_Mobile:
req[currentByte++] = 0x00;
req[currentByte++] = 0x0b;
req[currentByte++] = 0x00;
req[currentByte++] = 0x03;
break;
case PBK_Number_Work:
req[currentByte++] = 0x00;
req[currentByte++] = 0x0b;
req[currentByte++] = 0x00;
req[currentByte++] = 0x06;
break;
case PBK_Number_Fax:
req[currentByte++] = 0x00;
req[currentByte++] = 0x0b;
req[currentByte++] = 0x00;
req[currentByte++] = 0x04;
break;
case PBK_Text_Email:
req[currentByte++] = 0x00;
req[currentByte++] = 0x08;
req[currentByte++] = 0x00;
req[currentByte++] = 0x00;
break;
case PBK_Text_Name:
req[currentByte++] = 0x00;
req[currentByte++] = 0x07;
req[currentByte++] = 0x00;
req[currentByte++] = 0x00;
break;
default:
continue;
}
entryCount++;
req[currentByte++] = 0x00;
req[currentByte++] = UnicodeLength( subMemoryEntry->Text );
memcpy( req + currentByte, subMemoryEntry->Text, UnicodeLength( subMemoryEntry->Text ) * 2 );
currentByte += UnicodeLength( subMemoryEntry->Text ) * 2;
}
req[9] = entryCount;
return GSM_WaitFor(s, req, currentByte, 0x02, 4, ID_SetMemory);
}
GSM_Error GNAPGEN_ReplyGetToDo(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_ToDoEntry *Last = s->Phone.Data.ToDo;
int pos = 8;
smprintf(s, "TODO received\n");
memcpy(Last->Entries[0].Text,msg.Buffer+pos+2,(msg.Buffer[pos]*256+msg.Buffer[pos+1])*2);
Last->Entries[0].Text[(msg.Buffer[pos]*256+msg.Buffer[pos+1])*2] = 0;
Last->Entries[0].Text[(msg.Buffer[pos]*256+msg.Buffer[pos+1])*2+1] = 0;
smprintf(s, "Text: \"%s\"\n",DecodeUnicodeString(Last->Entries[0].Text));
pos+=(msg.Buffer[pos]*256+msg.Buffer[pos+1])*2+2;
/**
* @todo There might be better type.
*/
Last->Type = GSM_CAL_MEMO;
switch (msg.Buffer[pos]) {
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]);
Last->Entries[0].EntryType = TODO_TEXT;
Last->EntriesNum = 1;
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetNextToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo, bool refresh)
{
GSM_Error error;
unsigned char req[] = {0x00, 0x07,
0x00, 0x00, 0x00, 0x00}; /* Location */
if (refresh) {
ToDo->Location = 1;
} else {
ToDo->Location++;
}
req[4] = ToDo->Location / 256;
req[5] = ToDo->Location % 256;
s->Phone.Data.ToDo = ToDo;
smprintf(s, "Getting todo\n");
error = GSM_WaitFor (s, req, 6, 7, 4, ID_GetToDo);
if (error == ERR_INVALIDLOCATION) error = ERR_EMPTY;
return error;
}
GSM_Error GNAPGEN_DeleteCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
{
unsigned char req[] = {0x00, 0x05,
0x00, 0x00, 0x00, 0x00}; /* Location */
req[4] = Note->Location / 256;
req[5] = Note->Location % 256;
smprintf(s, "Deleting calendar note\n");
return GSM_WaitFor (s, req, 6, 7, 4, ID_DeleteCalendarNote);
}
GSM_Error GNAPGEN_AddCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
{
GSM_DateTime DT;
int Text, Time, Alarm, Phone, EndTime, Location, current=7;
unsigned char req[5000] = {
0x00, 0x03,0x00,0x00,
0x00, 0x00, 0x00, 0x00, /* location ? */
0x00}; /* type */
switch(Note->Type) {
case GSM_CAL_MEETING : req[6] = 0x01; break;
case GSM_CAL_REMINDER : req[6] = 0x04; break;
case GSM_CAL_MEMO :
default : req[6] = 0x08; break;
}
GSM_CalendarFindDefaultTextTimeAlarmPhone(Note, &Text, &Time, &Alarm, &Phone, &EndTime, &Location);
if (Time == -1) return ERR_UNKNOWN;
memcpy(&DT,&Note->Entries[Time].Date,sizeof(GSM_DateTime));
req[current++] = DT.Year / 256;
req[current++] = DT.Year % 256;
req[current++] = DT.Month;
req[current++] = DT.Day;
req[current++] = DT.Hour;
req[current++] = DT.Minute;
req[current++] = DT.Second;
if (EndTime == -1) {
memset(&DT,0,sizeof(GSM_DateTime));
DT.Month = 1;
DT.Day = 1;
} else {
memcpy(&DT,&Note->Entries[EndTime].Date,sizeof(GSM_DateTime));
}
req[current++] = DT.Year / 256;
req[current++] = DT.Year % 256;
req[current++] = DT.Month;
req[current++] = DT.Day;
req[current++] = DT.Hour;
req[current++] = DT.Minute;
req[current++] = DT.Second;
if (Alarm == -1) {
memset(&DT,0,sizeof(GSM_DateTime));
DT.Month = 1;
DT.Day = 1;
} else {
memcpy(&DT,&Note->Entries[Alarm].Date,sizeof(GSM_DateTime));
}
req[current++] = DT.Year / 256;
req[current++] = DT.Year % 256;
req[current++] = DT.Month;
req[current++] = DT.Day;
req[current++] = DT.Hour;
req[current++] = DT.Minute;
req[current++] = DT.Second;
if (Text == -1) return ERR_UNKNOWN;
req[current++] = UnicodeLength(Note->Entries[Text].Text) / 256;
req[current++] = UnicodeLength(Note->Entries[Text].Text) % 256;
memcpy(req+current,Note->Entries[Text].Text,UnicodeLength(Note->Entries[Text].Text)*2);
current+=UnicodeLength(Note->Entries[Text].Text)*2;
req[current++] = 0;
req[current++] = 0;
if (Location==-1) {
req[current++] = 0;
req[current++] = 0;
} else {
req[current++] = UnicodeLength(Note->Entries[Location].Text) / 256;
req[current++] = UnicodeLength(Note->Entries[Location].Text) % 256;
memcpy(req+current,Note->Entries[Location].Text,UnicodeLength(Note->Entries[Location].Text));
current+=UnicodeLength(Note->Entries[Location].Text);
}
if (Note->Type == GSM_CAL_MEETING) {
GSM_GetCalendarRecurranceRepeat(req+current, NULL, Note);
current+=2;
} else {
req[current++] = 0xff;
req[current++] = 0xff;
}
smprintf(s, "Writing calendar note\n");
return GSM_WaitFor (s, req, current, 7, 4, ID_SetCalendarNote);
}
static GSM_Error GNAPGEN_ReplyGetNextCalendar(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
int pos;
GSM_CalendarEntry *Entry = s->Phone.Data.Cal;
switch (msg.Buffer[3]) {
case 0x00:
smprintf(s, "Calendar note received\n");
switch (msg.Buffer[8]) {
case 0x01: Entry->Type = GSM_CAL_MEETING; break;
case 0x04: Entry->Type = GSM_CAL_REMINDER; break;
case 0x08: Entry->Type = GSM_CAL_MEMO; break;
default :
smprintf(s, "Unknown note type %i\n",msg.Buffer[8]);
return ERR_UNKNOWNRESPONSE;
}
pos = 9;
Entry->EntriesNum = 0;
NOKIA_DecodeDateTime(s, msg.Buffer+pos, &Entry->Entries[Entry->EntriesNum].Date);
smprintf(s, "Time : %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_START_DATETIME;
Entry->EntriesNum++;
pos+=7;
NOKIA_DecodeDateTime(s, msg.Buffer+pos, &Entry->Entries[Entry->EntriesNum].Date);
smprintf(s, "Time : %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_END_DATETIME;
Entry->EntriesNum++;
pos+=7;
NOKIA_DecodeDateTime(s, msg.Buffer+pos, &Entry->Entries[Entry->EntriesNum].Date);
if (Entry->Entries[Entry->EntriesNum].Date.Year!=0) {
smprintf(s, "Alarm : %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_TONE_ALARM_DATETIME;
Entry->EntriesNum++;
} else {
smprintf(s, "No alarm\n");
}
pos+=7;
memcpy(Entry->Entries[Entry->EntriesNum].Text,msg.Buffer+pos+2,msg.Buffer[pos+1]*2);
Entry->Entries[Entry->EntriesNum].Text[msg.Buffer[pos+1]*2 ]=0;
Entry->Entries[Entry->EntriesNum].Text[msg.Buffer[pos+1]*2+1]=0;
smprintf(s, "Text \"%s\"\n",DecodeUnicodeString(Entry->Entries[Entry->EntriesNum].Text));
if (msg.Buffer[pos+1] != 0x00) {
Entry->Entries[Entry->EntriesNum].EntryType = CAL_TEXT;
Entry->EntriesNum++;
}
pos+=msg.Buffer[pos+1]*2+4;
memcpy(Entry->Entries[Entry->EntriesNum].Text,msg.Buffer+pos+2,msg.Buffer[pos+1]*2);
Entry->Entries[Entry->EntriesNum].Text[msg.Buffer[pos+1]*2 ]=0;
Entry->Entries[Entry->EntriesNum].Text[msg.Buffer[pos+1]*2+1]=0;
smprintf(s, "Text \"%s\"\n",DecodeUnicodeString(Entry->Entries[Entry->EntriesNum].Text));
if (msg.Buffer[pos+1] != 0x00) {
Entry->Entries[Entry->EntriesNum].EntryType = CAL_LOCATION;
Entry->EntriesNum++;
}
pos+=msg.Buffer[pos+1]*2+2;
if (Entry->Type == GSM_CAL_MEETING) {
GSM_GetCalendarRecurranceRepeat(msg.Buffer+pos, NULL, Entry);
}
return ERR_NONE;
case 0x10:
smprintf(s, "Can't get calendar note - too high location?\n");
return ERR_INVALIDLOCATION;
}
return ERR_UNKNOWNRESPONSE;
}
static GSM_Error GNAPGEN_GetNextCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start)
{
GSM_Error error;
GSM_Phone_GNAPGENData *Priv = &s->Phone.Data.Priv.GNAPGEN;
unsigned char req[] = {0x00, 0x01,
0x00, 0x00, 0x00, 0x00}; /* Location */
if (start) {
Priv->LastCalendarPos = 1;
} else {
Priv->LastCalendarPos++;
}
Note->Location = Priv->LastCalendarPos;
req[4] = Priv->LastCalendarPos / 256;
req[5] = Priv->LastCalendarPos % 256;
s->Phone.Data.Cal=Note;
smprintf(s, "Getting calendar note\n");
error = GSM_WaitFor (s, req, 6, 7, 4, ID_GetCalendarNote);
if (error == ERR_INVALIDLOCATION) error = ERR_EMPTY;
return error;
}
static GSM_Error GNAPGEN_ReplyGetSMSStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_Data *Data = &s->Phone.Data;
smprintf(s, "Used in phone memory : %i\n",msg.Buffer[6]*256+msg.Buffer[7]);
smprintf(s, "Unread in phone memory : %i\n",msg.Buffer[10]*256+msg.Buffer[11]);
Data->SMSStatus->PhoneSize = 0xff*256+0xff;
Data->SMSStatus->PhoneUsed = msg.Buffer[6]*256+msg.Buffer[7];
Data->SMSStatus->PhoneUnRead = msg.Buffer[10]*256+msg.Buffer[11];
Data->SMSStatus->TemplatesUsed = 0;
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetSMSStatus(GSM_StateMachine *s, GSM_SMSMemoryStatus *status)
{
unsigned char req[] = {0x00, 0x09};
s->Phone.Data.SMSStatus=status;
smprintf(s, "Getting SMS status\n");
return GSM_WaitFor (s, req, 2, 0x6, 2, ID_GetSMSStatus);
}
static GSM_Error GNAPGEN_ReplyGetSMSFolders(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
int j, pos;
GSM_Phone_Data *Data = &s->Phone.Data;
GSM_Phone_GNAPGENData *Priv = &s->Phone.Data.Priv.GNAPGEN;
smprintf(s, "SMS folders names received\n");
Data->SMSFolders->Number = msg.Buffer[5];
pos = 6;
for (j=0;j<msg.Buffer[5];j++) {
if (msg.Buffer[pos+3]>GSM_MAX_SMS_FOLDER_NAME_LEN) {
smprintf(s, "Too long text\n");
return ERR_UNKNOWNRESPONSE;
}
Priv->SMSFolderID[j] = msg.Buffer[pos+1];
memcpy(Data->SMSFolders->Folder[j].Name,msg.Buffer + pos+4,msg.Buffer[pos+3]*2);
Data->SMSFolders->Folder[j].Name[msg.Buffer[pos+3]*2]=0;
Data->SMSFolders->Folder[j].Name[msg.Buffer[pos+3]*2+1]=0;
smprintf(s, "id: %d, folder name: \"%s\"\n",msg.Buffer[pos+1], DecodeUnicodeString(Data->SMSFolders->Folder[j].Name));
if( msg.Buffer[pos+1] == 12 )
Data->SMSFolders->Folder[j].InboxFolder = true;
else
Data->SMSFolders->Folder[j].InboxFolder = false;
Data->SMSFolders->Folder[j].Memory = MEM_ME;
pos+=msg.Buffer[pos+3]*2+4;
}
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetSMSFolders(GSM_StateMachine *s, GSM_SMSFolders *folders)
{
unsigned char req[] = {0x00,0x01};
s->Phone.Data.SMSFolders=folders;
smprintf(s, "Getting SMS folders\n");
return GSM_WaitFor (s, req, 2, 0x06, 4, ID_GetSMSFolders);
}
static GSM_Error GNAPGEN_ReplyGetSMSC(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
int pos=7;
GSM_Phone_Data *Data = &s->Phone.Data;
unsigned char buffer[100];
memcpy( Data->SMSC->Number, msg.Buffer + 6, msg.Buffer[5]*2 );
Data->SMSC->Number[msg.Buffer[5]*2] = 0;
Data->SMSC->Number[msg.Buffer[5]*2+1] = 0;
Data->SMSC->Name[0] = 0;
Data->SMSC->Name[1] = 0;
Data->SMSC->Format = SMS_FORMAT_Text;
Data->SMSC->Validity.Format = SMS_Validity_RelativeFormat;
Data->SMSC->Validity.Relative = SMS_VALID_Max_Time;
Data->SMSC->DefaultNumber[0] = 0;
Data->SMSC->DefaultNumber[1] = 0;
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
{
unsigned char req[] = {0x00,21,
0x00,0x01}; /* location */
if (smsc->Location==0x00) return ERR_INVALIDLOCATION;
req[3]=smsc->Location-1;
s->Phone.Data.SMSC=smsc;
smprintf(s, "Getting SMSC\n");
return GSM_WaitFor (s, req, 4, 0x06, 4, ID_GetSMSC);
}
static GSM_Error GNAPGEN_ReplyGetAlarm(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Phone_Data *Data = &s->Phone.Data;
smprintf(s, "Alarm received\n");
if (msg.Buffer[4] == 0x00) return ERR_EMPTY;
Data->Alarm->Repeating = false;
Data->Alarm->Text[0] = 0;
Data->Alarm->Text[1] = 0;
NOKIA_DecodeDateTime(s, msg.Buffer+5, &Data->Alarm->DateTime);
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm)
{
unsigned char req[] = {0x00, 0x05};
if (alarm->Location != 1) return ERR_NOTSUPPORTED;
s->Phone.Data.Alarm=alarm;
smprintf(s, "Getting alarm\n");
return GSM_WaitFor (s, req, 2, 0x8, 4, ID_GetAlarm);
}
static GSM_Error GNAPGEN_ReplyGetDateTime(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
smprintf(s, "Date & time received\n");
NOKIA_DecodeDateTime(s, msg.Buffer+4, s->Phone.Data.DateTime);
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
{
unsigned char req[2] = {0x00,0x01};
s->Phone.Data.DateTime=date_time;
smprintf(s, "Getting date & time\n");
return GSM_WaitFor (s, req, 2, 0x08, 4, ID_GetDateTime);
}
GSM_Error GNAPGEN_ReplyGetHW(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
unsigned char buff[200];
int pos=8,len,i;
for (i=0;i<5;i++) {
len=msg.Buffer[pos]*256+msg.Buffer[pos+1];
memset(buff,0,sizeof(buff));
memcpy(buff,msg.Buffer+pos+2,len*2);
pos+=2+len*2;
}
strcpy(s->Phone.Data.HardwareCache,DecodeUnicodeString(buff));
smprintf(s, "Received HW %s\n",s->Phone.Data.HardwareCache);
return ERR_NONE;
}
GSM_Error GNAPGEN_GetHW(GSM_StateMachine *s, char *value)
{
GSM_Error error;
unsigned char req[2] = {0x00,0x01};
if (strlen(s->Phone.Data.HardwareCache)!=0) {
strcpy(value,s->Phone.Data.HardwareCache);
return ERR_NONE;
}
smprintf(s, "Getting HW\n");
error = GSM_WaitFor (s, req, 2, 0x01, 2, ID_GetHardware);
if (error == ERR_NONE) strcpy(value,s->Phone.Data.HardwareCache);
return error;
}
GSM_Error GNAPGEN_ReplyGetManufacturer(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
unsigned char buff[200];
int pos=8,len;
GSM_Phone_GNAPGENData *Priv = &s->Phone.Data.Priv.GNAPGEN;
smprintf(s, "gnapplet %i. %i\n",msg.Buffer[4]*256+msg.Buffer[5],msg.Buffer[6]*256+msg.Buffer[7]);
Priv->GNAPPLETVer = msg.Buffer[4]*256+msg.Buffer[5] + 0.01*(msg.Buffer[6]*256+msg.Buffer[7]);
len=msg.Buffer[pos]*256+msg.Buffer[pos+1];
memset(buff,0,sizeof(buff));
memcpy(buff,msg.Buffer+pos+2,len*2);
strcpy(s->Phone.Data.Manufacturer,DecodeUnicodeString(buff));
return ERR_NONE;
}
GSM_Error GNAPGEN_GetManufacturer(GSM_StateMachine *s)
{
unsigned char req[2] = {0x00,0x01};
smprintf(s, "Getting manufacturer\n");
return GSM_WaitFor (s, req, 2, 0x01, 2, ID_GetManufacturer);
}
GSM_Error GNAPGEN_ReplyGetIMEI(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
unsigned char buff[200];
int pos=8,len,i;
for (i=0;i<3;i++) {
len=msg.Buffer[pos]*256+msg.Buffer[pos+1];
memset(buff,0,sizeof(buff));
memcpy(buff,msg.Buffer+pos+2,len*2);
pos+=2+len*2;
}
strcpy(s->Phone.Data.IMEI,DecodeUnicodeString(buff));
smprintf(s, "Received IMEI %s\n",s->Phone.Data.IMEI);
return ERR_NONE;
}
GSM_Error GNAPGEN_GetIMEI(GSM_StateMachine *s)
{
unsigned char req[2] = {0x00,0x01};
smprintf(s, "Getting IMEI\n");
return GSM_WaitFor (s, req, 2, 0x01, 2, ID_GetIMEI);
}
GSM_Error GNAPGEN_ReplyGetID(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
return ERR_NONE;
}
GSM_Error GNAPGEN_ReplyGetModelFirmware(GSM_Protocol_Message msg, GSM_StateMachine *s)
{
GSM_Lines lines;
GSM_Phone_Data *Data = &s->Phone.Data;
if (Data->RequestID!=ID_GetManufacturer && Data->RequestID!=ID_GetModel) return ERR_NONE;
SplitLines(DecodeUnicodeString(msg.Buffer+6), msg.Length-6, &lines, "\x0A", 1, false);
strcpy(Data->Model,GetLineString(DecodeUnicodeString(msg.Buffer+6), lines, 4));
smprintf(s, "Received model %s\n",Data->Model);
Data->ModelInfo = GetModelData(NULL,Data->Model,NULL);
strcpy(Data->VerDate,GetLineString(DecodeUnicodeString(msg.Buffer+6), lines, 3));
smprintf(s, "Received firmware date %s\n",Data->VerDate);
strcpy(Data->Version,GetLineString(DecodeUnicodeString(msg.Buffer+6), lines, 2));
smprintf(s, "Received firmware version %s\n",Data->Version);
GSM_CreateFirmwareNumber(s);
return ERR_NONE;
}
GSM_Error GNAPGEN_GetModel (GSM_StateMachine *s)
{
unsigned char req[2] = {0x00,0x01};
GSM_Error error;
if (strlen(s->Phone.Data.Model)>0) return ERR_NONE;
smprintf(s, "Getting model\n");
return GSM_WaitFor (s, req, 2, 0x01, 2, 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);
smprintf(s, "[Firmware version - \"%s\"]\n",s->Phone.Data.Version);
smprintf(s, "[Firmware date - \"%s\"]\n",s->Phone.Data.VerDate);
}
}
return error;
}
GSM_Error GNAPGEN_GetFirmware (GSM_StateMachine *s)
{
unsigned char req[2] = {0x00,0x01};
GSM_Error error;
if (strlen(s->Phone.Data.Version)>0) return ERR_NONE;
smprintf(s, "Getting firmware version\n");
return GSM_WaitFor (s, req, 2, 0x01, 2, 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, "[Connected model - \"%s\"]\n",s->Phone.Data.Model);
smprintf(s, "[Firmware version - \"%s\"]\n",s->Phone.Data.Version);
smprintf(s, "[Firmware date - \"%s\"]\n",s->Phone.Data.VerDate);
}
}
return error;
}
static GSM_Error GNAPGEN_Initialise (GSM_StateMachine *s)
{
GSM_Phone_GNAPGENData *Priv = &s->Phone.Data.Priv.GNAPGEN;
GSM_Error error;
error = GNAPGEN_GetManufacturer(s);
if (error != ERR_NONE) return error;
if (Priv->GNAPPLETVer==0.18) return ERR_NONE;
return ERR_GNAPPLETWRONG;
}
GSM_Error GNAPGEN_ReplyDialVoice( GSM_Protocol_Message msg, GSM_StateMachine *s ) {
dbgprintf("Dialed voice number\n");
return ERR_NONE;
}
static GSM_Error GNAPGEN_DialVoice ( GSM_StateMachine *s, char *Number, GSM_CallShowNumber ShowNumber ) {
/// @todo implement ShowNumber
unsigned char req[100] = {0x00,0x09};
memset( req + 2,0x00,sizeof(req) - 2 );
int currentByte = 2;
unsigned char unicodeNumber[200];
EncodeUnicode( unicodeNumber, Number, strlen(Number) );
req[currentByte++] = 0x00;
req[currentByte++] = UnicodeLength( unicodeNumber );
memcpy( req + currentByte, unicodeNumber, UnicodeLength( unicodeNumber ) * 2 );
currentByte += UnicodeLength( unicodeNumber ) * 2;
return GSM_WaitFor (s, req, currentByte, 0x02, 8, ID_DialVoice);
}
GSM_Error GNAPGEN_ReplyGetNextMemory( GSM_Protocol_Message msg, GSM_StateMachine *s ) {
int i,pos=8,type,subtype,len;
GSM_MemoryEntry *entry = s->Phone.Data.Memory;
GSM_Phone_GNAPGENData *Priv = &s->Phone.Data.Priv.GNAPGEN;
// 17 == GN_ERR_INVALIDMEMORYTYPE
if( msg.Buffer[3] == 17 ) {
dbgprintf("unknown memory type\n");
return ERR_UNKNOWN;
}
entry->Location=msg.Buffer[5];
entry->EntriesNum=0;
for (i=0;i<msg.Buffer[7];i++) {
type = msg.Buffer[pos]*256+msg.Buffer[pos+1];
subtype = msg.Buffer[pos+2]*256+msg.Buffer[pos+3];
pos+=4;
switch (type) {
// name
case 0x07:
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
if (len!=0) {
entry->Entries[entry->EntriesNum].EntryType=PBK_Text_Name;
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
}
pos+=2+len*2;
break;
// email
case 0x08:
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
entry->Entries[entry->EntriesNum].EntryType=PBK_Text_Email;
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
pos+=2+len*2;
break;
// 0x0b is a general identifier for a number
case 0x0B:
switch(subtype) {
// fax
case 0x04:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_Fax;
break;
// work
case 0x06:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_Work;
break;
// mobile
case 0x03:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_Mobile;
break;
// home
case 0x02:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_Home;
break;
// general
case 0x0a: default:
entry->Entries[entry->EntriesNum].EntryType=PBK_Number_General;
break;
}
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
pos+=2+len*2;
break;
// date
case 0x13:
entry->Entries[entry->EntriesNum].EntryType=PBK_Date;
NOKIA_DecodeDateTime(s, msg.Buffer+pos, &entry->Entries[entry->EntriesNum].Date);
entry->EntriesNum++;
pos+=2+7;
break;
// note
case 0x0a:
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
entry->Entries[entry->EntriesNum].EntryType=PBK_Text_Note;
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
pos+=2+len*2;
break;
// url
case 0x2c:
len = msg.Buffer[pos]*256+msg.Buffer[pos+1];
entry->Entries[entry->EntriesNum].EntryType=PBK_Text_URL;
memcpy(entry->Entries[entry->EntriesNum].Text,msg.Buffer+pos+2,len*2);
entry->Entries[entry->EntriesNum].Text[len*2]=0;
entry->Entries[entry->EntriesNum].Text[len*2+1]=0;
entry->EntriesNum++;
pos+=2+len*2;
break;
default:
Priv->LastContactArrived = true;
return ERR_UNKNOWN;
}
}
return ERR_NONE;
}
static GSM_Error GNAPGEN_GetNextMemory( GSM_StateMachine *s, GSM_MemoryEntry *entry, bool start ) {
GSM_Phone_GNAPGENData *Priv = &s->Phone.Data.Priv.GNAPGEN;
unsigned char req[] = {0x00, 11,
0x00, 0x00, /* memory type */
0x00, 0x00}; /* start (bool) */
if( start ) {
Priv->LastContactArrived = false;
req[5] = 0x01;
} else
req[5] = 0x00;
if( Priv->LastContactArrived )
return ERR_EMPTY;
if (entry->MemoryType != MEM_ME) {
req[3] = NOKIA_GetMemoryType(s, entry->MemoryType,GNAPGEN_MEMORY_TYPES);
if (req[3]==0xff) return ERR_NOTSUPPORTED;
}
s->Phone.Data.Memory=entry;
return GSM_WaitFor (s, req, 6, 0x02, 6, ID_GetMemory);
}
GSM_Error GNAPGEN_ReplyDeleteMemory ( GSM_Protocol_Message msg, GSM_StateMachine *s ) {
/// @todo implement error handling
dbgprintf("Deleted\n");
return ERR_NONE;
}
static GSM_Error GNAPGEN_DeleteMemory ( GSM_StateMachine *s, GSM_MemoryEntry *entry ) {
unsigned char req[] = {0x00, 0x05,
0x00, 0x00, /* memory type */
0x00, 0x00, 0x00, 0x00 }; /* location */
if (entry->MemoryType != MEM_ME) {
req[3] = NOKIA_GetMemoryType(s, entry->MemoryType,GNAPGEN_MEMORY_TYPES);
if (req[3]==0xff) return ERR_NOTSUPPORTED;
}
if (entry->Location==0x00) return ERR_INVALIDLOCATION;
req[6] = entry->Location / 256;
req[7] = entry->Location % 256;
return GSM_WaitFor (s, req, 8, 0x02, 6, ID_DeleteMemory);
}
static GSM_Error GNAPGEN_AddMemory ( GSM_StateMachine *s, GSM_MemoryEntry *entry ) {
entry->Location = -1;
return GNAPGEN_SetMemory( s, entry );
}
static GSM_Error GNAPGEN_ReplyDeleteSMSMessage ( GSM_Protocol_Message msg, GSM_StateMachine *s ) {
// 17 == GN_ERR_INVALIDMEMORYTYPE
switch( msg.Buffer[3] ) {
case 16:
dbgprintf("invalid location\n");
return ERR_UNKNOWN;
break;
case 17:
dbgprintf("unknown memory type\n");
return ERR_UNKNOWN;
break;
case 0:
dbgprintf("deleted");
}
return ERR_NONE;
}
static GSM_Error GNAPGEN_DeleteSMSMessage(GSM_StateMachine *s, GSM_SMSMessage *sms) {
unsigned char req[] = {0x00, 17,
0x00, 0x00, /* folder */
0x00, 0x00, 0x00, 0x00 }; /* location */
req[3] = sms->Folder;
req[4] = (sms->Location / (256*256*256)) % 256;
req[5] = (sms->Location / (256*256)) % 256;
req[6] = (sms->Location / 256) % 256 ;
req[7] = sms->Location % 256;
return GSM_WaitFor (s, req, 8, 0x06, 6, ID_DeleteSMSMessage );
}
// {
// (*Function),
// unsigned char* msgtype,
// int subtypechar,
// unsigned char subtype,
// GSM_Phone_RequestID requestID
// }
// requirements for function to be called:
// - requestID == current requested id/operation or ID_IncomingFrame
// - when subtypechar-th character matches subtype
// e.g. char[0x01] == 0x02
// - msgtype[0] == StateMachine->Phone.Data.RequestMsg.Type; (msgtype equals type of last received message from phone)
static GSM_Reply_Function GNAPGENReplyFunctions[] = {
//informations
{GNAPGEN_ReplyGetIMEI, "\x01",0x01,0x02,ID_GetIMEI },
{GNAPGEN_ReplyGetHW, "\x01",0x01,0x02,ID_GetHardware },
{GNAPGEN_ReplyGetManufacturer, "\x01",0x01,0x02,ID_GetManufacturer },
{GNAPGEN_ReplyGetID, "\x01",0x01,0x02,ID_GetModel },
{GNAPGEN_ReplyGetID, "\x01",0x01,0x02,ID_GetFirmware },
{GNAPGEN_ReplyGetMemory, "\x02",0x01,0x02,ID_GetMemory },
{GNAPGEN_ReplyGetMemoryStatus, "\x02",0x01,0x08,ID_GetMemoryStatus },
{GNAPGEN_ReplyDeleteMemory, "\x02",0x01,0x06,ID_DeleteMemory },
{GNAPGEN_ReplySetMemory, "\x02",0x01,0x04,ID_SetMemory },
{GNAPGEN_ReplyDialVoice, "\x02",0x01,10 ,ID_DialVoice },
{GNAPGEN_ReplyGetNextMemory, "\x02",0x01,12 ,ID_GetMemory },
{GNAPGEN_ReplyGetNetworkInfo, "\x03",0x01,0x02,ID_GetNetworkInfo },
{GNAPGEN_ReplyGetSignalQuality, "\x03",0x01,0x04,ID_GetSignalQuality },
{GNAPGEN_ReplyGetBatteryCharge, "\x04",0x01,0x02,ID_GetBatteryCharge },
//type 5 is DEBUG
{GNAPGEN_ReplyGetModelFirmware, "\x05",0x01,0x02,ID_IncomingFrame },
//type 6 is SMS
{GNAPGEN_ReplyGetSMSFolders, "\x06",0x01,0x02,ID_GetSMSFolders },
{GNAPGEN_ReplyGetSMSStatus, "\x06",0x01,0x0A,ID_GetSMSStatus },
{GNAPGEN_ReplyGetSMSC, "\x06",0x01,0x16,ID_GetSMSC },
{GNAPGEN_ReplyGetSMSFolderStatus,"\x06",0x01,0x04,ID_GetSMSFolderStatus },
{GNAPGEN_ReplyDeleteSMSMessage, "\x06",0x01,18,ID_DeleteSMSMessage },
{GNAPGEN_ReplyGetSMS, "\x06",0x01,12,ID_GetSMSMessage },
{GNAPGEN_ReplySetSMS, "\x06",0x01,14,ID_SaveSMSMessage },
//calendar
{GNAPGEN_ReplyGetNextCalendar, "\x07",0x01,0x02,ID_GetCalendarNote },
{NONEFUNCTION, "\x07",0x01,0x06,ID_DeleteCalendarNote },
{GNAPGEN_ReplyGetToDo, "\x07",0x01,0x08,ID_GetToDo },
//time
{GNAPGEN_ReplyGetDateTime, "\x08",0x01,0x02,ID_GetDateTime },
{GNAPGEN_ReplyGetAlarm, "\x08",0x01,0x06,ID_GetAlarm },
{NULL, "\x00",0x00,0x00,ID_None }
};
GSM_Phone_Functions GNAPGENPhone = {
"gnap",
GNAPGENReplyFunctions,
GNAPGEN_Initialise,
NONEFUNCTION, /* Terminate */
GSM_DispatchMessage,
NOTSUPPORTED, /* ShowStartInfo */
GNAPGEN_GetManufacturer,
GNAPGEN_GetModel,
GNAPGEN_GetFirmware,
GNAPGEN_GetIMEI,
NOTSUPPORTED, /* GetOriginalIMEI */
NOTSUPPORTED, /* GetManufactureMonth */
NOTSUPPORTED, /* GetProductCode */
GNAPGEN_GetHW,
NOTSUPPORTED, /* GetPPM */
NOTSUPPORTED, /* GetSIMIMSI */
GNAPGEN_GetDateTime,
NOTSUPPORTED, /* SetDateTime */
GNAPGEN_GetAlarm,
NOTSUPPORTED, /* SetAlarm */
NOTSUPPORTED, /* GetLocale */
NOTSUPPORTED, /* SetLocale */
NOTSUPPORTED, /* PressKey */
NOTSUPPORTED, /* Reset */
NOTSUPPORTED, /* ResetPhoneSettings */
NOTSUPPORTED, /* EnterSecurityCode */
NOTSUPPORTED, /* GetSecurityStatus */
NOTSUPPORTED, /* GetDisplayStatus */
NOTSUPPORTED, /* SetAutoNetworkLogin */
GNAPGEN_GetBatteryCharge,
GNAPGEN_GetSignalQuality,
GNAPGEN_GetNetworkInfo,
NOTSUPPORTED, /* GetCategory */
NOTSUPPORTED, /* AddCategory */
NOTSUPPORTED, /* GetCategoryStatus */
GNAPGEN_GetMemoryStatus,
GNAPGEN_GetMemory,
GNAPGEN_GetNextMemory,
GNAPGEN_SetMemory,
GNAPGEN_AddMemory,
GNAPGEN_DeleteMemory,
NOTIMPLEMENTED, /* DeleteAllMemory */
NOTSUPPORTED, /* GetSpeedDial */
NOTSUPPORTED, /* SetSpeedDial */
GNAPGEN_GetSMSC,
NOTSUPPORTED, /* SetSMSC */
GNAPGEN_GetSMSStatus,
NOTSUPPORTED, /* GetSMS */
GNAPGEN_GetNextSMS,
NOTSUPPORTED, /* SetSMS */
GNAPGEN_AddSMS,
GNAPGEN_DeleteSMSMessage,
GNAPGEN_SendSMSMessage,
NOTSUPPORTED, /* SendSavedSMS */
NOTSUPPORTED, /* SetFastSMSSending */
NOTSUPPORTED, /* SetIncomingSMS */
NOTSUPPORTED, /* SetIncomingCB */
GNAPGEN_GetSMSFolders,
NOTSUPPORTED, /* AddSMSFolder */
NOTSUPPORTED, /* DeleteSMSFolder */
GNAPGEN_DialVoice, /* 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, /* GetSyncMLSettings */
NOTSUPPORTED, /* SetSyncMLSettings */
NOTSUPPORTED, /* GetChatSettings */
NOTSUPPORTED, /* SetChatSettings */
NOTSUPPORTED, /* GetMMSSettings */
NOTSUPPORTED, /* SetMMSSettings */
NOTSUPPORTED, /* GetMMSFolders */
NOTSUPPORTED, /* GetNextMMSFileInfo */
NOTSUPPORTED, /* GetBitmap */
NOTSUPPORTED, /* SetBitmap */
NOTSUPPORTED, /* GetToDoStatus */
NOTSUPPORTED, /* GetToDo */
GNAPGEN_GetNextToDo,
NOTSUPPORTED, /* SetToDo */
NOTSUPPORTED, /* AddToDo */
NOTSUPPORTED, /* DeleteToDo */
NOTSUPPORTED, /* DeleteAllToDo */
NOTSUPPORTED, /* GetCalendarStatus */
NOTSUPPORTED, /* GetCalendar */
GNAPGEN_GetNextCalendar,
NOTSUPPORTED, /* SetCalendar */
GNAPGEN_AddCalendar,
GNAPGEN_DeleteCalendar,
NOTSUPPORTED, /* DeleteAllCalendar */
NOTSUPPORTED, /* GetCalendarSettings */
NOTSUPPORTED, /* SetCalendarSettings */
NOTSUPPORTED, /* GetNoteStatus */
NOTSUPPORTED, /* GetNote */
NOTSUPPORTED, /* GetNextNote */
NOTSUPPORTED, /* SetNote */
NOTSUPPORTED, /* AddNote */
NOTSUPPORTED, /* DeleteNote */
NOTSUPPORTED, /* DeleteAllNotes */
NOTSUPPORTED, /* GetProfile */
NOTSUPPORTED, /* SetProfile */
NOTSUPPORTED, /* GetFMStation */
NOTSUPPORTED, /* SetFMStation */
NOTSUPPORTED, /* ClearFMStations */
NOTSUPPORTED, /* GetNextFileFolder */
NOTSUPPORTED, /* GetFolderListing */
NOTSUPPORTED, /* GetNextRootFolder */
NOTSUPPORTED, /* SetFileAttributes */
NOTSUPPORTED, /* GetFilePart */
NOTSUPPORTED, /* AddFilePart */
NOTSUPPORTED, /* SendFilePart */
NOTSUPPORTED, /* GetFileSystemStatus */
NOTSUPPORTED, /* DeleteFile */
NOTSUPPORTED, /* AddFolder */
NOTSUPPORTED, /* DeleteFolder */
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:
*/