gcc4 fixes

author: zautrix <zautrix> 2006-02-24 19:41:06 (UTC)
committer: zautrix <zautrix> 2006-02-24 19:41:06 (UTC)
commit: 4e2553b95b2787ed7917073f6b628819b1f017c3 (patch) (unidiff)
tree: da5cb746bf3373cb2a368afda082999e6c22751f /gammu
parent: 08605356c77351d64e14e0fdd69bdb769f933909 (diff)
download: kdepimpi-4e2553b95b2787ed7917073f6b628819b1f017c3.zip
kdepimpi-4e2553b95b2787ed7917073f6b628819b1f017c3.tar.gz
kdepimpi-4e2553b95b2787ed7917073f6b628819b1f017c3.tar.bz2
5 files changed, 5 insertions, 5 deletions
diff --git a/gammu/emb/common/phone/alcatel/alcatel.c b/gammu/emb/common/phone/alcatel/alcatel.c
index b75077f..718d91e 100644
--- a/gammu/emb/common/phone/alcatel/alcatel.c
+++ b/gammu/emb/common/phone/alcatel/alcatel.c
@@ -1,1595 +1,1595 @@
 /* (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_CALENDAR0x64
        #define ALCATEL_SYNC_TYPE_TODO  0x68
        #define ALCATEL_SYNC_TYPE_CONTACTS0x6C
 /* synchronisation types (for begin transfer): */
        #define ALCATEL_BEGIN_SYNC_CALENDAR0x00
        #define ALCATEL_BEGIN_SYNC_TODO         0x02
        #define ALCATEL_BEGIN_SYNC_CONTACTS0x01
 /* category types */
        #define ALCATEL_LIST_TODO_CAT   0x9B
        #define ALCATEL_LIST_CONTACTS_CAT0x96
 /* We need lot of ATGEN functions, because Alcatel is an AT device. */
-extern GSM_Reply_Function ALCATELReplyFunctions[];
+static GSM_Reply_Function ALCATELReplyFunctions[];
 extern GSM_Reply_Function ATGENReplyFunctions[];
        extern GSM_Error ATGEN_Initialise       (GSM_StateMachine *s);
        extern GSM_Error ATGEN_Terminate        (GSM_StateMachine *s);
        extern GSM_Error ATGEN_GetIMEI                  (GSM_StateMachine *s);
        extern GSM_Error ATGEN_GetFirmware      (GSM_StateMachine *s);
        extern GSM_Error ATGEN_GetModel                 (GSM_StateMachine *s);
        extern GSM_Error ATGEN_GetDateTime      (GSM_StateMachine *s, GSM_DateTime *date_time);
        extern GSM_Error ATGEN_GetMemory        (GSM_StateMachine *s, GSM_MemoryEntry *entry);
        extern GSM_Error ATGEN_GetNextMemory    (GSM_StateMachine *s, GSM_MemoryEntry *entry, bool start);
        extern GSM_Error ATGEN_SetMemory        (GSM_StateMachine *s, GSM_MemoryEntry *entry);
        extern GSM_Error ATGEN_AddMemory        (GSM_StateMachine *s, GSM_MemoryEntry *entry);
        extern GSM_Error ATGEN_DeleteMemory     (GSM_StateMachine *s, GSM_MemoryEntry *entry);
        extern GSM_Error ATGEN_GetMemoryStatus  (GSM_StateMachine *s, GSM_MemoryStatus *Status);
        extern GSM_Error ATGEN_GetSMSC          (GSM_StateMachine *s, GSM_SMSC *smsc);
        extern GSM_Error ATGEN_SetSMSC          (GSM_StateMachine *s, GSM_SMSC *smsc);
        extern GSM_Error ATGEN_GetSMSFolders    (GSM_StateMachine *s, GSM_SMSFolders *folders);
        extern GSM_Error ATGEN_GetSMSStatus     (GSM_StateMachine *s, GSM_SMSMemoryStatus *status);
        extern GSM_Error ATGEN_GetSMS           (GSM_StateMachine *s, GSM_MultiSMSMessage *sms);
        extern GSM_Error ATGEN_GetNextSMS       (GSM_StateMachine *s, GSM_MultiSMSMessage *sms, bool start);
        extern GSM_Error ATGEN_SendSavedSMS     (GSM_StateMachine *s, int Folder, int Location);
        extern GSM_Error ATGEN_SendSMS          (GSM_StateMachine *s, GSM_SMSMessage *sms);
        extern GSM_Error ATGEN_DeleteSMS        (GSM_StateMachine *s, GSM_SMSMessage *sms);
        extern GSM_Error ATGEN_AddSMS           (GSM_StateMachine *s, GSM_SMSMessage *sms);
        extern GSM_Error ATGEN_GetBatteryCharge         (GSM_StateMachine *s, GSM_BatteryCharge *bat);
        extern GSM_Error ATGEN_GetSignalQuality         (GSM_StateMachine *s, GSM_SignalQuality *sig);
        extern GSM_Error ATGEN_DialVoice        (GSM_StateMachine *s, char *number, GSM_CallShowNumber ShowNumber);
        extern GSM_Error ATGEN_AnswerCall       (GSM_StateMachine *s, int ID, bool all);
        extern GSM_Error ATGEN_CancelCall       (GSM_StateMachine *s, int ID, bool all);
        extern GSM_Error ATGEN_SetDateTime      (GSM_StateMachine *s, GSM_DateTime *date_time);
        extern GSM_Error ATGEN_EnterSecurityCode(GSM_StateMachine *s, GSM_SecurityCode Code);
        extern GSM_Error ATGEN_GetSecurityStatus(GSM_StateMachine *s, GSM_SecurityCodeType *Status);
        extern GSM_Error ATGEN_ResetPhoneSettings(GSM_StateMachine *s, GSM_ResetSettingsType Type);
        extern GSM_Error ATGEN_SendDTMF                 (GSM_StateMachine *s, char *sequence);
        extern GSM_Error ATGEN_GetSIMIMSI       (GSM_StateMachine *s, char *IMSI);
        extern GSM_Error ATGEN_HandleCMSError   (GSM_StateMachine *s);
        extern GSM_Error ATGEN_GetNetworkInfo   (GSM_StateMachine *s, GSM_NetworkInfo *netinfo);
        extern GSM_Error ATGEN_Reset            (GSM_StateMachine *s, bool hard);
        extern GSM_Error ATGEN_PressKey                 (GSM_StateMachine *s, GSM_KeyCode Key, bool Press);
        extern GSM_Error ATGEN_GetDisplayStatus         (GSM_StateMachine *s, GSM_DisplayFeatures *features);
        extern GSM_Error ATGEN_SetAutoNetworkLogin(GSM_StateMachine *s);
        extern GSM_Error ATGEN_DeleteAllMemory  (GSM_StateMachine *s, GSM_MemoryType type);
        extern GSM_Error ATGEN_DispatchMessage  (GSM_StateMachine *s);
        extern GSM_Error ATGEN_SetFastSMSSending(GSM_StateMachine *s, bool enable);
        extern GSM_Error ATGEN_SetIncomingCB    (GSM_StateMachine *s, bool enable);
        extern GSM_Error ATGEN_SetIncomingSMS   (GSM_StateMachine *s, bool enable);
 /**
 * Alcatel uses some 8-bit characters in contacts, calendar etc.. This table
 * attempts to decode it, it is probably not complete, here are just chars
 * that I found...
 */
 unsigned char GSM_AlcatelAlphabet[] =
 {
        /*      in phone        unicode                 description*/
                0x80,           0x00,0x20,      /* empty */
                0x81,           0x00,0x20,      /* empty*/
                0x82,           0x00,0x20,      /* empty*/
                0x83,           0x00,0x20,      /* empty*/
                0x84,           0x00,0xe7,      /* c cedilla*/
                0x85,           0x20,0x26,      /* ...  */
                0x86,           0x03,0xc0,      /* pi   */
                0x87,           0x01,0x3e,      /* l caron*/
                0x88,           0x00,0xc0,      /* A grave*/
                0x89,           0x00,0xc1,      /* A acute*/
                0x8a,           0x00,0xc2,      /* A circumflex*/
                0x8b,           0x00,0xc3,      /* A tilde*/
                0x8c,           0x00,0xc8,      /* E grave*/
                0x8d,           0x00,0xca,      /* E circumflex*/
                0x8e,           0x00,0xcb,      /* E diaresis*/
                0x8f,           0x00,0xcc,      /* I grave*/
                0x90,           0x00,0xcd,      /* I acute*/
                0x91,           0x00,0xd0,      /* ETH  */
                0x92,           0x00,0xd2,      /* O grave*/
                0x93,           0x00,0xd3,      /* O acute*/
                0x94,           0x00,0xd4,      /* O circumflex*/
                0x95,           0x00,0xd5,      /* O tilde*/
                0x96,           0x00,0xd9,      /* U grave*/
                0x97,           0x00,0xda,      /* U acute*/
                0x98,           0x00,0xe1,      /* a acute*/
                0x99,           0x00,0xe2,      /* a circumflex*/
                0x9a,           0x00,0xe3,      /* a tilde*/
                0x9b,           0x00,0xea,      /* e circumflex*/
                0x9c,           0x00,0xeb,      /* e diaresis*/
                0x9d,           0x00,0xed,      /* i acute*/
                0x9e,           0x00,0xee,      /* i circumflex*/
                0x9f,           0x00,0xef,      /* i diaresis*/
                0xa0,           0x00,0xf3,      /* o acute*/
                0xa1,           0x00,0xf4,      /* o circumflex*/
                0xa2,           0x00,0xf5,      /* o tilde*/
                0xa3,           0x00,0xfa,      /* u acute*/
                0xa4,           0x00,0xa2,      /* cent         */
                0xa5,           0x00,0x5b,      /* [    */
                0xa6,           0x01,0x59,      /* r caron*/
                0xa7,           0x01,0x0d,      /* c caron*/
                0xa8,           0x01,0x61,      /* s caron*/
                0xa9,           0x01,0x1b,      /* e caron*/
                0xaa,           0x01,0x6f,      /* u ring*/
                0xab,           0x00,0xfd,      /* y acute*/
                0xac,           0x00,0xf0,      /* eth  */
                0xad,           0x01,0x07,      /* c acute*/
                0xae,           0x01,0x19,      /* e ogonek*/
                0xaf,           0x01,0x05,      /* a ogonek*/
                0xb0,           0x01,0x7c,      /* z dot*/
                0xb1,           0x01,0x7a,      /* z acute*/
                0xb2,           0x01,0x5b,      /* s acute*/
                0xb3,           0x01,0x44,      /* n acute*/
                0xb4,           0x01,0x42,      /* l stroke*/
                0xb5,           0x00,0x20,      /* empty*/
                0xb6,           0x01,0x48,      /* n caron*/
                0xb7,           0x01,0x65,      /* t caron*/
                0xb8,           0x00,0x20,      /* empty*/
                0xb9,           0x01,0x7e,      /* z caron*/
                0xba,           0x01,0xe7,      /* g caron*/
                0xbb,           0x00,0x20,      /* empty*/
                0xbc,           0x00,0x20,      /* empty*/
                0xbd,           0x1e,0x20,      /* G macron*/
                0xbe,           0x1e,0x21,      /* g macron*/
                0xbf,           0x01,0x5e,      /* S cedilla*/
                0xc0,           0x01,0x5f,      /* s cedilla*/
                0xc1,           0x01,0x2f,      /* i ogonek*/ /* FIXME: not sure with this, it look like normal i */
                0xc2,           0x01,0x31,      /* i dotless*/
                0xc3,           0x01,0x68,      /* U tilde*/
                0xc4,           0x01,0x50,      /* O dbl acute*/
                0xc5,           0x01,0x69,      /* u tilde*/
                0xc6,           0x01,0x51,      /* o dbl acute*/
                0xc7,           0x27,0xa9,      /* =>   */
                0xc8,           0x27,0xa8,      /* filled =>*/
                0xc9,           0x00,0xd7,      /* x    */
                0xca,           0x00,0x5d,      /* ]    */
                0xcb,           0x26,0x0f,      /* phone*/
                0xcc,           0x01,0x0f,      /* d caron*/
                0xcd,           0x00,0x20,      /* empty*/
                0xce,           0x00,0x7e,      /* ~    */
                0xcf,           0x00,0x5c,      /* \    */
                0xd0,           0x00,0x5e,      /* ^    */
                0xd1,           0x00,0x20,      /* empty*/
                0xd2,           0x00,0x7b,      /* {    */
                0xd3,           0x00,0x7c,      /* |    */
                0xd4,           0x00,0x7d,      /* }    */
                0xd5,           0x00,0x20,      /* empty*/
                0xd6,           0x01,0x63,      /* t cedilla*/
                0xd7,           0x00,0x20,      /* empty*/
                0xd8,           0x00,0x20,      /* empty*/
                0xd9,           0x00,0x20,      /* empty*/
                0xda,           0x00,0x20,      /* empty*/
                0xdb,           0x00,0x20,      /* empty*/
                0xdc,           0x00,0x20,      /* empty*/
                0xdd,           0x00,0x20,      /* empty*/
                0xde,           0x00,0x20,      /* empty*/
                0xdf,           0x00,0x20,      /* empty*/
                0xe0,           0x00,0x20,      /* empty*/
                0xe1,           0x00,0x20,      /* two candles*/ /* FIXME */
                0xe2,           0x00,0x20,      /* empty*/
                0xe3,           0x00,0x20,      /* empty*/
                0xe4,           0x00,0x20,      /* empty*/
                0xe5,           0x01,0xce,      /* a caron*/
                0xe6,           0x01,0x01,      /* a macron*/
                0xe7,           0x01,0x13,      /* e macron*/
                0xe8,           0x01,0x2b,      /* i macron*/
                0xe9,           0x01,0x4d,      /* o macron*/
                0xea,           0x01,0x6b,      /* u macron*/
                0xeb,           0x00,0x41,      /* A    */
                0xec,           0x00,0x40,      /* @    */
                0xed,           0x00,0x20,/* some strange char :-) */ /* FIXME */
                0xee,           0x00,0x20,      /* big key stroken*/ /* FIXME */
                0xef,           0x00,0x20,      /* big key*/ /* FIXME */
                0xf0,           0x00,0x20,      /* empty*/
                0xf1,           0x00,0x31,      /* 1    */
                0xf2,           0x00,0x21,      /* bold !*/
                0xf3,           0x26,0x0e,      /* black phone*/
                0xf4,           0x00,0x26,      /* &    */
                0xf5,           0x23,0x7e,      /* bell         */
                0xf6,           0x26,0x6a,      /* note         */
                0xf7,           0x27,0x13,      /* okay inv*/ /* FIXME */
                0xf8,           0x27,0x13,      /* okay         */
                0xf9,           0x00,0x20,      /* empty*/
                0xfa,           0x00,0x20,      /* key  */ /* FIXME */
                0xfb,           0x00,0x20,      /* empty*/
                0xfc,           0x20,0xac,      /* Euro         */
                0xfd,           0x21,0x97,      /* NE arrow*/
                0xfe,           0x21,0x98,      /* SE arrow*/
                0xff,           0x00,0x20,      /* empty*/
                0x00,   0x00,0x00
 };
 /* This is being called from atgen */
        GSM_Error ALCATEL_ProtocolVersionReply(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                char            *str, *str2;
 /*
 * Reply received here looks like:
 * 1 "AT+CPROT=?"
 * 2 "+CPROT: 0,"V1.0",1"
 * 3 "+CPROT: 16,"V1.1",16"
 * 4 "OK"
 */
        switch (s->Phone.Data.Priv.ATGEN.ReplyState) {
                case AT_Reply_OK:
                        str = strstr(msg.Buffer, "\"V");
                        if (str == NULL) return ERR_UNKNOWNRESPONSE;
                        str += 2;
                        while((str2 = strstr(str, "\"V")) != NULL) str = str2 + 2;
                        if (strncmp(str, "1.0", 3) == 0) {
                                s->Phone.Data.Priv.ALCATEL.ProtocolVersion = V_1_0;
                        } else if (strncmp(str, "1.1", 3) == 0) {
                                s->Phone.Data.Priv.ALCATEL.ProtocolVersion = V_1_1;
                        } else {
                                smprintf(s, "Unknown protocol version. Please send debug log and phone info to author.\n");
                                return ERR_NOTIMPLEMENTED;
                        }
                        return ERR_NONE;
                case AT_Reply_Error:
                case AT_Reply_CMSError:
                        return ATGEN_HandleCMSError(s);
                default:
                        return ERR_UNKNOWNRESPONSE;
        }
 }
 static GSM_Error ALCATEL_SetBinaryMode(GSM_StateMachine *s)
 {
                GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                GSM_Error       error;
        if (Priv->Mode == ModeBinary) return ERR_NONE;
        dbgprintf ("Changing to binary mode\n");
        error=GSM_WaitFor (s, "AT+IFC=2,2\r", 11, 0x02, 4, ID_SetFlowControl);
        if (error != ERR_NONE) return error;
        error=GSM_WaitFor (s, "AT+CPROT=?\r", 11, 0x02, 4, ID_AlcatelProtocol);
        if (error != ERR_NONE) return error;
        if (Priv->ProtocolVersion == V_1_0) {
                error=GSM_WaitFor (s, "AT+CPROT=16,\"V1.0\",16\r", 22, 0x00, 4, ID_AlcatelConnect);
        } else {
                error=GSM_WaitFor (s, "AT+CPROT=16,\"V1.1\",16\r", 22, 0x00, 4, ID_AlcatelConnect);
        }
        if (error == ERR_TIMEOUT && s->Speed != 19200) {
                smprintf(s, "HINT: Try changing speed to 19200, it is sometimes needed for Alcatel binary mode.\n");
        }
        if (error != ERR_NONE) return error;
        dbgprintf ("Changing protocol to Alcabus\n");
        s->Protocol.Functions = &ALCABUSProtocol;
        error = s->Protocol.Functions->Initialise(s);
        if (error != ERR_NONE) {
                s->Protocol.Functions = &ATProtocol;
                return error;
        }
                s->Phone.Functions->ReplyFunctions= ALCATELReplyFunctions;
                Priv->Mode                      = ModeBinary;
                Priv->BinaryItem                = 0;
                Priv->BinaryType                = 0;
                Priv->BinaryState               = StateAttached;
        return ERR_NONE;
 }
 static GSM_Error ALCATEL_GoToBinaryState(GSM_StateMachine *s, GSM_Alcatel_BinaryState state, GSM_Alcatel_BinaryType type, int item) {
                GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                GSM_Error       error;
                unsigned char   attach_buffer[] = {0x00, 0x00, 0x7C ,0x20};
                unsigned char   detach_buffer[] = {0x00, 0x01, 0x7C ,0x00};
                unsigned char   start_buffer[] =
                                        {0x00, 0x04, 0x7C, 0x80, /* 4 byte database id follows */
                                         0x12, 0x34, 0x56, 0x78};
                unsigned char   end_buffer[] =
                                        {0x00, 0x04, 0x7C, 0x82,
                                                 0x00,          /* type */
                                         0x00, 0x00, 0x00, 0x00}; /* TimeStamp */
                unsigned char   close_buffer[] =
                                        {0x00, 0x04,
                                                 0x00,                   /*type */
                                         0x23, 0x01};
                unsigned char   select1_buffer[] =
                                        {0x00, 0x00,
                                                 0x00,                   /*type */
                                         0x20};
                unsigned char   select2_buffer[] =
                                        {0x00, 0x04,
                                                 0x00,                   /*type */
                                         0x22, 0x01, 0x00};
                unsigned char   begin_buffer[] =
                                        {0x00, 0x04, 0x7C, 0x81,
                                                 0x00,           /*type */
                                         0x00, 0x85, 0x00};
                unsigned char   commit_buffer[] =
                                        {0x00, 0x04,
                                                 0x00,                  /*type */
                                         0x20, 0x01};
        smprintf(s, "Alcatel state switcher: %d -> %d, %d -> %d, %d -> %d\n", Priv->BinaryState, state, Priv->BinaryType, type, Priv->BinaryItem, item);
        error = ALCATEL_SetBinaryMode(s);
        if (error != ERR_NONE) return error;
        /* Do we need to do anything? */
        if ((state == Priv->BinaryState) && (type == Priv->BinaryType) && (item == Priv->BinaryItem)) return ERR_NONE;
        /* We're editing, but the next state is not the same. so commit editing */
        if (Priv->BinaryState == StateEdit) {
                /* Something has changed, we will have to reread fields! */
                Priv->CurrentFieldsItem  = -1;
                switch (Priv->BinaryType) {
                        case TypeCalendar:
                                commit_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                                break;
                        case TypeContacts:
                                commit_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                                break;
                        case TypeToDo:
                                commit_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                                break;
                }
                dbgprintf ("Commiting edited record\n");
                error=GSM_WaitFor (s, commit_buffer, 5, 0x02, ALCATEL_TIMEOUT, ID_AlcatelCommit);
                if (error != ERR_NONE) return error;
                error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelCommit2);
                if (error != ERR_NONE) return error;
                Priv->BinaryState = StateSession;
                Priv->BinaryItem = 0;
        }
        /* Do we want to edit something of same type? */
        if ((state == StateEdit) && (type == Priv->BinaryType)) {
                /* Edit state doesn't need any switching, it is needed only for
                 * indication that e have to commit record before we switch to other
                 * mode.
                 */
                Priv->BinaryState = StateEdit;
                Priv->BinaryItem = item;
                return ERR_NONE;
        }
        /* Now we can be only in Attached or Session state, so if states and types matches, just keep them as they are */
        if ((state == Priv->BinaryState) && (type == Priv->BinaryType)) {
                return ERR_NONE;
        }
        /* Do we need to close session? */
        if (Priv->BinaryState == StateSession) {
                dbgprintf ("Ending session\n");
                switch (Priv->BinaryType) {
                        case TypeCalendar:
                                        end_buffer[4] = ALCATEL_BEGIN_SYNC_CALENDAR;
                                break;
                        case TypeContacts:
                                        end_buffer[4] = ALCATEL_BEGIN_SYNC_CONTACTS;
                                break;
                        case TypeToDo:
                                        end_buffer[4] = ALCATEL_BEGIN_SYNC_TODO;
                                break;
                }
                error=GSM_WaitFor (s, end_buffer, 9, 0x02, ALCATEL_TIMEOUT, ID_AlcatelEnd);
                if (error != ERR_NONE) return error;
                switch (Priv->BinaryType) {
                        case TypeCalendar:
                                close_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                                break;
                        case TypeContacts:
                                close_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                                break;
                        case TypeToDo:
                                close_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                                break;
                }
                dbgprintf ("Closing session\n");
                error=GSM_WaitFor (s, close_buffer, 5, 0x02, ALCATEL_TIMEOUT, ID_AlcatelClose);
                if (error != ERR_NONE) return error;
                dbgprintf ("Detaching binary mode\n");
                GSM_WaitFor (s, detach_buffer, 4, 0x02, ALCATEL_TIMEOUT, ID_AlcatelDetach);
                Priv->BinaryState = StateAttached;
                Priv->BinaryType = 0;
        }
        /* Do we need to open session? */
        if (state == StateSession || state == StateEdit) {
                dbgprintf ("Starting session for %s\n",
                                (type == TypeCalendar ? "Calendar" :
                                (type == TypeToDo ? "Todo" :
                                (type == TypeContacts ? "Contacts" :
                                "Unknown!"))));
                /* Fill up buffers */
                switch (type) {
                        case TypeCalendar:
                                        select1_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                                        select2_buffer[2] = ALCATEL_SYNC_TYPE_CALENDAR;
                                        begin_buffer[4] = ALCATEL_BEGIN_SYNC_CALENDAR;
                                break;
                        case TypeContacts:
                                        select1_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                                        select2_buffer[2] = ALCATEL_SYNC_TYPE_CONTACTS;
                                        begin_buffer[4] = ALCATEL_BEGIN_SYNC_CONTACTS;
                                break;
                        case TypeToDo:
                                        select1_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                                        select2_buffer[2] = ALCATEL_SYNC_TYPE_TODO;
                                        begin_buffer[4] = ALCATEL_BEGIN_SYNC_TODO;
                                break;
                }
                dbgprintf ("Attaching in binary mode\n");
                /* Communicate */
                error=GSM_WaitFor (s, attach_buffer, 4, 0x02, ALCATEL_TIMEOUT, ID_AlcatelAttach);
                if (error != ERR_NONE) return error;
                smprintf(s,"Start session\n");
                error=GSM_WaitFor (s, start_buffer, 8, 0x02, ALCATEL_TIMEOUT, ID_AlcatelStart);
                if (error != ERR_NONE) return error;
                smprintf(s,"Select type\n");
                error=GSM_WaitFor (s, select1_buffer, 4, 0x02, ALCATEL_TIMEOUT, ID_AlcatelSelect1);
                if (error != ERR_NONE) return error;
                error=GSM_WaitFor (s, select2_buffer, 6, 0x02, ALCATEL_TIMEOUT, ID_AlcatelSelect2);
                if (error != ERR_NONE) return error;
                error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelSelect3);
                if (error != ERR_NONE) return error;
                smprintf(s,"Begin transfer\n");
                error=GSM_WaitFor (s, begin_buffer, 8, 0x02, ALCATEL_TIMEOUT, ID_AlcatelBegin1);
                if (error != ERR_NONE) return error;
                error=GSM_WaitFor (s, 0, 0, 0x00, ALCATEL_TIMEOUT, ID_AlcatelBegin2);
                if (error != ERR_NONE) return error;
                Priv->BinaryState = StateSession;
                Priv->BinaryType = type;
                /* Do we want to edit something of same type? */
                if ((state == StateEdit) && (type == Priv->BinaryType)) {
                        Priv->BinaryState = StateEdit;
                        Priv->BinaryItem = item;
                        return ERR_NONE;
                }
        }
        return ERR_NONE;
 }
 static GSM_Error ALCATEL_SetATMode(GSM_StateMachine *s)
 {
                GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                GSM_Error       error;
        if (Priv->Mode == ModeAT) return ERR_NONE;
        error = ALCATEL_GoToBinaryState(s, StateAttached, 0, 0);
        if (error != ERR_NONE) return error;
        error = s->Protocol.Functions->Terminate(s);
        if (error != ERR_NONE) return error;
        dbgprintf ("Changing protocol to AT\n");
                s->Protocol.Functions           = &ATProtocol;
                s->Phone.Functions->ReplyFunctions= ATGENReplyFunctions;
                Priv->Mode                      = ModeAT;
                s->Phone.Data.Priv.ATGEN.PBKCharset= 0;
                s->Phone.Data.Priv.ATGEN.PBKMemory= 0;
        my_sleep(100);
        /* In case we don't send AT command short after closing binary mode,
         * phone takes VERY long to react next time. The error code in
         * intetionally ignored.
         */
        GSM_WaitFor (s, "AT\r", 3, 0x00, 0, ID_IncomingFrame);
        return ERR_NONE;
 }
 static GSM_Error ALCATEL_Initialise(GSM_StateMachine *s)
 {
                GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                GSM_Error       error;
                Priv->Mode                      = ModeAT;
                Priv->CalendarItems             = NULL;
                Priv->ContactsItems             = NULL;
                Priv->ToDoItems                         = NULL;
                Priv->CalendarItemsCount        = 0;
                Priv->ToDoItemsCount            = 0;
                Priv->ContactsItemsCount        = 0;
                Priv->CurrentFields[0]          = 0;
                Priv->CurrentFieldsCount        = 0;
                Priv->CurrentFieldsItem                 = 0;
                Priv->CurrentFieldsType                 = 0;
                Priv->ProtocolVersion           = V_1_0;
                Priv->CurrentFieldsItem                 = -1;
                Priv->CurrentCategoriesCount    = 0;
                Priv->CurrentCategoriesType     = 0;
                s->Protocol.Functions           = &ATProtocol;
                s->Phone.Functions->ReplyFunctions= ATGENReplyFunctions;
        if (ATGEN_Initialise(s) != ERR_NONE || GSM_WaitFor (s, "AT\r", 3, 0x00, 2, ID_IncomingFrame) != ERR_NONE) {
                smprintf(s,"AT initialisation failed, trying to stop binary mode...\n");
                        s->Protocol.Functions   = &ALCABUSProtocol;
                error = s->Protocol.Functions->Terminate(s);
                        s->Protocol.Functions   = &ATProtocol;
                error = ATGEN_Initialise(s);
                if (error != ERR_NONE) return error;
        }
        return ERR_NONE;
 }
 static GSM_Error ALCATEL_Terminate(GSM_StateMachine *s)
 {
                GSM_Error       error;
                GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
        free(Priv->CalendarItems);
        free(Priv->ContactsItems);
        free(Priv->ToDoItems);
        error = ALCATEL_SetATMode(s);
        return ATGEN_Terminate(s);
 }
 /* finds whether id is set in the phone */
 static GSM_Error ALCATEL_IsIdAvailable(GSM_StateMachine *s, int id) {
                GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                int             i;
        if (id > ALCATEL_MAX_LOCATION) return ERR_INVALIDLOCATION;
        switch (Priv->BinaryType) {
                case TypeCalendar:
                                Priv->CurrentList = &(Priv->CalendarItems);
                                Priv->CurrentCount = &(Priv->CalendarItemsCount);
                        break;
                case TypeContacts:
                                Priv->CurrentList = &(Priv->ContactsItems);
                                Priv->CurrentCount = &(Priv->ContactsItemsCount);
                        break;
                case TypeToDo:
                                Priv->CurrentList = &(Priv->ToDoItems);
                                Priv->CurrentCount = &(Priv->ToDoItemsCount);
                        break;
        }
        for (i=0; i<*Priv->CurrentCount; i++) {
                if ((*Priv->CurrentList)[i] == id) return ERR_NONE;
        }
        return ERR_EMPTY;
 }
 /* finds next id that is available in the phone */
 static GSM_Error ALCATEL_GetNextId(GSM_StateMachine *s, int *id) {
                GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                int             i = 0;
                int             next = ALCATEL_MAX_LOCATION;
        switch (Priv->BinaryType) {
                case TypeCalendar:
                                Priv->CurrentList = &(Priv->CalendarItems);
                                Priv->CurrentCount = &(Priv->CalendarItemsCount);
                        break;
                case TypeContacts:
                                Priv->CurrentList = &(Priv->ContactsItems);
                                Priv->CurrentCount = &(Priv->ContactsItemsCount);
                        break;
                case TypeToDo:
                                Priv->CurrentList = &(Priv->ToDoItems);
                                Priv->CurrentCount = &(Priv->ToDoItemsCount);
                        break;
        }
        for (i=0; i<*Priv->CurrentCount; i++) {
                if (((*Priv->CurrentList)[i] > *id) && ((*Priv->CurrentList)[i] < next )) {
                        next = (*Priv->CurrentList)[i];
                }
        }
        if (next == ALCATEL_MAX_LOCATION) {
                return ERR_EMPTY;
        } else {
                *id = next;
                return ERR_NONE;
        }
 }
 static GSM_Error ALCATEL_ReplyGetIds(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                GSM_Phone_ALCATELData *Priv = &s->Phone.Data.Priv.ALCATEL;
                int             count,i,pos;
                count    = msg.Buffer[10];
        *Priv->CurrentCount += count;
        *Priv->CurrentList = (int *)realloc(*Priv->CurrentList, (*Priv->CurrentCount + 1)* sizeof(int));
        if (*Priv->CurrentList == NULL) return ERR_MOREMEMORY;
        for (i = 0; i < count; i++) {
                pos = 11 + (4 * i);
                (*Priv->CurrentList)[*Priv->CurrentCount - count + i] = msg.Buffer[pos + 3] +
                                                        (msg.Buffer[pos + 2] << 8) +
                                                        (msg.Buffer[pos + 1] << 16) +
                                                        (msg.Buffer[pos] << 24);
        }
        (*Priv->CurrentList)[*Priv->CurrentCount] = 0;
        /* If last byte is 0, then we transmitted all items */
        Priv->TransferCompleted = msg.Buffer[4 + msg.Buffer[4]] == 0;
        return ERR_NONE;
 }
 static GSM_Error ALCATEL_GetAvailableIds(GSM_StateMachine *s, bool refresh)
 {
                GSM_Phone_ALCATELData*Priv = &s->Phone.Data.Priv.ALCATEL;
                GSM_Error       error;
                int             i;
                unsigned char   buffer[] =
                                        {0x00, 0x04,
                                                 0x00,                  /*type */
                                         0x2F, 0x01};
        if (Priv->BinaryState != StateSession) return ERR_UNKNOWN;
        switch (Priv->BinaryType) {
                case TypeCalendar:
                                buffer[2]       = ALCATEL_SYNC_TYPE_CALENDAR;
                                Priv->CurrentList= &(Priv->CalendarItems);
                                Priv->CurrentCount= &(Priv->CalendarItemsCount);
                        break;
                case TypeContacts:
                                buffer[2]       = ALCATEL_SYNC_TYPE_CONTACTS;
                                Priv->CurrentList= &(Priv->ContactsItems);
                                Priv->CurrentCount= &(Priv->ContactsItemsCount);
                        break;
                case TypeToDo:
                                buffer[2]       = ALCATEL_SYNC_TYPE_TODO;
                                Priv->CurrentList= &(Priv->ToDoItems);
                                Priv->CurrentCount= &(Priv->ToDoItemsCount);
                        break;
        }
        if (*Priv->CurrentList != NULL) {
                if (!refresh) return ERR_NONE;
                free(*Priv->CurrentList);
                *Priv->CurrentList = NULL;
        }
        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);
diff --git a/gammu/emb/gammu/depend/nokia/dct3.c b/gammu/emb/gammu/depend/nokia/dct3.c
index b9e47ea..bda7532 100644
--- a/gammu/emb/gammu/depend/nokia/dct3.c
+++ b/gammu/emb/gammu/depend/nokia/dct3.c
@@ -1,807 +1,807 @@
 /* (c) 2002-2004 by Marcin Wiacek */
 /* MSID by Walek */
 #include "../../../common/gsmstate.h"
 #ifdef GSM_ENABLE_NOKIA_DCT3
 #include <string.h>
 #include <signal.h>
 #include "../../../common/misc/coding/coding.h"
 #include "../../../common/gsmcomon.h"
 #include "../../../common/service/gsmpbk.h"
 #include "../../../common/phone/nokia/dct3/dct3func.h"
 #include "../../../common/phone/pfunc.h"
 #include "../../gammu.h"
-extern GSM_Reply_Function UserReplyFunctions3[];
+static GSM_Reply_Function UserReplyFunctions3[];
 /* ------- some usefull functions ----------------------------------------- */
 GSM_Error CheckDCT3Only()
 {
        bool found = false;
        /* Checking if phone is DCT3 */
 #ifdef GSM_ENABLE_NOKIA6110
        if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true;
 #endif
 #ifdef GSM_ENABLE_NOKIA7110
        if (strstr(N7110Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true;
 #endif
 #ifdef GSM_ENABLE_NOKIA9210
        if (strstr(N9210Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true;
 #endif
        if (!found) return ERR_NOTSUPPORTED;
                if (s.ConnectionType!=GCT_MBUS2    && s.ConnectionType!=GCT_FBUS2      &&
            s.ConnectionType!=GCT_FBUS2DLR3 && s.ConnectionType!=GCT_FBUS2BLUE  &&
            s.ConnectionType!=GCT_FBUS2IRDA && s.ConnectionType!=GCT_IRDAPHONET &&
            s.ConnectionType!=GCT_BLUEFBUS2) {
                return ERR_OTHERCONNECTIONREQUIRED;
        }
        return ERR_NONE;
 }
 static void CheckDCT3()
 {
        GSM_Error error;
        error = CheckDCT3Only();
        switch (error) {
        case ERR_NOTSUPPORTED:
                Print_Error(ERR_NOTSUPPORTED);
                break;
        case ERR_OTHERCONNECTIONREQUIRED:
                printf("Can't do it with current phone protocol\n");
                GSM_TerminateConnection(&s);
                exit(-1);
        default:
                break;
        }
 }
 static bool answer_yes3(char *text)
 {
            int         len;
            char        ans[99];
        while (1) {
                printf("%s (yes/no) ? ",text);
                len=GetLine(stdin, ans, 99);
                if (len==-1) exit(-1);
                if (mystrncasecmp(ans, "yes",0)) return true;
                if (mystrncasecmp(ans, "no" ,0)) return false;
        }
 }
 /* ------------------- functions ------------------------------------------- */
 static FILE *DCT3T9File;
 static GSM_Error DCT3_ReplyGetT9(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        int DCT3T9Size;
        DCT3T9Size = msg.Length - 6;
        fwrite(msg.Buffer+6,1,DCT3T9Size,DCT3T9File);
        return ERR_NONE;
 }
 void DCT3GetT9(int argc, char *argv[])
 {
                int      i;
        unsigned char req[] = {0x00, 0x01, 0xAE, 0x02, 0x00,
                                       0x00};/* Part number */
 //"00 01 AE 00" gets some control values
        if (CheckDCT3Only()!=ERR_NONE) return;
        DCT3T9File = fopen("T9", "w");      
        if (DCT3T9File == NULL) return;
        s.User.UserReplyFunctions=UserReplyFunctions3;
        for (i=0;i<5;i++) {
                req[5] = i;
                        error=GSM_WaitFor (&s, req, 6, 0x40, 4, ID_User3);      
                Print_Error(error);
        }
        fclose(DCT3T9File);
 }
 void DCT3VibraTest(int argc, char *argv[])
 {
        unsigned char ans[200];
        unsigned char SetLevel[4] = {0x00, 0x01, 0xA3,
                                             0xff};/* Level */
        if (CheckDCT3Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions3;
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
        error=GSM_WaitFor (&s, SetLevel, 4, 0x40, 4, ID_User3);
        Print_Error(error);
        printf("Press any key to continue...\n");
        GetLine(stdin, ans, 99);
        SetLevel[3] = 0x00;
        error=GSM_WaitFor (&s, SetLevel, 4, 0x40, 4, ID_User3);
 }
 static GSM_Error DCT3_ReplyPhoneTests(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        int i;
        for (i=0;i<msg.Buffer[3];i++) {
                switch (i) {
                case 0: printf("Unknown(%02i)                       ",i);break;
                        case 1: printf("MCU ROM checksum         (startup)");break;
                        case 2: printf("MCU RAM interface        (startup)");break;
                        case 3: printf("MCU RAM component                 ");break;
                        case 4: printf("MCU EEPROM interface     (startup)");break;
                        case 5: printf("MCU EEPROM component              ");break;
                        case 6: printf("Real Time Clock battery  (startup)");break;
                        case 7: printf("CCONT interface          (startup)");break;
                        case 8: printf("AD converter             (startup)");break;
                        case 9: printf("SW Reset                          ");break;
                        case 10:printf("Power Off                         ");break;
                        case 11:printf("Security Data                     ");break;
                        case 12:printf("EEPROM Tune checksum     (startup)");break;
                        case 13:printf("PPM checksum             (startup)");break;
                        case 14:printf("MCU download DSP         (startup)");break;
                        case 15:printf("DSP alive                (startup)");break;
                        case 16:printf("COBBA serial             (startup)");break;
                        case 17:printf("COBBA paraller           (startup)");break;
                        case 18:printf("EEPROM security checksum (startup)");break;
                        case 19:printf("PPM validity             (startup)");break;
                        case 20:printf("Warranty state           (startup)");break;
                        case 21:printf("Simlock check/SW version (startup)");break;
                        case 22:printf("IMEI check?                       ");break;/*from PC-Locals1.3.is OK?*/
                default:printf("Unknown(%02i)                       ",i);break;
                }
                switch (msg.Buffer[4+i]) {
                        case 0:   printf(" : passed");                          break;
                        case 0xff:printf(" : not executed");                    break;
                        case 254: printf(" : fail");                            break;
                        default:  printf(" : result unknown(%i)",msg.Buffer[4+i]);break;
                }
                printf("\n");
        }
        return ERR_NONE;
 }
 void DCT3SelfTests(int argc, char *argv[])
 {
                unsigned char buffer[3]  = {0x00,0x01,0xcf};
                unsigned char buffer3[8] = {0x00,0x01,0xce,0x1d,0xfe,0x23,0x00,0x00};
                int     i;
        if (CheckDCT3Only()!=ERR_NONE) return;
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
        if (answer_yes3("Run all tests now ?")) {
                /* make almost all tests */
                error = s.Protocol.Functions->WriteMessage(&s, buffer3, 8, 0x40);
                Print_Error(error);
        
                GSM_Terminate();
                while (!false) {
                        GSM_Init(false);
                        if (error==ERR_NONE) break;
                        GSM_Terminate();
                }
                my_sleep(400);
        }
        s.User.UserReplyFunctions=UserReplyFunctions3;
        for (i=0;i<10;i++) {
                        error=GSM_WaitFor (&s, buffer, 3, 0x40, 4, ID_User1);
                if (error == ERR_NONE) break;
        }
 }
 struct DCT3ADCInfo {
                char *name;
                char *unit;
                int x;
                intpos1;
                intpos2;
 };
 static struct DCT3ADCInfo DCT3ADC[] = {
                {"Battery voltage:",            "mV",  1,  3,  2},
        //      {"Charger voltage:",                    "mV",  1, -1,  7},  
        //      {"Charger current:",            "mA",  1, -1,  5},
                {"Battery type:",               "mAh", 1,  4,  3},
                {"Battery temperature:",        "mK", 10,  5,  4},
        //      {"Accessory detection:",        "mV",  1, -1, -1},
                {"RSSI:",                       "",    1,  2, -1},
        //      {"VCXO temperature:",           "mV",  1, -1, -1},
        //      {"Hook information:",           "mV",  1, -1, -1},
        {"", "", 1, -1, -1}
 };
        unsigned char DCT3ADCBuf[200];
        int     DCT3ADCInt;
 static GSM_Error DCT3_ReplyGetADC(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        switch (msg.Buffer[2]) {
        case 0x68:
                memcpy(DCT3ADCBuf,msg.Buffer+4,msg.Length-4);
                return ERR_NONE;
        case 0x91:
                DCT3ADCInt = msg.Buffer[4]*256+msg.Buffer[5];
                return ERR_NONE;
        }
        return ERR_UNKNOWNRESPONSE;
 }
 void DCT3GetADC(int argc, char *argv[])
 {
                int     i = 0;
                unsigned charGetRaw[] = {0x00, 0x01, 0x68};
                unsigned charGetUnit[] = {0x00, 0x01, 0x91,
                                             0x02};     /* Test number */
        if (CheckDCT3Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions3;
        error=DCT3_EnableSecurity (&s, 0x02);
        Print_Error(error);
                error=GSM_WaitFor (&s, GetRaw, 3, 0x40, 6, ID_User3);   
        Print_Error(error);
        while (1) {
                printf(" %30s ",DCT3ADC[i].name);
                if (DCT3ADC[i].pos1 != -1) {
                        printf("raw ");
                        printf("%10i ",
                                DCT3ADCBuf[(DCT3ADC[i].pos1-1)*2]*256+
                                DCT3ADCBuf[(DCT3ADC[i].pos1-1)*2+1]);
                }
                if (DCT3ADC[i].pos2 != -1) {
                        printf("unit result ");
                        GetUnit[3] = DCT3ADC[i].pos2;
                                error=GSM_WaitFor (&s, GetUnit, 6, 0x40, 4, ID_User3);  
                        Print_Error(error);
                        printf("%10i ",DCT3ADCInt*DCT3ADC[i].x);
                        printf("%s\n",DCT3ADC[i].unit);
                }
                i++;
                if (DCT3ADC[i].name[0] == 0x00) break;
        }
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
 }
 void DCT3DisplayTest(int argc, char *argv[])
 {
        unsigned char ans[200];
        unsigned char req[] =  {0x00, 0x01, 0xD3,
                                        0x03,          /* 3=set, 2=clear */
                                        0x03};   /* test number */
        if (CheckDCT3Only()!=ERR_NONE) return;
        if (atoi(argv[2]) != 1 && atoi(argv[2]) != 2) {
                printf("Give 1 or 2 as test number\n");
        }
        s.User.UserReplyFunctions=UserReplyFunctions3;
        req[4] = atoi(argv[2]);
        s.Protocol.Functions->WriteMessage(&s, req, 5, 0x40);
        printf("Press any key to continue...\n");
        GetLine(stdin, ans, 99);
        req[3] = 0x02;
        req[4] = 0x03;
        s.Protocol.Functions->WriteMessage(&s, req, 5, 0x40);
        error=DCT3_EnableSecurity (&s, 0x03);
        Print_Error(error);
 }
 void DCT3netmonitor(int argc, char *argv[])
 {
        char value[100];
        GSM_Init(true);
        CheckDCT3();
        error=DCT3_Netmonitor(&s, atoi(argv[2]), value);
        Print_Error(error);
        printf("%s\n",value);
 #ifdef GSM_ENABLE_BEEP
        if (atoi(argv[2]) == 243) GSM_PhoneBeep();
 #endif
        GSM_Terminate();
 }
 static GSM_Error DCT3_ReplyGetMSID(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        int i;
        printf("MSID          : ");
        for (i=5;i<18;i++) printf("%02x",msg.Buffer[i]);
        printf("\n");
        return ERR_NONE;
 }
 static GSM_Error DCT3_ReplyGetDSPROM(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        printf("DSP ROM       : %c\n",msg.Buffer[5]);
        return ERR_NONE;
 }
 static GSM_Error DCT3_ReplySimlockInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                inti, j;  
                charuni[100], buffer[50];    
        j=0;
        for (i=0; i < 12; i++) {
                if (j<24) {
                        uni[j]='0' + (msg.Buffer[9+i] >> 4);
                        j++;
                }
                if (j!=15) {
                        if (j<24) {
                                uni[j]='0' + (msg.Buffer[9+i] & 0x0f);
                                j++;
                        }
                } else j++;
        }
        strncpy(buffer,uni,5);
        buffer[5]=0;
        printf("Simlock 1     : MCC+MNC %10s, %s, %s, counter %i\n",
                buffer,
                ((msg.Buffer[6] & 1) == 1)==0?"opened":"CLOSED",
                ((msg.Buffer[5] & 1) != 1)==0?"user   ":"factory",
                msg.Buffer[21]);
        strncpy(buffer,uni+16,4);
        buffer[4]=0;
        printf("Simlock 2     : GID1    %10s, %s, %s, counter %i\n",
                buffer,
                ((msg.Buffer[6] & 4) == 4)==0?"opened":"CLOSED",
                ((msg.Buffer[5] & 4) != 4)==0?"user   ":"factory",
                msg.Buffer[23]);
        strncpy(buffer,uni+20,4);
        buffer[4]=0;
        printf("Simlock 3     : GID2    %10s, %s, %s, counter %i\n",
                buffer,
                ((msg.Buffer[6] & 8) == 8)==0?"opened":"CLOSED",
                ((msg.Buffer[5] & 8) != 8)==0?"user   ":"factory",
                msg.Buffer[24]);
        strncpy(buffer,uni+5,10);
        buffer[10]=0;
        printf("Simlock 4     : MSIN    %10s, %s, %s, counter %i\n",
                buffer,
                ((msg.Buffer[6] & 2) == 2)==0?"opened":"CLOSED",
                ((msg.Buffer[5] & 2) != 2)==0?"user   ":"factory",
                msg.Buffer[22]);
        return ERR_NONE;
 }
 static GSM_Error DCT3_ReplyGetMCUchkSum(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        int i;
        
        if (msg.Buffer[3] == 0x12) printf("Language Pack: %c\n",msg.Buffer[5]);
        if (msg.Buffer[3] == 0x02) {
                printf("MCU checksum  : ");
                for (i=5;i<9;i++) printf("%c",msg.Buffer[i]);
                printf("\n");
        }
        return ERR_NONE;
 }
 static unsigned char MSID1;
 GSM_Error DCT3_ReplyEnableSecurity2(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        smprintf(s, "State of security commands set\n");
        MSID1 = msg.Buffer[5];
        return ERR_NONE;
 }
 void DCT3Info(int argc, char *argv[])
 {
                unsigned char           req[]           = {0x00, 0x01, 0x8A, 0x00};   /* Get simlock info */
                unsigned char   req2[]  = {0x00, 0x01, 0xb4, 0x00, 0x00}; /* Get MSID */
                unsigned char           req3[]  = {0x00, 0x01, 0xc8, 0x02};   /* Get MCU chksum */
                unsigned char           req4[]  = {0x00, 0x01, 0xc8, 0x09};   /* Get DSP ROM */
        if (CheckDCT3Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions3;
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
        error=GSM_WaitFor (&s, req, 4, 0x40, 4, ID_User3);
        Print_Error(error);
        req2[3] = MSID1;
        req2[4] = req2[2] + req2[3];
         error=GSM_WaitFor (&s, req2, 5, 0x40, 4, ID_User8);
        Print_Error(error);
        error=GSM_WaitFor (&s, req3, 4, 0x40, 4, ID_User9);
        Print_Error(error);
        error=GSM_WaitFor (&s, req4, 4, 0x40, 4, ID_User10);
        Print_Error(error);
 }
 static GSM_Error DCT3_ReplyResetTest36(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        printf("Netmonitor test 36 cleaned OK\n");
        return ERR_NONE;
 }
 void DCT3ResetTest36(int argc, char *argv[])
 {
        unsigned char req[]  = {0x00, 0x01, 0x65, 0x40, 0x00}; /* Reset test 36 in netmon */
        GSM_Init(true);
        CheckDCT3();
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
        s.User.UserReplyFunctions=UserReplyFunctions3;
        error=GSM_WaitFor (&s, req, 5, 0x40, 4, ID_User2);
        Print_Error(error);
 #ifdef GSM_ENABLE_BEEP
        GSM_PhoneBeep();
 #endif
        GSM_Terminate();
 }
 static unsigned char PPS[32]; /* Product Profile Settings */
 static GSM_Error DCT3_ReplyGetPPS(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        int i,j,z;
 #ifdef DEBUG
        dbgprintf("Product Profile Settings received -");
        for (i=0;i<4;i++) dbgprintf(" %02x",msg.Buffer[3+i]);
        dbgprintf("\n");
 #endif
        j=128;z=0;
        for (i=0;i<32;i++) {
                PPS[i]='0';
                if (msg.Buffer[z+3]&j) PPS[i]='1';
                if (j==1) {
                        j=128;
                        z++;
                } else j=j/2;
        }
 #ifdef DEBUG
        dbgprintf("After decoding: ");
        for (i=0;i<32;i++) dbgprintf("%c",PPS[i]);
        dbgprintf("\n");
 #endif
        return ERR_NONE;
 }
 static GSM_Error DCT3_ReplySetPPS(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        printf("Setting done OK\n");
        return ERR_NONE;
 }
 void DCT3SetPhoneMenus(int argc, char *argv[])
 {
                char    value[100];
                int     i,j,z;
                unsigned char reqGet[] = {0x00, 0x01, 0x6a};
                unsigned char reqSet[] = {
                0x00, 0x01, 0x6b,
                0x00, 0x00, 0x00, 0x00 }; /* bytes with Product Profile Setings */
        if (CheckDCT3Only()!=ERR_NONE) return;
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
        s.User.UserReplyFunctions=UserReplyFunctions3;
        error=GSM_WaitFor (&s, reqGet, 3, 0x40, 4, ID_User4);
        Print_Error(error);
        printf("ALS : enabling menu\n");
        PPS[10] = '1';
        if (!strcmp(s.Phone.Data.ModelInfo->model,"3310") && s.Phone.Data.VerNum>5.87) {
                printf("3310: enabling control of SMS charsets\n");
                PPS[11] = '0';//0 = ON, 1 = OFF
        }
        if (!strcmp(s.Phone.Data.ModelInfo->model,"6150")) {
                printf("6150: enabling WellMate menu\n");
                PPS[18] = '1';
        }
        /* FIXME */
        if (!strcmp(s.Phone.Data.ModelInfo->model,"3210")) {
                printf("3210: enabling vibra menu\n");
                PPS[24] = '1';
        }
        if (!strcmp(s.Phone.Data.ModelInfo->model,"3310") && s.Phone.Data.VerNum>5.13) {
                printf("3310: enabling 3315 features\n");
                PPS[25] = '1';
        }
        /* FIXME */
        if (!strcmp(s.Phone.Data.ModelInfo->model,"3210") && s.Phone.Data.VerNum>=5.31) {
                printf("3210: enabling React and Logic game\n");
                        PPS[26] = '1';  
        }
 #ifdef DEBUG
        dbgprintf("After settings: ");
        for (i=0;i<32;i++) dbgprintf("%c",PPS[i]);
        dbgprintf("\n");
 #endif
        j=128;z=0;
        for (i=0;i<32;i++) {
                if (PPS[i]=='1') reqSet[z+3]=reqSet[z+3]+j;
                if (j==1) {
                        j=128;
                        z++;
                } else j=j/2;
        } 
        //reqSet[3]=0xe7;
        //reqSet[4]=0x25;
        //reqSet[5]=0x00;
        //reqSet[6]=0xe0;
        error=GSM_WaitFor (&s, reqSet, 7, 0x40, 4, ID_User4);
        Print_Error(error);
        printf("Enabling netmonitor\n");
        error=DCT3_Netmonitor(&s, 243, value);
        Print_Error(error);
 }
 static GSM_Error DCT3_Reply61GetSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        printf("Security Code is \"%s\"\n",msg.Buffer+5);
        return ERR_NONE;
 }
 static GSM_Error DCT3_Reply7191GetSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        printf("Security Code is \"%s\"\n",msg.Buffer+6);
        return ERR_NONE;
 }
 void DCT3GetSecurityCode(int argc, char *argv[])
 {
 #ifdef GSM_ENABLE_NOKIA6110
        unsigned char req6110[] = {0x00, 0x01, 0x6e,
                                           0x01};/* Code type */
 #endif
 #if defined(GSM_ENABLE_NOKIA7110) || defined(GSM_ENABLE_NOKIA9210)
        unsigned char req71_91[] = {N7110_FRAME_HEADER, 0xee,
                                            0x1c};/* Setting */
 #endif
        if (CheckDCT3Only()!=ERR_NONE) return;
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
        s.User.UserReplyFunctions=UserReplyFunctions3;
 #ifdef GSM_ENABLE_NOKIA6110
        if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) != NULL) {
                error=GSM_WaitFor (&s, req6110, 4, 0x40, 4, ID_User6);
        }
 #endif
 #ifdef GSM_ENABLE_NOKIA7110
        if (strstr(N7110Phone.models, s.Phone.Data.ModelInfo->model) != NULL) {
                error=GSM_WaitFor (&s, req71_91, 5, 0x7a, 4, ID_User6);
        }
 #endif
 #ifdef GSM_ENABLE_NOKIA9210
        if (strstr(N9210Phone.models, s.Phone.Data.ModelInfo->model) != NULL) {
                error=GSM_WaitFor (&s, req71_91, 5, 0x7a, 4, ID_User6);
        }
 #endif
        Print_Error(error);
 }
 #ifdef GSM_ENABLE_NOKIA6110
 static GSM_Error DCT3_ReplyGetOperatorName(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        unsigned char buffer[10];
        NOKIA_DecodeNetworkCode(msg.Buffer+5, buffer);
        buffer[6] = 0;
                printf("Network           : %s (%s ",buffer,DecodeUnicodeString(GSM_GetNetworkName(buffer)));
                printf(", %s)\n",               DecodeUnicodeString(GSM_GetCountryName(buffer)));
        printf("Name              : \"%s\"\n",msg.Buffer+8);
        return ERR_NONE;
 }
 void DCT3GetOperatorName(int argc, char *argv[])
 {
        unsigned char req[] = {0x00,0x01,0x8c,0x00};
        GSM_Init(true);
        if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) == NULL) Print_Error(ERR_NOTSUPPORTED);
        CheckDCT3();
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
        s.User.UserReplyFunctions=UserReplyFunctions3;
        error=GSM_WaitFor (&s, req, 4, 0x40, 4, ID_User5);
        Print_Error(error);
        GSM_Terminate();
 }
 static GSM_Error DCT3_ReplySetOperatorName(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        printf("Operator name set OK\n");
        return ERR_NONE;
 }
 void DCT3SetOperatorName(int argc, char *argv[])
 {
                int     i = 0;
                unsigned char req[256] = {0x00,0x01,0x8b,0x00,
                                    0x00,0x00, /* MCC */
                                    0x00};     /* MNC */
        GSM_Init(true);
        if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) == NULL) Print_Error(ERR_NOTSUPPORTED);
        CheckDCT3();
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
        s.User.UserReplyFunctions=UserReplyFunctions3;
        switch (argc) {
        case 2:
                case 3:NOKIA_EncodeNetworkCode(req+4,"000 00");
                req[7] = 0x00;
                i = 1;
                break;
        case 4: NOKIA_EncodeNetworkCode(req+4,argv[2]);
                strncpy(req+7,argv[3],200);
                i = strlen(argv[3]);
        }
    
        error=GSM_WaitFor (&s, req, 8+i, 0x40, 4, ID_User7);
        Print_Error(error);
        GSM_Terminate();
 }
 static GSM_Error DCT3_ReplyDisplayOutput(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        unsigned char buf[100];
        switch (msg.Buffer[3]) {
        case 0x50:
                dbgprintf("Display string received\n");
                memcpy(buf,msg.Buffer+8,msg.Buffer[7]*2);
                buf[msg.Buffer[7]*2]   = 0;
                buf[msg.Buffer[7]*2+1] = 0;
                printf("X=%i, Y=%i, Text=\"%s\"\n",msg.Buffer[6],msg.Buffer[5],DecodeUnicodeString(buf));
                return ERR_NONE;
        case 0x54:
                dbgprintf("Display output set\n");
                return ERR_NONE;
        }
        return ERR_UNKNOWNRESPONSE;
 }
 void DCT3DisplayOutput(int argc, char *argv[])
 {
        unsigned char req[] = {N6110_FRAME_HEADER, 0x53,
                               0x01}; //1 = enable, 2 = disable
        GSM_Init(true);
        if (strstr(N6110Phone.models, s.Phone.Data.ModelInfo->model) == NULL) Print_Error(ERR_NOTSUPPORTED);
        CheckDCT3();
        s.User.UserReplyFunctions=UserReplyFunctions3;
        error=GSM_WaitFor (&s, req, 5, 0x0d, 4, ID_User7);
        Print_Error(error);
        signal(SIGINT, interrupt);
        printf("Press Ctrl+C to break...\n");
        printf("Entering monitor mode...\n\n");
        while (!gshutdown) {
                GSM_ReadDevice(&s,true);
                my_sleep(10);
        }
        req[4] = 0x02;
        error=GSM_WaitFor (&s, req, 5, 0x0d, 4, ID_User7);
        Print_Error(error);
        GSM_Terminate();
 }
 #endif
 static GSM_Reply_Function UserReplyFunctions3[] = {
 #ifdef GSM_ENABLE_NOKIA6110
                {DCT3_ReplyDisplayOutput,       "\x0D",0x03,0x50,ID_IncomingFrame},
                {DCT3_ReplyDisplayOutput,       "\x0D",0x03,0x54,ID_User7        },
 #endif
                {DCT3_ReplyEnableSecurity2,     "\x40",0x02,0x64,ID_EnableSecurity},
                {DCT3_ReplyResetTest36,                 "\x40",0x02,0x65,ID_User2        },
                {DCT3_ReplyGetADC,              "\x40",0x02,0x68,ID_User3        },
                {DCT3_ReplyGetPPS,              "\x40",0x02,0x6A,ID_User4        },
                {DCT3_ReplySetPPS,              "\x40",0x02,0x6B,ID_User4        },
                {DCT3_Reply61GetSecurityCode,   "\x40",0x02,0x6E,ID_User6        },
                {DCT3_ReplySimlockInfo,                 "\x40",0x02,0x8A,ID_User3        },
 #ifdef GSM_ENABLE_NOKIA6110
                {DCT3_ReplySetOperatorName,     "\x40",0x02,0x8B,ID_User7        },
                {DCT3_ReplyGetOperatorName,     "\x40",0x02,0x8C,ID_User5        },
 #endif
                {DCT3_ReplyGetADC,              "\x40",0x02,0x91,ID_User3        },
                {NoneReply,                     "\x40",0x02,0xA3,ID_User3       },
                {DCT3_ReplyGetT9,               "\x40",0x02,0xAE,ID_User3       },
                {DCT3_ReplyGetMSID,             "\x40",0x02,0xb5,ID_User8        },
                {DCT3_ReplyGetDSPROM,           "\x40",0x02,0xC8,ID_User10       },
                {DCT3_ReplyGetMCUchkSum,        "\x40",0x02,0xC8,ID_User9        },
                {DCT3_ReplyPhoneTests,          "\x40",0x02,0xCF,ID_User1        },
                {DCT3_Reply7191GetSecurityCode,         "\x7a",0x04,0x1C,ID_User6        },
                {NULL,                          "\x00",0x00,0x00,ID_None         }
        };                                                                       
 #endif
 /* How should editor hadle tabs in this file? Add editor commands here.
 * vim: noexpandtab sw=8 ts=8 sts=8:
 */
diff --git a/gammu/emb/gammu/depend/nokia/dct3trac/wmx.c b/gammu/emb/gammu/depend/nokia/dct3trac/wmx.c
index 64eda37..e46d9dd 100644
--- a/gammu/emb/gammu/depend/nokia/dct3trac/wmx.c
+++ b/gammu/emb/gammu/depend/nokia/dct3trac/wmx.c
@@ -1,480 +1,480 @@
 /**
 * Nokia DCT3 Firmware Debug Trace Monitor
 * wumpus 2003 -- www.blacksphere.tk
 * SIM stuff by The Monty
 *
 * Command line arguments:
 * gammu --nokiadebug v00-0F,20,21
 * (v=verbose)
 */
 #include "../../../../common/gsmstate.h"
 #ifdef GSM_ENABLE_NOKIA_DCT3
 #include <string.h>
 #include <signal.h>
 #include "../../../../common/misc/coding/coding.h"
 #include "../../../../common/gsmcomon.h"
 #include "../../../../common/gsmstate.h"
 #include "../../../../common/service/gsmpbk.h"
 #include "../../../../common/phone/nokia/dct3/dct3func.h"
 #include "../../../gammu.h"
 #include "../dct3.h"
 #include "wmx.h"
 #include "wmx-util.h"
 #include "wmx-gsm.h"
 #include "wmx-sim.h"
 #include "wmx-list.h"
-extern GSM_Reply_Function UserReplyFunctionsX[];
+static GSM_Reply_Function UserReplyFunctionsX[];
 /* Global variables suck */
        GSMDecoder      *gsmdec;
        struct wmx_tracestruct *traces;
 static GSM_Error DCT3_ReplySwitchDebug(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        switch(msg.Buffer[2]) {
        case 0x70:
                printf("Debug Trace Enabled\n");
                break;
        case 0x71:
                printf("Debug Trace Disabled\n");
                break;
        }
        return ERR_NONE;
 }
 /**
 * RPC confirmation/reply
 */
 static GSM_Error DCT3_ReplyRPC(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        printf("RPC Reply ");
        printf("call=%02x rettype=%02x data=", msg.Buffer[2], msg.Buffer[3]);
        if(msg.Buffer[3] == 3) {
                /* string */
                printf("%s", &msg.Buffer[4]);
        } else {
                dumpraw("RPC Reply data", &msg.Buffer[4], msg.Length-4);
        }
        printf("\n");
        return ERR_NONE;
 }
 /* disassemble mdisnd (0x18xx) packet */
 static void mdisnd_data(unsigned char type, unsigned char *buffer, size_t length)
 {
                GSMDecoder_l1l2data dat;
                size_t                  x;
                int             ch;
        if(type==0x1B && length>2) {
                /* channel packet */
                        ch = buffer[1];
                        dat.tx = GSMDECODER_SEND;
                        dat.ch = ch;
                printf("%02X ch=%02X ",buffer[0],ch);
                if (ch == 0x80 || ch == 0xB0) {
                        printf("\n");
                        GSMDecoder_L2packet(gsmdec, &dat, &buffer[2], length-2);
                } else if (ch == 0x70) {
                        dumpraw("MDI send ch70 prefix", &buffer[2], 2);
                        printf("\n");
                        GSMDecoder_L2packet(gsmdec, &dat, &buffer[4], length-4);
                } else {
                        dumpraw("MDI recv 1B packet", &buffer[2], length-2);
                }
        } else {
                /* hex */
                for(x=0; x<length; x++) {
                        printf("%02x ",buffer[x]&0xFF);
                }
        }
 }
 /* disassemble mdircv (0x19xx) packet */
 static void mdircv_data(unsigned char type, unsigned char *buffer, size_t length)
 {
                size_t                  x;
                int             ch;
                GSMDecoder_l1l2data dat;
        if (type==0x80 && length>1) {
                // buffer[0]    channel
                // buffer[1]    flag1
                // buffer[2]    flag2
                // buffer[3..5] timestamp
                // buffer[6..7] unknown_hw1
                // buffer[8..9] unknown_hw2
                        ch       = buffer[0];
                        dat.tx           = GSMDECODER_RECEIVE;
                        dat.ch           = ch;
                        dat.bsic = buffer[1];
                        dat.err  = buffer[2];
                        dat.seq  = (buffer[3]<<16)|(buffer[4]<<8)|(buffer[5]);
                        dat.arfcn = (buffer[6]<<8)|buffer[7];
                        dat.timeshift = (buffer[8]<<8)|buffer[9];
                
                printf("ch=%02X bsic=%i err=%i t=%06X arfcn=%i shift=%i",
                        ch, buffer[1], buffer[2],
                        dat.seq, dat.arfcn, dat.timeshift
                );
                
                //dumpraw("MDI recv 80 header", &buffer[6], 4);
                printf(" ");
                if(buffer[2] == 0) { /* unencrypted */
                        if(ch == 0x70) {
                                /* Normal header + 2b prefix */
                                dumpraw("MDI recv ch70 prefix", &buffer[10], 2);
                                printf("\n");
                                GSMDecoder_L2packet(gsmdec, &dat, &buffer[12], length-12);
                        } else if (ch == 0x80 || ch == 0xB0) {
                                /* Normal header */
                                printf("\n");
                                GSMDecoder_L2packet(gsmdec, &dat, &buffer[10], length-10);
                        } else if (ch == 0x50 || ch == 0x60) {
                                /* Short header */
                                
                                printf("\n");
                                GSMDecoder_L2short_packet(gsmdec, &dat, &buffer[10], length-10);
                        } else {
                                dumpraw("MDI send 80 packet", &buffer[10], length-10);
                        }
                } else {
                        /* Encrypted (?) */
                        dumpraw("MDI send err 80", &buffer[10], length-10);
                }
        } else {
                /* hex */
                for(x=0; x<length; x++) {
                        printf("%02x ",buffer[x]&0xFF);
                }
        }
 }
 static GSM_Error DCT3_ReplyDebugTrace(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                int             x;
                int             id,timestamp,number,length;
                struct wmx_tracetype *minor;
                char            *desc;
        //printf("Debug Trace Received\n");
        /* parse frame 
           Debug trace packet:
           packet type 0x00
           source subsystem 0x01 (LOCAL)
           verder formaat zie notebook
           0x08 ID (payload=offset 0x02 here)
           0x0A timestamp
           0x0C seq nr
           0x0D .. parameters
        */
                id      = ((msg.Buffer[2]&0xFF)<<8)|(msg.Buffer[3]&0xFF);
                timestamp = ((msg.Buffer[4]&0xFF)<<8)|(msg.Buffer[5]&0xFF);
                number          = msg.Buffer[6]&0xFF;
                length          = msg.Buffer[7]&0xFF;
        /* filter */
        //if((id&0xFF00)==0x1900 && id != 0x1980)
                //return GE_NONE;
        //printf("%02x\n",msg.Buffer[10]);
        //if(msg.Buffer[10]!=0x40) 
                //return GE_NONE;
        /* Query trace type name */
        desc = "Unknown";
        if(traces != NULL) {
                minor = wmx_tracestruct_queryminor(traces, id);
                if(minor != NULL) desc = minor->desc;
        }
        printf("<%04X> %s\n", id, desc);
        printf("t=%04x nr=%02x: ", timestamp, number);
        /* TODO -- decode debug types on phone type */
        switch(id>>8) {
        case 0x33:
        case 0x34:
        case 0x35:
        case 0x37:
        case 0x38:
        case 0x39:
        case 0x3A:
        case 0x3B:
        case 0x3C:
        case 0x5F:
                /* text */
                /* skip length byte */
                printf("\"");
                for(x=8; x<msg.Length; x++) {
                        printf("%c",msg.Buffer[x]&0xFF);
                }
                printf("\"");
                break;
                /*
        case 0x6801:
                for(x=8; x<msg.Length; x++) {
                        printf("%02x%c ",msg.Buffer[x]&0xFF,msg.Buffer[x]&0xFF);
                }
                break;
                */
        case 0x18: /* MDISND */
                
                /* skip these:
                  +00 length
                  +01 type (also xx in 0x18xx)
                */
                if(msg.Length<10 || msg.Buffer[9]!=(id&0xFF)) {
                        printf("C %02X: param:%02x", id&0xFF, msg.Buffer[8]);
                } else {
                        //printf("D %02X: ", id&0xFF);
                        printf("D %02X: ", id&0xFF);
                        mdisnd_data((unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[10], msg.Length-10);
                }
                break;
        case 0x19: /* MDIRCV */
                if(msg.Length<10 || msg.Buffer[9]!=(id&0xFF)) {
                        printf("C %02X: param:%02x", id&0xFF, msg.Buffer[8]);
                } else {
                        printf("D %02X: ", id&0xFF);
                        mdircv_data((unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[10], msg.Length-10);
                        //dumpraw((unsigned char*)&msg.Buffer[10], msg.Length-10);
                }
                break;
         case 0x20: /* 0x25 SIM commands */
                /*
                for(x=8;x<msg.Length;x++) 
                    printf("%02x ", msg.Buffer[x]&0xFF);
                */
                printf("SIM command ");
                if(msg.Buffer[8]==0xa0) { // check if valid (class=a0) 
                        simCommand_data(msg.Buffer[9], (unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[10], msg.Length-10);
                                // TODO: pass the msg.Buffer[9] and skip 1rst arg 
                } else {
                        printf("Unknown 0x25 packet (NOT SIM cmd): ");
                        for(x=8;x<msg.Length;x++) printf("%02x ", msg.Buffer[x]&0xFF);
                        printf("\n");
                }
                break;
         case 0x22: /* 0x27 SIM answer to command (error/ok/etc..) */
                if(msg.Length<10) {
                            // Unknown response
                            for(x=0;x<msg.Length-10;x++) printf("%02x ", msg.Buffer[x]&0xFF);
                        printf(" (Unknown 0x27 packet ? ? )\n");
                } else {
                            simAnswer_Process((unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[8], length);
                }
                        break;          
                case 0x23:  /* 0x28 SIM response data to commands */    
                if(msg.Length<10) {
                            // Unknown response
                            for(x=0;x<msg.Length-10;x++) printf("%02x ", msg.Buffer[x]&0xFF);
                            printf(" (Unknown 0x28 packet)\n");
                } else {
                            simResponse_Process((unsigned char)(id&0xFF), (unsigned char*)&msg.Buffer[8], length);
                }
                break;
        default:
                        /* hex */       
                for(x=8; x<msg.Length; x++) {
                        printf("%02x ",msg.Buffer[x]&0xFF);
                        }       
                break;
        }
        printf("\n");
        return ERR_NONE;
 }
 static GSM_Error DCT3_ReplyMyPacket(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        int x;
        printf("MyPacket ");
        for(x=0; x<msg.Length; x++) {
                printf("%02x ",msg.Buffer[x]&0xFF);
        }
        printf("\n");
        return ERR_NONE;
 }
 #define ID_DebugTrace   0x666
 #define ID_DebugSwitch  0x667
        #define ID_RPC  0x668
 void DCT3SetDebug(int argc, char *argv[])
        {
                int     x,count;
        unsigned int y;
                unsigned char reqDisable[] = {0x01, 0x01, 0x71};
        //      unsigned char reqTest[] = {0x01, 0x01, 0x96, 0xFF, 0xFF};
        /* RPC testing packets: */
        /* RPC: Get version */
                //unsigned char reqTest2[] = {0x01, 0x01, 0x00, 0x03, 0x00}; 
        /* RPC: read I/O 0x6D mask 0xFF */
                //unsigned char reqTest2[] = {0x01, 0x01, 0x02, 0x01, 0x02, 0x6D, 0xFF}; /*  */
        /* RPC: write I/O 0x03 mask 0xFF value 0x31 */
                //unsigned char reqTest2[] = {0x01, 0x01, 0x01, 0x01, 0x07, 0x03, 0xFF, 0x31}; /* write I/O */
        /* RPC: write forged FBUS packet to MDISND */
        //      unsigned char reqTest2[] = {0x01, 0x01, 0x16, 0x01, 0x06,
        //0x14, // R0 -- length
        //0x05, // R1 -- MDI type identifier 0x05(FBUS)
        //0x1e, 0x0c, 0x00, 0x66,
        //0x00, 0x0e, 0x01, 0x01,
        //0x66, 0x55, 0x44, 0x33,
        //0x0d, 0x01, 0x01, 0x01,
        //0x1b, 0x58, 0x01, 0x44};
        //1805 t=cb37 nr=e2 :D 05: 
        /* debug enable packet */
        unsigned char reqEnable[] = {
                0x00, 0x01, 0x70,
                /* Debug bits
                   byte[bit>>3]&(1<<(7-(bit&7)))
                */
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00 */
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x40 */
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x80 */
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xC0 */
                /* Debug verbose bits 
                   byte[bit>>3]&(1<<(7-(bit&7)))
                */
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
                }; 
        #define ENABLE_BIT(bit,verbose) reqEnable[3 + (bit>>3)] |= 1<<(7-(bit&7)); if(verbose){reqEnable[3 + 32 + (bit>>3)] |= 1<<(7-(bit&7));}
        /* Enable some bit
           TODO command line or GUI interface
        */   
                //ENABLE_BIT(0x18, 1);/* Enable MDISND debugging */
                //ENABLE_BIT(0x19, 1);/* Enable MDIRCV debugging */
        //ENABLE_BIT(0x31, 1); 
        
        gsmdec = GSMDecoder_new();
        /* Open XML file .. needs to be argument */
        {
                FILE *xout = fopen("out.xml", "w");
                GSMDecoder_xmlout(gsmdec, xout);
        }
        printf("Debug Trace Mode -- wumpus 2003\n");
        traces = wmx_tracestruct_load(argv[2]);
        if(traces == NULL)
                printf("Warning: could not load trace description file %s\n", argv[2]);
        printf("Activating ranges:\n");
        count = 0;
        for(x=3; x<argc; x++) {
                        char    *ptr = argv[x];
                        unsigned from,to,verbose;
                while(*ptr) {
                         verbose = 0;
                        if(*ptr == 'v') {
                                verbose = 1;
                                ptr++;
                        }
                        to = from = strtol(ptr, &ptr, 16);
                        if(*ptr == '-') {
                                ptr ++;
                                to = strtol(ptr, &ptr, 16);
                        }
                        if(*ptr != ',' && *ptr != 0) {
                                printf("Invalid parameter '%s'\n", argv[x]);
                                return;
                        }
                        if(*ptr == ',')
                                ptr++;
                        if(from > 0xFF) from=0xFF;
                        if(to > 0xFF) to=0xFF;
                        printf("  %02x-%02x verbose=%i\n",from,to,verbose);
                        for(y=from; y<=to; y++) {
                                ENABLE_BIT(y, verbose);
                                count++;
                        }
                }
        }
        if(count == 0) {
                printf("Nothing activated -- bailing out\n");
                return;
        }
        //ENABLE_BIT(0x20, 1);  /* SIM commands (literal) */
        //ENABLE_BIT(0x21, 1);  /* SIML2 commands (literal) */
        //ENABLE_BIT(0x22, 1);  /* SIM commands (literal) */
                //ENABLE_BIT(0x3B, 1);/* PHCTRL state */
        GSM_Init(true);
        /* We Need DCT3 */
        if (CheckDCT3Only()!=ERR_NONE) return;
        error=DCT3_EnableSecurity (&s, 0x01);
        Print_Error(error);
        s.User.UserReplyFunctions=UserReplyFunctionsX;
        //error=GSM_WaitFor (&s, reqTest, sizeof(reqTest), 0x40, 1, ID_DebugSwitch);
        
        //error=GSM_WaitFor (&s, reqTest2, sizeof(reqTest2), 0xD1, 4, ID_RPC);
        /* Enable Debug Mode */
        error=GSM_WaitFor (&s, reqEnable, sizeof(reqEnable), 0x40, 4, ID_DebugSwitch);
        
        Print_Error(error);
        signal(SIGINT, interrupt);
        printf("Press Ctrl+C to interrupt...\n");
        x=0;
        
        /*
        while(x<100) {
                //printf(": %02x\n",x);
                        s.Phone.Data.RequestID= ID_DebugTrace;
                res = s.Device.Functions->ReadDevice(&s, buff, 255);
                if(res) {
                        printf("%02x\n",x);
                        for(y=0;y<res;y++) {
                                //printf("%02x\n",x,buff[y]&0xFF);
                                s.Protocol.Functions->StateMachine(&s,buff[y]);
                                x++;
                        }
                }
        }
        */
        ;
        /* todo: wait and dump for some time */
        while (!gshutdown) {
                GSM_ReadDevice(&s,true);
                my_sleep(10);
        }
        signal(SIGINT, SIG_DFL);
        printf("Disabling\n");
        error=GSM_WaitFor (&s, reqDisable, sizeof(reqDisable), 0x40, 10, ID_DebugSwitch);
        Print_Error(error);
        
        GSMDecoder_free(gsmdec);
 }
 static GSM_Reply_Function UserReplyFunctionsX[] = {
                {DCT3_ReplySwitchDebug,                 "\x40",0x02,0x70,ID_DebugSwitch         },
                {DCT3_ReplySwitchDebug,                 "\x40",0x02,0x71,ID_DebugSwitch         },
                {DCT3_ReplyDebugTrace,          "\x00",0x00,0x00,ID_IncomingFrame},
                {DCT3_ReplyMyPacket,            "\x40",0x00,0x00,ID_IncomingFrame},
                {DCT3_ReplyRPC,                         "\xD2",0x00,0x00,ID_RPC                 },
                {NULL,                          "\x00",0x00,0x00,ID_None        }
        };                                                                       
 #endif
 /* How should editor hadle tabs in this file? Add editor commands here.
 * vim: noexpandtab sw=8 ts=8 sts=8:
 */
diff --git a/gammu/emb/gammu/depend/nokia/dct4.c b/gammu/emb/gammu/depend/nokia/dct4.c
index 4bf958d..43d8f09 100644
--- a/gammu/emb/gammu/depend/nokia/dct4.c
+++ b/gammu/emb/gammu/depend/nokia/dct4.c
@@ -1,1350 +1,1350 @@
 /* (c) 2002-2004 by Marcin Wiacek */
 #include "../../../common/gsmstate.h"
 #ifdef GSM_ENABLE_NOKIA_DCT4
 #include <string.h>
 #include "dct4.h"
 #include "../../gammu.h"
 #include "../../../common/phone/pfunc.h"
 #include "../../../common/phone/nokia/nfunc.h"
 #include "../../../common/phone/nokia/dct4/dct4func.h"
 #include "../../../common/misc/coding/coding.h"
-extern GSM_Reply_Function UserReplyFunctions4[];
+static GSM_Reply_Function UserReplyFunctions4[];
 /* ------- some usefull functions ----------------------------------------- */
 GSM_Error CheckDCT4Only()
 {
        bool found = false;
        /* Checking if phone is DCT4 */
 #ifdef GSM_ENABLE_NOKIA3650
         if (strstr(N3650Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true;
 #endif
 #ifdef GSM_ENABLE_NOKIA6510
         if (strstr(N6510Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true;
 #endif
 #ifdef GSM_ENABLE_NOKIA3320
         if (strstr(N3320Phone.models, s.Phone.Data.ModelInfo->model) != NULL) found = true;
 #endif
        if (!found) return ERR_NOTSUPPORTED;
                if (s.ConnectionType!=GCT_MBUS2     && s.ConnectionType!=GCT_FBUS2      &&
            s.ConnectionType!=GCT_FBUS2DLR3  && s.ConnectionType!=GCT_PHONETBLUE &&
            s.ConnectionType!=GCT_IRDAPHONET && s.ConnectionType!=GCT_BLUEPHONET &&
            s.ConnectionType!=GCT_FBUS2DKU5) {
                return ERR_OTHERCONNECTIONREQUIRED;
        }
        return ERR_NONE;
 }
 static void CheckDCT4()
 {
        GSM_Error error;
        error = CheckDCT4Only();
        switch (error) {
        case ERR_NOTSUPPORTED:
                Print_Error(ERR_NOTSUPPORTED);
                break;
        case ERR_OTHERCONNECTIONREQUIRED:
                printf("Can't do it with current phone protocol\n");
                GSM_TerminateConnection(&s);
                exit(-1);
        default:
                break;
        }
 }
 static bool answer_yes2(char *text)
 {
            int         len;
            char        ans[99];
        while (1) {
                printf("%s (yes/no) ? ",text);
                len=GetLine(stdin, ans, 99);
                if (len==-1) exit(-1);
                if (mystrncasecmp(ans, "yes",0)) return true;
                if (mystrncasecmp(ans, "no" ,0)) return false;
        }
 }
 /* ------------------- functions ------------------------------------------- */
 static DCT4_Feature DCT4Features[] = {
                {DCT4_ALWAYS_ONLINE,             "GPRS Always Online",   {{0,"on (Context)"},{1,"off (Attach)"},{0,""}}},///??
                {DCT4_GPRS_PCCH,                 "PCCH support for GPRS", {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_GEA1,                      "GEA1 support indication", {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_EOTD,                      "EOTD support",         {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_WAP_PUSH,                          "WAP push",             {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_USE_PREF_SIM_NET,          "Use SIM preffered network list",{{1,"on"},{0,"off"},{0,""}}},
                {DCT4_JAVA_TCK,                 "Java TCK support",             {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_ALS,                "Alternate Line Service (ALS)", {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_A52,                       "Ciphering alghoritm A52",  {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_CSP,                       "Customer Service Profile", {{0,"off"},{1,"on"},{0,""}}},
                {DCT4_EONS,                      "EONS support",         {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_3GINDICATOR,               "3G indicator",         {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_DISPLAY_PHONE_NAME, "Display both number and name for incoming calls",{{1,"on"},{0,"off"},{0,""}}},
                {DCT4_DISPLAY_WAP_PROFILE, "Display selected WAP profile name instead of Home option menu in Services",{{1,"on"},{0,"off"},{0,""}}},
                {DCT4_GAMES_WAP_DOWNLOAD,        "Games WAP download",   {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_GAMES_SCORE_SEND,                  "Games WAP score send", {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_GAMES_URL_CHECK,           "Games URL check",      {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_BLUETOOTH_MENU,            "Bluetooth menu",       {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_WAP_BOOKMARKS_MENU,        "Bookmarks menu in Services",  {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_WAP_BOOKMARKS_MENU2,       "Bookmarks menu in Services",  {{3,"bookmarks & download"},{0,"off"},{0,""}}},
                {DCT4_WAP_GOTO_MENU,             "GoTo menu in Services", {{0,"on"},{1,"off"},{0,""}}},
                {DCT4_WAP_SETTINGS_MENU,         "Profiles menu in Services", {{0,"on"},{1,"off"},{0,""}}},
        {DCT4_SERVICES_GAMES_APP_GALLERY,"Services menu in Games/Apps/Gallery",{{1,"on"},{0,"off"},{0,""}}},
                {DCT4_JAVA_GAMES_MENU,           "Java games menu in Games", {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_SAT_CONFIRM_MENU,          "Can use confirming SIM service actions", {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_INSTANT_MESS_MENU, "Instant Messaging in Messages",{{1,"on"},{0,"off"},{0,""}}},
                {DCT4_CONFIRM_ALS,       "Confirm using ALS",            {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_BOOKMARK_GOTO_MENU, "Bookmarks in GoTo menu",       {{1,"on"},{0,"off"},{0,""}}},
                {DCT4_5100_IDENTIFY,     "Phone identification",         {{1,"NPM-6U"},{0,"NPM-6"},{0,""}}},
 #ifdef DEBUG
        {DCT4_TEST,"",{{1,"1"},{0,"0"}}},
 #endif
                {0,                              "",                     {{0,""}}}
 };
 static DCT4_Phone_Features DCT4PhoneFeatures[] = {
        /*3100*/ {"RH-19",{{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,4},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                         {DCT4_EONS,28},{DCT4_3GINDICATOR,30},{DCT4_INSTANT_MESS_MENU,33},
                         {DCT4_CONFIRM_ALS,35},
                         {0,0}}},
        /*3200*/ {"RH-30",{{DCT4_ALS,2},{DCT4_A52,4},{DCT4_CSP,5},{DCT4_GPRS_PCCH,14},
                         {DCT4_GEA1,15},{DCT4_EOTD,18},{DCT4_WAP_SETTINGS_MENU,20},
                         {DCT4_DISPLAY_PHONE_NAME,21},{DCT4_WAP_GOTO_MENU,23},
                         {DCT4_SERVICES_GAMES_APP_GALLERY,26},{DCT4_3GINDICATOR,28},
                         {DCT4_DISPLAY_WAP_PROFILE,31},{DCT4_SAT_CONFIRM_MENU,33},
                         {DCT4_CONFIRM_ALS,34},{DCT4_EONS,40},{DCT4_ALWAYS_ONLINE,45},
                         {0,0}}},
        /*3200*/ {"RH-31",{{DCT4_ALS,2},{DCT4_A52,4},{DCT4_CSP,5},{DCT4_GPRS_PCCH,14},
                         {DCT4_GEA1,15},{DCT4_EOTD,18},{DCT4_WAP_SETTINGS_MENU,20},
                         {DCT4_DISPLAY_PHONE_NAME,21},{DCT4_WAP_GOTO_MENU,23},
                         {DCT4_SERVICES_GAMES_APP_GALLERY,26},{DCT4_3GINDICATOR,28},
                         {DCT4_DISPLAY_WAP_PROFILE,31},{DCT4_SAT_CONFIRM_MENU,33},
                         {DCT4_CONFIRM_ALS,34},{DCT4_EONS,40},{DCT4_ALWAYS_ONLINE,45},
                         {0,0}}},
        /*3300*/ {"NEM-1",{{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                /*MORE*/ {0,0}}},
        /*3510*/ {"NHM-8",{{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,6},
                         {DCT4_GAMES_WAP_DOWNLOAD,7},{DCT4_GAMES_SCORE_SEND,8},
                         {DCT4_GAMES_URL_CHECK,9},{DCT4_GPRS_PCCH,13},
                         {DCT4_GEA1,15},{DCT4_ALWAYS_ONLINE,18},{0,0}}},
        /*3510i*/{"RH-9",{{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,4},{DCT4_GPRS_PCCH,9},
                         {DCT4_DISPLAY_PHONE_NAME,14},{DCT4_WAP_GOTO_MENU,15},
                         {DCT4_WAP_SETTINGS_MENU,16},{DCT4_SERVICES_GAMES_APP_GALLERY,19},
                         {DCT4_DISPLAY_WAP_PROFILE,25},{0,0}}},
        /*3650*/ {"NHL-8",{{DCT4_ALS,1},{0,0}}},
        /*5100*/ {"NPM-6",{{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                         {DCT4_EONS,28},
                        // {DCT4_5100_IDENTIFY,10},
                         {0,0}}},
        /*5100*/ {"NPM-6U",{{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                         {DCT4_EONS,28},
                        // {DCT4_5100_IDENTIFY,10},
                         {0,0}}},
        /*6100*/ {"NPL-2",{{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                         {0,0}}},
        /*6220*/ {"RH-20",{{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,4},
                         {DCT4_GEA1,14},{DCT4_EOTD,17},{DCT4_WAP_SETTINGS_MENU,19},
                         {DCT4_DISPLAY_PHONE_NAME,20},{DCT4_WAP_GOTO_MENU,22},
                         {DCT4_WAP_BOOKMARKS_MENU2,24},{DCT4_SERVICES_GAMES_APP_GALLERY,25},
                         {DCT4_3GINDICATOR,27},{DCT4_DISPLAY_WAP_PROFILE,30},{DCT4_SAT_CONFIRM_MENU,32},
                         {DCT4_CONFIRM_ALS,33},{DCT4_JAVA_TCK,36},{DCT4_BOOKMARK_GOTO_MENU,37},
                         {0,0}}},
        /*6310*/ {"NPE-4",{{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,6},{DCT4_GAMES_WAP_DOWNLOAD,7},
                         {DCT4_GAMES_SCORE_SEND,8},{DCT4_GAMES_URL_CHECK,9},{DCT4_BLUETOOTH_MENU,10},
                         {DCT4_GPRS_PCCH,13},{DCT4_GEA1,15},{DCT4_ALWAYS_ONLINE,18},{0,0}}},
        /*6310i*/{"NPL-1",{{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,6},{DCT4_GAMES_WAP_DOWNLOAD,7},
                         {DCT4_GAMES_SCORE_SEND,8},{DCT4_GAMES_URL_CHECK,9},
                         {DCT4_BLUETOOTH_MENU,10},{DCT4_USE_PREF_SIM_NET,11},
                         {DCT4_GPRS_PCCH,13},{DCT4_GEA1,15},{DCT4_EOTD,16},
                         {DCT4_ALWAYS_ONLINE,17},{DCT4_JAVA_GAMES_MENU,18},
                         {DCT4_WAP_BOOKMARKS_MENU,20},{DCT4_WAP_SETTINGS_MENU,21},
                         {DCT4_WAP_PUSH,28},{DCT4_WAP_GOTO_MENU,29},{0,0}}},
        /*6510*/ {"NPM-9",{{DCT4_ALS,1},{DCT4_A52,3},{DCT4_CSP,6},{DCT4_GAMES_WAP_DOWNLOAD,7},
                         {DCT4_GAMES_SCORE_SEND,8},{DCT4_GAMES_URL_CHECK,9},
                         {DCT4_GPRS_PCCH,13},{DCT4_GEA1,15},{DCT4_ALWAYS_ONLINE,18},{0,0}}},
        /*6610*/ {"NHL-4U",{{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                         {0,0}}},
        /*6800*/ {"NHL-6",{{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                /*MORE*/ {0,0}}},
        /*7210*/ {"NHL-4",{{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                         {0,0}}},
        /*7250*/ {"NHL-4J",{{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                         {0,0}}},
        /*7250i*/{"NHL-4JX",{{DCT4_ALS,1},{DCT4_CSP,4},{DCT4_GAMES_URL_CHECK,5},{DCT4_GPRS_PCCH,8},
                         {DCT4_GEA1,9},{DCT4_ALWAYS_ONLINE,11},{DCT4_EOTD,12},
                         {DCT4_DISPLAY_PHONE_NAME,17},{DCT4_WAP_GOTO_MENU,18},
                         {DCT4_WAP_SETTINGS_MENU,19},{DCT4_SERVICES_GAMES_APP_GALLERY,22},
                         {DCT4_DISPLAY_WAP_PROFILE,26},{DCT4_SAT_CONFIRM_MENU,27},
                /*MORE*/ {0,0}}},
        /*8310*/{"NHM-7",{{DCT4_ALS,1},{DCT4_CSP,6},{DCT4_GAMES_WAP_DOWNLOAD,7},
                         {DCT4_GAMES_SCORE_SEND,8},{DCT4_GAMES_URL_CHECK,9},{DCT4_GPRS_PCCH,13},
                         {DCT4_ALWAYS_ONLINE,18},{0,0}}},
                {"",    {{0,0}}}
 };
 static GSM_Error DCT4_ReplySetPPS(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        printf("Setting done OK\n");
        return ERR_NONE;
 }
 void DCT4SetPhoneMenus(int argc, char *argv[])
 {
                int     current = 10,i=0,j,z;
                unsigned char reqSet[200] = {
                N7110_FRAME_HEADER,0x04,0x00,0x01,0x47,0x48,0x02,
                        0x00};  /* Number of changed features */
        if (CheckDCT4Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions4;
        while (DCT4PhoneFeatures[i].Model[0] != 0x00) {
                if (!strcmp(DCT4PhoneFeatures[i].Model,s.Phone.Data.Model)) {
                        j = 0;
                        while (DCT4PhoneFeatures[i].Features[j].Name != 0x00) {
                                z = 0;
                                while (DCT4Features[z].Name != 0x00) {
                                        if (DCT4Features[z].Name == DCT4PhoneFeatures[i].Features[j].Name) {
                                                printf("%s : %s\n",DCT4Features[z].Text,DCT4Features[z].Values[0].Text);
                                                        reqSet[9]++;                                            /* Number of features */
                                                        reqSet[current++] = DCT4PhoneFeatures[i].Features[j].Number; /* Feature number */
                                                        reqSet[current++] = DCT4Features[z].Values[0].Value;    /* Value */
                                                break;
                                        }
                                        z++;
                                }
                                j++;
                        }
                }
                i++;
        }
        if (current == 10) {
                printf("Sorry, but configuration matrix for this model is not added yet. Please report\n");
                return;
        }
        reqSet[current++] = 0x00;
        reqSet[current++] = 0x00;
        error=GSM_WaitFor (&s, reqSet, current, 0x1b, 4, ID_User1);
        Print_Error(error);
 }
 DCT4_Phone_Tests DCT4Tests;
 static GSM_Error DCT4_ReplyTestsNames(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        int i,pos;
        DCT4Tests.Num   = msg.Buffer[5];
                pos     = 6;
        smprintf(s,"%i names for phone tests received\n",msg.Buffer[5]);
        for (i=0;i<msg.Buffer[5];i++) {
                strcpy(DCT4Tests.Tests[i].Name,msg.Buffer+pos+4);
                DCT4Tests.Tests[i].ID = msg.Buffer[pos+2];
                smprintf(s,"%x.\"%s\"\n",DCT4Tests.Tests[i].ID,DCT4Tests.Tests[i].Name);
                pos+=msg.Buffer[pos+1];
        }
        return ERR_NONE;
 }
 static GSM_Error DCT4_ReplyTestsStartup(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                int  i,pos,j;
                bool found;
        pos = 10;
        for (i=0;i<msg.Buffer[8];i++) {
                found = false;
                for (j=0;j<DCT4Tests.Num;j++) {
                        if (DCT4Tests.Tests[j].ID == msg.Buffer[pos]) {
                                        DCT4Tests.Tests[j].Startup = true;
                                        found                   = true;
                                break;
                        }
                }
                if (!found) printf("%x ",msg.Buffer[pos]);
                pos++;
        }
        return ERR_NONE;
 }
 static GSM_Error DCT4_ReplyTestsStatus(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        int i,pos,j;
        pos = 6;
        smprintf(s,"%i status entries for phone tests received\n",msg.Buffer[5]);
        for (i=0;i<msg.Buffer[5];i++) {
                for (j=0;j<DCT4Tests.Num;j++) {
                        if (DCT4Tests.Tests[j].ID == msg.Buffer[pos+2]) {
                                printf("\"%40s\" : ",DCT4Tests.Tests[j].Name);
                                switch(msg.Buffer[pos+3]) {
                                                case 0x00: printf("Passed");    break;
                                                case 0x01: printf("Fail");      break;
                                                case 0x03: printf("Not executed"); break;
                                                case 0x06: printf("No signal");         break;
                                                case 0x0D: printf("Timeout");   break;
                                        default  : printf("Unknown (%x)",msg.Buffer[pos+3]);
                                }
                                if (DCT4Tests.Tests[j].Startup) printf(" (startup)");
                                        printf("\n");                   
                                break;
                        }
                }
                pos+=msg.Buffer[pos+1];
        }
        return ERR_NONE;
 }
 void DCT4SelfTests(int argc, char *argv[])
 {
                int       j;
        unsigned char GetDoneST[6]    = {0x00, 0x08, 0x01, 0x04, 0x01, 0x00};
        unsigned char GetDoneST2[6]   = {0x00, 0x08, 0x02, 0x04, 0x02, 0x00};
        unsigned char GetNames[6]     = {0x00, 0x08, 0x03, 0x06, 0x03, 0x00};
        unsigned char GetStatus[6]    = {0x00, 0x08, 0x04, 0x02, 0x03, 0x00}; 
        unsigned char RunALL[6]       = {0x00, 0x06, 0x04, 0x00, 0x03, 0x00};
        //unsigned char GetID[6]        = {0x00, 0x08, 0x00, 0x04, 0x03, 0x00};//tests ID
        if (CheckDCT4Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions4;
        if (answer_yes2("Run all tests now ?")) {
                error=GSM_WaitFor (&s, RunALL, 6, 0x35, 4, ID_User1);
                Print_Error(error);
        }
        error=GSM_WaitFor (&s, GetNames, 6, 0x35, 4, ID_User1);
        Print_Error(error);
        for (j=0;j<DCT4Tests.Num;j++) DCT4Tests.Tests[j].Startup = false;
        error=GSM_WaitFor (&s, GetDoneST, 6, 0x35, 4, ID_User3);
        Print_Error(error);
        error=GSM_WaitFor (&s, GetDoneST2, 6, 0x35, 4, ID_User3);
        Print_Error(error);
        error=GSM_WaitFor (&s, GetStatus, 6, 0x35, 4, ID_User2);
        Print_Error(error);
 }
 static GSM_Error DCT4_ReplyVibra(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
 #ifdef DEBUG
        switch (msg.Buffer[3]) {
                case 0x0D : dbgprintf("Vibra state set OK\n"); break;
                case 0x0F : dbgprintf("Vibra power set OK\n"); break;
        }
 #endif
        return ERR_NONE;
 }
 static GSM_Error DCT4EnableVibra(GSM_StateMachine *s, bool enable)
 {
        /* Enables or disables vibra */
                unsigned char Control[6] = {N7110_FRAME_HEADER,0x0C,
                        0x01,   /* 0x01 = On, 0x00 = Off */
                0x00};
        if (!enable) Control[4] = 0x00;
        return GSM_WaitFor (s, Control, 6, 0x1C, 4, ID_User3);
 }
 void DCT4SetVibraLevel(int argc, char *argv[])
 {
                GSM_DateTimeDate;
                unsigned inti,j;
        /* Set vibra level */
                unsigned char SetLevel[6] = {N7110_FRAME_HEADER,0x0E,
                                               0x64,/* Vibra power (in percent) */
                                       0x00};
        GSM_Init(true);
        CheckDCT4();
        s.User.UserReplyFunctions=UserReplyFunctions4;
        SetLevel[4] = atoi(argv[2]);
        error=GSM_WaitFor (&s, SetLevel, 6, 0x1C, 4, ID_User3);
        Print_Error(error);
        error=DCT4EnableVibra(&s, true);
        Print_Error(error);
        for (i=0;i<3;i++) {
                GSM_GetCurrentDateTime (&Date);
                j=Date.Second;
                while (j==Date.Second) {
                        my_sleep(10);
                        GSM_GetCurrentDateTime(&Date);
                }
        }
        error=DCT4EnableVibra(&s, false);
        Print_Error(error);
        GSM_Terminate();
 }
 void DCT4VibraTest(int argc, char *argv[])
 {
        unsigned char ans[200];
        if (CheckDCT4Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions4;
        error=DCT4EnableVibra(&s, true);
        Print_Error(error);
        printf("Press any key to continue...\n");
        GetLine(stdin, ans, 99);
        error=DCT4EnableVibra(&s, false);
        Print_Error(error);
 }
 #ifdef DEBUG
 static GSM_Error DCT4_ReplyResetSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        switch (msg.Buffer[3]) {
        case 0x05:
                printf("Security code set to \"12345\"\n");
                return ERR_NONE;
        case 0x06:
                printf("Unknown reason. Can't reset your security code\n");
                return ERR_UNKNOWN;
        }
        return ERR_UNKNOWNRESPONSE;
 }
 void DCT4ResetSecurityCode(int argc, char *argv[])
 {
                unsigned inti;
                unsigned char ResetCode[30] = {0x00,0x06,0x03,0x04,0x01,
                        '1','2','3','4','5','6','7','8','9','0',/* Old code */
                0x00,
                '1','2','3','4','5',0x00,0x00,0x00,0x00,0x00,   /* New code */
                0x00};
        if (CheckDCT4Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions4;
        error=GSM_WaitFor (&s, ResetCode, 27, 0x08, 4, ID_User2);
        if (error == ERR_UNKNOWN) {
                if (answer_yes2("Try brutal force ?")) {
                        for (i=10000;i<9999999;i++) {
                                printf("Trying %i\n",i);
                                memset(ResetCode+6,0,22);
                                sprintf(ResetCode+5,"%i",i);
                                sprintf(ResetCode+16,"12345");
                                error=GSM_WaitFor (&s, ResetCode, 27, 0x08, 4, ID_User2);
                                if (error == ERR_NONE) break;
                        }
                }
        } else Print_Error(error);
 }
 #endif
 char SecLength;
 static GSM_Error DCT4_ReplyGetSecurityCode(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        if (msg.Length > 12) {
                SecLength = msg.Buffer[13];
                if ((msg.Buffer[17]+18) == msg.Length) {
                        printf("Security code is %s\n",msg.Buffer+18);
        //              DumpMessage(stdout, msg.Buffer, msg.Length);
                }
        }
        return ERR_NONE;
 }
 void DCT4GetSecurityCode(int argc, char *argv[])
 {
                GSM_Error error;
                unsigned char getlen[]={0x00, 0x08, 0x01, 0x0C, 
                                          0x00, 0x23,   //ID 
                                          0x00, 0x00,   //Index
                                  0x00, 0x00}; 
                unsigned char read[]={0x00, 0x08, 0x02, 0x04,
                                        0x00, 0x23,     //ID
                                        0x00, 0x00,     //Index
                                0x00, 0x00, 0x00, 0x00, 0x00,
                                0x00, 0x00, 0x00, 0x00,
                                0x00};                  //Length
        if (CheckDCT4Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions4;
        SecLength = 0;
        error=GSM_WaitFor (&s, getlen, sizeof(getlen), 0x23, 1, ID_User1);
        Print_Error(error);
        if (SecLength != 0) {
                read[17] = SecLength;
                error=GSM_WaitFor (&s, read, sizeof(read), 0x23, 5, ID_User1);
                Print_Error(error);
        }
 }
 static GSM_Error DCT4_ReplyGetVoiceRecord(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                int     i=18,j;
                unsigned charBuffer[100];
        switch (msg.Buffer[3]) {
        case 0x05:
                dbgprintf("Part of voice record received\n");
                if (msg.Length == 6) {
                        dbgprintf("Empty\n");
                        return ERR_EMPTY;
                }
                *s->Phone.Data.VoiceRecord = 0;
                while (i<msg.Length) {
                        s->Phone.Data.PhoneString[(*s->Phone.Data.VoiceRecord)++] = msg.Buffer[i+1];
                        s->Phone.Data.PhoneString[(*s->Phone.Data.VoiceRecord)++] = msg.Buffer[i];
                        i += 2;
                }
                return ERR_NONE;
        case 0x0D:
                dbgprintf("Last part of voice record is %02x %02x\n",msg.Buffer[11],msg.Buffer[12]);
                dbgprintf("Token is %02x\n",msg.Buffer[13]);
                s->Phone.Data.PhoneString[0] = msg.Buffer[11];
                s->Phone.Data.PhoneString[1] = msg.Buffer[12];
                s->Phone.Data.PhoneString[2] = msg.Buffer[13];
                return ERR_NONE;
                break;
        case 0x31:
                dbgprintf("Names of voice records received\n");
                j = 33;
                for (i=0;i<msg.Buffer[9];i++) {
                        memcpy(Buffer,msg.Buffer+(j+1),msg.Buffer[j]);
                                Buffer[msg.Buffer[j]] = 0;
                        Buffer[msg.Buffer[j]+1] = 0;
                        dbgprintf("%i. \"%s\"\n",i+1,DecodeUnicodeString(Buffer));
                        if (i==*s->Phone.Data.VoiceRecord) {
                                sprintf(s->Phone.Data.PhoneString,"%s.wav",DecodeUnicodeString(Buffer));
                                return ERR_NONE;
                        }
                        if (i != msg.Buffer[9] - 1) {
                                j+=msg.Buffer[j] + 1;
                                if (msg.Buffer[j] == 0x00 && msg.Buffer[j+1]==0x00) j+=2;
                                j+=23;
                        }
                }
                return ERR_EMPTY;
        }
        return ERR_UNKNOWNRESPONSE;
 }
 void DCT4GetVoiceRecord(int argc, char *argv[])
 {
        /* Voice records names */
                unsigned char ReqNames[200] = {
                N7110_FRAME_HEADER,
                0x30,0x01,0x55,0x00,0x00,0xFF,0xFF,0x01,0x01,0x55,0x55};
        /* Voice record token */
                unsigned char ReqToken[200] = {
                N7110_FRAME_HEADER,0x0C,0x00,0x44,0x00,
                        0x00,   /* Location: 0, 1, ... */
                0x55,0x55};
        /* Voice record part */
                unsigned char ReqGet[200] = {
                N7110_FRAME_HEADER,0x04,0x00,0x44,
                        0x00,0x00,/* Location: 0, 1, ...  */
                0x55,0x55,0x00,
                        0x00,0x00,      /* Part Location*/
                0x00,0x00,0x00,
                        0x04,           /* ???          */
                        0x00};          /* Token        */
        /* WAV file headers */
                unsigned char WAV_Header[] = {
                        'R','I','F','F',
                                0x00,0x00,0x00,0x00,/* Length */
                        'W','A','V','E'};
                unsigned char FMT_Header[] = {'f','m','t',' ',
                        0x14,0x00,0x00,0x00,0x31,0x00,0x01,0x00,0x40,0x1f,
                        0x00,0x00,0x59,0x06,0x00,0x00,0x41,0x00,0x00,0x00,
                        0x02,0x00,0x40,0x01,'f', 'a', 'c', 't', 0x04,0x00,
                        0x00,0x00,
                                0x00,0x73,0x00,0x00};/* Seems to be some length */
                unsigned char DATA_Header[] = {
                        'd','a','t','a',
                                0x00,0x00,0x00,0x00};/* Length */
                long    wavfilesize=0;
                unsigned charFileName[100], Buffer[10000], Token;
                unsigned int Location, size=0, CurrentLocation = 0, TokenLocation;
                int     i;
                FILE    *WAVFile;
        Location = atoi(argv[2]);
        if (Location == 0x00) {
                printf("Please numerate locations from 1\n");
                return;
        }
        Location--;
        GSM_Init(true);
        CheckDCT4();
        s.User.UserReplyFunctions=UserReplyFunctions4;
                s.Phone.Data.VoiceRecord = &Location;
                s.Phone.Data.PhoneString = FileName;
        dbgprintf("Getting voice record name\n");
        error=GSM_WaitFor (&s, ReqNames, 14, 0x4A, 4, ID_User4);
        Print_Error(error);
        
                s.Phone.Data.PhoneString = Buffer;
                ReqToken[7]             = Location;
        dbgprintf("Getting voice record token\n");
        error=GSM_WaitFor (&s, ReqToken, 10, 0x23, 4, ID_User4);
        Print_Error(error);
                TokenLocation           = Buffer[0] * 256 + Buffer[1];
                Token                   = Buffer[2];
        WAVFile = fopen(FileName, "wb");      
                fwrite(&WAV_Header,     1, sizeof(WAV_Header),WAVFile);
                fwrite(&FMT_Header,     1, sizeof(FMT_Header),WAVFile);
                fwrite(&DATA_Header,    1, sizeof(DATA_Header),WAVFile);
                s.Phone.Data.VoiceRecord = &size;
                s.Phone.Data.PhoneString = Buffer;
                ReqGet[7]               = Location;
        fprintf(stderr,"Getting voice record and saving to \"%s\": ",FileName);
        while (1) {
                dbgprintf("Getting next part of voice record\n");
                fprintf(stderr,".");
                error=GSM_WaitFor (&s, ReqGet, 18, 0x23, 4, ID_User4);
                if (error == ERR_NONE) {
                        wavfilesize += size;
                        fwrite(Buffer,1,size,WAVFile);
                }
                if (error == ERR_EMPTY) break;
                Print_Error(error);
                CurrentLocation += 4;
                ReqGet[11] = CurrentLocation / 256;
                ReqGet[12] = CurrentLocation % 256;
                if (CurrentLocation+4 > TokenLocation) break;
        }
        dbgprintf("Getting first part in last sequence of voice record\n");
        for (i=255;i>=0;i--) {
                ReqGet[16] = i;
                ReqGet[17] = Token;
                fprintf(stderr,".");
                error=GSM_WaitFor (&s, ReqGet, 18, 0x23, 4, ID_User4);
                if (error == ERR_NONE) {
                        wavfilesize += size;
                        fwrite(Buffer,1,size,WAVFile);
                        break;
                }
                if (error != ERR_EMPTY) Print_Error(error);
        }
        while (1) {
                dbgprintf("Getting next part of last sequence in voice record\n");
                CurrentLocation += 4;
                ReqGet[11] = CurrentLocation / 256;
                ReqGet[12] = CurrentLocation % 256;
                fprintf(stderr,".");
                error=GSM_WaitFor (&s, ReqGet, 18, 0x23, 4, ID_User4);
                if (error == ERR_NONE) {
                        wavfilesize += size;
                        fwrite(Buffer,1,size,WAVFile);
                }
                if (error == ERR_EMPTY) break;
                Print_Error(error);
        }
        fprintf(stderr,"\n");
                wavfilesize += sizeof(WAV_Header) + sizeof(FMT_Header) + sizeof(DATA_Header);
                WAV_Header[4] = (unsigned char)(wavfilesize % 256);
                WAV_Header[5] = (unsigned char)(wavfilesize / 256);
                WAV_Header[6] = (unsigned char)(wavfilesize / (256*256));
                WAV_Header[7] = (unsigned char)(wavfilesize / (256*256*256));
        /* FIXME */
                FMT_Header[36]= (unsigned char)(((wavfilesize - 238) * 5 ) % 256);
                FMT_Header[37]= (unsigned char)(((wavfilesize - 238) * 5 ) / 256);
                FMT_Header[38]= (unsigned char)(((wavfilesize - 238) * 5 ) / (256*256));
                FMT_Header[39]= (unsigned char)(((wavfilesize - 238) * 5 ) / (256*256*256));
                wavfilesize = wavfilesize - 54 - 6;
                DATA_Header[4] = (unsigned char)(wavfilesize % 256);
                DATA_Header[5] = (unsigned char)(wavfilesize / 256);
                DATA_Header[6] = (unsigned char)(wavfilesize / (256*256));
                DATA_Header[7] = (unsigned char)(wavfilesize / (256*256*256));
        fseek( WAVFile, 0, SEEK_SET);
                fwrite(&WAV_Header,     1, sizeof(WAV_Header),WAVFile);
                fwrite(&FMT_Header,     1, sizeof(FMT_Header),WAVFile);
                fwrite(&DATA_Header,    1, sizeof(DATA_Header),WAVFile);
        fclose(WAVFile);
        GSM_Terminate();
 }
 static GSM_Error DCT4_ReplyGetBTInfo(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        printf("device address %02x%02x%02x%02x%02x%02x\n",
                msg.Buffer[9],msg.Buffer[10],msg.Buffer[11],
                msg.Buffer[12],msg.Buffer[13],msg.Buffer[14]);
        return ERR_NONE;
 }
 static GSM_Error DCT4_ReplyGetSimlock(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        int i;
        switch (msg.Buffer[3]) {
        case 0x0D:
                dbgprintf("Simlock info received\n");
                dbgprintf("Config_Data: ");
                for (i=14;i<22;i++) {
                        dbgprintf("%02x",msg.Buffer[i]);
                }
                dbgprintf("\n");
                dbgprintf("Profile_Bits: ");
                for (i=22;i<30;i++) {
                        dbgprintf("%02x",msg.Buffer[i]);
                }
                        dbgprintf("\n");        
                return ERR_NONE;
        case 0x13:
                dbgprintf("Simlock info received\n");
                if (msg.Buffer[58] == 0x05 && msg.Buffer[59] == 0x02) {
                        dbgprintf("SIM_PATH: ");
                        for (i=44;i<52;i++) {
                                dbgprintf("%02x",msg.Buffer[i]);
                        }
                        dbgprintf("\n");
                        printf("Simlock data  : ");
                        for (i=60;i<63;i++) {
                                printf("%02x",msg.Buffer[i]);
                        }
                        printf("\n");
                }
                return ERR_NONE;
        }
        return ERR_UNKNOWNRESPONSE;
 }
 void DCT4Info(int argc, char *argv[])
 {
        unsigned char GetBTAddress[8] = {N6110_FRAME_HEADER, 0x09, 0x19, 0x01, 0x03, 0x06};
        unsigned char GetSimlock[5] = {N6110_FRAME_HEADER, 0x12, 0x0D};
        unsigned char value[10];
        if (CheckDCT4Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions4;
        if (IsPhoneFeatureAvailable(s.Phone.Data.ModelInfo, F_BLUETOOTH)) {
                printf("Bluetooth     : ");
                error=GSM_WaitFor (&s, GetBTAddress, 8, 0xD7, 4, ID_User6);
                Print_Error(error);
        }
        error=GSM_WaitFor (&s, GetSimlock, 5, 0x53, 4, ID_User6);
        Print_Error(error);
        GetSimlock[4] = 0x0E;
        error=GSM_WaitFor (&s, GetSimlock, 5, 0x53, 4, ID_User6);
        Print_Error(error);
        GetSimlock[3] = 0x0C;
        error=GSM_WaitFor (&s, GetSimlock, 4, 0x53, 4, ID_User6);
        Print_Error(error);
        error=NOKIA_GetPhoneString(&s,"\x00\x03\x02\x07\x00\x08",6,0x1b,value,ID_User6,10);
        Print_Error(error);
        printf("UEM           : %s\n",value);
 }
        static FILE *T9File;
        int     T9Size;
        int     T9FullSize;
 static GSM_Error DCT4_ReplyGetT9(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                T9FullSize = msg.Buffer[18] * 256 + msg.Buffer[19];
                T9Size          = msg.Length - 18;
        fwrite(msg.Buffer+18,1,T9Size,T9File);
        return ERR_NONE;
 }
 void DCT4GetT9(int argc, char *argv[])
 {
                int      i,T9Dictionary=0;
        unsigned char req[] = {N7110_FRAME_HEADER, 0x04, 0x00, 0x5B,
                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                       0x00, 0x00,/* Start position */
                               0x00, 0x00,
                                       0x02, 0xBC};/* How many bytes to read */
        if (CheckDCT4Only()!=ERR_NONE) return;
        T9File = fopen("T9", "w");      
        if (T9File == NULL) return;
        s.User.UserReplyFunctions=UserReplyFunctions4;
        i = 0;
        while (1) {
                req[12] = i / 256;
                req[13] = i % 256;
                if (i != 0) {
                        if (T9Dictionary - i < req[16]*256+req[17]) {
                                req[16] = (T9Dictionary - i) / 256;
                                req[17] = (T9Dictionary - i) % 256;
                        }
                        if (T9Dictionary - i == 0) break;
                }
                        error=GSM_WaitFor (&s, req, 18, 0x23, 4, ID_User3);     
                Print_Error(error);
                if (i==0) {
                        T9Dictionary = T9FullSize;
                        dbgprintf("T9 dictionary size is %i\n",T9Dictionary);
                }
                i+=T9Size;
        }
        fclose(T9File);
 }
 #ifdef GSM_ENABLE_NOKIA6510
 extern GSM_Error N6510_SetLight(GSM_StateMachine *s, N6510_PHONE_LIGHTS light, bool enable);
 void DCT4SetLight(int argc, char *argv[])
 {
                int             i;
                N6510_PHONE_LIGHTS type;
                bool            enable;
                if (mystrncasecmp(argv[2],"display",0)) { type = N6510_LIGHT_DISPLAY;
                } else if (mystrncasecmp(argv[2],"keypad",0)) {type = N6510_LIGHT_KEYPAD;
                } else if (mystrncasecmp(argv[2],"torch",0)) {type = N6510_LIGHT_TORCH;
        } else {
                printf("What lights should I enable (\"%s\") ?\n",argv[2]);
                exit(-1);
        }
                if (mystrncasecmp(argv[3],"on",0)) {    enable = true;
                } else if (mystrncasecmp(argv[3],"off",0)) {enable = false;
        } else {
                printf("What should I do (\"%s\") ?\n",argv[3]);
                exit(-1);
        }
        for (i=0;i<s.ConfigNum;i++) {
                s.Config[i].StartInfo = "false";
        }
        GSM_Init(true);
        CheckDCT4();
        error=N6510_SetLight(&s, type, enable);
        Print_Error(error);
        GSM_Terminate();
 }
 #endif
 void DCT4DisplayTest(int argc, char *argv[])
 {
        unsigned char ans[200];
        unsigned char req0[] = {0x00, 0x08, 0x0D, 0x00, 0x0F, 0x00};
        unsigned char req[] =  {0x00, 0x08, 0x0E, 0x00, 0x12, 0x01, 0x00, 0x04,
                                        0x09,   /* test number */
                                0x00};
        if (CheckDCT4Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions4;
        DCT4_SetPhoneMode(&s, DCT4_MODE_TEST);
        s.Protocol.Functions->WriteMessage(&s, req0, 6, 0x40);
        req[8] = atoi(argv[2]);
        s.Protocol.Functions->WriteMessage(&s, req, 10, 0x40);
        printf("Press any key to continue...\n");
        GetLine(stdin, ans, 99);
        DCT4_SetPhoneMode(&s, DCT4_MODE_NORMAL);
 }
 int ADC;
 static GSM_Error DCT4_ReplyGetADC(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        if (msg.Buffer[6] == 0xff && msg.Buffer[7] == 0xff) return ERR_NONE;
        switch (msg.Buffer[3]) {
        case 0x10:
                printf("raw ");
                printf("%10i ",msg.Buffer[8]*256+msg.Buffer[9]);
                break;
        case 0x12:
                printf("unit result ");
                printf("%10i ",(msg.Buffer[8]*256+msg.Buffer[9])*ADC);
                break;
        }
        return ERR_NONE;
 }
 struct DCT4ADCInfo {
                char *name;
                char *unit;
                int x;
 };
 static struct DCT4ADCInfo DCT4ADC[] = {
                {"Battery voltage, divided:",   "mV",  1},
                {"Battery voltage, scaled:",    "mV",  1},
                {"Charger voltage:",                    "mV",  1},  
                {"Charger current:",            "mA",  1},
                {"Battery size indicator:",     "Ohms",100},
                {"Battery temperature:",        "K",   1},
                {"Headset interconnection:",    "mV",  1},
                {"Hook interconnection:",       "mV",  1},
                {"Light sensor:",               "mV",  1},
                {"Power amplifier temperature:","K",   1},
                {"VCXO temperature:",           "K",   1},
                {"Resistive keyboard 1/headint2:","mV",  1},
                {"Resistive keyboard 1/auxdet:","mV",  1},
                {"Initial battery voltage:",    "mV",  1},
                {"Battery Current:",            "mA",  1},
                {"Battery Current Fast:",       "mA",  1},
        {"", "", 1}
 };
 void DCT4GetADC(int argc, char *argv[])
 {
                int     i = 0;
                unsigned char GetRaw[]  = {N6110_FRAME_HEADER, 0x0F,
                                             0x00,      /* Test number */
                                     0x01};
                unsigned char GetUnit[] = {N6110_FRAME_HEADER, 0x11,
                                             0x00,      /* Test number */
                                     0x01};
        if (CheckDCT4Only()!=ERR_NONE) return;
        s.User.UserReplyFunctions=UserReplyFunctions4;
        while (1) {
                printf(" %30s ",DCT4ADC[i].name);
                GetRaw[4] = i;
                        error=GSM_WaitFor (&s, GetRaw, 6, 0x17, 4, ID_User3);   
                Print_Error(error);
                        GetUnit[4] = i;
                        ADC     = DCT4ADC[i].x;
                        error=GSM_WaitFor (&s, GetUnit, 6, 0x17, 4, ID_User3);  
                Print_Error(error);
                printf("%s\n",DCT4ADC[i].unit);
                i++;
                if (DCT4ADC[i].name[0] == 0x00) break;
        }
 }
 #ifdef GSM_ENABLE_NOKIA6510
        static double   RadioFreq;
        static unsigned char RadioName[100];
 static GSM_Error DCT4_ReplyTuneRadio(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                int     length;
                unsigned char name[100];
        switch (msg.Buffer[3]) {
        case 0x09:
                N6510_DecodeFMFrequency(&RadioFreq, msg.Buffer+16);
                length = msg.Buffer[8];
                memcpy(name,msg.Buffer+18,length*2);
                        name[length*2] = 0x00;
                name[length*2+1] = 0x00;
                CopyUnicodeString(RadioName,name);
                smprintf(s,"Station name: \"%s\"\n",DecodeUnicodeString(RadioName));
                return ERR_NONE;
        case 0x15:
        case 0x16:
                smprintf(s,"Response for enabling radio/headset status received\n");
                if (msg.Buffer[5] == 0) {
                        smprintf(s,"Connected\n");
                        return ERR_NONE;
                }
                smprintf(s,"Probably not connected\n");
                return ERR_PERMISSION;
        }
        return ERR_UNKNOWNRESPONSE;
 }
 void DCT4TuneRadio(int argc, char *argv[])
 {
                double  Freq, diff;
                GSM_FMStation FMStation[50],FMStat;
                int     i, j, num;
                bool    found;
        unsigned char Enable[]     = {N6110_FRAME_HEADER, 0x00, 0x00, 0x00};
        unsigned char Disable[]    = {N6110_FRAME_HEADER, 0x01, 0x0E, 0x00};
        //unsigned char SetVolume[]  = {N6110_FRAME_HEADER, 0x14,
        //                                    0x00,/* Volume level */
        //                            0x00};
        //unsigned char MuteUnMute[] = {N6110_FRAME_HEADER, 0x0F,
        //                                    0x0C,/* 0x0B = mute, 0x0C = unmute */
        //                            0x00};
                unsigned char SetFreq[]   = {N6110_FRAME_HEADER, 0x08,
                                      0x08, 0x14, 0x00, 0x01,
                                      0x9A, 0x28};  /* Frequency */
        //      unsigned char Find1[]   = {N6110_FRAME_HEADER, 0x08,
        //                            0x04, 0x14, 0x00, 0x00, 0x00, 0x00};
                unsigned char Find2[]   = {N6110_FRAME_HEADER, 0x08,
                                      0x05, 0x14, 0x00, 0x00, 0x00, 0x00};
        //unsigned char SetStereo[]  = {N6110_FRAME_HEADER, 0x19,
        //                            0x0A, 0x00, 0x15};
        //unsigned char SetMono[]    = {N6110_FRAME_HEADER, 0x19,
        //                            0x09, 0x00, 0x96};
        GSM_Init(true);
        CheckDCT4();
        s.User.UserReplyFunctions=UserReplyFunctions4;
        FMStat.Location = 1;
        error = Phone->GetFMStation(&s,&FMStat);
        if (error != ERR_NONE && error != ERR_EMPTY) {
                printf("Phone seems not to support radio\n");
                GSM_Terminate();
                        exit(-1);       
        }
        error=GSM_WaitFor (&s, Enable, 6, 0x3E, 4, ID_User3);
        if (error == ERR_PERMISSION) {
                printf("Please connect headset. Required as antenna\n");
                GSM_Terminate();
                exit(-1);
        }
        Print_Error(error);
        num=0;
        for (i=88;i<108;i++) {
                fprintf(stderr,"%cSearching: %i percent",13,(i-88)*100/(108-88));
                Freq = i;
                N6510_EncodeFMFrequency(Freq, SetFreq+8);
                error=GSM_WaitFor (&s, SetFreq, 10, 0x3E, 4, ID_User3);
                Print_Error(error);
                error=GSM_WaitFor (&s, Find2, 10, 0x3E, 4, ID_User3);
                Print_Error(error);
                found = false;
                for (j=0;j<num;j++) {
                        if (FMStation[j].Frequency > RadioFreq) {
                                diff = FMStation[j].Frequency - RadioFreq;
                        } else {
                                diff = RadioFreq - FMStation[j].Frequency;
                        }
                        if (diff <= 0.2) {
                                dbgprintf("diff is %f\n",diff);
                                found = true;
                                break;
                        }
                }
                if (!found) {
                        dbgprintf("Adding %f, num %i\n",RadioFreq,num);
                        FMStation[num].Frequency = RadioFreq;
                        CopyUnicodeString(FMStation[num].StationName,RadioName);
                        num++;
                }
        }
        fprintf(stderr,"%cSearching: %i percent",13,100);
        fprintf(stderr,"\n\n");
        i=0;
        while(1) {
                if (i==num || i==num-1) break;
                if (FMStation[i].Frequency > FMStation[i+1].Frequency) {
                        memcpy(&FMStat,&FMStation[i],sizeof(GSM_FMStation));
                        memcpy(&FMStation[i],&FMStation[i+1],sizeof(GSM_FMStation));
                        memcpy(&FMStation[i+1],&FMStat,sizeof(GSM_FMStation));
                        i = 0;
                        continue;
                }
                i++;
        }
        for (i=0;i<num;i++) {
                fprintf(stderr,"%02i.",i+1);
                if (FMStation[i].Frequency < 100) fprintf(stderr," ");
                fprintf(stderr,"%.1f MHz - \"%s\" \n",
                        FMStation[i].Frequency,
                        DecodeUnicodeString(FMStation[i].StationName));
        }
        if (answer_yes2("Do you want to save found stations")) {
                fprintf(stderr,"Deleting old FM stations: ");
                error=Phone->ClearFMStations(&s);
                Print_Error(error);
                fprintf(stderr,"Done\n");
                for (i=0;i<num;i++) {
                        FMStation[i].Location = i+1;
                        error=Phone->SetFMStation(&s,&FMStation[i]);
                        Print_Error(error);
                        fprintf(stderr,"%cWriting: %i percent",13,(i+1)*100/num);
                }
                fprintf(stderr,"\n");
        }
        error=GSM_WaitFor (&s, Disable, 6, 0x3E, 4, ID_User3);
        Print_Error(error);
        GSM_Terminate();
 }
 #endif
 void DCT4PlaySavedRingtone(int argc, char *argv[])
 {
        unsigned char req[] =  {N6110_FRAME_HEADER, 
                                      0x01,
                                        0x00,0x64,//id
                                        0x01,   //group
                                0x01,0x00,0x00,
                                        0x0A,   //volume
                                0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        GSM_AllRingtonesInfo Info;
        GSM_Init(true);
        CheckDCT4();
        s.User.UserReplyFunctions=UserReplyFunctions4;
        error=Phone->GetRingtonesInfo(&s,&Info);
        Print_Error(error);
        if (atoi(argv[2]) > Info.Number-1) {
                GSM_Terminate();
                return;
        }
        req[4] = Info.Ringtone[atoi(argv[2])].ID / 256;
        req[5] = Info.Ringtone[atoi(argv[2])].ID % 256;
        req[6] = Info.Ringtone[atoi(argv[2])].Group;
        error=GSM_WaitFor (&s, req, 18, 0x1F, 4, ID_User3);
        Print_Error(error);
        //for (i=0;i<Info.Number;i++) printmsg("%i. \"%s\"\n",i,DecodeUnicodeConsole(Info.Ringtone[i].Name));
        GSM_Terminate();
 }
 static GSM_Error DCT4_ReplyMakeCameraShoot(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                return ERR_NONE;
 }
 void DCT4MakeCameraShoot(int argc, char *argv[])
 {
        unsigned char SetCamera[] = {N6110_FRAME_HEADER, 0x09, 0x01, 0x02};
        unsigned char CameraON[] = {N6110_FRAME_HEADER, 0x02, 0x01, 0x00, 0x00, 0x00 , 0x00, 0x00};
        unsigned char CameraON2[] = {N6110_FRAME_HEADER, 0xF0, 0x02, 0x00};
        unsigned char MakeShot[200] = {N6110_FRAME_HEADER, 0x06, 0x01, 0x06,
                0x01, 0x00, 0x00, 0x02, 0x00, 0x04, 0x32, 0x00, 0x01, 
                        0x1D,   //length of rest
                0x00, 0x00, 0x00, 0x01, 
                        0x00, 0x02,//master folder id
                        0x00, 0x14}; //length
        unsigned char CameraOFF[] = {N6110_FRAME_HEADER, 0x04, 0x01, 0x00};
        GSM_Init(true);
        CheckDCT4();
        s.User.UserReplyFunctions=UserReplyFunctions4;
        error=GSM_WaitFor (&s, SetCamera, 6, 0x61, 4, ID_User3);
        Print_Error(error);
        error=GSM_WaitFor (&s, CameraON, 10, 0x61, 4, ID_User3);
        Print_Error(error);
        error=GSM_WaitFor (&s, CameraON2, 6, 0x61, 4, ID_User3);
        Print_Error(error);
        EncodeUnicode(MakeShot+24,"GammuShot",9);
        MakeShot[15] = 9+9*2;
        MakeShot[23] = 9*2;
        error=GSM_WaitFor (&s, MakeShot, 24+MakeShot[23], 0x61, 4, ID_User3);
        Print_Error(error);
        error=GSM_WaitFor (&s, SetCamera, 6, 0x61, 4, ID_User3);
        Print_Error(error);
        error=GSM_WaitFor (&s, CameraOFF, 6, 0x61, 4, ID_User3);
        Print_Error(error);
        GSM_Terminate();
 }
 int len;
 static GSM_Error DCT4_ReplyGetScreenDump(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
        if (msg.Buffer[7] == 0x0C) len = 1;
                return ERR_NONE;
 }
 void DCT4GetScreenDump(int argc, char *argv[])
 {
        unsigned char req[] = {N6110_FRAME_HEADER, 0x07, 0x01, 0x00};
        //n6110_frameheader 06//screen info
        GSM_Init(true);
        CheckDCT4();
        s.User.UserReplyFunctions=UserReplyFunctions4;
        error=GSM_WaitFor (&s, req, 6, 0x0E, 4, ID_User3);
        Print_Error(error);
        len = 2000;
        while (len >= 200) GSM_ReadDevice(&s,true);
        GSM_Terminate();
 }
 static GSM_Reply_Function UserReplyFunctions4[] = {
 #ifdef DEBUG
                {DCT4_ReplyResetSecurityCode,   "\x08",0x03,0x05,ID_User2},
                {DCT4_ReplyResetSecurityCode,   "\x08",0x03,0x06,ID_User2},
 #endif
                {DCT4_ReplyGetScreenDump,       "\x0E",0x00,0x00,ID_User3},
                {DCT4_ReplyGetScreenDump,"\x0E",0x00,0x00,ID_IncomingFrame},
                {DCT4_ReplyGetADC,              "\x17",0x03,0x10,ID_User3},
                {DCT4_ReplyGetADC,              "\x17",0x03,0x12,ID_User3},
                {DCT4_ReplySetPPS,              "\x1b",0x03,0x05,ID_User1},
                {NOKIA_ReplyGetPhoneString,     "\x1B",0x03,0x08,ID_User6},
                {DCT4_ReplyVibra,               "\x1C",0x03,0x0D,ID_User3},
                {DCT4_ReplyVibra,               "\x1C",0x03,0x0F,ID_User3},
                {NoneReply,                     "\x1F",0x03,0x02,ID_User3},
                {DCT4_ReplyGetSecurityCode,     "\x23",0x03,0x05,ID_User1},
                {DCT4_ReplyGetT9,               "\x23",0x03,0x05,ID_User3},
                {DCT4_ReplyGetVoiceRecord,      "\x23",0x03,0x05,ID_User4},
                {DCT4_ReplyGetVoiceRecord,      "\x23",0x03,0x0D,ID_User4},
                {DCT4_ReplyGetSecurityCode,     "\x23",0x03,0x0D,ID_User1}, 
                {DCT4_ReplyTestsStartup,        "\x35",0x02,0x01,ID_User3},
                {DCT4_ReplyTestsStartup,        "\x35",0x02,0x02,ID_User3},
                {DCT4_ReplyTestsNames,          "\x35",0x02,0x03,ID_User1},
                {DCT4_ReplyTestsStatus,                 "\x35",0x02,0x04,ID_User2},
 #ifdef GSM_ENABLE_NOKIA6510
                {DCT4_ReplyTuneRadio,           "\x3E",0x03,0x09,ID_User3},
                {DCT4_ReplyTuneRadio,           "\x3E",0x03,0x15,ID_User3},
                {DCT4_ReplyTuneRadio,   "\x3E",0x03,0x15,ID_SetFMStation},
                {DCT4_ReplyTuneRadio,           "\x3E",0x03,0x16,ID_User3},
 #endif
                {DCT4_ReplyGetVoiceRecord,      "\x4A",0x03,0x31,ID_User4},
                {DCT4_ReplyGetSimlock,          "\x53",0x03,0x0D,ID_User6},
                {DCT4_ReplyGetSimlock,          "\x53",0x03,0x13,ID_User6},
                {DCT4_ReplyMakeCameraShoot,     "\x61",0x03,0x03,ID_User3},
                {DCT4_ReplyMakeCameraShoot,     "\x61",0x03,0x07,ID_User3},
                {DCT4_ReplyMakeCameraShoot,     "\x61",0x03,0x08,ID_User3},
                {DCT4_ReplyMakeCameraShoot,     "\x61",0x03,0x0A,ID_User3},
                {DCT4_ReplyMakeCameraShoot,     "\x61",0x03,0xF0,ID_User3},
                {DCT4_ReplyGetBTInfo,           "\xD7",0x03,0x0A,ID_User6},
                {NULL,                          "\x00",0x00,0x00,ID_None}
 };
 #endif
 /* How should editor hadle tabs in this file? Add editor commands here.
 * vim: noexpandtab sw=8 ts=8 sts=8:
 */
diff --git a/gammu/emb/gammu/depend/siemens/dsiemens.c b/gammu/emb/gammu/depend/siemens/dsiemens.c
index dc54102..a34bc3b 100644
--- a/gammu/emb/gammu/depend/siemens/dsiemens.c
+++ b/gammu/emb/gammu/depend/siemens/dsiemens.c
@@ -1,363 +1,363 @@
 /* (c) by Walek */
 #include "../../../common/gsmstate.h"
 #ifdef GSM_ENABLE_ATGEN
 #include <string.h>
 #include "../../../common/misc/coding/coding.h"
 #include "../../../common/gsmcomon.h"
 #include "../../../common/service/gsmnet.h"
 #include "../../../common/phone/at/atgen.h"
 #include "../../gammu.h"
 #include "dsiemens.h"
 #include "chiffre.h"
 extern GSM_Error  ATGEN_GetSIMIMSI (GSM_StateMachine *s, char *IMSI);
 extern GSM_Error  ATGEN_GetMemoryStatus (GSM_StateMachine *s, GSM_MemoryStatus *status);
 extern GSM_Error  ATGEN_SetMemory (GSM_StateMachine *s, GSM_MemoryEntry *pbk);
-extern GSM_Reply_Function UserReplyFunctionsAtS[];
+static GSM_Reply_Function UserReplyFunctionsAtS[];
        bool new_variable;
 GSM_Error CheckSiemens()
 {
        if (s.Phone.Data.Priv.ATGEN.Manufacturer != AT_Siemens) return ERR_NOTSUPPORTED;
        return ERR_NONE;
 }
 GSM_Error ATSIEMENS_Reply_GetSAT(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                GSM_Phone_ATGENData     *Priv = &s->Phone.Data.Priv.ATGEN;
                GSM_SAT_Measure_results         MeasureResult;
                unsigned char           buf[256];
        int                             length,i,rep,ChNo=1,j=0,result=0,origARFCN=0;
                int                     freq_tmp,frequency[24];
                GSM_NetworkInfo                 Network;
            if (Priv->ReplyState!=AT_Reply_OK) return ERR_UNKNOWN;
            if (s->Protocol.Data.AT.EditMode) s->Protocol.Data.AT.EditMode = false;
        if (strstr(GetLineString(msg.Buffer,Priv->Lines,2),"SSTK")) {
                length = strlen(GetLineString(msg.Buffer,Priv->Lines,2))-7;
                DecodeHexBin(buf, GetLineString(msg.Buffer,Priv->Lines,2)+7,length);
            if (buf[0]==0x7f) {
                new_variable=true;
                return ERR_NONE;
            } 
            else return ERR_UNKNOWN;
        }
            if (!strstr(GetLineString(msg.Buffer,Priv->Lines,3),"SSTK")) return ERR_UNKNOWN;
        
            length = strlen(GetLineString(msg.Buffer,Priv->Lines,3))-7;
            DecodeHexBin(buf, GetLineString(msg.Buffer,Priv->Lines,3)+7,length);
            if (buf[3]!=0x26) return ERR_UNKNOWN;
    
 #ifdef DEBUG
            dbgprintf ("SAT command: Provide Local Information\nFunction: ");
            switch (buf[4]) {
                        case 00: dbgprintf ("Loc Info\n");              break;
                        case 01: dbgprintf ("IMEI\n");                  break;
                        case 02: dbgprintf ("Network Measure\n");       break;
                        case 03: dbgprintf ("Date time and timezone\n");break;
                        case 04: dbgprintf ("Language setting\n");      break;
                        case 05: dbgprintf ("Timing advance\n");        break;
            }
 #endif
            /* Loc Info (MCC, MNC, LAC, Cell ID) */
            if (buf[4]==00) {
                DecodeBCD (Network.NetworkCode,buf+14,2);
                Network.NetworkCode[3] = ' ';
                DecodeBCD (Network.NetworkCode+4,buf+16,1);
                EncodeHexBin (Network.LAC,buf+17,2);
                EncodeHexBin (Network.CID,buf+19,2);
                printf("   Network code              : %s\n",Network.NetworkCode);
                printf("   Network name for Gammu    : %s\n",
                        DecodeUnicodeString(GSM_GetNetworkName(Network.NetworkCode)));
                printf("   CID   : %s\n",Network.CID);
                printf("   LAC   : %s\n",Network.LAC);
            }
            /* Network Measure */
            if (buf[4]==02) {
        
            for (i=0;i<24;i++) frequency[i]=0;
            if (!new_variable) {
                GetBufferI(buf+32,&j,&result,7);
                result &= 0x67;
                if (result !=0x47) return ERR_NOTSUPPORTED;
            }
 #ifdef DEBUG
                    if (new_variable)dbgprintf ("New variable Bitmap format\n");
                    else                dbgprintf ("Old variable Bitmap format\n");    
 #endif    
            GetBufferI(buf+32,&j,&origARFCN,10);
        /* 10 bit origin ARFCN or first frequency (new variable format) */
 #ifdef DEBUG
            dbgprintf("Origin BCCH = %i\n",origARFCN);
 #endif
            rep     = buf[31]*8;
            if (!new_variable ){
                    for (i=0;i<rep;i++){
                        result = 0; 
                    GetBufferI(buf+32,&j,&result,1);
                    if (result) {
                        frequency[ChNo]=i+origARFCN+1;
                        ChNo++;
                    }
                        }    
            } 
            else {
                frequency[ChNo++]=origARFCN;
                for (i=0; i<rep; i+=10){
                    result = 0;
                    GetBufferI(buf+32,&j,&result,10);
                    if (!result) break;
                    frequency[ChNo++]=result;
                }
                j=1;
                while (j) {
                    j=0;
                    for (i=0; i<ChNo-1; i++){
                        if (frequency[i] > frequency[i+1]){
                            freq_tmp=frequency[i];
                            frequency[i]=frequency[i+1];
                            frequency[i+1]=freq_tmp;
                            j=1;
                        }
                    }
                }
            };
 #ifdef DEBUG
            dbgprintf("Neighbor BCCH list: ");
        for (i=1;i<ChNo;i++) dbgprintf ("%d ",frequency[i]);
        dbgprintf ("\n");
 #endif
                j= 0;
                result= 0;
        GetBufferI(buf+14,&j,&result,1);
                if (result) MeasureResult.BA_used=true;
                else    MeasureResult.BA_used=false;
                result= 0;
        GetBufferI(buf+14,&j,&result,1);
                if (result) MeasureResult.DTX_used=true;
                else    MeasureResult.DTX_used=false;
        
                result= 0;
        GetBufferI(buf+14,&j,&result,6);
        MeasureResult.RXLEV_FullServicingCell=result-110;
        
                j++;//skip spare bit
                result= 0;
        GetBufferI(buf+14,&j,&result,1);
                if (result) MeasureResult.MeasValid=true;
                else    MeasureResult.MeasValid=false;
        
                result= 0;
        GetBufferI(buf+14,&j,&result,6);
        MeasureResult.RXLEV_SubServicingCell=result-110;
                j++;//skip spare bit
                result= 0;
        GetBufferI(buf+14,&j,&result,3);
        MeasureResult.RXQUAL_FullServicingCell=result;
        
                result= 0;
        GetBufferI(buf+14,&j,&result,3);
        MeasureResult.RXQUAL_SubServicingCell=result;
        
        printf ("RX Level FULL Servicing Cell = %i\n",MeasureResult.RXLEV_FullServicingCell);
        printf ("RX Level Sub Servicing Cell = %i\n",MeasureResult.RXLEV_FullServicingCell);
        printf ("RX Quality Full Servicing Cell = %i\n",MeasureResult.RXQUAL_FullServicingCell);
        printf ("RX Quality Sub Servicing Cell = %i\n",MeasureResult.RXQUAL_SubServicingCell);
                result= 0;
        GetBufferI(buf+14,&j,&result,3);
        MeasureResult.NO_NCELL_M=result;
        rep=MeasureResult.NO_NCELL_M;
        
        for (i=0;i<MeasureResult.NO_NCELL_M;i++) {
                    result= 0;
            GetBufferI(buf+14,&j,&result,6);
            MeasureResult.NeighbourCell[i].RxLev = result-110;
                    result= 0;
            GetBufferI(buf+14,&j,&result,5);
            if (new_variable)
                   MeasureResult.NeighbourCell[i].ChFreq = frequency[result+1];
            else   MeasureResult.NeighbourCell[i].ChFreq = frequency[result];
                    result= 0;
            GetBufferI(buf+14,&j,&result,3);
            MeasureResult.NeighbourCell[i].NB = 10 * result;
                    result= 0;
            GetBufferI(buf+14,&j,&result,3);
            MeasureResult.NeighbourCell[i].NB +=  result;
            if (MeasureResult.NeighbourCell[i].ChFreq)
                printf("CH = %i,\t",MeasureResult.NeighbourCell[i].ChFreq);
            else
                printf("CH = Unknown\t");
                printf("RX Lev = %i dBm\t",MeasureResult.NeighbourCell[i].RxLev);
                printf("BSIC CELL = %i\n",MeasureResult.NeighbourCell[i].NB);
            }
            }
 #ifdef DEBUG
                if  (buf[4]==05) {                      //Timing Advance
                if (buf[11]) dbgprintf ("Unknown Timing Advance\n");
                else dbgprintf ("Timing Advance = %i\n",buf[14] & 0x3f);
            }
 #endif
            return ERR_NONE;
 }
 GSM_Error ATSIEMENS_Reply_GetNetmon(GSM_Protocol_Message msg, GSM_StateMachine *s)
 {
                GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                int             i=2;
    
            if (!strstr(GetLineString(msg.Buffer,Priv->Lines,1),"AT^S^MI")) return ERR_UNKNOWN;
            while (strlen(GetLineString(msg.Buffer,Priv->Lines,i+1)))   
                printf("%s\n",GetLineString(msg.Buffer,Priv->Lines,i++));
            printf("\n");
            return ERR_NONE;
 }
 GSM_Error ATSIEMENS_GetSAT(GSM_StateMachine *s)
 {
                GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                GSM_Error       error;
                unsigned char   *reqSAT[]= {"D009810301260082028182",
                                                "D009810301260282028182",
                                                "D009810301260582028182"},req[32];
                int             i,len;
        
            if (Priv->Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
        
        sprintf(req, "AT^SSTK=?\r");
        error = GSM_WaitFor (s, req, strlen(req), 0x00, 3, ID_User1); 
        
            for (i=0;i<3;i++){
                        len                     = strlen(reqSAT[i]);
                        s->Protocol.Data.AT.EditMode = true;
                sprintf(req, "AT^SSTK=%i,1\r",len/2);
                error = GSM_WaitFor (s, req, strlen(req), 0x00, 3, ID_User1); 
                        s->Phone.Data.DispatchError= ERR_TIMEOUT;
                        s->Phone.Data.RequestID         = ID_User1;
                error = s->Protocol.Functions->WriteMessage(s, reqSAT[i], len, 0x00);
                if (error!=ERR_NONE) return error;
                error = s->Protocol.Functions->WriteMessage(s, "\x1A", 1, 0x00);
                if (error!=ERR_NONE) return error;
                error = GSM_WaitForOnce (s, NULL,0x00, 0x00, 4);
                if (error!=ERR_NONE) return error;
            }
            return ERR_NONE;
 }
 GSM_Error ATSIEMENS_GetNetmon(GSM_StateMachine *s,int test_no)
 {
                GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                unsigned char   req[32];
        
        if (Priv->Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
        sprintf(req, "AT^S^MI=%d\r",test_no);
        printf ("Siemens NetMonitor test #%i\n",test_no); 
        return GSM_WaitFor(s, req, strlen(req), 0x00, 3, ID_User2);
 }
 GSM_Error ATSIEMENS_ActivateNetmon (GSM_StateMachine *s,int netmon_type)
 {
                GSM_Phone_ATGENData*Priv = &s->Phone.Data.Priv.ATGEN;
                unsigned char   req[32];
        
        if (Priv->Manufacturer!=AT_Siemens) return ERR_NOTSUPPORTED;
        sprintf(req, "AT\r");
        printf ("Activate Siemens NetMonitor\n"); 
        siemens_code (req,req,2);
        return GSM_WaitFor(s, req, strlen(req), 0x00, 3, ID_User2);
 }
 void ATSIEMENSActivateNetmon(int argc, char *argv[])
 {
        GSM_MemoryStatus status;
                GSM_MemoryEntry pbk;
                int      netmon_type, pbk_maxlocation;
                char     imsi[15], NetMonCode[32];
        GSM_Init(true);
        if (CheckSiemens()==ERR_NOTSUPPORTED) Print_Error(ERR_NOTSUPPORTED);
        s.User.UserReplyFunctions=UserReplyFunctionsAtS;
        printf ("Activate NetMonitor...\n");
        netmon_type = atoi(argv[2]);
                        
        if ((netmon_type==1) || (netmon_type==2)) {
            error   = ATGEN_GetSIMIMSI (&s,imsi);
                    Print_Error(error);    
            siemens_code(imsi,NetMonCode,netmon_type);
            
            status.MemoryType = MEM_SM;
            error = ATGEN_GetMemoryStatus (&s,&status);
            Print_Error(error);
            pbk_maxlocation = status.MemoryUsed+status.MemoryFree;
            pbk.MemoryType = MEM_SM;
            pbk.Location = pbk_maxlocation;
            pbk.EntriesNum = 2;
            pbk.Entries[0].EntryType = PBK_Number_General;
            EncodeUnicode (pbk.Entries[0].Text,NetMonCode,strlen(NetMonCode));
            pbk.Entries[1].EntryType = PBK_Text_Name;
                    sprintf (NetMonCode,"Net Monitor");
            EncodeUnicode (pbk.Entries[1].Text,NetMonCode,strlen(NetMonCode));
            error = ATGEN_SetMemory (&s, &pbk);
                    Print_Error(error);
        }
        else printf ("NetMonitor type should be:\n1 - full Netmon\n2 - simple NetMon\n");
    
        GSM_Terminate();
 }
 void ATSIEMENSSATNetmon(int argc, char *argv[])
 {
        GSM_Init(true);
        if (CheckSiemens()==ERR_NOTSUPPORTED) Print_Error(ERR_NOTSUPPORTED);
        s.User.UserReplyFunctions=UserReplyFunctionsAtS;
        printf ("Getting Siemens Sim Aplication Toolkit NetMonitor...\n");
        error=ATSIEMENS_GetSAT(&s);    
        Print_Error(error);    
        GSM_Terminate();
 }
 void ATSIEMENSNetmonitor(int argc, char *argv[])
 {
        int test_no;
        GSM_Init(true);
        if (CheckSiemens()==ERR_NOTSUPPORTED) Print_Error(ERR_NOTSUPPORTED);
        s.User.UserReplyFunctions=UserReplyFunctionsAtS;
        printf ("Getting Siemens NetMonitor...\n");
        test_no = atoi(argv[2]);
        error   = ATSIEMENS_GetNetmon (&s,test_no+1);
        Print_Error(error);
        GSM_Terminate();
 }
 static GSM_Reply_Function UserReplyFunctionsAtS[] = {
                {ATSIEMENS_Reply_GetSAT,        "AT^SSTK",      0x00,0x00,ID_User1},
                {ATSIEMENS_Reply_GetNetmon,     "AT^S^MI",      0x00,0x00,ID_User2},
                {NULL,                          "\x00",                 0x00,0x00,ID_None}
 };
 #endif
 /* How should editor hadle tabs in this file? Add editor commands here.
 * vim: noexpandtab sw=8 ts=8 sts=8:
 */
author	zautrix <zautrix>	2006-02-24 19:41:06 (UTC)
committer	zautrix <zautrix>	2006-02-24 19:41:06 (UTC)
commit	4e2553b95b2787ed7917073f6b628819b1f017c3 (patch) (unidiff)
tree	da5cb746bf3373cb2a368afda082999e6c22751f /gammu
parent	08605356c77351d64e14e0fdd69bdb769f933909 (diff)
download	kdepimpi-4e2553b95b2787ed7917073f6b628819b1f017c3.zip kdepimpi-4e2553b95b2787ed7917073f6b628819b1f017c3.tar.gz kdepimpi-4e2553b95b2787ed7917073f6b628819b1f017c3.tar.bz2