summaryrefslogtreecommitdiffabout
path: root/gammu/emb/common/phone/alcatel/alcatel.c
authorzautrix <zautrix>2004-08-07 17:24:40 (UTC)
committer zautrix <zautrix>2004-08-07 17:24:40 (UTC)
commit88b0d33b8b0b1f6ae320cfc863ca6a47fa8fec22 (patch) (side-by-side diff)
tree6331418973714243beb674abc87692277b83869d /gammu/emb/common/phone/alcatel/alcatel.c
parentef8a09ce74ad3f0a51484d03fdf009bd5b3677bf (diff)
downloadkdepimpi-88b0d33b8b0b1f6ae320cfc863ca6a47fa8fec22.zip
kdepimpi-88b0d33b8b0b1f6ae320cfc863ca6a47fa8fec22.tar.gz
kdepimpi-88b0d33b8b0b1f6ae320cfc863ca6a47fa8fec22.tar.bz2
Initial revision
Diffstat (limited to 'gammu/emb/common/phone/alcatel/alcatel.c') (more/less context) (ignore whitespace changes)
-rw-r--r--gammu/emb/common/phone/alcatel/alcatel.c3991
1 files changed, 3991 insertions, 0 deletions
diff --git a/gammu/emb/common/phone/alcatel/alcatel.c b/gammu/emb/common/phone/alcatel/alcatel.c
new file mode 100644
index 0000000..f004ad4
--- a/dev/null
+++ b/gammu/emb/common/phone/alcatel/alcatel.c
@@ -0,0 +1,3991 @@
+/* (c) 2002-2004 by Michal Cihar */
+
+/*
+ * High level functions for communication with Alcatel One Touch 501 and
+ * compatible mobile phone.
+ *
+ * This code implements functions to communicate with Alcatel phones,
+ * currently seem to work:
+ * - BE5 series (501/701)
+ * - BF5 series (715)
+ * - BH4 series (535/735)
+ * For some functions it uses normal AT mode (not implemented here, look at
+ * ../at/atgen.[ch]) for others it switches into binary mode and initialises
+ * underlaying protocol (see ../../protocol/alcatel/alcabus.[ch]) and
+ * communicates over it. Don't ask me why Alcatel uses such silly thing...
+ *
+ * Notes for future features:
+ * - max phone number length is 61 (BE5)
+ * - max name length is 50 (BE5)
+ */
+
+#include "../../gsmstate.h"
+
+#ifdef GSM_ENABLE_ALCATEL
+#ifdef GSM_ENABLE_ATGEN
+
+#include <string.h>
+#include <time.h>
+
+#include "../../gsmcomon.h"
+#include "../../misc/coding/coding.h"
+#include "../../misc/misc.h"
+#include "../../service/sms/gsmsms.h"
+#include "../pfunc.h"
+#include "alcatel.h"
+
+/* Timeout for GSM_WaitFor calls. */
+#define ALCATEL_TIMEOUT 64
+
+/* Some magic numbers for protocol follow */
+
+/* synchronisation types (for everything except begin transfer): */
+#define ALCATEL_SYNC_TYPE_CALENDAR 0x64
+#define ALCATEL_SYNC_TYPE_TODO 0x68
+#define ALCATEL_SYNC_TYPE_CONTACTS 0x6C
+
+/* synchronisation types (for begin transfer): */
+#define ALCATEL_BEGIN_SYNC_CALENDAR 0x00
+#define ALCATEL_BEGIN_SYNC_TODO 0x02
+#define ALCATEL_BEGIN_SYNC_CONTACTS 0x01
+
+/* category types */
+#define ALCATEL_LIST_TODO_CAT 0x9B
+#define ALCATEL_LIST_CONTACTS_CAT 0x96
+
+
+/* We need lot of ATGEN functions, because Alcatel is an AT device. */
+
+extern GSM_Reply_Function ALCATELReplyFunctions[];
+extern GSM_Reply_Function ATGENReplyFunctions[];
+
+extern GSM_Error ATGEN_Initialise (GSM_StateMachine *s);
+extern GSM_Error ATGEN_Terminate (GSM_StateMachine *s);
+extern GSM_Error ATGEN_GetIMEI (GSM_StateMachine *s);
+extern GSM_Error ATGEN_GetFirmware (GSM_StateMachine *s);
+extern GSM_Error ATGEN_GetModel (GSM_StateMachine *s);
+extern GSM_Error ATGEN_GetDateTime (GSM_StateMachine *s, GSM_DateTime *date_time);
+extern GSM_Error ATGEN_GetMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry);
+extern GSM_Error ATGEN_GetNextMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry, bool start);
+extern GSM_Error ATGEN_SetMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry);
+extern GSM_Error ATGEN_AddMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry);
+extern GSM_Error ATGEN_DeleteMemory (GSM_StateMachine *s, GSM_MemoryEntry *entry);
+extern GSM_Error ATGEN_GetMemoryStatus (GSM_StateMachine *s, GSM_MemoryStatus *Status);
+extern GSM_Error ATGEN_GetSMSC (GSM_StateMachine *s, GSM_SMSC *smsc);
+extern GSM_Error ATGEN_SetSMSC (GSM_StateMachine *s, GSM_SMSC *smsc);
+extern GSM_Error ATGEN_GetSMSFolders (GSM_StateMachine *s, GSM_SMSFolders *folders);
+extern GSM_Error ATGEN_GetSMSStatus (GSM_StateMachine *s, GSM_SMSMemoryStatus *status);
+extern GSM_Error ATGEN_GetSMS (GSM_StateMachine *s, GSM_MultiSMSMessage *sms);
+extern GSM_Error ATGEN_GetNextSMS (GSM_StateMachine *s, GSM_MultiSMSMessage *sms, bool start);
+extern GSM_Error ATGEN_SendSavedSMS (GSM_StateMachine *s, int Folder, int Location);
+extern GSM_Error ATGEN_SendSMS (GSM_StateMachine *s, GSM_SMSMessage *sms);
+extern GSM_Error ATGEN_DeleteSMS (GSM_StateMachine *s, GSM_SMSMessage *sms);
+extern GSM_Error ATGEN_AddSMS (GSM_StateMachine *s, GSM_SMSMessage *sms);
+extern GSM_Error ATGEN_GetBatteryCharge (GSM_StateMachine *s, GSM_BatteryCharge *bat);
+extern GSM_Error ATGEN_GetSignalQuality (GSM_StateMachine *s, GSM_SignalQuality *sig);
+extern GSM_Error ATGEN_DialVoice (GSM_StateMachine *s, char *number, GSM_CallShowNumber ShowNumber);
+extern GSM_Error ATGEN_AnswerCall (GSM_StateMachine *s, int ID, bool all);
+extern GSM_Error ATGEN_CancelCall (GSM_StateMachine *s, int ID, bool all);
+extern GSM_Error ATGEN_SetDateTime (GSM_StateMachine *s, GSM_DateTime *date_time);
+extern GSM_Error ATGEN_EnterSecurityCode (GSM_StateMachine *s, GSM_SecurityCode Code);
+extern GSM_Error ATGEN_GetSecurityStatus (GSM_StateMachine *s, GSM_SecurityCodeType *Status);
+extern GSM_Error ATGEN_ResetPhoneSettings (GSM_StateMachine *s, GSM_ResetSettingsType Type);
+extern GSM_Error ATGEN_SendDTMF (GSM_StateMachine *s, char *sequence);
+extern GSM_Error ATGEN_GetSIMIMSI (GSM_StateMachine *s, char *IMSI);
+extern GSM_Error ATGEN_HandleCMSError (GSM_StateMachine *s);
+extern GSM_Error ATGEN_GetNetworkInfo (GSM_StateMachine *s, GSM_NetworkInfo *netinfo);
+extern GSM_Error ATGEN_Reset (GSM_StateMachine *s, bool hard);
+extern GSM_Error ATGEN_PressKey (GSM_StateMachine *s, GSM_KeyCode Key, bool Press);
+extern GSM_Error ATGEN_GetDisplayStatus (GSM_StateMachine *s, GSM_DisplayFeatures *features);
+extern GSM_Error ATGEN_SetAutoNetworkLogin (GSM_StateMachine *s);
+extern GSM_Error ATGEN_DeleteAllMemory (GSM_StateMachine *s, GSM_MemoryType type);
+
+extern GSM_Error ATGEN_DispatchMessage (GSM_StateMachine *s);
+extern GSM_Error ATGEN_SetIncomingCB (GSM_StateMachine *s, bool enable);
+extern GSM_Error ATGEN_SetIncomingSMS (GSM_StateMachine *s, bool enable);
+
+/**
+ * Alcatel uses some 8-bit characters in contacts, calendar etc.. This table
+ * attempts to decode it, it is probably not complete, here are just chars
+ * that I found...
+ */
+unsigned char GSM_AlcatelAlphabet[] =
+{
+/* in phone unicode description */
+ 0x80, 0x00,0x20, /* empty */
+ 0x81, 0x00,0x20, /* empty */
+ 0x82, 0x00,0x20, /* empty */
+ 0x83, 0x00,0x20, /* empty */
+
+ 0x84, 0x00,0xe7, /* c cedilla */
+ 0x85, 0x20,0x26, /* ... */
+ 0x86, 0x03,0xc0, /* pi */
+ 0x87, 0x01,0x3e, /* l caron */
+ 0x88, 0x00,0xc0, /* A grave */
+ 0x89, 0x00,0xc1, /* A acute */
+ 0x8a, 0x00,0xc2, /* A circumflex */
+ 0x8b, 0x00,0xc3, /* A tilde */
+ 0x8c, 0x00,0xc8, /* E grave */
+ 0x8d, 0x00,0xca, /* E circumflex */
+ 0x8e, 0x00,0xcb, /* E diaresis */
+ 0x8f, 0x00,0xcc, /* I grave */
+ 0x90, 0x00,0xcd, /* I acute */
+ 0x91, 0x00,0xd0, /* ETH */
+ 0x92, 0x00,0xd2, /* O grave */
+ 0x93, 0x00,0xd3, /* O acute */
+ 0x94, 0x00,0xd4, /* O circumflex */
+ 0x95, 0x00,0xd5, /* O tilde */
+ 0x96, 0x00,0xd9, /* U grave */
+ 0x97, 0x00,0xda, /* U acute */
+ 0x98, 0x00,0xe1, /* a acute */
+ 0x99, 0x00,0xe2, /* a circumflex */
+ 0x9a, 0x00,0xe3, /* a tilde */
+ 0x9b, 0x00,0xea, /* e circumflex */
+ 0x9c, 0x00,0xeb, /* e diaresis */
+ 0x9d, 0x00,0xed, /* i acute */
+ 0x9e, 0x00,0xee, /* i circumflex */
+ 0x9f, 0x00,0xef, /* i diaresis */
+ 0xa0, 0x00,0xf3, /* o acute */
+ 0xa1, 0x00,0xf4, /* o circumflex */
+ 0xa2, 0x00,0xf5, /* o tilde */
+ 0xa3, 0x00,0xfa, /* u acute */
+ 0xa4, 0x00,0xa2, /* cent */
+ 0xa5, 0x00,0x5b, /* [ */
+ 0xa6, 0x01,0x59, /* r caron */
+ 0xa7, 0x01,0x0d, /* c caron */
+ 0xa8, 0x01,0x61, /* s caron */
+ 0xa9, 0x01,0x1b, /* e caron */
+ 0xaa, 0x01,0x6f, /* u ring */
+ 0xab, 0x00,0xfd, /* y acute */
+ 0xac, 0x00,0xf0, /* eth */
+ 0xad, 0x01,0x07, /* c acute */
+ 0xae, 0x01,0x19, /* e ogonek */
+ 0xaf, 0x01,0x05, /* a ogonek */
+ 0xb0, 0x01,0x7c, /* z dot */
+ 0xb1, 0x01,0x7a, /* z acute */
+ 0xb2, 0x01,0x5b, /* s acute */
+ 0xb3, 0x01,0x44, /* n acute */
+ 0xb4, 0x01,0x42, /* l stroke */
+
+ 0xb5, 0x00,0x20, /* empty */
+
+ 0xb6, 0x01,0x48, /* n caron */
+ 0xb7, 0x01,0x65, /* t caron */
+
+ 0xb8, 0x00,0x20, /* empty */
+
+ 0xb9, 0x01,0x7e, /* z caron */
+ 0xba, 0x01,0xe7, /* g caron */
+
+ 0xbb, 0x00,0x20, /* empty */
+ 0xbc, 0x00,0x20, /* empty */
+
+ 0xbd, 0x1e,0x20, /* G macron */
+ 0xbe, 0x1e,0x21, /* g macron */
+ 0xbf, 0x01,0x5e, /* S cedilla */
+ 0xc0, 0x01,0x5f, /* s cedilla */
+ 0xc1, 0x01,0x2f, /* i ogonek */ /* FIXME: not sure with this, it look like normal i */
+ 0xc2, 0x01,0x31, /* i dotless */
+ 0xc3, 0x01,0x68, /* U tilde */
+ 0xc4, 0x01,0x50, /* O dbl acute */
+ 0xc5, 0x01,0x69, /* u tilde */
+ 0xc6, 0x01,0x51, /* o dbl acute */
+ 0xc7, 0x27,0xa9, /* => */
+ 0xc8, 0x27,0xa8, /* filled => */
+ 0xc9, 0x00,0xd7, /* x */
+ 0xca, 0x00,0x5d, /* ] */
+ 0xcb, 0x26,0x0f, /* phone */
+ 0xcc, 0x01,0x0f, /* d caron */
+
+ 0xcd, 0x00,0x20, /* empty */
+
+ 0xce, 0x00,0x7e, /* ~ */
+ 0xcf, 0x00,0x5c, /* \ */
+ 0xd0, 0x00,0x5e, /* ^ */
+
+ 0xd1, 0x00,0x20, /* empty */
+
+ 0xd2, 0x00,0x7b, /* { */
+ 0xd3, 0x00,0x7c, /* | */
+ 0xd4, 0x00,0x7d, /* } */
+
+ 0xd5, 0x00,0x20, /* empty */
+
+ 0xd6, 0x01,0x63, /* t cedilla */
+
+ 0xd7, 0x00,0x20, /* empty */
+ 0xd8, 0x00,0x20, /* empty */
+ 0xd9, 0x00,0x20, /* empty */
+ 0xda, 0x00,0x20, /* empty */
+ 0xdb, 0x00,0x20, /* empty */
+ 0xdc, 0x00,0x20, /* empty */
+ 0xdd, 0x00,0x20, /* empty */
+ 0xde, 0x00,0x20, /* empty */
+ 0xdf, 0x00,0x20, /* empty */
+ 0xe0, 0x00,0x20, /* empty */
+
+ 0xe1, 0x00,0x20, /* two candles */ /* FIXME */
+
+ 0xe2, 0x00,0x20, /* empty */
+ 0xe3, 0x00,0x20, /* empty */
+ 0xe4, 0x00,0x20, /* empty */
+
+ 0xe5, 0x01,0xce, /* a caron */
+ 0xe6, 0x01,0x01, /* a macron */
+ 0xe7, 0x01,0x13, /* e macron */
+ 0xe8, 0x01,0x2b, /* i macron */
+ 0xe9, 0x01,0x4d, /* o macron */
+ 0xea, 0x01,0x6b, /* u macron */
+ 0xeb, 0x00,0x41, /* A */
+ 0xec, 0x00,0x40, /* @ */
+ 0xed, 0x00,0x20, /* some strange char :-) */ /* FIXME */
+
+ 0xee, 0x00,0x20, /* big key stroken */ /* FIXME */
+ 0xef, 0x00,0x20, /* big key */ /* FIXME */
+
+ 0xf0, 0x00,0x20, /* empty */
+
+ 0xf1, 0x00,0x31, /* 1 */
+ 0xf2, 0x00,0x21, /* bold ! */
+ 0xf3, 0x26,0x0e, /* black phone */
+ 0xf4, 0x00,0x26, /* & */
+ 0xf5, 0x23,0x7e, /* bell */
+ 0xf6, 0x26,0x6a, /* note */
+
+ 0xf7, 0x27,0x13, /* okay inv */ /* FIXME */
+ 0xf8, 0x27,0x13, /* okay */
+
+ 0xf9, 0x00,0x20, /* empty */
+
+ 0xfa, 0x00,0x20, /* key */ /* FIXME */
+
+ 0xfb, 0x00,0x20, /* empty */
+
+ 0xfc, 0x20,0xac, /* Euro */
+ 0xfd, 0x21,0x97, /* NE arrow */
+ 0xfe, 0x21,0x98, /* SE arrow */
+
+ 0xff, 0x00,0x20, /* empty */
+
+ 0x00, 0x00,0x00
+};
+
+/* This is being called from atgen */
+GSM_Error ALCATEL_ProtocolVersionReply (GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ char *str, *str2;
+/*
+ * Reply received here looks like:
+ * 1 "AT+CPROT=?"
+ * 2 "+CPROT: 0,"V1.0",1"
+ * 3 "+CPROT: 16,"V1.1",16"
+ * 4 "OK"
+ */
+ switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
+ case AT_Reply_OK:
+ str = strstr(msg.Buffer, "\"V");
+ if (str == NULL) return ERR_UNKNOWNRESPONSE;
+ str += 2;
+ while((str2 = strstr(str, "\"V")) != NULL) str = str2 + 2;
+ if (strncmp(str, "1.0", 3) == 0) {
+ s->Phone.Data.Priv.ALCATEL.ProtocolVersion = V_1_0;
+ } else if (strncmp(str, "1.1", 3) == 0) {
+ s->Phone.Data.Priv.ALCATEL.ProtocolVersion = V_1_1;
+ } else {
+ smprintf(s, "Unknown protocol version. Please send debug log and phone info to author.\n");
+ return ERR_NOTIMPLEMENTED;
+ }
+ return ERR_NONE;
+ case AT_Reply_Error:
+ case AT_Reply_CMSError:
+ return ATGEN_HandleCMSError(s);
+ default:
+ return ERR_UNKNOWNRESPONSE;
+ }
+}
+
+static GSM_Error ALCATEL_SetBinaryMode(GSM_StateMachine *s)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+
+ if (Priv->Mode == ModeBinary) return ERR_NONE;
+
+ dbgprintf ("Changing to binary mode\n");
+
+ error=GSM_WaitFor (s, "AT+IFC=2,2\r", 11, 0x02, 4, ID_SetFlowControl);
+ if (error != ERR_NONE) return error;
+
+ error=GSM_WaitFor (s, "AT+CPROT=?\r", 11, 0x02, 4, ID_AlcatelProtocol);
+ if (error != ERR_NONE) return error;
+
+ if (Priv->ProtocolVersion == V_1_0) {
+ error=GSM_WaitFor (s, "AT+CPROT=16,\"V1.0\",16\r", 22, 0x00, 4, ID_AlcatelConnect);
+ } else {
+ error=GSM_WaitFor (s, "AT+CPROT=16,\"V1.1\",16\r", 22, 0x00, 4, ID_AlcatelConnect);
+ }
+
+ if (error == ERR_TIMEOUT && s->Speed != 19200) {
+ smprintf(s, "HINT: Try changing speed to 19200, it is sometimes needed for Alcatel binary mode.\n");
+ }
+
+ if (error != ERR_NONE) return error;
+
+ dbgprintf ("Changing protocol to Alcabus\n");
+
+ s->Protocol.Functions = &ALCABUSProtocol;
+ error = s->Protocol.Functions->Initialise(s);
+ if (error != ERR_NONE) {
+ s->Protocol.Functions = &ATProtocol;
+ return error;
+ }
+ s->Phone.Functions->ReplyFunctions = ALCATELReplyFunctions;
+ Priv->Mode = ModeBinary;
+ Priv->BinaryItem = 0;
+ Priv->BinaryType = 0;
+ Priv->BinaryState = StateAttached;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GoToBinaryState(GSM_StateMachine *s, GSM_Alcatel_BinaryState state, GSM_Alcatel_BinaryType type, int item) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ unsigned char attach_buffer[] = {0x00, 0x00, 0x7C ,0x20};
+ unsigned char detach_buffer[] = {0x00, 0x01, 0x7C ,0x00};
+ unsigned char start_buffer[] =
+ {0x00, 0x04, 0x7C, 0x80, /* 4 byte database id follows */
+ 0x12, 0x34, 0x56, 0x78};
+ unsigned char end_buffer[] =
+ {0x00, 0x04, 0x7C, 0x82,
+ 0x00, /* type */
+ 0x00, 0x00, 0x00, 0x00}; /* TimeStamp */
+ unsigned char close_buffer[] =
+ {0x00, 0x04,
+ 0x00, /*type */
+ 0x23, 0x01};
+ unsigned char select1_buffer[] =
+ {0x00, 0x00,
+ 0x00, /*type */
+ 0x20};
+ unsigned char select2_buffer[] =
+ {0x00, 0x04,
+ 0x00, /*type */
+ 0x22, 0x01, 0x00};
+ unsigned char begin_buffer[] =
+ {0x00, 0x04, 0x7C, 0x81,
+ 0x00, /*type */
+ 0x00, 0x85, 0x00};
+ unsigned char commit_buffer[] =
+ {0x00, 0x04,
+ 0x00, /*type */
+ 0x20, 0x01};
+
+ smprintf(s, "Alcatel state switcher: %d -> %d, %d -> %d, %d -> %d\n", Priv->BinaryState, state, Priv->BinaryType, type, Priv->BinaryItem, item);
+ error = ALCATEL_SetBinaryMode(s);
+ if (error != ERR_NONE) return error;
+
+ /* Do we need to do anything? */
+ if ((state == Priv->BinaryState) && (type == Priv->BinaryType) && (item == Priv->BinaryItem)) return ERR_NONE;
+
+ /* We're editing, but the next state is not the same. so commit editing */
+ if (Priv->BinaryState == StateEdit) {
+ /* Something has changed, we will have to reread fields! */
+ Priv->CurrentFieldsItem = -1;
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ commit_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ break;
+ case TypeContacts:
+ commit_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ break;
+ case TypeToDo:
+ commit_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ break;
+ }
+ dbgprintf ("Commiting edited record\n");
+ error=GSM_WaitFor (s, commit_buffer, 5, 0x02, ALCATEL_TIMEOUT, ID_AlcatelCommit);
+ if (error != ERR_NONE) return error;
+ error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelCommit2);
+ if (error != ERR_NONE) return error;
+ Priv->BinaryState = StateSession;
+ Priv->BinaryItem = 0;
+ }
+
+ /* Do we want to edit something of same type? */
+ if ((state == StateEdit) && (type == Priv->BinaryType)) {
+ /* Edit state doesn't need any switching, it is needed only for
+ * indication that e have to commit record before we switch to other
+ * mode.
+ */
+ Priv->BinaryState = StateEdit;
+ Priv->BinaryItem = item;
+ return ERR_NONE;
+ }
+
+ /* Now we can be only in Attached or Session state, so if states and types matches, just keep them as they are */
+ if ((state == Priv->BinaryState) && (type == Priv->BinaryType)) {
+ return ERR_NONE;
+ }
+
+ /* Do we need to close session? */
+ if (Priv->BinaryState == StateSession) {
+ dbgprintf ("Ending session\n");
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ end_buffer[4] = ALCATEL_BEGIN_SYNC_CALENDAR;
+ break;
+ case TypeContacts:
+ end_buffer[4] = ALCATEL_BEGIN_SYNC_CONTACTS;
+ break;
+ case TypeToDo:
+ end_buffer[4] = ALCATEL_BEGIN_SYNC_TODO;
+ break;
+ }
+ error=GSM_WaitFor (s, end_buffer, 9, 0x02, ALCATEL_TIMEOUT, ID_AlcatelEnd);
+ if (error != ERR_NONE) return error;
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ close_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ break;
+ case TypeContacts:
+ close_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ break;
+ case TypeToDo:
+ close_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ break;
+ }
+ dbgprintf ("Closing session\n");
+ error=GSM_WaitFor (s, close_buffer, 5, 0x02, ALCATEL_TIMEOUT, ID_AlcatelClose);
+ if (error != ERR_NONE) return error;
+
+ dbgprintf ("Detaching binary mode\n");
+ GSM_WaitFor (s, detach_buffer, 4, 0x02, ALCATEL_TIMEOUT, ID_AlcatelDetach);
+
+ Priv->BinaryState = StateAttached;
+ Priv->BinaryType = 0;
+ }
+
+ /* Do we need to open session? */
+ if (state == StateSession || state == StateEdit) {
+ dbgprintf ("Starting session for %s\n",
+ (type == TypeCalendar ? "Calendar" :
+ (type == TypeToDo ? "Todo" :
+ (type == TypeContacts ? "Contacts" :
+ "Unknown!"))));
+ /* Fill up buffers */
+ switch (type) {
+ case TypeCalendar:
+ select1_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ select2_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ begin_buffer[4] = ALCATEL_BEGIN_SYNC_CALENDAR;
+ break;
+ case TypeContacts:
+ select1_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ select2_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ begin_buffer[4] = ALCATEL_BEGIN_SYNC_CONTACTS;
+ break;
+ case TypeToDo:
+ select1_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ select2_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ begin_buffer[4] = ALCATEL_BEGIN_SYNC_TODO;
+ break;
+ }
+ dbgprintf ("Attaching in binary mode\n");
+
+ /* Communicate */
+ error=GSM_WaitFor (s, attach_buffer, 4, 0x02, ALCATEL_TIMEOUT, ID_AlcatelAttach);
+ if (error != ERR_NONE) return error;
+
+ smprintf(s,"Start session\n");
+ error=GSM_WaitFor (s, start_buffer, 8, 0x02, ALCATEL_TIMEOUT, ID_AlcatelStart);
+ if (error != ERR_NONE) return error;
+
+ smprintf(s,"Select type\n");
+ error=GSM_WaitFor (s, select1_buffer, 4, 0x02, ALCATEL_TIMEOUT, ID_AlcatelSelect1);
+ if (error != ERR_NONE) return error;
+ error=GSM_WaitFor (s, select2_buffer, 6, 0x02, ALCATEL_TIMEOUT, ID_AlcatelSelect2);
+ if (error != ERR_NONE) return error;
+ error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelSelect3);
+ if (error != ERR_NONE) return error;
+
+ smprintf(s,"Begin transfer\n");
+ error=GSM_WaitFor (s, begin_buffer, 8, 0x02, ALCATEL_TIMEOUT, ID_AlcatelBegin1);
+ if (error != ERR_NONE) return error;
+ error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelBegin2);
+ if (error != ERR_NONE) return error;
+
+ Priv->BinaryState = StateSession;
+ Priv->BinaryType = type;
+ /* Do we want to edit something of same type? */
+ if ((state == StateEdit) && (type == Priv->BinaryType)) {
+ Priv->BinaryState = StateEdit;
+ Priv->BinaryItem = item;
+ return ERR_NONE;
+ }
+ }
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_SetATMode(GSM_StateMachine *s)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+
+ if (Priv->Mode == ModeAT) return ERR_NONE;
+
+ error = ALCATEL_GoToBinaryState(s, StateAttached, 0, 0);
+ if (error != ERR_NONE) return error;
+
+ error = s->Protocol.Functions->Terminate(s);
+ if (error != ERR_NONE) return error;
+
+ dbgprintf ("Changing protocol to AT\n");
+ s->Protocol.Functions = &ATProtocol;
+ s->Phone.Functions->ReplyFunctions = ATGENReplyFunctions;
+ Priv->Mode = ModeAT;
+
+ my_sleep(100);
+
+ /* In case we don't send AT command short after closing binary mode,
+ * phone takes VERY long to react next time. The error code in
+ * intetionally ignored.
+ */
+ GSM_WaitFor (s, "AT\r", 3, 0x00, 0, ID_IncomingFrame);
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_Initialise(GSM_StateMachine *s)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+
+ Priv->Mode = ModeAT;
+
+ Priv->CalendarItems = NULL;
+ Priv->ContactsItems = NULL;
+ Priv->ToDoItems = NULL;
+ Priv->CalendarItemsCount = 0;
+ Priv->ToDoItemsCount = 0;
+ Priv->ContactsItemsCount = 0;
+ Priv->CurrentFields[0] = 0;
+ Priv->CurrentFieldsCount = 0;
+ Priv->CurrentFieldsItem = 0;
+ Priv->CurrentFieldsType = 0;
+ Priv->ProtocolVersion = V_1_0;
+ Priv->CurrentFieldsItem = -1;
+
+ Priv->CurrentCategoriesCount = 0;
+ Priv->CurrentCategoriesType = 0;
+
+ s->Protocol.Functions = &ATProtocol;
+ s->Phone.Functions->ReplyFunctions = ATGENReplyFunctions;
+
+ if (ATGEN_Initialise(s) != ERR_NONE || GSM_WaitFor (s, "AT\r", 3, 0x00, 2, ID_IncomingFrame) != ERR_NONE) {
+ smprintf(s,"AT initialisation failed, trying to stop binary mode...\n");
+ s->Protocol.Functions = &ALCABUSProtocol;
+ error = s->Protocol.Functions->Terminate(s);
+ s->Protocol.Functions = &ATProtocol;
+
+ error = ATGEN_Initialise(s);
+ if (error != ERR_NONE) return error;
+ }
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_Terminate(GSM_StateMachine *s)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ free(Priv->CalendarItems);
+ free(Priv->ContactsItems);
+ free(Priv->ToDoItems);
+ error = ALCATEL_SetATMode(s);
+ return ATGEN_Terminate(s);
+}
+
+/* finds whether id is set in the phone */
+static GSM_Error ALCATEL_IsIdAvailable(GSM_StateMachine *s, int id) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+
+ if (id > ALCATEL_MAX_LOCATION) return ERR_INVALIDLOCATION;
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ Priv->CurrentList = &(Priv->CalendarItems);
+ Priv->CurrentCount = &(Priv->CalendarItemsCount);
+ break;
+ case TypeContacts:
+ Priv->CurrentList = &(Priv->ContactsItems);
+ Priv->CurrentCount = &(Priv->ContactsItemsCount);
+ break;
+ case TypeToDo:
+ Priv->CurrentList = &(Priv->ToDoItems);
+ Priv->CurrentCount = &(Priv->ToDoItemsCount);
+ break;
+ }
+
+ for (i=0; i<*Priv->CurrentCount; i++) {
+ if ((*Priv->CurrentList)[i] == id) return ERR_NONE;
+ }
+
+ return ERR_EMPTY;
+}
+
+/* finds next id that is available in the phone */
+static GSM_Error ALCATEL_GetNextId(GSM_StateMachine *s, int *id) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i = 0;
+ int next = ALCATEL_MAX_LOCATION;
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ Priv->CurrentList = &(Priv->CalendarItems);
+ Priv->CurrentCount = &(Priv->CalendarItemsCount);
+ break;
+ case TypeContacts:
+ Priv->CurrentList = &(Priv->ContactsItems);
+ Priv->CurrentCount = &(Priv->ContactsItemsCount);
+ break;
+ case TypeToDo:
+ Priv->CurrentList = &(Priv->ToDoItems);
+ Priv->CurrentCount = &(Priv->ToDoItemsCount);
+ break;
+ }
+
+ for (i=0; i<*Priv->CurrentCount; i++) {
+ if (((*Priv->CurrentList)[i] > *id) && ((*Priv->CurrentList)[i] < next )) {
+ next = (*Priv->CurrentList)[i];
+ }
+ }
+ if (next == ALCATEL_MAX_LOCATION) {
+ return ERR_EMPTY;
+ } else {
+ *id = next;
+ return ERR_NONE;
+ }
+}
+
+static GSM_Error ALCATEL_ReplyGetIds(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int count,i,pos;
+
+ count = msg.Buffer[10];
+ *Priv->CurrentCount += count;
+
+ *Priv->CurrentList = (int *)realloc(*Priv->CurrentList, (*Priv->CurrentCount + 1)* sizeof(int));
+ if (*Priv->CurrentList == NULL) return ERR_MOREMEMORY;
+
+ for (i = 0; i < count; i++) {
+ pos = 11 + (4 * i);
+ (*Priv->CurrentList)[*Priv->CurrentCount - count + i] = msg.Buffer[pos + 3] +
+ (msg.Buffer[pos + 2] << 8) +
+ (msg.Buffer[pos + 1] << 16) +
+ (msg.Buffer[pos] << 24);
+ }
+ (*Priv->CurrentList)[*Priv->CurrentCount] = 0;
+
+ /* If last byte is 0, then we transmitted all items */
+ Priv->TransferCompleted = msg.Buffer[4 + msg.Buffer[4]] == 0;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetAvailableIds(GSM_StateMachine *s, bool refresh)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ int i;
+ unsigned char buffer[] =
+ {0x00, 0x04,
+ 0x00, /*type */
+ 0x2F, 0x01};
+
+ if (Priv->BinaryState != StateSession) return ERR_UNKNOWN;
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ Priv->CurrentList = &(Priv->CalendarItems);
+ Priv->CurrentCount = &(Priv->CalendarItemsCount);
+ break;
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ Priv->CurrentList = &(Priv->ContactsItems);
+ Priv->CurrentCount = &(Priv->ContactsItemsCount);
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ Priv->CurrentList = &(Priv->ToDoItems);
+ Priv->CurrentCount = &(Priv->ToDoItemsCount);
+ break;
+ }
+
+ if (*Priv->CurrentList != NULL) {
+ if (!refresh) return ERR_NONE;
+ free(*Priv->CurrentList);
+ *Priv->CurrentList = NULL;
+ }
+ smprintf(s,"Reading items list\n");
+
+ *Priv->CurrentCount = 0;
+ Priv->TransferCompleted = false;
+
+ error=GSM_WaitFor (s, buffer, 5, 0x02, ALCATEL_TIMEOUT, ID_AlcatelGetIds1);
+ if (error != ERR_NONE) return error;
+
+ while (!Priv->TransferCompleted) {
+ error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelGetIds2);
+ if (error != ERR_NONE) return error;
+ }
+
+ i = 0;
+ smprintf(s,"Received %d ids: ", *Priv->CurrentCount);
+ for (i=0; i < *Priv->CurrentCount; i++) {
+ smprintf(s,"%x ", (*Priv->CurrentList)[i]);
+ }
+ smprintf(s,"\n");
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_ReplyGetFields(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+
+ if (msg.Buffer[14] > GSM_PHONEBOOK_ENTRIES) {
+ smprintf(s, "WARNING: Field list truncated, you should increase GSM_PHONEBOOK_ENTRIES to at least %d\n", msg.Buffer[14]);
+ Priv->CurrentFieldsCount = GSM_PHONEBOOK_ENTRIES;
+ } else {
+ Priv->CurrentFieldsCount = msg.Buffer[14];
+ }
+
+ Priv->CurrentFields[Priv->CurrentFieldsCount] = 0;
+
+ for (i = 0; i < Priv->CurrentFieldsCount; i++) {
+ Priv->CurrentFields[i] = msg.Buffer[15 + i];
+ }
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetFields(GSM_StateMachine *s, int id) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ int i;
+ unsigned char buffer[] =
+ {0x00, 0x04,
+ 0x00, /* type */
+ 0x30, 0x01,
+ 0x00, 0x00, 0x00, 0x00}; /* item */
+
+ if (Priv->BinaryState != StateSession) return ERR_UNKNOWN;
+ if ((Priv->CurrentFieldsItem == id) && (Priv->CurrentFieldsType == Priv->BinaryType)) return ERR_NONE;
+
+ smprintf(s,"Reading item fields (%d)\n", id);
+
+ buffer[5] = (id >> 24);
+ buffer[6] = ((id >> 16) & 0xff);
+ buffer[7] = ((id >> 8) & 0xff);
+ buffer[8] = (id & 0xff);
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ break;
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ break;
+ }
+
+ Priv->CurrentFieldsItem = id;
+ Priv->CurrentFieldsType = Priv->BinaryType;
+
+ error=GSM_WaitFor (s, buffer, 9, 0x02, ALCATEL_TIMEOUT, ID_AlcatelGetFields1);
+ if (error != ERR_NONE) return error;
+ error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelGetFields2);
+ if (error != ERR_NONE) return error;
+
+ i = 0;
+ smprintf(s,"Received %d fields: ", Priv->CurrentFieldsCount);
+ for (i=0; i < Priv->CurrentFieldsCount; i++) {
+ smprintf(s,"%x ", Priv->CurrentFields[i]);
+ }
+ smprintf(s,"\n");
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_ReplyGetFieldValue(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ unsigned char *buffer = &(msg.Buffer[16]);
+
+ if (buffer[1] == 0x05 && buffer[2] == 0x67) {
+ /* date */
+ Priv->ReturnType = Alcatel_date;
+ Priv->ReturnDateTime.Day = buffer[4];
+ Priv->ReturnDateTime.Month = buffer[5];
+ Priv->ReturnDateTime.Year = buffer[7] + (buffer[6] << 8);
+ Priv->ReturnDateTime.Timezone = 0; /* FIXME: how to acquire this? */
+
+ Priv->ReturnDateTime.Hour = 0;
+ Priv->ReturnDateTime.Minute = 0;
+ Priv->ReturnDateTime.Second = 0;
+ } else if (buffer[1] == 0x06 && buffer[2] == 0x68) {
+ /* time */
+ Priv->ReturnType = Alcatel_time;
+ Priv->ReturnDateTime.Hour = buffer[4];
+ Priv->ReturnDateTime.Minute = buffer[5];
+ Priv->ReturnDateTime.Second = buffer[6];
+
+ Priv->ReturnDateTime.Day = 0;
+ Priv->ReturnDateTime.Month = 0;
+ Priv->ReturnDateTime.Year = 0;
+ Priv->ReturnDateTime.Timezone = 0;
+ } else if (buffer[1] == 0x08 && buffer[2] == 0x3C) {
+ /* string */
+ Priv->ReturnType = Alcatel_string;
+ if (GSM_PHONEBOOK_TEXT_LENGTH < buffer[3])
+ smprintf(s, "WARNING: Text truncated, you should increase GSM_PHONEBOOK_TEXT_LENGTH to at least %d\n", buffer[3] + 1);
+ if (Priv->ProtocolVersion == V_1_0) {
+ DecodeDefault( Priv->ReturnString, buffer + 4, MIN(GSM_PHONEBOOK_TEXT_LENGTH, buffer[3]), false, GSM_AlcatelAlphabet);
+ } else if(Priv->ProtocolVersion == V_1_1 && (buffer[4] & 0x80)) {
+ memcpy(Priv->ReturnString, buffer + 5, buffer[3]);
+ Priv->ReturnString[buffer[3] + 1] = 0;
+ Priv->ReturnString[buffer[3] + 2] = 0;
+ ReverseUnicodeString(Priv->ReturnString);
+ } else {
+ DecodeDefault( Priv->ReturnString, buffer + 4, MIN(GSM_PHONEBOOK_TEXT_LENGTH, buffer[3]), false, GSM_AlcatelAlphabet);
+ }
+ } else if (buffer[1] == 0x07 && buffer[2] == 0x3C) {
+ /* phone */
+ Priv->ReturnType = Alcatel_phone;
+ if (GSM_PHONEBOOK_TEXT_LENGTH < buffer[3])
+ smprintf(s, "WARNING: Text truncated, you should increase GSM_PHONEBOOK_TEXT_LENGTH to at least %d\n", buffer[3] + 1);
+ if (Priv->ProtocolVersion == V_1_0) {
+ DecodeDefault( Priv->ReturnString, buffer + 4, MIN(GSM_PHONEBOOK_TEXT_LENGTH, buffer[3]), false, GSM_AlcatelAlphabet);
+ } else if(Priv->ProtocolVersion == V_1_1 && (buffer[4] & 0x80)) {
+ memcpy(Priv->ReturnString, buffer + 5, buffer[3]);
+ Priv->ReturnString[buffer[3] + 1] = 0;
+ Priv->ReturnString[buffer[3] + 2] = 0;
+ ReverseUnicodeString(Priv->ReturnString);
+ } else {
+ DecodeDefault( Priv->ReturnString, buffer + 4, MIN(GSM_PHONEBOOK_TEXT_LENGTH, buffer[3]), false, GSM_AlcatelAlphabet);
+ }
+ } else if (buffer[1] == 0x03 && buffer[2] == 0x3B) {
+ /* boolean */
+ Priv->ReturnType = Alcatel_bool;
+ Priv->ReturnInt = buffer[3];
+ } else if (buffer[1] == 0x02 && buffer[2] == 0x3A) {
+ /* integer */
+ Priv->ReturnType = Alcatel_int;
+ Priv->ReturnInt = buffer[6] + (buffer[5] << 8) + (buffer[4] << 16) + (buffer[3] << 24);
+ } else if (buffer[1] == 0x04 && buffer[2] == 0x38) {
+ /* enumeration */
+ Priv->ReturnType = Alcatel_enum;
+ Priv->ReturnInt = buffer[3];
+ } else if (buffer[1] == 0x00 && buffer[2] == 0x38) {
+ /* byte */
+ Priv->ReturnType = Alcatel_byte;
+ Priv->ReturnInt = buffer[3];
+ } else {
+ smprintf(s, "WARNING: Uknown data type received (%02X,%02X)\n", buffer[1], buffer[2]);
+ return ERR_UNKNOWNRESPONSE;
+ }
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetFieldValue(GSM_StateMachine *s, int id, int field)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ unsigned char buffer[] =
+ {0x00, 0x04,
+ 0x00, /* type */
+ 0x1f, 0x01,
+ 0x00, 0x00, 0x00, 0x00, /* here follows 4byte id */
+ 0x00}; /* field */
+
+ smprintf(s,"Reading item value (%08x.%02x)\n", id, field);
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ break;
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ break;
+ }
+
+ buffer[5] = (id >> 24);
+ buffer[6] = ((id >> 16) & 0xff);
+ buffer[7] = ((id >> 8) & 0xff);
+ buffer[8] = (id & 0xff);
+ buffer[9] = (field & 0xff);
+
+ error=GSM_WaitFor (s, buffer, 10, 0x02, ALCATEL_TIMEOUT, ID_AlcatelGetFieldValue1);
+ if (error != ERR_NONE) return error;
+ error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelGetFieldValue2);
+ if (error != ERR_NONE) return error;
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_ReplyGetCategories(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+
+ /* Did we get any category? */
+ if (msg.Buffer[4] == 6) {
+ Priv->CurrentCategoriesCount = 0;
+ return ERR_NONE;
+ }
+ if (msg.Buffer[12] > ALCATEL_MAX_CATEGORIES) {
+ smprintf(s, "WARNING: Field list truncated, you should increase ALCATEL_MAX_CATEGORIES to at least %d\n", msg.Buffer[12]);
+ Priv->CurrentCategoriesCount = ALCATEL_MAX_CATEGORIES;
+ } else {
+ Priv->CurrentCategoriesCount = msg.Buffer[12];
+ }
+
+ for (i = 0; i < Priv->CurrentCategoriesCount; i++) {
+ Priv->CurrentCategories[i] = msg.Buffer[13 + i];
+ Priv->CurrentCategoriesCache[i][0] = '\000';
+ Priv->CurrentCategoriesCache[i][1] = '\000';
+ }
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetAvailableCategoryIds(GSM_StateMachine *s) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ int i;
+ unsigned char buffer[] =
+ {0x00, 0x04,
+ 0x00 /*type */,
+ 0x0b,
+ 0x00 /* list */};
+
+ if (Priv->BinaryState != StateSession) return ERR_UNKNOWN;
+ if (Priv->CurrentCategoriesType == Priv->BinaryType) return ERR_NONE;
+ switch (Priv->BinaryType) {
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ buffer[4] = ALCATEL_LIST_CONTACTS_CAT;
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ buffer[4] = ALCATEL_LIST_TODO_CAT;
+ break;
+ default:
+ return ERR_NOTSUPPORTED;
+ }
+
+ Priv->CurrentCategoriesType = Priv->BinaryType;
+
+ smprintf(s,"Reading category list\n");
+
+ error=GSM_WaitFor (s, buffer, 5, 0x02, ALCATEL_TIMEOUT, ID_AlcatelGetCategories1);
+ if (error != ERR_NONE) return error;
+
+ error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelGetCategories2);
+ if (error != ERR_NONE) return error;
+
+ i = 0;
+ smprintf(s,"Received %d ids: ", Priv->CurrentCategoriesCount);
+ for (i=0; i < Priv->CurrentCategoriesCount; i++) {
+ smprintf(s,"%i ", Priv->CurrentCategories[i]);
+ }
+ smprintf(s,"\n");
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_IsCategoryIdAvailable(GSM_StateMachine *s, int id) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i = 0;
+
+ if (Priv->CurrentCategoriesType != Priv->BinaryType) return ERR_UNKNOWN;
+
+ for (i = 0; i< Priv->CurrentCategoriesCount; i++) {
+ if (Priv->CurrentCategories[i] == id) return ERR_NONE;
+ }
+ return ERR_EMPTY;
+}
+
+static GSM_Error ALCATEL_ReplyAddCategoryText(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ Priv->ReturnInt = msg.Buffer[12];
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_AddCategoryText(GSM_StateMachine *s, const unsigned char *str) {
+ unsigned char buffer[200] = {0x00, 0x04, 0x00 /*type*/, 0x0d, 0x00 /*list*/, 0x0b };
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ int len;
+
+ smprintf(s,"Creating category\n");
+ len = UnicodeLength(str);
+ EncodeDefault(buffer + 8, str, &len, true, GSM_AlcatelAlphabet);
+ buffer[6] = len + 1;
+ buffer[7] = len;
+
+ switch (Priv->BinaryType) {
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ buffer[4] = ALCATEL_LIST_CONTACTS_CAT;
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ buffer[4] = ALCATEL_LIST_TODO_CAT;
+ break;
+ default:
+ return ERR_NOTSUPPORTED;
+ }
+
+ error=GSM_WaitFor (s, buffer, 8 + len, 0x02, ALCATEL_TIMEOUT, ID_AlcatelAddCategoryText1);
+ if (error != ERR_NONE) return error;
+ error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelAddCategoryText2);
+ if (error != ERR_NONE) return error;
+
+ /* Refresh list */
+ Priv->CurrentCategoriesType = 0;
+ return ALCATEL_GetAvailableCategoryIds(s);
+}
+
+static GSM_Error ALCATEL_ReplyGetCategoryText(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int len;
+
+ len = msg.Buffer[14];
+ if (len > GSM_MAX_CATEGORY_NAME_LENGTH) {
+ smprintf(s, "WARNING: Category name truncated, you should increase GSM_MAX_CATEGORY_NAME_LENGTH to at least %d\n", len);
+ }
+ if (Priv->ProtocolVersion == V_1_0) {
+ DecodeDefault( Priv->ReturnString, msg.Buffer + 15, MIN(GSM_MAX_CATEGORY_NAME_LENGTH, len), false, GSM_AlcatelAlphabet);
+ } else if(Priv->ProtocolVersion == V_1_1 && (msg.Buffer[15] & 0x80)) {
+ memcpy(Priv->ReturnString, msg.Buffer + 16, len);
+ Priv->ReturnString[len + 1] = 0;
+ Priv->ReturnString[len + 2] = 0;
+ ReverseUnicodeString(Priv->ReturnString);
+ } else {
+ DecodeDefault( Priv->ReturnString, msg.Buffer + 15, MIN(GSM_MAX_CATEGORY_NAME_LENGTH, len), false, GSM_AlcatelAlphabet);
+ }
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetCategoryText(GSM_StateMachine *s, int id) {
+ unsigned char buffer[] = {0x00, 0x04, 0x00 /*type*/, 0x0c, 0x00 /*list*/, 0x0A, 0x01, 0x00 /*item*/ };
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+
+ if (Priv->CurrentCategoriesCache[id][0] != '\000' || Priv->CurrentCategoriesCache[id][1] != '\000') {
+ CopyUnicodeString(Priv->ReturnString, Priv->CurrentCategoriesCache[id]);
+ return ERR_NONE;
+ }
+
+ smprintf(s,"Reading category %d\n", id);
+
+ switch (Priv->BinaryType) {
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ buffer[4] = ALCATEL_LIST_CONTACTS_CAT;
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ buffer[4] = ALCATEL_LIST_TODO_CAT;
+ break;
+ default:
+ return ERR_NOTSUPPORTED;
+ }
+
+ buffer[7] = (id & 0xff);
+
+ error=GSM_WaitFor (s, buffer, 8, 0x02, ALCATEL_TIMEOUT, ID_AlcatelGetCategoryText1);
+ if (error != ERR_NONE) return error;
+ error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelGetCategoryText2);
+ if (error != ERR_NONE) return error;
+
+ CopyUnicodeString(Priv->CurrentCategoriesCache[id], Priv->ReturnString);
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_DeleteField(GSM_StateMachine *s, int id, int field) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ unsigned char buffer[] =
+ {0x00, 0x04,
+ 0x00, /* type */
+ 0x26, 0x01,
+ 0x00, 0x00, 0x00, 0x00, /* here follows 4byte id */
+ 0x65, 0x01,
+ 0x00, /* field */
+ 0x01};
+
+ smprintf(s,"Deleting field (%08x.%02x)\n", id, field);
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ break;
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ break;
+ }
+
+ buffer[5] = (id >> 24);
+ buffer[6] = ((id >> 16) & 0xff);
+ buffer[7] = ((id >> 8) & 0xff);
+ buffer[8] = (id & 0xff);
+ buffer[11] = (field & 0xff);
+
+ error=GSM_WaitFor (s, buffer, 13, 0x02, ALCATEL_TIMEOUT, ID_AlcatelDeleteField);
+ if (error != ERR_NONE) return error;
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_DeleteItem(GSM_StateMachine *s, int id) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ unsigned char buffer[] =
+ {0x00, 0x04,
+ 0x00, /* type */
+ 0x27, 0x01,
+ 0x00, 0x00, 0x00, 0x00, /* here follows 4byte id */
+ 0x42};
+
+ smprintf(s,"Deleting item (%08x)\n", id);
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ break;
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ break;
+ }
+
+ buffer[5] = (id >> 24);
+ buffer[6] = ((id >> 16) & 0xff);
+ buffer[7] = ((id >> 8) & 0xff);
+ buffer[8] = (id & 0xff);
+
+ error=GSM_WaitFor (s, buffer, 10, 0x02, ALCATEL_TIMEOUT, ID_AlcatelDeleteItem1);
+ if (error != ERR_NONE) return error;
+
+ error=GSM_WaitFor (s, 0, 0, 0x0, ALCATEL_TIMEOUT, ID_AlcatelDeleteItem2);
+ if (error != ERR_NONE) return error;
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_ReplyDeleteItem(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ if (msg.Buffer[8] != 0x25) return ERR_UNKNOWNRESPONSE;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_BuildWriteBuffer(unsigned char * buffer, GSM_Alcatel_FieldType type, int field, void *data) {
+ int len;
+
+ buffer[1] = field & 0xff;
+
+ switch(type) {
+ case Alcatel_date:
+ if (!CheckDate((GSM_DateTime *)data)) return ERR_INVALIDDATETIME;
+
+ buffer[3] = 0x05;
+ buffer[4] = 0x67;
+
+ buffer[0] = 0x09;
+ buffer[5] = 0x04;
+ buffer[6] = ((GSM_DateTime *)data)->Day & 0xff;
+ buffer[7] = ((GSM_DateTime *)data)->Month & 0xff;
+ buffer[8] = ((GSM_DateTime *)data)->Year >> 8;
+ buffer[9] = ((GSM_DateTime *)data)->Year & 0xff;
+ buffer[10] = 0x00;
+ break;
+ case Alcatel_time:
+ if (!CheckTime((GSM_DateTime *)data)) return ERR_INVALIDDATETIME;
+
+ buffer[3] = 0x06;
+ buffer[4] = 0x68;
+
+ buffer[0] = 0x08;
+ buffer[5] = 0x03;
+ buffer[6] = ((GSM_DateTime *)data)->Hour & 0xff;
+ buffer[7] = ((GSM_DateTime *)data)->Minute & 0xff;
+ buffer[8] = ((GSM_DateTime *)data)->Second & 0xff;
+ buffer[9] = 0x00;
+ break;
+ case Alcatel_string:
+ buffer[3] = 0x08;
+ buffer[4] = 0x3c;
+
+ len = MIN(UnicodeLength((char *)data),62);
+ EncodeDefault(buffer + 6, (char *)data, &len, true, GSM_AlcatelAlphabet);
+ buffer[5] = len;
+ buffer[0] = 5 + len;
+ buffer[6 + len] = 0x00;
+ break;
+ case Alcatel_phone:
+ buffer[3] = 0x07;
+ buffer[4] = 0x3c;
+
+ len = MIN(UnicodeLength((char *)data),50);
+ EncodeDefault(buffer + 6, (char *)data, &len, true, GSM_AlcatelAlphabet);
+ buffer[5] = len;
+ buffer[0] = 5 + len;
+ buffer[6 + len] = 0x00;
+ break;
+ case Alcatel_enum:
+ buffer[3] = 0x04;
+ buffer[4] = 0x38;
+
+ buffer[0] = 0x05;
+ buffer[5] = *(int *)data & 0xff;
+ buffer[6] = 0x00;
+ break;
+ case Alcatel_bool:
+ buffer[3] = 0x03;
+ buffer[4] = 0x3b;
+
+ buffer[0] = 0x05;
+ buffer[5] = *(int *)data & 0xff;
+ buffer[6] = 0x00;
+ break;
+ case Alcatel_int:
+ buffer[3] = 0x02;
+ buffer[4] = 0x3a;
+
+ buffer[0] = 0x08;
+ buffer[5] = *(unsigned int *)data >> 24;
+ buffer[6] = (*(unsigned int *)data >> 16) & 0xff;
+ buffer[7] = (*(unsigned int *)data >> 8) & 0xff;
+ buffer[8] = *(unsigned int *)data & 0xff;
+ buffer[9] = 0x00;
+ break;
+ case Alcatel_byte:
+ buffer[3] = 0x00;
+ buffer[4] = 0x38;
+
+ buffer[0] = 0x05;
+ buffer[5] = *(int *)data & 0xff;
+ buffer[6] = 0x00;
+ break;
+ }
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_CreateField(GSM_StateMachine *s, GSM_Alcatel_FieldType type, int field, void *data) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ unsigned char buffer[200] =
+ {0x00, 0x04,
+ 0x00, /* type */
+ 0x25, 0x01, 0x65,
+ 0x00, /* length of remaining part */
+ 0x00, /* field */
+ 0x37}; /* data follows here */
+
+ smprintf(s,"Creating field (%02x)\n", field);
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ break;
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ break;
+ }
+ error = ALCATEL_BuildWriteBuffer(buffer + 6, type, field, data);
+ if (error != ERR_NONE) return error;
+
+ error = GSM_WaitFor (s, buffer, 8 + buffer[6], 0x02, ALCATEL_TIMEOUT, ID_AlcatelCreateField);
+ if (error != ERR_NONE) return error;
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_UpdateField(GSM_StateMachine *s, GSM_Alcatel_FieldType type, int id, int field, void *data) {
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+ unsigned char buffer[200] =
+ {0x00, 0x04,
+ 0x00, /* type */
+ 0x26, 0x01,
+ 0x00, 0x00, 0x00, 0x00, /* id */
+ 0x65,
+ 0x00, /* length of remaining part */
+ 0x00, /* field */
+ 0x37}; /* data follows here */
+
+ smprintf(s,"Updating field (%08x.%02x)\n", id, field);
+
+ buffer[5] = (id >> 24);
+ buffer[6] = ((id >> 16) & 0xff);
+ buffer[7] = ((id >> 8) & 0xff);
+ buffer[8] = (id & 0xff);
+
+ switch (Priv->BinaryType) {
+ case TypeCalendar:
+ buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
+ break;
+ case TypeContacts:
+ buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
+ break;
+ case TypeToDo:
+ buffer[2] = ALCATEL_SYNC_TYPE_TODO;
+ break;
+ }
+ error = ALCATEL_BuildWriteBuffer(buffer + 10, type, field, data);
+ if (error != ERR_NONE) return error;
+
+ error = GSM_WaitFor (s, buffer, 12 + buffer[10], 0x02, ALCATEL_TIMEOUT, ID_AlcatelUpdateField);
+ if (error != ERR_NONE) return error;
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetManufacturer(GSM_StateMachine *s)
+{
+ strcpy(s->Phone.Data.Manufacturer, "Alcatel");
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetIMEI (GSM_StateMachine *s)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetIMEI(s);
+}
+
+static GSM_Error ALCATEL_GetFirmware(GSM_StateMachine *s)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetFirmware(s);
+}
+
+static GSM_Error ALCATEL_GetModel(GSM_StateMachine *s)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetModel(s);
+}
+
+static GSM_Error ALCATEL_GetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetDateTime(s, date_time);
+}
+
+static GSM_Error ALCATEL_GetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+ int j = 0;
+
+ if (entry->MemoryType == MEM_ME) {
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsIdAvailable(s, entry->Location))!= ERR_NONE) {
+ entry->EntriesNum = 0;
+ return error;
+ }
+ if ((error = ALCATEL_GetFields(s, entry->Location))!= ERR_NONE) return error;
+
+ entry->EntriesNum = Priv->CurrentFieldsCount;
+
+ for (i=0; i<Priv->CurrentFieldsCount; i++) {
+ if ((error = ALCATEL_GetFieldValue(s, entry->Location, Priv->CurrentFields[i]))!= ERR_NONE) return error;
+ entry->Entries[i].VoiceTag = 0;
+ entry->Entries[i].SMSList[0] = 0;
+ switch (Priv->CurrentFields[i]) {
+ case 0:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 0, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_LastName;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 1:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 1, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_FirstName;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 2:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 2, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Company;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 3:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 3, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_JobTitle;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 4:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 4, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Note;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 5:
+ if (Priv->ReturnType != Alcatel_byte) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 5, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Category;
+ entry->Entries[i - j].Number = Priv->ReturnInt;
+ break;
+ case 6:
+ if (Priv->ReturnType != Alcatel_bool) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 6, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Private;
+ entry->Entries[i - j].Number = Priv->ReturnInt;
+ break;
+ case 7:
+ if (Priv->ReturnType != Alcatel_phone) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 7, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Number_Work;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 8:
+ if (Priv->ReturnType != Alcatel_phone) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 8, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Number_General;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 9:
+ if (Priv->ReturnType != Alcatel_phone) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 9, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Number_Fax;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 10:
+ if (Priv->ReturnType != Alcatel_phone) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 10, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Number_Other;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 11:
+ if (Priv->ReturnType != Alcatel_phone) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 11, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Number_Pager;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 12:
+ if (Priv->ReturnType != Alcatel_phone) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 12, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Number_Mobile;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 13:
+ if (Priv->ReturnType != Alcatel_phone) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 13, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Number_Home;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 14:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 14, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Email;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 15:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 15, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Email2;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 16:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 16, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_StreetAddress;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 17:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 17, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_City;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 18:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 18, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_State;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 19:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 19, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Zip;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 20:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 20, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Country;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 21:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 21, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Custom1;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 22:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 22, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Custom2;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 23:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 23, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Custom3;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 24:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 24, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ entry->Entries[i - j].EntryType = PBK_Text_Custom4;
+ CopyUnicodeString(entry->Entries[i - j].Text, Priv->ReturnString);
+ break;
+ case 25:
+ if (Priv->ReturnType != Alcatel_int) {
+ smprintf(s,"WARNING: Received unexpected type %02X for field 25, ignoring\n", Priv->ReturnType);
+ entry->EntriesNum--;
+ j++;
+ break;
+ }
+ if (Priv->ReturnInt != 0) {
+ entry->Entries[i - j].EntryType = PBK_PictureID;
+ entry->Entries[i - j].Number = Priv->ReturnInt;
+ } else {
+ entry->EntriesNum--;
+ j++;
+ }
+ break;
+ default:
+ entry->EntriesNum--;
+ j++;
+ smprintf(s,"WARNING: Received unknown field %02X, ignoring. Type = %02X. Value = ", Priv->CurrentFields[i], Priv->ReturnType);
+ switch (Priv->ReturnType) {
+ case Alcatel_date:
+ smprintf(s, "%d.%d.%d", Priv->ReturnDateTime.Day, Priv->ReturnDateTime.Month, Priv->ReturnDateTime.Year);
+ break;
+ case Alcatel_time:
+ smprintf(s, "%d:%d:%d", Priv->ReturnDateTime.Hour, Priv->ReturnDateTime.Minute, Priv->ReturnDateTime.Second);
+ break;
+ case Alcatel_string:
+ case Alcatel_phone:
+ smprintf(s, "\"%s\"",DecodeUnicodeString(Priv->ReturnString));
+ break;
+ case Alcatel_enum:
+ case Alcatel_bool:
+ case Alcatel_int:
+ case Alcatel_byte:
+ smprintf(s, "%d", Priv->ReturnInt);
+ break;
+ }
+ smprintf(s,"\n");
+ }
+ }
+ return ERR_NONE;
+ } else {
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetMemory(s, entry);
+ }
+}
+
+static GSM_Error ALCATEL_GetNextMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry, bool start)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ if (entry->MemoryType == MEM_ME) {
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if (Priv->ContactsItemsCount == 0) return ERR_EMPTY;
+
+ if (start) entry->Location = 0;
+ if ((error = ALCATEL_GetNextId(s, &(entry->Location))) != ERR_NONE) return error;
+
+ return ALCATEL_GetMemory(s, entry);
+ } else {
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetNextMemory(s, entry, start);
+ }
+}
+
+static GSM_Error ALCATEL_AddMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int NamePosition = -1;
+ bool NameSet = false;
+ int i;
+
+
+ if (entry->MemoryType == MEM_ME) {
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeContacts, 0))!= ERR_NONE) return error;
+ for (i = 0; i < entry->EntriesNum; i++) {
+ switch (entry->Entries[i].EntryType) {
+ case PBK_Number_General:
+ if ((error = ALCATEL_CreateField(s, Alcatel_phone, 8, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Mobile:
+ if ((error = ALCATEL_CreateField(s, Alcatel_phone, 12, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Work:
+ if ((error = ALCATEL_CreateField(s, Alcatel_phone, 7, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Fax:
+ if ((error = ALCATEL_CreateField(s, Alcatel_phone, 9, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Home:
+ if ((error = ALCATEL_CreateField(s, Alcatel_phone, 13, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Pager:
+ if ((error = ALCATEL_CreateField(s, Alcatel_phone, 11, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Other:
+ if ((error = ALCATEL_CreateField(s, Alcatel_phone, 10, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Note:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 4, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Email:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 14, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Email2:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 15, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_LastName:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 0, entry->Entries[i].Text)) != ERR_NONE) return error;
+ NameSet = true;
+ break;
+ case PBK_Text_FirstName:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 1, entry->Entries[i].Text)) != ERR_NONE) return error;
+ NameSet = true;
+ break;
+ case PBK_Text_Company:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 2, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_JobTitle:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 3, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Category:
+ if ((error = ALCATEL_CreateField(s, Alcatel_byte, 5, &(entry->Entries[i].Number))) != ERR_NONE) return error;
+ break;
+ case PBK_Private:
+ if ((error = ALCATEL_CreateField(s, Alcatel_bool, 6, &(entry->Entries[i].Number))) != ERR_NONE) return error;
+ break;
+ case PBK_Text_StreetAddress:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 16, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_City:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 17, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_State:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 18, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Zip:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 19, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Country:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 20, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Custom1:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 21, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Custom2:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 22, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Custom3:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 23, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Custom4:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 24, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_PictureID:
+ if (s->Phone.Data.Priv.ALCATEL.ProtocolVersion == V_1_1) {
+ if ((error = ALCATEL_CreateField(s, Alcatel_int, 25, &(entry->Entries[i].Number))) != ERR_NONE) return error;
+ } else {
+ smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", entry->Entries[i].EntryType);
+ }
+ break;
+
+ case PBK_Text_Name: NamePosition = i; break;
+ /* Following fields are not supported: */
+ case PBK_Text_UserID:
+ case PBK_SMSListID:
+ case PBK_RingtoneFileSystemID:
+ case PBK_Date:
+ case PBK_Caller_Group:
+ case PBK_RingtoneID:
+ case PBK_Text_Postal:
+ case PBK_Text_URL:
+ smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", entry->Entries[i].EntryType);
+ break;
+ }
+ }
+ if (NamePosition != -1) {
+ if (NameSet) {
+ smprintf(s,"WARNING: Ignoring name, not supported by phone\n");
+ } else {
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 1, entry->Entries[i].Text)) != ERR_NONE) return error;
+ }
+ }
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ entry->Location = Priv->CommitedRecord;
+ /* Refresh list */
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+ return ERR_NONE;
+ } else {
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_AddMemory(s, entry);
+ }
+}
+
+static GSM_Error ALCATEL_SetMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int NamePosition = -1;
+ bool NameSet = false;
+ int i;
+ bool UpdatedFields[26];
+
+ if (entry->Location == 0) return ERR_INVALIDLOCATION;
+
+ if (entry->MemoryType == MEM_ME) {
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ /* Save modified entry */
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsIdAvailable(s, entry->Location))!= ERR_NONE) {
+ /* Entry doesn't exist, we will create new one */
+ return ALCATEL_AddMemory(s, entry);
+ }
+ /* Get fields for current item */
+ if ((error = ALCATEL_GetFields(s, entry->Location))!= ERR_NONE) return error;
+
+ for (i = 0; i < 26; i++) { UpdatedFields[i] = false; }
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeContacts, entry->Location))!= ERR_NONE) return error;
+ for (i = 0; i < entry->EntriesNum; i++) {
+ switch (entry->Entries[i].EntryType) {
+ case PBK_Number_General:
+ UpdatedFields[8] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 8, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Mobile:
+ UpdatedFields[12] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 12, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Work:
+ UpdatedFields[7] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 7, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Fax:
+ UpdatedFields[9] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 9, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Home:
+ UpdatedFields[13] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 13, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Pager:
+ UpdatedFields[11] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 11, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Number_Other:
+ UpdatedFields[10] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_phone, entry->Location, 10, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Note:
+ UpdatedFields[4] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 4, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Email:
+ UpdatedFields[14] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 14, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Email2:
+ UpdatedFields[15] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 15, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_LastName:
+ UpdatedFields[0] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 0, entry->Entries[i].Text)) != ERR_NONE) return error; NameSet = true;
+ break;
+ case PBK_Text_FirstName:
+ UpdatedFields[1] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 1, entry->Entries[i].Text)) != ERR_NONE) return error; NameSet = true;
+ break;
+ case PBK_Text_Company:
+ UpdatedFields[2] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 2, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_JobTitle:
+ UpdatedFields[3] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 3, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Category:
+ UpdatedFields[5] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_byte, entry->Location, 5, &(entry->Entries[i].Number))) != ERR_NONE) return error;
+ break;
+ case PBK_Private:
+ UpdatedFields[6] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_bool, entry->Location, 6, &(entry->Entries[i].Number))) != ERR_NONE) return error;
+ break;
+ case PBK_Text_StreetAddress:
+ UpdatedFields[16] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 16, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_City:
+ UpdatedFields[17] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 17, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_State:
+ UpdatedFields[18] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 18, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Zip:
+ UpdatedFields[19] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 19, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Country:
+ UpdatedFields[20] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 20, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Custom1:
+ UpdatedFields[21] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 21, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Custom2:
+ UpdatedFields[22] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 22, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Custom3:
+ UpdatedFields[23] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 23, entry->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case PBK_Text_Custom4:
+ UpdatedFields[24] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 24, entry->Entries[i].Text)) != ERR_NONE) return error
+ ; break;
+ case PBK_PictureID:
+ if (s->Phone.Data.Priv.ALCATEL.ProtocolVersion == V_1_1) {
+ UpdatedFields[25] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_int, entry->Location, 25, &(entry->Entries[i].Number))) != ERR_NONE) return error;
+ } else {
+ smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", entry->Entries[i].EntryType);
+ }
+ break;
+
+ case PBK_Text_Name: NamePosition = i; break;
+ /* Following fields are not supported: */
+ case PBK_SMSListID:
+ case PBK_Text_UserID:
+ case PBK_RingtoneFileSystemID:
+ case PBK_Date:
+ case PBK_Caller_Group:
+ case PBK_RingtoneID:
+ case PBK_Text_Postal:
+ case PBK_Text_URL:
+ smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", entry->Entries[i].EntryType);
+ break;
+ }
+ }
+ if (NamePosition != -1) {
+ if (NameSet) {
+ smprintf(s,"WARNING: Ignoring name, not supported by phone\n");
+ } else {
+ UpdatedFields[1] = true; if ((error = ALCATEL_UpdateField(s, Alcatel_string, entry->Location, 1, entry->Entries[i].Text)) != ERR_NONE) return error;
+ }
+ }
+ /* If we didn't update some field, we have to delete it... */
+ for (i=0; i<Priv->CurrentFieldsCount; i++) {
+ if (!UpdatedFields[Priv->CurrentFields[i]]) if ((error = ALCATEL_DeleteField(s, entry->Location, Priv->CurrentFields[i])) != ERR_NONE) return error;
+ }
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ entry->Location = Priv->CommitedRecord;
+ return ERR_NONE;
+ } else {
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_SetMemory(s, entry);
+ }
+}
+
+static GSM_Error ALCATEL_DeleteMemory(GSM_StateMachine *s, GSM_MemoryEntry *entry)
+{
+ GSM_Error error;
+
+ if (entry->MemoryType == MEM_ME) {
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsIdAvailable(s, entry->Location))!= ERR_NONE) {
+ /* Entry was empty => no error */
+ return ERR_NONE;
+ }
+ /* Do real delete */
+ error = ALCATEL_DeleteItem(s, entry->Location);
+ if (error != ERR_NONE) return error;
+
+ /* Refresh list */
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+
+ return ERR_NONE;
+ } else {
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_DeleteMemory(s, entry);
+ }
+}
+
+static GSM_Error ALCATEL_DeleteAllMemory(GSM_StateMachine *s, GSM_MemoryType type)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+
+ if (type == MEM_ME) {
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+
+ for (i=0; i<Priv->ContactsItemsCount; i++) {
+ error = ALCATEL_DeleteItem(s, Priv->ContactsItems[i]);
+ if (error != ERR_NONE) return error;
+ }
+
+ /* Refresh list */
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+
+ return ERR_NONE;
+ } else {
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_DeleteAllMemory(s, type);
+ }
+}
+
+static GSM_Error ALCATEL_GetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetSMSC(s, smsc);
+}
+
+
+static GSM_Error ALCATEL_GetMemoryStatus(GSM_StateMachine *s, GSM_MemoryStatus *Status)
+{
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_Error error;
+
+ if (Status->MemoryType == MEM_ME) {
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeContacts, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+ Status->MemoryUsed = Priv->ContactsItemsCount;
+ Status->MemoryFree = ALCATEL_FREE_MEMORY;
+ return ERR_NONE;
+ } else {
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetMemoryStatus(s, Status);
+ }
+}
+
+static GSM_Error ALCATEL_GetSMS(GSM_StateMachine *s, GSM_MultiSMSMessage *sms)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetSMS(s, sms);
+}
+
+static GSM_Error ALCATEL_DeleteSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_DeleteSMS(s, sms);
+}
+
+static GSM_Error ALCATEL_AddSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_AddSMS(s, sms);
+}
+
+static GSM_Error ALCATEL_GetBatteryCharge(GSM_StateMachine *s, GSM_BatteryCharge *bat)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetBatteryCharge(s, bat);
+}
+
+static GSM_Error ALCATEL_GetSignalStrength(GSM_StateMachine *s, GSM_SignalQuality *sig)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetSignalQuality(s, sig);
+}
+
+static GSM_Error ALCATEL_GetSMSFolders(GSM_StateMachine *s, GSM_SMSFolders *folders)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetSMSFolders(s, folders);
+}
+
+static GSM_Error ALCATEL_GetNextSMS(GSM_StateMachine *s, GSM_MultiSMSMessage *sms, bool start)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetNextSMS(s, sms, start);
+}
+
+static GSM_Error ALCATEL_GetSMSStatus(GSM_StateMachine *s, GSM_SMSMemoryStatus *status)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetSMSStatus(s, status);
+}
+
+static GSM_Error ALCATEL_DialVoice(GSM_StateMachine *s, char *number, GSM_CallShowNumber ShowNumber)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_DialVoice(s, number, ShowNumber);
+}
+
+static GSM_Error ALCATEL_AnswerCall(GSM_StateMachine *s, int ID, bool all)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_AnswerCall(s,ID,all);
+}
+
+static GSM_Error ALCATEL_GetNetworkInfo(GSM_StateMachine *s, GSM_NetworkInfo *netinfo)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetNetworkInfo(s, netinfo);
+}
+
+static GSM_Error ALCATEL_GetDisplayStatus(GSM_StateMachine *s, GSM_DisplayFeatures *features)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetDisplayStatus(s, features);
+}
+
+static GSM_Error ALCATEL_SetAutoNetworkLogin(GSM_StateMachine *s)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_SetAutoNetworkLogin(s);
+}
+
+static GSM_Error ALCATEL_PressKey(GSM_StateMachine *s, GSM_KeyCode Key, bool Press)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_PressKey(s, Key, Press);
+}
+
+static GSM_Error ALCATEL_Reset(GSM_StateMachine *s, bool hard)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_Reset(s, hard);
+}
+
+static GSM_Error ALCATEL_CancelCall(GSM_StateMachine *s, int ID, bool all)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_CancelCall(s,ID,all);
+}
+
+static GSM_Error ALCATEL_SendSavedSMS(GSM_StateMachine *s, int Folder, int Location)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_SendSavedSMS(s, Folder, Location);
+}
+
+static GSM_Error ALCATEL_SendSMS(GSM_StateMachine *s, GSM_SMSMessage *sms)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_SendSMS(s, sms);
+}
+
+static GSM_Error ALCATEL_SetDateTime(GSM_StateMachine *s, GSM_DateTime *date_time)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_SetDateTime(s, date_time);
+}
+
+static GSM_Error ALCATEL_SetSMSC(GSM_StateMachine *s, GSM_SMSC *smsc)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_SetSMSC(s, smsc);
+}
+
+static GSM_Error ALCATEL_EnterSecurityCode(GSM_StateMachine *s, GSM_SecurityCode Code)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_EnterSecurityCode(s, Code);
+}
+
+static GSM_Error ALCATEL_GetSecurityStatus(GSM_StateMachine *s, GSM_SecurityCodeType *Status)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetSecurityStatus(s, Status);
+}
+
+static GSM_Error ALCATEL_ResetPhoneSettings(GSM_StateMachine *s, GSM_ResetSettingsType Type)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_ResetPhoneSettings(s, Type);
+}
+
+static GSM_Error ALCATEL_SendDTMF(GSM_StateMachine *s, char *sequence)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_SendDTMF(s, sequence);
+}
+
+static GSM_Error ALCATEL_GetSIMIMSI(GSM_StateMachine *s, char *IMSI)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_GetSIMIMSI(s, IMSI);
+}
+
+static GSM_Error ALCATEL_GetCalendarStatus(GSM_StateMachine *s, GSM_CalendarStatus *status)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ status->Used = 0;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+
+ status->Used = Priv->CalendarItemsCount;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
+{
+ GSM_Error error;
+ GSM_DateTime *dt = NULL;
+ GSM_DateTime evdate;
+ bool evdateused = true;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+ int j=0;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsIdAvailable(s, Note->Location))!= ERR_NONE) {
+ Note->EntriesNum = 0;
+ return error;
+ }
+ if ((error = ALCATEL_GetFields(s, Note->Location))!= ERR_NONE) return error;
+
+ Note->EntriesNum = Priv->CurrentFieldsCount;
+
+ for (i=0; i < Priv->CurrentFieldsCount; i++) {
+ if ((error = ALCATEL_GetFieldValue(s, Note->Location, Priv->CurrentFields[i]))!= ERR_NONE) return error;
+ switch (Priv->CurrentFields[i]) {
+ case 0:
+ if (Priv->ReturnType != Alcatel_date) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckDate(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ j++;
+ Note->EntriesNum--;
+ evdate = Priv->ReturnDateTime;
+ evdateused = false;
+ break;
+ case 1:
+ if (Priv->ReturnType != Alcatel_time) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckTime(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_START_DATETIME;
+ Note->Entries[i-j].Date = Priv->ReturnDateTime;
+ Note->Entries[i-j].Date.Day = evdate.Day;
+ Note->Entries[i-j].Date.Month = evdate.Month;
+ Note->Entries[i-j].Date.Year = evdate.Year;
+ Note->Entries[i-j].Date.Timezone = evdate.Timezone;
+ evdateused = true;
+ break;
+ case 2:
+ if (Priv->ReturnType != Alcatel_time) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckTime(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_END_DATETIME;
+ Note->Entries[i-j].Date = Priv->ReturnDateTime;
+ Note->Entries[i-j].Date.Day = evdate.Day;
+ Note->Entries[i-j].Date.Month = evdate.Month;
+ Note->Entries[i-j].Date.Year = evdate.Year;
+ Note->Entries[i-j].Date.Timezone = evdate.Timezone;
+ evdateused = true;
+ break;
+ case 3:
+ if (Priv->ReturnType != Alcatel_date) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckDate(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (dt == NULL) {
+ Note->Entries[i-j].EntryType = CAL_ALARM_DATETIME;
+ Note->Entries[i-j].Date = Priv->ReturnDateTime;
+ dt = &(Note->Entries[i-j].Date);
+ } else {
+ j++;
+ Note->EntriesNum--;
+ dt->Day = Priv->ReturnDateTime.Day;
+ dt->Month = Priv->ReturnDateTime.Month;
+ dt->Year = Priv->ReturnDateTime.Year;
+ dt->Timezone = Priv->ReturnDateTime.Timezone;
+ dt = NULL;
+ }
+ break;
+ case 4:
+ if (Priv->ReturnType != Alcatel_time) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckTime(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (dt == NULL) {
+ Note->Entries[i-j].EntryType = CAL_ALARM_DATETIME;
+ Note->Entries[i-j].Date = Priv->ReturnDateTime;
+ dt = &(Note->Entries[i-j].Date);
+ } else {
+ j++;
+ Note->EntriesNum--;
+ dt->Hour = Priv->ReturnDateTime.Hour;
+ dt->Minute = Priv->ReturnDateTime.Minute;
+ dt->Second = Priv->ReturnDateTime.Second;
+ dt = NULL;
+ }
+ break;
+ case 5:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_TEXT;
+ CopyUnicodeString(Note->Entries[i-j].Text, Priv->ReturnString);
+ break;
+ case 6:
+ if (Priv->ReturnType != Alcatel_bool) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_PRIVATE;
+ Note->Entries[i-j].Number = Priv->ReturnInt;
+ break;
+ case 7:
+ if (Priv->ReturnType != Alcatel_enum) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ switch (Priv->ReturnInt) {
+ case 0:
+ Note->Type = GSM_CAL_MEETING;
+ break;
+ case 2:
+ Note->Type = GSM_CAL_BIRTHDAY;
+ break;
+ case 3:
+ Note->Type = GSM_CAL_CALL;
+ break;
+ case 4:
+ Note->Type = GSM_CAL_ALARM;
+ break;
+ case 5:
+ Note->Type = GSM_CAL_DAILY_ALARM;
+ break;
+ case 9:
+ /* I'd call this repeating event, but it makes no sense creating one more type ... */
+ Note->Type = GSM_CAL_MEETING;
+ break;
+ default:
+ smprintf(s,"WARNING: Received unknown event type %02X!\n", Priv->ReturnInt);
+ break;
+ }
+ j++;
+ Note->EntriesNum--;
+ break;
+ case 8:
+ if (Priv->ReturnType != Alcatel_int) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ /* 0xffffffff indicates that there is phone (BF5), 0 means none (BF5, BE5)*/
+ if (Priv->ReturnInt == 0xffffffff || Priv->ReturnInt == 0) {
+ j++;
+ Note->EntriesNum--;
+ } else {
+ Note->Entries[i-j].EntryType = CAL_CONTACTID;
+ Note->Entries[i-j].Number = Priv->ReturnInt;
+ }
+ break;
+ case 9:
+ if (Priv->ReturnType != Alcatel_phone) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_PHONE;
+ CopyUnicodeString(Note->Entries[i-j].Text, Priv->ReturnString);
+ break;
+ case 10:
+ if (Priv->ReturnType != Alcatel_byte) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_REPEAT_DAYOFWEEK;
+ Note->Entries[i-j].Number = Priv->ReturnInt;
+ break;
+ case 11:
+ if (Priv->ReturnType != Alcatel_byte) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_REPEAT_DAY;
+ Note->Entries[i-j].Number = Priv->ReturnInt;
+ break;
+ case 12:
+ if (Priv->ReturnType != Alcatel_byte) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_REPEAT_WEEKOFMONTH;
+ Note->Entries[i-j].Number = Priv->ReturnInt;
+ break;
+ case 13:
+ if (Priv->ReturnType != Alcatel_byte) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_REPEAT_MONTH;
+ Note->Entries[i-j].Number = Priv->ReturnInt;
+ break;
+ case 17:
+ if (Priv->ReturnType != Alcatel_byte) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ /* In BF5 birthday has frequency = 1 */
+ if (Note->Type == GSM_CAL_BIRTHDAY) {
+ Note->EntriesNum--;
+ j++;
+ } else {
+ Note->Entries[i-j].EntryType = CAL_REPEAT_FREQUENCY;
+ Note->Entries[i-j].Number = Priv->ReturnInt;
+ }
+ break;
+ case 18:
+ if (Priv->ReturnType != Alcatel_date) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckDate(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_REPEAT_STARTDATE;
+ Note->Entries[i-j].Date = Priv->ReturnDateTime;
+ break;
+ case 19:
+ if (Priv->ReturnType != Alcatel_date) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckDate(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ Note->Entries[i-j].EntryType = CAL_REPEAT_STOPDATE;
+ Note->Entries[i-j].Date = Priv->ReturnDateTime;
+ break;
+ case 20:
+ if (Priv->ReturnType != Alcatel_date) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckDate(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ /* This entry had always same value as the 3rd (alarm date) */
+ j++;
+ Note->EntriesNum--;
+ break;
+ case 21:
+ if (Priv->ReturnType != Alcatel_time) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckTime(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
+ Note->EntriesNum--;
+ j++;
+ break;
+ }
+ /* This entry had always same value as the 4th (alarm time) */
+ j++;
+ Note->EntriesNum--;
+ break;
+ default:
+ Note->EntriesNum--;
+ j++;
+ smprintf(s,"WARNING: Received unknown field %02X, ignoring. Type = %02X. Value = ", Priv->CurrentFields[i], Priv->ReturnType);
+ switch (Priv->ReturnType) {
+ case Alcatel_date:
+ smprintf(s, "%d.%d.%d", Priv->ReturnDateTime.Day, Priv->ReturnDateTime.Month, Priv->ReturnDateTime.Year);
+ break;
+ case Alcatel_time:
+ smprintf(s, "%d:%d:%d", Priv->ReturnDateTime.Hour, Priv->ReturnDateTime.Minute, Priv->ReturnDateTime.Second);
+ break;
+ case Alcatel_string:
+ case Alcatel_phone:
+ smprintf(s, "\"%s\"",DecodeUnicodeString(Priv->ReturnString));
+ break;
+ case Alcatel_enum:
+ case Alcatel_bool:
+ case Alcatel_int:
+ case Alcatel_byte:
+ smprintf(s, "%d", Priv->ReturnInt);
+ break;
+ }
+ smprintf(s,"\n");
+ }
+ }
+ /* The event didn't have start/stop time -> we need only date */
+ if (!evdateused) {
+ Note->EntriesNum++;
+ Note->Entries[i-j].EntryType = CAL_START_DATETIME;
+ Note->Entries[i-j].Date = evdate;
+ }
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetNextCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note, bool start)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if (Priv->CalendarItemsCount == 0) return ERR_EMPTY;
+
+ if (start) Note->Location = 0;
+ if ((error = ALCATEL_GetNextId(s, &(Note->Location))) != ERR_NONE) return error;
+
+ return ALCATEL_GetCalendar(s, Note);
+}
+
+
+static GSM_Error ALCATEL_DeleteCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ /* Delete Calendar */
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsIdAvailable(s, Note->Location))!= ERR_NONE) {
+ /* Entry was empty => no error */
+ return ERR_NONE;
+ }
+ error = ALCATEL_DeleteItem(s, Note->Location);
+ if (error != ERR_NONE) return error;
+ /* Refresh list */
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+ return ERR_NONE;
+}
+
+
+static GSM_Error ALCATEL_AddCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
+{
+ GSM_Error error;
+ unsigned int val;
+ bool contact_set = false;
+ bool phone_set = false;
+ bool date_set = false;
+ bool repeating = false;
+ int i;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeCalendar, 0))!= ERR_NONE) return error;
+
+ for (i = 0; i < Note->EntriesNum; i++) {
+ switch (Note->Entries[i].EntryType) {
+ case CAL_START_DATETIME:
+ if (!date_set) {
+ if ((error = ALCATEL_CreateField(s, Alcatel_date, 0, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ date_set = true;
+ }
+ if ((error = ALCATEL_CreateField(s, Alcatel_time, 1, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ break;
+ case CAL_END_DATETIME:
+ if (!date_set) {
+ if ((error = ALCATEL_CreateField(s, Alcatel_date, 0, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ date_set = true;
+ }
+ if ((error = ALCATEL_CreateField(s, Alcatel_time, 2, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ break;
+ case CAL_ALARM_DATETIME:
+ if ((error = ALCATEL_CreateField(s, Alcatel_date, 3, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ if ((error = ALCATEL_CreateField(s, Alcatel_time, 4, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ if (Note->Type == GSM_CAL_ALARM || Note->Type == GSM_CAL_DAILY_ALARM) {
+ if ((error = ALCATEL_CreateField(s, Alcatel_date, 20, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ if ((error = ALCATEL_CreateField(s, Alcatel_time, 21, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ }
+ break;
+ case CAL_TEXT:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 5, Note->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case CAL_PRIVATE:
+ if ((error = ALCATEL_CreateField(s, Alcatel_bool, 6, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ break;
+ case CAL_CONTACTID:
+ if ((error = ALCATEL_CreateField(s, Alcatel_int, 8, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ contact_set = true;
+ break;
+ case CAL_PHONE:
+ if ((error = ALCATEL_CreateField(s, Alcatel_phone, 9, Note->Entries[i].Text)) != ERR_NONE) return error;
+ phone_set = true;
+ break;
+ case CAL_REPEAT_DAYOFWEEK:
+ if ((error = ALCATEL_CreateField(s, Alcatel_byte, 10, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_DAY:
+ if ((error = ALCATEL_CreateField(s, Alcatel_byte, 11, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_WEEKOFMONTH:
+ if ((error = ALCATEL_CreateField(s, Alcatel_byte, 12, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_MONTH:
+ if ((error = ALCATEL_CreateField(s, Alcatel_byte, 13, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_FREQUENCY:
+ if ((error = ALCATEL_CreateField(s, Alcatel_byte, 17, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_STARTDATE:
+ if ((error = ALCATEL_CreateField(s, Alcatel_date, 18, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_STOPDATE:
+ if ((error = ALCATEL_CreateField(s, Alcatel_date, 19, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_SILENT_ALARM_DATETIME:
+ case CAL_RECURRANCE:
+ case CAL_LOCATION:
+ smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", Note->Entries[i].EntryType);
+ break;
+ }
+ }
+
+ switch (Note->Type) {
+ case GSM_CAL_CALL:
+ val = 3;
+ break;
+ case GSM_CAL_BIRTHDAY:
+ val = 2;
+ break;
+ case GSM_CAL_ALARM:
+ val = 4;
+ break;
+ case GSM_CAL_DAILY_ALARM:
+ val = 5;
+ break;
+ default:
+ if (repeating) {
+ val = 9;
+ } else {
+ val = 0;
+ }
+ }
+ if ((error = ALCATEL_CreateField(s, Alcatel_enum, 7, &val)) != ERR_NONE) return error;
+
+ if (!contact_set) {
+ if (phone_set) {
+ val = 0xffffffff;
+ } else {
+ val = 0;
+ }
+ if ((error = ALCATEL_CreateField(s, Alcatel_int, 8, &val)) != ERR_NONE) return error;
+ }
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ Note->Location = Priv->CommitedRecord;
+ /* Refresh list */
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_SetCalendar(GSM_StateMachine *s, GSM_CalendarEntry *Note)
+{
+ GSM_Error error;
+ unsigned int val;
+ bool contact_set = false;
+ bool phone_set = false;
+ bool date_set = false;
+ bool repeating = false;
+ int i;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ bool UpdatedFields[22];
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsIdAvailable(s, Note->Location))!= ERR_NONE) {
+ /* Entry doesn't exist, we will create new one */
+ return ALCATEL_AddCalendar(s, Note);
+ }
+ /* Get fields for current item */
+ if ((error = ALCATEL_GetFields(s, Note->Location))!= ERR_NONE) return error;
+
+ for (i = 0; i < 22; i++) { UpdatedFields[i] = false; }
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeCalendar, Note->Location))!= ERR_NONE) return error;
+
+ for (i = 0; i < Note->EntriesNum; i++) {
+ switch (Note->Entries[i].EntryType) {
+ case CAL_START_DATETIME:
+ if (!date_set) {
+ UpdatedFields[0] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 0, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ date_set = true;
+ }
+ UpdatedFields[1] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_time, Note->Location, 1, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ break;
+ case CAL_END_DATETIME:
+ if (!date_set) {
+ UpdatedFields[0] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 0, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ date_set = true;
+ }
+ UpdatedFields[2] = true; if ((error = ALCATEL_UpdateField(s, Alcatel_time, Note->Location, 2, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ break;
+ case CAL_ALARM_DATETIME:
+ UpdatedFields[3] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 3, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ UpdatedFields[4] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_time, Note->Location, 4, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ if (Note->Type == GSM_CAL_ALARM || Note->Type == GSM_CAL_DAILY_ALARM) {
+ UpdatedFields[20] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 20, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ UpdatedFields[21] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_time, Note->Location, 21, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ }
+ break;
+ case CAL_TEXT:
+ UpdatedFields[5] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, Note->Location, 5, Note->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case CAL_PRIVATE:
+ UpdatedFields[6] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_bool, Note->Location, 6, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ break;
+ case CAL_CONTACTID:
+ UpdatedFields[8] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_int, Note->Location, 8, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ contact_set = true;
+ break;
+ case CAL_PHONE:
+ UpdatedFields[9] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_phone, Note->Location, 9, Note->Entries[i].Text)) != ERR_NONE) return error;
+ phone_set = true;
+ break;
+ case CAL_REPEAT_DAYOFWEEK:
+ UpdatedFields[10] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 10, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_DAY:
+ UpdatedFields[11] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 11, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_WEEKOFMONTH:
+ UpdatedFields[12] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 12, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_MONTH:
+ UpdatedFields[13] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 13, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_FREQUENCY:
+ UpdatedFields[17] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_byte, Note->Location, 17, &(Note->Entries[i].Number))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_STARTDATE:
+ UpdatedFields[18] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 18, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_REPEAT_STOPDATE:
+ UpdatedFields[19] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_date, Note->Location, 19, &(Note->Entries[i].Date))) != ERR_NONE) return error;
+ repeating = true;
+ break;
+ case CAL_SILENT_ALARM_DATETIME:
+ case CAL_RECURRANCE:
+ case CAL_LOCATION:
+ smprintf(s,"WARNING: Ignoring entry %d, not supported by phone\n", Note->Entries[i].EntryType);
+ break;
+ }
+ }
+
+ switch (Note->Type) {
+ case GSM_CAL_CALL:
+ val = 3;
+ break;
+ case GSM_CAL_BIRTHDAY:
+ val = 2;
+ break;
+ case GSM_CAL_ALARM:
+ val = 4;
+ break;
+ case GSM_CAL_DAILY_ALARM:
+ val = 5;
+ break;
+ default:
+ if (repeating) {
+ val = 9;
+ } else {
+ val = 0;
+ }
+ }
+ UpdatedFields[7] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_enum, Note->Location, 7, &val)) != ERR_NONE) return error;
+
+ if (!contact_set) {
+ if (phone_set) {
+ val = 0xffffffff;
+ } else {
+ val = 0;
+ }
+ UpdatedFields[8] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_int, Note->Location, 8, &val)) != ERR_NONE) return error;
+ }
+ /* If we didn't update some field, we have to delete it... */
+ for (i=0; i<Priv->CurrentFieldsCount; i++) {
+ if (!UpdatedFields[Priv->CurrentFields[i]]) if ((error = ALCATEL_DeleteField(s, Note->Location, Priv->CurrentFields[i])) != ERR_NONE) return error;
+ }
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_DeleteAllCalendar (GSM_StateMachine *s)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+
+ for (i=0; i<Priv->CalendarItemsCount; i++) {
+ error = ALCATEL_DeleteItem(s, Priv->CalendarItems[i]);
+ if (error != ERR_NONE) return error;
+ }
+
+ /* Refresh list */
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+
+ return ERR_NONE;
+}
+
+
+static GSM_Error ALCATEL_GetAlarm(GSM_StateMachine *s, GSM_Alarm *alarm)
+{
+ GSM_Error error;
+ GSM_CalendarEntry Note;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+ bool Found = false;
+ bool DateSet = false;
+ int alarm_number = alarm->Location;
+ static GSM_DateTime nulldt = {0,0,0,0,0,0,0};
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+
+ for (i=0; i<Priv->CalendarItemsCount; i++) {
+ if ((error = ALCATEL_GetFieldValue(s, Priv->CalendarItems[i], 7))!= ERR_NONE) return error;
+ if (Priv->ReturnType != Alcatel_enum) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ continue;
+ }
+ if (Priv->ReturnInt == 4 || Priv->ReturnInt == 5) {
+ alarm_number--;
+ if (alarm_number == 0) {
+ Found = true;
+ break;
+ }
+ }
+ }
+
+ if (!Found) return ERR_EMPTY;
+
+ Note.Location = Priv->CalendarItems[i];
+
+ if ((error = ALCATEL_GetCalendar(s, &Note))!= ERR_NONE) return error;
+
+ if (Note.Type == GSM_CAL_ALARM) {
+ alarm->Repeating = false;
+ } else {
+ alarm->Repeating = true;
+ }
+
+ alarm->Text[0] = 0; alarm->Text[1] = 0;
+
+
+ for (i = 0; i < Note.EntriesNum; i++) {
+ if (Note.Entries[i].EntryType == CAL_TEXT) {
+ CopyUnicodeString(alarm->Text, Note.Entries[i].Text);
+ } else if (Note.Entries[i].EntryType == CAL_ALARM_DATETIME) {
+ alarm->DateTime = Note.Entries[i].Date;
+ DateSet = false;
+ }
+ }
+ if (!DateSet) {
+ alarm->DateTime = nulldt;
+ }
+
+ return ERR_NONE;
+}
+
+
+static GSM_Error ALCATEL_SetAlarm (GSM_StateMachine *s, GSM_Alarm *alarm)
+{
+ GSM_Error error;
+ GSM_CalendarEntry Note;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ GSM_DateTime dt;
+ int i;
+ bool Found = false;
+ int alarm_number = alarm->Location;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeCalendar, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+
+ for (i=0; i<Priv->CalendarItemsCount; i++) {
+ if ((error = ALCATEL_GetFieldValue(s, Priv->CalendarItems[i], 7))!= ERR_NONE) return error;
+ if (Priv->ReturnType != Alcatel_enum) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ continue;
+ }
+ if (Priv->ReturnInt == 4 || Priv->ReturnInt == 5) {
+ alarm_number--;
+ if (alarm_number == 0) {
+ Found = true;
+ break;
+ }
+ }
+ }
+
+ if (Found) {
+ Note.Location = Priv->CalendarItems[i];
+ }
+
+ Note.EntriesNum = 1;
+
+ Note.Entries[0].EntryType = CAL_ALARM_DATETIME;
+ Note.Entries[0].Date = alarm->DateTime;
+
+ if (alarm->Repeating) {
+ Note.Type = GSM_CAL_DAILY_ALARM;
+ GSM_GetCurrentDateTime(&dt);
+ Note.Entries[0].Date.Day = dt.Day;
+ Note.Entries[0].Date.Month = dt.Month;
+ Note.Entries[0].Date.Year = dt.Year;
+ } else {
+ Note.Type = GSM_CAL_ALARM;
+ }
+
+ if (alarm->Text[0] != 0 || alarm->Text[1] != 0) {
+ Note.EntriesNum++;
+ Note.Entries[1].EntryType = CAL_TEXT;
+ CopyUnicodeString(Note.Entries[1].Text, alarm->Text);
+ }
+
+ if (Found) {
+ return ALCATEL_SetCalendar(s, &Note);
+ } else {
+ return ALCATEL_AddCalendar(s, &Note);
+ }
+}
+
+
+static GSM_Error ALCATEL_GetToDoStatus(GSM_StateMachine *s, GSM_ToDoStatus *status)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ status->Used = 0;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+
+ status->Used = Priv->ToDoItemsCount;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
+{
+ GSM_Error error;
+ GSM_DateTime *dt = NULL;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+ int j=0;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsIdAvailable(s, ToDo->Location))!= ERR_NONE) {
+ ToDo->EntriesNum = 0;
+ return error;
+ }
+ if ((error = ALCATEL_GetFields(s, ToDo->Location))!= ERR_NONE) return error;
+
+ ToDo->EntriesNum = Priv->CurrentFieldsCount;
+
+ for (i=0; i < Priv->CurrentFieldsCount; i++) {
+ if ((error = ALCATEL_GetFieldValue(s, ToDo->Location, Priv->CurrentFields[i]))!= ERR_NONE) return error;
+ switch (Priv->CurrentFields[i]) {
+ case 0:
+ if (Priv->ReturnType != Alcatel_date) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckDate(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ ToDo->Entries[i-j].EntryType = TODO_END_DATETIME;
+ ToDo->Entries[i-j].Date = Priv->ReturnDateTime;
+ break;
+ case 1:
+ if (Priv->ReturnType != Alcatel_bool) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ ToDo->Entries[i-j].EntryType = TODO_COMPLETED;
+ ToDo->Entries[i-j].Number = Priv->ReturnInt;
+ break;
+ case 2:
+ if (Priv->ReturnType != Alcatel_date) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckDate(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ if (dt == NULL) {
+ ToDo->Entries[i-j].EntryType = TODO_ALARM_DATETIME;
+ ToDo->Entries[i-j].Date = Priv->ReturnDateTime;
+ dt = &(ToDo->Entries[i-j].Date);
+ } else {
+ j++;
+ ToDo->EntriesNum--;
+ dt->Day = Priv->ReturnDateTime.Day;
+ dt->Month = Priv->ReturnDateTime.Month;
+ dt->Year = Priv->ReturnDateTime.Year;
+ dt->Timezone = Priv->ReturnDateTime.Timezone;
+ dt = NULL;
+ }
+ break;
+ case 3:
+ if (Priv->ReturnType != Alcatel_time) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckTime(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ if (dt == NULL) {
+ ToDo->Entries[i-j].EntryType = TODO_ALARM_DATETIME;
+ ToDo->Entries[i-j].Date = Priv->ReturnDateTime;
+ dt = &(ToDo->Entries[i-j].Date);
+ } else {
+ j++;
+ ToDo->EntriesNum--;
+ dt->Hour = Priv->ReturnDateTime.Hour;
+ dt->Minute = Priv->ReturnDateTime.Minute;
+ dt->Second = Priv->ReturnDateTime.Second;
+ dt = NULL;
+ }
+ break;
+ case 4:
+ if (Priv->ReturnType != Alcatel_string) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ ToDo->Entries[i-j].EntryType = TODO_TEXT;
+ CopyUnicodeString(ToDo->Entries[i-j].Text, Priv->ReturnString);
+ break;
+ case 5:
+ if (Priv->ReturnType != Alcatel_bool) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ ToDo->Entries[i-j].EntryType = TODO_PRIVATE;
+ ToDo->Entries[i-j].Number = Priv->ReturnInt;
+ break;
+ case 6:
+ if (Priv->ReturnType != Alcatel_byte) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ if (Priv->ReturnInt == 255) {
+ /* 255 means no category */
+ j++;
+ ToDo->EntriesNum--;
+ } else {
+ ToDo->Entries[i-j].EntryType = TODO_CATEGORY;
+ ToDo->Entries[i-j].Number = Priv->ReturnInt;
+ }
+ break;
+ case 7:
+ /* This one seems to be byte for BF5 and enum for BE5 */
+ if (Priv->ReturnType != Alcatel_enum && Priv->ReturnType != Alcatel_byte) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ switch (Priv->ReturnInt) {
+ case 0:
+ ToDo->Priority = GSM_Priority_High;
+ break;
+ case 1:
+ ToDo->Priority = GSM_Priority_Medium;
+ break;
+ case 2:
+ ToDo->Priority = GSM_Priority_Low;
+ break;
+ default:
+ ToDo->Priority = 0;
+ smprintf(s,"WARNING: Received unexpected priority %02X, ignoring\n", Priv->ReturnInt);
+ }
+ j++;
+ ToDo->EntriesNum--;
+ break;
+ case 8:
+ if (Priv->ReturnType != Alcatel_int) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ /* 0xffffffff indicates that there is phone, 0 means none */
+ if (Priv->ReturnInt == 0xffffffff || Priv->ReturnInt == 0) {
+ j++;
+ ToDo->EntriesNum--;
+ } else {
+ ToDo->Entries[i-j].EntryType = TODO_CONTACTID;
+ ToDo->Entries[i-j].Number = Priv->ReturnInt;
+ }
+ break;
+ case 9:
+ if (Priv->ReturnType != Alcatel_phone) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ ToDo->Entries[i-j].EntryType = TODO_PHONE;
+ CopyUnicodeString(ToDo->Entries[i-j].Text, Priv->ReturnString);
+ break;
+ case 10:
+ if (Priv->ReturnType != Alcatel_date) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckDate(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid date in phone, ignoring\n");
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ /* This entry had always same value as the 2nd (alarm date) */
+ j++;
+ ToDo->EntriesNum--;
+ break;
+ case 11:
+ if (Priv->ReturnType != Alcatel_time) {
+ smprintf(s,"WARNING: Received unexpected type %02X, ignoring\n", Priv->ReturnType);
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ if (!CheckTime(&(Priv->ReturnDateTime))) {
+ smprintf(s,"WARNING: Invalid time in phone, ignoring\n");
+ ToDo->EntriesNum--;
+ j++;
+ break;
+ }
+ /* This entry had always same value as the 3rd (alarm time) */
+ j++;
+ ToDo->EntriesNum--;
+ break;
+ default:
+ ToDo->EntriesNum--;
+ j++;
+ smprintf(s,"WARNING: Received unknown field %02X, ignoring. Type = %02X. Value = ", Priv->CurrentFields[i], Priv->ReturnType);
+ switch (Priv->ReturnType) {
+ case Alcatel_date:
+ smprintf(s, "%d.%d.%d", Priv->ReturnDateTime.Day, Priv->ReturnDateTime.Month, Priv->ReturnDateTime.Year);
+ break;
+ case Alcatel_time:
+ smprintf(s, "%d:%d:%d", Priv->ReturnDateTime.Hour, Priv->ReturnDateTime.Minute, Priv->ReturnDateTime.Second);
+ break;
+ case Alcatel_string:
+ case Alcatel_phone:
+ smprintf(s, "\"%s\"",DecodeUnicodeString(Priv->ReturnString));
+ break;
+ case Alcatel_enum:
+ case Alcatel_bool:
+ case Alcatel_int:
+ case Alcatel_byte:
+ smprintf(s, "%d", Priv->ReturnInt);
+ break;
+ }
+ smprintf(s,"\n");
+ }
+ }
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetNextToDo(GSM_StateMachine *s, GSM_ToDoEntry *ToDo, bool start)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if (Priv->ToDoItemsCount == 0) return ERR_EMPTY;
+
+ if (start) ToDo->Location = 0;
+ if ((error = ALCATEL_GetNextId(s, &(ToDo->Location))) != ERR_NONE) return error;
+
+ return ALCATEL_GetToDo(s, ToDo);
+}
+
+static GSM_Error ALCATEL_DeleteAllToDo (GSM_StateMachine *s)
+{
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+ int i;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+
+ for (i=0; i<Priv->ToDoItemsCount; i++) {
+ error = ALCATEL_DeleteItem(s, Priv->ToDoItems[i]);
+ if (error != ERR_NONE) return error;
+ }
+
+ /* Refresh list */
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_AddToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
+{
+ GSM_Error error;
+ unsigned int val;
+ bool contact_set = false;
+ bool phone_set = false;
+ int i;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeToDo, 0))!= ERR_NONE) return error;
+
+ switch (ToDo->Priority) {
+ case GSM_Priority_High:
+ val = 0;
+ break;
+ case GSM_Priority_Low:
+ val = 2;
+ break;
+ case GSM_Priority_Medium:
+ default:
+ val = 1;
+ break;
+ }
+ /* This one seems to be byte for BF5 and enum for BE5 */
+ if (s->Phone.Data.Priv.ALCATEL.ProtocolVersion == V_1_1) {
+ if ((error = ALCATEL_CreateField(s, Alcatel_byte, 7, &val)) != ERR_NONE) return error;
+ } else {
+ if ((error = ALCATEL_CreateField(s, Alcatel_enum, 7, &val)) != ERR_NONE) return error;
+ }
+
+ for (i = 0; i < ToDo->EntriesNum; i++) {
+ switch (ToDo->Entries[i].EntryType) {
+ case TODO_END_DATETIME:
+ if ((error = ALCATEL_CreateField(s, Alcatel_date, 0, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ break;
+ case TODO_COMPLETED:
+ if ((error = ALCATEL_CreateField(s, Alcatel_bool, 1, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
+ break;
+ case TODO_ALARM_DATETIME:
+ if ((error = ALCATEL_CreateField(s, Alcatel_date, 2, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ if ((error = ALCATEL_CreateField(s, Alcatel_time, 3, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ if ((error = ALCATEL_CreateField(s, Alcatel_date, 10, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ if ((error = ALCATEL_CreateField(s, Alcatel_time, 11, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ break;
+ case TODO_TEXT:
+ if ((error = ALCATEL_CreateField(s, Alcatel_string, 4, ToDo->Entries[i].Text)) != ERR_NONE) return error;
+ break;
+ case TODO_PRIVATE:
+ if ((error = ALCATEL_CreateField(s, Alcatel_bool, 5, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
+ break;
+ case TODO_CATEGORY:
+ if ((error = ALCATEL_CreateField(s, Alcatel_byte, 6, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
+ break;
+ case TODO_CONTACTID:
+ if ((error = ALCATEL_CreateField(s, Alcatel_int, 8, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
+ contact_set = true;
+ break;
+ case TODO_PHONE:
+ if ((error = ALCATEL_CreateField(s, Alcatel_phone, 9, ToDo->Entries[i].Text)) != ERR_NONE) return error;
+ phone_set = true;
+ break;
+ default:
+ break;
+ }
+ }
+ if (!contact_set) {
+ if (phone_set) {
+ val = 0xffffffff;
+ } else {
+ val = 0;
+ }
+ if ((error = ALCATEL_CreateField(s, Alcatel_int, 8, &val)) != ERR_NONE) return error;
+ }
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ ToDo->Location = Priv->CommitedRecord;
+ /* Refresh list */
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_SetToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
+{
+ GSM_Error error;
+ unsigned int val;
+ bool contact_set = false;
+ bool phone_set = false;
+ bool UpdatedFields[12];
+ int i;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ /* Save modified ToDo */
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsIdAvailable(s, ToDo->Location))!= ERR_NONE) {
+ /* Entry doesn't exist, we will create new one */
+ return ALCATEL_AddToDo(s, ToDo);
+ }
+ /* Get fields for current item */
+ if ((error = ALCATEL_GetFields(s, ToDo->Location))!= ERR_NONE) return error;
+
+ for (i = 0; i < 12; i++) { UpdatedFields[i] = false; }
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateEdit, TypeToDo, ToDo->Location))!= ERR_NONE) return error;
+
+ switch (ToDo->Priority) {
+ case GSM_Priority_High:
+ val = 0;
+ break;
+ case GSM_Priority_Low:
+ val = 2;
+ break;
+ case GSM_Priority_Medium:
+ default:
+ val = 1;
+ break;
+ }
+ /* This one seems to be byte for BF5 and enum for BE5 */
+ if (s->Phone.Data.Priv.ALCATEL.ProtocolVersion == V_1_1) {
+ if ((error = ALCATEL_UpdateField(s, Alcatel_byte, ToDo->Location, 7, &val)) != ERR_NONE) return error;
+ } else {
+ if ((error = ALCATEL_UpdateField(s, Alcatel_enum, ToDo->Location, 7, &val)) != ERR_NONE) return error;
+ }
+ UpdatedFields[7] = true;
+
+ for (i = 0; i < ToDo->EntriesNum; i++) {
+ switch (ToDo->Entries[i].EntryType) {
+ case TODO_END_DATETIME:
+ if ((error = ALCATEL_UpdateField(s, Alcatel_date, ToDo->Location, 0, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ UpdatedFields[0] = true;
+ break;
+ case TODO_COMPLETED:
+ if ((error = ALCATEL_UpdateField(s, Alcatel_bool, ToDo->Location, 1, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
+ UpdatedFields[1] = true;
+ break;
+ case TODO_ALARM_DATETIME:
+ if ((error = ALCATEL_UpdateField(s, Alcatel_date, ToDo->Location, 2, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ UpdatedFields[2] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_time, ToDo->Location, 3, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ UpdatedFields[3] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_date, ToDo->Location, 10, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ UpdatedFields[10] = true;
+ if ((error = ALCATEL_UpdateField(s, Alcatel_time, ToDo->Location, 11, &(ToDo->Entries[i].Date))) != ERR_NONE) return error;
+ UpdatedFields[11] = true;
+ break;
+ case TODO_TEXT:
+ if ((error = ALCATEL_UpdateField(s, Alcatel_string, ToDo->Location, 4, ToDo->Entries[i].Text)) != ERR_NONE) return error;
+ UpdatedFields[4] = true;
+ break;
+ case TODO_PRIVATE:
+ if ((error = ALCATEL_UpdateField(s, Alcatel_bool, ToDo->Location, 5, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
+ UpdatedFields[5] = true;
+ break;
+ case TODO_CATEGORY:
+ if ((error = ALCATEL_UpdateField(s, Alcatel_byte, ToDo->Location, 6, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
+ UpdatedFields[6] = true;
+ break;
+ case TODO_CONTACTID:
+ if ((error = ALCATEL_UpdateField(s, Alcatel_int, ToDo->Location, 8, &(ToDo->Entries[i].Number))) != ERR_NONE) return error;
+ UpdatedFields[8] = true;
+ contact_set = true;
+ break;
+ case TODO_PHONE:
+ if ((error = ALCATEL_UpdateField(s, Alcatel_phone, ToDo->Location, 9, ToDo->Entries[i].Text)) != ERR_NONE) return error;
+ UpdatedFields[9] = true;
+ phone_set = true;
+ break;
+ default:
+ break;
+ }
+ }
+ if (!contact_set) {
+ if (phone_set) {
+ val = 0xffffffff;
+ } else {
+ val = 0;
+ }
+ if ((error = ALCATEL_UpdateField(s, Alcatel_int, ToDo->Location, 8, &val)) != ERR_NONE) return error;
+ UpdatedFields[8] = true;
+ }
+
+
+ /* If we didn't update some field, we have to delete it... */
+ for (i=0; i<Priv->CurrentFieldsCount; i++) {
+ if (!UpdatedFields[Priv->CurrentFields[i]]) if ((error = ALCATEL_DeleteField(s, ToDo->Location, Priv->CurrentFields[i])) != ERR_NONE) return error;
+ }
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_DeleteToDo (GSM_StateMachine *s, GSM_ToDoEntry *ToDo)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ /* Delete ToDo */
+ if ((error = ALCATEL_GetAvailableIds(s, false))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsIdAvailable(s, ToDo->Location))!= ERR_NONE) {
+ /* Entry was empty => no error */
+ return ERR_NONE;
+ }
+ error = ALCATEL_DeleteItem(s, ToDo->Location);
+ if (error != ERR_NONE) return error;
+ /* Refresh list */
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, TypeToDo, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableIds(s, true))!= ERR_NONE) return error;
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetCategoryStatus(GSM_StateMachine *s, GSM_CategoryStatus *Status)
+{
+ GSM_Alcatel_BinaryType type;
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ switch (Status->Type) {
+ case Category_ToDo: type = TypeToDo; break;
+ case Category_Phonebook: type = TypeContacts; break;
+ default: return ERR_NOTSUPPORTED;
+ }
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, type, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableCategoryIds(s))!= ERR_NONE) return error;
+
+ Status->Used = Priv->CurrentCategoriesCount;
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetCategory(GSM_StateMachine *s, GSM_Category *Category)
+{
+ GSM_Alcatel_BinaryType type;
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ switch (Category->Type) {
+ case Category_ToDo: type = TypeToDo; break;
+ case Category_Phonebook: type = TypeContacts; break;
+ default: return ERR_NOTSUPPORTED;
+ }
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, type, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetAvailableCategoryIds(s))!= ERR_NONE) return error;
+ if ((error = ALCATEL_IsCategoryIdAvailable(s, Category->Location))!= ERR_NONE) return error;
+ if ((error = ALCATEL_GetCategoryText(s, Category->Location))!= ERR_NONE) return error;
+
+ CopyUnicodeString(Category->Name, Priv->ReturnString);
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_AddCategory(GSM_StateMachine *s, GSM_Category *Category)
+{
+ GSM_Alcatel_BinaryType type;
+ GSM_Error error;
+ GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
+
+ switch (Category->Type) {
+ case Category_ToDo: type = TypeToDo; break;
+ case Category_Phonebook: type = TypeContacts; break;
+ default: return ERR_NOTSUPPORTED;
+ }
+ if ((error = ALCATEL_GoToBinaryState(s, StateSession, type, 0))!= ERR_NONE) return error;
+ if ((error = ALCATEL_AddCategoryText(s, Category->Name))!= ERR_NONE) return error;
+
+ Category->Location = Priv->ReturnInt;
+
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_GetProductCode(GSM_StateMachine *s, char *value)
+{
+ strcpy(value, s->Phone.Data.ModelInfo->model);
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_DispatchMessage(GSM_StateMachine *s)
+{
+ if (s->Phone.Data.Priv.ALCATEL.Mode == ModeBinary) {
+ return GSM_DispatchMessage(s);
+ } else {
+ return ATGEN_DispatchMessage(s);
+ }
+}
+
+static GSM_Error ALCATEL_ReplyGeneric(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ /* All error values are just VERY wild guesses, but these seems to work
+ * almost as expected ...
+ */
+ switch (msg.Buffer[8]) {
+ case 0x00: /* no error */
+ return ERR_NONE;
+ case 0x10: /* same thing opened in phone menus */
+ return ERR_INSIDEPHONEMENU;
+ case 0x13:
+ /* This appears in more cases:
+ * - phone needs PIN code
+ * - we want to close not opened session
+ * For normal users the second case shouldn't occur...
+ */
+ return ERR_SECURITYERROR;
+ case 0x14: /* Bad data */
+ case 0x2f: /* Closing session when not opened */
+ case 0x1f: /* Bad in/out counter in packet/ack */
+ case 0x0e: /* Openning session when not closed */
+ case 0x0C: /* Bad id (item/database) */
+ case 0x11: /* Bad list id */
+ case 0x2A: /* Nonexistant field/item id */
+ case 0x35: /* Too long text */
+ return ERR_BUG;
+ case 0x23: /* Session opened */
+ case 0x80: /* Transfer started */
+ return ERR_NONE;
+ case 0x82: /* Transfer canceled */
+ return ERR_CANCELED;
+ default:
+ smprintf(s, "WARNING: Packet seems to indicate some status by %02X, ignoring!\n", msg.Buffer[8]);
+ return ERR_NONE;
+ }
+}
+
+static GSM_Error ALCATEL_ReplyCommit(GSM_Protocol_Message msg, GSM_StateMachine *s)
+{
+ s->Phone.Data.Priv.ALCATEL.CommitedRecord = msg.Buffer[12] + (msg.Buffer[11] << 8) + (msg.Buffer[10] << 16) + (msg.Buffer[9] << 24);
+ smprintf(s, "Created record %08x\n", s->Phone.Data.Priv.ALCATEL.CommitedRecord);
+ return ERR_NONE;
+}
+
+static GSM_Error ALCATEL_SetIncomingCB (GSM_StateMachine *s, bool enable)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_SetIncomingCB(s, enable);
+}
+
+static GSM_Error ALCATEL_SetIncomingSMS (GSM_StateMachine *s, bool enable)
+{
+ GSM_Error error;
+
+ if ((error = ALCATEL_SetATMode(s))!= ERR_NONE) return error;
+ return ATGEN_SetIncomingSMS(s, enable);
+}
+
+static GSM_Reply_Function ALCATELReplyFunctions[] = {
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelAttach },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelDetach },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelCommit },
+{ALCATEL_ReplyCommit, "\x02",0x00,0x00, ID_AlcatelCommit2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelEnd },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelClose },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelStart },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelSelect1 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelSelect2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelSelect3 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelBegin1 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelBegin2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelGetIds1 },
+{ALCATEL_ReplyGetIds, "\x02",0x00,0x00, ID_AlcatelGetIds2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelGetCategories1 },
+{ALCATEL_ReplyGetCategories, "\x02",0x00,0x00, ID_AlcatelGetCategories2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelGetCategoryText1 },
+{ALCATEL_ReplyGetCategoryText, "\x02",0x00,0x00, ID_AlcatelGetCategoryText2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelAddCategoryText1 },
+{ALCATEL_ReplyAddCategoryText, "\x02",0x00,0x00, ID_AlcatelAddCategoryText2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelGetFields1 },
+{ALCATEL_ReplyGetFields, "\x02",0x00,0x00, ID_AlcatelGetFields2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelGetFieldValue1 },
+{ALCATEL_ReplyGetFieldValue, "\x02",0x00,0x00, ID_AlcatelGetFieldValue2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelDeleteField },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelDeleteItem1 },
+{ALCATEL_ReplyDeleteItem, "\x02",0x00,0x00, ID_AlcatelDeleteItem2 },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelCreateField },
+{ALCATEL_ReplyGeneric, "\x02",0x00,0x00, ID_AlcatelUpdateField },
+{NULL, "\x00",0x00,0x00, ID_None }
+};
+
+GSM_Phone_Functions ALCATELPhone = {
+ /* AFAIK, any 50[0123] phone should work, but I'm not sure whether all
+ * they were ever really released, if yes add them here also.
+ */
+ "alcatel|OT501|OT701|OT715|OT535|OT735|BE5|BF5|BH4",
+ ALCATELReplyFunctions,
+ ALCATEL_Initialise,
+ ALCATEL_Terminate,
+ ALCATEL_DispatchMessage,
+ NOTSUPPORTED, /* ShowStartInfo */
+ ALCATEL_GetManufacturer,
+ ALCATEL_GetModel,
+ ALCATEL_GetFirmware,
+ ALCATEL_GetIMEI,
+ NOTSUPPORTED, /* GetOriginalIMEI */
+ NOTSUPPORTED, /* GetManufactureMonth */
+ ALCATEL_GetProductCode,
+ NOTSUPPORTED, /* GetHardware */
+ NOTSUPPORTED, /* GetPPM */
+ ALCATEL_GetSIMIMSI,
+ ALCATEL_GetDateTime,
+ ALCATEL_SetDateTime,
+ ALCATEL_GetAlarm,
+ ALCATEL_SetAlarm,
+ NOTSUPPORTED, /* GetLocale */
+ NOTSUPPORTED, /* SetLocale */
+ ALCATEL_PressKey,
+ ALCATEL_Reset,
+ ALCATEL_ResetPhoneSettings,
+ ALCATEL_EnterSecurityCode,
+ ALCATEL_GetSecurityStatus,
+ ALCATEL_GetDisplayStatus,
+ ALCATEL_SetAutoNetworkLogin,
+ ALCATEL_GetBatteryCharge,
+ ALCATEL_GetSignalStrength,
+ ALCATEL_GetNetworkInfo,
+ ALCATEL_GetCategory,
+ ALCATEL_AddCategory,
+ ALCATEL_GetCategoryStatus,
+ ALCATEL_GetMemoryStatus,
+ ALCATEL_GetMemory,
+ ALCATEL_GetNextMemory,
+ ALCATEL_SetMemory,
+ ALCATEL_AddMemory,
+ ALCATEL_DeleteMemory,
+ ALCATEL_DeleteAllMemory,
+ NOTSUPPORTED, /* GetSpeedDial */
+ NOTSUPPORTED, /* SetSpeedDial */
+ ALCATEL_GetSMSC,
+ ALCATEL_SetSMSC,
+ ALCATEL_GetSMSStatus,
+ ALCATEL_GetSMS,
+ ALCATEL_GetNextSMS,
+ NOTSUPPORTED, /* SetSMS */
+ ALCATEL_AddSMS,
+ ALCATEL_DeleteSMS,
+ ALCATEL_SendSMS,
+ ALCATEL_SendSavedSMS,
+ ALCATEL_SetIncomingSMS,
+ ALCATEL_SetIncomingCB,
+ ALCATEL_GetSMSFolders,
+ NOTSUPPORTED, /* AddSMSFolder */
+ NOTSUPPORTED, /* DeleteSMSFolder */
+ ALCATEL_DialVoice,
+ ALCATEL_AnswerCall,
+ ALCATEL_CancelCall,
+ NOTSUPPORTED, /* HoldCall */
+ NOTSUPPORTED, /* UnholdCall */
+ NOTSUPPORTED, /* ConferenceCall */
+ NOTSUPPORTED, /* SplitCall */
+ NOTSUPPORTED, /* TransferCall */
+ NOTSUPPORTED, /* SwitchCall */
+ NOTSUPPORTED, /* GetCallDivert */
+ NOTSUPPORTED, /* SetCallDivert */
+ NOTSUPPORTED, /* CancelAllDiverts */
+ NONEFUNCTION, /* SetIncomingCall */
+ NOTSUPPORTED, /* SetIncomingUSSD */
+ ALCATEL_SendDTMF,
+ NOTSUPPORTED, /* GetRingtone */
+ NOTSUPPORTED, /* SetRingtone */
+ NOTSUPPORTED, /* GetRingtonesInfo */
+ NOTSUPPORTED, /* DeleteUserRingtones */
+ NOTSUPPORTED, /* PlayTone */
+ NOTSUPPORTED, /* GetWAPBookmark */
+ NOTSUPPORTED, /* SetWAPBookmark */
+ NOTSUPPORTED, /* DeleteWAPBookmark */
+ NOTSUPPORTED, /* GetWAPSettings */
+ NOTSUPPORTED, /* SetWAPSettings */
+ NOTSUPPORTED, /* GetMMSSettings */
+ NOTSUPPORTED, /* SetMMSSettings */
+ NOTSUPPORTED, /* GetSyncMLSettings */
+ NOTSUPPORTED, /* SetSyncMLSettings */
+ NOTSUPPORTED, /* GetChatSettings */
+ NOTSUPPORTED, /* SetChatSettings */
+ NOTSUPPORTED, /* GetBitmap */
+ NOTSUPPORTED, /* SetBitmap */
+ ALCATEL_GetToDoStatus,
+ ALCATEL_GetToDo,
+ ALCATEL_GetNextToDo,
+ ALCATEL_SetToDo,
+ ALCATEL_AddToDo,
+ ALCATEL_DeleteToDo,
+ ALCATEL_DeleteAllToDo,
+ ALCATEL_GetCalendarStatus,
+ ALCATEL_GetCalendar,
+ ALCATEL_GetNextCalendar,
+ ALCATEL_SetCalendar,
+ ALCATEL_AddCalendar,
+ ALCATEL_DeleteCalendar,
+ ALCATEL_DeleteAllCalendar,
+ NOTSUPPORTED, /* GetCalendarSettings */
+ NOTSUPPORTED, /* SetCalendarSettings */
+ NOTSUPPORTED, /* GetNote */
+ NOTSUPPORTED, /* GetProfile */
+ NOTSUPPORTED, /* SetProfile */
+ NOTSUPPORTED, /* GetFMStation */
+ NOTSUPPORTED, /* SetFMStation */
+ NOTSUPPORTED, /* ClearFMStations */
+ NOTSUPPORTED, /* GetNextFileFolder */
+ NOTSUPPORTED, /* GetFilePart */
+ NOTSUPPORTED, /* AddFilePart */
+ NOTSUPPORTED, /* GetFileSystemStatus */
+ NOTSUPPORTED, /* DeleteFile */
+ NOTSUPPORTED, /* AddFolder */
+ NOTSUPPORTED, /* GetGPRSAccessPoint */
+ NOTSUPPORTED /* SetGPRSAccessPoint */
+};
+
+#endif
+#endif
+
+/* How should editor hadle tabs in this file? Add editor commands here.
+ * vim: noexpandtab sw=8 ts=8 sts=8:
+ */