gcc4 fixes

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,251 +1,251 @@
 /* (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*/
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,210 +1,210 @@
 /* (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;
 
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,223 +1,223 @@
 /**
  * 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 */
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,208 +1,208 @@
 /* (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},
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,212 +1,212 @@
 /* (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);