chan_mobile.c File Reference

Bluetooth Mobile Device channel driver. More...

#include "asterisk.h"
#include <pthread.h>
#include <signal.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>
#include <bluetooth/sdp.h>
#include <bluetooth/sdp_lib.h>
#include <bluetooth/rfcomm.h>
#include <bluetooth/sco.h>
#include <bluetooth/l2cap.h>
#include "asterisk/compat.h"
#include "asterisk/lock.h"
#include "asterisk/callerid.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/utils.h"
#include "asterisk/linkedlists.h"
#include "asterisk/cli.h"
#include "asterisk/devicestate.h"
#include "asterisk/causes.h"
#include "asterisk/dsp.h"
#include "asterisk/app.h"
#include "asterisk/manager.h"
#include "asterisk/io.h"
#include "asterisk/smoother.h"
#include "asterisk/format_cache.h"

Include dependency graph for chan_mobile.c:

Go to the source code of this file.

Data Structures
struct	adapter_pvt
struct	adapters
struct	cidinfo
struct	devices
struct	hfp_ag
	This struct holds HFP features the AG supports. More...
struct	hfp_cind
	This struct holds mappings for indications. More...
struct	hfp_hf
	This struct holds HFP features that we support. More...
struct	hfp_pvt
	This struct holds state information about the current hfp connection. More...
struct	mbl_pvt
struct	mbl_pvt::msg_queue
struct	msg_queue_entry

Macros
#define	CHANNEL_FRAME_SIZE   320
#define	DEVICE_FRAME_FORMAT   ast_format_slin
#define	DEVICE_FRAME_SIZE   48
#define	FORMAT1   "%-15.15s %-17.17s %-5.5s %-15.15s %-9.9s %-10.10s %-3.3s\n"
#define	FORMAT1   "%-17.17s %-30.30s %-6.6s %-7.7s %-4.4s\n"
#define	FORMAT2   "%-17.17s %-30.30s %-6.6s %-7.7s %d\n"
#define	HFP_AG_CONTROL   (1 << 7)
#define	HFP_AG_CW   (1 << 0)
#define	HFP_AG_ECNR   (1 << 1)
#define	HFP_AG_ERRORS   (1 << 8)
#define	HFP_AG_REJECT   (1 << 5)
#define	HFP_AG_RING   (1 << 3)
#define	HFP_AG_STATUS   (1 << 6)
#define	HFP_AG_TAG   (1 << 4)
#define	HFP_AG_VOICE   (1 << 2)
#define	HFP_CIND_BATTCHG   7
#define	HFP_CIND_CALL   2
#define	HFP_CIND_CALL_ACTIVE   1
#define	HFP_CIND_CALL_NONE   0
#define	HFP_CIND_CALLHELD   4
#define	HFP_CIND_CALLSETUP   3
#define	HFP_CIND_CALLSETUP_ALERTING   3
#define	HFP_CIND_CALLSETUP_INCOMING   1
#define	HFP_CIND_CALLSETUP_NONE   0
#define	HFP_CIND_CALLSETUP_OUTGOING   2
#define	HFP_CIND_NONE   0
#define	HFP_CIND_ROAM   6
#define	HFP_CIND_SERVICE   1
#define	HFP_CIND_SERVICE_AVAILABLE   1
#define	HFP_CIND_SERVICE_NONE   0
#define	HFP_CIND_SIGNAL   5
#define	HFP_CIND_UNKNOWN   -1
#define	HFP_HF_CID   (1 << 2)
#define	HFP_HF_CONTROL   (1 << 6)
#define	HFP_HF_CW   (1 << 1)
#define	HFP_HF_ECNR   (1 << 0)
#define	HFP_HF_STATUS   (1 << 5)
#define	HFP_HF_VOICE   (1 << 3)
#define	HFP_HF_VOLUME   (1 << 4)
#define	MBL_CONFIG   "chan_mobile.conf"
#define	MBL_CONFIG_OLD   "mobile.conf"
#define	rfcomm_read_debug(c)

Enumerations
enum	at_message_t {   AT_PARSE_ERROR = -2 , AT_READ_ERROR = -1 , AT_UNKNOWN = 0 , AT_OK ,   AT_ERROR , AT_RING , AT_BRSF , AT_CIND ,   AT_CIEV , AT_CLIP , AT_CMTI , AT_CMGR ,   AT_SMS_PROMPT , AT_CMS_ERROR , AT_A , AT_D ,   AT_CHUP , AT_CKPD , AT_CMGS , AT_VGM ,   AT_VGS , AT_VTS , AT_CMGF , AT_CNMI ,   AT_CMER , AT_CIND_TEST , AT_CUSD , AT_BUSY ,   AT_NO_DIALTONE , AT_NO_CARRIER , AT_ECAM }
enum	mbl_type { MBL_TYPE_PHONE , MBL_TYPE_HEADSET }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	at_match_prefix (char *buf, char *prefix)
	Match the given buffer with the given prefix. More...
static const char *	at_msg2str (at_message_t msg)
	Get the string representation of the given AT message. More...
static at_message_t	at_read_full (int rsock, char *buf, size_t count)
	Read an AT message and classify it. More...
static int	check_unloading ()
	Check if the module is unloading. More...
static void	do_alignment_detection (struct mbl_pvt *pvt, char *buf, int buflen)
static void *	do_discovery (void *data)
static void *	do_monitor_headset (void *data)
static void *	do_monitor_phone (void *data)
static void *	do_sco_listen (void *data)
	Service new and existing SCO connections. This thread accepts new sco connections and handles audio data. There is one do_sco_listen thread for each adapter. More...
static char *	handle_cli_mobile_cusd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_mobile_rfcomm (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_mobile_search (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_mobile_show_devices (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	handle_response_brsf (struct mbl_pvt *pvt, char *buf)
	Handle the BRSF response. More...
static int	handle_response_busy (struct mbl_pvt *pvt)
	Handle BUSY messages. More...
static int	handle_response_ciev (struct mbl_pvt *pvt, char *buf)
	Handle AT+CIEV messages. More...
static int	handle_response_cind (struct mbl_pvt *pvt, char *buf)
	Handle the CIND response. More...
static int	handle_response_clip (struct mbl_pvt *pvt, char *buf)
	Handle AT+CLIP messages. More...
static int	handle_response_cmgr (struct mbl_pvt *pvt, char *buf)
	Handle AT+CMGR messages. More...
static int	handle_response_cmti (struct mbl_pvt *pvt, char *buf)
	Handle AT+CMTI messages. More...
static int	handle_response_cusd (struct mbl_pvt *pvt, char *buf)
	Handle CUSD messages. More...
static int	handle_response_error (struct mbl_pvt *pvt, char *buf)
	Handle ERROR AT messages. More...
static int	handle_response_no_carrier (struct mbl_pvt *pvt, char *buf)
	Handle NO CARRIER messages. More...
static int	handle_response_no_dialtone (struct mbl_pvt *pvt, char *buf)
	Handle NO DIALTONE messages. More...
static int	handle_response_ok (struct mbl_pvt *pvt, char *buf)
	Handle OK AT messages. More...
static int	handle_response_ring (struct mbl_pvt *pvt, char *buf)
	Handle RING messages. More...
static int	handle_sms_prompt (struct mbl_pvt *pvt, char *buf)
	Send an SMS message from the queue. More...
static int	headset_send_ring (const void *data)
static int	hfp_brsf2int (struct hfp_hf *hf)
	Convert a hfp_hf struct to a BRSF int. More...
static struct hfp_ag *	hfp_int2brsf (int brsf, struct hfp_ag *ag)
	Convert a BRSF int to an hfp_ag struct. More...
static int	hfp_parse_brsf (struct hfp_pvt *hfp, const char *buf)
	Parse BRSF data. More...
static int	hfp_parse_ciev (struct hfp_pvt *hfp, char *buf, int *value)
	Parse a CIEV event. More...
static int	hfp_parse_cind (struct hfp_pvt *hfp, char *buf)
	Read the result of the AT+CIND? command. More...
static int	hfp_parse_cind_indicator (struct hfp_pvt *hfp, int group, char *indicator)
	Parse and store the given indicator. More...
static int	hfp_parse_cind_test (struct hfp_pvt *hfp, char *buf)
	Parse the result of the AT+CIND=? command. More...
static struct cidinfo	hfp_parse_clip (struct hfp_pvt *hfp, char *buf)
	Parse a CLIP event. More...
static int	hfp_parse_cmgr (struct hfp_pvt *hfp, char *buf, char **from_number, char **text)
	Parse a CMGR message. More...
static int	hfp_parse_cmti (struct hfp_pvt *hfp, char *buf)
	Parse a CMTI notification. More...
static char *	hfp_parse_cusd (struct hfp_pvt *hfp, char *buf)
	Parse a CUSD answer. More...
static int	hfp_parse_ecav (struct hfp_pvt *hfp, char *buf)
	Parse a ECAV event. More...
static int	hfp_send_ata (struct hfp_pvt *hfp)
	Send ATA. More...
static int	hfp_send_atd (struct hfp_pvt *hfp, const char *number)
	Send ATD. More...
static int	hfp_send_brsf (struct hfp_pvt *hfp, struct hfp_hf *brsf)
	Send a BRSF request. More...
static int	hfp_send_chup (struct hfp_pvt *hfp)
	Send AT+CHUP. More...
static int	hfp_send_cind (struct hfp_pvt *hfp)
	Send the CIND read command. More...
static int	hfp_send_cind_test (struct hfp_pvt *hfp)
	Send the CIND test command. More...
static int	hfp_send_clip (struct hfp_pvt *hfp, int status)
	Enable or disable calling line identification. More...
static int	hfp_send_cmer (struct hfp_pvt *hfp, int status)
	Enable or disable indicator events reporting. More...
static int	hfp_send_cmgf (struct hfp_pvt *hfp, int mode)
	Set the SMS mode. More...
static int	hfp_send_cmgr (struct hfp_pvt *hfp, int index)
	Read an SMS message. More...
static int	hfp_send_cmgs (struct hfp_pvt *hfp, const char *number)
	Start sending an SMS message. More...
static int	hfp_send_cnmi (struct hfp_pvt *hfp)
	Setup SMS new message indication. More...
static int	hfp_send_cusd (struct hfp_pvt *hfp, const char *code)
	Send CUSD. More...
static int	hfp_send_dtmf (struct hfp_pvt *hfp, char digit)
	Send a DTMF command. More...
static int	hfp_send_ecam (struct hfp_pvt *hfp)
	Enable Sony Ericsson extensions / indications. More...
static int	hfp_send_sms_text (struct hfp_pvt *hfp, const char *message)
	Send the text of an SMS message. More...
static int	hfp_send_vgs (struct hfp_pvt *hfp, int value)
	Send the current speaker gain level. More...
static int	hsp_send_error (int rsock)
	Send an ERROR AT response. More...
static int	hsp_send_ok (int rsock)
	Send an OK AT response. More...
static int	hsp_send_ring (int rsock)
	Send a RING unsolicited AT response. More...
static int	hsp_send_vgm (int rsock, int gain)
	Send a microphone gain unsolicited AT response. More...
static int	hsp_send_vgs (int rsock, int gain)
	Send a speaker gain unsolicited AT response. More...
static int	load_module (void)
static int	mbl_answer (struct ast_channel *ast)
static int	mbl_ast_hangup (struct mbl_pvt *pvt)
static int	mbl_call (struct ast_channel *ast, const char *dest, int timeout)
static int	mbl_devicestate (const char *data)
static int	mbl_digit_end (struct ast_channel *ast, char digit, unsigned int duration)
static int	mbl_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
static int	mbl_hangup (struct ast_channel *ast)
static int	mbl_has_service (struct mbl_pvt *pvt)
	Check if a mobile device has service. More...
static struct adapter_pvt *	mbl_load_adapter (struct ast_config *cfg, const char *cat)
	Load an adapter from the configuration file. More...
static int	mbl_load_config (void)
static struct mbl_pvt *	mbl_load_device (struct ast_config *cfg, const char *cat)
	Load a device from the configuration file. More...
static struct ast_channel *	mbl_new (int state, struct mbl_pvt *pvt, struct cidinfo *cidinfo, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor)
static int	mbl_queue_control (struct mbl_pvt *pvt, enum ast_control_frame_type control)
static int	mbl_queue_hangup (struct mbl_pvt *pvt)
static struct ast_frame *	mbl_read (struct ast_channel *ast)
static struct ast_channel *	mbl_request (const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
static int	mbl_sendsms_exec (struct ast_channel *ast, const char *data)
static int	mbl_status_exec (struct ast_channel *ast, const char *data)
static int	mbl_write (struct ast_channel *ast, struct ast_frame *frame)
static void	msg_queue_flush (struct mbl_pvt *pvt)
	Remove all items from the queue and free them. More...
static void	msg_queue_free_and_pop (struct mbl_pvt *pvt)
	Remove an item from the front of the queue, and free it. More...
static struct msg_queue_entry *	msg_queue_head (struct mbl_pvt *pvt)
	Get the head of a queue. More...
static struct msg_queue_entry *	msg_queue_pop (struct mbl_pvt *pvt)
	Remove an item from the front of the queue. More...
static int	msg_queue_push (struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to)
	Add an item to the back of the queue. More...
static int	msg_queue_push_data (struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to, void *data)
	Add an item to the back of the queue with data. More...
static int	parse_next_token (char string[], const int start, const char delim)
	Terminate current token and return an index to start of the next token. More...
static void	rfcomm_append_buf (char **buf, size_t count, size_t *in_count, char c)
	Append the given character to the given buffer and increase the in_count. More...
static int	rfcomm_connect (bdaddr_t src, bdaddr_t dst, int remote_channel)
static ssize_t	rfcomm_read (int rsock, char *buf, size_t count)
	Read one Hayes AT message from an rfcomm socket. More...
static int	rfcomm_read_and_append_char (int rsock, char **buf, size_t count, size_t *in_count, char *result, char expected)
	Read a character from the given stream and append it to the given buffer if it matches the expected character. More...
static int	rfcomm_read_and_expect_char (int rsock, char *result, char expected)
	Read a character from the given stream and check if it matches what we expected. More...
static int	rfcomm_read_cmgr (int rsock, char **buf, size_t count, size_t *in_count)
	Read the remainder of a +CMGR message. More...
static int	rfcomm_read_command (int rsock, char **buf, size_t count, size_t *in_count)
	Read the remainder of an AT command. More...
static int	rfcomm_read_result (int rsock, char **buf, size_t count, size_t *in_count)
	Read and AT result code. More...
static int	rfcomm_read_sms_prompt (int rsock, char **buf, size_t count, size_t *in_count)
	Read the remainder of an AT SMS prompt. More...
static int	rfcomm_read_until_crlf (int rsock, char **buf, size_t count, size_t *in_count)
	Read until. More...
static int	rfcomm_read_until_ok (int rsock, char **buf, size_t count, size_t *in_count)
	Read until a. More...
static int	rfcomm_wait (int rsock, int *ms)
	Wait for activity on an rfcomm socket. More...
static int	rfcomm_write (int rsock, char *buf)
	Write to an rfcomm socket. More...
static int	rfcomm_write_full (int rsock, char *buf, size_t count)
	Write to an rfcomm socket. More...
static int	sco_accept (int *id, int fd, short events, void *data)
	Accept SCO connections. This function is an ast_io callback function used to accept incoming sco audio connections. More...
static int	sco_bind (struct adapter_pvt *adapter)
	Bind an SCO listener socket for the given adapter. More...
static int	sco_connect (bdaddr_t src, bdaddr_t dst)
static int	sco_write (int s, char *buf, int len)
static sdp_session_t *	sdp_register (void)
static int	sdp_search (char *addr, int profile)
static void	set_unloading ()
	Set the unloading flag. More...
static int	start_monitor (struct mbl_pvt *pvt)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Bluetooth Mobile Device Channel Driver" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DRIVER, }
static struct adapters	adapters = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static char *	app_mblsendsms = "MobileSendSMS"
static char *	app_mblstatus = "MobileStatus"
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct devices	devices = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static int	discovery_interval = 60
static pthread_t	discovery_thread = AST_PTHREADT_NULL
static struct hfp_hf	hfp_our_brsf
static struct ast_cli_entry	mbl_cli []
static struct ast_channel_tech	mbl_tech
static char *	mblsendsms_desc
static char *	mblsendsms_synopsis = "MobileSendSMS(Device,Dest,Message)"
static char *	mblstatus_desc
static char *	mblstatus_synopsis = "MobileStatus(Device,Variable)"
static sdp_session_t *	sdp_session
static ast_mutex_t	unload_mutex = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
static int	unloading_flag = 0

Detailed Description

Bluetooth Mobile Device channel driver.

Author

Dave Bowerman david.nosp@m..bow.nosp@m.erman.nosp@m.@gma.nosp@m.il.co.nosp@m.m

Definition in file chan_mobile.c.

Macro Definition Documentation

CHANNEL_FRAME_SIZE

#define CHANNEL_FRAME_SIZE   320

Definition at line 83 of file chan_mobile.c.

DEVICE_FRAME_FORMAT

#define DEVICE_FRAME_FORMAT   ast_format_slin

Definition at line 82 of file chan_mobile.c.

DEVICE_FRAME_SIZE

#define DEVICE_FRAME_SIZE   48

Definition at line 81 of file chan_mobile.c.

FORMAT1 [1/2]

#define FORMAT1   "%-15.15s %-17.17s %-5.5s %-15.15s %-9.9s %-10.10s %-3.3s\n"

FORMAT1 [2/2]

#define FORMAT1   "%-17.17s %-30.30s %-6.6s %-7.7s %-4.4s\n"

FORMAT2

#define FORMAT2   "%-17.17s %-30.30s %-6.6s %-7.7s %d\n"

HFP_AG_CONTROL

#define HFP_AG_CONTROL   (1 << 7)

Definition at line 272 of file chan_mobile.c.

HFP_AG_CW

#define HFP_AG_CW   (1 << 0)

Definition at line 265 of file chan_mobile.c.

HFP_AG_ECNR

#define HFP_AG_ECNR   (1 << 1)

Definition at line 266 of file chan_mobile.c.

HFP_AG_ERRORS

#define HFP_AG_ERRORS   (1 << 8)

Definition at line 273 of file chan_mobile.c.

HFP_AG_REJECT

#define HFP_AG_REJECT   (1 << 5)

Definition at line 270 of file chan_mobile.c.

HFP_AG_RING

#define HFP_AG_RING   (1 << 3)

Definition at line 268 of file chan_mobile.c.

HFP_AG_STATUS

#define HFP_AG_STATUS   (1 << 6)

Definition at line 271 of file chan_mobile.c.

HFP_AG_TAG

#define HFP_AG_TAG   (1 << 4)

Definition at line 269 of file chan_mobile.c.

HFP_AG_VOICE

#define HFP_AG_VOICE   (1 << 2)

Definition at line 267 of file chan_mobile.c.

HFP_CIND_BATTCHG

#define HFP_CIND_BATTCHG   7

Definition at line 283 of file chan_mobile.c.

HFP_CIND_CALL

#define HFP_CIND_CALL   2

Definition at line 278 of file chan_mobile.c.

HFP_CIND_CALL_ACTIVE

#define HFP_CIND_CALL_ACTIVE   1

Definition at line 287 of file chan_mobile.c.

HFP_CIND_CALL_NONE

#define HFP_CIND_CALL_NONE   0

Definition at line 286 of file chan_mobile.c.

HFP_CIND_CALLHELD

#define HFP_CIND_CALLHELD   4

Definition at line 280 of file chan_mobile.c.

HFP_CIND_CALLSETUP

#define HFP_CIND_CALLSETUP   3

Definition at line 279 of file chan_mobile.c.

HFP_CIND_CALLSETUP_ALERTING

#define HFP_CIND_CALLSETUP_ALERTING   3

Definition at line 293 of file chan_mobile.c.

HFP_CIND_CALLSETUP_INCOMING

#define HFP_CIND_CALLSETUP_INCOMING   1

Definition at line 291 of file chan_mobile.c.

HFP_CIND_CALLSETUP_NONE

#define HFP_CIND_CALLSETUP_NONE   0

Definition at line 290 of file chan_mobile.c.

HFP_CIND_CALLSETUP_OUTGOING

#define HFP_CIND_CALLSETUP_OUTGOING   2

Definition at line 292 of file chan_mobile.c.

HFP_CIND_NONE

#define HFP_CIND_NONE   0

Definition at line 276 of file chan_mobile.c.

HFP_CIND_ROAM

#define HFP_CIND_ROAM   6

Definition at line 282 of file chan_mobile.c.

HFP_CIND_SERVICE

#define HFP_CIND_SERVICE   1

Definition at line 277 of file chan_mobile.c.

HFP_CIND_SERVICE_AVAILABLE

#define HFP_CIND_SERVICE_AVAILABLE   1

Definition at line 297 of file chan_mobile.c.

HFP_CIND_SERVICE_NONE

#define HFP_CIND_SERVICE_NONE   0

Definition at line 296 of file chan_mobile.c.

HFP_CIND_SIGNAL

#define HFP_CIND_SIGNAL   5

Definition at line 281 of file chan_mobile.c.

HFP_CIND_UNKNOWN

#define HFP_CIND_UNKNOWN   -1

Definition at line 275 of file chan_mobile.c.

HFP_HF_CID

#define HFP_HF_CID   (1 << 2)

Definition at line 259 of file chan_mobile.c.

HFP_HF_CONTROL

#define HFP_HF_CONTROL   (1 << 6)

Definition at line 263 of file chan_mobile.c.

HFP_HF_CW

#define HFP_HF_CW   (1 << 1)

Definition at line 258 of file chan_mobile.c.

HFP_HF_ECNR

#define HFP_HF_ECNR   (1 << 0)

Definition at line 257 of file chan_mobile.c.

HFP_HF_STATUS

#define HFP_HF_STATUS   (1 << 5)

Definition at line 262 of file chan_mobile.c.

HFP_HF_VOICE

#define HFP_HF_VOICE   (1 << 3)

Definition at line 260 of file chan_mobile.c.

HFP_HF_VOLUME

#define HFP_HF_VOLUME   (1 << 4)

Definition at line 261 of file chan_mobile.c.

MBL_CONFIG

#define MBL_CONFIG   "chan_mobile.conf"

Definition at line 78 of file chan_mobile.c.

MBL_CONFIG_OLD

#define MBL_CONFIG_OLD   "mobile.conf"

Definition at line 79 of file chan_mobile.c.

rfcomm_read_debug

#define rfcomm_read_debug

(

c

)

Definition at line 1501 of file chan_mobile.c.

Enumeration Type Documentation

at_message_t

enum at_message_t

Enumerator
AT_PARSE_ERROR
AT_READ_ERROR
AT_UNKNOWN
AT_OK
AT_ERROR
AT_RING
AT_BRSF
AT_CIND
AT_CIEV
AT_CLIP
AT_CMTI
AT_CMGR
AT_SMS_PROMPT
AT_CMS_ERROR
AT_A
AT_D
AT_CHUP
AT_CKPD
AT_CMGS
AT_VGM
AT_VGS
AT_VTS
AT_CMGF
AT_CNMI
AT_CMER
AT_CIND_TEST
AT_CUSD
AT_BUSY
AT_NO_DIALTONE
AT_NO_CARRIER
AT_ECAM

Definition at line 419 of file chan_mobile.c.

             {
    /* errors */
    AT_PARSE_ERROR = -2,
    AT_READ_ERROR = -1,
    AT_UNKNOWN = 0,
    /* at responses */
    AT_OK,
    AT_ERROR,
    AT_RING,
    AT_BRSF,
    AT_CIND,
    AT_CIEV,
    AT_CLIP,
    AT_CMTI,
    AT_CMGR,
    AT_SMS_PROMPT,
    AT_CMS_ERROR,
    /* at commands */
    AT_A,
    AT_D,
    AT_CHUP,
    AT_CKPD,
    AT_CMGS,
    AT_VGM,
    AT_VGS,
    AT_VTS,
    AT_CMGF,
    AT_CNMI,
    AT_CMER,
    AT_CIND_TEST,
    AT_CUSD,
    AT_BUSY,
    AT_NO_DIALTONE,
    AT_NO_CARRIER,
    AT_ECAM,
} at_message_t;

mbl_type

enum mbl_type

Enumerator
MBL_TYPE_PHONE
MBL_TYPE_HEADSET

Definition at line 94 of file chan_mobile.c.

              {
    MBL_TYPE_PHONE,
    MBL_TYPE_HEADSET
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 4840 of file chan_mobile.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 4840 of file chan_mobile.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 4840 of file chan_mobile.c.

at_match_prefix()

static int at_match_prefix ( char *  buf, char *  prefix  )

static

Match the given buffer with the given prefix.

Parameters

buf	the buffer to match
prefix	the prefix to match

Definition at line 2003 of file chan_mobile.c.

{
    return !strncmp(buf, prefix, strlen(prefix));
}

References buf, and prefix.

Referenced by at_read_full().

at_msg2str()

static const char * at_msg2str ( at_message_t  msg )

inlinestatic

Get the string representation of the given AT message.

Parameters

msg	the message to process

Returns

a string describing the given message

Definition at line 2076 of file chan_mobile.c.

{
    switch (msg) {
    /* errors */
    case AT_PARSE_ERROR:
        return "PARSE ERROR";
    case AT_READ_ERROR:
        return "READ ERROR";
    default:
    case AT_UNKNOWN:
        return "UNKNOWN";
    /* at responses */
    case AT_OK:
        return "OK";
    case AT_ERROR:
        return "ERROR";
    case AT_RING:
        return "RING";
    case AT_BRSF:
        return "AT+BRSF";
    case AT_CIND:
        return "AT+CIND";
    case AT_CIEV:
        return "AT+CIEV";
    case AT_CLIP:
        return "AT+CLIP";
    case AT_CMTI:
        return "AT+CMTI";
    case AT_CMGR:
        return "AT+CMGR";
    case AT_SMS_PROMPT:
        return "SMS PROMPT";
    case AT_CMS_ERROR:
        return "+CMS ERROR";
    case AT_BUSY:
        return "BUSY";
    case AT_NO_DIALTONE:
        return "NO DIALTONE";
    case AT_NO_CARRIER:
        return "NO CARRIER";
    /* at commands */
    case AT_A:
        return "ATA";
    case AT_D:
        return "ATD";
    case AT_CHUP:
        return "AT+CHUP";
    case AT_CKPD:
        return "AT+CKPD";
    case AT_CMGS:
        return "AT+CMGS";
    case AT_VGM:
        return "AT+VGM";
    case AT_VGS:
        return "AT+VGS";
    case AT_VTS:
        return "AT+VTS";
    case AT_CMGF:
        return "AT+CMGF";
    case AT_CNMI:
        return "AT+CNMI";
    case AT_CMER:
        return "AT+CMER";
    case AT_CIND_TEST:
        return "AT+CIND=?";
    case AT_CUSD:
        return "AT+CUSD";
    case AT_ECAM:
        return "AT*ECAM";
    }
}

References AT_A, AT_BRSF, AT_BUSY, AT_CHUP, AT_CIEV, AT_CIND, AT_CIND_TEST, AT_CKPD, AT_CLIP, AT_CMER, AT_CMGF, AT_CMGR, AT_CMGS, AT_CMS_ERROR, AT_CMTI, AT_CNMI, AT_CUSD, AT_D, AT_ECAM, AT_ERROR, AT_NO_CARRIER, AT_NO_DIALTONE, AT_OK, AT_PARSE_ERROR, AT_READ_ERROR, AT_RING, AT_SMS_PROMPT, AT_UNKNOWN, AT_VGM, AT_VGS, and AT_VTS.

Referenced by do_monitor_headset(), do_monitor_phone(), handle_response_brsf(), handle_response_cind(), handle_response_error(), and handle_response_ok().

at_read_full()

static at_message_t at_read_full ( int  rsock, char *  buf, size_t  count  )

static

Read an AT message and classify it.

Parameters

rsock	an rfcomm socket
buf	the buffer to store the result in
count	the size of the buffer or the maximum number of characters to read

Returns

the type of message received, in addition buf will contain the message received and will be null terminated

See also

at_read()

Definition at line 2017 of file chan_mobile.c.

{
    ssize_t s;
    if ((s = rfcomm_read(rsock, buf, count - 1)) < 1)
        return s;
    buf[s] = '\0';
 
    if (!strcmp("OK", buf)) {
        return AT_OK;
    } else if (!strcmp("ERROR", buf)) {
        return AT_ERROR;
    } else if (!strcmp("RING", buf)) {
        return AT_RING;
    } else if (!strcmp("AT+CKPD=200", buf)) {
        return AT_CKPD;
    } else if (!strcmp("> ", buf)) {
        return AT_SMS_PROMPT;
    } else if (at_match_prefix(buf, "+CMTI:")) {
        return AT_CMTI;
    } else if (at_match_prefix(buf, "+CIEV:")) {
        return AT_CIEV;
    } else if (at_match_prefix(buf, "+BRSF:")) {
        return AT_BRSF;
    } else if (at_match_prefix(buf, "+CIND:")) {
        return AT_CIND;
    } else if (at_match_prefix(buf, "+CLIP:")) {
        return AT_CLIP;
    } else if (at_match_prefix(buf, "+CMGR:")) {
        return AT_CMGR;
    } else if (at_match_prefix(buf, "+VGM:")) {
        return AT_VGM;
    } else if (at_match_prefix(buf, "+VGS:")) {
        return AT_VGS;
    } else if (at_match_prefix(buf, "+CMS ERROR:")) {
        return AT_CMS_ERROR;
    } else if (at_match_prefix(buf, "AT+VGM=")) {
        return AT_VGM;
    } else if (at_match_prefix(buf, "AT+VGS=")) {
        return AT_VGS;
    } else if (at_match_prefix(buf, "+CUSD:")) {
        return AT_CUSD;
    } else if (at_match_prefix(buf, "BUSY")) {
        return AT_BUSY;
    } else if (at_match_prefix(buf, "NO DIALTONE")) {
        return AT_NO_DIALTONE;
    } else if (at_match_prefix(buf, "NO CARRIER")) {
        return AT_NO_CARRIER;
    } else if (at_match_prefix(buf, "*ECAV:")) {
        return AT_ECAM;
    } else {
        return AT_UNKNOWN;
    }
}

References AT_BRSF, AT_BUSY, AT_CIEV, AT_CIND, AT_CKPD, AT_CLIP, AT_CMGR, AT_CMS_ERROR, AT_CMTI, AT_CUSD, AT_ECAM, AT_ERROR, at_match_prefix(), AT_NO_CARRIER, AT_NO_DIALTONE, AT_OK, AT_RING, AT_SMS_PROMPT, AT_UNKNOWN, AT_VGM, AT_VGS, buf, and rfcomm_read().

Referenced by do_monitor_headset(), and do_monitor_phone().

check_unloading()

static int check_unloading ( void  )

inlinestatic

Check if the module is unloading.

Return values

0	not unloading
1	unloading

Definition at line 4684 of file chan_mobile.c.

{
    int res;
    ast_mutex_lock(&unload_mutex);
    res = unloading_flag;
    ast_mutex_unlock(&unload_mutex);
 
    return res;
}

References ast_mutex_lock, ast_mutex_unlock, unload_mutex, and unloading_flag.

Referenced by do_discovery(), do_monitor_headset(), do_monitor_phone(), and do_sco_listen().

do_alignment_detection()

static void do_alignment_detection ( struct mbl_pvt *  pvt, char *  buf, int  buflen  )

static

Definition at line 1281 of file chan_mobile.c.

{
 
    int i;
    short a, *s;
    char *p;
 
    if (pvt->alignment_detection_triggered) {
        for (i=buflen, p=buf+buflen-1; i>0; i--, p--)
            *p = *(p-1);
        *(p+1) = 0;
        return;
    }
 
    if (pvt->alignment_count < 4) {
        s = (short *)buf;
        for (i=0, a=0; i<buflen/2; i++) {
            a += *s++;
            a /= i+1;
        }
        pvt->alignment_samples[pvt->alignment_count++] = a;
        return;
    }
 
    ast_debug(1, "Alignment Detection result is [%-d %-d %-d %-d]\n", pvt->alignment_samples[0], pvt->alignment_samples[1], pvt->alignment_samples[2], pvt->alignment_samples[3]);
 
    a = abs(pvt->alignment_samples[1]) + abs(pvt->alignment_samples[2]) + abs(pvt->alignment_samples[3]);
    a /= 3;
    if (a > 100) {
        pvt->alignment_detection_triggered = 1;
        ast_debug(1, "Alignment Detection Triggered.\n");
    } else
        pvt->do_alignment_detection = 0;
 
}

References a, abs, mbl_pvt::alignment_count, mbl_pvt::alignment_detection_triggered, mbl_pvt::alignment_samples, ast_debug, buf, and mbl_pvt::do_alignment_detection.

Referenced by mbl_read().

do_discovery()

static void * do_discovery ( void *  data )

static

Definition at line 4284 of file chan_mobile.c.

{
 
    struct adapter_pvt *adapter;
    struct mbl_pvt *pvt;
 
    while (!check_unloading()) {
        AST_RWLIST_RDLOCK(&adapters);
        AST_RWLIST_TRAVERSE(&adapters, adapter, entry) {
            if (!adapter->inuse) {
                AST_RWLIST_RDLOCK(&devices);
                AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
                    ast_mutex_lock(&pvt->lock);
                    if (!adapter->inuse && !pvt->connected && !strcmp(adapter->id, pvt->adapter->id)) {
                        if ((pvt->rfcomm_socket = rfcomm_connect(adapter->addr, pvt->addr, pvt->rfcomm_port)) > -1) {
                            if (start_monitor(pvt)) {
                                pvt->connected = 1;
                                adapter->inuse = 1;
                                manager_event(EVENT_FLAG_SYSTEM, "MobileStatus", "Status: Connect\r\nDevice: %s\r\n", pvt->id);
                                ast_verb(3, "Bluetooth Device %s has connected, initializing...\n", pvt->id);
                            }
                        }
                    }
                    ast_mutex_unlock(&pvt->lock);
                }
                AST_RWLIST_UNLOCK(&devices);
            }
        }
        AST_RWLIST_UNLOCK(&adapters);
 
 
        /* Go to sleep (only if we are not unloading) */
        if (!check_unloading())
            sleep(discovery_interval);
    }
 
    return NULL;
}

References mbl_pvt::adapter, adapter_pvt::addr, mbl_pvt::addr, ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_verb, check_unloading(), mbl_pvt::connected, discovery_interval, EVENT_FLAG_SYSTEM, adapter_pvt::id, mbl_pvt::id, adapter_pvt::inuse, mbl_pvt::lock, manager_event, NULL, rfcomm_connect(), mbl_pvt::rfcomm_port, mbl_pvt::rfcomm_socket, and start_monitor().

Referenced by load_module().

do_monitor_headset()

static void * do_monitor_headset ( void *  data )

static

Definition at line 4121 of file chan_mobile.c.

{
 
    struct mbl_pvt *pvt = (struct mbl_pvt *)data;
    char buf[256];
    int t;
    at_message_t at_msg;
    struct ast_channel *chan = NULL;
 
    ast_verb(3, "Bluetooth Device %s initialised and ready.\n", pvt->id);
 
    while (!check_unloading()) {
 
        t = ast_sched_wait(pvt->sched);
        if (t == -1) {
            t = 6000;
        }
 
        ast_sched_runq(pvt->sched);
 
        if (rfcomm_wait(pvt->rfcomm_socket, &t) == 0)
            continue;
 
        if ((at_msg = at_read_full(pvt->rfcomm_socket, buf, sizeof(buf))) < 0) {
            ast_debug(1, "[%s] error reading from device: %s (%d)\n", pvt->id, strerror(errno), errno);
            goto e_cleanup;
        }
        ast_debug(1, "[%s] %s\n", pvt->id, buf);
 
        switch (at_msg) {
        case AT_VGS:
        case AT_VGM:
            /* XXX volume change requested, we will just
             * pretend to do something with it */
            if (hsp_send_ok(pvt->rfcomm_socket)) {
                ast_debug(1, "[%s] error sending AT message 'OK'\n", pvt->id);
                goto e_cleanup;
            }
            break;
        case AT_CKPD:
            ast_mutex_lock(&pvt->lock);
            if (pvt->outgoing) {
                pvt->needring = 0;
                hsp_send_ok(pvt->rfcomm_socket);
                if (pvt->answered) {
                    /* we have an answered call up to the
                     * HS, he wants to hangup */
                    mbl_queue_hangup(pvt);
                } else {
                    /* we have an outgoing call to the HS,
                     * he wants to answer */
                    if ((pvt->sco_socket = sco_connect(pvt->adapter->addr, pvt->addr)) == -1) {
                        ast_log(LOG_ERROR, "[%s] unable to create audio connection\n", pvt->id);
                        mbl_queue_hangup(pvt);
                        ast_mutex_unlock(&pvt->lock);
                        goto e_cleanup;
                    }
 
                    ast_channel_set_fd(pvt->owner, 0, pvt->sco_socket);
 
                    mbl_queue_control(pvt, AST_CONTROL_ANSWER);
                    pvt->answered = 1;
 
                    if (hsp_send_vgs(pvt->rfcomm_socket, 13) || hsp_send_vgm(pvt->rfcomm_socket, 13)) {
                        ast_debug(1, "[%s] error sending VGS/VGM\n", pvt->id);
                        mbl_queue_hangup(pvt);
                        ast_mutex_unlock(&pvt->lock);
                        goto e_cleanup;
                    }
                }
            } else if (pvt->incoming) {
                /* we have an incoming call from the
                 * HS, he wants to hang up */
                mbl_queue_hangup(pvt);
            } else {
                /* no call is up, HS wants to dial */
                hsp_send_ok(pvt->rfcomm_socket);
 
                if ((pvt->sco_socket = sco_connect(pvt->adapter->addr, pvt->addr)) == -1) {
                    ast_log(LOG_ERROR, "[%s] unable to create audio connection\n", pvt->id);
                    ast_mutex_unlock(&pvt->lock);
                    goto e_cleanup;
                }
 
                pvt->incoming = 1;
 
                if (!(chan = mbl_new(AST_STATE_UP, pvt, NULL, NULL, NULL))) {
                    ast_log(LOG_ERROR, "[%s] unable to allocate channel for incoming call\n", pvt->id);
                    ast_mutex_unlock(&pvt->lock);
                    goto e_cleanup;
                }
 
                ast_channel_set_fd(chan, 0, pvt->sco_socket);
 
                ast_channel_exten_set(chan, "s");
                if (ast_pbx_start(chan)) {
                    ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming call\n", pvt->id);
                    ast_hangup(chan);
                    ast_mutex_unlock(&pvt->lock);
                    goto e_cleanup;
                }
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        default:
            ast_debug(1, "[%s] received unknown AT command: %s (%s)\n", pvt->id, buf, at_msg2str(at_msg));
            if (hsp_send_error(pvt->rfcomm_socket)) {
                ast_debug(1, "[%s] error sending AT message 'ERROR'\n", pvt->id);
                goto e_cleanup;
            }
            break;
        }
    }
 
e_cleanup:
    ast_mutex_lock(&pvt->lock);
    if (pvt->owner) {
        ast_debug(1, "[%s] device disconnected, hanging up owner\n", pvt->id);
        mbl_queue_hangup(pvt);
    }
 
 
    close(pvt->rfcomm_socket);
    close(pvt->sco_socket);
    pvt->sco_socket = -1;
 
    pvt->connected = 0;
 
    pvt->needring = 0;
    pvt->outgoing = 0;
    pvt->incoming = 0;
 
    pvt->adapter->inuse = 0;
    ast_mutex_unlock(&pvt->lock);
 
    manager_event(EVENT_FLAG_SYSTEM, "MobileStatus", "Status: Disconnect\r\nDevice: %s\r\n", pvt->id);
    ast_verb(3, "Bluetooth Device %s has disconnected\n", pvt->id);
 
    return NULL;
 
}

References mbl_pvt::adapter, adapter_pvt::addr, mbl_pvt::addr, mbl_pvt::answered, ast_channel_exten_set(), ast_channel_set_fd(), AST_CONTROL_ANSWER, ast_debug, ast_hangup(), ast_log, ast_mutex_lock, ast_mutex_unlock, ast_pbx_start(), ast_sched_runq(), ast_sched_wait(), AST_STATE_UP, ast_verb, AT_CKPD, at_msg2str(), at_read_full(), AT_VGM, AT_VGS, buf, check_unloading(), mbl_pvt::connected, errno, EVENT_FLAG_SYSTEM, hsp_send_error(), hsp_send_ok(), hsp_send_vgm(), hsp_send_vgs(), mbl_pvt::id, mbl_pvt::incoming, adapter_pvt::inuse, mbl_pvt::lock, LOG_ERROR, manager_event, mbl_new(), mbl_queue_control(), mbl_queue_hangup(), mbl_pvt::needring, NULL, mbl_pvt::outgoing, mbl_pvt::owner, mbl_pvt::rfcomm_socket, rfcomm_wait(), mbl_pvt::sched, sco_connect(), and mbl_pvt::sco_socket.

Referenced by start_monitor().

do_monitor_phone()

static void * do_monitor_phone ( void *  data )

static

Definition at line 3872 of file chan_mobile.c.

{
    struct mbl_pvt *pvt = (struct mbl_pvt *)data;
    struct hfp_pvt *hfp = pvt->hfp;
    char buf[350];
    int t;
    at_message_t at_msg;
    struct msg_queue_entry *entry;
 
    /* Note: At one point the initialization procedure was neatly contained
     * in the hfp_init() function, but that initialization method did not
     * work with non standard devices.  As a result, the initialization
     * procedure is not spread throughout the event handling loop.
     */
 
    /* start initialization with the BRSF request */
    ast_mutex_lock(&pvt->lock);
    pvt->timeout = 10000;
    if (hfp_send_brsf(hfp, &hfp_our_brsf)  || msg_queue_push(pvt, AT_BRSF, AT_BRSF)) {
        ast_debug(1, "[%s] error sending BRSF\n", hfp->owner->id);
        goto e_cleanup;
    }
    ast_mutex_unlock(&pvt->lock);
 
    while (!check_unloading()) {
        ast_mutex_lock(&pvt->lock);
        t = pvt->timeout;
        ast_mutex_unlock(&pvt->lock);
 
        if (!rfcomm_wait(pvt->rfcomm_socket, &t)) {
            ast_debug(1, "[%s] timeout waiting for rfcomm data, disconnecting\n", pvt->id);
            ast_mutex_lock(&pvt->lock);
            if (!hfp->initialized) {
                if ((entry = msg_queue_head(pvt))) {
                    switch (entry->response_to) {
                    case AT_CIND_TEST:
                        if (pvt->blackberry)
                            ast_debug(1, "[%s] timeout during CIND test\n", hfp->owner->id);
                        else
                            ast_debug(1, "[%s] timeout during CIND test, try setting 'blackberry=yes'\n", hfp->owner->id);
                        break;
                    case AT_CMER:
                        if (pvt->blackberry)
                            ast_debug(1, "[%s] timeout after sending CMER, try setting 'blackberry=no'\n", hfp->owner->id);
                        else
                            ast_debug(1, "[%s] timeout after sending CMER\n", hfp->owner->id);
                        break;
                    default:
                        ast_debug(1, "[%s] timeout while waiting for %s in response to %s\n", pvt->id, at_msg2str(entry->expected), at_msg2str(entry->response_to));
                        break;
                    }
                }
            }
            ast_mutex_unlock(&pvt->lock);
            goto e_cleanup;
        }
 
        if ((at_msg = at_read_full(hfp->rsock, buf, sizeof(buf))) < 0) {
            ast_debug(1, "[%s] error reading from device: %s (%d)\n", pvt->id, strerror(errno), errno);
            break;
        }
 
        ast_debug(1, "[%s] read %s\n", pvt->id, buf);
 
        switch (at_msg) {
        case AT_BRSF:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_brsf(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_CIND:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_cind(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_OK:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_ok(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_CMS_ERROR:
        case AT_ERROR:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_error(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_RING:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_ring(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_CIEV:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_ciev(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_CLIP:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_clip(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_CMTI:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_cmti(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_CMGR:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_cmgr(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_SMS_PROMPT:
            ast_mutex_lock(&pvt->lock);
            if (handle_sms_prompt(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_CUSD:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_cusd(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_BUSY:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_busy(pvt)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_NO_DIALTONE:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_no_dialtone(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_NO_CARRIER:
            ast_mutex_lock(&pvt->lock);
            if (handle_response_no_carrier(pvt, buf)) {
                ast_mutex_unlock(&pvt->lock);
                goto e_cleanup;
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_ECAM:
            ast_mutex_lock(&pvt->lock);
            if (hfp_parse_ecav(hfp, buf) == 7) {
                if (handle_response_busy(pvt)) {
                    ast_mutex_unlock(&pvt->lock);
                    goto e_cleanup;
                }
            }
            ast_mutex_unlock(&pvt->lock);
            break;
        case AT_UNKNOWN:
            ast_debug(1, "[%s] ignoring unknown message: %s\n", pvt->id, buf);
            break;
        case AT_PARSE_ERROR:
            ast_debug(1, "[%s] error parsing message\n", pvt->id);
            goto e_cleanup;
        case AT_READ_ERROR:
            ast_debug(1, "[%s] error reading from device: %s (%d)\n", pvt->id, strerror(errno), errno);
            goto e_cleanup;
        default:
            break;
        }
    }
 
e_cleanup:
 
    if (!hfp->initialized)
        ast_verb(3, "Error initializing Bluetooth device %s.\n", pvt->id);
 
    ast_mutex_lock(&pvt->lock);
    if (pvt->owner) {
        ast_debug(1, "[%s] device disconnected, hanging up owner\n", pvt->id);
        pvt->needchup = 0;
        mbl_queue_hangup(pvt);
    }
 
    close(pvt->rfcomm_socket);
    close(pvt->sco_socket);
    pvt->sco_socket = -1;
 
    msg_queue_flush(pvt);
 
    pvt->connected = 0;
    hfp->initialized = 0;
 
    pvt->adapter->inuse = 0;
    ast_mutex_unlock(&pvt->lock);
 
    ast_verb(3, "Bluetooth Device %s has disconnected.\n", pvt->id);
    manager_event(EVENT_FLAG_SYSTEM, "MobileStatus", "Status: Disconnect\r\nDevice: %s\r\n", pvt->id);
 
    return NULL;
}

References mbl_pvt::adapter, ast_debug, ast_mutex_lock, ast_mutex_unlock, ast_verb, AT_BRSF, AT_BUSY, AT_CIEV, AT_CIND, AT_CIND_TEST, AT_CLIP, AT_CMER, AT_CMGR, AT_CMS_ERROR, AT_CMTI, AT_CUSD, AT_ECAM, AT_ERROR, at_msg2str(), AT_NO_CARRIER, AT_NO_DIALTONE, AT_OK, AT_PARSE_ERROR, AT_READ_ERROR, at_read_full(), AT_RING, AT_SMS_PROMPT, AT_UNKNOWN, mbl_pvt::blackberry, buf, check_unloading(), mbl_pvt::connected, msg_queue_entry::entry, errno, EVENT_FLAG_SYSTEM, handle_response_brsf(), handle_response_busy(), handle_response_ciev(), handle_response_cind(), handle_response_clip(), handle_response_cmgr(), handle_response_cmti(), handle_response_cusd(), handle_response_error(), handle_response_no_carrier(), handle_response_no_dialtone(), handle_response_ok(), handle_response_ring(), handle_sms_prompt(), mbl_pvt::hfp, hfp_our_brsf, hfp_parse_ecav(), hfp_send_brsf(), mbl_pvt::id, hfp_pvt::initialized, adapter_pvt::inuse, mbl_pvt::lock, manager_event, mbl_queue_hangup(), msg_queue_flush(), msg_queue_head(), msg_queue_push(), mbl_pvt::needchup, NULL, mbl_pvt::owner, hfp_pvt::owner, mbl_pvt::rfcomm_socket, rfcomm_wait(), hfp_pvt::rsock, mbl_pvt::sco_socket, and mbl_pvt::timeout.

Referenced by start_monitor().

do_sco_listen()

static void * do_sco_listen ( void *  data )

static

Service new and existing SCO connections. This thread accepts new sco connections and handles audio data. There is one do_sco_listen thread for each adapter.

Definition at line 4328 of file chan_mobile.c.

{
    struct adapter_pvt *adapter = (struct adapter_pvt *) data;
 
    while (!check_unloading()) {
        /* check for new sco connections */
        if (ast_io_wait(adapter->accept_io, 0) == -1) {
            /* handle errors */
            ast_log(LOG_ERROR, "ast_io_wait() failed for adapter %s\n", adapter->id);
            break;
        }
 
        /* handle audio data */
        if (ast_io_wait(adapter->io, 1) == -1) {
            ast_log(LOG_ERROR, "ast_io_wait() failed for audio on adapter %s\n", adapter->id);
            break;
        }
    }
 
    return NULL;
}

References adapter_pvt::accept_io, ast_io_wait(), ast_log, check_unloading(), adapter_pvt::id, adapter_pvt::io, LOG_ERROR, and NULL.

Referenced by mbl_load_adapter().

handle_cli_mobile_cusd()

static char * handle_cli_mobile_cusd ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 659 of file chan_mobile.c.

{
    char buf[128];
    struct mbl_pvt *pvt = NULL;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "mobile cusd";
        e->usage =
            "Usage: mobile cusd <device ID> <command>\n"
            "       Send cusd <command> to the rfcomm port on the device\n"
            "       with the specified <device ID>.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 4)
        return CLI_SHOWUSAGE;
 
    AST_RWLIST_RDLOCK(&devices);
    AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
        if (!strcmp(pvt->id, a->argv[2]))
            break;
    }
    AST_RWLIST_UNLOCK(&devices);
 
    if (!pvt) {
        ast_cli(a->fd, "Device %s not found.\n", a->argv[2]);
        goto e_return;
    }
 
    ast_mutex_lock(&pvt->lock);
    if (!pvt->connected) {
        ast_cli(a->fd, "Device %s not connected.\n", a->argv[2]);
        goto e_unlock_pvt;
    }
 
    snprintf(buf, sizeof(buf), "%s", a->argv[3]);
    if (hfp_send_cusd(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CUSD)) {
        ast_cli(a->fd, "[%s] error sending CUSD\n", pvt->id);
        goto e_unlock_pvt;
    }
 
e_unlock_pvt:
    ast_mutex_unlock(&pvt->lock);
e_return:
    return CLI_SUCCESS;
}

References a, ast_cli(), ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AT_CUSD, AT_OK, buf, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, mbl_pvt::connected, mbl_pvt::hfp, hfp_send_cusd(), mbl_pvt::id, mbl_pvt::lock, msg_queue_push(), NULL, and ast_cli_entry::usage.

handle_cli_mobile_rfcomm()

static char * handle_cli_mobile_rfcomm ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 611 of file chan_mobile.c.

{
    char buf[128];
    struct mbl_pvt *pvt = NULL;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "mobile rfcomm";
        e->usage =
            "Usage: mobile rfcomm <device ID> <command>\n"
            "       Send <command> to the rfcomm port on the device\n"
            "       with the specified <device ID>.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 4)
        return CLI_SHOWUSAGE;
 
    AST_RWLIST_RDLOCK(&devices);
    AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
        if (!strcmp(pvt->id, a->argv[2]))
            break;
    }
    AST_RWLIST_UNLOCK(&devices);
 
    if (!pvt) {
        ast_cli(a->fd, "Device %s not found.\n", a->argv[2]);
        goto e_return;
    }
 
    ast_mutex_lock(&pvt->lock);
    if (!pvt->connected) {
        ast_cli(a->fd, "Device %s not connected.\n", a->argv[2]);
        goto e_unlock_pvt;
    }
 
    snprintf(buf, sizeof(buf), "%s\r", a->argv[3]);
    rfcomm_write(pvt->rfcomm_socket, buf);
    msg_queue_push(pvt, AT_OK, AT_UNKNOWN);
 
e_unlock_pvt:
    ast_mutex_unlock(&pvt->lock);
e_return:
    return CLI_SUCCESS;
}

References a, ast_cli(), ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AT_OK, AT_UNKNOWN, buf, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, mbl_pvt::connected, mbl_pvt::id, mbl_pvt::lock, msg_queue_push(), NULL, mbl_pvt::rfcomm_socket, rfcomm_write(), and ast_cli_entry::usage.

handle_cli_mobile_search()

static char * handle_cli_mobile_search ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 541 of file chan_mobile.c.

{
    struct adapter_pvt *adapter;
    inquiry_info *ii = NULL;
    int max_rsp, num_rsp;
    int len, flags;
    int i, phport, hsport;
    char addr[19] = {0};
    char name[31] = {0};
 
#define FORMAT1 "%-17.17s %-30.30s %-6.6s %-7.7s %-4.4s\n"
#define FORMAT2 "%-17.17s %-30.30s %-6.6s %-7.7s %d\n"
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "mobile search";
        e->usage =
            "Usage: mobile search\n"
            "       Searches for Bluetooth Cell / Mobile devices in range.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 2)
        return CLI_SHOWUSAGE;
 
    /* find a free adapter */
    AST_RWLIST_RDLOCK(&adapters);
    AST_RWLIST_TRAVERSE(&adapters, adapter, entry) {
        if (!adapter->inuse)
            break;
    }
    AST_RWLIST_UNLOCK(&adapters);
 
    if (!adapter) {
        ast_cli(a->fd, "All Bluetooth adapters are in use at this time.\n");
        return CLI_SUCCESS;
    }
 
    len  = 8;
    max_rsp = 255;
    flags = IREQ_CACHE_FLUSH;
 
    ii = ast_alloca(max_rsp * sizeof(inquiry_info));
    num_rsp = hci_inquiry(adapter->dev_id, len, max_rsp, NULL, &ii, flags);
    if (num_rsp > 0) {
        ast_cli(a->fd, FORMAT1, "Address", "Name", "Usable", "Type", "Port");
        for (i = 0; i < num_rsp; i++) {
            ba2str(&(ii + i)->bdaddr, addr);
            name[0] = 0x00;
            if (hci_read_remote_name(adapter->hci_socket, &(ii + i)->bdaddr, sizeof(name) - 1, name, 0) < 0)
                strcpy(name, "[unknown]");
            phport = sdp_search(addr, HANDSFREE_AGW_PROFILE_ID);
            if (!phport)
                hsport = sdp_search(addr, HEADSET_PROFILE_ID);
            else
                hsport = 0;
            ast_cli(a->fd, FORMAT2, addr, name, (phport > 0 || hsport > 0) ? "Yes" : "No",
                (phport > 0) ? "Phone" : "Headset", (phport > 0) ? phport : hsport);
        }
    } else
        ast_cli(a->fd, "No Bluetooth Cell / Mobile devices found.\n");
 
#undef FORMAT1
#undef FORMAT2
 
    return CLI_SUCCESS;
}

References a, adapter_pvt::addr, ast_alloca, ast_cli(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, adapter_pvt::dev_id, FORMAT1, FORMAT2, adapter_pvt::hci_socket, adapter_pvt::inuse, len(), name, NULL, sdp_search(), and ast_cli_entry::usage.

handle_cli_mobile_show_devices()

static char * handle_cli_mobile_show_devices ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 495 of file chan_mobile.c.

{
    struct mbl_pvt *pvt;
    char bdaddr[18];
    char group[6];
 
#define FORMAT1 "%-15.15s %-17.17s %-5.5s %-15.15s %-9.9s %-10.10s %-3.3s\n"
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "mobile show devices";
        e->usage =
            "Usage: mobile show devices\n"
            "       Shows the state of Bluetooth Cell / Mobile devices.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 3)
        return CLI_SHOWUSAGE;
 
    ast_cli(a->fd, FORMAT1, "ID", "Address", "Group", "Adapter", "Connected", "State", "SMS");
    AST_RWLIST_RDLOCK(&devices);
    AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
        ast_mutex_lock(&pvt->lock);
        ba2str(&pvt->addr, bdaddr);
        snprintf(group, sizeof(group), "%d", pvt->group);
        ast_cli(a->fd, FORMAT1,
                pvt->id,
                bdaddr,
                group,
                pvt->adapter->id,
                pvt->connected ? "Yes" : "No",
                (!pvt->connected) ? "None" : (pvt->owner) ? "Busy" : (pvt->outgoing_sms || pvt->incoming_sms) ? "SMS" : (mbl_has_service(pvt)) ? "Free" : "No Service",
                (pvt->has_sms) ? "Yes" : "No"
               );
        ast_mutex_unlock(&pvt->lock);
    }
    AST_RWLIST_UNLOCK(&devices);
 
#undef FORMAT1
 
    return CLI_SUCCESS;
}

References a, mbl_pvt::adapter, mbl_pvt::addr, ast_cli(), ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, mbl_pvt::connected, FORMAT1, mbl_pvt::group, mbl_pvt::has_sms, adapter_pvt::id, mbl_pvt::id, mbl_pvt::incoming_sms, mbl_pvt::lock, mbl_has_service(), NULL, mbl_pvt::outgoing_sms, mbl_pvt::owner, and ast_cli_entry::usage.

handle_response_brsf()

static int handle_response_brsf ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle the BRSF response.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3198 of file chan_mobile.c.

{
    struct msg_queue_entry *entry;
    if ((entry = msg_queue_head(pvt)) && entry->expected == AT_BRSF) {
        if (hfp_parse_brsf(pvt->hfp, buf)) {
            ast_debug(1, "[%s] error parsing BRSF\n", pvt->id);
            goto e_return;
        }
 
        if (msg_queue_push(pvt, AT_OK, AT_BRSF)) {
            ast_debug(1, "[%s] error handling BRSF\n", pvt->id);
            goto e_return;
        }
 
        msg_queue_free_and_pop(pvt);
    } else if (entry) {
        ast_debug(1, "[%s] received unexpected AT message 'BRSF' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
    } else {
        ast_debug(1, "[%s] received unexpected AT message 'BRSF'\n", pvt->id);
    }
 
    return 0;
 
e_return:
    msg_queue_free_and_pop(pvt);
    return -1;
}

References ast_debug, AT_BRSF, at_msg2str(), AT_OK, buf, msg_queue_entry::entry, mbl_pvt::hfp, hfp_parse_brsf(), mbl_pvt::id, msg_queue_free_and_pop(), msg_queue_head(), and msg_queue_push().

Referenced by do_monitor_phone().

handle_response_busy()

static int handle_response_busy ( struct mbl_pvt *  pvt )

static

Handle BUSY messages.

Parameters

pvt	a mbl_pvt structure

Return values

0	success
-1	error

Definition at line 3833 of file chan_mobile.c.

{
    pvt->hangupcause = AST_CAUSE_USER_BUSY;
    pvt->needchup = 1;
    mbl_queue_control(pvt, AST_CONTROL_BUSY);
    return 0;
}

References AST_CAUSE_USER_BUSY, AST_CONTROL_BUSY, mbl_pvt::hangupcause, mbl_queue_control(), and mbl_pvt::needchup.

Referenced by do_monitor_phone(), and handle_response_ciev().

handle_response_ciev()

static int handle_response_ciev ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle AT+CIEV messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3561 of file chan_mobile.c.

{
    int i;
    switch (hfp_parse_ciev(pvt->hfp, buf, &i)) {
    case HFP_CIND_CALL:
        switch (i) {
        case HFP_CIND_CALL_NONE:
            ast_debug(1, "[%s] line disconnected\n", pvt->id);
            if (pvt->owner) {
                ast_debug(1, "[%s] hanging up owner\n", pvt->id);
                if (mbl_queue_hangup(pvt)) {
                    ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnecting...\n", pvt->id);
                    return -1;
                }
            }
            pvt->needchup = 0;
            pvt->needcallerid = 0;
            pvt->incoming = 0;
            pvt->outgoing = 0;
            break;
        case HFP_CIND_CALL_ACTIVE:
            if (pvt->outgoing) {
                ast_debug(1, "[%s] remote end answered\n", pvt->id);
                mbl_queue_control(pvt, AST_CONTROL_ANSWER);
            } else if (pvt->incoming && pvt->answered) {
                ast_setstate(pvt->owner, AST_STATE_UP);
            } else if (pvt->incoming) {
                /* user answered from handset, disconnecting */
                ast_verb(3, "[%s] user answered bluetooth device from handset, disconnecting\n", pvt->id);
                mbl_queue_hangup(pvt);
                return -1;
            }
            break;
        }
        break;
 
    case HFP_CIND_CALLSETUP:
        switch (i) {
        case HFP_CIND_CALLSETUP_NONE:
            if (pvt->hfp->cind_state[pvt->hfp->cind_map.call] != HFP_CIND_CALL_ACTIVE) {
                if (pvt->owner) {
                    if (pvt->hfp->sent_alerting == 1) {
                        handle_response_busy(pvt);
                    }
                    if (mbl_queue_hangup(pvt)) {
                        ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnecting...\n", pvt->id);
                        return -1;
                    }
                }
                pvt->needchup = 0;
                pvt->needcallerid = 0;
                pvt->incoming = 0;
                pvt->outgoing = 0;
            }
            break;
        case HFP_CIND_CALLSETUP_INCOMING:
            ast_debug(1, "[%s] incoming call, waiting for caller id\n", pvt->id);
            pvt->needcallerid = 1;
            pvt->incoming = 1;
            break;
        case HFP_CIND_CALLSETUP_OUTGOING:
            if (pvt->outgoing) {
                pvt->hfp->sent_alerting = 0;
                ast_debug(1, "[%s] outgoing call\n", pvt->id);
            } else {
                ast_verb(3, "[%s] user dialed from handset, disconnecting\n", pvt->id);
                return -1;
            }
            break;
        case HFP_CIND_CALLSETUP_ALERTING:
            if (pvt->outgoing) {
                ast_debug(1, "[%s] remote alerting\n", pvt->id);
                mbl_queue_control(pvt, AST_CONTROL_RINGING);
                pvt->hfp->sent_alerting = 1;
            }
            break;
        }
        break;
    case HFP_CIND_NONE:
        ast_debug(1, "[%s] error parsing CIND: %s\n", pvt->id, buf);
        break;
    }
    return 0;
}

References mbl_pvt::answered, AST_CONTROL_ANSWER, AST_CONTROL_RINGING, ast_debug, ast_log, ast_setstate(), AST_STATE_UP, ast_verb, buf, hfp_cind::call, hfp_pvt::cind_map, hfp_pvt::cind_state, handle_response_busy(), mbl_pvt::hfp, HFP_CIND_CALL, HFP_CIND_CALL_ACTIVE, HFP_CIND_CALL_NONE, HFP_CIND_CALLSETUP, HFP_CIND_CALLSETUP_ALERTING, HFP_CIND_CALLSETUP_INCOMING, HFP_CIND_CALLSETUP_NONE, HFP_CIND_CALLSETUP_OUTGOING, HFP_CIND_NONE, hfp_parse_ciev(), mbl_pvt::id, mbl_pvt::incoming, LOG_ERROR, mbl_queue_control(), mbl_queue_hangup(), mbl_pvt::needcallerid, mbl_pvt::needchup, mbl_pvt::outgoing, mbl_pvt::owner, and hfp_pvt::sent_alerting.

Referenced by do_monitor_phone().

handle_response_cind()

static int handle_response_cind ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle the CIND response.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3233 of file chan_mobile.c.

{
    struct msg_queue_entry *entry;
    if ((entry = msg_queue_head(pvt)) && entry->expected == AT_CIND) {
        switch (entry->response_to) {
        case AT_CIND_TEST:
            if (hfp_parse_cind_test(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND_TEST)) {
                ast_debug(1, "[%s] error performing CIND test\n", pvt->id);
                goto e_return;
            }
            break;
        case AT_CIND:
            if (hfp_parse_cind(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND)) {
                ast_debug(1, "[%s] error getting CIND state\n", pvt->id);
                goto e_return;
            }
            break;
        default:
            ast_debug(1, "[%s] error getting CIND state\n", pvt->id);
            goto e_return;
        }
        msg_queue_free_and_pop(pvt);
    } else if (entry) {
        ast_debug(1, "[%s] received unexpected AT message 'CIND' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
    } else {
        ast_debug(1, "[%s] received unexpected AT message 'CIND'\n", pvt->id);
    }
 
    return 0;
 
e_return:
    msg_queue_free_and_pop(pvt);
    return -1;
}

References ast_debug, AT_CIND, AT_CIND_TEST, at_msg2str(), AT_OK, buf, msg_queue_entry::entry, mbl_pvt::hfp, hfp_parse_cind(), hfp_parse_cind_test(), mbl_pvt::id, msg_queue_free_and_pop(), msg_queue_head(), and msg_queue_push().

Referenced by do_monitor_phone().

handle_response_clip()

static int handle_response_clip ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle AT+CLIP messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3653 of file chan_mobile.c.

{
    struct msg_queue_entry *msg;
    struct ast_channel *chan;
    struct cidinfo cidinfo;
 
    if ((msg = msg_queue_head(pvt)) && msg->expected == AT_CLIP) {
        msg_queue_free_and_pop(pvt);
 
        pvt->needcallerid = 0;
        cidinfo = hfp_parse_clip(pvt->hfp, buf);
 
        if (!(chan = mbl_new(AST_STATE_RING, pvt, &cidinfo, NULL, NULL))) {
            ast_log(LOG_ERROR, "[%s] unable to allocate channel for incoming call\n", pvt->id);
            hfp_send_chup(pvt->hfp);
            msg_queue_push(pvt, AT_OK, AT_CHUP);
            return -1;
        }
 
        /* from this point on, we need to send a chup in the event of a
         * hangup */
        pvt->needchup = 1;
 
        if (ast_pbx_start(chan)) {
            ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming call\n", pvt->id);
            mbl_ast_hangup(pvt);
            return -1;
        }
    }
 
    return 0;
}

References ast_log, ast_pbx_start(), AST_STATE_RING, AT_CHUP, AT_CLIP, AT_OK, buf, msg_queue_entry::expected, mbl_pvt::hfp, hfp_parse_clip(), hfp_send_chup(), mbl_pvt::id, LOG_ERROR, mbl_ast_hangup(), mbl_new(), msg_queue_free_and_pop(), msg_queue_head(), msg_queue_push(), mbl_pvt::needcallerid, mbl_pvt::needchup, and NULL.

Referenced by do_monitor_phone().

handle_response_cmgr()

static int handle_response_cmgr ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle AT+CMGR messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3737 of file chan_mobile.c.

{
    char *from_number = NULL, *text = NULL;
    struct ast_channel *chan;
    struct msg_queue_entry *msg;
 
    if ((msg = msg_queue_head(pvt)) && msg->expected == AT_CMGR) {
        msg_queue_free_and_pop(pvt);
 
        if (hfp_parse_cmgr(pvt->hfp, buf, &from_number, &text)) {
            ast_debug(1, "[%s] error parsing sms message, disconnecting\n", pvt->id);
            return -1;
        }
 
        ast_debug(1, "[%s] successfully read sms message\n", pvt->id);
        pvt->incoming_sms = 0;
 
        /* XXX this channel probably does not need to be associated with this pvt */
        if (!(chan = mbl_new(AST_STATE_DOWN, pvt, NULL, NULL, NULL))) {
            ast_debug(1, "[%s] error creating sms message channel, disconnecting\n", pvt->id);
            return -1;
        }
 
        ast_channel_exten_set(chan, "sms");
        pbx_builtin_setvar_helper(chan, "SMSSRC", from_number);
        pbx_builtin_setvar_helper(chan, "SMSTXT", text);
 
        if (ast_pbx_start(chan)) {
            ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming sms\n", pvt->id);
            mbl_ast_hangup(pvt);
        }
    } else {
        ast_debug(1, "[%s] got unexpected +CMGR message, ignoring\n", pvt->id);
    }
 
    return 0;
}

References ast_channel_exten_set(), ast_debug, ast_log, ast_pbx_start(), AST_STATE_DOWN, AT_CMGR, buf, msg_queue_entry::expected, mbl_pvt::hfp, hfp_parse_cmgr(), mbl_pvt::id, mbl_pvt::incoming_sms, LOG_ERROR, mbl_ast_hangup(), mbl_new(), msg_queue_free_and_pop(), msg_queue_head(), NULL, pbx_builtin_setvar_helper(), and text.

Referenced by do_monitor_phone().

handle_response_cmti()

static int handle_response_cmti ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle AT+CMTI messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3710 of file chan_mobile.c.

{
    int index = hfp_parse_cmti(pvt->hfp, buf);
    if (index > 0) {
        ast_debug(1, "[%s] incoming sms message\n", pvt->id);
 
        if (hfp_send_cmgr(pvt->hfp, index)
                || msg_queue_push(pvt, AT_CMGR, AT_CMGR)) {
            ast_debug(1, "[%s] error sending CMGR to retrieve SMS message\n", pvt->id);
            return -1;
        }
 
        pvt->incoming_sms = 1;
        return 0;
    } else {
        ast_debug(1, "[%s] error parsing incoming sms message alert, disconnecting\n", pvt->id);
        return -1;
    }
}

References ast_debug, AT_CMGR, buf, mbl_pvt::hfp, hfp_parse_cmti(), hfp_send_cmgr(), mbl_pvt::id, mbl_pvt::incoming_sms, and msg_queue_push().

Referenced by do_monitor_phone().

handle_response_cusd()

static int handle_response_cusd ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle CUSD messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3813 of file chan_mobile.c.

{
    char *cusd;
 
    if (!(cusd = hfp_parse_cusd(pvt->hfp, buf))) {
        ast_verb(0, "[%s] error parsing CUSD: %s\n", pvt->id, buf);
        return 0;
    }
 
    ast_verb(0, "[%s] CUSD response: %s\n", pvt->id, cusd);
 
    return 0;
}

References ast_verb, buf, mbl_pvt::hfp, hfp_parse_cusd(), and mbl_pvt::id.

Referenced by do_monitor_phone().

handle_response_error()

static int handle_response_error ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle ERROR AT messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3444 of file chan_mobile.c.

{
    struct msg_queue_entry *entry;
    if ((entry = msg_queue_head(pvt))
            && (entry->expected == AT_OK
            || entry->expected == AT_ERROR
            || entry->expected == AT_CMS_ERROR
            || entry->expected == AT_CMGR
            || entry->expected == AT_SMS_PROMPT)) {
        switch (entry->response_to) {
 
        /* initialization stuff */
        case AT_BRSF:
            ast_debug(1, "[%s] error reading BSRF\n", pvt->id);
            goto e_return;
        case AT_CIND_TEST:
            ast_debug(1, "[%s] error during CIND test\n", pvt->id);
            goto e_return;
        case AT_CIND:
            ast_debug(1, "[%s] error requesting CIND state\n", pvt->id);
            goto e_return;
        case AT_CMER:
            ast_debug(1, "[%s] error during CMER request\n", pvt->id);
            goto e_return;
        case AT_CLIP:
            ast_debug(1, "[%s] error enabling calling line indication\n", pvt->id);
            goto e_return;
        case AT_VGS:
            ast_debug(1, "[%s] volume level synchronization failed\n", pvt->id);
 
            /* this is not a fatal error, let's continue with initialization */
 
            /* set the SMS operating mode to text mode */
            if (hfp_send_cmgf(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMGF)) {
                ast_debug(1, "[%s] error setting CMGF\n", pvt->id);
                goto e_return;
            }
            break;
        case AT_CMGF:
            pvt->has_sms = 0;
            ast_debug(1, "[%s] error setting CMGF\n", pvt->id);
            ast_debug(1, "[%s] no SMS support\n", pvt->id);
            break;
        case AT_CNMI:
            pvt->has_sms = 0;
            ast_debug(1, "[%s] error setting CNMI\n", pvt->id);
            ast_debug(1, "[%s] no SMS support\n", pvt->id);
            break;
        case AT_ECAM:
            ast_debug(1, "[%s] Mobile does not support Sony Ericsson extensions\n", pvt->id);
 
            /* this is not a fatal error, let's continue with the initialization */
 
            if (hfp_send_vgs(pvt->hfp, 15) || msg_queue_push(pvt, AT_OK, AT_VGS)) {
                ast_debug(1, "[%s] error synchronizing gain settings\n", pvt->id);
                goto e_return;
            }
 
            pvt->timeout = -1;
            pvt->hfp->initialized = 1;
            ast_verb(3, "Bluetooth Device %s initialized and ready.\n", pvt->id);
 
            break;
        /* end initialization stuff */
 
        case AT_A:
            ast_debug(1, "[%s] answer failed\n", pvt->id);
            mbl_queue_hangup(pvt);
            break;
        case AT_D:
            ast_debug(1, "[%s] dial failed\n", pvt->id);
            pvt->needchup = 0;
            mbl_queue_control(pvt, AST_CONTROL_CONGESTION);
            break;
        case AT_CHUP:
            ast_debug(1, "[%s] error sending hangup, disconnecting\n", pvt->id);
            goto e_return;
        case AT_CMGR:
            ast_debug(1, "[%s] error reading sms message\n", pvt->id);
            pvt->incoming_sms = 0;
            break;
        case AT_CMGS:
            ast_debug(1, "[%s] error sending sms message\n", pvt->id);
            pvt->outgoing_sms = 0;
            break;
        case AT_VTS:
            ast_debug(1, "[%s] error sending digit\n", pvt->id);
            break;
        case AT_CUSD:
            ast_verb(0, "[%s] error sending CUSD command\n", pvt->id);
            break;
        case AT_UNKNOWN:
        default:
            ast_debug(1, "[%s] received ERROR for unhandled request: %s\n", pvt->id, at_msg2str(entry->response_to));
            break;
        }
        msg_queue_free_and_pop(pvt);
    } else if (entry) {
        ast_debug(1, "[%s] received AT message 'ERROR' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
    } else {
        ast_debug(1, "[%s] received unexpected AT message 'ERROR'\n", pvt->id);
    }
 
    return 0;
 
e_return:
    msg_queue_free_and_pop(pvt);
    return -1;
}

References AST_CONTROL_CONGESTION, ast_debug, ast_verb, AT_A, AT_BRSF, AT_CHUP, AT_CIND, AT_CIND_TEST, AT_CLIP, AT_CMER, AT_CMGF, AT_CMGR, AT_CMGS, AT_CMS_ERROR, AT_CNMI, AT_CUSD, AT_D, AT_ECAM, AT_ERROR, at_msg2str(), AT_OK, AT_SMS_PROMPT, AT_UNKNOWN, AT_VGS, AT_VTS, msg_queue_entry::entry, mbl_pvt::has_sms, mbl_pvt::hfp, hfp_send_cmgf(), hfp_send_vgs(), mbl_pvt::id, mbl_pvt::incoming_sms, hfp_pvt::initialized, mbl_queue_control(), mbl_queue_hangup(), msg_queue_free_and_pop(), msg_queue_head(), msg_queue_push(), mbl_pvt::needchup, mbl_pvt::outgoing_sms, and mbl_pvt::timeout.

Referenced by do_monitor_phone().

handle_response_no_carrier()

static int handle_response_no_carrier ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle NO CARRIER messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3863 of file chan_mobile.c.

{
    ast_verb(1, "[%s] mobile reports NO CARRIER\n", pvt->id);
    pvt->needchup = 1;
    mbl_queue_control(pvt, AST_CONTROL_CONGESTION);
    return 0;
}

References AST_CONTROL_CONGESTION, ast_verb, mbl_pvt::id, mbl_queue_control(), and mbl_pvt::needchup.

Referenced by do_monitor_phone().

handle_response_no_dialtone()

static int handle_response_no_dialtone ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle NO DIALTONE messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3848 of file chan_mobile.c.

{
    ast_verb(1, "[%s] mobile reports NO DIALTONE\n", pvt->id);
    pvt->needchup = 1;
    mbl_queue_control(pvt, AST_CONTROL_CONGESTION);
    return 0;
}

References AST_CONTROL_CONGESTION, ast_verb, mbl_pvt::id, mbl_queue_control(), and mbl_pvt::needchup.

Referenced by do_monitor_phone().

handle_response_ok()

static int handle_response_ok ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle OK AT messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3275 of file chan_mobile.c.

{
    struct msg_queue_entry *entry;
    if ((entry = msg_queue_head(pvt)) && entry->expected == AT_OK) {
        switch (entry->response_to) {
 
        /* initialization stuff */
        case AT_BRSF:
            ast_debug(1, "[%s] BSRF sent successfully\n", pvt->id);
 
            /* If this is a blackberry do CMER now, otherwise
             * continue with CIND as normal. */
            if (pvt->blackberry) {
                if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) {
                    ast_debug(1, "[%s] error sending CMER\n", pvt->id);
                    goto e_return;
                }
            } else {
                if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) {
                    ast_debug(1, "[%s] error sending CIND test\n", pvt->id);
                    goto e_return;
                }
            }
            break;
        case AT_CIND_TEST:
            ast_debug(1, "[%s] CIND test sent successfully\n", pvt->id);
 
            ast_debug(2, "[%s] call: %d\n", pvt->id, pvt->hfp->cind_map.call);
            ast_debug(2, "[%s] callsetup: %d\n", pvt->id, pvt->hfp->cind_map.callsetup);
            ast_debug(2, "[%s] service: %d\n", pvt->id, pvt->hfp->cind_map.service);
 
            if (hfp_send_cind(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND)) {
                ast_debug(1, "[%s] error requesting CIND state\n", pvt->id);
                goto e_return;
            }
            break;
        case AT_CIND:
            ast_debug(1, "[%s] CIND sent successfully\n", pvt->id);
 
            /* check if a call is active */
            if (pvt->hfp->cind_state[pvt->hfp->cind_map.call]) {
                ast_verb(3, "Bluetooth Device %s has a call in progress - delaying connection.\n", pvt->id);
                goto e_return;
            }
 
            /* If this is NOT a blackberry proceed with CMER,
             * otherwise send CLIP. */
            if (!pvt->blackberry) {
                if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) {
                    ast_debug(1, "[%s] error sending CMER\n", pvt->id);
                    goto e_return;
                }
            } else {
                if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) {
                    ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id);
                    goto e_return;
                }
            }
            break;
        case AT_CMER:
            ast_debug(1, "[%s] CMER sent successfully\n", pvt->id);
 
            /* If this is a blackberry proceed with the CIND test,
             * otherwise send CLIP. */
            if (pvt->blackberry) {
                if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) {
                    ast_debug(1, "[%s] error sending CIND test\n", pvt->id);
                    goto e_return;
                }
            } else {
                if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) {
                    ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id);
                    goto e_return;
                }
            }
            break;
        case AT_CLIP:
            ast_debug(1, "[%s] calling line indication enabled\n", pvt->id);
            if (hfp_send_ecam(pvt->hfp) || msg_queue_push(pvt, AT_OK, AT_ECAM)) {
                ast_debug(1, "[%s] error enabling Sony Ericsson call monitoring extensions\n", pvt->id);
                goto e_return;
            }
 
            break;
        case AT_ECAM:
            ast_debug(1, "[%s] Sony Ericsson call monitoring is active on device\n", pvt->id);
            if (hfp_send_vgs(pvt->hfp, 15) || msg_queue_push(pvt, AT_OK, AT_VGS)) {
                ast_debug(1, "[%s] error synchronizing gain settings\n", pvt->id);
                goto e_return;
            }
 
            pvt->timeout = -1;
            pvt->hfp->initialized = 1;
            ast_verb(3, "Bluetooth Device %s initialized and ready.\n", pvt->id);
 
            break;
        case AT_VGS:
            ast_debug(1, "[%s] volume level synchronization successful\n", pvt->id);
 
            /* set the SMS operating mode to text mode */
            if (pvt->has_sms) {
                if (hfp_send_cmgf(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMGF)) {
                    ast_debug(1, "[%s] error setting CMGF\n", pvt->id);
                    goto e_return;
                }
            }
            break;
        case AT_CMGF:
            ast_debug(1, "[%s] sms text mode enabled\n", pvt->id);
            /* turn on SMS new message indication */
            if (hfp_send_cnmi(pvt->hfp) || msg_queue_push(pvt, AT_OK, AT_CNMI)) {
                ast_debug(1, "[%s] error setting CNMI\n", pvt->id);
                goto e_return;
            }
            break;
        case AT_CNMI:
            ast_debug(1, "[%s] sms new message indication enabled\n", pvt->id);
            pvt->has_sms = 1;
            break;
        /* end initialization stuff */
 
        case AT_A:
            ast_debug(1, "[%s] answer sent successfully\n", pvt->id);
            pvt->needchup = 1;
            break;
        case AT_D:
            ast_debug(1, "[%s] dial sent successfully\n", pvt->id);
            pvt->needchup = 1;
            pvt->outgoing = 1;
            mbl_queue_control(pvt, AST_CONTROL_PROGRESS);
            break;
        case AT_CHUP:
            ast_debug(1, "[%s] successful hangup\n", pvt->id);
            break;
        case AT_CMGS:
            ast_debug(1, "[%s] successfully sent sms message\n", pvt->id);
            pvt->outgoing_sms = 0;
            break;
        case AT_VTS:
            ast_debug(1, "[%s] digit sent successfully\n", pvt->id);
            break;
        case AT_CUSD:
            ast_debug(1, "[%s] CUSD code sent successfully\n", pvt->id);
            break;
        case AT_UNKNOWN:
        default:
            ast_debug(1, "[%s] received OK for unhandled request: %s\n", pvt->id, at_msg2str(entry->response_to));
            break;
        }
        msg_queue_free_and_pop(pvt);
    } else if (entry) {
        ast_debug(1, "[%s] received AT message 'OK' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
    } else {
        ast_debug(1, "[%s] received unexpected AT message 'OK'\n", pvt->id);
    }
    return 0;
 
e_return:
    msg_queue_free_and_pop(pvt);
    return -1;
}

References AST_CONTROL_PROGRESS, ast_debug, ast_verb, AT_A, AT_BRSF, AT_CHUP, AT_CIND, AT_CIND_TEST, AT_CLIP, AT_CMER, AT_CMGF, AT_CMGS, AT_CNMI, AT_CUSD, AT_D, AT_ECAM, at_msg2str(), AT_OK, AT_UNKNOWN, AT_VGS, AT_VTS, mbl_pvt::blackberry, hfp_cind::call, hfp_cind::callsetup, hfp_pvt::cind_map, hfp_pvt::cind_state, msg_queue_entry::entry, mbl_pvt::has_sms, mbl_pvt::hfp, hfp_send_cind(), hfp_send_cind_test(), hfp_send_clip(), hfp_send_cmer(), hfp_send_cmgf(), hfp_send_cnmi(), hfp_send_ecam(), hfp_send_vgs(), mbl_pvt::id, hfp_pvt::initialized, mbl_queue_control(), msg_queue_free_and_pop(), msg_queue_head(), msg_queue_push(), mbl_pvt::needchup, mbl_pvt::outgoing, mbl_pvt::outgoing_sms, hfp_cind::service, and mbl_pvt::timeout.

Referenced by do_monitor_phone().

handle_response_ring()

static int handle_response_ring ( struct mbl_pvt *  pvt, char *  buf  )

static

Handle RING messages.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3693 of file chan_mobile.c.

{
    if (pvt->needcallerid) {
        ast_debug(1, "[%s] got ring while waiting for caller id\n", pvt->id);
        return msg_queue_push(pvt, AT_CLIP, AT_UNKNOWN);
    } else {
        return 0;
    }
}

References ast_debug, AT_CLIP, AT_UNKNOWN, mbl_pvt::id, msg_queue_push(), and mbl_pvt::needcallerid.

Referenced by do_monitor_phone().

handle_sms_prompt()

static int handle_sms_prompt ( struct mbl_pvt *  pvt, char *  buf  )

static

Send an SMS message from the queue.

Parameters

pvt	a mbl_pvt structure
buf	a null terminated buffer containing an AT message

Return values

0	success
-1	error

Definition at line 3782 of file chan_mobile.c.

{
    struct msg_queue_entry *msg;
    if (!(msg = msg_queue_head(pvt))) {
        ast_debug(1, "[%s] error, got sms prompt with no pending sms messages\n", pvt->id);
        return 0;
    }
 
    if (msg->expected != AT_SMS_PROMPT) {
        ast_debug(1, "[%s] error, got sms prompt but no pending sms messages\n", pvt->id);
        return 0;
    }
 
    if (hfp_send_sms_text(pvt->hfp, msg->data)
            || msg_queue_push(pvt, AT_OK, AT_CMGS)) {
        msg_queue_free_and_pop(pvt);
        ast_debug(1, "[%s] error sending sms message\n", pvt->id);
        return 0;
    }
 
    msg_queue_free_and_pop(pvt);
    return 0;
}

References ast_debug, AT_CMGS, AT_OK, AT_SMS_PROMPT, msg_queue_entry::data, msg_queue_entry::expected, mbl_pvt::hfp, hfp_send_sms_text(), mbl_pvt::id, msg_queue_free_and_pop(), msg_queue_head(), and msg_queue_push().

Referenced by do_monitor_phone().

headset_send_ring()

static int headset_send_ring ( const void *  data )

static

Definition at line 4104 of file chan_mobile.c.

{
    struct mbl_pvt *pvt = (struct mbl_pvt *) data;
    ast_mutex_lock(&pvt->lock);
    if (!pvt->needring) {
        ast_mutex_unlock(&pvt->lock);
        return 0;
    }
    ast_mutex_unlock(&pvt->lock);
 
    if (hsp_send_ring(pvt->rfcomm_socket)) {
        ast_debug(1, "[%s] error sending RING\n", pvt->id);
        return 0;
    }
    return 1;
}

References ast_debug, ast_mutex_lock, ast_mutex_unlock, hsp_send_ring(), mbl_pvt::id, mbl_pvt::lock, mbl_pvt::needring, and mbl_pvt::rfcomm_socket.

Referenced by mbl_call().

hfp_brsf2int()

static int hfp_brsf2int ( struct hfp_hf *  hf )

static

Convert a hfp_hf struct to a BRSF int.

Parameters

hf	an hfp_hf brsf object

Returns

an integer representing the given brsf struct

Definition at line 2470 of file chan_mobile.c.

{
    int brsf = 0;
 
    brsf |= hf->ecnr ? HFP_HF_ECNR : 0;
    brsf |= hf->cw ? HFP_HF_CW : 0;
    brsf |= hf->cid ? HFP_HF_CID : 0;
    brsf |= hf->voice ? HFP_HF_VOICE : 0;
    brsf |= hf->volume ? HFP_HF_VOLUME : 0;
    brsf |= hf->status ? HFP_HF_STATUS : 0;
    brsf |= hf->control ? HFP_HF_CONTROL : 0;
 
    return brsf;
}

References hfp_hf::cid, hfp_hf::control, hfp_hf::cw, hfp_hf::ecnr, HFP_HF_CID, HFP_HF_CONTROL, HFP_HF_CW, HFP_HF_ECNR, HFP_HF_STATUS, HFP_HF_VOICE, HFP_HF_VOLUME, hfp_hf::status, hfp_hf::voice, and hfp_hf::volume.

Referenced by hfp_send_brsf().

hfp_int2brsf()

static struct hfp_ag * hfp_int2brsf ( int  brsf, struct hfp_ag *  ag  )

static

Convert a BRSF int to an hfp_ag struct.

Parameters

brsf	a brsf integer
ag	a AG (hfp_ag) brsf object

Returns

a pointer to the given hfp_ag object populated with the values from the given brsf integer

Definition at line 2492 of file chan_mobile.c.

{
    ag->cw = brsf & HFP_AG_CW ? 1 : 0;
    ag->ecnr = brsf & HFP_AG_ECNR ? 1 : 0;
    ag->voice = brsf & HFP_AG_VOICE ? 1 : 0;
    ag->ring = brsf & HFP_AG_RING ? 1 : 0;
    ag->tag = brsf & HFP_AG_TAG ? 1 : 0;
    ag->reject = brsf & HFP_AG_REJECT ? 1 : 0;
    ag->status = brsf & HFP_AG_STATUS ? 1 : 0;
    ag->control = brsf & HFP_AG_CONTROL ? 1 : 0;
    ag->errors = brsf & HFP_AG_ERRORS ? 1 : 0;
 
    return ag;
}

References hfp_ag::control, hfp_ag::cw, hfp_ag::ecnr, hfp_ag::errors, HFP_AG_CONTROL, HFP_AG_CW, HFP_AG_ECNR, HFP_AG_ERRORS, HFP_AG_REJECT, HFP_AG_RING, HFP_AG_STATUS, HFP_AG_TAG, HFP_AG_VOICE, hfp_ag::reject, hfp_ag::ring, hfp_ag::status, hfp_ag::tag, and hfp_ag::voice.

Referenced by hfp_parse_brsf().

hfp_parse_brsf()

static int hfp_parse_brsf ( struct hfp_pvt *  hfp, const char *  buf  )

static

Parse BRSF data.

Parameters

hfp	an hfp_pvt struct
buf	the buffer to parse (null terminated)

Definition at line 2726 of file chan_mobile.c.

{
    int brsf;
 
    if (!sscanf(buf, "+BRSF:%d", &brsf))
        return -1;
 
    hfp_int2brsf(brsf, &hfp->brsf);
 
    return 0;
}

References hfp_pvt::brsf, buf, and hfp_int2brsf().

Referenced by handle_response_brsf().

hfp_parse_ciev()

static int hfp_parse_ciev ( struct hfp_pvt *  hfp, char *  buf, int *  value  )

static

Parse a CIEV event.

Parameters

hfp	an hfp_pvt struct
buf	the buffer to parse (null terminated)
value	a pointer to an int to store the event value in (can be NULL)

Returns

0 on error (parse error, or unknown event) or a HFP_CIND_* value on success

Definition at line 2197 of file chan_mobile.c.

{
    int i, v;
    if (!value)
        value = &v;
 
    if (!sscanf(buf, "+CIEV: %d,%d", &i, value)) {
        ast_debug(2, "[%s] error parsing CIEV event '%s'\n", hfp->owner->id, buf);
        return HFP_CIND_NONE;
    }
 
    if (i >= ARRAY_LEN(hfp->cind_state)) {
        ast_debug(2, "[%s] CIEV event index too high (%s)\n", hfp->owner->id, buf);
        return HFP_CIND_NONE;
    }
 
    hfp->cind_state[i] = *value;
    return hfp->cind_index[i];
}

References ARRAY_LEN, ast_debug, buf, hfp_pvt::cind_index, hfp_pvt::cind_state, HFP_CIND_NONE, mbl_pvt::id, hfp_pvt::owner, and value.

Referenced by handle_response_ciev().

hfp_parse_cind()

static int hfp_parse_cind ( struct hfp_pvt *  hfp, char *  buf  )

static

Read the result of the AT+CIND? command.

Parameters

hfp	an hfp_pvt struct
buf	the buffer to parse (null terminated)

Note

hfp_send_cind_test() and hfp_parse_cind_test() should be called at least once before this function is called.

Definition at line 2770 of file chan_mobile.c.

{
    int i, state, group;
    size_t s;
    char *indicator = NULL;
 
    /* parse current state of all of our indicators.  The list is in the
     * following format:
     * +CIND: 1,0,2,0,0,0,0
     */
    group = 0;
    state = 0;
    s = strlen(buf);
    for (i = 0; i < s; i++) {
        switch (state) {
        case 0: /* search for start of the status indicators (a space) */
            if (buf[i] == ' ') {
                group++;
                state++;
            }
            break;
        case 1: /* mark this indicator */
            indicator = &buf[i];
            state++;
            break;
        case 2: /* search for the start of the next indicator (a comma) */
            if (buf[i] == ',') {
                buf[i] = '\0';
 
                hfp_parse_cind_indicator(hfp, group, indicator);
 
                group++;
                state = 1;
            }
            break;
        }
    }
 
    /* store the last indicator */
    if (state == 2)
        hfp_parse_cind_indicator(hfp, group, indicator);
 
    return 0;
}

References buf, hfp_parse_cind_indicator(), indicator, NULL, and state.

Referenced by handle_response_cind().

hfp_parse_cind_indicator()

static int hfp_parse_cind_indicator ( struct hfp_pvt *  hfp, int  group, char *  indicator  )

static

Parse and store the given indicator.

Parameters

hfp	an hfp_pvt struct
group	the indicator group
indicator	the indicator to parse

Definition at line 2744 of file chan_mobile.c.

{
    int value;
 
    /* store the current indicator */
    if (group >= ARRAY_LEN(hfp->cind_state)) {
        ast_debug(1, "ignoring CIND state '%s' for group %d, we only support up to %d indicators\n", indicator, group, (int) sizeof(hfp->cind_state));
        return -1;
    }
 
    if (!sscanf(indicator, "%d", &value)) {
        ast_debug(1, "error parsing CIND state '%s' for group %d\n", indicator, group);
        return -1;
    }
 
    hfp->cind_state[group] = value;
    return 0;
}

References ARRAY_LEN, ast_debug, hfp_pvt::cind_state, indicator, and value.

Referenced by hfp_parse_cind().

hfp_parse_cind_test()

static int hfp_parse_cind_test ( struct hfp_pvt *  hfp, char *  buf  )

static

Parse the result of the AT+CIND=? command.

Parameters

hfp	an hfp_pvt struct
buf	the buffer to parse (null terminated)

Definition at line 2820 of file chan_mobile.c.

{
    int i, state, group;
    size_t s;
    char *indicator = NULL;
 
    hfp->nocallsetup = 1;
 
    /* parse the indications list.  It is in the follwing format:
     * +CIND: ("ind1",(0-1)),("ind2",(0-5))
     */
    group = 0;
    state = 0;
    s = strlen(buf);
    for (i = 0; i < s; i++) {
        switch (state) {
        case 0: /* search for start of indicator block */
            if (buf[i] == '(') {
                group++;
                state++;
            }
            break;
        case 1: /* search for '"' in indicator block */
            if (buf[i] == '"') {
                state++;
            }
            break;
        case 2: /* mark the start of the indicator name */
            indicator = &buf[i];
            state++;
            break;
        case 3: /* look for the end of the indicator name */
            if (buf[i] == '"') {
                buf[i] = '\0';
                state++;
            }
            break;
        case 4: /* find the start of the value range */
            if (buf[i] == '(') {
                state++;
            }
            break;
        case 5: /* mark the start of the value range */
            state++;
            break;
        case 6: /* find the end of the value range */
            if (buf[i] == ')') {
                buf[i] = '\0';
                state++;
            }
            break;
        case 7: /* process the values we found */
            if (group < sizeof(hfp->cind_index)) {
                if (!strcmp(indicator, "service")) {
                    hfp->cind_map.service = group;
                    hfp->cind_index[group] = HFP_CIND_SERVICE;
                } else if (!strcmp(indicator, "call")) {
                    hfp->cind_map.call = group;
                    hfp->cind_index[group] = HFP_CIND_CALL;
                } else if (!strcmp(indicator, "callsetup")) {
                    hfp->nocallsetup = 0;
                    hfp->cind_map.callsetup = group;
                    hfp->cind_index[group] = HFP_CIND_CALLSETUP;
                } else if (!strcmp(indicator, "call_setup")) { /* non standard call setup identifier */
                    hfp->nocallsetup = 0;
                    hfp->cind_map.callsetup = group;
                    hfp->cind_index[group] = HFP_CIND_CALLSETUP;
                } else if (!strcmp(indicator, "callheld")) {
                    hfp->cind_map.callheld = group;
                    hfp->cind_index[group] = HFP_CIND_CALLHELD;
                } else if (!strcmp(indicator, "signal")) {
                    hfp->cind_map.signal = group;
                    hfp->cind_index[group] = HFP_CIND_SIGNAL;
                } else if (!strcmp(indicator, "roam")) {
                    hfp->cind_map.roam = group;
                    hfp->cind_index[group] = HFP_CIND_ROAM;
                } else if (!strcmp(indicator, "battchg")) {
                    hfp->cind_map.battchg = group;
                    hfp->cind_index[group] = HFP_CIND_BATTCHG;
                } else {
                    hfp->cind_index[group] = HFP_CIND_UNKNOWN;
                    ast_debug(2, "ignoring unknown CIND indicator '%s'\n", indicator);
                }
            } else {
                    ast_debug(1, "can't store indicator %d (%s), we only support up to %d indicators", group, indicator, (int) sizeof(hfp->cind_index));
            }
 
            state = 0;
            break;
        }
    }
 
    hfp->owner->no_callsetup = hfp->nocallsetup;
 
    return 0;
}

References ast_debug, hfp_cind::battchg, buf, hfp_cind::call, hfp_cind::callheld, hfp_cind::callsetup, hfp_pvt::cind_index, hfp_pvt::cind_map, HFP_CIND_BATTCHG, HFP_CIND_CALL, HFP_CIND_CALLHELD, HFP_CIND_CALLSETUP, HFP_CIND_ROAM, HFP_CIND_SERVICE, HFP_CIND_SIGNAL, HFP_CIND_UNKNOWN, indicator, mbl_pvt::no_callsetup, hfp_pvt::nocallsetup, NULL, hfp_pvt::owner, hfp_cind::roam, hfp_cind::service, hfp_cind::signal, and state.

Referenced by handle_response_cind().

hfp_parse_clip()

static struct cidinfo hfp_parse_clip ( struct hfp_pvt *  hfp, char *  buf  )

static

Parse a CLIP event.

Parameters

hfp	an hfp_pvt struct
buf	the buffer to parse (null terminated)

Note

buf will be modified when the CID string is parsed

Returns

a cidinfo structure pointing to the cnam and cnum data in buf. On parse errors, either or both pointers will point to null strings

Definition at line 2226 of file chan_mobile.c.

{
    int i;
    int tokens[6];
    char *cnamtmp;
    char delim = ' ';   /* First token terminates with space */
    int invalid = 0;    /* Number of invalid chars in cnam */
    struct cidinfo cidinfo = { NULL, NULL };
 
    /* parse clip info in the following format:
     * +CLIP: "123456789",128,...
     */
    ast_debug(3, "[%s] hfp_parse_clip is processing \"%s\"\n", hfp->owner->id, buf);
    tokens[0] = 0;      /* First token starts in position 0 */
    for (i = 1; i < ARRAY_LEN(tokens); i++) {
        tokens[i] = parse_next_token(buf, tokens[i - 1], delim);
        delim = ',';    /* Subsequent tokens terminate with comma */
    }
    ast_debug(3, "[%s] hfp_parse_clip found tokens: 0=%s, 1=%s, 2=%s, 3=%s, 4=%s, 5=%s\n",
        hfp->owner->id, &buf[tokens[0]], &buf[tokens[1]], &buf[tokens[2]],
        &buf[tokens[3]], &buf[tokens[4]], &buf[tokens[5]]);
 
    /* Clean up cnum, and make sure it is legitimate since it is untrusted. */
    cidinfo.cnum = ast_strip_quoted(&buf[tokens[1]], "\"", "\"");
    if (!ast_isphonenumber(cidinfo.cnum)) {
        ast_debug(1, "[%s] hfp_parse_clip invalid cidinfo.cnum data \"%s\" - deleting\n",
            hfp->owner->id, cidinfo.cnum);
        cidinfo.cnum = "";
    }
 
    /*
     * Some docs say tokens 2 and 3 including the commas are optional.
     * If absent, that would move CNAM back to token 3.
     */
    cidinfo.cnam = &buf[tokens[5]]; /* Assume it's in token 5 */
    if (buf[tokens[5]] == '\0' && buf[tokens[4]] == '\0') {
        /* Tokens 4 and 5 are empty.  See if token 3 looks like CNAM (starts with ") */
        i = tokens[3];
        while (buf[i] == ' ') {     /* Find the first non-blank */
            i++;
        }
        if (buf[i] == '"') {
            /* Starts with quote.  Use this for CNAM. */
            cidinfo.cnam = &buf[i];
        }
    }
 
    /* Clean up CNAM. */
    cidinfo.cnam = ast_strip_quoted(cidinfo.cnam, "\"", "\"");
    for (cnamtmp = cidinfo.cnam; *cnamtmp != '\0'; cnamtmp++) {
        if (!strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789-,abcdefghijklmnopqrstuvwxyz_", *cnamtmp)) {
            *cnamtmp = '_'; /* Invalid.  Replace with underscore. */
            invalid++;
        }
    }
    if (invalid) {
        ast_debug(2, "[%s] hfp_parse_clip replaced %d invalid byte(s) in cnam data\n",
            hfp->owner->id, invalid);
    }
    ast_debug(2, "[%s] hfp_parse_clip returns cnum=%s and cnam=%s\n",
        hfp->owner->id, cidinfo.cnum, cidinfo.cnam);
 
    return cidinfo;
}

References ARRAY_LEN, ast_debug, ast_isphonenumber(), ast_strip_quoted(), buf, cidinfo::cnam, cidinfo::cnum, NULL, and parse_next_token().

Referenced by handle_response_clip().

hfp_parse_cmgr()

static int hfp_parse_cmgr ( struct hfp_pvt *  hfp, char *  buf, char **  from_number, char **  text  )

static

Parse a CMGR message.

Parameters

hfp	an hfp_pvt struct
buf	the buffer to parse (null terminated)
from_number	a pointer to a char pointer which will store the from number
text	a pointer to a char pointer which will store the message text

Note

buf will be modified when the CMGR message is parsed

Return values

-1	parse error
0	success

Definition at line 2354 of file chan_mobile.c.

{
    int i, state;
    size_t s;
 
    /* parse cmgr info in the following format:
     * +CMGR: <msg status>,"+123456789",...\r\n
     * <message text>
     */
    state = 0;
    s = strlen(buf);
    for (i = 0; i < s && state != 6; i++) {
        switch (state) {
        case 0: /* search for start of the number section (,) */
            if (buf[i] == ',') {
                state++;
            }
            break;
        case 1: /* find the opening quote (") */
            if (buf[i] == '"') {
                state++;
            }
            break;
        case 2: /* mark the start of the number */
            if (from_number) {
                *from_number = &buf[i];
                state++;
            }
            /* fall through */
        case 3: /* search for the end of the number (") */
            if (buf[i] == '"') {
                buf[i] = '\0';
                state++;
            }
            break;
        case 4: /* search for the start of the message text (\n) */
            if (buf[i] == '\n') {
                state++;
            }
            break;
        case 5: /* mark the start of the message text */
            if (text) {
                *text = &buf[i];
                state++;
            }
            break;
        }
    }
 
    if (state != 6) {
        return -1;
    }
 
    return 0;
}

References buf, state, and text.

Referenced by handle_response_cmgr().

hfp_parse_cmti()

static int hfp_parse_cmti ( struct hfp_pvt *  hfp, char *  buf  )

static

Parse a CMTI notification.

Parameters

hfp	an hfp_pvt struct
buf	the buffer to parse (null terminated)

Note

buf will be modified when the CMTI message is parsed

Returns

-1 on error (parse error) or the index of the new sms message

Definition at line 2328 of file chan_mobile.c.

{
    int index = -1;
 
    /* parse cmti info in the following format:
     * +CMTI: <mem>,<index>
     */
    if (!sscanf(buf, "+CMTI: %*[^,],%d", &index)) {
        ast_debug(2, "[%s] error parsing CMTI event '%s'\n", hfp->owner->id, buf);
        return -1;
    }
 
    return index;
}

References ast_debug, buf, mbl_pvt::id, and hfp_pvt::owner.

Referenced by handle_response_cmti().

hfp_parse_cusd()

static char * hfp_parse_cusd ( struct hfp_pvt *  hfp, char *  buf  )

static

Parse a CUSD answer.

Parameters

hfp	an hfp_pvt struct
buf	the buffer to parse (null terminated)

Note

buf will be modified when the CUSD string is parsed

Returns

NULL on error (parse error) or a pointer to the cusd message information in buf

Definition at line 2418 of file chan_mobile.c.

{
    int i, message_start, message_end;
    char *cusd;
    size_t s;
 
    /* parse cusd message in the following format:
     * +CUSD: 0,"100,00 EURO, valid till 01.01.2010, you are using tariff "Mega Tariff". More informations *111#."
     */
    message_start = 0;
    message_end = 0;
    s = strlen(buf);
 
    /* Find the start of the message (") */
    for (i = 0; i < s; i++) {
        if (buf[i] == '"') {
            message_start = i + 1;
            break;
        }
    }
 
    if (message_start == 0 || message_start >= s) {
        return NULL;
    }
 
    /* Find the end of the message (") */
    for (i = s; i > 0; i--) {
        if (buf[i] == '"') {
            message_end = i;
            break;
        }
    }
 
    if (message_end == 0) {
        return NULL;
    }
 
    if (message_start >= message_end) {
        return NULL;
    }
 
    cusd = &buf[message_start];
    buf[message_end] = '\0';
 
    return cusd;
}

References buf, and NULL.

Referenced by handle_response_cusd().

hfp_parse_ecav()

static int hfp_parse_ecav ( struct hfp_pvt *  hfp, char *  buf  )

static

Parse a ECAV event.

Parameters

hfp	an hfp_pvt struct
buf	the buffer to parse (null terminated)

Returns

-1 on error (parse error) or a ECAM value on success

Example:

*ECAV: <ccid>,<ccstatus>,<calltype>[,<processid>]
                 [,exitcause][,<number>,<type>] 

Example indicating busy:

*ECAV: 1,7,1 

Definition at line 2166 of file chan_mobile.c.

{
    int ccid = 0;
    int ccstatus = 0;
    int calltype = 0;
 
    if (!sscanf(buf, "*ECAV: %2d,%2d,%2d", &ccid, &ccstatus, &calltype)) {
        ast_debug(1, "[%s] error parsing ECAV event '%s'\n", hfp->owner->id, buf);
        return -1;
    }
 
    return ccstatus;
}

References ast_debug, buf, mbl_pvt::id, and hfp_pvt::owner.

Referenced by do_monitor_phone().

hfp_send_ata()

static int hfp_send_ata ( struct hfp_pvt *  hfp )

static

Send ATA.

Parameters

hfp	an hfp_pvt struct

Definition at line 2704 of file chan_mobile.c.

{
    return rfcomm_write(hfp->rsock, "ATA\r");
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by mbl_answer().

hfp_send_atd()

static int hfp_send_atd ( struct hfp_pvt *  hfp, const char *  number  )

static

Send ATD.

Parameters

hfp	an hfp_pvt struct
number	the number to send

Definition at line 2693 of file chan_mobile.c.

{
    char cmd[64];
    snprintf(cmd, sizeof(cmd), "ATD%s;\r", number);
    return rfcomm_write(hfp->rsock, cmd);
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by mbl_call().

hfp_send_brsf()

static int hfp_send_brsf ( struct hfp_pvt *  hfp, struct hfp_hf *  brsf  )

static

Send a BRSF request.

Parameters

hfp	an hfp_pvt struct
brsf	an hfp_hf brsf struct

Return values

0	on success
-1	on error

Definition at line 2516 of file chan_mobile.c.

{
    char cmd[32];
    snprintf(cmd, sizeof(cmd), "AT+BRSF=%d\r", hfp_brsf2int(brsf));
    return rfcomm_write(hfp->rsock, cmd);
}

References hfp_brsf2int(), rfcomm_write(), and hfp_pvt::rsock.

Referenced by do_monitor_phone().

hfp_send_chup()

static int hfp_send_chup ( struct hfp_pvt *  hfp )

static

Send AT+CHUP.

Parameters

hfp	an hfp_pvt struct

Definition at line 2683 of file chan_mobile.c.

{
    return rfcomm_write(hfp->rsock, "AT+CHUP\r");
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by handle_response_clip(), and mbl_hangup().

hfp_send_cind()

static int hfp_send_cind ( struct hfp_pvt *  hfp )

static

Send the CIND read command.

Parameters

hfp	an hfp_pvt struct

Definition at line 2527 of file chan_mobile.c.

{
    return rfcomm_write(hfp->rsock, "AT+CIND?\r");
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by handle_response_ok().

hfp_send_cind_test()

static int hfp_send_cind_test ( struct hfp_pvt *  hfp )

static

Send the CIND test command.

Parameters

hfp	an hfp_pvt struct

Definition at line 2536 of file chan_mobile.c.

{
    return rfcomm_write(hfp->rsock, "AT+CIND=?\r");
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by handle_response_ok().

hfp_send_clip()

static int hfp_send_clip ( struct hfp_pvt *  hfp, int  status  )

static

Enable or disable calling line identification.

Parameters

hfp	an hfp_pvt struct
status	enable or disable calling line identification (should be 1 or 0)

Definition at line 2585 of file chan_mobile.c.

{
    char cmd[32];
    snprintf(cmd, sizeof(cmd), "AT+CLIP=%d\r", status ? 1 : 0);
    return rfcomm_write(hfp->rsock, cmd);
}

References rfcomm_write(), hfp_pvt::rsock, and status.

Referenced by handle_response_ok().

hfp_send_cmer()

static int hfp_send_cmer ( struct hfp_pvt *  hfp, int  status  )

static

Enable or disable indicator events reporting.

Parameters

hfp	an hfp_pvt struct
status	enable or disable events reporting (should be 1 or 0)

Definition at line 2546 of file chan_mobile.c.

{
    char cmd[32];
    snprintf(cmd, sizeof(cmd), "AT+CMER=3,0,0,%d\r", status ? 1 : 0);
    return rfcomm_write(hfp->rsock, cmd);
}

References rfcomm_write(), hfp_pvt::rsock, and status.

Referenced by handle_response_ok().

hfp_send_cmgf()

static int hfp_send_cmgf ( struct hfp_pvt *  hfp, int  mode  )

static

Set the SMS mode.

Parameters

hfp	an hfp_pvt struct
mode	the sms mode (0 = PDU, 1 = Text)

Definition at line 2627 of file chan_mobile.c.

{
    char cmd[32];
    snprintf(cmd, sizeof(cmd), "AT+CMGF=%d\r", mode);
    return rfcomm_write(hfp->rsock, cmd);
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by handle_response_error(), and handle_response_ok().

hfp_send_cmgr()

static int hfp_send_cmgr ( struct hfp_pvt *  hfp, int  index  )

static

Read an SMS message.

Parameters

hfp	an hfp_pvt struct
index	the location of the requested message

Definition at line 2648 of file chan_mobile.c.

{
    char cmd[32];
    snprintf(cmd, sizeof(cmd), "AT+CMGR=%d\r", index);
    return rfcomm_write(hfp->rsock, cmd);
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by handle_response_cmti().

hfp_send_cmgs()

static int hfp_send_cmgs ( struct hfp_pvt *  hfp, const char *  number  )

static

Start sending an SMS message.

Parameters

hfp	an hfp_pvt struct
number	the destination of the message

Definition at line 2660 of file chan_mobile.c.

{
    char cmd[64];
    snprintf(cmd, sizeof(cmd), "AT+CMGS=\"%s\"\r", number);
    return rfcomm_write(hfp->rsock, cmd);
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by mbl_sendsms_exec().

hfp_send_cnmi()

static int hfp_send_cnmi ( struct hfp_pvt *  hfp )

static

Setup SMS new message indication.

Parameters

hfp	an hfp_pvt struct

Definition at line 2638 of file chan_mobile.c.

{
    return rfcomm_write(hfp->rsock, "AT+CNMI=2,1,0,0,0\r");
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by handle_response_ok().

hfp_send_cusd()

static int hfp_send_cusd ( struct hfp_pvt *  hfp, const char *  code  )

static

Send CUSD.

Parameters

hfp	an hfp_pvt struct
code	the CUSD code to send

Definition at line 2714 of file chan_mobile.c.

{
    char cmd[128];
    snprintf(cmd, sizeof(cmd), "AT+CUSD=1,\"%s\",15\r", code);
    return rfcomm_write(hfp->rsock, cmd);
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by handle_cli_mobile_cusd().

hfp_send_dtmf()

static int hfp_send_dtmf ( struct hfp_pvt *  hfp, char  digit  )

static

Send a DTMF command.

Parameters

hfp	an hfp_pvt struct
digit	the dtmf digit to send

Returns

the result of rfcomm_write() or -1 on an invalid digit being sent

Definition at line 2598 of file chan_mobile.c.

{
    char cmd[10];
 
    switch(digit) {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case '*':
    case '#':
        snprintf(cmd, sizeof(cmd), "AT+VTS=%c\r", digit);
        return rfcomm_write(hfp->rsock, cmd);
    default:
        return -1;
    }
}

References digit, rfcomm_write(), and hfp_pvt::rsock.

Referenced by mbl_digit_end().

hfp_send_ecam()

static int hfp_send_ecam ( struct hfp_pvt *  hfp )

static

Enable Sony Ericsson extensions / indications.

Parameters

hfp	an hfp_pvt struct

Definition at line 2184 of file chan_mobile.c.

{
    return rfcomm_write(hfp->rsock, "AT*ECAM=1\r");
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by handle_response_ok().

hfp_send_sms_text()

static int hfp_send_sms_text ( struct hfp_pvt *  hfp, const char *  message  )

static

Send the text of an SMS message.

Parameters

hfp	an hfp_pvt struct
message	the text of the message

Definition at line 2672 of file chan_mobile.c.

{
    char cmd[162];
    snprintf(cmd, sizeof(cmd), "%.160s\x1a", message);
    return rfcomm_write(hfp->rsock, cmd);
}

References rfcomm_write(), and hfp_pvt::rsock.

Referenced by handle_sms_prompt().

hfp_send_vgs()

static int hfp_send_vgs ( struct hfp_pvt *  hfp, int  value  )

static

Send the current speaker gain level.

Parameters

hfp	an hfp_pvt struct
value	the value to send (must be between 0 and 15)

Definition at line 2558 of file chan_mobile.c.

{
    char cmd[32];
    snprintf(cmd, sizeof(cmd), "AT+VGS=%d\r", value);
    return rfcomm_write(hfp->rsock, cmd);
}

References rfcomm_write(), hfp_pvt::rsock, and value.

Referenced by handle_response_error(), and handle_response_ok().

hsp_send_error()

static int hsp_send_error ( int  rsock )

static

Send an ERROR AT response.

Parameters

rsock

the rfcomm socket to use

Definition at line 2935 of file chan_mobile.c.

{
    return rfcomm_write(rsock, "\r\nERROR\r\n");
}

References rfcomm_write().

Referenced by do_monitor_headset().

hsp_send_ok()

static int hsp_send_ok ( int  rsock )

static

Send an OK AT response.

Parameters

rsock

the rfcomm socket to use

Definition at line 2926 of file chan_mobile.c.

{
    return rfcomm_write(rsock, "\r\nOK\r\n");
}

References rfcomm_write().

Referenced by do_monitor_headset().

hsp_send_ring()

static int hsp_send_ring ( int  rsock )

static

Send a RING unsolicited AT response.

Parameters

rsock

the rfcomm socket to use

Definition at line 2968 of file chan_mobile.c.

{
    return rfcomm_write(rsock, "\r\nRING\r\n");
}

References rfcomm_write().

Referenced by headset_send_ring(), and mbl_call().

hsp_send_vgm()

static int hsp_send_vgm ( int  rsock, int  gain  )

static

Send a microphone gain unsolicited AT response.

Parameters

rsock	the rfcomm socket to use
gain	the microphone gain value

Definition at line 2957 of file chan_mobile.c.

{
    char cmd[32];
    snprintf(cmd, sizeof(cmd), "\r\n+VGM=%d\r\n", gain);
    return rfcomm_write(rsock, cmd);
}

References rfcomm_write().

Referenced by do_monitor_headset().

hsp_send_vgs()

static int hsp_send_vgs ( int  rsock, int  gain  )

static

Send a speaker gain unsolicited AT response.

Parameters

rsock	the rfcomm socket to use
gain	the speaker gain value

Definition at line 2945 of file chan_mobile.c.

{
    char cmd[32];
    snprintf(cmd, sizeof(cmd), "\r\n+VGS=%d\r\n", gain);
    return rfcomm_write(rsock, cmd);
}

References rfcomm_write().

Referenced by do_monitor_headset().

load_module()

static int load_module ( void  )

static

Definition at line 4778 of file chan_mobile.c.

{
 
    int dev_id, s;
 
    if (!(mbl_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_format_cap_append(mbl_tech.capabilities, DEVICE_FRAME_FORMAT, 0);
    /* Check if we have Bluetooth, no point loading otherwise... */
    dev_id = hci_get_route(NULL);
 
    s = hci_open_dev(dev_id);
    if (dev_id < 0 || s < 0) {
        ast_log(LOG_ERROR, "No Bluetooth devices found. Not loading module.\n");
        ao2_ref(mbl_tech.capabilities, -1);
        mbl_tech.capabilities = NULL;
        hci_close_dev(s);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    hci_close_dev(s);
 
    if (mbl_load_config()) {
        ast_log(LOG_ERROR, "Errors reading config file %s. Not loading module.\n", MBL_CONFIG);
        ao2_ref(mbl_tech.capabilities, -1);
        mbl_tech.capabilities = NULL;
        return AST_MODULE_LOAD_DECLINE;
    }
 
    sdp_session = sdp_register();
 
    /* Spin the discovery thread */
    if (ast_pthread_create_background(&discovery_thread, NULL, do_discovery, NULL) < 0) {
        ast_log(LOG_ERROR, "Unable to create discovery thread.\n");
        goto e_cleanup;
    }
 
    /* register our channel type */
    if (ast_channel_register(&mbl_tech)) {
        ast_log(LOG_ERROR, "Unable to register channel class %s\n", "Mobile");
        goto e_cleanup;
    }
 
    ast_cli_register_multiple(mbl_cli, sizeof(mbl_cli) / sizeof(mbl_cli[0]));
    ast_register_application(app_mblstatus, mbl_status_exec, mblstatus_synopsis, mblstatus_desc);
    ast_register_application(app_mblsendsms, mbl_sendsms_exec, mblsendsms_synopsis, mblsendsms_desc);
 
    return AST_MODULE_LOAD_SUCCESS;
 
e_cleanup:
    unload_module();
 
    return AST_MODULE_LOAD_DECLINE;
}

References ao2_ref, app_mblsendsms, app_mblstatus, ast_channel_register(), ast_cli_register_multiple, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_log, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_pthread_create_background, ast_register_application, ast_channel_tech::capabilities, adapter_pvt::dev_id, DEVICE_FRAME_FORMAT, discovery_thread, do_discovery(), LOG_ERROR, mbl_cli, MBL_CONFIG, mbl_load_config(), mbl_sendsms_exec(), mbl_status_exec(), mbl_tech, mblsendsms_desc, mblsendsms_synopsis, mblstatus_desc, mblstatus_synopsis, NULL, sdp_register(), sdp_session, and unload_module().

mbl_answer()

static int mbl_answer ( struct ast_channel *  ast )

static

Definition at line 1066 of file chan_mobile.c.

{
 
    struct mbl_pvt *pvt;
 
    pvt = ast_channel_tech_pvt(ast);
 
    if (pvt->type == MBL_TYPE_HEADSET)
        return 0;
 
    ast_mutex_lock(&pvt->lock);
    if (pvt->incoming) {
        hfp_send_ata(pvt->hfp);
        msg_queue_push(pvt, AT_OK, AT_A);
        pvt->answered = 1;
    }
    ast_mutex_unlock(&pvt->lock);
 
    return 0;
 
}

References mbl_pvt::answered, ast_channel_tech_pvt(), ast_mutex_lock, ast_mutex_unlock, AT_A, AT_OK, mbl_pvt::hfp, hfp_send_ata(), mbl_pvt::incoming, mbl_pvt::lock, MBL_TYPE_HEADSET, msg_queue_push(), and mbl_pvt::type.

mbl_ast_hangup()

static int mbl_ast_hangup ( struct mbl_pvt *  pvt )

static

Definition at line 1354 of file chan_mobile.c.

{
    ast_hangup(pvt->owner);
    return 0;
}

References ast_hangup(), and mbl_pvt::owner.

Referenced by handle_response_clip(), and handle_response_cmgr().

mbl_call()

static int mbl_call ( struct ast_channel *  ast, const char *  dest, int  timeout  )

static

Definition at line 970 of file chan_mobile.c.

{
    struct mbl_pvt *pvt;
    char *dest_dev;
    char *dest_num = NULL;
 
    dest_dev = ast_strdupa(dest);
 
    pvt = ast_channel_tech_pvt(ast);
 
    if (pvt->type == MBL_TYPE_PHONE) {
        dest_num = strchr(dest_dev, '/');
        if (!dest_num) {
            ast_log(LOG_WARNING, "Cant determine destination number.\n");
            return -1;
        }
        *dest_num++ = 0x00;
    }
 
    if ((ast_channel_state(ast) != AST_STATE_DOWN) && (ast_channel_state(ast) != AST_STATE_RESERVED)) {
        ast_log(LOG_WARNING, "mbl_call called on %s, neither down nor reserved\n", ast_channel_name(ast));
        return -1;
    }
 
    ast_debug(1, "Calling %s on %s\n", dest, ast_channel_name(ast));
 
    ast_mutex_lock(&pvt->lock);
    if (pvt->type == MBL_TYPE_PHONE) {
        if (hfp_send_atd(pvt->hfp, dest_num)) {
            ast_mutex_unlock(&pvt->lock);
            ast_log(LOG_ERROR, "error sending ATD command on %s\n", pvt->id);
            return -1;
        }
        pvt->hangupcause = 0;
        pvt->needchup = 1;
        msg_queue_push(pvt, AT_OK, AT_D);
    } else {
        if (hsp_send_ring(pvt->rfcomm_socket)) {
            ast_log(LOG_ERROR, "[%s] error ringing device\n", pvt->id);
            ast_mutex_unlock(&pvt->lock);
            return -1;
        }
 
        if ((pvt->ring_sched_id = ast_sched_add(pvt->sched, 6000, headset_send_ring, pvt)) == -1) {
            ast_log(LOG_ERROR, "[%s] error ringing device\n", pvt->id);
            ast_mutex_unlock(&pvt->lock);
            return -1;
        }
 
        pvt->outgoing = 1;
        pvt->needring = 1;
    }
    ast_mutex_unlock(&pvt->lock);
 
    return 0;
 
}

References ast_channel_name(), ast_channel_tech_pvt(), ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_sched_add(), AST_STATE_DOWN, AST_STATE_RESERVED, ast_strdupa, AT_D, AT_OK, mbl_pvt::hangupcause, headset_send_ring(), mbl_pvt::hfp, hfp_send_atd(), hsp_send_ring(), mbl_pvt::id, mbl_pvt::lock, LOG_ERROR, LOG_WARNING, MBL_TYPE_PHONE, msg_queue_push(), mbl_pvt::needchup, mbl_pvt::needring, NULL, mbl_pvt::outgoing, mbl_pvt::rfcomm_socket, mbl_pvt::ring_sched_id, mbl_pvt::sched, and mbl_pvt::type.

mbl_devicestate()

static int mbl_devicestate ( const char *  data )

static

Definition at line 1214 of file chan_mobile.c.

{
 
    char *device;
    int res = AST_DEVICE_INVALID;
    struct mbl_pvt *pvt;
 
    device = ast_strdupa(S_OR(data, ""));
 
    ast_debug(1, "Checking device state for device %s\n", device);
 
    AST_RWLIST_RDLOCK(&devices);
    AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
        if (!strcmp(pvt->id, device))
            break;
    }
    AST_RWLIST_UNLOCK(&devices);
 
    if (!pvt)
        return res;
 
    ast_mutex_lock(&pvt->lock);
    if (pvt->connected) {
        if (pvt->owner)
            res = AST_DEVICE_INUSE;
        else
            res = AST_DEVICE_NOT_INUSE;
 
        if (!mbl_has_service(pvt))
            res = AST_DEVICE_UNAVAILABLE;
    }
    ast_mutex_unlock(&pvt->lock);
 
    return res;
 
}

References ast_debug, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_UNAVAILABLE, ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdupa, mbl_pvt::connected, mbl_pvt::id, mbl_pvt::lock, mbl_has_service(), mbl_pvt::owner, and S_OR.

mbl_digit_end()

static int mbl_digit_end ( struct ast_channel *  ast, char  digit, unsigned int  duration  )

static

Definition at line 1088 of file chan_mobile.c.

{
    struct mbl_pvt *pvt = ast_channel_tech_pvt(ast);
 
    if (pvt->type == MBL_TYPE_HEADSET)
        return 0;
 
    ast_mutex_lock(&pvt->lock);
    if (hfp_send_dtmf(pvt->hfp, digit)) {
        ast_mutex_unlock(&pvt->lock);
        ast_debug(1, "[%s] error sending digit %c\n", pvt->id, digit);
        return -1;
    }
    msg_queue_push(pvt, AT_OK, AT_VTS);
    ast_mutex_unlock(&pvt->lock);
 
    ast_debug(1, "[%s] dialed %c\n", pvt->id, digit);
 
    return 0;
}

References ast_channel_tech_pvt(), ast_debug, ast_mutex_lock, ast_mutex_unlock, AT_OK, AT_VTS, digit, mbl_pvt::hfp, hfp_send_dtmf(), mbl_pvt::id, mbl_pvt::lock, MBL_TYPE_HEADSET, msg_queue_push(), and mbl_pvt::type.

mbl_fixup()

static int mbl_fixup ( struct ast_channel *  oldchan, struct ast_channel *  newchan  )

static

Definition at line 1195 of file chan_mobile.c.

{
 
    struct mbl_pvt *pvt = ast_channel_tech_pvt(newchan);
 
    if (!pvt) {
        ast_debug(1, "fixup failed, no pvt on newchan\n");
        return -1;
    }
 
    ast_mutex_lock(&pvt->lock);
    if (pvt->owner == oldchan)
        pvt->owner = newchan;
    ast_mutex_unlock(&pvt->lock);
 
    return 0;
 
}

References ast_channel_tech_pvt(), ast_debug, ast_mutex_lock, ast_mutex_unlock, mbl_pvt::lock, and mbl_pvt::owner.

mbl_hangup()

static int mbl_hangup ( struct ast_channel *  ast )

static

Definition at line 1028 of file chan_mobile.c.

{
 
    struct mbl_pvt *pvt;
 
    if (!ast_channel_tech_pvt(ast)) {
        ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
        return 0;
    }
    pvt = ast_channel_tech_pvt(ast);
 
    ast_debug(1, "[%s] hanging up device\n", pvt->id);
 
    ast_mutex_lock(&pvt->lock);
    ast_channel_set_fd(ast, 0, -1);
    close(pvt->sco_socket);
    pvt->sco_socket = -1;
 
    if (pvt->needchup) {
        hfp_send_chup(pvt->hfp);
        msg_queue_push(pvt, AT_OK, AT_CHUP);
        pvt->needchup = 0;
    }
 
    pvt->outgoing = 0;
    pvt->incoming = 0;
    pvt->needring = 0;
    pvt->owner = NULL;
    ast_channel_tech_pvt_set(ast, NULL);
 
    ast_mutex_unlock(&pvt->lock);
 
    ast_setstate(ast, AST_STATE_DOWN);
 
    return 0;
 
}

References ast_channel_set_fd(), ast_channel_tech_pvt(), ast_channel_tech_pvt_set(), ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_setstate(), AST_STATE_DOWN, AT_CHUP, AT_OK, mbl_pvt::hfp, hfp_send_chup(), mbl_pvt::id, mbl_pvt::incoming, mbl_pvt::lock, LOG_WARNING, msg_queue_push(), mbl_pvt::needchup, mbl_pvt::needring, NULL, mbl_pvt::outgoing, mbl_pvt::owner, and mbl_pvt::sco_socket.

mbl_has_service()

static int mbl_has_service ( struct mbl_pvt *  pvt )

static

Check if a mobile device has service.

Parameters

pvt	a mbl_pvt struct

Return values

1	this device has service
0	no service

Note

This function will always indicate that service is available if the given device does not support service indication.

Definition at line 1369 of file chan_mobile.c.

{
 
    if (pvt->type != MBL_TYPE_PHONE)
        return 1;
 
    if (!pvt->hfp->cind_map.service)
        return 1;
 
    if (pvt->hfp->cind_state[pvt->hfp->cind_map.service] == HFP_CIND_SERVICE_AVAILABLE)
        return 1;
 
    return 0;
}

References hfp_pvt::cind_map, hfp_pvt::cind_state, mbl_pvt::hfp, HFP_CIND_SERVICE_AVAILABLE, MBL_TYPE_PHONE, hfp_cind::service, and mbl_pvt::type.

Referenced by handle_cli_mobile_show_devices(), mbl_devicestate(), and mbl_request().

mbl_load_adapter()

static struct adapter_pvt * mbl_load_adapter ( struct ast_config *  cfg, const char *  cat  )

static

Load an adapter from the configuration file.

Parameters

cfg	the config to load the adapter from
cat	the adapter to load

This function loads the given adapter and starts the sco listener thread for that adapter.

Returns

NULL on error, a pointer to the adapter that was loaded on success

Definition at line 4366 of file chan_mobile.c.

{
    const char *id, *address;
    struct adapter_pvt *adapter;
    struct ast_variable *v;
    struct hci_dev_req dr;
    uint16_t vs;
 
    id = ast_variable_retrieve(cfg, cat, "id");
    address = ast_variable_retrieve(cfg, cat, "address");
 
    if (ast_strlen_zero(id) || ast_strlen_zero(address)) {
        ast_log(LOG_ERROR, "Skipping adapter. Missing id or address settings.\n");
        goto e_return;
    }
 
    ast_debug(1, "Reading configuration for adapter %s %s.\n", id, address);
 
    if (!(adapter = ast_calloc(1, sizeof(*adapter)))) {
        ast_log(LOG_ERROR, "Skipping adapter %s. Error allocating memory.\n", id);
        goto e_return;
    }
 
    ast_copy_string(adapter->id, id, sizeof(adapter->id));
    str2ba(address, &adapter->addr);
 
    /* attempt to connect to the adapter */
    adapter->dev_id = hci_devid(address);
    adapter->hci_socket = hci_open_dev(adapter->dev_id);
    if (adapter->dev_id < 0 || adapter->hci_socket < 0) {
        ast_log(LOG_ERROR, "Skipping adapter %s. Unable to communicate with adapter.\n", adapter->id);
        goto e_free_adapter;
    }
 
    /* check voice setting */
    hci_read_voice_setting(adapter->hci_socket, &vs, 1000);
    vs = htobs(vs);
    if (vs != 0x0060) {
        ast_log(LOG_ERROR, "Skipping adapter %s. Voice setting must be 0x0060 - see 'man hciconfig' for details.\n", adapter->id);
        goto e_hci_close_dev;
    }
 
    for (v = ast_variable_browse(cfg, cat); v; v = v->next) {
        if (!strcasecmp(v->name, "forcemaster")) {
            if (ast_true(v->value)) {
                dr.dev_id = adapter->dev_id;
                if (hci_strtolm("master", &dr.dev_opt)) {
                    if (ioctl(adapter->hci_socket, HCISETLINKMODE, (unsigned long) &dr) < 0) {
                        ast_log(LOG_WARNING, "Unable to set adapter %s link mode to MASTER. Ignoring 'forcemaster' option.\n", adapter->id);
                    }
                }
            }
        } else if (!strcasecmp(v->name, "alignmentdetection")) {
            adapter->alignment_detection = ast_true(v->value);
        }
    }
 
    /* create io contexts */
    if (!(adapter->accept_io = io_context_create())) {
        ast_log(LOG_ERROR, "Unable to create I/O context for audio connection listener\n");
        goto e_hci_close_dev;
    }
 
    if (!(adapter->io = io_context_create())) {
        ast_log(LOG_ERROR, "Unable to create I/O context for audio connections\n");
        goto e_destroy_accept_io;
    }
 
    /* bind the sco listener socket */
    if (sco_bind(adapter) < 0) {
        ast_log(LOG_ERROR, "Skipping adapter %s. Error binding audio connection listener socket.\n", adapter->id);
        goto e_destroy_io;
    }
 
    /* add the socket to the io context */
    if (!(adapter->sco_id = ast_io_add(adapter->accept_io, adapter->sco_socket, sco_accept, AST_IO_IN, adapter))) {
        ast_log(LOG_ERROR, "Skipping adapter %s. Error adding listener socket to I/O context.\n", adapter->id);
        goto e_close_sco;
    }
 
    /* start the sco listener for this adapter */
    if (ast_pthread_create_background(&adapter->sco_listener_thread, NULL, do_sco_listen, adapter)) {
        ast_log(LOG_ERROR, "Skipping adapter %s. Error creating audio connection listener thread.\n", adapter->id);
        goto e_remove_sco;
    }
 
    /* add the adapter to our global list */
    AST_RWLIST_WRLOCK(&adapters);
    AST_RWLIST_INSERT_HEAD(&adapters, adapter, entry);
    AST_RWLIST_UNLOCK(&adapters);
    ast_debug(1, "Loaded adapter %s %s.\n", adapter->id, address);
 
    return adapter;
 
e_remove_sco:
    ast_io_remove(adapter->accept_io, adapter->sco_id);
e_close_sco:
    close(adapter->sco_socket);
e_destroy_io:
    io_context_destroy(adapter->io);
e_destroy_accept_io:
    io_context_destroy(adapter->accept_io);
e_hci_close_dev:
    hci_close_dev(adapter->hci_socket);
e_free_adapter:
    ast_free(adapter);
e_return:
    return NULL;
}

References adapter_pvt::accept_io, adapter_pvt::addr, adapter_pvt::alignment_detection, ast_calloc, ast_copy_string(), ast_debug, ast_free, ast_io_add(), AST_IO_IN, ast_io_remove(), ast_log, ast_pthread_create_background, AST_RWLIST_INSERT_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero(), ast_true(), ast_variable_browse(), ast_variable_retrieve(), adapter_pvt::dev_id, do_sco_listen(), dr, adapter_pvt::hci_socket, adapter_pvt::id, id, adapter_pvt::io, io_context_create(), io_context_destroy(), LOG_ERROR, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, sco_accept(), sco_bind(), adapter_pvt::sco_id, adapter_pvt::sco_listener_thread, adapter_pvt::sco_socket, and ast_variable::value.

Referenced by mbl_load_config().

mbl_load_config()

static int mbl_load_config ( void  )

static

Definition at line 4626 of file chan_mobile.c.

{
    struct ast_config *cfg;
    const char *cat;
    struct ast_variable *v;
    struct ast_flags config_flags = { 0 };
 
    cfg = ast_config_load(MBL_CONFIG, config_flags);
    if (!cfg) {
        cfg = ast_config_load(MBL_CONFIG_OLD, config_flags);
    }
    if (!cfg)
        return -1;
 
    /* parse [general] section */
    for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
        if (!strcasecmp(v->name, "interval")) {
            if (!sscanf(v->value, "%d", &discovery_interval)) {
                ast_log(LOG_NOTICE, "error parsing 'interval' in general section, using default value\n");
            }
        }
    }
 
    /* load adapters */
    for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) {
        if (!strcasecmp(cat, "adapter")) {
            mbl_load_adapter(cfg, cat);
        }
    }
 
    if (AST_RWLIST_EMPTY(&adapters)) {
        ast_log(LOG_ERROR,
            "***********************************************************************\n"
            "No adapters could be loaded from the configuration file.\n"
            "Please review mobile.conf. See sample for details.\n"
            "***********************************************************************\n"
               );
        ast_config_destroy(cfg);
        return -1;
    }
 
    /* now load devices */
    for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) {
        if (strcasecmp(cat, "general") && strcasecmp(cat, "adapter")) {
            mbl_load_device(cfg, cat);
        }
    }
 
    ast_config_destroy(cfg);
 
    return 0;
}

References ast_category_browse(), ast_config_destroy(), ast_config_load, ast_log, AST_RWLIST_EMPTY, ast_variable_browse(), discovery_interval, LOG_ERROR, LOG_NOTICE, MBL_CONFIG, MBL_CONFIG_OLD, mbl_load_adapter(), mbl_load_device(), ast_variable::name, ast_variable::next, NULL, and ast_variable::value.

Referenced by load_module().

mbl_load_device()

static struct mbl_pvt * mbl_load_device ( struct ast_config *  cfg, const char *  cat  )

static

Load a device from the configuration file.

Parameters

cfg	the config to load the device from
cat	the device to load

Returns

NULL on error, a pointer to the device that was loaded on success

Definition at line 4482 of file chan_mobile.c.

{
    struct mbl_pvt *pvt;
    struct adapter_pvt *adapter;
    struct ast_variable *v;
    const char *address, *adapter_str, *port;
    ast_debug(1, "Reading configuration for device %s.\n", cat);
 
    adapter_str = ast_variable_retrieve(cfg, cat, "adapter");
    if(ast_strlen_zero(adapter_str)) {
        ast_log(LOG_ERROR, "Skipping device %s. No adapter specified.\n", cat);
        goto e_return;
    }
 
    /* find the adapter */
    AST_RWLIST_RDLOCK(&adapters);
    AST_RWLIST_TRAVERSE(&adapters, adapter, entry) {
        if (!strcmp(adapter->id, adapter_str))
            break;
    }
    AST_RWLIST_UNLOCK(&adapters);
    if (!adapter) {
        ast_log(LOG_ERROR, "Skipping device %s. Unknown adapter '%s' specified.\n", cat, adapter_str);
        goto e_return;
    }
 
    address = ast_variable_retrieve(cfg, cat, "address");
    port = ast_variable_retrieve(cfg, cat, "port");
    if (ast_strlen_zero(port) || ast_strlen_zero(address)) {
        ast_log(LOG_ERROR, "Skipping device %s. Missing required port or address setting.\n", cat);
        goto e_return;
    }
 
    /* create and initialize our pvt structure */
    if (!(pvt = ast_calloc(1, sizeof(*pvt)))) {
        ast_log(LOG_ERROR, "Skipping device %s. Error allocating memory.\n", cat);
        goto e_return;
    }
 
    ast_mutex_init(&pvt->lock);
    AST_LIST_HEAD_INIT_NOLOCK(&pvt->msg_queue);
 
    /* set some defaults */
 
    pvt->type = MBL_TYPE_PHONE;
    ast_copy_string(pvt->context, "default", sizeof(pvt->context));
 
    /* populate the pvt structure */
    pvt->adapter = adapter;
    ast_copy_string(pvt->id, cat, sizeof(pvt->id));
    str2ba(address, &pvt->addr);
    pvt->timeout = -1;
    pvt->rfcomm_socket = -1;
    pvt->rfcomm_port = atoi(port);
    pvt->sco_socket = -1;
    pvt->monitor_thread = AST_PTHREADT_NULL;
    pvt->ring_sched_id = -1;
    pvt->has_sms = 1;
 
    /* setup the bt_out_smoother */
    if (!(pvt->bt_out_smoother = ast_smoother_new(DEVICE_FRAME_SIZE))) {
        ast_log(LOG_ERROR, "Skipping device %s. Error setting up frame bt_out_smoother.\n", cat);
        goto e_free_pvt;
    }
 
    /* setup the bt_in_smoother */
    if (!(pvt->bt_in_smoother = ast_smoother_new(CHANNEL_FRAME_SIZE))) {
        ast_log(LOG_ERROR, "Skipping device %s. Error setting up frame bt_in_smoother.\n", cat);
        goto e_free_bt_out_smoother;
    }
 
    /* setup the dsp */
    if (!(pvt->dsp = ast_dsp_new())) {
        ast_log(LOG_ERROR, "Skipping device %s. Error setting up dsp for dtmf detection.\n", cat);
        goto e_free_bt_in_smoother;
    }
 
    /* setup the scheduler */
    if (!(pvt->sched = ast_sched_context_create())) {
        ast_log(LOG_ERROR, "Unable to create scheduler context for headset device\n");
        goto e_free_dsp;
    }
 
    ast_dsp_set_features(pvt->dsp, DSP_FEATURE_DIGIT_DETECT);
    ast_dsp_set_digitmode(pvt->dsp, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF);
 
    for (v = ast_variable_browse(cfg, cat); v; v = v->next) {
        if (!strcasecmp(v->name, "type")) {
            if (!strcasecmp(v->value, "headset"))
                pvt->type = MBL_TYPE_HEADSET;
            else
                pvt->type = MBL_TYPE_PHONE;
        } else if (!strcasecmp(v->name, "context")) {
            ast_copy_string(pvt->context, v->value, sizeof(pvt->context));
        } else if (!strcasecmp(v->name, "group")) {
            /* group is set to 0 if invalid */
            pvt->group = atoi(v->value);
        } else if (!strcasecmp(v->name, "sms")) {
            pvt->has_sms = ast_true(v->value);
        } else if (!strcasecmp(v->name, "nocallsetup")) {
            pvt->no_callsetup = ast_true(v->value);
 
            if (pvt->no_callsetup)
                ast_debug(1, "Setting nocallsetup mode for device %s.\n", pvt->id);
        } else if (!strcasecmp(v->name, "blackberry")) {
            pvt->blackberry = ast_true(v->value);
            pvt->has_sms = 0;
        }
    }
 
    if (pvt->type == MBL_TYPE_PHONE) {
        if (!(pvt->hfp = ast_calloc(1, sizeof(*pvt->hfp)))) {
            ast_log(LOG_ERROR, "Skipping device %s. Error allocating memory.\n", pvt->id);
            goto e_free_sched;
        }
 
        pvt->hfp->owner = pvt;
        pvt->hfp->rport = pvt->rfcomm_port;
        pvt->hfp->nocallsetup = pvt->no_callsetup;
    } else {
        pvt->has_sms = 0;
    }
 
    AST_RWLIST_WRLOCK(&devices);
    AST_RWLIST_INSERT_HEAD(&devices, pvt, entry);
    AST_RWLIST_UNLOCK(&devices);
    ast_debug(1, "Loaded device %s.\n", pvt->id);
 
    return pvt;
 
e_free_sched:
    ast_sched_context_destroy(pvt->sched);
e_free_dsp:
    ast_dsp_free(pvt->dsp);
e_free_bt_in_smoother:
    ast_smoother_free(pvt->bt_in_smoother);
e_free_bt_out_smoother:
    ast_smoother_free(pvt->bt_out_smoother);
e_free_pvt:
    ast_free(pvt);
e_return:
    return NULL;
}

References mbl_pvt::adapter, mbl_pvt::addr, ast_calloc, ast_copy_string(), ast_debug, ast_dsp_free(), ast_dsp_new(), ast_dsp_set_digitmode(), ast_dsp_set_features(), ast_free, AST_LIST_HEAD_INIT_NOLOCK, ast_log, ast_mutex_init, AST_PTHREADT_NULL, AST_RWLIST_INSERT_HEAD, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_sched_context_create(), ast_sched_context_destroy(), ast_smoother_free(), ast_smoother_new(), ast_strlen_zero(), ast_true(), ast_variable_browse(), ast_variable_retrieve(), mbl_pvt::blackberry, mbl_pvt::bt_in_smoother, mbl_pvt::bt_out_smoother, CHANNEL_FRAME_SIZE, mbl_pvt::context, DEVICE_FRAME_SIZE, mbl_pvt::dsp, DSP_DIGITMODE_DTMF, DSP_DIGITMODE_RELAXDTMF, DSP_FEATURE_DIGIT_DETECT, mbl_pvt::group, mbl_pvt::has_sms, mbl_pvt::hfp, adapter_pvt::id, mbl_pvt::id, mbl_pvt::lock, LOG_ERROR, MBL_TYPE_HEADSET, MBL_TYPE_PHONE, mbl_pvt::monitor_thread, mbl_pvt::msg_queue, ast_variable::name, ast_variable::next, mbl_pvt::no_callsetup, hfp_pvt::nocallsetup, NULL, hfp_pvt::owner, mbl_pvt::rfcomm_port, mbl_pvt::rfcomm_socket, mbl_pvt::ring_sched_id, hfp_pvt::rport, mbl_pvt::sched, mbl_pvt::sco_socket, mbl_pvt::timeout, mbl_pvt::type, and ast_variable::value.

Referenced by mbl_load_config().

mbl_new()

static struct ast_channel * mbl_new ( int  state, struct mbl_pvt *  pvt, struct cidinfo *  cidinfo, const struct ast_assigned_ids *  assignedids, const struct ast_channel *  requestor  )

static

Definition at line 847 of file chan_mobile.c.

{
    struct ast_channel *chn;
 
    pvt->answered = 0;
    pvt->alignment_count = 0;
    pvt->alignment_detection_triggered = 0;
    if (pvt->adapter->alignment_detection)
        pvt->do_alignment_detection = 1;
    else
        pvt->do_alignment_detection = 0;
 
    ast_smoother_reset(pvt->bt_out_smoother, DEVICE_FRAME_SIZE);
    ast_smoother_reset(pvt->bt_in_smoother, CHANNEL_FRAME_SIZE);
    ast_dsp_digitreset(pvt->dsp);
 
    chn = ast_channel_alloc(1, state,
        cidinfo ? cidinfo->cnum : NULL,
        cidinfo ? cidinfo->cnam : NULL,
        0, 0, pvt->context, assignedids, requestor, 0,
        "Mobile/%s-%04lx", pvt->id, ast_random() & 0xffff);
    if (!chn) {
        goto e_return;
    }
 
    ast_channel_tech_set(chn, &mbl_tech);
    ast_channel_nativeformats_set(chn, mbl_tech.capabilities);
    ast_channel_set_rawreadformat(chn, DEVICE_FRAME_FORMAT);
    ast_channel_set_rawwriteformat(chn, DEVICE_FRAME_FORMAT);
    ast_channel_set_writeformat(chn, DEVICE_FRAME_FORMAT);
    ast_channel_set_readformat(chn, DEVICE_FRAME_FORMAT);
    ast_channel_tech_pvt_set(chn, pvt);
 
    if (state == AST_STATE_RING)
        ast_channel_rings_set(chn, 1);
 
    ast_channel_language_set(chn, "en");
    pvt->owner = chn;
 
    if (pvt->sco_socket != -1) {
        ast_channel_set_fd(chn, 0, pvt->sco_socket);
    }
    ast_channel_unlock(chn);
 
    return chn;
 
e_return:
    return NULL;
}

References mbl_pvt::adapter, mbl_pvt::alignment_count, adapter_pvt::alignment_detection, mbl_pvt::alignment_detection_triggered, mbl_pvt::answered, ast_channel_alloc, ast_channel_nativeformats_set(), ast_channel_rings_set(), ast_channel_set_fd(), ast_channel_set_rawreadformat(), ast_channel_set_rawwriteformat(), ast_channel_set_readformat(), ast_channel_set_writeformat(), ast_channel_tech_pvt_set(), ast_channel_tech_set(), ast_channel_unlock, ast_dsp_digitreset(), ast_random(), ast_smoother_reset(), AST_STATE_RING, mbl_pvt::bt_in_smoother, mbl_pvt::bt_out_smoother, ast_channel_tech::capabilities, CHANNEL_FRAME_SIZE, cidinfo::cnam, cidinfo::cnum, mbl_pvt::context, DEVICE_FRAME_FORMAT, DEVICE_FRAME_SIZE, mbl_pvt::do_alignment_detection, mbl_pvt::dsp, mbl_pvt::id, mbl_tech, NULL, mbl_pvt::owner, and mbl_pvt::sco_socket.

Referenced by do_monitor_headset(), handle_response_clip(), handle_response_cmgr(), and mbl_request().

mbl_queue_control()

static int mbl_queue_control ( struct mbl_pvt *  pvt, enum ast_control_frame_type  control  )

static

Definition at line 1317 of file chan_mobile.c.

{
    for (;;) {
        if (pvt->owner) {
            if (ast_channel_trylock(pvt->owner)) {
                DEADLOCK_AVOIDANCE(&pvt->lock);
            } else {
                ast_queue_control(pvt->owner, control);
                ast_channel_unlock(pvt->owner);
                break;
            }
        } else
            break;
    }
    return 0;
}

References ast_channel_trylock, ast_channel_unlock, ast_queue_control(), DEADLOCK_AVOIDANCE, mbl_pvt::lock, and mbl_pvt::owner.

Referenced by do_monitor_headset(), handle_response_busy(), handle_response_ciev(), handle_response_error(), handle_response_no_carrier(), handle_response_no_dialtone(), and handle_response_ok().

mbl_queue_hangup()

static int mbl_queue_hangup ( struct mbl_pvt *  pvt )

static

Definition at line 1334 of file chan_mobile.c.

{
    for (;;) {
        if (pvt->owner) {
            if (ast_channel_trylock(pvt->owner)) {
                DEADLOCK_AVOIDANCE(&pvt->lock);
            } else {
                if (pvt->hangupcause != 0) {
                    ast_channel_hangupcause_set(pvt->owner, pvt->hangupcause);
                }
                ast_queue_hangup(pvt->owner);
                ast_channel_unlock(pvt->owner);
                break;
            }
        } else
            break;
    }
    return 0;
}

References ast_channel_hangupcause_set(), ast_channel_trylock, ast_channel_unlock, ast_queue_hangup(), DEADLOCK_AVOIDANCE, mbl_pvt::hangupcause, mbl_pvt::lock, and mbl_pvt::owner.

Referenced by do_monitor_headset(), do_monitor_phone(), handle_response_ciev(), and handle_response_error().

mbl_read()

static struct ast_frame * mbl_read ( struct ast_channel *  ast )

static

Definition at line 1109 of file chan_mobile.c.

{
 
    struct mbl_pvt *pvt = ast_channel_tech_pvt(ast);
    struct ast_frame *fr = &ast_null_frame;
    int r;
 
    ast_debug(3, "*** mbl_read()\n");
 
    while (ast_mutex_trylock(&pvt->lock)) {
        CHANNEL_DEADLOCK_AVOIDANCE(ast);
    }
 
    if (!pvt->owner || pvt->sco_socket == -1) {
        goto e_return;
    }
 
    memset(&pvt->fr, 0x00, sizeof(struct ast_frame));
    pvt->fr.frametype = AST_FRAME_VOICE;
    pvt->fr.subclass.format = DEVICE_FRAME_FORMAT;
    pvt->fr.src = "Mobile";
    pvt->fr.offset = AST_FRIENDLY_OFFSET;
    pvt->fr.mallocd = 0;
    pvt->fr.delivery.tv_sec = 0;
    pvt->fr.delivery.tv_usec = 0;
    pvt->fr.data.ptr = pvt->io_buf + AST_FRIENDLY_OFFSET;
 
    do {
        if ((r = read(pvt->sco_socket, pvt->fr.data.ptr, DEVICE_FRAME_SIZE)) == -1) {
            if (errno != EAGAIN && errno != EINTR) {
                ast_debug(1, "[%s] read error %d, going to wait for new connection\n", pvt->id, errno);
                close(pvt->sco_socket);
                pvt->sco_socket = -1;
                ast_channel_set_fd(ast, 0, -1);
            }
            goto e_return;
        }
 
        pvt->fr.datalen = r;
        pvt->fr.samples = r / 2;
 
        if (pvt->do_alignment_detection)
            do_alignment_detection(pvt, pvt->fr.data.ptr, r);
 
        ast_smoother_feed(pvt->bt_in_smoother, &pvt->fr);
        fr = ast_smoother_read(pvt->bt_in_smoother);
    } while (fr == NULL);
    fr = ast_dsp_process(ast, pvt->dsp, fr);
 
    ast_mutex_unlock(&pvt->lock);
 
    return fr;
 
e_return:
    ast_mutex_unlock(&pvt->lock);
    return fr;
}

References ast_channel_set_fd(), ast_channel_tech_pvt(), ast_debug, ast_dsp_process(), AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_mutex_trylock, ast_mutex_unlock, ast_null_frame, ast_smoother_feed, ast_smoother_read(), mbl_pvt::bt_in_smoother, CHANNEL_DEADLOCK_AVOIDANCE, ast_frame::data, ast_frame::datalen, ast_frame::delivery, DEVICE_FRAME_FORMAT, DEVICE_FRAME_SIZE, mbl_pvt::do_alignment_detection, do_alignment_detection(), mbl_pvt::dsp, errno, ast_frame_subclass::format, mbl_pvt::fr, ast_frame::frametype, mbl_pvt::id, mbl_pvt::io_buf, mbl_pvt::lock, ast_frame::mallocd, NULL, ast_frame::offset, mbl_pvt::owner, ast_frame::ptr, ast_frame::samples, mbl_pvt::sco_socket, ast_frame::src, and ast_frame::subclass.

mbl_request()

static struct ast_channel * mbl_request ( const char *  type, struct ast_format_cap *  cap, const struct ast_assigned_ids *  assignedids, const struct ast_channel *  requestor, const char *  data, int *  cause  )

static

Definition at line 898 of file chan_mobile.c.

{
 
    struct ast_channel *chn = NULL;
    struct mbl_pvt *pvt;
    char *dest_dev = NULL;
    char *dest_num = NULL;
    int group = -1;
 
    if (!data) {
        ast_log(LOG_WARNING, "Channel requested with no data\n");
        *cause = AST_CAUSE_INCOMPATIBLE_DESTINATION;
        return NULL;
    }
 
    if (ast_format_cap_iscompatible_format(cap, DEVICE_FRAME_FORMAT) == AST_FORMAT_CMP_NOT_EQUAL) {
        struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
        ast_log(LOG_WARNING, "Asked to get a channel of unsupported format '%s'\n", ast_format_cap_get_names(cap, &codec_buf));
        *cause = AST_CAUSE_FACILITY_NOT_IMPLEMENTED;
        return NULL;
    }
 
    dest_dev = ast_strdupa(data);
 
    dest_num = strchr(dest_dev, '/');
    if (dest_num)
        *dest_num++ = 0x00;
 
    if (((dest_dev[0] == 'g') || (dest_dev[0] == 'G')) && ((dest_dev[1] >= '0') && (dest_dev[1] <= '9'))) {
        group = atoi(&dest_dev[1]);
    }
 
    /* Find requested device and make sure it's connected. */
    AST_RWLIST_RDLOCK(&devices);
    AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
        if (group > -1 && pvt->group == group && pvt->connected && !pvt->owner) {
            if (!mbl_has_service(pvt)) {
                continue;
            }
 
            break;
        } else if (!strcmp(pvt->id, dest_dev)) {
            break;
        }
    }
    AST_RWLIST_UNLOCK(&devices);
    if (!pvt || !pvt->connected || pvt->owner) {
        ast_log(LOG_WARNING, "Request to call on device %s which is not connected / already in use.\n", dest_dev);
        *cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
        return NULL;
    }
 
    if ((pvt->type == MBL_TYPE_PHONE) && !dest_num) {
        ast_log(LOG_WARNING, "Can't determine destination number.\n");
        *cause = AST_CAUSE_INCOMPATIBLE_DESTINATION;
        return NULL;
    }
 
    ast_mutex_lock(&pvt->lock);
    chn = mbl_new(AST_STATE_DOWN, pvt, NULL, assignedids, requestor);
    ast_mutex_unlock(&pvt->lock);
    if (!chn) {
        ast_log(LOG_WARNING, "Unable to allocate channel structure.\n");
        *cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
        return NULL;
    }
 
    return chn;
 
}

References AST_CAUSE_FACILITY_NOT_IMPLEMENTED, AST_CAUSE_INCOMPATIBLE_DESTINATION, AST_CAUSE_REQUESTED_CHAN_UNAVAIL, ast_format_cap_get_names(), ast_format_cap_iscompatible_format(), AST_FORMAT_CAP_NAMES_LEN, AST_FORMAT_CMP_NOT_EQUAL, ast_log, ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_STATE_DOWN, ast_str_alloca, ast_strdupa, mbl_pvt::connected, DEVICE_FRAME_FORMAT, mbl_pvt::group, mbl_pvt::id, mbl_pvt::lock, LOG_WARNING, mbl_has_service(), mbl_new(), MBL_TYPE_PHONE, NULL, mbl_pvt::owner, and mbl_pvt::type.

mbl_sendsms_exec()

static int mbl_sendsms_exec ( struct ast_channel *  ast, const char *  data  )

static

Definition at line 763 of file chan_mobile.c.

{
 
    struct mbl_pvt *pvt;
    char *parse, *message;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(device);
        AST_APP_ARG(dest);
        AST_APP_ARG(message);
    );
 
    if (ast_strlen_zero(data))
        return -1;
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.device)) {
        ast_log(LOG_ERROR,"NULL device for message -- SMS will not be sent.\n");
        return -1;
    }
 
    if (ast_strlen_zero(args.dest)) {
        ast_log(LOG_ERROR,"NULL destination for message -- SMS will not be sent.\n");
        return -1;
    }
 
    if (ast_strlen_zero(args.message)) {
        ast_log(LOG_ERROR,"NULL Message to be sent -- SMS will not be sent.\n");
        return -1;
    }
 
    AST_RWLIST_RDLOCK(&devices);
    AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
        if (!strcmp(pvt->id, args.device))
            break;
    }
    AST_RWLIST_UNLOCK(&devices);
 
    if (!pvt) {
        ast_log(LOG_ERROR,"Bluetooth device %s wasn't found in the list -- SMS will not be sent.\n", args.device);
        goto e_return;
    }
 
    ast_mutex_lock(&pvt->lock);
    if (!pvt->connected) {
        ast_log(LOG_ERROR,"Bluetooth device %s wasn't connected -- SMS will not be sent.\n", args.device);
        goto e_unlock_pvt;
    }
 
    if (!pvt->has_sms) {
        ast_log(LOG_ERROR,"Bluetooth device %s doesn't handle SMS -- SMS will not be sent.\n", args.device);
        goto e_unlock_pvt;
    }
 
    message = ast_strdup(args.message);
 
    if (hfp_send_cmgs(pvt->hfp, args.dest)
        || msg_queue_push_data(pvt, AT_SMS_PROMPT, AT_CMGS, message)) {
 
        ast_log(LOG_ERROR, "[%s] problem sending SMS message\n", pvt->id);
        goto e_free_message;
    }
 
    ast_mutex_unlock(&pvt->lock);
 
    return 0;
 
e_free_message:
    ast_free(message);
e_unlock_pvt:
    ast_mutex_unlock(&pvt->lock);
e_return:
    return -1;
}

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_free, ast_log, ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_STANDARD_APP_ARGS, ast_strdup, ast_strdupa, ast_strlen_zero(), AT_CMGS, AT_SMS_PROMPT, mbl_pvt::connected, mbl_pvt::has_sms, mbl_pvt::hfp, hfp_send_cmgs(), mbl_pvt::id, mbl_pvt::lock, LOG_ERROR, and msg_queue_push_data().

Referenced by load_module().

mbl_status_exec()

static int mbl_status_exec ( struct ast_channel *  ast, const char *  data  )

static

Definition at line 715 of file chan_mobile.c.

{
 
    struct mbl_pvt *pvt;
    char *parse;
    int stat;
    char status[2];
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(device);
        AST_APP_ARG(variable);
    );
 
    if (ast_strlen_zero(data))
        return -1;
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.device) || ast_strlen_zero(args.variable))
        return -1;
 
    stat = 1;
 
    AST_RWLIST_RDLOCK(&devices);
    AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
        if (!strcmp(pvt->id, args.device))
            break;
    }
    AST_RWLIST_UNLOCK(&devices);
 
    if (pvt) {
        ast_mutex_lock(&pvt->lock);
        if (pvt->connected)
            stat = 2;
        if (pvt->owner)
            stat = 3;
        ast_mutex_unlock(&pvt->lock);
    }
 
    snprintf(status, sizeof(status), "%d", stat);
    pbx_builtin_setvar_helper(ast, args.variable, status);
 
    return 0;
 
}

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), mbl_pvt::connected, mbl_pvt::id, mbl_pvt::lock, mbl_pvt::owner, pbx_builtin_setvar_helper(), and status.

Referenced by load_module().

mbl_write()

static int mbl_write ( struct ast_channel *  ast, struct ast_frame *  frame  )

static

Definition at line 1167 of file chan_mobile.c.

{
 
    struct mbl_pvt *pvt = ast_channel_tech_pvt(ast);
    struct ast_frame *f;
 
    ast_debug(3, "*** mbl_write\n");
 
    if (frame->frametype != AST_FRAME_VOICE) {
        return 0;
    }
 
    while (ast_mutex_trylock(&pvt->lock)) {
        CHANNEL_DEADLOCK_AVOIDANCE(ast);
    }
 
    ast_smoother_feed(pvt->bt_out_smoother, frame);
 
    while ((f = ast_smoother_read(pvt->bt_out_smoother))) {
        sco_write(pvt->sco_socket, f->data.ptr, f->datalen);
    }
 
    ast_mutex_unlock(&pvt->lock);
 
    return 0;
 
}

References ast_channel_tech_pvt(), ast_debug, AST_FRAME_VOICE, ast_mutex_trylock, ast_mutex_unlock, ast_smoother_feed, ast_smoother_read(), mbl_pvt::bt_out_smoother, CHANNEL_DEADLOCK_AVOIDANCE, ast_frame::data, ast_frame::datalen, ast_frame::frametype, mbl_pvt::lock, ast_frame::ptr, mbl_pvt::sco_socket, and sco_write().

msg_queue_flush()

static void msg_queue_flush ( struct mbl_pvt *  pvt )

static

Remove all items from the queue and free them.

Parameters

pvt	a mbl_pvt structure

Definition at line 3048 of file chan_mobile.c.

{
    struct msg_queue_entry *msg;
    while ((msg = msg_queue_head(pvt)))
        msg_queue_free_and_pop(pvt);
}

References msg_queue_free_and_pop(), and msg_queue_head().

Referenced by do_monitor_phone(), and unload_module().

msg_queue_free_and_pop()

static void msg_queue_free_and_pop ( struct mbl_pvt *  pvt )

static

Remove an item from the front of the queue, and free it.

Parameters

pvt	a mbl_pvt structure

Definition at line 3034 of file chan_mobile.c.

{
    struct msg_queue_entry *msg;
    if ((msg = msg_queue_pop(pvt))) {
        if (msg->data)
            ast_free(msg->data);
        ast_free(msg);
    }
}

References ast_free, msg_queue_entry::data, and msg_queue_pop().

Referenced by handle_response_brsf(), handle_response_cind(), handle_response_clip(), handle_response_cmgr(), handle_response_error(), handle_response_ok(), handle_sms_prompt(), and msg_queue_flush().

msg_queue_head()

static struct msg_queue_entry * msg_queue_head ( struct mbl_pvt *  pvt )

static

Get the head of a queue.

Parameters

pvt	a mbl_pvt structure

Returns

a pointer to the head of the given msg queue

Definition at line 3060 of file chan_mobile.c.

{
    return AST_LIST_FIRST(&pvt->msg_queue);
}

References AST_LIST_FIRST, and mbl_pvt::msg_queue.

Referenced by do_monitor_phone(), handle_response_brsf(), handle_response_cind(), handle_response_clip(), handle_response_cmgr(), handle_response_error(), handle_response_ok(), handle_sms_prompt(), and msg_queue_flush().

msg_queue_pop()

static struct msg_queue_entry * msg_queue_pop ( struct mbl_pvt *  pvt )

static

Remove an item from the front of the queue.

Parameters

pvt	a mbl_pvt structure

Returns

a pointer to the removed item

Definition at line 3025 of file chan_mobile.c.

{
    return AST_LIST_REMOVE_HEAD(&pvt->msg_queue, entry);
}

References AST_LIST_REMOVE_HEAD, and mbl_pvt::msg_queue.

Referenced by msg_queue_free_and_pop().

msg_queue_push()

static int msg_queue_push ( struct mbl_pvt *  pvt, at_message_t  expect, at_message_t  response_to  )

static

Add an item to the back of the queue.

Parameters

pvt	a mbl_pvt structure
expect	the msg we expect to receive
response_to	the message that was sent to generate the expected response

Definition at line 2984 of file chan_mobile.c.

{
    struct msg_queue_entry *msg;
    if (!(msg = ast_calloc(1, sizeof(*msg)))) {
        return -1;
    }
    msg->expected = expect;
    msg->response_to = response_to;
 
    AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry);
    return 0;
}

References ast_calloc, AST_LIST_INSERT_TAIL, msg_queue_entry::expected, mbl_pvt::msg_queue, and msg_queue_entry::response_to.

Referenced by do_monitor_phone(), handle_cli_mobile_cusd(), handle_cli_mobile_rfcomm(), handle_response_brsf(), handle_response_cind(), handle_response_clip(), handle_response_cmti(), handle_response_error(), handle_response_ok(), handle_response_ring(), handle_sms_prompt(), mbl_answer(), mbl_call(), mbl_digit_end(), and mbl_hangup().

msg_queue_push_data()

static int msg_queue_push_data ( struct mbl_pvt *  pvt, at_message_t  expect, at_message_t  response_to, void *  data  )

static

Add an item to the back of the queue with data.

Parameters

pvt	a mbl_pvt structure
expect	the msg we expect to receive
response_to	the message that was sent to generate the expected response
data	data associated with this message, it will be freed when the message is freed

Definition at line 3006 of file chan_mobile.c.

{
    struct msg_queue_entry *msg;
    if (!(msg = ast_calloc(1, sizeof(*msg)))) {
        return -1;
    }
    msg->expected = expect;
    msg->response_to = response_to;
    msg->data = data;
 
    AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry);
    return 0;
}

References ast_calloc, AST_LIST_INSERT_TAIL, msg_queue_entry::data, msg_queue_entry::expected, mbl_pvt::msg_queue, and msg_queue_entry::response_to.

Referenced by mbl_sendsms_exec().

parse_next_token()

static int parse_next_token ( char  string[], const int  start, const char  delim  )

static

Terminate current token and return an index to start of the next token.

Parameters

string	the null-terminated string being parsed (will be altered!)
start	where the current token starts
delim	the token termination delimiter. \0 is also considered a terminator.

Returns

index of the next token. May be the same as this token if the string is exhausted.

Definition at line 2299 of file chan_mobile.c.

{
    int index;
    int quoting = 0;
 
    for (index = start; string[index] != 0; index++) {
        if ((string[index] == delim) && !quoting ) {
            /* Found the delimiter, outside of quotes.  This is the end of the token. */
            string[index] = '\0';   /* Terminate this token. */
            index++;        /* Point the index to the start of the next token. */
            break;          /* We're done. */
        } else if (string[index] == '"' && !quoting) {
            /* Found a beginning quote mark.  Remember it. */
            quoting = 1;
        } else if (string[index] == '"' ) {
            /* Found the end quote mark. */
            quoting = 0;
        }
    }
    return index;
}

Referenced by hfp_parse_clip().

rfcomm_append_buf()

static void rfcomm_append_buf ( char **  buf, size_t  count, size_t *  in_count, char  c  )

inlinestatic

Append the given character to the given buffer and increase the in_count.

Definition at line 1508 of file chan_mobile.c.

{
    if (*in_count < count) {
        (*in_count)++;
        *(*buf)++ = c;
    }
}

References c.

Referenced by rfcomm_read(), rfcomm_read_and_append_char(), rfcomm_read_cmgr(), rfcomm_read_command(), rfcomm_read_result(), rfcomm_read_until_crlf(), and rfcomm_read_until_ok().

rfcomm_connect()

static int rfcomm_connect ( bdaddr_t  src, bdaddr_t  dst, int  remote_channel  )

static

Definition at line 1390 of file chan_mobile.c.

{
 
    struct sockaddr_rc addr;
    int s;
 
    if ((s = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) < 0) {
        ast_debug(1, "socket() failed (%d).\n", errno);
        return -1;
    }
 
    memset(&addr, 0, sizeof(addr));
    addr.rc_family = AF_BLUETOOTH;
    bacpy(&addr.rc_bdaddr, &src);
    addr.rc_channel = (uint8_t) 0;
    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        ast_debug(1, "bind() failed (%d).\n", errno);
        close(s);
        return -1;
    }
 
    memset(&addr, 0, sizeof(addr));
    addr.rc_family = AF_BLUETOOTH;
    bacpy(&addr.rc_bdaddr, &dst);
    addr.rc_channel = remote_channel;
    if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        ast_debug(1, "connect() failed (%d).\n", errno);
        close(s);
        return -1;
    }
 
    return s;
 
}

References ast_debug, and errno.

Referenced by do_discovery().

rfcomm_read()

static ssize_t rfcomm_read ( int  rsock, char *  buf, size_t  count  )

static

Read one Hayes AT message from an rfcomm socket.

Parameters

rsock	the rfcomm socket to read from
buf	the buffer to store the result in
count	the size of the buffer or the maximum number of characters to read

Here we need to read complete Hayes AT messages. The AT message formats we support are listed below.

* \r\n<result code>\r\n
* <at command>\r
* \r\n>
* 

These formats correspond to AT result codes, AT commands, and the AT SMS prompt respectively. When messages are read the leading and trailing

'\r' 

and

'\n' 

characters are discarded. If the given buffer is not large enough to hold the response, what does not fit in the buffer will be dropped.

Note

The rfcomm connection to the device is asynchronous, so there is no guarantee that responses will be returned in a single read() call. We handle this by blocking until we can read an entire response.

Return values

0	end of file
-1	read error
-2	parse error
other	the number of characters added to buf

Definition at line 1808 of file chan_mobile.c.

{
    ssize_t res;
    size_t in_count = 0;
    char c;
 
    if ((res = rfcomm_read_and_expect_char(rsock, &c, '\r')) == 1) {
        res = rfcomm_read_result(rsock, &buf, count, &in_count);
    } else if (res == -2) {
        rfcomm_append_buf(&buf, count, &in_count, c);
        res = rfcomm_read_command(rsock, &buf, count, &in_count);
    }
 
    if (res < 1)
        return res;
    else
        return in_count;
}

References buf, c, rfcomm_append_buf(), rfcomm_read_and_expect_char(), rfcomm_read_command(), and rfcomm_read_result().

Referenced by at_read_full().

rfcomm_read_and_append_char()

static int rfcomm_read_and_append_char ( int  rsock, char **  buf, size_t  count, size_t *  in_count, char *  result, char  expected  )

static

Read a character from the given stream and append it to the given buffer if it matches the expected character.

Definition at line 1544 of file chan_mobile.c.

{
    int res;
    char c;
 
    if (!result)
        result = &c;
 
    if ((res = rfcomm_read_and_expect_char(rsock, result, expected)) < 1) {
        return res;
    }
 
    rfcomm_append_buf(buf, count, in_count, *result);
    return 1;
}

References buf, c, result, rfcomm_append_buf(), and rfcomm_read_and_expect_char().

Referenced by rfcomm_read_result(), and rfcomm_read_sms_prompt().

rfcomm_read_and_expect_char()

static int rfcomm_read_and_expect_char ( int  rsock, char *  result, char  expected  )

static

Read a character from the given stream and check if it matches what we expected.

Definition at line 1520 of file chan_mobile.c.

{
    int res;
    char c;
 
    if (!result)
        result = &c;
 
    if ((res = read(rsock, result, 1)) < 1) {
        return res;
    }
    rfcomm_read_debug(*result);
 
    if (*result != expected) {
        return -2;
    }
 
    return 1;
}

References c, result, and rfcomm_read_debug.

Referenced by rfcomm_read(), rfcomm_read_and_append_char(), rfcomm_read_result(), rfcomm_read_until_crlf(), and rfcomm_read_until_ok().

rfcomm_read_cmgr()

static int rfcomm_read_cmgr ( int  rsock, char **  buf, size_t  count, size_t *  in_count  )

static

Read the remainder of a +CMGR message.

Note

the entire parsed string is

'+CMGR: ...\r\n...\r\n...\r\n...\r\nOK\r\n' 

Definition at line 1706 of file chan_mobile.c.

{
    int res;
 
    /* append the \r\n that was stripped by the calling function */
    rfcomm_append_buf(buf, count, in_count, '\r');
    rfcomm_append_buf(buf, count, in_count, '\n');
 
    if ((res = rfcomm_read_until_ok(rsock, buf, count, in_count)) != 1) {
        ast_log(LOG_ERROR, "error reading +CMGR message on rfcomm socket\n");
    }
 
    return res;
}

References ast_log, buf, LOG_ERROR, rfcomm_append_buf(), and rfcomm_read_until_ok().

Referenced by rfcomm_read_result().

rfcomm_read_command()

static int rfcomm_read_command ( int  rsock, char **  buf, size_t  count, size_t *  in_count  )

static

Read the remainder of an AT command.

Note

the entire parsed string is

'<at command>\r' 

Definition at line 1763 of file chan_mobile.c.

{
    int res;
    char c;
 
    while ((res = read(rsock, &c, 1)) == 1) {
        rfcomm_read_debug(c);
        /* stop when we get to '\r' */
        if (c == '\r')
            break;
 
        rfcomm_append_buf(buf, count, in_count, c);
    }
    return res;
}

References buf, c, rfcomm_append_buf(), and rfcomm_read_debug.

Referenced by rfcomm_read().

rfcomm_read_result()

static int rfcomm_read_result ( int  rsock, char **  buf, size_t  count, size_t *  in_count  )

static

Read and AT result code.

Note

the entire parsed string is

'\r\n<result code>\r\n' 

Definition at line 1725 of file chan_mobile.c.

{
    int res;
    char c;
 
    if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) < 1) {
        goto e_return;
    }
 
    if ((res = rfcomm_read_and_append_char(rsock, buf, count, in_count, &c, '>')) == 1) {
        return rfcomm_read_sms_prompt(rsock, buf, count, in_count);
    } else if (res != -2) {
        goto e_return;
    }
 
    rfcomm_append_buf(buf, count, in_count, c);
    res = rfcomm_read_until_crlf(rsock, buf, count, in_count);
 
    if (res != 1)
        return res;
 
    /* check for CMGR, which contains an embedded \r\n pairs terminated by
     * an \r\nOK\r\n message */
    if (*in_count >= 5 && !strncmp(*buf - *in_count, "+CMGR", 5)) {
        return rfcomm_read_cmgr(rsock, buf, count, in_count);
    }
 
    return 1;
 
e_return:
    ast_log(LOG_ERROR, "error parsing AT result on rfcomm socket\n");
    return res;
}

References ast_log, buf, c, LOG_ERROR, rfcomm_append_buf(), rfcomm_read_and_append_char(), rfcomm_read_and_expect_char(), rfcomm_read_cmgr(), rfcomm_read_sms_prompt(), and rfcomm_read_until_crlf().

Referenced by rfcomm_read().

rfcomm_read_sms_prompt()

static int rfcomm_read_sms_prompt ( int  rsock, char **  buf, size_t  count, size_t *  in_count  )

static

Read the remainder of an AT SMS prompt.

Note

the entire parsed string is

'\r\n> ' 

By the time this function is executed, only a ' ' is left to read.

Definition at line 1593 of file chan_mobile.c.

{
    int res;
    if ((res = rfcomm_read_and_append_char(rsock, buf, count, in_count, NULL, ' ')) < 1)
           goto e_return;
 
    return 1;
 
e_return:
    ast_log(LOG_ERROR, "error parsing SMS prompt on rfcomm socket\n");
    return res;
}

References ast_log, buf, LOG_ERROR, NULL, and rfcomm_read_and_append_char().

Referenced by rfcomm_read_result().

rfcomm_read_until_crlf()

static int rfcomm_read_until_crlf ( int  rsock, char **  buf, size_t  count, size_t *  in_count  )

static

Read until.

'\r\n'. 

This function consumes the

'\r\n'

but does not add it to buf.

Definition at line 1564 of file chan_mobile.c.

{
    int res;
    char c;
 
    while ((res = read(rsock, &c, 1)) == 1) {
        rfcomm_read_debug(c);
        if (c == '\r') {
            if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) == 1) {
                break;
            } else if (res == -2) {
                rfcomm_append_buf(buf, count, in_count, '\r');
            } else {
                rfcomm_append_buf(buf, count, in_count, '\r');
                break;
            }
        }
 
        rfcomm_append_buf(buf, count, in_count, c);
    }
    return res;
}

References buf, c, rfcomm_append_buf(), rfcomm_read_and_expect_char(), and rfcomm_read_debug.

Referenced by rfcomm_read_result(), and rfcomm_read_until_ok().

rfcomm_read_until_ok()

static int rfcomm_read_until_ok ( int  rsock, char **  buf, size_t  count, size_t *  in_count  )

static

Read until a.

\r\nOK\r\n 

message.

Definition at line 1609 of file chan_mobile.c.

{
    int res;
    char c;
 
    /* here, we read until finding a \r\n, then we read one character at a
     * time looking for the string '\r\nOK\r\n'.  If we only find a partial
     * match, we place that in the buffer and try again. */
 
    for (;;) {
        if ((res = rfcomm_read_until_crlf(rsock, buf, count, in_count)) != 1) {
            break;
        }
 
        rfcomm_append_buf(buf, count, in_count, '\r');
        rfcomm_append_buf(buf, count, in_count, '\n');
 
        if ((res = rfcomm_read_and_expect_char(rsock, &c, '\r')) != 1) {
            if (res != -2) {
                break;
            }
 
            rfcomm_append_buf(buf, count, in_count, c);
            continue;
        }
 
        if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) != 1) {
            if (res != -2) {
                break;
            }
 
            rfcomm_append_buf(buf, count, in_count, '\r');
            rfcomm_append_buf(buf, count, in_count, c);
            continue;
        }
        if ((res = rfcomm_read_and_expect_char(rsock, &c, 'O')) != 1) {
            if (res != -2) {
                break;
            }
 
            rfcomm_append_buf(buf, count, in_count, '\r');
            rfcomm_append_buf(buf, count, in_count, '\n');
            rfcomm_append_buf(buf, count, in_count, c);
            continue;
        }
 
        if ((res = rfcomm_read_and_expect_char(rsock, &c, 'K')) != 1) {
            if (res != -2) {
                break;
            }
 
            rfcomm_append_buf(buf, count, in_count, '\r');
            rfcomm_append_buf(buf, count, in_count, '\n');
            rfcomm_append_buf(buf, count, in_count, 'O');
            rfcomm_append_buf(buf, count, in_count, c);
            continue;
        }
 
        if ((res = rfcomm_read_and_expect_char(rsock, &c, '\r')) != 1) {
            if (res != -2) {
                break;
            }
 
            rfcomm_append_buf(buf, count, in_count, '\r');
            rfcomm_append_buf(buf, count, in_count, '\n');
            rfcomm_append_buf(buf, count, in_count, 'O');
            rfcomm_append_buf(buf, count, in_count, 'K');
            rfcomm_append_buf(buf, count, in_count, c);
            continue;
        }
 
        if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) != 1) {
            if (res != -2) {
                break;
            }
 
            rfcomm_append_buf(buf, count, in_count, '\r');
            rfcomm_append_buf(buf, count, in_count, '\n');
            rfcomm_append_buf(buf, count, in_count, 'O');
            rfcomm_append_buf(buf, count, in_count, 'K');
            rfcomm_append_buf(buf, count, in_count, '\r');
            rfcomm_append_buf(buf, count, in_count, c);
            continue;
        }
 
        /* we have successfully parsed a '\r\nOK\r\n' string */
        return 1;
    }
 
    return res;
}

References buf, c, rfcomm_append_buf(), rfcomm_read_and_expect_char(), and rfcomm_read_until_crlf().

Referenced by rfcomm_read_cmgr().

rfcomm_wait()

static int rfcomm_wait ( int  rsock, int *  ms  )

static

Wait for activity on an rfcomm socket.

Parameters

rsock	the socket to watch
ms	a pointer to an int containing a timeout in ms

Returns

zero on timeout and the socket fd (non-zero) otherwise

Return values

0

timeout

Definition at line 1479 of file chan_mobile.c.

{
    int exception, outfd;
    outfd = ast_waitfor_n_fd(&rsock, 1, ms, &exception);
    if (outfd < 0)
        outfd = 0;
 
    return outfd;
}

References ast_waitfor_n_fd().

Referenced by do_monitor_headset(), and do_monitor_phone().

rfcomm_write()

static int rfcomm_write ( int  rsock, char *  buf  )

static

Write to an rfcomm socket.

Parameters

rsock	the socket to write to
buf	the null terminated buffer to write

This function will write characters from buf. The buffer must be null terminated.

Return values

-1	error
0	success

Definition at line 1436 of file chan_mobile.c.

{
    return rfcomm_write_full(rsock, buf, strlen(buf));
}

References buf, and rfcomm_write_full().

Referenced by handle_cli_mobile_rfcomm(), hfp_send_ata(), hfp_send_atd(), hfp_send_brsf(), hfp_send_chup(), hfp_send_cind(), hfp_send_cind_test(), hfp_send_clip(), hfp_send_cmer(), hfp_send_cmgf(), hfp_send_cmgr(), hfp_send_cmgs(), hfp_send_cnmi(), hfp_send_cusd(), hfp_send_dtmf(), hfp_send_ecam(), hfp_send_sms_text(), hfp_send_vgs(), hsp_send_error(), hsp_send_ok(), hsp_send_ring(), hsp_send_vgm(), and hsp_send_vgs().

rfcomm_write_full()

static int rfcomm_write_full ( int  rsock, char *  buf, size_t  count  )

static

Write to an rfcomm socket.

Parameters

rsock	the socket to write to
buf	the buffer to write
count	the number of characters from the buffer to write

This function will write count characters from buf. It will always write count chars unless it encounters an error.

Return values

-1	error
0	success

Definition at line 1454 of file chan_mobile.c.

{
    char *p = buf;
    ssize_t out_count;
 
    ast_debug(1, "rfcomm_write() (%d) [%.*s]\n", rsock, (int) count, buf);
    while (count > 0) {
        if ((out_count = write(rsock, p, count)) == -1) {
            ast_debug(1, "rfcomm_write() error [%d]\n", errno);
            return -1;
        }
        count -= out_count;
        p += out_count;
    }
 
    return 0;
}

References ast_debug, buf, and errno.

Referenced by rfcomm_write().

sco_accept()

static int sco_accept ( int *  id, int  fd, short  events, void *  data  )

static

Accept SCO connections. This function is an ast_io callback function used to accept incoming sco audio connections.

Definition at line 1898 of file chan_mobile.c.

{
    struct adapter_pvt *adapter = (struct adapter_pvt *) data;
    struct sockaddr_sco addr;
    socklen_t addrlen;
    struct mbl_pvt *pvt;
    socklen_t len;
    char saddr[18];
    struct sco_options so;
    int sock;
 
    addrlen = sizeof(struct sockaddr_sco);
    if ((sock = accept(fd, (struct sockaddr *)&addr, &addrlen)) == -1) {
        ast_log(LOG_ERROR, "error accepting audio connection on adapter %s\n", adapter->id);
        return 0;
    }
 
    len = sizeof(so);
    getsockopt(sock, SOL_SCO, SCO_OPTIONS, &so, &len);
 
    ba2str(&addr.sco_bdaddr, saddr);
    ast_debug(1, "Incoming Audio Connection from device %s MTU is %d\n", saddr, so.mtu);
 
    /* figure out which device this sco connection belongs to */
    pvt = NULL;
    AST_RWLIST_RDLOCK(&devices);
    AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
        if (!bacmp(&pvt->addr, &addr.sco_bdaddr))
            break;
    }
    AST_RWLIST_UNLOCK(&devices);
    if (!pvt) {
        ast_log(LOG_WARNING, "could not find device for incoming audio connection\n");
        close(sock);
        return 1;
    }
 
    ast_mutex_lock(&pvt->lock);
    if (pvt->sco_socket != -1) {
        close(pvt->sco_socket);
        pvt->sco_socket = -1;
    }
 
    pvt->sco_socket = sock;
    if (pvt->owner) {
        ast_channel_set_fd(pvt->owner, 0, sock);
    } else {
        ast_debug(1, "incoming audio connection for pvt without owner\n");
    }
 
    ast_mutex_unlock(&pvt->lock);
 
    return 1;
}

References mbl_pvt::addr, ast_channel_set_fd(), ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, adapter_pvt::id, len(), mbl_pvt::lock, LOG_ERROR, LOG_WARNING, NULL, mbl_pvt::owner, and mbl_pvt::sco_socket.

Referenced by mbl_load_adapter().

sco_bind()

static int sco_bind ( struct adapter_pvt *  adapter )

static

Bind an SCO listener socket for the given adapter.

Parameters

adapter

an adapter_pvt

Returns

-1 on error, non zero on success

Definition at line 1958 of file chan_mobile.c.

{
    struct sockaddr_sco addr;
    int opt = 1;
 
    if ((adapter->sco_socket = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) {
        ast_log(LOG_ERROR, "Unable to create sco listener socket for adapter %s.\n", adapter->id);
        goto e_return;
    }
 
    memset(&addr, 0, sizeof(addr));
    addr.sco_family = AF_BLUETOOTH;
    bacpy(&addr.sco_bdaddr, &adapter->addr);
    if (bind(adapter->sco_socket, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        ast_log(LOG_ERROR, "Unable to bind sco listener socket. (%d)\n", errno);
        goto e_close_socket;
    }
    if (setsockopt(adapter->sco_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
        ast_log(LOG_ERROR, "Unable to setsockopt sco listener socket.\n");
        goto e_close_socket;
    }
    if (listen(adapter->sco_socket, 5) < 0) {
        ast_log(LOG_ERROR, "Unable to listen sco listener socket.\n");
        goto e_close_socket;
    }
 
    return adapter->sco_socket;
 
e_close_socket:
    close(adapter->sco_socket);
    adapter->sco_socket = -1;
e_return:
    return -1;
}

References adapter_pvt::addr, ast_log, errno, adapter_pvt::id, LOG_ERROR, and adapter_pvt::sco_socket.

Referenced by mbl_load_adapter().

sco_connect()

static int sco_connect ( bdaddr_t  src, bdaddr_t  dst  )

static

Definition at line 1833 of file chan_mobile.c.

{
 
    struct sockaddr_sco addr;
    int s;
 
    if ((s = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) {
        ast_debug(1, "socket() failed (%d).\n", errno);
        return -1;
    }
 
/* XXX this does not work with the do_sco_listen() thread (which also bind()s
 * to this address).  Also I am not sure if it is necessary. */
#if 0
    memset(&addr, 0, sizeof(addr));
    addr.sco_family = AF_BLUETOOTH;
    bacpy(&addr.sco_bdaddr, &src);
    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        ast_debug(1, "bind() failed (%d).\n", errno);
        close(s);
        return -1;
    }
#endif
 
    memset(&addr, 0, sizeof(addr));
    addr.sco_family = AF_BLUETOOTH;
    bacpy(&addr.sco_bdaddr, &dst);
 
    if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        ast_debug(1, "sco connect() failed (%d).\n", errno);
        close(s);
        return -1;
    }
 
    return s;
 
}

References ast_debug, and errno.

Referenced by do_monitor_headset().

sco_write()

static int sco_write ( int  s, char *  buf, int  len  )

static

Definition at line 1871 of file chan_mobile.c.

{
 
    int r;
 
    if (s == -1) {
        ast_debug(3, "sco_write() not ready\n");
        return 0;
    }
 
    ast_debug(3, "sco_write()\n");
 
    r = write(s, buf, len);
    if (r == -1) {
        ast_debug(3, "sco write error %d\n", errno);
        return 0;
    }
 
    return 1;
 
}

References ast_debug, buf, errno, and len().

Referenced by mbl_write().

sdp_register()

static sdp_session_t * sdp_register ( void  )

static

Definition at line 3121 of file chan_mobile.c.

{
    uint32_t service_uuid_int[] = {0, 0, 0, GENERIC_AUDIO_SVCLASS_ID};
    uint8_t rfcomm_channel = 1;
    const char *service_name = "Asterisk PABX";
    const char *service_dsc = "Asterisk PABX";
    const char *service_prov = "Asterisk";
 
    uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid, svc_class1_uuid, svc_class2_uuid;
    sdp_list_t  *l2cap_list = 0, *rfcomm_list = 0, *root_list = 0, *proto_list = 0, *access_proto_list = 0, *svc_uuid_list = 0;
    sdp_data_t *channel = 0;
 
    sdp_session_t *session = 0;
 
    sdp_record_t *record = sdp_record_alloc();
 
    sdp_uuid128_create(&svc_uuid, &service_uuid_int);
    sdp_set_service_id(record, svc_uuid);
 
    sdp_uuid32_create(&svc_class1_uuid, GENERIC_AUDIO_SVCLASS_ID);
    sdp_uuid32_create(&svc_class2_uuid, HEADSET_PROFILE_ID);
 
    svc_uuid_list = sdp_list_append(0, &svc_class1_uuid);
    svc_uuid_list = sdp_list_append(svc_uuid_list, &svc_class2_uuid);
    sdp_set_service_classes(record, svc_uuid_list);
 
    sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
    root_list = sdp_list_append(0, &root_uuid);
    sdp_set_browse_groups( record, root_list );
 
    sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
    l2cap_list = sdp_list_append(0, &l2cap_uuid);
    proto_list = sdp_list_append(0, l2cap_list);
 
    sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
    channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
    rfcomm_list = sdp_list_append(0, &rfcomm_uuid);
    sdp_list_append(rfcomm_list, channel);
    sdp_list_append(proto_list, rfcomm_list);
 
    access_proto_list = sdp_list_append(0, proto_list);
    sdp_set_access_protos(record, access_proto_list);
 
    sdp_set_info_attr(record, service_name, service_prov, service_dsc);
 
    if (!(session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY)))
        ast_log(LOG_WARNING, "Failed to connect sdp and create session.\n");
    else {
        if (sdp_record_register(session, record, 0) < 0) {
            ast_log(LOG_WARNING, "Failed to sdp_record_register error: %d\n", errno);
            return NULL;
        }
    }
 
    sdp_data_free(channel);
    sdp_list_free(rfcomm_list, 0);
    sdp_list_free(root_list, 0);
    sdp_list_free(access_proto_list, 0);
    sdp_list_free(svc_uuid_list, 0);
 
    return session;
 
}

References ast_log, errno, LOG_WARNING, NULL, and session.

Referenced by load_module().

sdp_search()

static int sdp_search ( char *  addr, int  profile  )

static

Definition at line 3073 of file chan_mobile.c.

{
 
    sdp_session_t *session = 0;
    bdaddr_t bdaddr;
    uuid_t svc_uuid;
    uint32_t range = 0x0000ffff;
    sdp_list_t *response_list, *search_list, *attrid_list;
    int status, port;
    sdp_list_t *proto_list;
    sdp_record_t *sdprec;
 
    str2ba(addr, &bdaddr);
    port = 0;
    session = sdp_connect(BDADDR_ANY, &bdaddr, SDP_RETRY_IF_BUSY);
    if (!session) {
        ast_debug(1, "sdp_connect() failed on device %s.\n", addr);
        return 0;
    }
 
    sdp_uuid32_create(&svc_uuid, profile);
    search_list = sdp_list_append(0, &svc_uuid);
    attrid_list = sdp_list_append(0, &range);
    response_list = 0x00;
    status = sdp_service_search_attr_req(session, search_list, SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
    if (status == 0) {
        if (response_list) {
            sdprec = (sdp_record_t *) response_list->data;
            proto_list = 0x00;
            if (sdp_get_access_protos(sdprec, &proto_list) == 0) {
                port = sdp_get_proto_port(proto_list, RFCOMM_UUID);
                sdp_list_free(proto_list, 0);
            }
            sdp_record_free(sdprec);
            sdp_list_free(response_list, 0);
        } else
            ast_debug(1, "No responses returned for device %s.\n", addr);
    } else
        ast_debug(1, "sdp_service_search_attr_req() failed on device %s.\n", addr);
 
    sdp_list_free(search_list, 0);
    sdp_list_free(attrid_list, 0);
    sdp_close(session);
 
    return port;
 
}

References ast_debug, if(), session, and status.

Referenced by handle_cli_mobile_search().

set_unloading()

static void set_unloading ( void  )

inlinestatic

Set the unloading flag.

Definition at line 4697 of file chan_mobile.c.

{
    ast_mutex_lock(&unload_mutex);
    unloading_flag = 1;
    ast_mutex_unlock(&unload_mutex);
}

References ast_mutex_lock, ast_mutex_unlock, unload_mutex, and unloading_flag.

Referenced by unload_module().

start_monitor()

static int start_monitor ( struct mbl_pvt *  pvt )

static

Definition at line 4263 of file chan_mobile.c.

{
 
    if (pvt->type == MBL_TYPE_PHONE) {
        pvt->hfp->rsock = pvt->rfcomm_socket;
 
        if (ast_pthread_create_background(&pvt->monitor_thread, NULL, do_monitor_phone, pvt) < 0) {
            pvt->monitor_thread = AST_PTHREADT_NULL;
            return 0;
        }
    } else {
        if (ast_pthread_create_background(&pvt->monitor_thread, NULL, do_monitor_headset, pvt) < 0) {
            pvt->monitor_thread = AST_PTHREADT_NULL;
            return 0;
        }
    }
 
    return 1;
 
}

References ast_pthread_create_background, AST_PTHREADT_NULL, do_monitor_headset(), do_monitor_phone(), mbl_pvt::hfp, MBL_TYPE_PHONE, mbl_pvt::monitor_thread, NULL, mbl_pvt::rfcomm_socket, hfp_pvt::rsock, and mbl_pvt::type.

Referenced by do_discovery().

unload_module()

static int unload_module ( void  )

static

Definition at line 4704 of file chan_mobile.c.

{
    struct mbl_pvt *pvt;
    struct adapter_pvt *adapter;
 
    /* First, take us out of the channel loop */
    ast_channel_unregister(&mbl_tech);
 
    /* Unregister the CLI & APP */
    ast_cli_unregister_multiple(mbl_cli, sizeof(mbl_cli) / sizeof(mbl_cli[0]));
    ast_unregister_application(app_mblstatus);
    ast_unregister_application(app_mblsendsms);
 
    /* signal everyone we are unloading */
    set_unloading();
 
    /* Kill the discovery thread */
    if (discovery_thread != AST_PTHREADT_NULL) {
        pthread_kill(discovery_thread, SIGURG);
        pthread_join(discovery_thread, NULL);
    }
 
    /* stop the sco listener threads */
    AST_RWLIST_WRLOCK(&adapters);
    AST_RWLIST_TRAVERSE(&adapters, adapter, entry) {
        pthread_kill(adapter->sco_listener_thread, SIGURG);
        pthread_join(adapter->sco_listener_thread, NULL);
    }
    AST_RWLIST_UNLOCK(&adapters);
 
    /* Destroy the device list */
    AST_RWLIST_WRLOCK(&devices);
    while ((pvt = AST_RWLIST_REMOVE_HEAD(&devices, entry))) {
        if (pvt->monitor_thread != AST_PTHREADT_NULL) {
            pthread_kill(pvt->monitor_thread, SIGURG);
            pthread_join(pvt->monitor_thread, NULL);
        }
 
        close(pvt->sco_socket);
        close(pvt->rfcomm_socket);
 
        msg_queue_flush(pvt);
 
        if (pvt->hfp) {
            ast_free(pvt->hfp);
        }
 
        ast_smoother_free(pvt->bt_out_smoother);
        ast_smoother_free(pvt->bt_in_smoother);
        ast_dsp_free(pvt->dsp);
        ast_sched_context_destroy(pvt->sched);
        ast_free(pvt);
    }
    AST_RWLIST_UNLOCK(&devices);
 
    /* Destroy the adapter list */
    AST_RWLIST_WRLOCK(&adapters);
    while ((adapter = AST_RWLIST_REMOVE_HEAD(&adapters, entry))) {
        close(adapter->sco_socket);
        io_context_destroy(adapter->io);
        io_context_destroy(adapter->accept_io);
        hci_close_dev(adapter->hci_socket);
        ast_free(adapter);
    }
    AST_RWLIST_UNLOCK(&adapters);
 
    if (sdp_session)
        sdp_close(sdp_session);
 
    ao2_ref(mbl_tech.capabilities, -1);
    mbl_tech.capabilities = NULL;
    return 0;
}

References adapter_pvt::accept_io, ao2_ref, app_mblsendsms, app_mblstatus, ast_channel_unregister(), ast_cli_unregister_multiple(), ast_dsp_free(), ast_free, AST_PTHREADT_NULL, AST_RWLIST_REMOVE_HEAD, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_sched_context_destroy(), ast_smoother_free(), ast_unregister_application(), mbl_pvt::bt_in_smoother, mbl_pvt::bt_out_smoother, ast_channel_tech::capabilities, discovery_thread, mbl_pvt::dsp, adapter_pvt::hci_socket, mbl_pvt::hfp, adapter_pvt::io, io_context_destroy(), mbl_cli, mbl_tech, mbl_pvt::monitor_thread, msg_queue_flush(), NULL, mbl_pvt::rfcomm_socket, mbl_pvt::sched, adapter_pvt::sco_listener_thread, adapter_pvt::sco_socket, mbl_pvt::sco_socket, sdp_session, and set_unloading().

Referenced by load_module().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Bluetooth Mobile Device Channel Driver" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_EXTENDED, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DRIVER, }

static

Definition at line 4840 of file chan_mobile.c.

adapters

struct adapters adapters = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

app_mblsendsms

char* app_mblsendsms = "MobileSendSMS"

static

Definition at line 209 of file chan_mobile.c.

Referenced by load_module(), and unload_module().

app_mblstatus

char* app_mblstatus = "MobileStatus"

static

Definition at line 201 of file chan_mobile.c.

Referenced by load_module(), and unload_module().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 4840 of file chan_mobile.c.

devices

struct devices devices = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

discovery_interval

int discovery_interval = 60

static

Definition at line 85 of file chan_mobile.c.

Referenced by do_discovery(), and mbl_load_config().

discovery_thread

pthread_t discovery_thread = AST_PTHREADT_NULL

static

Definition at line 86 of file chan_mobile.c.

Referenced by load_module(), and unload_module().

hfp_our_brsf

struct hfp_hf hfp_our_brsf

static

Definition at line 361 of file chan_mobile.c.

Referenced by do_monitor_phone().

mbl_cli

struct ast_cli_entry mbl_cli[]

static

Definition at line 193 of file chan_mobile.c.

Referenced by load_module(), and unload_module().

mbl_tech

struct ast_channel_tech mbl_tech

static

Definition at line 479 of file chan_mobile.c.

Referenced by load_module(), mbl_new(), and unload_module().

mblsendsms_desc

char* mblsendsms_desc

static

Initial value:

=
"MobileSendSms(Device,Dest,Message)\n"
"  Device - Id of device from mobile.conf\n"
"  Dest - destination\n"
"  Message - text of the message\n"

Definition at line 211 of file chan_mobile.c.

Referenced by load_module().

mblsendsms_synopsis

char* mblsendsms_synopsis = "MobileSendSMS(Device,Dest,Message)"

static

Definition at line 210 of file chan_mobile.c.

Referenced by load_module().

mblstatus_desc

char* mblstatus_desc

static

Initial value:

=
"MobileStatus(Device,Variable)\n"
"  Device - Id of mobile device from mobile.conf\n"
"  Variable - Variable to store status in will be 1-3.\n"
"             In order, Disconnected, Connected & Free, Connected & Busy.\n"

Definition at line 203 of file chan_mobile.c.

Referenced by load_module().

mblstatus_synopsis

char* mblstatus_synopsis = "MobileStatus(Device,Variable)"

static

Definition at line 202 of file chan_mobile.c.

Referenced by load_module().

sdp_session

sdp_session_t* sdp_session

static

Definition at line 87 of file chan_mobile.c.

Referenced by load_module(), and unload_module().

unload_mutex

ast_mutex_t unload_mutex = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Definition at line 89 of file chan_mobile.c.

Referenced by check_unloading(), and set_unloading().

unloading_flag

int unloading_flag = 0

static

Definition at line 90 of file chan_mobile.c.

Referenced by check_unloading(), and set_unloading().