--- /dev/null
+/*
+
+ $Id$
+
+ G N O K I I
+
+ A Linux/Unix toolset and driver for Nokia mobile phones.
+
+ Copyright (C) 2001 Jan Kratochvil,
+ based on code by Hugh Blemings & Pavel JanÃk ml.
+
+ Released under the terms of the GNU GPL, see file COPYING for more details.
+
+ This file provides an API for accessing functions on AT (Hayes) command
+ compatible hardware modems such as Siemens M20.
+ See README-AT for more details on supported mobile phones and GSM modems.
+
+ The various routines are called ATHW (whatever) as a concatenation of AT
+ and HardWare communication type.
+
+ $Log$
+ Revision 1.1.1.1 2002/04/03 00:08:02 short
+ Found in "gnokii-working" directory, some November-patches version
+
+
+*/
+
+#define ATHW_DEBUG 1
+/* #define DISABLE_CMGF0 1 */ /* Force AT+CMGF=1 on phones capable +CMGF=0 */
+
+/* System header files */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <limits.h>
+
+
+#ifdef WIN32
+
+#include <windows.h>
+#include "win32/winserial.h"
+
+#undef IN
+#undef OUT
+
+#define WRITEPHONE(a, b, c) WriteCommBlock(b, c)
+#define sleep(x) Sleep((x) * 1000)
+#define usleep(x) Sleep(((x) < 1000) ? 1 : ((x) / 1000))
+extern HANDLE hPhone;
+
+#else
+
+#define WRITEPHONE(a, b, c) device_write(b, c)
+#include <unistd.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <pthread.h>
+#include <errno.h>
+#include "device.h"
+#include "devices/unixserial.h"
+
+#endif
+
+/* Various header file */
+
+#include "config.h"
+#include "misc.h"
+#include "gsm-common.h"
+
+/* Global variables used by code in gsm-api.c to expose the functions
+ supported by this model of phone. */
+
+
+#if __unices__
+/* fd opened in device.c */
+extern int device_portfd;
+#endif
+
+/* Our private defines */
+
+#define ATHW_CME_NOT_FOUND (22) /* +CME ERROR: 22 */
+#define ATHW_CMS_INVALID_MEMORY_INDEX (321) /* +CMS ERROR: 321 */
+
+/* When now catchbuffer was provided and must have some space to decode
+ * OK/ERROR/... result codes.
+ */
+#define ATHW_CATCHBUFFER_LENGTH 0x400
+
+/* Default message reference, filled-in by GSM modem
+ */
+#define ATHW_PDU_MR_DEFAULT (0x00)
+
+/* Maximum PDU size in bytes
+ */
+#define GNOKII_MAX_PDU_LENGTH (64+GSM_MAX_DESTINATION_LENGTH/2+(GSM_MAX_SMS_LENGTH*7)/8)
+
+/* Local variables */
+
+
+#ifndef WIN32
+static char PortDevice[GSM_MAX_DEVICE_NAME_LENGTH];
+#endif
+static bool RequestTerminate;
+static GSM_MemoryType ATHW_CurrentMemoryType=GMT_XX;
+static int ATHW_CurrentCMGF=-1;
+static bool ATHW_CMGS_CMGF1_8bit_HaveBinHex; /* AT+CMGS in +CMGF==1 and 8bit mode accepts hexstring */
+static bool ATHW_HaveCNMI=false;
+static bool ATHW_HaveSiemensMGR=false; /* "AT^SMGR" supported? */
+static bool ATHW_HaveSiemensMGL=false; /* "AT^SMGL" supported? */
+static int ATHW_CNMI_count=-1; /* value (-1) means it is not yet known */
+
+/* We don't know whether we should place SMSC in the front of +CMGS PDU
+ * so we will try both methods.
+ * When we will at least once successfuly send a message, we will *_force-it
+ * as the probability of wrong settings and successful message send is REALLY low. :-)
+ * (Maybe not so low when we will try to send prefix and no prefix is expected,
+ * this is also the reason why we will first try to NOT to send the prefix as we
+ * would have to successfuly hit some valid SMS center by the initial part of PDU.)
+ * Note: Applicable only if +CMGF==0
+ */
+static bool ATHW_CurrentSMSCPrefix=false;
+static bool ATHW_CurrentSMSCPrefix_force=false;
+/* Always try 4 retries - w/o prefix, w/prefix, w/o prefix again, w/prefix again, fail
+ * This number should be probable even to give some 'stability' when all SMSes are failing
+ */
+#define ATHW_CURRENTSMSCPREFIX_RETRIES (4)
+
+/* Please see the comment above ATHW_SaveSMS_StatSupported_solve().
+ * Number of retry sessions before giving up sending SMS <stat> during SaveSMS.
+ */
+#define ATHW_SAVESMS_STATSUPPORTED_RETRIES (2)
+
+
+static char ATHW_CatchBuffer[ATHW_CATCHBUFFER_LENGTH];
+static char *ATHW_CatchBufferPtr=ATHW_CatchBuffer; /* current destination writing ptr */
+static char *ATHW_CatchBufferMarker; /* marks begin of currently catched stream */
+static GSM_Error *ATHW_CatchBufferErrorP;
+
+static long ATHW_RX_Patrol_CME_ERROR_code;
+static long ATHW_RX_Patrol_CMS_ERROR_code;
+
+typedef char *(*ATHW_RX_PatrolFunc)(char *after);
+typedef void (*ATHW_RX_PatrolReset)(void);
+
+struct ATHW_RX_Patrol {
+ const char *buoy;
+ ATHW_RX_PatrolFunc func;
+ ATHW_RX_PatrolReset reset;
+ };
+
+static const struct ATHW_RX_Patrol *ATHW_RX_Patrol_Current;
+
+static void ATHW_CatchBufferReset(void);
+static void ATHW_CatchBufferMarkStart(GSM_Error *errorcodep);
+
+#ifndef WIN32
+
+static pthread_t Thread;
+# if __unices__
+static pthread_t selThread;
+# endif
+
+#endif
+
+/* Local variables used by get/set phonebook entry code. Buffer is used as a
+ source or destination for phonebook data and other functions... Error is
+ set to GE_NONE by calling function, set to GE_COMPLETE or an error code by
+ handler routines as appropriate. */
+
+static GSM_MemoryStatus *CurrentMemoryStatus;
+static GSM_Error CurrentMemoryStatusError;
+
+static GSM_PhonebookEntry *CurrentPhonebookEntry;
+static GSM_Error CurrentPhonebookError;
+
+static GSM_SMSMessage *CurrentSMSMessage;
+static char *CurrentSMSMessagePDU; /* hex string representation for +CMGF=0 patrol */
+static size_t CurrentSMSMessagePDU_size; /* used only if (+CMGF==0), size in bytes */
+static GSM_Error CurrentSMSMessageError;
+
+static GSM_SMSStatus *CurrentSMSStatus;
+static GSM_Error CurrentSMSStatusError;
+
+static GSM_MessageCenter *CurrentMessageCenter;
+static GSM_Error CurrentMessageCenterError;
+
+static float *CurrentRFLevel; /* AT+CSQ */
+static GSM_Error GetRFLevelError;
+
+static float *CurrentBatteryLevel; /* AT+CBC */
+static GSM_Error GetBatteryLevelError;
+
+static GSM_PowerSource *CurrentPowersource; /* AT+CBC */
+static GSM_Error GetPowersourceError;
+
+static GSM_Error DialVoiceError;
+
+static GSM_Error CancelCallError;
+
+static GSM_Error CurrentPhoneInfoError;
+
+static unsigned char Manufacturer[GSM_MAX_MANUFACTURER_LENGTH];
+static unsigned char Model[GSM_MAX_MODEL_LENGTH];
+static unsigned char Revision[GSM_MAX_REVISION_LENGTH];
+static unsigned char IMEI[GSM_MAX_IMEI_LENGTH];
+
+static char CurrentIncomingCall[20] = " ";
+
+static GSM_NetworkInfo *CurrentNetworkInfo;
+static GSM_Error CurrentNetworkInfoError;
+
+
+/* Pointer to a callback function used to return changes to a calls status */
+/* This saves unreliable polling */
+static void (*CallPassup)(char c);
+
+
+/* "catchbufer" can be provided as NULL:
+ * - sizeof() will be bogus but it will be ingored anyway
+ */
+
+static void ATHW_TX_SendCommand(GSM_Error *errorcodep,const struct ATHW_RX_Patrol *patrol,const char *fmt,...) G_GNUC_PRINTF(3,4);
+static void ATHW_TX_SendCommand(GSM_Error *errorcodep,const struct ATHW_RX_Patrol *patrol,const char *fmt,...)
+{
+char *command;
+size_t command_len;
+va_list ap;
+int writephone_got;
+
+ if (errorcodep)
+ *errorcodep=GE_BUSY;
+ ATHW_RX_Patrol_Current=patrol;
+
+ va_start(ap,fmt);
+ command_len=gvasprintf(&command,fmt,ap);
+ va_end(ap);
+ if (-1==command_len) {
+ if (errorcodep)
+ *errorcodep=GE_INTERNALERROR;
+ return;
+ }
+
+ ATHW_CatchBufferMarkStart(errorcodep);
+
+ writephone_got=WRITEPHONE(PortFD, command, command_len);
+
+#ifdef ATHW_DEBUG
+ write(1,"CMD:",4);
+ write(1,command,command_len);
+ write(1,"\n",1);
+#endif
+
+ free(command);
+ if (command_len!=writephone_got) {
+ if (errorcodep)
+ *errorcodep=GE_INTERNALERROR;
+ return;
+ }
+
+ /* success but we don't wait for the result code */
+}
+
+/* This function is used to get storage status from the phone. It currently
+ supports two different memory areas - internal and SIM. */
+
+static GSM_Error
+wait_on(volatile GSM_Error *what, int timeout)
+{
+GSM_Error r=GE_TIMEOUT; /* shut up GCC when (timeout==0) */
+
+ while (timeout && ((r=*what)==GE_BUSY)) {
+ if (!--timeout) {
+ r=GE_TIMEOUT;
+ break;
+ }
+ usleep(100000);
+ }
+ /* any specific patrollers are no longer valid */
+ ATHW_RX_Patrol_Current=NULL;
+
+#ifdef ATHW_DEBUG
+ printf("wait_on finish, timeout=%d\n",(r==GE_TIMEOUT));
+#endif
+
+ return(r);
+}
+
+#define WAIT_ON(what, timeout) \
+ do { \
+ GSM_Error res = wait_on(what, timeout); \
+ if (res != GE_NONE) \
+ return res; \
+ } while (0)
+
+/* I hope GCC gets this bunch optimized on the normal the normal errorcodep!=NULL case
+ */
+#define ATHW_TX_SENDCOMMAND_WAIT_ON(errorcodep,timeout,patrol,args...) \
+ do { \
+GSM_Error _ATHW_TX_SENDCOMMAND_WAIT_ON_err,*_ATHW_TX_SENDCOMMAND_WAIT_ON_errp; \
+ \
+ if (!(_ATHW_TX_SENDCOMMAND_WAIT_ON_errp=(errorcodep))) \
+ _ATHW_TX_SENDCOMMAND_WAIT_ON_errp=&_ATHW_TX_SENDCOMMAND_WAIT_ON_err; \
+ ATHW_TX_SendCommand(_ATHW_TX_SENDCOMMAND_WAIT_ON_errp,(patrol),args); \
+ WAIT_ON(_ATHW_TX_SENDCOMMAND_WAIT_ON_errp,(timeout)); \
+ } while (0)
+
+
+#define ATHW_ERR_WRAPPER(expr) \
+ do { \
+ GSM_Error err=(expr); \
+ if (err!=GE_NONE) \
+ return(err); \
+ } while (0)
+
+/* Currently we use a heuristic for extraction as at least Nokia 9000i doesn't
+ * escape quote characters even if they are inside enquoted strings!
+ * When we find -- ", -- we assume it is the separator although it may be false!
+ * Hmm, Siemens M20 has the same broken behaviour.
+ */
+static void ATHW_ExtractString(char *dest,size_t destlen,char *src,int element_no)
+{
+char *srcend,*start,*end;
+
+ *dest='\0';
+ if (!(srcend=strchr(src,'\n')))
+ return; /* INTERNAL error! */
+ do {
+ while (*src==' ') src++;
+ if (*src!='"') {
+ start=src;
+ while (src<srcend && *src!=',') src++;
+ end=src;
+ }
+ else { /* *src=='"' */
+ start=++src;
+ while (src<srcend && !(src[0]=='"' && (src[1]==',' || src+1==srcend))) src++;
+ end=src;
+ if (*src=='"')
+ src++;
+ }
+ while (*src==' ') src++;
+ if (*src==',')
+ src++;
+ /* here we have <start..end) as the current element */
+ } while (element_no--);
+
+ if (destlen-1<end-start)
+ end=start+destlen-1;
+
+ memcpy(dest,start,end-start);
+ dest[end-start]='\0';
+}
+
+#define ATHW_EXTRACTSTRING(dest,src,element_no) (ATHW_ExtractString((dest),sizeof((dest)),(src),(element_no)))
+
+static long ATHW_ExtractNumber(char *src,int element_no)
+{
+char buf[32],*end=NULL;
+long r;
+
+ ATHW_EXTRACTSTRING(buf,src,element_no);
+ r=strtol(buf,&end,10);
+ if (!*buf || (end && *end))
+ return(LONG_MIN);
+ return(r);
+}
+
+/* s/^\s+//; s/\s+$//; s/\s+/ /g; */
+
+static void ATHW_BufferTrimCopy(char *d_buf,size_t d_len,const char *s)
+{
+char *d_end=d_buf+d_len,*d;
+
+ for (d=d_buf;*s && d<d_end -1/*Terminating '\0'*/ ;s++) {
+ if (isspace(*s)) {
+ if (d==d_buf || d[-1]==' ')
+ continue;
+ *d++=' ';
+ continue;
+ }
+ *d++=*s;
+ }
+ if (d>d_buf && d[-1]==' ')
+ d--;
+ *d='\0';
+}
+
+#define ATHW_BUFFERTRIMCOPY_OFFSET(d,s,offset) (ATHW_BufferTrimCopy((d)+(offset),sizeof((d))-(offset),(s)))
+#define ATHW_BUFFERTRIMCOPY(d,s) (ATHW_BUFFERTRIMCOPY_OFFSET((d),(s),0))
+
+static GSM_Error ATHW_GetPhoneInfo(void)
+{
+/* +CGMI=Request Manufacturer Identification
+ * +CGMM=Request Model Identification
+ * +CGMR=Request Revision Identification
+ * +CGSN=Request Product Serial Number Identification (IMEI)
+ */
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentPhoneInfoError/*errorcodep*/,20/*timeout*/,NULL/*patrol*/,"/AT+CGMI\r");
+ ATHW_BUFFERTRIMCOPY(Manufacturer,ATHW_CatchBufferMarker);
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentPhoneInfoError/*errorcodep*/,20/*timeout*/,NULL/*patrol*/,"/AT+CGMM\r");
+ ATHW_BUFFERTRIMCOPY_OFFSET(Model,ATHW_CatchBufferMarker,3);
+ memcpy(Model,"AT-",3);
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentPhoneInfoError/*errorcodep*/,20/*timeout*/,NULL/*patrol*/,"/AT+CGMR\r");
+ ATHW_BUFFERTRIMCOPY(Revision,ATHW_CatchBufferMarker);
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentPhoneInfoError/*errorcodep*/,20/*timeout*/,NULL/*patrol*/,"/AT+CGSN\r");
+ ATHW_BUFFERTRIMCOPY(IMEI,ATHW_CatchBufferMarker);
+
+ return(GE_NONE);
+}
+
+static unsigned char ATHW_SMStoFO(GSM_SMSMessage *SMS)
+{
+ return(0
+ |((SMS->Type==GST_MO)<<0)
+ |(2<<3) /*<vp>=integer*/
+ |0 /* bit 5 is Status Report Request, not supported */
+ |((!!SMS->UDHPresent)<<6) /*UDH set*/
+ |((!!SMS->ReplyViaSameSMSC)<<7) /*ReplyPath*/
+ );
+}
+
+static unsigned char ATHW_SMStoDCS(GSM_SMSMessage *SMS)
+{
+int class=(SMS->Class==-1 ? 1 : SMS->Class); /* we default to class 1 (Mobile Equipment target) */
+
+ if (!SMS->EightBit && class==1)
+ return(0x00);
+ return(0xF0 | ((!!SMS->EightBit)<<2) | ((class&0x03)<<0));
+}
+
+/* Nokia 9000i: We need to temporarily turn on ECHO otherwise we wouldn't got the "\n> " prompt
+ * (At least Siemens M20 doesn't have this broken behaviour.)
+ */
+static GSM_Error ATHW_SMS_CMGF01_pre(void)
+{
+ if (ATHW_CurrentCMGF==1) {
+ /* We just cannot send UDH header in pure CMGF 1 mode */
+ if (CurrentSMSMessage->UDHPresent && (!CurrentSMSMessage->EightBit || !ATHW_CMGS_CMGF1_8bit_HaveBinHex))
+ return(GE_INTERNALERROR);
+
+ /* AT+CSMP=<fo>,<vp>,<pid>,<dcs> */
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentSMSMessageError/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "AT+CSMP=%d,%d,%d,%d\r",
+ /* <fo>: */ ATHW_SMStoFO(CurrentSMSMessage),
+ /* <vp>: */ SMS_Validity_to_VP(CurrentSMSMessage->Validity),
+
+ /* FIXME: Should we query current "MessageCenter.No" to get "Format" field? */
+ /* <pid>: */ (unsigned char)CurrentSMSMessage->MessageCenter.Format,
+
+ /* <dcs>: */ ATHW_SMStoDCS(CurrentSMSMessage)
+ );
+ }
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentSMSMessageError/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "ATE1\r");
+
+ return(GE_NONE);
+}
+
+static GSM_Error ATHW_SMS_CMGF01_post(void)
+{
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentSMSMessageError/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "ATE0\r");
+
+ return(GE_NONE);
+}
+
+/* For now we just kick out all quotes in the source "string" as no escaping
+ * method was found on Nokia 9000i - what the other ones?
+ */
+static const char *ATHW_Enquote(const char *string)
+{
+
+#define ATHW_ENQUOTE_SLOTS (4)
+
+struct ATHW_Enquote_slot {
+ char *buf;
+ size_t len;
+ };
+
+static struct ATHW_Enquote_slot slots[ATHW_ENQUOTE_SLOTS];
+static struct ATHW_Enquote_slot *slot=slots;
+size_t stringl=strlen(string);
+char *d;
+const char *r,*s;
+
+ if (slot->len<1+stringl+1+1) { /* "string"\0 */
+char *newbuf;
+size_t newlen=(!slot->len ? 0x100 : slot->len*2);
+
+ if (!(newbuf=realloc(slot->buf,newlen)))
+ return(NULL);
+ slot->buf=newbuf;
+ slot->len=newlen;
+ }
+
+ d=slot->buf;
+ *d++='"';
+ for (s=string;*s;s++) {
+ if (*s=='"')
+ continue;
+ *d++=*s;
+ }
+ *d++='"';
+ *d++='\0';
+
+ r=slot->buf;
+ if (++slot>=slots+ARRAY_LEN(slots))
+ slot=slots;
+ return(r);
+}
+
+static char *ATHW_PhoneSetup_CMGF1_Detect_Patrol_9(char *after)
+{
+ /* We got at least echo of the initial "9" digit.
+ * Nokia 9000i/9110i/CardPhone will echo even "Q" followed by ERROR,
+ * but Nokia 9210 will give ERROR immediately (w/o echo of "Q").
+ * When the feature is not supported we will get GE_TIMEOUT and
+ * ATHW_CMGS_CMGF1_8bit_HaveBinHex will be reset to "false" by the error check
+ * in ATHW_PhoneSetup_CMGF1_Detect_core().
+ */
+ ATHW_CMGS_CMGF1_8bit_HaveBinHex=true;
+
+ WRITEPHONE(PortFD,"Q",1);
+
+ /* We don't need to patrol for "Q", its detection would be cross-phone
+ * incompatible.
+ */
+
+ return(after); /* eat line - it will be just one character... */
+}
+
+static const struct ATHW_RX_Patrol ATHW_PhoneSetup_CMGF1_Detect_Patrol_9_struct=
+ { "9",ATHW_PhoneSetup_CMGF1_Detect_Patrol_9 };
+
+static char *ATHW_PhoneSetup_CMGF1_Detect_Patrol_GT_SPACE(char *after)
+{
+ WRITEPHONE(PortFD,"9",1);
+ ATHW_RX_Patrol_Current=&ATHW_PhoneSetup_CMGF1_Detect_Patrol_9_struct;
+ return(after); /* eat line - it will be just one character... */
+}
+
+static const struct ATHW_RX_Patrol ATHW_PhoneSetup_CMGF1_Detect_Patrol_GT_SPACE_struct=
+ { "\n> ",ATHW_PhoneSetup_CMGF1_Detect_Patrol_GT_SPACE };
+
+/* ATHW_CMGS_CMGF1_8bit_HaveBinHex feature is AFAIK present on Nokia 9000i/9110
+ * and also on Nokia CardPhone (but CardPhone supports +CMGF==0 so it is useless there).
+ * On Nokia 9000i we will detect the feature as present although it cannot be used
+ * for logo/ring sending as it will later fail to set UDH bit in FO by AT+CSMP.
+ */
+static GSM_Error ATHW_PhoneSetup_CMGF1_Detect_core(void)
+{
+GSM_SMSMessage sms;
+
+ ATHW_CMGS_CMGF1_8bit_HaveBinHex=false; /* default */
+
+ /* We need to reset the catchbuffer as we would otherwise
+ * catch some completely bogus previous output.
+ * We are called only during phone setup so here is no risk in loosing
+ * some unsolicited result codes.
+ */
+ ATHW_CatchBufferReset();
+
+ CurrentSMSMessage=&sms;
+ /* for ATHW_SMStoFO(): */
+ CurrentSMSMessage->UDHPresent=false;
+ CurrentSMSMessage->Type=GST_MO;
+ CurrentSMSMessage->UDHPresent=false; /* warning: it would fail on Nokia 9000i or Siemens M20! */
+ CurrentSMSMessage->ReplyViaSameSMSC=false;
+ /* for SMS_Validity_to_VP(): */
+ CurrentSMSMessage->Validity=GSMV_72_Hours; /* default */
+ /* for ATHW_SMS_CMGF01_pre(): */
+ CurrentSMSMessage->MessageCenter.Format=GSMF_Text;
+ /* for ATHW_SMStoDCS(): */
+ CurrentSMSMessage->EightBit=true; /* IMPORTANT!: The ONLY meaning of the whole procedure! */
+ CurrentSMSMessage->Class=1;
+ /* Do proper AT+CSMP= and also ATE1 */
+ ATHW_SMS_CMGF01_pre();
+
+ ATHW_TX_SendCommand(&CurrentSMSMessageError/*errorcodep*/,&ATHW_PhoneSetup_CMGF1_Detect_Patrol_GT_SPACE_struct/*patrol*/,
+ "AT+CMGS=%s\r",ATHW_Enquote("123456"/*just some test number*/));
+
+ /* Timeout 5 is too small for Nokia 9000i, give it a rest...
+ */
+ if (GE_TIMEOUT==wait_on(&CurrentSMSMessageError,20/*timeout*/))
+ ATHW_CMGS_CMGF1_8bit_HaveBinHex=false;
+
+ return(GE_NONE);
+}
+
+static GSM_Error ATHW_PhoneSetup_CMGS_Reset(void)
+{
+GSM_Error err;
+int retry;
+
+ /* We try to escape AT+CMGS mode, at least Siemens M20 then needs to get some rest
+ */
+ WRITEPHONE(PortFD,"\x1B\r",2);
+ usleep(500000);
+
+ ATHW_CatchBufferReset(); /* output can be very bogus due to escaping */
+
+ for (retry=0;retry<3;retry++) {
+ ATHW_TX_SendCommand(&err/*errorcodep*/,NULL/*patrol*/,
+ "AT\r");
+ if (wait_on(&err,10/*timeout*/)==GE_NONE)
+ return(err); /* success */
+ }
+ /* Hmm, we've probably stucked the phone :-(
+ */
+ return(err); /* failure */
+}
+
+static void ATHW_PhoneSetup_CMGF1_Detect(void)
+{
+ ATHW_PhoneSetup_CMGF1_Detect_core(); /* errors of the detection are ignored */
+ ATHW_PhoneSetup_CMGS_Reset();
+ ATHW_SMS_CMGF01_post(); /* turn off echo */
+#ifdef ATHW_DEBUG
+ printf("ATHW_PhoneSetup_CMGF1_Detect: ATHW_CMGS_CMGF1_8bit_HaveBinHex=%d\n",(int)ATHW_CMGS_CMGF1_8bit_HaveBinHex);
+#endif
+}
+
+static GSM_Error ATHW_PhoneSetup_CMGFSet(int CMGF)
+{
+ ATHW_CurrentCMGF=-1;
+ ATHW_TX_SENDCOMMAND_WAIT_ON(NULL/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "AT+CMGF=%d\r",CMGF);
+ ATHW_CurrentCMGF=CMGF;
+
+ if (CMGF==1)
+ ATHW_PhoneSetup_CMGF1_Detect();
+
+ return(GE_NONE);
+}
+
+static GSM_Error ATHW_PhoneSetup(void)
+{
+GSM_Error err;
+
+ ATHW_CurrentMemoryType=GMT_XX; /* invalidate */
+
+ ATHW_PhoneSetup_CMGS_Reset();
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(NULL/*errorcodep*/,60/*timeout*/,NULL/*patrol*/,
+ "AT&F\r");
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(NULL/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "ATE0\r");
+ ATHW_TX_SENDCOMMAND_WAIT_ON(NULL/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "AT+CSDH=1\r");
+ ATHW_TX_SENDCOMMAND_WAIT_ON(NULL/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "AT+CMEE=1\r");
+ ATHW_TX_SENDCOMMAND_WAIT_ON(NULL/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "AT+CRC=1\r"); /* request "+CRING: VOICE" reporting */
+
+ /* Try to detect Siemens M20 with M1 backward compatibility mode */
+ ATHW_TX_SendCommand(&err/*errorcodep*/,NULL/*patrol*/,
+ "AT+CSMS=128\r");
+ if (GE_NONE==wait_on(&err,10/*timeout*/)) {
+ ATHW_CurrentSMSCPrefix=true; /* it will be true ASAP +CMGS=0 is done */
+ ATHW_CurrentSMSCPrefix_force=true;
+ }
+ ATHW_TX_SENDCOMMAND_WAIT_ON(NULL/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "AT+CSMS=0\r"); /* turn on ATHW_CurrentSMSCPrefix, if possible */
+
+#ifndef DISABLE_CMGF0
+ if (GE_NONE!=ATHW_PhoneSetup_CMGFSet(0))
+#endif
+ ATHW_PhoneSetup_CMGFSet(1);
+
+ ATHW_TX_SendCommand(&err/*errorcodep*/,NULL/*patrol*/,
+ "AT^SMGR=?\r"); /* it should just return "\nOK\n" */
+ ATHW_HaveSiemensMGR=(GE_NONE==wait_on(&err,10/*timeout*/));
+ ATHW_TX_SendCommand(&err/*errorcodep*/,NULL/*patrol*/,
+ "AT^SMGL=?\r"); /* it should just return "\nOK\n" */
+ ATHW_HaveSiemensMGL=(GE_NONE==wait_on(&err,10/*timeout*/));
+
+ ATHW_HaveCNMI=true;
+ ATHW_TX_SendCommand(&err/*errorcodep*/,NULL/*patrol*/,
+ "AT+CNMI=2,1\r"); /* <mode>=2 (buffer when data active), <mt>=1 (+CMTI codes) */
+ if (GE_NONE!=wait_on(&err,10/*timeout*/)) {
+ ATHW_TX_SendCommand(&err/*errorcodep*/,NULL/*patrol*/,
+ "AT+CNMI=1,1\r"); /* <mode>=1 (discard when data active), <mt>=1 (+CMTI codes) */
+ if (GE_NONE!=wait_on(&err,10/*timeout*/))
+ ATHW_HaveCNMI=false;
+ }
+ ATHW_CNMI_count=-1; /* unknown yet */
+
+ ATHW_TX_SendCommand(&err/*errorcodep*/,NULL/*patrol*/,
+ "AT+COPS=3,2\r"); /* <mode>=3 (just set <format>), <format>=2 (numeric) */
+ wait_on(&err,10/*timeout*/); /* error ignored, GetNetworkInfo will find the failure itself */
+
+ /* Enable LAC+CellID returns, it will also disable unsolicited changes reporting
+ * but we ignore it successfuly.
+ */
+ ATHW_TX_SendCommand(&err/*errorcodep*/,NULL/*patrol*/,
+ "AT+CREG=2\r");
+ wait_on(&err,10/*timeout*/); /* error ignored, GetNetworkInfo will find the failure itself */
+
+ ATHW_GetPhoneInfo();
+
+ return(GE_NONE);
+}
+
+
+static void ATHW_RX_Char(char rx_byte);
+static void ATHW_SigHandler(int status);
+static bool ATHW_OpenSerial(void);
+
+GSM_Phone phone_at_hw; /* forward declaration */
+
+/* Initialise variables and state machine. */
+
+static GSM_Error ATHW_Init(GSM_Data *data, GSM_Statemachine *state)
+{
+ RequestTerminate = false;
+ CallPassup = NULL;
+
+ /* Create and start main thread. */
+
+#ifdef WIN32
+{
+int rtn;
+ rtn = ! OpenConnection(State->Link.PortDevice,ATHW_RX_Char,ATHW_KeepAliveProc);
+ if (rtn != 0) {
+ return(GE_INTERNALERROR);
+}
+#else
+ SAFE_STRNCPY_SIZEOF(PortDevice,state->Link.PortDevice);
+ if (!ATHW_OpenSerial())
+ return(GE_INTERNALERROR);
+#endif
+
+ ATHW_ERR_WRAPPER(ATHW_PhoneSetup());
+
+ return (GE_NONE);
+}
+
+#if __unices__
+/* thread for handling incoming data */
+void ATHW_SelectLoop()
+{
+ int err;
+ fd_set readfds;
+ struct timeval timeout;
+
+ FD_ZERO(&readfds);
+ FD_SET(device_portfd, &readfds);
+ /* set timeout to 15 seconds */
+ timeout.tv_sec=15;
+ timeout.tv_usec=0;
+ while (!RequestTerminate) {
+ err = select(device_portfd + 1, &readfds, NULL, NULL, &timeout);
+ /* call singal handler to process incoming data */
+ if ( err > 0 ) ATHW_SigHandler(0);
+ else if (err == -1) perror("Error in SelectLoop");
+ }
+}
+#endif
+
+static GSM_Error ATHW_AnswerCall(GSM_Data *data, GSM_Statemachine *state)
+{
+ /* data->CallNo not present up to Nokia 9110i */
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentPhoneInfoError/*errorcodep*/,20/*timeout*/,NULL/*patrol*/,"ATA\r");
+ return(GE_NONE);
+}
+
+/* Applications should call ATHW_Terminate to shut down the ATHW thread and
+ close the serial port. */
+
+static GSM_Error ATHW_Terminate(GSM_Data *data, GSM_Statemachine *state)
+{
+ /* Request termination of thread */
+ RequestTerminate = true;
+
+#ifndef WIN32
+ /* Now wait for thread to terminate. */
+ pthread_join(Thread, NULL);
+
+ /* Close serial port. */
+ device_close();
+
+#else
+ CloseConnection();
+#endif
+
+ return(GE_NONE);
+}
+
+/* +CSQ: Signal Quality
+ * CurrentRFLevel = 1st arg <rssi>
+ */
+static char *ATHW_RX_Patrol_CSQ(char *after)
+{
+long l;
+
+ l=ATHW_ExtractNumber(after/*src*/,0/*element_no*/);
+ if (l>=0 && l<=31)
+ *CurrentRFLevel=l;
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CSQ_struct=
+ { "\n+CSQ:", ATHW_RX_Patrol_CSQ };
+
+static GSM_Error ATHW_GetRFLevel(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentRFLevel=data->RFLevel;
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&GetRFLevelError/*errorcodep*/,30/*timeout*/,&ATHW_RX_Patrol_CSQ_struct,"AT+CSQ\r");
+
+ if (*data->RFUnits!=GRF_CSQ) {
+ *data->RFUnits = GRF_Percentage; /* required by xgnokii_lowlevel.c */
+ *data->RFLevel = (*data->RFLevel)*100/31; /* +CSQ */
+ }
+
+ return (GE_NONE);
+}
+
+/* +CBC: Battery Charge
+ * CurrentPowersource = 1st arg <bcs>
+ * CurrentBatteryLevel = 2nd arg <bcl>
+ */
+static char *ATHW_RX_Patrol_CBC(char *after)
+{
+long l;
+
+ if (CurrentPowersource) {
+ l=ATHW_ExtractNumber(after/*src*/,0/*element_no*/);
+ if (l==0 || l==1)
+ *CurrentPowersource=(l==1 ? GPS_ACDC : GPS_BATTERY);
+ }
+
+ if (CurrentBatteryLevel) {
+ l=ATHW_ExtractNumber(after/*src*/,1/*element_no*/);
+ if (l>=0 && l<=100)
+ *CurrentBatteryLevel=l;
+ }
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CBC_struct=
+ { "\n+CBC:", ATHW_RX_Patrol_CBC };
+
+static GSM_Error ATHW_GetBatteryLevel(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentBatteryLevel=data->BatteryLevel;
+ *data->BatteryUnits = GBU_Percentage;
+
+ ATHW_TX_SendCommand(&GetBatteryLevelError/*errorcodep*/,&ATHW_RX_Patrol_CBC_struct,"AT+CBC\r");
+ if (GE_NONE!=wait_on(&GetBatteryLevelError,30/*timeout*/)) {
+ /* We are probably on AC powered device such as Nokia CardPhone
+ */
+ *CurrentBatteryLevel=100;
+ }
+
+
+ return (GE_NONE);
+}
+
+static GSM_Error ATHW_GetPowersource(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentPowersource=data->PowerSource;
+
+ ATHW_TX_SendCommand(&GetPowersourceError/*errorcodep*/,&ATHW_RX_Patrol_CBC_struct,"AT+CBC\r");
+ if (GE_NONE!=wait_on(&GetPowersourceError,30/*timeout*/)) {
+ /* We are probably on AC powered device such as Nokia CardPhone
+ */
+ *CurrentPowersource=GPS_ACDC;
+ }
+
+ return (GE_NONE);
+}
+
+static GSM_Error ATHW_DialVoice(GSM_Data *data, GSM_Statemachine *state)
+{
+ /* "ATDnumber;" is notation supported at least on Nokia up to 9110i
+ * We need to wait for establishing a connection as other commands would otherwise break it!
+ */
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&DialVoiceError/*errorcodep*/,600/*timeout*/,NULL/*patrol*/,"ATD%s;\r",data->VoiceNumber);
+
+ return(GE_NONE);
+}
+
+/* Dial a data call - type specifies request to use:
+ type 0 should normally be used
+ type 1 should be used when calling a digital line - corresponds to ats35=0
+ Maybe one day we'll know what they mean!
+ FIXME: ATHW currently ignores it - what value should be used for S35?
+*/
+
+static GSM_Error ATHW_DialData(GSM_Data *data, GSM_Statemachine *state)
+{
+ CallPassup=data->DataCallPassUp;
+
+ switch (*data->DataType) {
+ case 0: /* FALLTHRU */
+ case 1: /* FALLTHRU */
+ default:
+ break;
+ break;
+ case -1: /* Just used to set the call passup */
+ return GE_NONE;
+ break;
+ }
+
+ ATHW_TX_SendCommand(NULL/*errorcodep*/,NULL/*patrol*/,"ATD%s\r",data->DataNumber);
+ return(GE_NONE);
+}
+
+static GSM_Error ATHW_GetIncomingCallNr(GSM_Data *data, GSM_Statemachine *state)
+{
+ if (*CurrentIncomingCall != ' ') {
+ strcpy(data->IncomingCallNr, CurrentIncomingCall);
+ return GE_NONE;
+ } else return GE_BUSY;
+}
+
+static GSM_Error ATHW_CancelCall(GSM_Data *data, GSM_Statemachine *state)
+{
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CancelCallError/*errorcodep*/,60/*timeout*/,NULL/*patrol*/,"ATH\r");
+
+ return(GE_NONE);
+}
+
+/* messagecenter->No" is NOT set as it is input argument */
+static void ATHW_MessageCenterClear(GSM_MessageCenter *messagecenter)
+{
+ messagecenter->Name[0]='\0'; /* not present up to Nokia 9110i */
+ messagecenter->Recipient[0]='\0'; /* not present up to Nokia 9110i */
+ messagecenter->Number[0]='\0'; /* default */
+ messagecenter->Format=GSMF_Text; /* default */
+ messagecenter->Validity=GSMV_72_Hours; /* default */
+}
+
+/* +CSCA:
+ * MessageCenter->Number = 1st arg <sca>
+ */
+static char *ATHW_RX_Patrol_CSCA(char *after)
+{
+ ATHW_EXTRACTSTRING(CurrentMessageCenter->Number,after/*src*/,0/*element_no*/);
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CSCA_struct=
+ { "\n+CSCA:", ATHW_RX_Patrol_CSCA };
+
+/* +CSMP:
+ * CurrentMessageCenter->Format = 3rd arg <pid>
+ * CurrentMessageCenter->Validity = 2nd arg <vp>
+ */
+static char *ATHW_RX_Patrol_CSMP(char *after)
+{
+long l;
+
+ l=ATHW_ExtractNumber(after/*src*/,2/*element_no*/);
+ if (l>=0 && l<0x100)
+ CurrentMessageCenter->Format=(GSM_SMSMessageFormat)l;
+
+ l=ATHW_ExtractNumber(after/*src*/,1/*element_no*/);
+ if (l>=0 && l<0x100)
+ CurrentMessageCenter->Validity=(GSM_SMSMessageValidity)l;
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CSMP_struct=
+ { "\n+CSMP:", ATHW_RX_Patrol_CSMP };
+
+/* This function sends to the mobile phone a request for the SMS Center */
+
+static GSM_Error ATHW_GetSMSCenter(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentMessageCenter = data->MessageCenter;
+
+ if (CurrentMessageCenter->No!=1) /* "CurrentMessageCenter->No" not present up to Nokia 9110i */
+ return(GE_INTERNALERROR); /* FIXME: some better code? */
+ ATHW_MessageCenterClear(CurrentMessageCenter);
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentMessageCenterError/*errorcodep*/,10/*timeout*/,&ATHW_RX_Patrol_CSCA_struct,"AT+CSCA?\r");
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentMessageCenterError/*errorcodep*/,10/*timeout*/,&ATHW_RX_Patrol_CSMP_struct,"AT+CSMP?\r");
+
+ printf("message center OK: %s\n",CurrentMessageCenter->Number);
+ return(GE_NONE);
+}
+
+/* This function set the SMS Center profile on the phone. */
+
+static GSM_Error ATHW_SetSMSCenter(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentMessageCenter = data->MessageCenter;
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentMessageCenterError/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "AT+CSCA=%s\r",ATHW_Enquote(CurrentMessageCenter->Number));
+ return(GE_NONE);
+}
+
+static int ATHW_RX_Patrol_SiemensMGL_count;
+
+static char *ATHW_RX_Patrol_SiemensMGL(char *after)
+{
+char *s;
+
+ /* There may be left string from AT+CMGL=? which would confuse us!
+ */
+ for (s=after;isspace(*s);s++);
+ if (*s=='(')
+ return(after); /* eat line */
+
+ /* Lines with our wanted "REC UNREAD" should be already filtered by the request
+ */
+ ATHW_RX_Patrol_SiemensMGL_count++;
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_SiemensMGL_struct=
+ { "\n^SMGL:", ATHW_RX_Patrol_SiemensMGL };
+
+static void ATHW_Update_CNMI_count(void)
+{
+const char *state;
+
+ if (!ATHW_HaveSiemensMGL)
+ return;
+
+ switch (ATHW_CurrentCMGF) {
+ case 0: state="0"; break;
+ case 1: state=ATHW_Enquote("REC UNREAD"); break;
+ default:
+ return; /* not supported */
+ }
+
+ ATHW_RX_Patrol_SiemensMGL_count=0;
+ ATHW_TX_SendCommand(&CurrentSMSStatusError/*errorcodep*/,&ATHW_RX_Patrol_SiemensMGL_struct/*patrol*/,
+ "AT^SMGL=%s\r",state);
+ if (GE_NONE==wait_on(&CurrentSMSStatusError,600/*timeout*/))
+ ATHW_CNMI_count=ATHW_RX_Patrol_SiemensMGL_count; /* otherwise not updated */
+}
+
+/* +CPMS:
+ * CurrentSMSStatus->Used = 2nd arg <used1>
+ * CurrentSMSStatus->Slots = 3nd arg <total1>
+ */
+static char *ATHW_RX_Patrol_CPMS(char *after)
+{
+long l;
+
+ l=ATHW_ExtractNumber(after/*src*/,1/*element_no*/);
+ if (l>=0 && l<INT_MAX)
+ CurrentSMSStatus->Used=l;
+
+ l=ATHW_ExtractNumber(after/*src*/,2/*element_no*/);
+ if (l>=0 && l<INT_MAX)
+ CurrentSMSStatus->Slots=l;
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CPMS_struct=
+ { "\n+CPMS:", ATHW_RX_Patrol_CPMS };
+
+/* Note: "Status->UnRead" cannot be detected at all up to Nokia 9110i
+ * as its GEOS always reads the incoming message immediately.
+ * On some other devices it could be probably solved by: AT+CMGL="REC UNREAD"
+ */
+static GSM_Error ATHW_GetSMSStatus(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentSMSStatus = data->SMSStatus;
+ if (ATHW_CNMI_count<0)
+ ATHW_Update_CNMI_count();
+ CurrentSMSStatus->UnRead=(ATHW_CNMI_count<0 ? 0 : ATHW_CNMI_count); /* not present up to Nokia 9110i */
+ CurrentSMSStatus->Used =10; /* default */
+ CurrentSMSStatus->Slots=10; /* default */
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentSMSStatusError/*errorcodep*/,10/*timeout*/,&ATHW_RX_Patrol_CPMS_struct,
+ "AT+CPMS?\r");
+ return(GE_NONE);
+}
+
+static GSM_Error ATHW_GetImei(GSM_Data *data, GSM_Statemachine *state)
+{
+ if (*IMEI) {
+ strcpy(data->Imei,IMEI);
+ return (GE_NONE);
+ } else return (GE_TRYAGAIN);
+}
+
+static GSM_Error ATHW_GetRevision(GSM_Data *data, GSM_Statemachine *state)
+{
+ if (*Revision) {
+ strcpy(data->Revision,Revision);
+ return (GE_NONE);
+ } else return (GE_TRYAGAIN);
+}
+
+static GSM_Error ATHW_GetModel(GSM_Data *data, GSM_Statemachine *state)
+{
+ if (*Model) {
+ strcpy(data->Model,Model);
+ return (GE_NONE);
+ } else return (GE_TRYAGAIN);
+}
+
+static GSM_Error ATHW_GetManufacturer(GSM_Data *data, GSM_Statemachine *state)
+{
+ if (*Model) {
+ strcpy(data->Manufacturer,Manufacturer);
+ return (GE_NONE);
+ } else return (GE_TRYAGAIN);
+}
+
+/* This function translates GMT_MemoryType to the string for AT+CPBS
+ * Nokia 9000i: ("SM")
+ * Siemens M20: ("SM","FD","LD","RC","ON","ME","MC","MT")
+ */
+
+#define GETMEMORYTYPE_ENTRY(code) \
+ case GMT_##code: return( #code );
+
+static const char *ATHW_GetMemoryType(GSM_MemoryType memory_type)
+{
+ switch (memory_type) {
+ GETMEMORYTYPE_ENTRY(ME)
+ GETMEMORYTYPE_ENTRY(SM)
+ GETMEMORYTYPE_ENTRY(FD)
+ GETMEMORYTYPE_ENTRY(ON)
+ GETMEMORYTYPE_ENTRY(EN)
+ GETMEMORYTYPE_ENTRY(DC)
+ GETMEMORYTYPE_ENTRY(RC)
+ GETMEMORYTYPE_ENTRY(MC)
+ GETMEMORYTYPE_ENTRY(LD)
+ GETMEMORYTYPE_ENTRY(MT)
+ GETMEMORYTYPE_ENTRY(TA)
+ GETMEMORYTYPE_ENTRY(CB)
+ default: return(NULL);
+ }
+}
+
+#define ATHW_GETMEMORYTYPE(dst,memory_type) \
+ do { \
+ (dst)=ATHW_GetMemoryType((memory_type)); \
+ if (!(dst)) \
+ return(GE_INVALIDMEMORYTYPE); \
+ } while (0)
+
+static GSM_Error ATHW_SelectPhonebookMemory(GSM_MemoryType memory_type)
+{
+const char *atmemtype;
+
+ if (memory_type==ATHW_CurrentMemoryType)
+ return(GE_NONE);
+ ATHW_CurrentMemoryType=GMT_XX;
+
+ ATHW_GETMEMORYTYPE(atmemtype,memory_type);
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentPhonebookError/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "AT+CPBS=%s\r",ATHW_Enquote(atmemtype));
+
+ ATHW_CurrentMemoryType=memory_type;
+
+ return(GE_NONE);
+}
+
+/* +CPBR: (GetMemoryStatus)
+ * CurrentMemoryStatus->Free=1st arg (1-<index>)
+ */
+static char *ATHW_RX_Patrol_CPBR_GetMemoryStatus(char *after)
+{
+char buf[32];
+int num_1,num_2;
+
+ ATHW_EXTRACTSTRING(buf,after/*src*/,0/*element_no*/);
+ if (2==sscanf(buf,"(%d-%d)",&num_1,&num_2)) {
+ CurrentMemoryStatus->Used=0; /* not present up to Nokia 9110i, we ignore it now */
+ CurrentMemoryStatus->Free=num_2;
+ }
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CPBR_GetMemoryStatus_struct=
+ { "\n+CPBR:", ATHW_RX_Patrol_CPBR_GetMemoryStatus };
+
+static GSM_Error ATHW_GetMemoryStatus(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentMemoryStatus=data->MemoryStatus;
+
+ ATHW_ERR_WRAPPER(ATHW_SelectPhonebookMemory(CurrentMemoryStatus->MemoryType));
+
+ CurrentMemoryStatus->Used=0; /* default */
+ CurrentMemoryStatus->Free=0; /* default */
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentMemoryStatusError/*errorcodep*/,10/*timeout*/,&ATHW_RX_Patrol_CPBR_GetMemoryStatus_struct,
+ "AT+CPBR=?\r");
+
+ return(GE_NONE);
+}
+
+static void ATHW_DateTimeSetCurrent(GSM_DateTime *datetime)
+{
+time_t current=time(NULL);
+struct tm *tm=localtime(¤t);
+
+ datetime->AlarmEnabled=false;
+
+ datetime->Year =tm->tm_year+1900;
+ datetime->Month =tm->tm_mon+1;
+ datetime->Day =tm->tm_mday;
+ datetime->Hour =tm->tm_hour;
+ datetime->Minute=tm->tm_min;
+ datetime->Second=tm->tm_sec;
+
+ datetime->Timezone=timezone;
+}
+
+/* +CPBR: (ReadPhonebook)
+ * CurrentPhonebookEntry->Name =4th arg <text>
+ * CurrentPhonebookEntry->Number=2nd arg <number>
+ */
+static char *ATHW_RX_Patrol_CPBR_ReadPhonebook(char *after)
+{
+ CurrentPhonebookEntry->Empty=false;
+ ATHW_EXTRACTSTRING(CurrentPhonebookEntry->Name ,after/*src*/,3/*element_no*/);
+ ATHW_EXTRACTSTRING(CurrentPhonebookEntry->Number,after/*src*/,1/*element_no*/);
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CPBR_ReadPhonebook_struct=
+ { "\n+CPBR:", ATHW_RX_Patrol_CPBR_ReadPhonebook };
+
+/* Routine to get specifed phone book location. Designed to be called by
+ * application. Will block until location is retrieved or a timeout/error
+ * occurs.
+ */
+static GSM_Error ATHW_ReadPhonebook(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentPhonebookEntry=data->PhonebookEntry;
+
+ ATHW_ERR_WRAPPER(ATHW_SelectPhonebookMemory(CurrentPhonebookEntry->MemoryType));
+
+ /* We may get just OK response (Siemens M20) which means empty location
+ */
+ CurrentPhonebookEntry->Empty=true;
+ CurrentPhonebookEntry->Group=0; /* not present up to Nokia 9110i */
+ ATHW_DateTimeSetCurrent(&CurrentPhonebookEntry->Date); /* not present up to Nokia 9110i */
+ CurrentPhonebookEntry->SubEntriesCount=0; /* not present up to Nokia 9110i */
+ CurrentPhonebookEntry->Name[0]='\0'; /* default */
+ CurrentPhonebookEntry->Number[0]='\0'; /* default */
+
+ ATHW_TX_SendCommand(&CurrentPhonebookError/*errorcodep*/,&ATHW_RX_Patrol_CPBR_ReadPhonebook_struct,
+ "AT+CPBR=%d\r",CurrentPhonebookEntry->Location);
+ if (GE_NONE!=wait_on(&CurrentPhonebookError,10/*timeout*/)) {
+ /* Nokia 9000i returns ATHW_CME_NOT_FOUND error code for empty locations
+ */
+ if (ATHW_CME_NOT_FOUND!=ATHW_RX_Patrol_CME_ERROR_code)
+ return(CurrentPhonebookError);
+ return(GE_NONE);
+ }
+
+ return(GE_NONE);
+}
+
+
+/* Routine to write phonebook location in phone. Designed to be called by
+ application code. Will block until location is written or timeout
+ occurs. */
+
+static GSM_Error ATHW_WritePhonebook(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentPhonebookEntry=data->PhonebookEntry;
+
+ ATHW_ERR_WRAPPER(ATHW_SelectPhonebookMemory(CurrentPhonebookEntry->MemoryType));
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentPhonebookError/*errorcodep*/,60/*timeout*/,NULL/*patrol*/,
+ (CurrentPhonebookEntry->Empty ? "AT+CPBW=%d\r" : "AT+CPBW=%d,%s,,%s\r"),
+ CurrentPhonebookEntry->Location,
+ ATHW_Enquote(CurrentPhonebookEntry->Number),
+ ATHW_Enquote(CurrentPhonebookEntry->Name)
+ );
+
+ return(GE_NONE);
+}
+
+static const char *ATHW_SMStoStat(GSM_SMSMessage *SMS)
+{
+ switch (CurrentSMSMessage->Type) {
+ case GST_MT:
+ switch (CurrentSMSMessage->Status) {
+ case GSS_NOTSENTREAD:
+ return("REC UNREAD");
+ case GSS_SENTREAD:
+ return("REC READ");
+ }
+ return(NULL);
+ case GST_MO:
+ switch (CurrentSMSMessage->Status) {
+ case GSS_NOTSENTREAD:
+ return("STO UNSENT");
+ case GSS_SENTREAD:
+ return("STO SENT");
+ }
+ return(NULL);
+ default:
+ return(NULL);
+ }
+ /* NOTREACHED */
+}
+
+/* RETURN: Success of recognizing "SMSstat"
+ */
+static bool ATHW_StattoSMS(GSM_SMSMessage *SMS,const char *SMSstat)
+{
+ /**/ if (!strcmp(SMSstat,"0") || !strcmp(SMSstat,"REC UNREAD")) {
+ SMS->Type=GST_MT;
+ SMS->Status=GSS_NOTSENTREAD;
+ }
+ else if (!strcmp(SMSstat,"1") || !strcmp(SMSstat,"REC READ")) {
+ SMS->Type=GST_MT;
+ SMS->Status=GSS_SENTREAD;
+ }
+ else if (!strcmp(SMSstat,"2") || !strcmp(SMSstat,"STO UNSENT")) {
+ SMS->Type=GST_MO;
+ SMS->Status=GSS_NOTSENTREAD;
+ }
+ else if (!strcmp(SMSstat,"3") || !strcmp(SMSstat,"STO SENT")) {
+ SMS->Type=GST_MO;
+ SMS->Status=GSS_SENTREAD;
+ }
+ else return(false); /* not recognized! */
+ return(true);
+}
+
+/* scts=="01/10/25,02:28:18+08", scts WILL BE DESTROYED!
+ */
+static bool ATHW_SCTStoSMS_CMGF1(GSM_SMSMessage *SMS,char *scts)
+{
+GSM_DateTime *DateTime=&SMS->Time;
+bool timezone_minus;
+const char *fmt="%d/%d/%d,%d:%d:%d+%d"; /* trailing '\0' IS used! */
+int i;
+
+ if (strlen(scts)!=20)
+ return(false);
+ if ((timezone_minus=(scts[17]=='-')))
+ scts[17]='+';
+ i=0;
+ do {
+ if (!isdigit(scts[i++]))
+ return(false);
+ if (!isdigit(scts[i++]))
+ return(false);
+ if (scts[i]!=fmt[i])
+ return(false);
+ } while (fmt[i++]);
+ /* string is completely valid now */
+
+ sscanf(scts,fmt,
+ &DateTime->Year,
+ &DateTime->Month,
+ &DateTime->Day,
+ &DateTime->Hour,
+ &DateTime->Minute,
+ &DateTime->Second,
+ &DateTime->Timezone);
+ if (DateTime->Year>=85)
+ DateTime->Year-=100;
+ DateTime->Year+=2000;
+ if (timezone_minus)
+ DateTime->Timezone=-DateTime->Timezone;
+ return(true);
+}
+
+static void ATHW_DCStoSMS(GSM_SMSMessage *SMS,unsigned char dcs)
+{
+ switch ((dcs&0xF0)>>4) {
+ case 0x0:
+ switch (dcs&0x0F) {
+ case 0x0:
+ CurrentSMSMessage->EightBit=false;
+ break;
+ }
+ break;
+ case 0xF:
+ CurrentSMSMessage->EightBit=!!(dcs&0x04); /* bit 2 */
+ CurrentSMSMessage->Class=(dcs&0x03); /* bits 0 & 1 */
+ break;
+ }
+}
+
+static bool ATHW_SCTStoSMS_CMGF0(GSM_SMSMessage *SMS,unsigned char *scts)
+{
+GSM_DateTime *DateTime=&SMS->Time;
+int *fields[]={ /* FIXME: offsetof() would be nice here but currently not supported by Gnokii */
+ &DateTime->Year,
+ &DateTime->Month,
+ &DateTime->Day,
+ &DateTime->Hour,
+ &DateTime->Minute,
+ &DateTime->Second,
+ &DateTime->Timezone,
+ };
+int i;
+unsigned char digit0,digit1;
+
+ for (i=0;i<ARRAY_LEN(fields);i++,scts++) {
+ if (0
+ || (digit0= (*scts) &0x0F) > 9
+ || (digit1=((*scts)>>4)&0x0F) > 9
+ )
+ return(false);
+ (*fields[i])=10*digit0 + digit1;
+ }
+ /* scts is completely valid now */
+
+ if (DateTime->Year>=85)
+ DateTime->Year-=100;
+ DateTime->Year+=2000;
+ return(true);
+}
+
+/* Value MUST match ((fo>>3)&0x03) !
+ */
+enum ATHW_FO_Validity {
+ ATHW_FOV_None =0,
+ ATHW_FOV_Reserved=1,
+ ATHW_FOV_Relative=2,
+ ATHW_FOV_Absolute=3,
+ };
+static const size_t ATHW_FO_Validity_sizes[]={
+ 0, /* ATHW_FOV_None */
+ 0, /* ATHW_FOV_Reserved - not valid */
+ 1, /* ATHW_FOV_Relative */
+ 7, /* ATHW_FOV_Absolute */
+ };
+
+/* RETURN: Success of recognizing "SMSstat"
+ */
+static void ATHW_FOtoSMS(GSM_SMSMessage *SMS,enum ATHW_FO_Validity *validityp,unsigned char fo)
+{
+ switch (fo&0x03) {
+ case 0: SMS->Type=GST_MT; break;
+ case 1: SMS->Type=GST_MO; break;
+ default: /* FIXME: value 2 and 3? */
+ }
+
+ /* bit 2 - reject duplices - not supported by Gnokii
+ */
+
+ if (validityp)
+ *validityp=(enum ATHW_FO_Validity)((fo>>3)&0x03);
+
+ /* bit 5 - status report request - not supported by Gnokii
+ */
+
+ SMS->UDHPresent=!!(fo&(1<<6));
+
+ SMS->ReplyViaSameSMSC=!!(fo&(1<<7));
+}
+
+static GSM_Error ATHW_RX_Patrol_CMGR_CMGF0_core(char *after,char *messagetext,char *end)
+{
+unsigned char pdu[GNOKII_MAX_PDU_LENGTH],*pduend,*s;
+char *oada;
+size_t oada_size,udl;
+enum ATHW_FO_Validity FO_validity;
+unsigned udbits; /* 7 or 8 bits in UserData */
+
+ if (end-messagetext>2*sizeof(pdu))
+ return(GE_INTERNALERROR); /* input PDU hex too long! */
+ if (!(pduend=SMS_BlockFromHex(pdu,messagetext,end-messagetext/*len*/)))
+ return(GE_INTERNALERROR);
+ s=pdu;
+ if (ATHW_CurrentSMSCPrefix) {
+ if (s >= pduend
+ || *s < 1/*type*/
+ || *s > 1/*type*/
+ + ( sizeof(CurrentSMSMessage->MessageCenter.Number)
+ -1/*'\0' termination*/
+ +1 )/2/*bytes of rounded-up nibbles*/
+ || s +1/*type*/ +((*s)+1)/2/*bytes of rounded-up nibbles*/ > pduend /* whole SMSC.Number must fit */
+ )
+ return(GE_INTERNALERROR);
+ if (!(s=SemiOctetUnpack(CurrentSMSMessage->MessageCenter.Number,sizeof(CurrentSMSMessage->MessageCenter.Number),
+ s+1,2*((*s) -1/*type*/ ))))
+ return(GE_INTERNALERROR); /* invalid SMSCenter */
+ }
+ if (s +1/*<fo>*/ +1/*received number length*/ > pduend)
+ return(GE_INTERNALERROR);
+ ATHW_FOtoSMS(CurrentSMSMessage,&FO_validity,*s++);
+
+ switch (CurrentSMSMessage->Type) {
+
+ case GST_MT:
+ oada =CurrentSMSMessage->Sender;
+ oada_size=sizeof(CurrentSMSMessage->Sender);
+ break;
+
+ case GST_MO:
+ oada =CurrentSMSMessage->Destination;
+ oada_size=sizeof(CurrentSMSMessage->Destination);
+
+ /* message reference is really not interesting to be read */
+ if (s +1/*<mr>*/ > pduend)
+ return(GE_INTERNALERROR);
+ s++;
+
+ break;
+
+ /* FIXME: GST_DR - Delivery Report - not supported!
+ */
+ default:
+ /* Unable to skip OA/DA, parsing would fail
+ */
+ return(GE_INTERNALERROR);
+ }
+
+ if (oada) {
+ if (s + 1/*type*/ +((*s)+1)/2/*bytes of rounded-up nibbles*/ > pduend)
+ return(GE_INTERNALERROR);
+ if (!(s=SemiOctetUnpack(oada,oada_size,s+1,(*s)/*nibbles*/)))
+ return(GE_INTERNALERROR); /* invalid OA/DA */
+ }
+
+ if (s +1/*<pid>*/ +1/*<dcs>*/ > pduend)
+ return(GE_INTERNALERROR);
+
+ /* FIXME: Is it correct to fill "MessageCenter" fields from SMS body? */
+ CurrentSMSMessage->MessageCenter.Format=*s++; /* <pid> */
+
+ ATHW_DCStoSMS(CurrentSMSMessage,*s++); /* <dcs> */
+
+ switch (CurrentSMSMessage->Type) {
+
+ case GST_MT: /* SCTS field */
+ if (s +7/*scts*/ > pduend)
+ return(GE_INTERNALERROR);
+ if (!ATHW_SCTStoSMS_CMGF0(CurrentSMSMessage,s))
+ return(GE_INTERNALERROR);
+ s+=7;
+ break;
+
+ case GST_MO: /* VP field */
+ if (s +ATHW_FO_Validity_sizes[(unsigned)FO_validity] > pduend)
+ return(GE_INTERNALERROR);
+ switch (FO_validity) {
+ case ATHW_FOV_None:
+ break;
+ case ATHW_FOV_Reserved:
+ return(GE_INTERNALERROR); /* not supported */
+ case ATHW_FOV_Relative:
+ CurrentSMSMessage->Validity=SMS_VP_to_Validity((GSM_SMSMessageValidity)*s);
+ break;
+ case ATHW_FOV_Absolute:
+ /* leave default, not supported by Gnokii */
+ break;
+ }
+ s+=ATHW_FO_Validity_sizes[(unsigned)FO_validity];
+ break;
+
+ default:
+ /* To be written when other types get supported in the above switch
+ */
+ }
+
+ if (s +1/*udl*/ > pduend)
+ return(GE_INTERNALERROR);
+
+ /* We are pretty strict as UDL must exactly match the end of SMS
+ * as the is the primary check for the good guess of SMSCenter presentness
+ * during guessing by ATHW_RX_Patrol_CMGR_CMGF0_retrier().
+ */
+ udl=(*s++);
+ udbits=(CurrentSMSMessage->EightBit ? 8 : 7);
+ if (s +( udl*udbits +7/*round-up*/ )/8 != pduend)
+ return(GE_INTERNALERROR);
+
+ if (CurrentSMSMessage->UDHPresent) {
+ if (0
+ || s +1/*sizeof(UDH[0])*/ > pduend
+ || s +1/*sizeof(UDH[0])*/ + *s/*UDH[0]*/ > pduend
+ || 1/*sizeof(UDH[0])*/ + *s/*UDH[0]*/ > sizeof(CurrentSMSMessage->UDH)
+ )
+ return(GE_INTERNALERROR);
+ memcpy(CurrentSMSMessage->UDH,s, 1/*sizeof(UDH[0])*/ + *s/*UDH[0]*/ );
+ s+=1/*sizeof(UDH[0])*/ + *s/*UDH[0]*/;
+ udl-=(( 1/*sizeof(UDH[0])*/ +CurrentSMSMessage->UDH[0] )*8 +0/*round-down*/ )/udbits;
+ }
+
+ if (udl > (sizeof(CurrentSMSMessage->MessageText) -1/*terminating '\0'*/))
+ return(GE_INTERNALERROR);
+ CurrentSMSMessage->MessageTextLength=udl;
+ CurrentSMSMessage->MessageText[CurrentSMSMessage->MessageTextLength]='\0';
+
+ if (udbits==8) {
+ memcpy(CurrentSMSMessage->MessageText,s,udl);
+ }
+ else { /* udhbits==7 */
+ UnpackEightBitsToSeven((7-(!CurrentSMSMessage->UDHPresent ? 0 : 1+CurrentSMSMessage->UDH[0]))%7, /* offset */
+ pduend-s, /* in_length */
+ udl, /* out_length */
+ s, /* input */
+ CurrentSMSMessage->MessageText /* output */
+ );
+ CurrentSMSMessage->MessageText[udl]='\0';
+ }
+
+ return(GE_NONE);
+}
+
+/* This is just a variant of ATHW_SMS_CMGF0(), I was too lazy to generalize it
+ */
+static GSM_Error ATHW_RX_Patrol_CMGR_CMGF0_retrier(char *after,char *messagetext,char *end)
+{
+GSM_Error err,err_first=GE_INTERNALERROR/*shut up GCC*/;
+int retry;
+
+ for (retry=0;retry<2;retry++) {
+ /* There is no need to give up trying decoding (=> retried>0 )
+ * by both ways as it does't cost us anything (not as in ATHW_SMS_CMGF0()).
+ */
+ if (GE_NONE==(err=ATHW_RX_Patrol_CMGR_CMGF0_core(after,messagetext,end),1/*retried*/)) {
+ ATHW_CurrentSMSCPrefix_force=true;
+ return(err);
+ }
+ if (ATHW_CurrentSMSCPrefix_force)
+ return(err);
+ if (!retry)
+ err_first=err;
+ ATHW_CurrentSMSCPrefix=!ATHW_CurrentSMSCPrefix;
+ }
+ /* Return rather the first error code as it is more probable that
+ * it was generated with valid ATHW_CurrentSMSCPrefix setting
+ */
+ return(err_first);
+}
+
+/* +CMGR message reading will be finalized by "\nOK\n" which will terminate wait_on().
+ * But invalid message data followed by "\nOK\n" are still invalid so we have to indicate it.
+ */
+static void ATHW_RX_Patrol_CMGR_CMGF0(char *after,char *messagetext,char *end)
+{
+GSM_Error err;
+
+ err=ATHW_RX_Patrol_CMGR_CMGF0_retrier(after,messagetext,end);
+ if (err!=GE_NONE)
+ CurrentSMSMessageError=err;
+}
+
+/* +CMGR: (+CMGF==1)
+ * CurrentSMSMessage->Status = 1st arg <stat>
+ * CurrentSMSMessage->Sender = 2nd arg <oa>
+ * CurrentSMSMessage->Destination = 2nd arg <da>
+ * ...etc., see the code below
+ *
+ * Type==GST_MT:
+ * +CMGR: <stat>,<oa>,<alpha>,<scts>,<tooa>,<fo>,<pid>,<dcs> ,<sca>,<tosca>,<length>
+ * 0 1 2 3 4 5 6 7 8 9 10
+ * Type==GSM_MO:
+ * +CMGR: <stat>,<da>,<alpha> ,<toda>,<fo>,<pid>,<dcs>,<vp>,<sca>,<tosca>,<length>
+ * 0 1 2 3 4 5 6 7 8 9 10
+ */
+static void ATHW_RX_Patrol_CMGR_CMGF1(char *after,char *messagetext,char *end)
+{
+char buf[32];
+int fieldno_fo=-1,fieldno_dcs=-1;
+long l;
+
+ switch (CurrentSMSMessage->Type) {
+
+ case GST_MT:
+ ATHW_EXTRACTSTRING(CurrentSMSMessage->Sender,after/*src*/,1/*element_no*/);
+
+ /* <scts> Service centre time stamp string format "01/10/25,02:28:18+08"
+ * Note: not present up to Nokia 9110i
+ */
+ ATHW_EXTRACTSTRING(buf ,after/*src*/,3/*element_no*/);
+ ATHW_SCTStoSMS_CMGF1(CurrentSMSMessage,buf/*scts*/); /* error ignored, leave the default value */
+
+ fieldno_fo=5;
+ fieldno_dcs=7;
+ break;
+
+ case GST_MO:
+ ATHW_EXTRACTSTRING(CurrentSMSMessage->Destination,after/*src*/,1/*element_no*/);
+ fieldno_fo=4;
+ fieldno_dcs=6;
+
+ l=ATHW_ExtractNumber(after/*src*/,7/*element_no*/);
+ if (l>=0 && l<0x100)
+ CurrentSMSMessage->Validity=SMS_VP_to_Validity((GSM_SMSMessageValidity)l);
+ break;
+
+ default:
+ /* Not supported */
+ }
+
+ if (fieldno_fo>=0) {
+ l=ATHW_ExtractNumber(after/*src*/,fieldno_fo/*element_no*/);
+ if (l>=0 && l<0x100)
+ ATHW_FOtoSMS(CurrentSMSMessage,
+ NULL, /* validityp - solved by GSM device in +CMGF==1 */
+ l);
+ }
+
+ if (fieldno_dcs>=0) {
+ l=ATHW_ExtractNumber(after/*src*/,fieldno_dcs/*element_no*/);
+ if (l>=0 && l<0x100)
+ ATHW_DCStoSMS(CurrentSMSMessage,l);
+ }
+
+ ATHW_EXTRACTSTRING(CurrentSMSMessage->MessageCenter.Number,after/*src*/,8/*element_no*/);
+
+ CurrentSMSMessage->MessageTextLength=GNOKII_MIN(end-messagetext,sizeof(CurrentSMSMessage->MessageText)-1);
+ memcpy(CurrentSMSMessage->MessageText,messagetext,CurrentSMSMessage->MessageTextLength);
+ CurrentSMSMessage->MessageText[CurrentSMSMessage->MessageTextLength]='\0';
+}
+
+/* +CMGR:
+ * CurrentSMSMessage->Type = 1st arg <stat>
+ */
+static char *ATHW_RX_Patrol_CMGR(char *after)
+{
+char buf[32],*end,*messagetext;
+
+ end=strchr(after,'\n');
+ if (!end++)
+ return(after); /* assert, INTERNAL! */
+ if (!*end)
+ return(NULL); /* need data */
+ if (*end=='\n') /* 2nd optional '\n' */
+ end++; /* '\n' should be really double as it was "\r\n" from the device */
+ messagetext=end;
+ if (!(end=strchr(end,'\n')))
+ return(NULL); /* need data */
+ /* Now we have read "+CMGR:*\n[\n]*\n" */
+
+ /* 1st arg <stat> is numeric(+CMGF==0)/alpha(+CMGF==1), ATHW_StattoSMS parses it all
+ */
+ ATHW_EXTRACTSTRING(buf,after/*src*/,0/*element_no*/);
+ ATHW_StattoSMS(CurrentSMSMessage,buf); /* error ignored: what to do if unknown? */;
+
+ switch (ATHW_CurrentCMGF) {
+ case 0: ATHW_RX_Patrol_CMGR_CMGF0(after,messagetext,end); break;
+ case 1: ATHW_RX_Patrol_CMGR_CMGF1(after,messagetext,end); break;
+ }
+
+ return(++end); /* eat the whole SMS block, INCLUDING the trailing '\n' */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CMGR_struct=
+ { "\n+CMGR:", ATHW_RX_Patrol_CMGR };
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_SiemensMGR_struct=
+ { "\n^SMGR:", ATHW_RX_Patrol_CMGR };
+
+/* Currently we always set the first two memory types as the syntax with empty
+ * preceding elements is not supported at least by Nokia 9110i & Siemens M20.
+ * Ideal case would be to first query the state by AT+CPMS? and then the settings
+ * would be written back.
+ * We never need to set the third argument, for example on Nokia 9110i it even isn't
+ * supported for "SM" memory type!
+ */
+static GSM_Error ATHW_SMS_SelectMemoryType(GSM_SMSMessage *SMS)
+{
+const char *atmemtype;
+const char *atmemtype_quoted;
+
+ ATHW_GETMEMORYTYPE(atmemtype,SMS->MemoryType);
+ atmemtype_quoted=ATHW_Enquote(atmemtype);
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentSMSMessageError/*errorcodep*/,10/*timeout*/,NULL/*patrol*/,
+ "AT+CPMS=%s,%s\r",atmemtype_quoted,atmemtype_quoted);
+
+ return(GE_NONE);
+}
+
+static GSM_Error ATHW_GetSMS(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentSMSMessage = data->SMSMessage;
+
+ ATHW_ERR_WRAPPER(ATHW_SMS_SelectMemoryType(CurrentSMSMessage)); /* select <mem1> - reading/deleting */
+
+ ATHW_DateTimeSetCurrent(&CurrentSMSMessage->Time); /* not present up to Nokia 9110i */
+ ATHW_DateTimeSetCurrent(&CurrentSMSMessage->SMSCTime); /* not present up to Nokia 9110i */
+ CurrentSMSMessage->MessageTextLength=0; /* default */
+ CurrentSMSMessage->Validity=72/*hours*/*60; /* default */
+ CurrentSMSMessage->UDHPresent=false; /* default */
+ CurrentSMSMessage->MessageText[0]='\0'; /* default */
+
+ ATHW_MessageCenterClear(&CurrentSMSMessage->MessageCenter); /* default */
+ CurrentSMSMessage->MessageCenter.No=0; /* default - input for GetSMSCenter */
+
+ CurrentSMSMessage->Sender[0]='\0'; /* default */
+ CurrentSMSMessage->Destination[0]='\0'; /* default */
+ CurrentSMSMessage->MessageNumber=CurrentSMSMessage->Location; /* default */
+ /* CurrentSMSMessage->MemoryType is input argument */
+ CurrentSMSMessage->Type=GST_UN; /* default, detection of EMPTY SMSes! */
+ CurrentSMSMessage->Status=GSS_SENTREAD; /* default */
+ CurrentSMSMessage->Class=1; /* default */
+ CurrentSMSMessage->EightBit=false; /* default */
+ CurrentSMSMessage->Compression=false; /* default */
+ /* CurrentSMSMessage->Location is input argument */
+ CurrentSMSMessage->ReplyViaSameSMSC=false; /* default */
+
+ /* We may now read "unread" SMS which will change its status to "read".
+ * We don't know its current state so we don't know whether the number
+ * of "unread" SMSes will change.
+ */
+ if (!ATHW_HaveSiemensMGR)
+ ATHW_CNMI_count=-1;
+
+ ATHW_TX_SendCommand(&CurrentSMSMessageError/*errorcodep*/,
+ (ATHW_HaveSiemensMGR ? &ATHW_RX_Patrol_SiemensMGR_struct : &ATHW_RX_Patrol_CMGR_struct)/*patrol*/,
+ (ATHW_HaveSiemensMGR ? "AT^SMGR=%d\r" : "AT+CMGR=%d\r"),
+ CurrentSMSMessage->Location);
+ if (GE_NONE!=wait_on(&CurrentSMSMessageError,60/*timeout*/)) {
+ if (ATHW_CMS_INVALID_MEMORY_INDEX!=ATHW_RX_Patrol_CMS_ERROR_code)
+ return(CurrentSMSMessageError);
+ return(GE_EMPTYSMSLOCATION);
+ }
+ if (CurrentSMSMessage->Type==GST_UN) /* Empty slot with "\nOK\n" response detection */
+ return(GE_EMPTYSMSLOCATION);
+
+ return(GE_NONE);
+}
+
+static GSM_Error ATHW_DeleteSMS(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentSMSMessage = data->SMSMessage;
+
+ ATHW_ERR_WRAPPER(ATHW_SMS_SelectMemoryType(CurrentSMSMessage)); /* select <mem1> - reading/deleting */
+
+ ATHW_CNMI_count=-1;
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentSMSMessageError/*errorcodep*/,30/*timeout*/,NULL/*patrol*/,
+ "AT+CMGD=%d\r",CurrentSMSMessage->Location);
+
+ return(GE_NONE);
+}
+
+static const struct ATHW_RX_Patrol *ATHW_RX_Patrol_GT_SPACE_patrol_after;
+
+/* RETURNS: "true" if successful
+ */
+static bool WRITEPHONE_hex(unsigned char *buf,size_t buflen)
+{
+char *hex;
+size_t hexsize; /* should be ==2*buflen */
+size_t got;
+
+ if (!(hex=malloc(2*buflen)))
+ return(false);
+ hexsize=(SMS_BlockToHex(hex,buf,buflen)-hex);
+ got=WRITEPHONE(PortFD,hex,hexsize);
+ free(hex);
+
+ if (hexsize!=got)
+ return(false);
+ return(true);
+}
+
+static char *ATHW_RX_Patrol_GT_SPACE(char *after)
+{
+ switch (ATHW_CurrentCMGF) {
+
+ case 0:
+ if (!WRITEPHONE_hex(CurrentSMSMessagePDU,CurrentSMSMessagePDU_size))
+ goto fail;
+ break;
+
+ case 1:
+ if (CurrentSMSMessage->UDHPresent) { /* ATHW_CMGS_CMGF1_8bit_HaveBinHex==true assumed */
+ if (!WRITEPHONE_hex(CurrentSMSMessage->UDH,1+CurrentSMSMessage->UDH[0]))
+ goto fail;
+ }
+ if (CurrentSMSMessage->EightBit && ATHW_CMGS_CMGF1_8bit_HaveBinHex) {
+ if (!WRITEPHONE_hex( CurrentSMSMessage->MessageText,CurrentSMSMessage->MessageTextLength))
+ goto fail;
+ }
+ else {
+ if (CurrentSMSMessage->MessageTextLength!=WRITEPHONE(PortFD,CurrentSMSMessage->MessageText,CurrentSMSMessage->MessageTextLength))
+ goto fail;
+ }
+ break;
+ }
+
+ if (1 !=WRITEPHONE(PortFD,"\x1A"/*CTRL-Z*/,1)) {
+fail:
+ CurrentSMSMessageError=GE_INTERNALERROR;
+ /* FALLTHRU to exit path */
+ }
+
+ /* We may be actually doing +CMGS instead of +CMGW but we do not yet
+ * need to patrol any output from +CMGS so don't bother its distinguishing now.
+ */
+ ATHW_RX_Patrol_Current=ATHW_RX_Patrol_GT_SPACE_patrol_after;
+
+ /* We just cannot return "after" as it would mean "eat line".
+ * Just leaving there an additional '\n' is pretty harmless.
+ */
+ after[-1]='\n';
+ return(after-1);
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_GT_SPACE_struct=
+ { "\n> ",ATHW_RX_Patrol_GT_SPACE };
+
+static char *ATHW_SMS_TypeToSenderOrDestination(GSM_SMSMessage *SMS)
+{
+ switch (CurrentSMSMessage->Type) {
+ case GST_MO:
+ return(SMS->Destination);
+ case GST_MT:
+ return(SMS->Sender);
+ default:
+ return(NULL);
+ }
+ /* NOTREACHED */
+}
+
+/* The second argument is the size of the data in octets,
+ * excluding User Data Header - important only for 8bit data
+ * Ooops, we cannot share the PDU generating code with Gnokii FBUS code
+ * as FBUS doesn't use PDU format in its SMS-Send packet!
+ */
+static GSM_Error ATHW_SendSMS_CMGF0_core(GSM_Data *data, GSM_Statemachine *state,const char *commandfmt) G_GNUC_PRINTF(3,0);
+static GSM_Error ATHW_SendSMS_CMGF0_core(GSM_Data *data, GSM_Statemachine *state,const char *commandfmt)
+{
+unsigned char pdu[GNOKII_MAX_PDU_LENGTH];
+unsigned char *d,*pdustart,*bodystart,*pdudatalengthp;
+int i;
+char *SMSsenderdestination;
+
+ d=pdu;
+
+ if (ATHW_CurrentSMSCPrefix) {
+
+ /* We should get SMSC number */
+ if (CurrentSMSMessage->MessageCenter.No) {
+GSM_Data data_messagecenter;
+
+ data_messagecenter.MessageCenter=&CurrentSMSMessage->MessageCenter;
+ ATHW_ERR_WRAPPER(ATHW_GetSMSCenter(&data_messagecenter,state));
+ CurrentSMSMessage->MessageCenter.No = 0;
+ }
+ if (!*CurrentSMSMessage->MessageCenter.Number)
+ *d++=0x00; /* total SMSC length */
+ else {
+ i=SemiOctetPack(CurrentSMSMessage->MessageCenter.Number,d+1);
+ *d= 1/*type*/ + (i+1)/2/*rounded-up bytes of nibbles*/ ;
+ d+= 1/*length*/ + 1/*type*/ + (i+1)/2/*rounded-up bytes of nibbles*/ ;
+ }
+ }
+ /* We MUST NOT count SMSCenter length into +CMGS=%d count argument
+ */
+ pdustart=d;
+
+ *d++=ATHW_SMStoFO(CurrentSMSMessage); /* <fo>: First Octet of SMS-SUBMIT */
+ *d++=ATHW_PDU_MR_DEFAULT; /* Message Reference */
+ SMSsenderdestination=ATHW_SMS_TypeToSenderOrDestination(CurrentSMSMessage);
+ i=SemiOctetPack((!SMSsenderdestination ? "" : CurrentSMSMessage->Destination),d+1);
+ *d= i/*nibbles*/ ;
+ d+= 1/*length*/ + 1/*type*/ + (i+1)/2/*rounded-up bytes of nibbles*/ ;
+ *d++=(unsigned char)CurrentSMSMessage->MessageCenter.Format;
+ *d++=ATHW_SMStoDCS(CurrentSMSMessage);
+ *d++=SMS_Validity_to_VP(CurrentSMSMessage->Validity);
+ pdudatalengthp=d++;
+
+ bodystart=d;
+ if (CurrentSMSMessage->UDHPresent) {
+size_t UDHlen=1+CurrentSMSMessage->UDH[0];
+
+ memcpy(d,CurrentSMSMessage->UDH,UDHlen);
+ d+=UDHlen;
+ }
+ if (CurrentSMSMessage->EightBit) {
+ memcpy(d,CurrentSMSMessage->MessageText,CurrentSMSMessage->MessageTextLength);
+ d+=CurrentSMSMessage->MessageTextLength;
+ } else {
+size_t byteslen=PackSevenBitsToEight(
+ /* check it out yourself, really the number of used bits for UDH header on the start
+ * as we will need to allocate initial bit to align SMS->MessageText on the 7-bit boundary
+ */
+ (7-(d-bodystart))%7,
+ CurrentSMSMessage->MessageText,d);
+ d+=byteslen;
+ }
+ *pdudatalengthp=((d-bodystart)*8)/(CurrentSMSMessage->EightBit ? 8 : 7);
+
+ CurrentSMSMessagePDU=pdu;
+ CurrentSMSMessagePDU_size=d-pdu;
+
+ ATHW_ERR_WRAPPER(ATHW_SMS_CMGF01_pre());
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentSMSMessageError/*errorcodep*/,150/*timeout*/,&ATHW_RX_Patrol_GT_SPACE_struct/*patrol*/,
+ commandfmt,d-pdustart);
+ ATHW_ERR_WRAPPER(ATHW_SMS_CMGF01_post());
+
+ return(GE_NONE);
+}
+
+/* Houston, we have a problem.
+ * Siemens M20 supports +CMGW <stat> specification but on my model it just
+ * reports ERROR (and <stat> is not respected).
+ * Fortunately it will write "+CMGW: <index>\n" before and the message gets written
+ * so we try to ignore ERROR reports during initial probing of <stat> support.
+ */
+static bool ATHW_SaveSMS_StatSupported=true;
+static bool ATHW_SaveSMS_StatSupported_force=false;
+static int ATHW_SaveSMS_StatSupported_retries=ATHW_SAVESMS_STATSUPPORTED_RETRIES;
+
+static GSM_Error ATHW_SaveSMS_StatSupported_solve(GSM_Error err,int retried)
+{
+ if (ATHW_SaveSMS_StatSupported_force)
+ return(err);
+ if (err==GE_NONE || CurrentSMSMessage->MessageNumber) {
+ ATHW_SaveSMS_StatSupported_force=true;
+ return(GE_NONE);
+ }
+ if (!ATHW_SaveSMS_StatSupported_retries) {
+ ATHW_SaveSMS_StatSupported=false;
+ ATHW_SaveSMS_StatSupported_force=true;
+ return(err);
+ }
+ /* Count only the sending sessions, not each attempt.
+ * Otherwise SMS with not-acceptable for write would
+ * cost us ATHW_CURRENTSMSCPREFIX_RETRIES number of retries
+ * in ATHW_SaveSMS_StatSupported_retries counter!
+ */
+ if (!retried)
+ ATHW_SaveSMS_StatSupported_retries--;
+ return(err);
+}
+
+/* This is just a wrapper for ATHW_CurrentSMSCPrefix retrying, please see the comment
+ * at the definition of this variable.
+ */
+/* This is just a variant of ATHW_RX_Patrol_CMGR_CMGF0(), I was too lazy to generalize it
+ */
+static GSM_Error ATHW_SMS_CMGF0(GSM_Data *data, GSM_Statemachine *state,const char *commandfmt)
+{
+GSM_Error err,err_first=GE_INTERNALERROR/*shut up GCC*/;
+int retry;
+
+ for (retry=0;retry<ATHW_CURRENTSMSCPREFIX_RETRIES;retry++) {
+ if (GE_NONE==(err=ATHW_SaveSMS_StatSupported_solve(ATHW_SendSMS_CMGF0_core(data,state,commandfmt),retry))) {
+ ATHW_CurrentSMSCPrefix_force=true;
+ return(err);
+ }
+ if (ATHW_CurrentSMSCPrefix_force)
+ return(err);
+ if (!retry)
+ err_first=err;
+ ATHW_CurrentSMSCPrefix=!ATHW_CurrentSMSCPrefix;
+ }
+ /* Return rather the first error code as it is more probable that
+ * it was generated with valid ATHW_CurrentSMSCPrefix setting
+ */
+ return(err_first);
+}
+
+static GSM_Error ATHW_SendSMS_CMGF0(GSM_Data *data, GSM_Statemachine *state)
+{
+GSM_Error err=ATHW_SMS_CMGF0(data,state,"AT+CMGS=%d\r");
+
+ if (err==GE_NONE)
+ return(GE_SMSSENDOK);
+ return(err);
+}
+
+/* The second argument is the size of the data in octets,
+ excluding User Data Header - important only for 8bit data */
+static GSM_Error ATHW_SendSMS_CMGF1(GSM_Data *data, GSM_Statemachine *state)
+{
+ ATHW_ERR_WRAPPER(ATHW_SMS_CMGF01_pre());
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentSMSMessageError/*errorcodep*/,150/*timeout*/,&ATHW_RX_Patrol_GT_SPACE_struct/*patrol*/,
+ "AT+CMGS=%s\r",ATHW_Enquote(CurrentSMSMessage->Destination));
+ ATHW_ERR_WRAPPER(ATHW_SMS_CMGF01_post());
+
+ return(GE_SMSSENDOK);
+}
+
+static char *ATHW_RX_Patrol_CMGS_CMGW(char *after)
+{
+long l;
+
+ l=ATHW_ExtractNumber(after/*src*/,0/*element_no*/);
+ if (l>=0 && l<=INT_MAX/* SMS->Location is int */)
+ CurrentSMSMessage->MessageNumber=l;
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CMGS_struct=
+ { "\n+CMGS:", ATHW_RX_Patrol_CMGS_CMGW };
+
+static GSM_Error ATHW_SendSMS(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentSMSMessage = data->SMSMessage;
+ ATHW_RX_Patrol_GT_SPACE_patrol_after=&ATHW_RX_Patrol_CMGS_struct;
+ CurrentSMSMessage->MessageNumber=0; /* default */
+
+ switch (ATHW_CurrentCMGF) {
+ case 0: return(ATHW_SendSMS_CMGF0(data,state));
+ case 1: return(ATHW_SendSMS_CMGF1(data,state));
+ }
+ return(GE_INTERNALERROR);
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CMGW_struct=
+ { "\n+CMGW:", ATHW_RX_Patrol_CMGS_CMGW };
+
+static GSM_Error ATHW_SaveSMS_CMGF0(GSM_Data *data, GSM_Statemachine *state)
+{
+const char *SMSstat;
+char *commandfmt=NULL; /* just paranoia */
+GSM_Error err;
+
+ SMSstat=(!ATHW_SaveSMS_StatSupported ? NULL : ATHW_SMStoStat(CurrentSMSMessage));
+ gasprintf(&commandfmt,"AT+CMGW=%%d,%s\r",(!SMSstat ? "" : ATHW_Enquote(SMSstat)));
+ if (!commandfmt)
+ return(GE_INTERNALERROR);
+
+ err=ATHW_SMS_CMGF0(data,state,commandfmt);
+ free(commandfmt);
+
+ return(err);
+}
+
+static GSM_Error ATHW_SaveSMS_CMGF1(GSM_Data *data, GSM_Statemachine *state)
+{
+const char *SMSstat;
+char *SMSsenderdestination;
+GSM_Error err;
+
+ SMSstat=(!ATHW_SaveSMS_StatSupported ? NULL : ATHW_SMStoStat(CurrentSMSMessage));
+ SMSsenderdestination=ATHW_SMS_TypeToSenderOrDestination(CurrentSMSMessage);
+
+ ATHW_ERR_WRAPPER(ATHW_SMS_CMGF01_pre());
+ ATHW_TX_SendCommand(&CurrentSMSMessageError/*errorcodep*/,&ATHW_RX_Patrol_GT_SPACE_struct/*patrol*/,
+ "AT+CMGW=%s,,%s\r",
+ (!SMSsenderdestination ? "" : ATHW_Enquote(SMSsenderdestination)),
+ (!SMSstat ? "" : ATHW_Enquote(SMSstat)));
+ err=wait_on(&CurrentSMSMessageError,150/*timeout*/);
+ ATHW_ERR_WRAPPER(ATHW_SMS_CMGF01_post());
+
+ return(ATHW_SaveSMS_StatSupported_solve(err,0/*retried-no retry session here*/));
+}
+
+static GSM_Error ATHW_SaveSMS(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentSMSMessage = data->SMSMessage;
+ ATHW_RX_Patrol_GT_SPACE_patrol_after=&ATHW_RX_Patrol_CMGW_struct;
+ CurrentSMSMessage->MessageNumber=0; /* default */
+
+ ATHW_ERR_WRAPPER(ATHW_SMS_SelectMemoryType(CurrentSMSMessage)); /* select <mem1> - writing */
+
+ switch (ATHW_CurrentCMGF) {
+ case 0: return(ATHW_SaveSMS_CMGF0(data,state));
+ case 1: return(ATHW_SaveSMS_CMGF1(data,state));
+ }
+ return(GE_INTERNALERROR);
+}
+
+static GSM_Error ATHW_Reset(GSM_Data *data, GSM_Statemachine *state)
+{
+ ATHW_ERR_WRAPPER(ATHW_PhoneSetup());
+
+ return(GE_NONE);
+}
+
+/* +COPS:
+ * CurrentNetworkInfo->NetworkCode = 3rd arg <oper>
+ */
+static char *ATHW_RX_Patrol_COPS(char *after)
+{
+long l;
+char *s;
+
+ l=ATHW_ExtractNumber(after/*src*/,1/*element_no*/);
+ /* check whether numeric operator mode is on */
+ if (l!=2)
+ return(after); /* eat line */
+
+ ATHW_EXTRACTSTRING(CurrentNetworkInfo->NetworkCode,after/*src*/,2/*element_no*/);
+ if (strlen(CurrentNetworkInfo->NetworkCode)!=5) {
+fail:
+ CurrentNetworkInfo->NetworkCode[0]='\0';
+ return(after); /* eat line */
+ }
+ for (s=CurrentNetworkInfo->NetworkCode;*s;s++)
+ if (!isdigit(*s))
+ goto fail;
+ /* network code valid */
+
+ memmove(CurrentNetworkInfo->NetworkCode+3+1,CurrentNetworkInfo->NetworkCode+3,2 +1/*terminating '\0'*/);
+ CurrentNetworkInfo->NetworkCode[3]=' ';
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_COPS_struct=
+ { "\n+COPS:", ATHW_RX_Patrol_COPS };
+
+static void ATHW_RX_Patrol_CREG_hex4valid(char *hex4)
+{
+char *s;
+
+ if (strlen(hex4)!=4) {
+fail:
+ hex4[0]='\0';
+ return;
+ }
+ for (s=hex4;*s;s++)
+ if (!isxdigit(*s))
+ goto fail;
+}
+
+/* +CREG:
+ * CurrentNetworkInfo->CellID = 4rd arg <lac>
+ * CurrentNetworkInfo->LAC = 3nd arg <cid>
+ */
+static char *ATHW_RX_Patrol_CREG(char *after)
+{
+long l;
+
+ l=ATHW_ExtractNumber(after/*src*/,1/*element_no*/);
+ /* check whether we don't report stale information
+ */
+ if (l==1/*registered-home network*/ || l==5/*registered-roaming*/)
+ return(after); /* eat line */
+
+ ATHW_EXTRACTSTRING( CurrentNetworkInfo->CellID,after/*src*/,3/*element_no*/);
+ ATHW_RX_Patrol_CREG_hex4valid(CurrentNetworkInfo->CellID);
+ ATHW_EXTRACTSTRING( CurrentNetworkInfo->LAC ,after/*src*/,2/*element_no*/);
+ ATHW_RX_Patrol_CREG_hex4valid(CurrentNetworkInfo->LAC );
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrol_CREG_struct=
+ { "\n+CREG:", ATHW_RX_Patrol_CREG };
+
+static GSM_Error ATHW_GetNetworkInfo(GSM_Data *data, GSM_Statemachine *state)
+{
+ CurrentNetworkInfo=data->NetworkInfo;
+
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentNetworkInfoError/*errorcodep*/,10/*timeout*/,&ATHW_RX_Patrol_COPS_struct/*patrol*/,
+ "AT+COPS?\r");
+ ATHW_TX_SENDCOMMAND_WAIT_ON(&CurrentNetworkInfoError/*errorcodep*/,10/*timeout*/,&ATHW_RX_Patrol_CREG_struct/*patrol*/,
+ "AT+CREG?\r");
+
+ /* When no information was gather we will rather report failure
+ */
+ if (1
+ && !*CurrentNetworkInfo->NetworkCode
+ && !*CurrentNetworkInfo->CellID
+ && !*CurrentNetworkInfo->LAC
+ )
+ return(GE_INTERNALERROR);
+
+
+ return(GE_NONE);
+}
+
+
+#ifndef WIN32
+
+/* Called by initialisation code to open comm port in asynchronous mode. */
+
+static bool ATHW_OpenSerial(void)
+{
+ int result;
+
+#if __unices__
+ int rtn;
+#else
+ struct sigaction sig_io;
+
+ /* Set up and install handler before enabling async IO on port. */
+
+ sig_io.sa_handler = ATHW_SigHandler;
+ sig_io.sa_flags = 0;
+ sigaction (SIGIO, &sig_io, NULL);
+#endif
+
+ /* Open device. */
+
+ result = device_open(PortDevice, false/*with_odd_parity*/, true/*with_async*/, -1/*with_hw_handshake*/, GCT_Serial);
+
+ if (!result) {
+ perror(_("Couldn't open AT device"));
+ return false;
+ }
+
+#if __unices__
+ /* create a thread to handle incoming data from mobile phone */
+ rtn = pthread_create(&selThread, NULL, (void*)ATHW_SelectLoop, (void*)NULL);
+ if (rtn != 0) return false;
+#endif
+
+ /* device_changespeed() not needed as device_open() now automatically
+ * sets the user-specified (or default) speed.
+ */
+ return (true);
+}
+
+static void ATHW_SigHandler(int status)
+{
+ unsigned char buffer[255];
+ int count, res;
+ res = device_read(buffer, 255);
+ for (count = 0; count < res ; count ++)
+ ATHW_RX_Char(buffer[count]);
+}
+#endif /* WIN32 */
+
+static char *ATHW_RX_Patrol_OK(char *after)
+{
+ /* Some patrol may have already indicated some error!
+ */
+ if (ATHW_CatchBufferErrorP && *ATHW_CatchBufferErrorP==GE_BUSY)
+ *ATHW_CatchBufferErrorP=GE_NONE;
+
+ return(after); /* eat line */
+}
+
+static char *ATHW_RX_Patrol_ERROR(char *after)
+{
+ if (ATHW_CatchBufferErrorP)
+ *ATHW_CatchBufferErrorP=GE_INTERNALERROR;
+
+ return(after); /* eat line */
+}
+
+/* We can't kick the user with anything else */
+#define ATHW_RX_Patrol_NO_CARRIER ATHW_RX_Patrol_ERROR
+#define ATHW_RX_Patrol_DELAYED ATHW_RX_Patrol_ERROR
+#define ATHW_RX_Patrol_NO_DIALTONE ATHW_RX_Patrol_ERROR
+#define ATHW_RX_Patrol_BUSY ATHW_RX_Patrol_ERROR
+
+static char *ATHW_RX_Patrol_CMX_ERROR(char *after,long *errorp)
+{
+char *end=NULL;
+long l;
+
+ while (*after==' ') after++;
+
+ l=strtol(after,&end,10);
+ if (*after && l>=0 && l<LONG_MAX && end && *end=='\n')
+ *errorp=l;
+
+ if (ATHW_CatchBufferErrorP)
+ *ATHW_CatchBufferErrorP=GE_INTERNALERROR;
+
+ return(after); /* eat line */
+}
+
+static char *ATHW_RX_Patrol_CME_ERROR(char *after)
+{
+ return(ATHW_RX_Patrol_CMX_ERROR(after,&ATHW_RX_Patrol_CME_ERROR_code));
+}
+
+static void ATHW_RX_Patrol_CME_ERROR_reset(void)
+{
+ ATHW_RX_Patrol_CME_ERROR_code=-1;
+}
+
+static char *ATHW_RX_Patrol_CMS_ERROR(char *after)
+{
+ return(ATHW_RX_Patrol_CMX_ERROR(after,&ATHW_RX_Patrol_CMS_ERROR_code));
+}
+
+static void ATHW_RX_Patrol_CMS_ERROR_reset(void)
+{
+ ATHW_RX_Patrol_CMS_ERROR_code=-1;
+}
+
+static char *ATHW_RX_Patrol_CRING_VOICE(char *after)
+{
+ if (CallPassup)
+ (*CallPassup)('V');
+
+ return(after); /* eat line */
+}
+
+static char *ATHW_RX_Patrol_CMTI(char *after)
+{
+#ifdef ATHW_DEBUG
+ printf("ATHW_RX_Patrol_CMTI: ATHW_CNMI_count==%d\n",ATHW_CNMI_count);
+#endif
+
+ if (ATHW_CNMI_count>=0) {
+ ATHW_CNMI_count++;
+#ifdef ATHW_DEBUG
+ printf("ATHW_CNMI_count increased to %d\n",ATHW_CNMI_count);
+#endif
+ }
+
+ return(after); /* eat line */
+}
+
+static const struct ATHW_RX_Patrol ATHW_RX_Patrols[]={
+ { "\nOK\n" ,ATHW_RX_Patrol_OK },
+ { "\nERROR\n" ,ATHW_RX_Patrol_ERROR },
+ { "\nNO CARRIER\n" ,ATHW_RX_Patrol_NO_CARRIER },
+ { "\nDELAYED\n" ,ATHW_RX_Patrol_DELAYED },
+ { "\nNO DIALTONE\n" ,ATHW_RX_Patrol_NO_DIALTONE },
+ { "\nBUSY\n" ,ATHW_RX_Patrol_BUSY },
+ { "\n+CME ERROR:" ,ATHW_RX_Patrol_CME_ERROR, ATHW_RX_Patrol_CME_ERROR_reset },
+ { "\n+CMS ERROR:" ,ATHW_RX_Patrol_CMS_ERROR, ATHW_RX_Patrol_CMS_ERROR_reset },
+ { "\n+CRING: VOICE\n",ATHW_RX_Patrol_CRING_VOICE },
+ { "\n+CMTI:" ,ATHW_RX_Patrol_CMTI },
+ };
+
+static void ATHW_CatchBufferReset(void)
+{
+ ATHW_CatchBufferPtr=ATHW_CatchBuffer;
+ *ATHW_CatchBufferPtr='\0';
+ ATHW_CatchBufferMarker=NULL;
+}
+
+static void ATHW_CatchBufferMarkStart(GSM_Error *errorcodep)
+{
+static GSM_Error err_trashcan;
+const struct ATHW_RX_Patrol *patrol;
+
+ if (!errorcodep)
+ errorcodep=&err_trashcan;
+ ATHW_CatchBufferErrorP=errorcodep;
+
+ ATHW_CatchBufferMarker=ATHW_CatchBufferPtr;
+
+ for (patrol=ATHW_RX_Patrols;patrol<ATHW_RX_Patrols+ARRAY_LEN(ATHW_RX_Patrols);patrol++)
+ if (patrol->reset)
+ (*patrol->reset)();
+}
+
+static const struct ATHW_RX_Patrol *ATHW_RX_Char_EvalPatrol_best;
+static char *ATHW_RX_Char_EvalPatrol_best_found;
+
+static void ATHW_RX_Char_EvalPatrol(const struct ATHW_RX_Patrol *patrol)
+{
+char *found,*foundend;
+
+ if (!patrol)
+ return;
+
+ if (!(found=strstr(ATHW_CatchBuffer,patrol->buoy)))
+ return;
+
+ /* When the buoy doesn't end with '\n' we need to find some '\n' after it.
+ * Otherwise the whole line hasn't been read yet and we to yet wait.
+ * It means that we doesn't support Patrol which would catch an incomplete line
+ * - the only exception are the explicite checks for functions like "ATHW_RX_Patrol_GT_SPACE_struct" :-(
+ */
+ foundend=found+strlen(patrol->buoy);
+ if (foundend<=found) /* assert */
+ return;
+ if (1 /* FIXME: This list is an ugly solution... */
+ && patrol!=&ATHW_RX_Patrol_GT_SPACE_struct
+ && patrol!=&ATHW_PhoneSetup_CMGF1_Detect_Patrol_GT_SPACE_struct
+ && patrol!=&ATHW_PhoneSetup_CMGF1_Detect_Patrol_9_struct
+
+ && foundend>found && foundend[-1]!='\n' && !strchr(foundend,'\n'))
+ return; /* no whole line has been read yet */
+
+ if (!ATHW_RX_Char_EvalPatrol_best || ATHW_RX_Char_EvalPatrol_best_found>found) {
+ ATHW_RX_Char_EvalPatrol_best=patrol;
+ ATHW_RX_Char_EvalPatrol_best_found=found;
+ }
+}
+
+
+/* RX_State machine for receive handling. Called once for each character
+ received from the phone/phone. */
+
+static void ATHW_RX_Char(char rx_byte)
+{
+size_t offset;
+#ifdef ATHW_DEBUG
+#if 0
+ dprintf(_("Received character '%c' (0x%02X)\n"),
+ (!isgraph(rx_byte) ? '?' : rx_byte),(unsigned char)rx_byte);
+#endif
+ putchar(rx_byte);
+#endif
+
+/* We try to keep back 1/2 of buffer data, ineffectively shifting it up when the buffer
+ * gets filled up.
+ */
+ if (ATHW_CatchBufferPtr>=ATHW_CatchBuffer+sizeof(ATHW_CatchBuffer) -1/*Terminating '\0'*/ ) {
+char *movefrom;
+
+#ifdef ATHW_DEBUG
+ dprintf(_("Shifting buffer:\n%s\n__END__\n"),ATHW_CatchBuffer);
+#endif
+ movefrom=ATHW_CatchBuffer+(sizeof(ATHW_CatchBuffer)/2);
+ if (1 && ATHW_CatchBufferMarker
+ && ATHW_CatchBufferMarker>ATHW_CatchBuffer
+ && ATHW_CatchBufferMarker<movefrom)
+ movefrom=ATHW_CatchBufferMarker;
+ offset=ATHW_CatchBuffer+sizeof(ATHW_CatchBuffer)-movefrom;
+ memmove(ATHW_CatchBuffer,movefrom,offset);
+ ATHW_CatchBufferPtr-=offset;
+ if (ATHW_CatchBufferMarker) {
+ if ((ATHW_CatchBufferMarker-=offset)<ATHW_CatchBuffer)
+ ATHW_CatchBufferMarker=ATHW_CatchBuffer;
+ }
+ }
+
+ /* NEVER store '\0' as it would knock-out completely our patrolling system!
+ */
+ if (rx_byte=='\r' || rx_byte=='\0')
+ rx_byte='\n';
+
+ *ATHW_CatchBufferPtr++=rx_byte;
+ *ATHW_CatchBufferPtr='\0';
+
+ for (;;) {
+const struct ATHW_RX_Patrol *patrol;
+char *found,*end,*foundend;
+
+ ATHW_RX_Char_EvalPatrol_best=NULL;
+ for (patrol=ATHW_RX_Patrols;patrol<ATHW_RX_Patrols+ARRAY_LEN(ATHW_RX_Patrols);patrol++) {
+ ATHW_RX_Char_EvalPatrol(patrol);
+ }
+ ATHW_RX_Char_EvalPatrol(ATHW_RX_Patrol_Current);
+ if (!ATHW_RX_Char_EvalPatrol_best)
+ return;
+
+#if 0
+#ifdef ATHW_DEBUG
+ printf("Invoking patrol for: %s\n",ATHW_RX_Char_EvalPatrol_best->buoy);
+#endif
+#endif
+ found=ATHW_RX_Char_EvalPatrol_best_found;
+ foundend=found+strlen(ATHW_RX_Char_EvalPatrol_best->buoy);
+ end=(*ATHW_RX_Char_EvalPatrol_best->func)(foundend);
+
+ if (!end) /* patrol returned NULL - it is on the track but it needs more data! */
+ return;
+ if (end==foundend) { /* they did simple 'return(after);' */
+ if (foundend[-1]!='\n') {
+ if (!(end=strchr(foundend,'\n')))
+ end=foundend+strlen(foundend);
+ }
+ }
+ /* We place '\n' delimited at the *end */
+ memmove(found+1,end,ATHW_CatchBufferPtr+1-end);
+ offset=end-(found+1);
+ ATHW_CatchBufferPtr-=offset;
+ ATHW_CatchBufferPtr[-1]='\n';
+
+ /* Move Marker right behind the squeezed data if we were inside
+ */
+ if (ATHW_CatchBufferMarker>=found) {
+ if (ATHW_CatchBufferMarker<=end)
+ ATHW_CatchBufferMarker=ATHW_CatchBufferPtr+1;
+ else
+ ATHW_CatchBufferMarker-=offset;
+ }
+ }
+}
+
+/* Here we initialise model specific functions. */
+
+#define ATHW_FUNCTIONS_ENTRY(name) \
+ case GOP_##name: return(ATHW_##name(data,state));
+
+static GSM_Error ATHW_Functions(GSM_Operation op, GSM_Data *data, GSM_Statemachine *state)
+{
+static GSM_Statemachine *catcher=NULL;
+
+ if (!catcher || catcher==state)
+ catcher=state;
+ else
+ *((char *)NULL)=1;
+
+ switch (op) {
+ ATHW_FUNCTIONS_ENTRY(Init)
+ ATHW_FUNCTIONS_ENTRY(Terminate)
+ ATHW_FUNCTIONS_ENTRY(GetMemoryStatus)
+ ATHW_FUNCTIONS_ENTRY(ReadPhonebook)
+ ATHW_FUNCTIONS_ENTRY(WritePhonebook)
+ ATHW_FUNCTIONS_ENTRY(GetSMSStatus)
+ ATHW_FUNCTIONS_ENTRY(GetSMSCenter)
+ ATHW_FUNCTIONS_ENTRY(SetSMSCenter)
+ ATHW_FUNCTIONS_ENTRY(GetSMS)
+ ATHW_FUNCTIONS_ENTRY(DeleteSMS)
+ ATHW_FUNCTIONS_ENTRY(SendSMS)
+ ATHW_FUNCTIONS_ENTRY(SaveSMS)
+ ATHW_FUNCTIONS_ENTRY(GetRFLevel)
+ ATHW_FUNCTIONS_ENTRY(GetBatteryLevel)
+ ATHW_FUNCTIONS_ENTRY(GetPowersource)
+ ATHW_FUNCTIONS_ENTRY(GetImei)
+ ATHW_FUNCTIONS_ENTRY(GetRevision)
+ ATHW_FUNCTIONS_ENTRY(GetModel)
+ ATHW_FUNCTIONS_ENTRY(GetManufacturer)
+ ATHW_FUNCTIONS_ENTRY(DialVoice)
+ ATHW_FUNCTIONS_ENTRY(DialData)
+ ATHW_FUNCTIONS_ENTRY(GetIncomingCallNr)
+ ATHW_FUNCTIONS_ENTRY(Reset)
+ ATHW_FUNCTIONS_ENTRY(CancelCall)
+ ATHW_FUNCTIONS_ENTRY(AnswerCall)
+ ATHW_FUNCTIONS_ENTRY(GetNetworkInfo)
+
+ case GOP_Identify: {
+GSM_Error err,r=GE_NONE;
+ if (GE_NONE!=(err=ATHW_GetImei (data,state)))
+ r=err;
+ if (GE_NONE!=(err=ATHW_GetRevision (data,state)))
+ r=err;
+ if (GE_NONE!=(err=ATHW_GetModel (data,state)))
+ r=err;
+ if (GE_NONE!=(err=ATHW_GetManufacturer(data,state)))
+ r=err;
+ return(r);
+ }
+
+ default:
+ return(GE_NOTIMPLEMENTED);
+ }
+}
+
+GSM_Phone phone_at_hw = {
+ UNIMPLEMENTED, /* IncomingFunctions - we don't use default StateMachine */
+ UNIMPLEMENTED, /* DefaultFunction - we don't use default StateMachine */
+ /* Mobile phone information */
+ {
+ "AT", /* Supported models */
+ 31, /* Max RF Level (AT+CSQ) */
+ 0, /* Min RF Level (AT+CSQ) */
+ GRF_CSQ, /* RF level units */
+ 100, /* Max Battery Level (AT+CBC) */
+ 0, /* Min Battery Level (AT+CBC) */
+ GBU_Percentage, /* Battery level units */
+ GDT_None, /* Have date/time support */
+ GDT_None, /* Alarm supports time only */
+ 0, /* No alarm available */
+ 48, 84, /* Startup logo size */
+ 14, 72, /* Op logo size */
+ 14, 72, /* Caller logo size */
+ },
+ ATHW_Functions,
+};
git://git.jankratochvil.net / gnokii.git / blobdiff