State machine

Data Structures
struct	GSM_Reply_Function
struct	GSM_Device_Functions
struct	GSM_Device
struct	GSM_Protocol_Functions
struct	GSM_Protocol
struct	GSM_Phone_Data
struct	GSM_Phone_Functions
struct	GSM_Phone
struct	_GSM_User
struct	_GSM_StateMachine
struct	GSM_Config

Macros
#define	GSM_ENABLE_SERIALDEVICE
#define	GSM_ENABLE_IRDADEVICE
#define	MAX_CONFIG_NUM   5
#define	GSM_WaitForAutoLen(s, buffer, type, timeout, request)   GSM_WaitFor(s,buffer,strlen(buffer),type,timeout,request)

Typedefs
typedef struct _GSM_User	GSM_User
typedef struct _GSM_StateMachine	GSM_StateMachine

Enumerations
enum	GSM_Phone_RequestID {   ID_None =1, ID_GetModel, ID_GetFirmware, ID_EnableSecurity,   ID_OpenFile, ID_CloseFile, ID_GetIMEI, ID_GetDateTime,   ID_GetAlarm, ID_GetMemory, ID_GetMemoryStatus, ID_GetSMSC,   ID_GetSMSMessage, ID_EnableEcho, ID_EnableErrorInfo, ID_SetOBEX,   ID_SetUSSD, ID_GetUSSD, ID_GetNote, ID_SetNote,   ID_GetSignalQuality, ID_GetBatteryCharge, ID_GetSMSFolders, ID_GetSMSFolderStatus,   ID_GetSMSStatus, ID_AddSMSFolder, ID_ConfigureNetworkInfo, ID_GetNetworkInfo,   ID_GetNetworkCode, ID_GetNetworkName, ID_GetRingtone, ID_DialVoice,   ID_GetCalendarNotesInfo, ID_GetCalendarNote, ID_GetSecurityCode, ID_GetWAPBookmark,   ID_GetBitmap, ID_GetCRC, ID_SetAttrib, ID_SaveSMSMessage,   ID_CancelCall, ID_SetDateTime, ID_SetAlarm, ID_DisableConnectFunc,   ID_EnableConnectFunc, ID_AnswerCall, ID_SetBitmap, ID_SetRingtone,   ID_DeleteSMSMessage, ID_DeleteCalendarNote, ID_SetPath, ID_SetSMSC,   ID_SetProfile, ID_SetMemory, ID_DeleteMemory, ID_SetCalendarNote,   ID_AddCalendarNote, ID_SetIncomingSMS, ID_SetIncomingCB, ID_SetIncomingCall,   ID_GetCNMIMode, ID_GetCalendarNotePos, ID_Initialise, ID_Terminate,   ID_GetConnectSet, ID_SetWAPBookmark, ID_GetLocale, ID_SetLocale,   ID_GetCalendarSettings, ID_SetCalendarSettings, ID_GetGPRSPoint, ID_GetGPRSState,   ID_SetGPRSPoint, ID_EnableGPRSPoint, ID_DeleteWAPBookmark, ID_Netmonitor,   ID_HoldCall, ID_UnholdCall, ID_ConferenceCall, ID_SplitCall,   ID_TransferCall, ID_SwitchCall, ID_GetManufactureMonth, ID_GetProductCode,   ID_GetOriginalIMEI, ID_GetHardware, ID_GetPPM, ID_GetSMSMode,   ID_GetSMSMemories, ID_GetManufacturer, ID_SetMemoryType, ID_GetMemoryCharset,   ID_SetMemoryCharset, ID_SetSMSParameters, ID_GetFMStation, ID_SetFMStation,   ID_GetLanguage, ID_SetFastSMSSending, ID_Reset, ID_GetToDoInfo,   ID_GetToDo, ID_PressKey, ID_DeleteAllToDo, ID_SetLight,   ID_Divert, ID_SetDivert, ID_SetToDo, ID_AddToDo,   ID_PlayTone, ID_GetChatSettings, ID_GetSyncMLSettings, ID_GetSyncMLName,   ID_GetSecurityStatus, ID_EnterSecurityCode, ID_GetProfile, ID_GetRingtonesInfo,   ID_MakeAuthentication, ID_GetSpeedDial, ID_ResetPhoneSettings, ID_SendDTMF,   ID_GetDisplayStatus, ID_SetAutoNetworkLogin, ID_SetConnectSet, ID_GetSIMIMSI,   ID_GetFileInfo, ID_FileSystemStatus, ID_GetFile, ID_AddFile,   ID_AddFolder, ID_DeleteFolder, ID_DeleteFile, ID_ModeSwitch,   ID_GetProtocol, ID_Screenshot, ID_GetScreenSize, ID_SetFlowControl,   ID_AlcatelConnect, ID_AlcatelProtocol, ID_AlcatelAttach, ID_AlcatelDetach,   ID_AlcatelCommit, ID_AlcatelCommit2, ID_AlcatelEnd, ID_AlcatelClose,   ID_AlcatelStart, ID_AlcatelSelect1, ID_AlcatelSelect2, ID_AlcatelSelect3,   ID_AlcatelBegin1, ID_AlcatelBegin2, ID_AlcatelGetIds1, ID_AlcatelGetIds2,   ID_AlcatelGetCategories1, ID_AlcatelGetCategories2, ID_AlcatelGetCategoryText1, ID_AlcatelGetCategoryText2,   ID_AlcatelAddCategoryText1, ID_AlcatelAddCategoryText2, ID_AlcatelGetFields1, ID_AlcatelGetFields2,   ID_AlcatelGetFieldValue1, ID_AlcatelGetFieldValue2, ID_AlcatelDeleteItem1, ID_AlcatelDeleteItem2,   ID_AlcatelDeleteField, ID_AlcatelCreateField, ID_AlcatelUpdateField, ID_SetPower,   ID_IncomingFrame, ID_User1, ID_User2, ID_User3,   ID_User4, ID_User5, ID_User6, ID_User7,   ID_User8, ID_User9, ID_User10, ID_All,   ID_EachFrame }

Functions
GSM_Error	GSM_RegisterAllPhoneModules (GSM_StateMachine *s)
GSM_Error	GSM_WaitForOnce (GSM_StateMachine *s, unsigned const char *buffer, size_t length, int type, int timeout)
GSM_Error	GSM_WaitFor (GSM_StateMachine *s, unsigned const char *buffer, size_t length, int type, int timeout, GSM_Phone_RequestID request) WARNUNUSED
GSM_Error	GSM_DispatchMessage (GSM_StateMachine *s)
void	GSM_DumpMessageText (GSM_StateMachine *s, unsigned const char *message, size_t messagesize, int type)
void	GSM_DumpMessageTextRecv (GSM_StateMachine *s, unsigned const char *message, size_t messagesize, int type)
void	GSM_DumpMessageBinary (GSM_StateMachine *s, unsigned const char *message, size_t messagesize, int type)
void	GSM_DumpMessageBinaryRecv (GSM_StateMachine *s, unsigned const char *message, size_t messagesize, int type)
void	GSM_OSErrorInfo (GSM_StateMachine *s, const char *description)
GSM_Debug_Info *	GSM_GetDebug (GSM_StateMachine *s)
GSM_Debug_Info *	GSM_GetDI (GSM_StateMachine *s)
GSM_Error	GSM_InitConnection_Log (GSM_StateMachine *s, int ReplyNum, GSM_Log_Function log_function, void *user_data)
GSM_Error	GSM_InitConnection (GSM_StateMachine *s, int ReplyNum)
GSM_Error	GSM_TerminateConnection (GSM_StateMachine *s)
GSM_Error	GSM_AbortOperation (GSM_StateMachine *s)
int	GSM_ReadDevice (GSM_StateMachine *s, gboolean waitforreply)
gboolean	GSM_IsConnected (GSM_StateMachine *s)
GSM_Error	GSM_FindGammuRC (INI_Section **result, const char *force_config)
GSM_Error	GSM_ReadConfig (INI_Section *cfg_info, GSM_Config *cfg, int num)
GSM_Config *	GSM_GetConfig (GSM_StateMachine *s, int num)
int	GSM_GetConfigNum (const GSM_StateMachine *s)
void	GSM_SetConfigNum (GSM_StateMachine *s, int sections)
GSM_StateMachine *	GSM_AllocStateMachine (void)
void	GSM_FreeStateMachine (GSM_StateMachine *s)
GSM_ConnectionType	GSM_GetUsedConnection (GSM_StateMachine *s)
GSM_Error	GSM_Install (GSM_StateMachine *s, const char *ExtraPath, gboolean Minimal)

Variables
GSM_Device_Functions	ProxyDevice
GSM_Phone_Functions	NAUTOPhone
GSM_Phone_Functions	DUMMYPhone

Detailed Description

Generic state machine layer.

Macro Definition Documentation

GSM_ENABLE_IRDADEVICE

#define GSM_ENABLE_IRDADEVICE

Definition at line 172 of file gsmstate.h.

GSM_ENABLE_SERIALDEVICE

#define GSM_ENABLE_SERIALDEVICE

Definition at line 162 of file gsmstate.h.

GSM_WaitForAutoLen

#define GSM_WaitForAutoLen	(		s,
			buffer,
			type,
			timeout,
			request
	)		GSM_WaitFor(s,buffer,strlen(buffer),type,timeout,request)

Wait for reply from the phone for ASCII strings without given length. This is just a convenience wrapper around GSM_WaitFor which fills in length.

Parameters

s	State machine pointer.
buffer	Data to write to phone.
type	Type of request (for protocols where it makes sense).
timeout	How long to wait for reply.
request	ID of request

Returns

Error code, ERR_NONE on sucecss.

Definition at line 1478 of file gsmstate.h.

MAX_CONFIG_NUM

#define MAX_CONFIG_NUM   5

Maximum number of concurrent configurations.

Definition at line 1399 of file gsmstate.h.

Referenced by GSM_FreeStateMachine(), GSM_GetConfig(), and GSM_SetConfigNum().

Typedef Documentation

GSM_StateMachine

typedef struct _GSM_StateMachine GSM_StateMachine

Private structure holding information about phone connection. Should be allocated by GSM_AllocStateMachine and freed by GSM_FreeStateMachine.

Definition at line 40 of file gammu-statemachine.h.

GSM_User

typedef struct _GSM_User GSM_User

Definition at line 32 of file gsmstate.h.

Enumeration Type Documentation

GSM_Phone_RequestID

enum GSM_Phone_RequestID

Phone requests identificators, these are used for internally identifying which operation is being performed.

Enumerator
ID_None
ID_GetModel
ID_GetFirmware
ID_EnableSecurity
ID_OpenFile
ID_CloseFile
ID_GetIMEI
ID_GetDateTime
ID_GetAlarm
ID_GetMemory
ID_GetMemoryStatus
ID_GetSMSC
ID_GetSMSMessage
ID_EnableEcho
ID_EnableErrorInfo
ID_SetOBEX
ID_SetUSSD
ID_GetUSSD
ID_GetNote
ID_SetNote
ID_GetSignalQuality
ID_GetBatteryCharge
ID_GetSMSFolders
ID_GetSMSFolderStatus
ID_GetSMSStatus
ID_AddSMSFolder
ID_ConfigureNetworkInfo
ID_GetNetworkInfo
ID_GetNetworkCode
ID_GetNetworkName
ID_GetRingtone
ID_DialVoice
ID_GetCalendarNotesInfo
ID_GetCalendarNote
ID_GetSecurityCode
ID_GetWAPBookmark
ID_GetBitmap
ID_GetCRC
ID_SetAttrib
ID_SaveSMSMessage
ID_CancelCall
ID_SetDateTime
ID_SetAlarm
ID_DisableConnectFunc
ID_EnableConnectFunc
ID_AnswerCall
ID_SetBitmap
ID_SetRingtone
ID_DeleteSMSMessage
ID_DeleteCalendarNote
ID_SetPath
ID_SetSMSC
ID_SetProfile
ID_SetMemory
ID_DeleteMemory
ID_SetCalendarNote
ID_AddCalendarNote
ID_SetIncomingSMS
ID_SetIncomingCB
ID_SetIncomingCall
ID_GetCNMIMode
ID_GetCalendarNotePos
ID_Initialise
ID_Terminate
ID_GetConnectSet
ID_SetWAPBookmark
ID_GetLocale
ID_SetLocale
ID_GetCalendarSettings
ID_SetCalendarSettings
ID_GetGPRSPoint
ID_GetGPRSState
ID_SetGPRSPoint
ID_EnableGPRSPoint
ID_DeleteWAPBookmark
ID_Netmonitor
ID_HoldCall
ID_UnholdCall
ID_ConferenceCall
ID_SplitCall
ID_TransferCall
ID_SwitchCall
ID_GetManufactureMonth
ID_GetProductCode
ID_GetOriginalIMEI
ID_GetHardware
ID_GetPPM
ID_GetSMSMode
ID_GetSMSMemories
ID_GetManufacturer
ID_SetMemoryType
ID_GetMemoryCharset
ID_SetMemoryCharset
ID_SetSMSParameters
ID_GetFMStation
ID_SetFMStation
ID_GetLanguage
ID_SetFastSMSSending
ID_Reset
ID_GetToDoInfo
ID_GetToDo
ID_PressKey
ID_DeleteAllToDo
ID_SetLight
ID_Divert
ID_SetDivert
ID_SetToDo
ID_AddToDo
ID_PlayTone
ID_GetChatSettings
ID_GetSyncMLSettings
ID_GetSyncMLName
ID_GetSecurityStatus
ID_EnterSecurityCode
ID_GetProfile
ID_GetRingtonesInfo
ID_MakeAuthentication
ID_GetSpeedDial
ID_ResetPhoneSettings
ID_SendDTMF
ID_GetDisplayStatus
ID_SetAutoNetworkLogin
ID_SetConnectSet
ID_GetSIMIMSI
ID_GetFileInfo
ID_FileSystemStatus
ID_GetFile
ID_AddFile
ID_AddFolder
ID_DeleteFolder
ID_DeleteFile
ID_ModeSwitch
ID_GetProtocol
ID_Screenshot
ID_GetScreenSize
ID_SetFlowControl
ID_AlcatelConnect
ID_AlcatelProtocol
ID_AlcatelAttach
ID_AlcatelDetach
ID_AlcatelCommit
ID_AlcatelCommit2
ID_AlcatelEnd
ID_AlcatelClose
ID_AlcatelStart
ID_AlcatelSelect1
ID_AlcatelSelect2
ID_AlcatelSelect3
ID_AlcatelBegin1
ID_AlcatelBegin2
ID_AlcatelGetIds1
ID_AlcatelGetIds2
ID_AlcatelGetCategories1
ID_AlcatelGetCategories2
ID_AlcatelGetCategoryText1
ID_AlcatelGetCategoryText2
ID_AlcatelAddCategoryText1
ID_AlcatelAddCategoryText2
ID_AlcatelGetFields1
ID_AlcatelGetFields2
ID_AlcatelGetFieldValue1
ID_AlcatelGetFieldValue2
ID_AlcatelDeleteItem1
ID_AlcatelDeleteItem2
ID_AlcatelDeleteField
ID_AlcatelCreateField
ID_AlcatelUpdateField
ID_SetPower
ID_IncomingFrame
ID_User1
ID_User2
ID_User3
ID_User4
ID_User5
ID_User6
ID_User7
ID_User8
ID_User9
ID_User10
ID_All
ID_EachFrame

Definition at line 25 of file gsmreply.h.

             {
        ID_None=1,
        ID_GetModel,
        ID_GetFirmware,
        ID_EnableSecurity,
        ID_OpenFile,
        ID_CloseFile,
        ID_GetIMEI,
        ID_GetDateTime,
        ID_GetAlarm,
        ID_GetMemory,
        ID_GetMemoryStatus,
        ID_GetSMSC,
        ID_GetSMSMessage,
        ID_EnableEcho,
        ID_EnableErrorInfo,
        ID_SetOBEX,
        ID_SetUSSD,
        ID_GetUSSD,
        ID_GetNote,
        ID_SetNote,
        ID_GetSignalQuality,
        ID_GetBatteryCharge,
        ID_GetSMSFolders,
        ID_GetSMSFolderStatus,
        ID_GetSMSStatus,
        ID_AddSMSFolder,
        ID_ConfigureNetworkInfo,
        ID_GetNetworkInfo,
        ID_GetNetworkCode,
        ID_GetNetworkName,
        ID_GetRingtone,
        ID_DialVoice,
        ID_GetCalendarNotesInfo,
        ID_GetCalendarNote,
        ID_GetSecurityCode,
        ID_GetWAPBookmark,
        ID_GetBitmap,
        ID_GetCRC,
        ID_SetAttrib,
        ID_SaveSMSMessage,
        ID_CancelCall,
        ID_SetDateTime,
        ID_SetAlarm,
        ID_DisableConnectFunc,
        ID_EnableConnectFunc,
        ID_AnswerCall,
        ID_SetBitmap,
        ID_SetRingtone,
        ID_DeleteSMSMessage,
        ID_DeleteCalendarNote,
        ID_SetPath,
        ID_SetSMSC,
        ID_SetProfile,
        ID_SetMemory,
        ID_DeleteMemory,
        ID_SetCalendarNote,
        ID_AddCalendarNote,
        ID_SetIncomingSMS,
        ID_SetIncomingCB,
        ID_SetIncomingCall,
        ID_GetCNMIMode,
        ID_GetCalendarNotePos,
        ID_Initialise,
        ID_Terminate,
        ID_GetConnectSet,
        ID_SetWAPBookmark,
        ID_GetLocale,
        ID_SetLocale,
        ID_GetCalendarSettings,
        ID_SetCalendarSettings,
        ID_GetGPRSPoint,
        ID_GetGPRSState,
        ID_SetGPRSPoint,
        ID_EnableGPRSPoint,
        ID_DeleteWAPBookmark,
        ID_Netmonitor,
        ID_HoldCall,
        ID_UnholdCall,
        ID_ConferenceCall,
        ID_SplitCall,
        ID_TransferCall,
        ID_SwitchCall,
        ID_GetManufactureMonth,
        ID_GetProductCode,
        ID_GetOriginalIMEI,
        ID_GetHardware,
        ID_GetPPM,
        ID_GetSMSMode,
        ID_GetSMSMemories,
        ID_GetManufacturer,
        ID_SetMemoryType,
        ID_GetMemoryCharset,
        ID_SetMemoryCharset,
        ID_SetSMSParameters,
        ID_GetFMStation,
        ID_SetFMStation,
        ID_GetLanguage,
        ID_SetFastSMSSending,
        ID_Reset,
        ID_GetToDoInfo,
        ID_GetToDo,
        ID_PressKey,
        ID_DeleteAllToDo,
        ID_SetLight,
        ID_Divert,
        ID_SetDivert,
        ID_SetToDo,
        ID_AddToDo,
        ID_PlayTone,
        ID_GetChatSettings,
        ID_GetSyncMLSettings,
        ID_GetSyncMLName,
        ID_GetSecurityStatus,
        ID_EnterSecurityCode,
        ID_GetProfile,
        ID_GetRingtonesInfo,
        ID_MakeAuthentication,
        ID_GetSpeedDial,
        ID_ResetPhoneSettings,
        ID_SendDTMF,
        ID_GetDisplayStatus,
        ID_SetAutoNetworkLogin,
        ID_SetConnectSet,
        ID_GetSIMIMSI,
        ID_GetFileInfo,
        ID_FileSystemStatus,
        ID_GetFile,
        ID_AddFile,
        ID_AddFolder,
        ID_DeleteFolder,
        ID_DeleteFile,
        ID_ModeSwitch,
        ID_GetProtocol,
        ID_Screenshot,
        ID_GetScreenSize,

        /* Alcatel AT mode */
        ID_SetFlowControl,
        ID_AlcatelConnect,
        ID_AlcatelProtocol,

        /* Alcatel Binary mode */
        ID_AlcatelAttach,
        ID_AlcatelDetach,
        ID_AlcatelCommit,
        ID_AlcatelCommit2,
        ID_AlcatelEnd,
        ID_AlcatelClose,
        ID_AlcatelStart,
        ID_AlcatelSelect1,
        ID_AlcatelSelect2,
        ID_AlcatelSelect3,
        ID_AlcatelBegin1,
        ID_AlcatelBegin2,
        ID_AlcatelGetIds1,
        ID_AlcatelGetIds2,
        ID_AlcatelGetCategories1,
        ID_AlcatelGetCategories2,
        ID_AlcatelGetCategoryText1,
        ID_AlcatelGetCategoryText2,
        ID_AlcatelAddCategoryText1,
        ID_AlcatelAddCategoryText2,
        ID_AlcatelGetFields1,
        ID_AlcatelGetFields2,
        ID_AlcatelGetFieldValue1,
        ID_AlcatelGetFieldValue2,
        ID_AlcatelDeleteItem1,
        ID_AlcatelDeleteItem2,
        ID_AlcatelDeleteField,
        ID_AlcatelCreateField,
        ID_AlcatelUpdateField,

        ID_SetPower,

        ID_IncomingFrame,

        ID_User1,
        ID_User2,
        ID_User3,
        ID_User4,
        ID_User5,
        ID_User6,
        ID_User7,
        ID_User8,
        ID_User9,
        ID_User10,

        ID_All,
        ID_EachFrame
} GSM_Phone_RequestID;

Function Documentation

GSM_AbortOperation()

GSM_Error GSM_AbortOperation

(

GSM_StateMachine *

s

)

Aborts current operation.

This is thread safe call to abort any existing operations with the phone.

Parameters

s	State machine data

Returns

Error code

Definition at line 980 of file gsmstate.c.

References _GSM_StateMachine::Abort, ERR_NONE, and TRUE.

{
        s->Abort = TRUE;
        return ERR_NONE;
}

GSM_AllocStateMachine()

GSM_StateMachine* GSM_AllocStateMachine

(

void

)

Allocates new clean state machine structure. You should free it then by GSM_FreeStateMachine.

Returns

Pointer to state machine structure.

Definition at line 1677 of file gsmstate.c.

References _GSM_StateMachine::Abort, _GSM_StateMachine::Config, _GSM_StateMachine::CurrentConfig, and FALSE.

{
        GSM_StateMachine *ret;
        ret = (GSM_StateMachine *)calloc(1, sizeof(GSM_StateMachine));
        if (ret == NULL) {
                return ret;
        }
        ret->CurrentConfig = &(ret->Config[0]);
        ret->Abort = FALSE;
        return ret;
}

GSM_DispatchMessage()

GSM_Error GSM_DispatchMessage

(

GSM_StateMachine *

s

)

Definition at line 1131 of file gsmstate.c.

References GSM_Protocol_Message::Buffer, CheckReplyFunctions(), D_ERROR, GSM_Phone::Data, DumpMessage(), ERR_FRAMENOTREQUESTED, ERR_NEEDANOTHERANSWER, ERR_NONE, ERR_TIMEOUT, ERR_UNKNOWNFRAME, ERR_UNKNOWNRESPONSE, FALSE, GSM_Reply_Function::Function, GSM_Phone::Functions, GSM_DumpMessageBinaryRecv(), GSM_DumpMessageTextRecv(), GSM_GetDI(), ID_None, GSM_Protocol_Message::Length, _GSM_StateMachine::MessagesCount, GSM_Phone_Functions::models, _GSM_StateMachine::Phone, GSM_Phone_Functions::ReplyFunctions, GSM_Phone_Data::RequestID, GSM_Phone_Data::RequestMsg, GSM_Phone_Data::SentMsg, smprintf(), smprintf_level(), TRUE, GSM_Protocol_Message::Type, _GSM_StateMachine::User, and _GSM_User::UserReplyFunctions.

{
        GSM_Error               error   = ERR_UNKNOWNFRAME;
        GSM_Protocol_Message    *msg    = s->Phone.Data.RequestMsg;
        GSM_Phone_Data          *Phone  = &s->Phone.Data;
        gboolean                        disp    = FALSE;
        GSM_Reply_Function      *Reply;
        int                     reply;

        s->MessagesCount++;

        GSM_DumpMessageTextRecv(s, msg->Buffer, msg->Length, msg->Type);
        GSM_DumpMessageBinaryRecv(s, msg->Buffer, msg->Length, msg->Type);

        Reply = s->User.UserReplyFunctions;
        if (Reply != NULL) {
                error = CheckReplyFunctions(s, Reply, &reply);
        }

        if (error == ERR_UNKNOWNFRAME) {
                Reply = s->Phone.Functions->ReplyFunctions;
                error = CheckReplyFunctions(s, Reply, &reply);
        }

        if (error == ERR_NONE) {
                error = Reply[reply].Function(msg, s);
                if (Reply[reply].requestID == Phone->RequestID) {
                        if (error == ERR_NEEDANOTHERANSWER) {
                                error = ERR_NONE;
                        } else {
                                Phone->RequestID = ID_None;
                        }
                }
        }

        if (strcmp(s->Phone.Functions->models,"NAUTO")) {
                disp = TRUE;
                switch (error) {
                case ERR_UNKNOWNRESPONSE:
                        smprintf_level(s, D_ERROR, "\nUNKNOWN response");
                        break;
                case ERR_UNKNOWNFRAME:
                        smprintf_level(s, D_ERROR, "\nUNKNOWN frame");
                        break;
                case ERR_FRAMENOTREQUESTED:
                        smprintf_level(s, D_ERROR, "\nFrame not request now");
                        break;
                default:
                        disp = FALSE;
                }

                if (error == ERR_UNKNOWNFRAME || error == ERR_FRAMENOTREQUESTED) {
                        error = ERR_TIMEOUT;
                }
        }

        if (disp) {
                smprintf(s,". Please report the error, see <https://wammu.eu/support/bugs/>. Thank you\n");
                if (Phone->SentMsg != NULL) {
                        smprintf(s,"LAST SENT frame ");
                        smprintf(s, "type 0x%02X/length %ld", Phone->SentMsg->Type, (long)Phone->SentMsg->Length);
                        DumpMessage(GSM_GetDI(s), Phone->SentMsg->Buffer, Phone->SentMsg->Length);
                }
                smprintf(s, "RECEIVED frame ");
                smprintf(s, "type 0x%02X/length 0x%lx/%ld", msg->Type, (long)msg->Length, (long)msg->Length);
                DumpMessage(GSM_GetDI(s), msg->Buffer, msg->Length);
                smprintf(s, "\n");
        }

        return error;
}

GSM_DumpMessageBinary()

void GSM_DumpMessageBinary	(	GSM_StateMachine *	s,
		unsigned const char *	message,
		size_t	messagesize,
		int	type
	)

Definition at line 1583 of file gsmstate.c.

References GSM_DumpMessageBinary_Custom().

{
        GSM_DumpMessageBinary_Custom(s, message, messagesize, type, 0x01);
}

GSM_DumpMessageBinaryRecv()

void GSM_DumpMessageBinaryRecv	(	GSM_StateMachine *	s,
		unsigned const char *	message,
		size_t	messagesize,
		int	type
	)

Definition at line 1588 of file gsmstate.c.

References GSM_DumpMessageBinary_Custom().

Referenced by GSM_DispatchMessage().

{
        GSM_DumpMessageBinary_Custom(s, message, messagesize, type, 0x02);
}

GSM_DumpMessageText()

void GSM_DumpMessageText	(	GSM_StateMachine *	s,
		unsigned const char *	message,
		size_t	messagesize,
		int	type
	)

Definition at line 1555 of file gsmstate.c.

References GSM_DumpMessageText_Custom().

{
        GSM_DumpMessageText_Custom(s, message, messagesize, type, "SENDING frame");
}

GSM_DumpMessageTextRecv()

void GSM_DumpMessageTextRecv	(	GSM_StateMachine *	s,
		unsigned const char *	message,
		size_t	messagesize,
		int	type
	)

Definition at line 1560 of file gsmstate.c.

References GSM_DumpMessageText_Custom().

Referenced by GSM_DispatchMessage().

{
        GSM_DumpMessageText_Custom(s, message, messagesize, type, "RECEIVED frame");
}

GSM_FindGammuRC()

GSM_Error GSM_FindGammuRC	(	INI_Section **	result,
		const char *	force_config
	)

Finds and reads gammu configuration file. The search order depends on platform. On POSIX systems it looks for ~/.gammurc and then for /etc/gammurc, on Windows for gammurc in Application data folder, then in home and last fallback is in current driectory.

Parameters

result	Ini file representation
force_config	Forcing of custom path instead of autodetected one (if NULL, autodetection is performed).

Returns

Error code

Definition at line 1209 of file gsmstate.c.

References ERR_NONE, FALLBACK_GAMMURC, GAMMURC_NAME, GSM_TryReadGammuRC(), PATH_MAX, and XDG_GAMMURC_NAME.

{
        char configfile[PATH_MAX + 1];
        char *envpath;
        GSM_Error error;
#if defined(HAVE_GETPWUID) && defined(HAVE_GETUID)
        struct passwd *pwent;
#endif

        *result = NULL;

        if (force_config != NULL) {
                return GSM_TryReadGammuRC(force_config, result);
        }

#ifdef WIN32
        /* Get Windows application data path */
        if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, configfile))) {
                strcat(configfile, GAMMURC_NAME);

                error = GSM_TryReadGammuRC(configfile, result);
                if (error == ERR_NONE) return ERR_NONE;
        }
#endif

        /* XDG paths */
        envpath = getenv("XDG_CONFIG_HOME");
        if (envpath) {
                strcpy(configfile, envpath);
                strcat(configfile, XDG_GAMMURC_NAME);

                error = GSM_TryReadGammuRC(configfile, result);
                if (error == ERR_NONE) return ERR_NONE;
        } else {
                envpath  = getenv("HOME");
                if (envpath) {
                        strcpy(configfile, envpath);
                        strcat(configfile, "/.config");
                        strcat(configfile, XDG_GAMMURC_NAME);

                        error = GSM_TryReadGammuRC(configfile, result);
                        if (error == ERR_NONE) return ERR_NONE;
                }
        }

        /* Try home from environment */
        envpath  = getenv("HOME");
        if (envpath) {
                strcpy(configfile, envpath);
                strcat(configfile, GAMMURC_NAME);

                error = GSM_TryReadGammuRC(configfile, result);
                if (error == ERR_NONE) return ERR_NONE;
        }

#if defined(HAVE_GETPWUID) && defined(HAVE_GETUID)
        /* Tru home from passwd */
        pwent = getpwuid(getuid());
        if (pwent != NULL) {
                strcpy(configfile, pwent->pw_dir);
                strcat(configfile, GAMMURC_NAME);

                error = GSM_TryReadGammuRC(configfile, result);
                if (error == ERR_NONE) return ERR_NONE;
        }

#endif

#if defined(WIN32)
        /* Reset as we're using strcat */
        configfile[0] = 0;

        /* This makes sense only on Windows */
        envpath = getenv("HOMEDRIVE");
        if (envpath) {
                strcat(configfile, envpath);
        }

        envpath = getenv("HOMEPATH");
        if (envpath) {
                strcat(configfile, envpath);
                strcat(configfile, GAMMURC_NAME);

                error = GSM_TryReadGammuRC(configfile, result);
                if (error == ERR_NONE) return ERR_NONE;
        }
#endif

        /* Try fallback config as last */
        return GSM_TryReadGammuRC(FALLBACK_GAMMURC, result);
}

GSM_FreeStateMachine()

void GSM_FreeStateMachine

(

GSM_StateMachine *

s

)

Frees state machine structure allocated by GSM_AllocStateMachine.

Parameters

s	Pointer to state machine structure.

Definition at line 1689 of file gsmstate.c.

References _GSM_StateMachine::Config, GSM_Config::Connection, GSM_Config::DebugFile, GSM_Config::Device, and MAX_CONFIG_NUM.

{
        int i=0;

        if (s == NULL) return;

        /* Free allocated memory */
        for (i = 0; i <= MAX_CONFIG_NUM; i++) {
                free(s->Config[i].Device);
                s->Config[i].Device = NULL;
                free(s->Config[i].Connection);
                s->Config[i].Connection = NULL;
                free(s->Config[i].DebugFile);
                s->Config[i].DebugFile = NULL;
        }
        free(s);
        s = NULL;
}

GSM_GetConfig()

GSM_Config* GSM_GetConfig	(	GSM_StateMachine *	s,
		int	num
	)

Gets gammu configuration from state machine. This actually returns pointer to internal configuration storage, so you can use it also for updating existing settings.

Parameters

s	State machine data
num	Number of section to read, -1 for currently used.

Returns

Pointer to configuration.

Definition at line 1301 of file gsmstate.c.

References _GSM_StateMachine::Config, _GSM_StateMachine::CurrentConfig, and MAX_CONFIG_NUM.

{
        if (num == -1) {
                return s->CurrentConfig;
        } else {
                if (num > MAX_CONFIG_NUM) return NULL;
                return &(s->Config[num]);
        }
}

GSM_GetConfigNum()

int GSM_GetConfigNum

(

const GSM_StateMachine *

s

)

Gets number of active gammu configurations.

Parameters

s	State machine data

Returns

Number of sections.

Definition at line 1312 of file gsmstate.c.

References _GSM_StateMachine::ConfigNum.

{
        return s->ConfigNum;
}

GSM_GetDebug()

GSM_Debug_Info* GSM_GetDebug

(

GSM_StateMachine *

s

)

Gets debug information for state machine.

Parameters

s	State machine data

Returns

Debug information.

Definition at line 1719 of file gsmstate.c.

References _GSM_StateMachine::di.

{
        return s == NULL ? NULL : &(s->di);
}

GSM_GetDI()

GSM_Debug_Info* GSM_GetDI

(

GSM_StateMachine *

s

)

Returns debug information active for state machine. Please note that it can be either global debug or state machine debug structure, depending on use_global flag. For configuring usite GSM_GetDebug.

Parameters

s	State machine data

Returns

Debug information.

Returns current debuging descriptor. It honors use_global flag.

Definition at line 70 of file gsmstate.c.

References _GSM_StateMachine::di, FALSE, GSM_global_debug, and _GSM_Debug_Info::use_global.

Referenced by GSM_DispatchMessage(), GSM_DumpMessageBinary_Custom(), GSM_DumpMessageText_Custom(), GSM_InitConnection_Log(), GSM_OSErrorInfo(), N71_65_DecodePhonebook(), PHONE_EncodeSMSFrame(), smprintf(), and smprintf_level().

{
        GSM_Debug_Info *curdi;

        curdi = &GSM_global_debug;
        if (s != NULL && s->di.use_global == FALSE) {
                curdi = &(s->di);
        }
        return curdi;
}

GSM_GetUsedConnection()

GSM_ConnectionType GSM_GetUsedConnection

(

GSM_StateMachine *

s

)

Gets number of active gammu configurations.

Parameters

s	State machine data

Returns

Connection type.

Definition at line 1709 of file gsmstate.c.

References _GSM_StateMachine::ConnectionType.

{
        return s->ConnectionType;
}

GSM_InitConnection()

GSM_Error GSM_InitConnection	(	GSM_StateMachine *	s,
		int	ReplyNum
	)

Initiates connection.

Parameters

s	State machine data
ReplyNum	Number of replies to await (usually 3).

Returns

Error code

Definition at line 914 of file gsmstate.c.

References GSM_InitConnection_Log(), GSM_none_debug, _GSM_Debug_Info::log_function, and _GSM_Debug_Info::user_data.

{
        return GSM_InitConnection_Log(s, ReplyNum, GSM_none_debug.log_function, GSM_none_debug.user_data);
}

GSM_InitConnection_Log()

GSM_Error GSM_InitConnection_Log	(	GSM_StateMachine *	s,
		int	ReplyNum,
		GSM_Log_Function	log_function,
		void *	user_data
	)

Initiates connection with custom logging callback.

Parameters

s	State machine data
ReplyNum	Number of replies to await (usually 3).
log_function	Logging function, see GSM_SetDebugFunction.
user_data	User data for logging function, see GSM_SetDebugFunction.

Returns

Error code

See also

GSM_SetDebugFunction

Definition at line 711 of file gsmstate.c.

References _GSM_StateMachine::Config, _GSM_StateMachine::ConfigNum, GSM_Config::Connection, _GSM_StateMachine::ConnectionType, _GSM_StateMachine::CurrentConfig, D_ERROR, GSM_Phone::Data, GSM_Config::DebugFile, GSM_Config::DebugLevel, GSM_Config::Device, _GSM_StateMachine::di, DL_BINARY, GSM_Phone_Data::EnableIncomingCall, GSM_Phone_Data::EnableIncomingCB, GSM_Phone_Data::EnableIncomingSMS, GSM_Phone_Data::EnableIncomingUSSD, ERR_DEVICEBUSY, ERR_DEVICELOCKED, ERR_DEVICENODRIVER, ERR_DEVICENOPERMISSION, ERR_DEVICENOTEXIST, ERR_DEVICENOTWORK, ERR_DEVICEOPENERROR, ERR_NONE, ERR_NOTSUPPORTED, ERR_TIMEOUT, ERR_UNCONFIGURED, ERR_UNKNOWNMODELSTRING, FALSE, GSM_Phone::Functions, GAMMU_VERSION, GCT_BLUEGNAPBUS, GCT_BLUEOBEX, GCT_BLUES60, GCT_IRDAGNAPBUS, GCT_IRDAOBEX, GCT_NONE, GCT_PROXYGNAPBUS, GCT_PROXYOBEX, GCT_PROXYS60, GSM_Phone_Functions::GetFirmware, GSM_Phone_Functions::GetManufacturer, GSM_Phone_Functions::GetModel, GetModelData(), GetOS(), GSM_CloseConnection(), GSM_GetCurrentDateTime(), GSM_GetDI(), GSM_LogError(), GSM_none_debug, GSM_OpenConnection(), GSM_RegisterAllConnections(), GSM_RegisterAllPhoneModules(), GSM_SetDebugFile(), GSM_SetDebugFunction(), GSM_SetDebugLevel(), GSM_TryGetModel(), GSM_Phone_Data::HardwareCache, _GSM_User::IncomingCall, _GSM_User::IncomingCB, _GSM_User::IncomingSMS, _GSM_User::IncomingUSSD, GSM_Phone_Functions::Initialise, _GSM_StateMachine::LockFile, GSM_Phone_Data::Manufacturer, GSM_Config::Model, GSM_Phone_Data::Model, GSM_Phone_Data::ModelInfo, _GSM_StateMachine::opened, _GSM_StateMachine::Phone, GSM_Phone_Functions::PostConnect, GSM_Phone_Data::ProductCodeCache, _GSM_StateMachine::ReplyNum, _GSM_User::SendSMSStatus, GSM_Phone_Data::SentMsg, GSM_Phone_Functions::SetDateTime, GSM_Phone_Functions::ShowStartInfo, smprintf(), smprintf_level(), _GSM_StateMachine::Speed, GSM_Config::StartInfo, GSM_Phone_Data::StartInfoCounter, StripSpaces(), GSM_Config::SyncTime, TRUE, _GSM_Debug_Info::use_global, GSM_Config::UseGlobalDebugFile, _GSM_StateMachine::User, _GSM_User::UserReplyFunctions, GSM_Phone_Data::VerDate, GSM_Phone_Data::VerNum, and GSM_Phone_Data::Version.

Referenced by GSM_InitConnection().

{
        GSM_Error       error;
        GSM_DateTime    current_time;
        int             i;

        for (i=0;i<s->ConfigNum;i++) {
                s->CurrentConfig                  = &s->Config[i];

                /* Skip non configured sections */
                if (s->CurrentConfig->Connection == NULL) {
                        smprintf_level(s, D_ERROR, "[Empty section    - %d]\n", i);
                        continue;
                }

                s->Speed                          = 0;
                s->ReplyNum                       = ReplyNum;
                s->Phone.Data.ModelInfo           = GetModelData(s, "unknown", NULL, NULL);
                s->Phone.Data.Manufacturer[0]     = 0;
                s->Phone.Data.Model[0]            = 0;
                s->Phone.Data.Version[0]          = 0;
                s->Phone.Data.VerDate[0]          = 0;
                s->Phone.Data.VerNum              = 0;
                s->Phone.Data.StartInfoCounter    = 0;
                s->Phone.Data.SentMsg             = NULL;

                s->Phone.Data.HardwareCache[0]    = 0;
                s->Phone.Data.ProductCodeCache[0] = 0;
                s->Phone.Data.EnableIncomingCall  = FALSE;
                s->Phone.Data.EnableIncomingSMS   = FALSE;
                s->Phone.Data.EnableIncomingCB    = FALSE;
                s->Phone.Data.EnableIncomingUSSD  = FALSE;
                s->User.UserReplyFunctions        = NULL;
                s->User.IncomingCall              = NULL;
                s->User.IncomingSMS               = NULL;
                s->User.IncomingCB                = NULL;
                s->User.IncomingUSSD              = NULL;
                s->User.SendSMSStatus             = NULL;
                s->LockFile                       = NULL;
                s->opened                         = FALSE;
                s->Phone.Functions                = NULL;

                s->di                             = GSM_none_debug;
                s->di.use_global                  = s->CurrentConfig->UseGlobalDebugFile;
                if (!s->di.use_global) {
                        GSM_SetDebugFunction(log_function, user_data, &s->di);
                        GSM_SetDebugLevel(s->CurrentConfig->DebugLevel, &s->di);
                        error = GSM_SetDebugFile(s->CurrentConfig->DebugFile, &s->di);
                        if (error != ERR_NONE) {
                                GSM_LogError(s, "Init:GSM_SetDebugFile" , error);
                                return error;
                        }
                }

                smprintf_level(s, D_ERROR, "[Gammu            - %s]\n", GAMMU_VERSION);
                StripSpaces(s->CurrentConfig->Connection);
                StripSpaces(s->CurrentConfig->Model);
                StripSpaces(s->CurrentConfig->Device);
                smprintf_level(s, D_ERROR, "[Connection       - \"%s\"]\n",
                                s->CurrentConfig->Connection);
                smprintf_level(s, D_ERROR, "[Connection index - %d]\n", i);
                smprintf_level(s, D_ERROR, "[Model type       - \"%s\"]\n",
                                s->CurrentConfig->Model);
                smprintf_level(s, D_ERROR, "[Device           - \"%s\"]\n",
                                s->CurrentConfig->Device);
                if (strlen(GetOS()) != 0) {
                        smprintf_level(s, D_ERROR, "[Running on       - %s]\n",
                                        GetOS());
                }

                if (GSM_GetDI(s)->dl == DL_BINARY) {
                        smprintf(s,"%c",((unsigned char)strlen(GAMMU_VERSION)));
                        smprintf(s,"%s",GAMMU_VERSION);
                }

                error = GSM_RegisterAllConnections(s, s->CurrentConfig->Connection);
                if (error != ERR_NONE) {
                        GSM_LogError(s, "Init:GSM_RegisterAllConnections" , error);
                        return error;
                }

autodetect:
                /* Model auto */
                /* Try to guess correct driver based on model */
                if (s->CurrentConfig->Model[0] == 0 &&
                                s->ConnectionType != GCT_NONE &&
                                s->ConnectionType != GCT_IRDAOBEX &&
                                s->ConnectionType != GCT_BLUEOBEX &&
                                s->ConnectionType != GCT_PROXYOBEX &&
                                s->ConnectionType != GCT_BLUEGNAPBUS &&
                                s->ConnectionType != GCT_PROXYGNAPBUS &&
                                s->ConnectionType != GCT_IRDAGNAPBUS &&
                                s->ConnectionType != GCT_PROXYS60 &&
                                s->ConnectionType != GCT_BLUES60) {
                        error = GSM_TryGetModel(s);
                        /* Fall back to other configuraitons if the device is not existing (or similar error) */
                        if ((i != s->ConfigNum - 1) && (
                                (error == ERR_DEVICEOPENERROR) ||
                                (error == ERR_DEVICELOCKED) ||
                                (error == ERR_DEVICENOTEXIST) ||
                                (error == ERR_DEVICEBUSY) ||
                                (error == ERR_DEVICENOPERMISSION) ||
                                (error == ERR_DEVICENODRIVER) ||
                                (error == ERR_DEVICENOTWORK))) {
                                GSM_CloseConnection(s);
                                continue;
                        }
                        if (error != ERR_NONE) {
                                GSM_LogError(s, "Init:GSM_TryGetModel" , error);
                                return error;
                        }
                }

                /* Switching to "correct" module */
                error = GSM_RegisterAllPhoneModules(s);
                /* If user selected soemthing which is not supported, try autodetection */
                if (s->CurrentConfig->Model[0] != 0 && error == ERR_UNKNOWNMODELSTRING) {
                        smprintf(s, "Configured model %s is not known, retrying with autodetection!\n",
                                        s->CurrentConfig->Model);
                        s->CurrentConfig->Model[0] = 0;
                        goto autodetect;
                }
                if (error != ERR_NONE) {
                        GSM_LogError(s, "Init:GSM_RegisterAllPhoneModules" , error);
                        return error;
                }

                /* We didn't open device earlier ? Make it now */
                if (!s->opened) {
                        error = GSM_OpenConnection(s);
                        if ((i != s->ConfigNum - 1) && (
                                (error == ERR_DEVICEOPENERROR) ||
                                (error == ERR_DEVICELOCKED) ||
                                (error == ERR_DEVICENOTEXIST) ||
                                (error == ERR_DEVICEBUSY) ||
                                (error == ERR_DEVICENOPERMISSION) ||
                                (error == ERR_DEVICENODRIVER) ||
                                (error == ERR_DEVICENOTWORK))) {
                                GSM_CloseConnection(s);
                                continue;
                        }
                        if (error != ERR_NONE) {
                                GSM_LogError(s, "Init:GSM_OpenConnection" , error);
                                return error;
                        }
                }

                /* Initialize phone layer */
                error=s->Phone.Functions->Initialise(s);
                if (error == ERR_TIMEOUT && i != s->ConfigNum - 1) {
                        GSM_CloseConnection(s);
                        continue;
                }
                if (error != ERR_NONE) {
                        GSM_LogError(s, "Init:Phone->Initialise" , error);
                        return error;
                }

                if (s->CurrentConfig->StartInfo) {
                        s->Phone.Functions->ShowStartInfo(s,TRUE);
                        s->Phone.Data.StartInfoCounter = 30;
                }

                if (s->CurrentConfig->SyncTime) {
                        GSM_GetCurrentDateTime (&current_time);
                        s->Phone.Functions->SetDateTime(s,&current_time);
                }

                /* For debug it's good to have firmware and real model version and manufacturer */
                error=s->Phone.Functions->GetManufacturer(s);
                if (error == ERR_TIMEOUT && i != s->ConfigNum - 1) {
                        GSM_CloseConnection(s);
                        continue;
                }
                if (error != ERR_NONE && error != ERR_NOTSUPPORTED) {
                        GSM_LogError(s, "Init:Phone->GetManufacturer" , error);
                        return error;
                }

                error=s->Phone.Functions->GetModel(s);
                if (error != ERR_NONE && error != ERR_NOTSUPPORTED) {
                        GSM_LogError(s, "Init:Phone->GetModel" , error);
                        return error;
                }

                error=s->Phone.Functions->GetFirmware(s);
                if (error != ERR_NONE && error != ERR_NOTSUPPORTED) {
                        GSM_LogError(s, "Init:Phone->GetFirmware" , error);
                        return error;
                }

                error=s->Phone.Functions->PostConnect(s);
                if (error != ERR_NONE && error != ERR_NOTSUPPORTED) {
                        GSM_LogError(s, "Init:Phone->PostConnect" , error);
                        return error;
                }

                smprintf(s,"[Connected]\n");
                return ERR_NONE;
        }
        return ERR_UNCONFIGURED;
}

GSM_Install()

GSM_Error GSM_Install	(	GSM_StateMachine *	s,
		const char *	ExtraPath,
		gboolean	Minimal
	)

Installs applet required for configured connection to the phone.

Parameters

s	State machine data.
ExtraPath	Extra path where to search for installation data.
Minimal	Whether to do minimal installation (eg. without support libraries), useful for applet updates

Returns

Result of operation.

Gets phone screenshot

Definition at line 1888 of file api.c.

References GSM_Phone::Functions, GSM_Phone_Functions::Install, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

{
        GSM_Error err;

        err = s->Phone.Functions->Install(s, ExtraPath, Minimal);
        PRINT_LOG_ERROR(err);
        return err;
}

GSM_IsConnected()

gboolean GSM_IsConnected

(

GSM_StateMachine *

s

)

Detects whether state machine is connected.

Parameters

s	State machine data

Returns

Whether phone is connected.

Definition at line 976 of file gsmstate.c.

References GSM_Phone::Functions, _GSM_StateMachine::opened, and _GSM_StateMachine::Phone.

Referenced by GSM_ReadDevice().

                                              {
        return (s != NULL) && s->Phone.Functions != NULL && s->opened;
}

GSM_OSErrorInfo()

void GSM_OSErrorInfo	(	GSM_StateMachine *	s,
		const char *	description
	)

Definition at line 1593 of file gsmstate.c.

References _GSM_Debug_Info::dl, DL_TEXT, DL_TEXTALL, DL_TEXTALLDATE, DL_TEXTDATE, DL_TEXTERROR, DL_TEXTERRORDATE, GSM_GetDI(), and smprintf().

Referenced by DUMMY_Error(), DUMMY_Initialise(), proxy_connect(), proxy_read(), and proxy_write().

{
#ifdef WIN32
        int             i=0;
        unsigned char   *lpMsgBuf = NULL;
#endif
        GSM_Debug_Info *curdi;

        curdi = GSM_GetDI(s);

#ifdef WIN32
        /* We don't use errno in win32 - GetLastError gives better info */
        if (GetLastError() != 0) {
                if (curdi->dl == DL_TEXTERROR ||
                                curdi->dl == DL_TEXT ||
                                curdi->dl == DL_TEXTALL ||
                                curdi->dl == DL_TEXTERRORDATE ||
                                curdi->dl == DL_TEXTDATE ||
                                curdi->dl == DL_TEXTALLDATE) {
                        FormatMessage(
                                FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                FORMAT_MESSAGE_FROM_SYSTEM |
                                FORMAT_MESSAGE_IGNORE_INSERTS,
                                NULL,
                                GetLastError(),
                                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
                                (LPTSTR) &lpMsgBuf,
                                0,
                                NULL
                        );
                        for (i=0;i<(int)strlen(lpMsgBuf);i++) {
                                if (lpMsgBuf[i] == 13 || lpMsgBuf[i] == 10) {
                                        lpMsgBuf[i] = ' ';
                                }
                        }
                        smprintf(s,"[System error     - %s, %i, \"%s\"]\n", description, (int)GetLastError(), (LPCTSTR)lpMsgBuf);
                        LocalFree(lpMsgBuf);
                }
        }
#else

        if (errno!=-1) {
                if (curdi->dl == DL_TEXTERROR ||
                                curdi->dl == DL_TEXT ||
                                curdi->dl == DL_TEXTALL ||
                                curdi->dl == DL_TEXTERRORDATE ||
                                curdi->dl == DL_TEXTDATE ||
                                curdi->dl == DL_TEXTALLDATE) {
                        smprintf(s,"[System error     - %s, %i, \"%s\"]\n",description,errno,strerror(errno));
                }
        }
#endif
}

GSM_ReadConfig()

GSM_Error GSM_ReadConfig	(	INI_Section *	cfg_info,
		GSM_Config *	cfg,
		int	num
	)

Processes gammu configuration.

Parameters

cfg_info	Ini file representation.
cfg	Where to store configuration.
num	Number of section to read.

Returns

Whether we got valid configuration. Especially check for ERR_USING_DEFAULTS.

See also

GSM_FallbackConfig

Definition at line 1350 of file gsmstate.c.

References GSM_Config::Connection, GSM_Config::DebugFile, GSM_Config::DebugLevel, DEFAULT_CONNECTION, DEFAULT_DEBUG_FILE, DEFAULT_DEBUG_LEVEL, DEFAULT_DEVICE, DEFAULT_LOCK_DEVICE, DEFAULT_MODEL, DEFAULT_START_INFO, DEFAULT_SYNCHRONIZE_TIME, GSM_Config::Device, ERR_NONE, ERR_NONE_SECTION, ERR_UNCONFIGURED, ERR_UNKNOWN, ERR_USING_DEFAULTS, FALSE, GSM_ExpandUserPath(), GSM_SetFeatureString(), INI_GetBool(), INI_GetValue(), GSM_Config::LockDevice, GSM_Config::Model, _INI_Section::Next, GSM_Config::PhoneFeatures, _INI_Section::SectionName, GSM_Config::StartInfo, GSM_Config::SyncTime, GSM_Config::TextBirthday, GSM_Config::TextCall, GSM_Config::TextMeeting, GSM_Config::TextMemo, GSM_Config::TextReminder, TRUE, and GSM_Config::UseGlobalDebugFile.

{
        INI_Section     *h;
        unsigned char   section[50]={0};
        gboolean        found = FALSE;
        char            *Temp = NULL;

        GSM_Error error = ERR_UNKNOWN;

        cfg->UseGlobalDebugFile  = TRUE;

        /* If we don't have valid config, bail out */
        if (cfg_info == NULL) {
                error = ERR_UNCONFIGURED;
                goto fail;
        }

        /* Which section should we read? */
        if (num == 0) {
                snprintf(section, sizeof(section) - 1, "gammu");
        } else {
                snprintf(section, sizeof(section) - 1, "gammu%i", num);
        }

        /* Scan for section */
        for (h = cfg_info; h != NULL; h = h->Next) {
                if (strcasecmp(section, h->SectionName) == 0) {
                        found = TRUE;
                        break;
                }
        }
        if (!found) {
                error = ERR_NONE_SECTION;
                goto fail;
        }

        /* Set device name */
        free(cfg->Device);
        cfg->Device      = INI_GetValue(cfg_info, section, "device",            FALSE);
        if (!cfg->Device) {
                cfg->Device      = INI_GetValue(cfg_info, section, "port",              FALSE);
                if (!cfg->Device) {
                        cfg->Device                      = strdup(DEFAULT_DEVICE);
                } else {
                        cfg->Device                      = strdup(cfg->Device);
                }
        } else {
                cfg->Device                      = strdup(cfg->Device);
        }

        /* Set connection type */
        free(cfg->Connection);
        cfg->Connection  = INI_GetValue(cfg_info, section, "connection",        FALSE);
        if (cfg->Connection == NULL) {
                cfg->Connection                  = strdup(DEFAULT_CONNECTION);
        } else {
                cfg->Connection                  = strdup(cfg->Connection);
        }

        /* Set time sync */
        cfg->SyncTime = INI_GetBool(cfg_info, section, "synchronizetime", DEFAULT_SYNCHRONIZE_TIME);

        /* Set debug file */
        free(cfg->DebugFile);
        cfg->DebugFile   = INI_GetValue(cfg_info, section, "logfile",           FALSE);
        if (cfg->DebugFile == NULL) {
                cfg->DebugFile                   = strdup(DEFAULT_DEBUG_FILE);
        } else {
                cfg->DebugFile                   = strdup(cfg->DebugFile);
                GSM_ExpandUserPath(&cfg->DebugFile);
        }

        /* Set file locking */
        cfg->LockDevice  = INI_GetBool(cfg_info, section, "use_locking", DEFAULT_LOCK_DEVICE);

        /* Set model */
        Temp             = INI_GetValue(cfg_info, section, "model",             FALSE);
        if (Temp == NULL || strcmp(Temp, "auto") == 0) {
                strcpy(cfg->Model,DEFAULT_MODEL);
        } else {
                if (strlen(Temp) >= sizeof(cfg->Model))
                        Temp[sizeof(cfg->Model) - 1] = '\0';
                strcpy(cfg->Model,Temp);
        }

        /* Set Log format */
        Temp             = INI_GetValue(cfg_info, section, "logformat",         FALSE);

        if (Temp == NULL) {
                strcpy(cfg->DebugLevel,DEFAULT_DEBUG_LEVEL);
        } else {
                if (strlen(Temp) >= sizeof(cfg->DebugLevel))
                        Temp[sizeof(cfg->DebugLevel) - 1] = '\0';
                strcpy(cfg->DebugLevel,Temp);
        }

        /* Set startup info */
        cfg->StartInfo = INI_GetBool(cfg_info, section, "startinfo", DEFAULT_START_INFO);

        /* Read localised strings for some phones */

        Temp             = INI_GetValue(cfg_info, section, "reminder",          FALSE);

        if (Temp == NULL) {
                strcpy(cfg->TextReminder,"Reminder");
        } else {
                if (strlen(Temp) >= sizeof(cfg->TextReminder))
                        Temp[sizeof(cfg->TextReminder) - 1] = '\0';
                strcpy(cfg->TextReminder,Temp);
        }

        Temp             = INI_GetValue(cfg_info, section, "meeting",           FALSE);

        if (Temp == NULL) {
                strcpy(cfg->TextMeeting,"Meeting");
        } else {
                if (strlen(Temp) >= sizeof(cfg->TextMeeting))
                        Temp[sizeof(cfg->TextMeeting) - 1] = '\0';
                strcpy(cfg->TextMeeting,Temp);
        }

        Temp             = INI_GetValue(cfg_info, section, "call",              FALSE);

        if (Temp == NULL) {
                strcpy(cfg->TextCall,"Call");
        } else {
                if (strlen(Temp) >= sizeof(cfg->TextCall))
                        Temp[sizeof(cfg->TextCall) - 1] = '\0';
                strcpy(cfg->TextCall,Temp);
        }

        Temp             = INI_GetValue(cfg_info, section, "birthday",          FALSE);

        if (Temp == NULL) {
                strcpy(cfg->TextBirthday,"Birthday");
        } else {
                if (strlen(Temp) >= sizeof(cfg->TextBirthday))
                        Temp[sizeof(cfg->TextBirthday) - 1] = '\0';
                strcpy(cfg->TextBirthday,Temp);
        }

        Temp             = INI_GetValue(cfg_info, section, "memo",              FALSE);

        if (Temp == NULL) {
                strcpy(cfg->TextMemo,"Memo");
        } else {
                if (strlen(Temp) >= sizeof(cfg->TextMemo))
                        Temp[sizeof(cfg->TextMemo) - 1] = '\0';
                strcpy(cfg->TextMemo,Temp);
        }

        /* Phone features */
        Temp             = INI_GetValue(cfg_info, section, "features",          FALSE);

        if (Temp == NULL) {
                cfg->PhoneFeatures[0] = 0;
        } else {
                error = GSM_SetFeatureString(cfg->PhoneFeatures, Temp);

                if (error != ERR_NONE) {
                        goto fail;
                }
        }
        return ERR_NONE;

fail:
        /* Special case, this config needs to be somehow valid */
        if (num == 0) {
                cfg->Device                      = strdup(DEFAULT_DEVICE);
                cfg->Connection                  = strdup(DEFAULT_CONNECTION);
                cfg->SyncTime                    = DEFAULT_SYNCHRONIZE_TIME;
                cfg->DebugFile                   = strdup(DEFAULT_DEBUG_FILE);
                cfg->LockDevice                  = DEFAULT_LOCK_DEVICE;
                strcpy(cfg->Model,DEFAULT_MODEL);
                strcpy(cfg->DebugLevel,DEFAULT_DEBUG_LEVEL);
                cfg->StartInfo                   = DEFAULT_START_INFO;
                strcpy(cfg->TextReminder,"Reminder");
                strcpy(cfg->TextMeeting,"Meeting");
                strcpy(cfg->TextCall,"Call");
                strcpy(cfg->TextBirthday,"Birthday");
                strcpy(cfg->TextMemo,"Memo");
                cfg->PhoneFeatures[0] = 0;
                /* Indicate that we used defaults */
                return ERR_USING_DEFAULTS;
        }
        return error;
}

GSM_ReadDevice()

int GSM_ReadDevice	(	GSM_StateMachine *	s,
		gboolean	waitforreply
	)

Attempts to read data from phone. This can be used for getting status of incoming events, which would not be found out without polling device.

Parameters

s	State machine data
waitforreply	Whether to wait for some event

Returns

Number of read bytes

Definition at line 919 of file gsmstate.c.

References _GSM_StateMachine::Abort, _GSM_StateMachine::Device, GSM_Device::Functions, GSM_Protocol::Functions, GSM_GetCurrentDateTime(), GSM_IsConnected(), _GSM_StateMachine::Protocol, GSM_Device_Functions::ReadDevice, GSM_DateTime::Second, and GSM_Protocol_Functions::StateMachine.

Referenced by GSM_WaitForOnce().

{
        GSM_DateTime    Date;
        unsigned char   buff[65536]={'\0'};
        int             res=0,count=0,i=0;

        if (!GSM_IsConnected(s)) {
                return -1;
        }

        GSM_GetCurrentDateTime (&Date);
        i = Date.Second;
        while (i == Date.Second && !s->Abort) {
                res = s->Device.Functions->ReadDevice(s, buff, sizeof(buff));

                if (!waitforreply) {
                        break;
                }
                if (res > 0) {
                        break;
                }
                usleep(5000);
                GSM_GetCurrentDateTime(&Date);
        }
        for (count = 0; count < res; count++) {
                s->Protocol.Functions->StateMachine(s, buff[count]);
        }
        return res;
}

GSM_RegisterAllPhoneModules()

GSM_Error GSM_RegisterAllPhoneModules

(

GSM_StateMachine *

s

)

Tries to register all modules to find one matching current configuration.

Parameters

s	State machine pointer.

Returns

Error code, ERR_NONE on success.

Definition at line 383 of file gsmstate.c.

References _GSM_StateMachine::ConnectionType, _GSM_StateMachine::CurrentConfig, GSM_Phone::Data, DUMMYPhone, ERR_NONE, ERR_UNKNOWNMODELSTRING, F_6230iCALLER, F_ALCATEL, F_FILES2, F_NOTES, F_OBEX, F_RADIO, F_SERIES40_30, F_SMS_FILES, F_TODO66, GSM_PhoneModel::features, GSM_Phone::Functions, GCT_AT, GCT_BLUEAT, GCT_BLUEFBUS2, GCT_BLUEGNAPBUS, GCT_BLUEOBEX, GCT_BLUEPHONET, GCT_BLUES60, GCT_DKU2AT, GCT_DKU2PHONET, GCT_DKU5FBUS2, GCT_FBUS2, GCT_FBUS2BLUE, GCT_FBUS2DLR3, GCT_FBUS2IRDA, GCT_FBUS2PL2303, GCT_FBUS2USB, GCT_IRDAAT, GCT_IRDAGNAPBUS, GCT_IRDAOBEX, GCT_IRDAPHONET, GCT_MBUS2, GCT_NONE, GCT_PHONETBLUE, GCT_PROXYAT, GCT_PROXYFBUS2, GCT_PROXYGNAPBUS, GCT_PROXYOBEX, GCT_PROXYPHONET, GCT_PROXYS60, GetModelData(), GSM_AddPhoneFeature(), GSM_IsPhoneFeatureAvailable(), GSM_RegisterModule(), GSM_Config::Model, GSM_Phone_Data::Model, GSM_PhoneModel::model, GSM_Phone_Functions::models, _GSM_StateMachine::Phone, and smprintf().

Referenced by GSM_InitConnection_Log().

{
        GSM_PhoneModel *model;

        /* Auto model */
        if (s->CurrentConfig->Model[0] == 0) {
                model = GetModelData(s, NULL, s->Phone.Data.Model, NULL);
#ifdef GSM_ENABLE_ATGEN
                /* With ATgen and auto model we can work with unknown models too */
                if (s->ConnectionType==GCT_AT || s->ConnectionType==GCT_PROXYAT || s->ConnectionType==GCT_IRDAAT || s->ConnectionType==GCT_DKU2AT) {
#ifdef GSM_ENABLE_ALCATEL
                        /* If phone provides Alcatel specific functions, enable them */
                        if (model->model[0] != 0 && GSM_IsPhoneFeatureAvailable(model, F_ALCATEL)) {
                                smprintf(s,"[Module           - \"%s\"]\n",ALCATELPhone.models);
                                s->Phone.Functions = &ALCATELPhone;
                                return ERR_NONE;
                        }
#endif
#ifdef GSM_ENABLE_ATOBEX
                        /* If phone provides Sony-Ericsson specific functions, enable them */
                        if (model->model[0] != 0 && GSM_IsPhoneFeatureAvailable(model, F_OBEX)) {
                                smprintf(s,"[Module           - \"%s\"]\n",ATOBEXPhone.models);
                                s->Phone.Functions = &ATOBEXPhone;
                                return ERR_NONE;
                        }
#endif
                        smprintf(s,"[Module           - \"%s\"]\n",ATGENPhone.models);
                        s->Phone.Functions = &ATGENPhone;
                        return ERR_NONE;
                }
#endif
                /* With OBEXgen and auto model we can work with unknown models too */
#ifdef GSM_ENABLE_OBEXGEN
                if (s->ConnectionType==GCT_BLUEOBEX || s->ConnectionType==GCT_PROXYOBEX || s->ConnectionType==GCT_IRDAOBEX) {
                        smprintf(s,"[Module           - \"%s\"]\n",OBEXGENPhone.models);
                        s->Phone.Functions = &OBEXGENPhone;
                        return ERR_NONE;
                }
#endif

#ifdef GSM_ENABLE_BACKUP
                if (s->ConnectionType == GCT_NONE) {
                        smprintf(s,"[Module           - \"%s\"]\n",DUMMYPhone.models);
                        s->Phone.Functions = &DUMMYPhone;
                        return ERR_NONE;
                }
#endif

                /* With GNAPgen and auto model we can work with unknown models too */
#ifdef GSM_ENABLE_GNAPGEN
                if (s->ConnectionType == GCT_BLUEGNAPBUS || s->ConnectionType == GCT_PROXYGNAPBUS || s->ConnectionType == GCT_IRDAGNAPBUS) {
                        smprintf(s,"[Module           - \"%s\"]\n",GNAPGENPhone.models);
                        s->Phone.Functions = &GNAPGENPhone;
                        return ERR_NONE;
                }
#endif
#ifdef GSM_ENABLE_S60
                if (s->ConnectionType == GCT_BLUES60 || s->ConnectionType == GCT_PROXYS60) {
                        smprintf(s,"[Module           - \"%s\"]\n",S60Phone.models);
                        s->Phone.Functions = &S60Phone;
                        return ERR_NONE;
                }
#endif

#ifdef GSM_ENABLE_NOKIA6510
                if ( s->ConnectionType ==  GCT_MBUS2 ||
                                s->ConnectionType ==  GCT_FBUS2 ||
                                s->ConnectionType ==  GCT_FBUS2USB ||
                                s->ConnectionType ==  GCT_FBUS2DLR3 ||
                                s->ConnectionType ==  GCT_FBUS2PL2303 ||
                                s->ConnectionType ==  GCT_FBUS2BLUE ||
                                s->ConnectionType ==  GCT_FBUS2IRDA ||
                                s->ConnectionType ==  GCT_DKU5FBUS2 ||
                                s->ConnectionType ==  GCT_DKU2PHONET ||
                                s->ConnectionType ==  GCT_PHONETBLUE ||
                                s->ConnectionType ==  GCT_IRDAPHONET ||
                                s->ConnectionType ==  GCT_BLUEFBUS2 ||
                                s->ConnectionType ==  GCT_PROXYFBUS2 ||
                                s->ConnectionType ==  GCT_PROXYPHONET ||
                                s->ConnectionType ==  GCT_BLUEPHONET) {
                        /* Try to detect phone type */
                        if (strcmp(model->model, "unknown") == 0 && model->features[0] == 0) {
                                smprintf(s, "WARNING: phone not known, please report it to authors (see <https://wammu.eu/support/bugs/>). Thank you.\n");
                                if (strncmp(s->Phone.Data.Model, "RM-", 3) == 0) {
                                        /* 167 is really a wild guess */
                                        if (atoi(s->Phone.Data.Model + 3) > 167) {
                                                smprintf(s, "WARNING: Guessed phone as S40/30 compatible (RM series)!\n");
                                                GSM_AddPhoneFeature(model, F_SERIES40_30);
                                                GSM_AddPhoneFeature(model, F_FILES2);
                                                GSM_AddPhoneFeature(model, F_TODO66);
                                                GSM_AddPhoneFeature(model, F_RADIO);
                                                GSM_AddPhoneFeature(model, F_NOTES);
                                                GSM_AddPhoneFeature(model, F_SMS_FILES);
                                                GSM_AddPhoneFeature(model, F_6230iCALLER);
                                        }
                                }
                                if (strncmp(s->Phone.Data.Model, "RH-", 3) == 0) {
                                        /* 63 is really a wild guess */
                                        if (atoi(s->Phone.Data.Model + 3) > 63) {
                                                smprintf(s, "WARNING: Guessed phone as S40/30 compatible (RH series)!\n");
                                                GSM_AddPhoneFeature(model, F_SERIES40_30);
                                                GSM_AddPhoneFeature(model, F_FILES2);
                                                GSM_AddPhoneFeature(model, F_TODO66);
                                                GSM_AddPhoneFeature(model, F_RADIO);
                                                GSM_AddPhoneFeature(model, F_NOTES);
                                                GSM_AddPhoneFeature(model, F_SMS_FILES);
                                        }
                                }
                        }

                        /* If phone is S40, use 6510 */
                        if (GSM_IsPhoneFeatureAvailable(model, F_SERIES40_30)) {
                                smprintf(s,"[Module           - \"%s\"]\n", N6510Phone.models);
                                s->Phone.Functions = &N6510Phone;
                                return ERR_NONE;
                        }
                }
#endif
                if (model->model[0] == 0) return ERR_UNKNOWNMODELSTRING;
        }
        s->Phone.Functions = NULL;
#ifdef GSM_ENABLE_ATGEN
        /* AT module can have the same models ID to "normal" Nokia modules */
        if (s->ConnectionType==GCT_AT || s->ConnectionType==GCT_PROXYAT || s->ConnectionType==GCT_BLUEAT || s->ConnectionType==GCT_IRDAAT || s->ConnectionType==GCT_DKU2AT) {
                GSM_RegisterModule(s,&ATGENPhone);
                if (s->Phone.Functions != NULL) return ERR_NONE;
        }
#endif
#ifdef GSM_ENABLE_BACKUP
        GSM_RegisterModule(s, &DUMMYPhone);
#endif
#ifdef GSM_ENABLE_OBEXGEN
        GSM_RegisterModule(s,&OBEXGENPhone);
#endif
#ifdef GSM_ENABLE_GNAPGEN
        GSM_RegisterModule(s,&GNAPGENPhone);
#endif
#ifdef GSM_ENABLE_S60
        GSM_RegisterModule(s,&S60Phone);
#endif
#ifdef GSM_ENABLE_NOKIA3320
        GSM_RegisterModule(s,&N3320Phone);
#endif
#ifdef GSM_ENABLE_NOKIA3650
        GSM_RegisterModule(s,&N3650Phone);
#endif
#ifdef GSM_ENABLE_NOKIA650
        GSM_RegisterModule(s,&N650Phone);
#endif
#ifdef GSM_ENABLE_NOKIA6110
        GSM_RegisterModule(s,&N6110Phone);
#endif
#ifdef GSM_ENABLE_NOKIA6510
        GSM_RegisterModule(s,&N6510Phone);
#endif
#ifdef GSM_ENABLE_NOKIA7110
        GSM_RegisterModule(s,&N7110Phone);
#endif
#ifdef GSM_ENABLE_NOKIA9210
        GSM_RegisterModule(s,&N9210Phone);
#endif
#ifdef GSM_ENABLE_ALCATEL
        GSM_RegisterModule(s,&ALCATELPhone);
#endif
#ifdef GSM_ENABLE_ATOBEX
        GSM_RegisterModule(s,&ATOBEXPhone);
#endif
        if (s->Phone.Functions == NULL) {
                return ERR_UNKNOWNMODELSTRING;
        }
        return ERR_NONE;
}

GSM_SetConfigNum()

void GSM_SetConfigNum	(	GSM_StateMachine *	s,
		int	sections
	)

Gets number of active gammu configurations.

Parameters

s	State machine data
sections	Number of sections.

Definition at line 1317 of file gsmstate.c.

References _GSM_StateMachine::ConfigNum, and MAX_CONFIG_NUM.

{
        if (sections > MAX_CONFIG_NUM) return;
        s->ConfigNum = sections;
}

GSM_TerminateConnection()

GSM_Error GSM_TerminateConnection

(

GSM_StateMachine *

s

)

Terminates connection.

Parameters

s	State machine data

Returns

Error code

Definition at line 949 of file gsmstate.c.

References _GSM_StateMachine::CurrentConfig, GSM_Phone::Data, _GSM_StateMachine::di, ERR_NONE, FALSE, GSM_Phone::Functions, GSM_CloseConnection(), GSM_SetDebugFileDescriptor(), _GSM_StateMachine::opened, _GSM_StateMachine::Phone, GSM_Phone_Functions::ShowStartInfo, smprintf(), GSM_Config::StartInfo, GSM_Phone_Data::StartInfoCounter, and GSM_Phone_Functions::Terminate.

{
        GSM_Error error;

        if (!s->opened) return ERR_NONE;

        smprintf(s,"[Terminating]\n");

        if (s->CurrentConfig->StartInfo) {
                if (s->Phone.Data.StartInfoCounter > 0) s->Phone.Functions->ShowStartInfo(s,FALSE);
        }

        if (s->Phone.Functions != NULL) {
                error=s->Phone.Functions->Terminate(s);
                if (error!=ERR_NONE) return error;
        }

        error = GSM_CloseConnection(s);
        if (error != ERR_NONE) return error;

        GSM_SetDebugFileDescriptor(NULL, FALSE, &(s->di));

        s->opened = FALSE;

        return ERR_NONE;
}

GSM_WaitFor()

GSM_Error GSM_WaitFor	(	GSM_StateMachine *	s,
		unsigned const char *	buffer,
		size_t	length,
		int	type,
		int	timeout,
		GSM_Phone_RequestID	request
	)

Wait for reply from the phone.

Parameters

s	State machine pointer.
buffer	Data to write to phone.
length	Length of data in buffer.
type	Type of request (for protocols where it makes sense).
timeout	How long to wait for reply.
request	ID of request

Returns

Error code, ERR_NONE on sucecss.

Definition at line 1029 of file gsmstate.c.

References _GSM_StateMachine::CurrentConfig, D_ERROR, GSM_Phone::Data, GSM_Phone_Data::DispatchError, ERR_NONE, ERR_TIMEOUT, F_RESET_AFTER_TIMEOUT, FALSE, GSM_Protocol::Functions, GSM_Phone::Functions, GSM_IsPhoneFeatureAvailable(), GSM_Reset(), GSM_WaitForOnce(), ID_None, ID_Reset, GSM_Phone_Data::ModelInfo, _GSM_StateMachine::Phone, _GSM_StateMachine::Protocol, _GSM_StateMachine::ReplyNum, GSM_Phone_Data::RequestID, GSM_Phone_Functions::ShowStartInfo, smprintf_level(), GSM_Config::StartInfo, GSM_Phone_Data::StartInfoCounter, and GSM_Protocol_Functions::WriteMessage.

Referenced by NOKIA_EncodeDateTime().

{
        GSM_Phone_Data          *Phone = &s->Phone.Data;
        GSM_Error               error;
        int                     reply;

        if (s->CurrentConfig->StartInfo) {
                if (Phone->StartInfoCounter > 0) {
                        Phone->StartInfoCounter--;
                        if (Phone->StartInfoCounter == 0) {
                                s->Phone.Functions->ShowStartInfo(s,FALSE);
                        }
                }
        }

        Phone->RequestID        = request;
        Phone->DispatchError    = ERR_TIMEOUT;

        for (reply = 0; reply < s->ReplyNum; reply++) {
                if (reply != 0) {
                        smprintf_level(s, D_ERROR, "[Retrying %i type 0x%02X]\n", reply, type);
                }
                error = s->Protocol.Functions->WriteMessage(s, buffer, length, type);
                if (error != ERR_NONE) {
                        return error;
                }

                /* Special case when no reply is expected */
                if (request == ID_None) {
                        return ERR_NONE;
                }

                error = GSM_WaitForOnce(s, buffer, length, type, timeout);
                if (error != ERR_TIMEOUT) {
                        return error;
                }
        }

        if (request != ID_Reset && GSM_IsPhoneFeatureAvailable(s->Phone.Data.ModelInfo, F_RESET_AFTER_TIMEOUT)) {
                smprintf_level(s, D_ERROR, "Performing device reset after timeout!\n");
                GSM_Reset(s, FALSE);
        }

        return ERR_TIMEOUT;
}

GSM_WaitForOnce()

GSM_Error GSM_WaitForOnce	(	GSM_StateMachine *	s,
		unsigned const char *	buffer,
		size_t	length,
		int	type,
		int	timeout
	)

Definition at line 986 of file gsmstate.c.

References _GSM_StateMachine::Abort, GSM_Protocol_Message::Buffer, GSM_Phone::Data, GSM_Phone_Data::DispatchError, ERR_ABORTED, ERR_TIMEOUT, GSM_ReadDevice(), ID_None, GSM_Protocol_Message::Length, _GSM_StateMachine::Phone, GSM_Phone_Data::RequestID, GSM_Phone_Data::SentMsg, TRUE, and GSM_Protocol_Message::Type.

Referenced by GSM_WaitFor().

{
        GSM_Phone_Data *Phone = &s->Phone.Data;
        GSM_Protocol_Message sentmsg;
        int i = 0;

        do {
                if (length != 0) {
                        sentmsg.Length  = length;
                        sentmsg.Type    = type;
                        sentmsg.Buffer  = (unsigned char *)malloc(length);
                        memcpy(sentmsg.Buffer, buffer, length);
                        Phone->SentMsg  = &sentmsg;
                }

                /* Some data received. Reset timer */
                if (GSM_ReadDevice(s, TRUE) > 0) {
                        i = 0;
                } else {
                        usleep(10000);
                }

                if (length != 0) {
                        free(sentmsg.Buffer);
                        sentmsg.Buffer = NULL;
                        Phone->SentMsg = NULL;
                }

                if (s->Abort) {
                        return ERR_ABORTED;
                }

                /* Request completed */
                if (Phone->RequestID == ID_None) {
                        return Phone->DispatchError;
                }
                i++;
        } while (i < timeout);

        return ERR_TIMEOUT;
}

Variable Documentation

DUMMYPhone

GSM_Phone_Functions DUMMYPhone

Definition at line 1964 of file dummy.c.

Referenced by GSM_RegisterAllPhoneModules(), and GSM_TryGetModel().

NAUTOPhone

GSM_Phone_Functions NAUTOPhone

Referenced by GSM_TryGetModel().

ProxyDevice

GSM_Device_Functions ProxyDevice

Proxy device functions.

Definition at line 212 of file proxy.c.

Referenced by GSM_RegisterAllConnections().