backtrace: Refactor ast_bt_get_symbols so it doesn't crash
[asterisk/asterisk.git] / addons / chan_mobile.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \brief Bluetooth Mobile Device channel driver
22  *
23  * \author Dave Bowerman <david.bowerman@gmail.com>
24  *
25  * \ingroup channel_drivers
26  */
27
28 /*! \li \ref chan_mobile.c uses the configuration file \ref chan_mobile.conf
29  * \addtogroup configuration_file Configuration Files
30  */
31
32 /*!
33  * \page chan_mobile.conf chan_mobile.conf
34  * \verbinclude chan_mobile.conf.sample
35  */
36
37 /*** MODULEINFO
38         <depend>bluetooth</depend>
39         <defaultenabled>no</defaultenabled>
40         <support_level>extended</support_level>
41  ***/
42
43 #include "asterisk.h"
44
45 #include <pthread.h>
46 #include <signal.h>
47
48 #include <bluetooth/bluetooth.h>
49 #include <bluetooth/hci.h>
50 #include <bluetooth/hci_lib.h>
51 #include <bluetooth/sdp.h>
52 #include <bluetooth/sdp_lib.h>
53 #include <bluetooth/rfcomm.h>
54 #include <bluetooth/sco.h>
55 #include <bluetooth/l2cap.h>
56
57 #include "asterisk/compat.h"
58 #include "asterisk/lock.h"
59 #include "asterisk/callerid.h"
60 #include "asterisk/channel.h"
61 #include "asterisk/config.h"
62 #include "asterisk/logger.h"
63 #include "asterisk/module.h"
64 #include "asterisk/pbx.h"
65 #include "asterisk/options.h"
66 #include "asterisk/utils.h"
67 #include "asterisk/linkedlists.h"
68 #include "asterisk/cli.h"
69 #include "asterisk/devicestate.h"
70 #include "asterisk/causes.h"
71 #include "asterisk/dsp.h"
72 #include "asterisk/app.h"
73 #include "asterisk/manager.h"
74 #include "asterisk/io.h"
75 #include "asterisk/smoother.h"
76 #include "asterisk/format_cache.h"
77
78 #define MBL_CONFIG "chan_mobile.conf"
79 #define MBL_CONFIG_OLD "mobile.conf"
80
81 #define DEVICE_FRAME_SIZE 48
82 #define DEVICE_FRAME_FORMAT ast_format_slin
83 #define CHANNEL_FRAME_SIZE 320
84
85 static int discovery_interval = 60;                     /* The device discovery interval, default 60 seconds. */
86 static pthread_t discovery_thread = AST_PTHREADT_NULL;  /* The discovery thread */
87 static sdp_session_t *sdp_session;
88
89 AST_MUTEX_DEFINE_STATIC(unload_mutex);
90 static int unloading_flag = 0;
91 static inline int check_unloading(void);
92 static inline void set_unloading(void);
93
94 enum mbl_type {
95         MBL_TYPE_PHONE,
96         MBL_TYPE_HEADSET
97 };
98
99 struct adapter_pvt {
100         int dev_id;                                     /* device id */
101         int hci_socket;                                 /* device descriptor */
102         char id[31];                                    /* the 'name' from mobile.conf */
103         bdaddr_t addr;                                  /* adddress of adapter */
104         unsigned int inuse:1;                           /* are we in use ? */
105         unsigned int alignment_detection:1;             /* do alignment detection on this adpater? */
106         struct io_context *io;                          /*!< io context for audio connections */
107         struct io_context *accept_io;                   /*!< io context for sco listener */
108         int *sco_id;                                    /*!< the io context id of the sco listener socket */
109         int sco_socket;                                 /*!< sco listener socket */
110         pthread_t sco_listener_thread;                  /*!< sco listener thread */
111         AST_LIST_ENTRY(adapter_pvt) entry;
112 };
113
114 static AST_RWLIST_HEAD_STATIC(adapters, adapter_pvt);
115
116 struct msg_queue_entry;
117 struct hfp_pvt;
118 struct mbl_pvt {
119         struct ast_channel *owner;                      /* Channel we belong to, possibly NULL */
120         struct ast_frame fr;                            /* "null" frame */
121         ast_mutex_t lock;                               /*!< pvt lock */
122         /*! queue for messages we are expecting */
123         AST_LIST_HEAD_NOLOCK(msg_queue, msg_queue_entry) msg_queue;
124         enum mbl_type type;                             /* Phone or Headset */
125         char id[31];                                    /* The id from mobile.conf */
126         int group;                                      /* group number for group dialling */
127         bdaddr_t addr;                                  /* address of device */
128         struct adapter_pvt *adapter;                    /* the adapter we use */
129         char context[AST_MAX_CONTEXT];                  /* the context for incoming calls */
130         struct hfp_pvt *hfp;                            /*!< hfp pvt */
131         int rfcomm_port;                                /* rfcomm port number */
132         int rfcomm_socket;                              /* rfcomm socket descriptor */
133         char rfcomm_buf[256];
134         char io_buf[CHANNEL_FRAME_SIZE + AST_FRIENDLY_OFFSET];
135         struct ast_smoother *smoother;                  /* our smoother, for making 48 byte frames */
136         int sco_socket;                                 /* sco socket descriptor */
137         pthread_t monitor_thread;                       /* monitor thread handle */
138         int timeout;                                    /*!< used to set the timeout for rfcomm data (may be used in the future) */
139         unsigned int no_callsetup:1;
140         unsigned int has_sms:1;
141         unsigned int do_alignment_detection:1;
142         unsigned int alignment_detection_triggered:1;
143         unsigned int blackberry:1;
144         short alignment_samples[4];
145         int alignment_count;
146         int ring_sched_id;
147         struct ast_dsp *dsp;
148         struct ast_sched_context *sched;
149         int hangupcause;
150
151         /* flags */
152         unsigned int outgoing:1;        /*!< outgoing call */
153         unsigned int incoming:1;        /*!< incoming call */
154         unsigned int outgoing_sms:1;    /*!< outgoing sms */
155         unsigned int incoming_sms:1;    /*!< outgoing sms */
156         unsigned int needcallerid:1;    /*!< we need callerid */
157         unsigned int needchup:1;        /*!< we need to send a chup */
158         unsigned int needring:1;        /*!< we need to send a RING */
159         unsigned int answered:1;        /*!< we sent/received an answer */
160         unsigned int connected:1;       /*!< do we have an rfcomm connection to a device */
161
162         AST_LIST_ENTRY(mbl_pvt) entry;
163 };
164
165 /*! Structure used by hfp_parse_clip to return two items */
166 struct cidinfo {
167         char *cnum;
168         char *cnam;
169 };
170
171 static AST_RWLIST_HEAD_STATIC(devices, mbl_pvt);
172
173 static int handle_response_ok(struct mbl_pvt *pvt, char *buf);
174 static int handle_response_error(struct mbl_pvt *pvt, char *buf);
175 static int handle_response_ciev(struct mbl_pvt *pvt, char *buf);
176 static int handle_response_clip(struct mbl_pvt *pvt, char *buf);
177 static int handle_response_ring(struct mbl_pvt *pvt, char *buf);
178 static int handle_response_cmti(struct mbl_pvt *pvt, char *buf);
179 static int handle_response_cmgr(struct mbl_pvt *pvt, char *buf);
180 static int handle_response_cusd(struct mbl_pvt *pvt, char *buf);
181 static int handle_response_busy(struct mbl_pvt *pvt);
182 static int handle_response_no_dialtone(struct mbl_pvt *pvt, char *buf);
183 static int handle_response_no_carrier(struct mbl_pvt *pvt, char *buf);
184 static int handle_sms_prompt(struct mbl_pvt *pvt, char *buf);
185
186 /* CLI stuff */
187 static char *handle_cli_mobile_show_devices(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
188 static char *handle_cli_mobile_search(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
189 static char *handle_cli_mobile_rfcomm(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
190 static char *handle_cli_mobile_cusd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
191
192 static struct ast_cli_entry mbl_cli[] = {
193         AST_CLI_DEFINE(handle_cli_mobile_show_devices, "Show Bluetooth Cell / Mobile devices"),
194         AST_CLI_DEFINE(handle_cli_mobile_search,       "Search for Bluetooth Cell / Mobile devices"),
195         AST_CLI_DEFINE(handle_cli_mobile_rfcomm,       "Send commands to the rfcomm port for debugging"),
196         AST_CLI_DEFINE(handle_cli_mobile_cusd,         "Send CUSD commands to the mobile"),
197 };
198
199 /* App stuff */
200 static char *app_mblstatus = "MobileStatus";
201 static char *mblstatus_synopsis = "MobileStatus(Device,Variable)";
202 static char *mblstatus_desc =
203 "MobileStatus(Device,Variable)\n"
204 "  Device - Id of mobile device from mobile.conf\n"
205 "  Variable - Variable to store status in will be 1-3.\n"
206 "             In order, Disconnected, Connected & Free, Connected & Busy.\n";
207
208 static char *app_mblsendsms = "MobileSendSMS";
209 static char *mblsendsms_synopsis = "MobileSendSMS(Device,Dest,Message)";
210 static char *mblsendsms_desc =
211 "MobileSendSms(Device,Dest,Message)\n"
212 "  Device - Id of device from mobile.conf\n"
213 "  Dest - destination\n"
214 "  Message - text of the message\n";
215
216 static struct ast_channel *mbl_new(int state, struct mbl_pvt *pvt, struct cidinfo *cidinfo,
217                 const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor);
218 static struct ast_channel *mbl_request(const char *type, struct ast_format_cap *cap,
219                 const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause);
220 static int mbl_call(struct ast_channel *ast, const char *dest, int timeout);
221 static int mbl_hangup(struct ast_channel *ast);
222 static int mbl_answer(struct ast_channel *ast);
223 static int mbl_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
224 static struct ast_frame *mbl_read(struct ast_channel *ast);
225 static int mbl_write(struct ast_channel *ast, struct ast_frame *frame);
226 static int mbl_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
227 static int mbl_devicestate(const char *data);
228
229 static void do_alignment_detection(struct mbl_pvt *pvt, char *buf, int buflen);
230
231 static int mbl_queue_control(struct mbl_pvt *pvt, enum ast_control_frame_type control);
232 static int mbl_queue_hangup(struct mbl_pvt *pvt);
233 static int mbl_ast_hangup(struct mbl_pvt *pvt);
234 static int mbl_has_service(struct mbl_pvt *pvt);
235
236 static int rfcomm_connect(bdaddr_t src, bdaddr_t dst, int remote_channel);
237 static int rfcomm_write(int rsock, char *buf);
238 static int rfcomm_write_full(int rsock, char *buf, size_t count);
239 static int rfcomm_wait(int rsock, int *ms);
240 static ssize_t rfcomm_read(int rsock, char *buf, size_t count);
241
242 static int sco_connect(bdaddr_t src, bdaddr_t dst);
243 static int sco_write(int s, char *buf, int len);
244 static int sco_accept(int *id, int fd, short events, void *data);
245 static int sco_bind(struct adapter_pvt *adapter);
246
247 static void *do_sco_listen(void *data);
248 static int sdp_search(char *addr, int profile);
249
250 static int headset_send_ring(const void *data);
251
252 /*
253  * bluetooth handsfree profile helpers
254  */
255
256 #define HFP_HF_ECNR     (1 << 0)
257 #define HFP_HF_CW       (1 << 1)
258 #define HFP_HF_CID      (1 << 2)
259 #define HFP_HF_VOICE    (1 << 3)
260 #define HFP_HF_VOLUME   (1 << 4)
261 #define HFP_HF_STATUS   (1 << 5)
262 #define HFP_HF_CONTROL  (1 << 6)
263
264 #define HFP_AG_CW       (1 << 0)
265 #define HFP_AG_ECNR     (1 << 1)
266 #define HFP_AG_VOICE    (1 << 2)
267 #define HFP_AG_RING     (1 << 3)
268 #define HFP_AG_TAG      (1 << 4)
269 #define HFP_AG_REJECT   (1 << 5)
270 #define HFP_AG_STATUS   (1 << 6)
271 #define HFP_AG_CONTROL  (1 << 7)
272 #define HFP_AG_ERRORS   (1 << 8)
273
274 #define HFP_CIND_UNKNOWN        -1
275 #define HFP_CIND_NONE           0
276 #define HFP_CIND_SERVICE        1
277 #define HFP_CIND_CALL           2
278 #define HFP_CIND_CALLSETUP      3
279 #define HFP_CIND_CALLHELD       4
280 #define HFP_CIND_SIGNAL         5
281 #define HFP_CIND_ROAM           6
282 #define HFP_CIND_BATTCHG        7
283
284 /* call indicator values */
285 #define HFP_CIND_CALL_NONE      0
286 #define HFP_CIND_CALL_ACTIVE    1
287
288 /* callsetup indicator values */
289 #define HFP_CIND_CALLSETUP_NONE         0
290 #define HFP_CIND_CALLSETUP_INCOMING     1
291 #define HFP_CIND_CALLSETUP_OUTGOING     2
292 #define HFP_CIND_CALLSETUP_ALERTING     3
293
294 /* service indicator values */
295 #define HFP_CIND_SERVICE_NONE           0
296 #define HFP_CIND_SERVICE_AVAILABLE      1
297
298 /*!
299  * \brief This struct holds HFP features that we support.
300  */
301 struct hfp_hf {
302         int ecnr:1;     /*!< echo-cancel/noise reduction */
303         int cw:1;       /*!< call waiting and three way calling */
304         int cid:1;      /*!< cli presentation (callier id) */
305         int voice:1;    /*!< voice recognition activation */
306         int volume:1;   /*!< remote volume control */
307         int status:1;   /*!< enhanced call status */
308         int control:1;  /*!< enhanced call control*/
309 };
310
311 /*!
312  * \brief This struct holds HFP features the AG supports.
313  */
314 struct hfp_ag {
315         int cw:1;       /*!< three way calling */
316         int ecnr:1;     /*!< echo-cancel/noise reduction */
317         int voice:1;    /*!< voice recognition */
318         int ring:1;     /*!< in band ring tone capability */
319         int tag:1;      /*!< attach a number to a voice tag */
320         int reject:1;   /*!< ability to reject a call */
321         int status:1;   /*!< enhanced call status */
322         int control:1;  /*!< enhanced call control*/
323         int errors:1;   /*!< extended error result codes*/
324 };
325
326 /*!
327  * \brief This struct holds mappings for indications.
328  */
329 struct hfp_cind {
330         int service;    /*!< whether we have service or not */
331         int call;       /*!< call state */
332         int callsetup;  /*!< bluetooth call setup indications */
333         int callheld;   /*!< bluetooth call hold indications */
334         int signal;     /*!< signal strength */
335         int roam;       /*!< roaming indicator */
336         int battchg;    /*!< battery charge indicator */
337 };
338
339
340 /*!
341  * \brief This struct holds state information about the current hfp connection.
342  */
343 struct hfp_pvt {
344         struct mbl_pvt *owner;          /*!< the mbl_pvt struct that owns this struct */
345         int initialized:1;              /*!< whether a service level connection exists or not */
346         int nocallsetup:1;              /*!< whether we detected a callsetup indicator */
347         struct hfp_ag brsf;             /*!< the supported feature set of the AG */
348         int cind_index[16];             /*!< the cind/ciev index to name mapping for this AG */
349         int cind_state[16];             /*!< the cind/ciev state for this AG */
350         struct hfp_cind cind_map;       /*!< the cind name to index mapping for this AG */
351         int rsock;                      /*!< our rfcomm socket */
352         int rport;                      /*!< our rfcomm port */
353         int sent_alerting;              /*!< have we sent alerting? */
354 };
355
356
357 /* Our supported features.
358  * we only support caller id
359  */
360 static struct hfp_hf hfp_our_brsf = {
361         .ecnr = 0,
362         .cw = 0,
363         .cid = 1,
364         .voice = 0,
365         .volume = 0,
366         .status = 0,
367         .control = 0,
368 };
369
370
371 static int hfp_parse_ciev(struct hfp_pvt *hfp, char *buf, int *value);
372 static struct cidinfo hfp_parse_clip(struct hfp_pvt *hfp, char *buf);
373 static int parse_next_token(char string[], const int start, const char delim);
374 static int hfp_parse_cmti(struct hfp_pvt *hfp, char *buf);
375 static int hfp_parse_cmgr(struct hfp_pvt *hfp, char *buf, char **from_number, char **text);
376 static int hfp_parse_brsf(struct hfp_pvt *hfp, const char *buf);
377 static int hfp_parse_cind(struct hfp_pvt *hfp, char *buf);
378 static int hfp_parse_cind_test(struct hfp_pvt *hfp, char *buf);
379 static char *hfp_parse_cusd(struct hfp_pvt *hfp, char *buf);
380
381 static int hfp_brsf2int(struct hfp_hf *hf);
382 static struct hfp_ag *hfp_int2brsf(int brsf, struct hfp_ag *ag);
383
384 static int hfp_send_brsf(struct hfp_pvt *hfp, struct hfp_hf *brsf);
385 static int hfp_send_cind(struct hfp_pvt *hfp);
386 static int hfp_send_cind_test(struct hfp_pvt *hfp);
387 static int hfp_send_cmer(struct hfp_pvt *hfp, int status);
388 static int hfp_send_clip(struct hfp_pvt *hfp, int status);
389 static int hfp_send_vgs(struct hfp_pvt *hfp, int value);
390
391 #if 0
392 static int hfp_send_vgm(struct hfp_pvt *hfp, int value);
393 #endif
394 static int hfp_send_dtmf(struct hfp_pvt *hfp, char digit);
395 static int hfp_send_cmgf(struct hfp_pvt *hfp, int mode);
396 static int hfp_send_cnmi(struct hfp_pvt *hfp);
397 static int hfp_send_cmgr(struct hfp_pvt *hfp, int index);
398 static int hfp_send_cmgs(struct hfp_pvt *hfp, const char *number);
399 static int hfp_send_sms_text(struct hfp_pvt *hfp, const char *message);
400 static int hfp_send_chup(struct hfp_pvt *hfp);
401 static int hfp_send_atd(struct hfp_pvt *hfp, const char *number);
402 static int hfp_send_ata(struct hfp_pvt *hfp);
403 static int hfp_send_cusd(struct hfp_pvt *hfp, const char *code);
404
405 /*
406  * bluetooth headset profile helpers
407  */
408 static int hsp_send_ok(int rsock);
409 static int hsp_send_error(int rsock);
410 static int hsp_send_vgs(int rsock, int gain);
411 static int hsp_send_vgm(int rsock, int gain);
412 static int hsp_send_ring(int rsock);
413
414
415 /*
416  * Hayes AT command helpers
417  */
418 typedef enum {
419         /* errors */
420         AT_PARSE_ERROR = -2,
421         AT_READ_ERROR = -1,
422         AT_UNKNOWN = 0,
423         /* at responses */
424         AT_OK,
425         AT_ERROR,
426         AT_RING,
427         AT_BRSF,
428         AT_CIND,
429         AT_CIEV,
430         AT_CLIP,
431         AT_CMTI,
432         AT_CMGR,
433         AT_SMS_PROMPT,
434         AT_CMS_ERROR,
435         /* at commands */
436         AT_A,
437         AT_D,
438         AT_CHUP,
439         AT_CKPD,
440         AT_CMGS,
441         AT_VGM,
442         AT_VGS,
443         AT_VTS,
444         AT_CMGF,
445         AT_CNMI,
446         AT_CMER,
447         AT_CIND_TEST,
448         AT_CUSD,
449         AT_BUSY,
450         AT_NO_DIALTONE,
451         AT_NO_CARRIER,
452         AT_ECAM,
453 } at_message_t;
454
455 static int at_match_prefix(char *buf, char *prefix);
456 static at_message_t at_read_full(int rsock, char *buf, size_t count);
457 static inline const char *at_msg2str(at_message_t msg);
458
459 struct msg_queue_entry {
460         at_message_t expected;
461         at_message_t response_to;
462         void *data;
463
464         AST_LIST_ENTRY(msg_queue_entry) entry;
465 };
466
467 static int msg_queue_push(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to);
468 static int msg_queue_push_data(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to, void *data);
469 static struct msg_queue_entry *msg_queue_pop(struct mbl_pvt *pvt);
470 static void msg_queue_free_and_pop(struct mbl_pvt *pvt);
471 static void msg_queue_flush(struct mbl_pvt *pvt);
472 static struct msg_queue_entry *msg_queue_head(struct mbl_pvt *pvt);
473
474 /*
475  * channel stuff
476  */
477
478 static struct ast_channel_tech mbl_tech = {
479         .type = "Mobile",
480         .description = "Bluetooth Mobile Device Channel Driver",
481         .requester = mbl_request,
482         .call = mbl_call,
483         .hangup = mbl_hangup,
484         .answer = mbl_answer,
485         .send_digit_end = mbl_digit_end,
486         .read = mbl_read,
487         .write = mbl_write,
488         .fixup = mbl_fixup,
489         .devicestate = mbl_devicestate
490 };
491
492 /* CLI Commands implementation */
493
494 static char *handle_cli_mobile_show_devices(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
495 {
496         struct mbl_pvt *pvt;
497         char bdaddr[18];
498         char group[6];
499
500 #define FORMAT1 "%-15.15s %-17.17s %-5.5s %-15.15s %-9.9s %-10.10s %-3.3s\n"
501
502         switch (cmd) {
503         case CLI_INIT:
504                 e->command = "mobile show devices";
505                 e->usage =
506                         "Usage: mobile show devices\n"
507                         "       Shows the state of Bluetooth Cell / Mobile devices.\n";
508                 return NULL;
509         case CLI_GENERATE:
510                 return NULL;
511         }
512
513         if (a->argc != 3)
514                 return CLI_SHOWUSAGE;
515
516         ast_cli(a->fd, FORMAT1, "ID", "Address", "Group", "Adapter", "Connected", "State", "SMS");
517         AST_RWLIST_RDLOCK(&devices);
518         AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
519                 ast_mutex_lock(&pvt->lock);
520                 ba2str(&pvt->addr, bdaddr);
521                 snprintf(group, sizeof(group), "%d", pvt->group);
522                 ast_cli(a->fd, FORMAT1,
523                                 pvt->id,
524                                 bdaddr,
525                                 group,
526                                 pvt->adapter->id,
527                                 pvt->connected ? "Yes" : "No",
528                                 (!pvt->connected) ? "None" : (pvt->owner) ? "Busy" : (pvt->outgoing_sms || pvt->incoming_sms) ? "SMS" : (mbl_has_service(pvt)) ? "Free" : "No Service",
529                                 (pvt->has_sms) ? "Yes" : "No"
530                        );
531                 ast_mutex_unlock(&pvt->lock);
532         }
533         AST_RWLIST_UNLOCK(&devices);
534
535 #undef FORMAT1
536
537         return CLI_SUCCESS;
538 }
539
540 static char *handle_cli_mobile_search(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
541 {
542         struct adapter_pvt *adapter;
543         inquiry_info *ii = NULL;
544         int max_rsp, num_rsp;
545         int len, flags;
546         int i, phport, hsport;
547         char addr[19] = {0};
548         char name[31] = {0};
549
550 #define FORMAT1 "%-17.17s %-30.30s %-6.6s %-7.7s %-4.4s\n"
551 #define FORMAT2 "%-17.17s %-30.30s %-6.6s %-7.7s %d\n"
552
553         switch (cmd) {
554         case CLI_INIT:
555                 e->command = "mobile search";
556                 e->usage =
557                         "Usage: mobile search\n"
558                         "       Searches for Bluetooth Cell / Mobile devices in range.\n";
559                 return NULL;
560         case CLI_GENERATE:
561                 return NULL;
562         }
563
564         if (a->argc != 2)
565                 return CLI_SHOWUSAGE;
566
567         /* find a free adapter */
568         AST_RWLIST_RDLOCK(&adapters);
569         AST_RWLIST_TRAVERSE(&adapters, adapter, entry) {
570                 if (!adapter->inuse)
571                         break;
572         }
573         AST_RWLIST_UNLOCK(&adapters);
574
575         if (!adapter) {
576                 ast_cli(a->fd, "All Bluetooth adapters are in use at this time.\n");
577                 return CLI_SUCCESS;
578         }
579
580         len  = 8;
581         max_rsp = 255;
582         flags = IREQ_CACHE_FLUSH;
583
584         ii = ast_alloca(max_rsp * sizeof(inquiry_info));
585         num_rsp = hci_inquiry(adapter->dev_id, len, max_rsp, NULL, &ii, flags);
586         if (num_rsp > 0) {
587                 ast_cli(a->fd, FORMAT1, "Address", "Name", "Usable", "Type", "Port");
588                 for (i = 0; i < num_rsp; i++) {
589                         ba2str(&(ii + i)->bdaddr, addr);
590                         name[0] = 0x00;
591                         if (hci_read_remote_name(adapter->hci_socket, &(ii + i)->bdaddr, sizeof(name) - 1, name, 0) < 0)
592                                 strcpy(name, "[unknown]");
593                         phport = sdp_search(addr, HANDSFREE_AGW_PROFILE_ID);
594                         if (!phport)
595                                 hsport = sdp_search(addr, HEADSET_PROFILE_ID);
596                         else
597                                 hsport = 0;
598                         ast_cli(a->fd, FORMAT2, addr, name, (phport > 0 || hsport > 0) ? "Yes" : "No",
599                                 (phport > 0) ? "Phone" : "Headset", (phport > 0) ? phport : hsport);
600                 }
601         } else
602                 ast_cli(a->fd, "No Bluetooth Cell / Mobile devices found.\n");
603
604 #undef FORMAT1
605 #undef FORMAT2
606
607         return CLI_SUCCESS;
608 }
609
610 static char *handle_cli_mobile_rfcomm(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
611 {
612         char buf[128];
613         struct mbl_pvt *pvt = NULL;
614
615         switch (cmd) {
616         case CLI_INIT:
617                 e->command = "mobile rfcomm";
618                 e->usage =
619                         "Usage: mobile rfcomm <device ID> <command>\n"
620                         "       Send <command> to the rfcomm port on the device\n"
621                         "       with the specified <device ID>.\n";
622                 return NULL;
623         case CLI_GENERATE:
624                 return NULL;
625         }
626
627         if (a->argc != 4)
628                 return CLI_SHOWUSAGE;
629
630         AST_RWLIST_RDLOCK(&devices);
631         AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
632                 if (!strcmp(pvt->id, a->argv[2]))
633                         break;
634         }
635         AST_RWLIST_UNLOCK(&devices);
636
637         if (!pvt) {
638                 ast_cli(a->fd, "Device %s not found.\n", a->argv[2]);
639                 goto e_return;
640         }
641
642         ast_mutex_lock(&pvt->lock);
643         if (!pvt->connected) {
644                 ast_cli(a->fd, "Device %s not connected.\n", a->argv[2]);
645                 goto e_unlock_pvt;
646         }
647
648         snprintf(buf, sizeof(buf), "%s\r", a->argv[3]);
649         rfcomm_write(pvt->rfcomm_socket, buf);
650         msg_queue_push(pvt, AT_OK, AT_UNKNOWN);
651
652 e_unlock_pvt:
653         ast_mutex_unlock(&pvt->lock);
654 e_return:
655         return CLI_SUCCESS;
656 }
657
658 static char *handle_cli_mobile_cusd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
659 {
660         char buf[128];
661         struct mbl_pvt *pvt = NULL;
662
663         switch (cmd) {
664         case CLI_INIT:
665                 e->command = "mobile cusd";
666                 e->usage =
667                         "Usage: mobile cusd <device ID> <command>\n"
668                         "       Send cusd <command> to the rfcomm port on the device\n"
669                         "       with the specified <device ID>.\n";
670                 return NULL;
671         case CLI_GENERATE:
672                 return NULL;
673         }
674
675         if (a->argc != 4)
676                 return CLI_SHOWUSAGE;
677
678         AST_RWLIST_RDLOCK(&devices);
679         AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
680                 if (!strcmp(pvt->id, a->argv[2]))
681                         break;
682         }
683         AST_RWLIST_UNLOCK(&devices);
684
685         if (!pvt) {
686                 ast_cli(a->fd, "Device %s not found.\n", a->argv[2]);
687                 goto e_return;
688         }
689
690         ast_mutex_lock(&pvt->lock);
691         if (!pvt->connected) {
692                 ast_cli(a->fd, "Device %s not connected.\n", a->argv[2]);
693                 goto e_unlock_pvt;
694         }
695
696         snprintf(buf, sizeof(buf), "%s", a->argv[3]);
697         if (hfp_send_cusd(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CUSD)) {
698                 ast_cli(a->fd, "[%s] error sending CUSD\n", pvt->id);
699                 goto e_unlock_pvt;
700         }
701
702 e_unlock_pvt:
703         ast_mutex_unlock(&pvt->lock);
704 e_return:
705         return CLI_SUCCESS;
706 }
707
708 /*
709
710         Dialplan applications implementation
711
712 */
713
714 static int mbl_status_exec(struct ast_channel *ast, const char *data)
715 {
716
717         struct mbl_pvt *pvt;
718         char *parse;
719         int stat;
720         char status[2];
721
722         AST_DECLARE_APP_ARGS(args,
723                 AST_APP_ARG(device);
724                 AST_APP_ARG(variable);
725         );
726
727         if (ast_strlen_zero(data))
728                 return -1;
729
730         parse = ast_strdupa(data);
731
732         AST_STANDARD_APP_ARGS(args, parse);
733
734         if (ast_strlen_zero(args.device) || ast_strlen_zero(args.variable))
735                 return -1;
736
737         stat = 1;
738
739         AST_RWLIST_RDLOCK(&devices);
740         AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
741                 if (!strcmp(pvt->id, args.device))
742                         break;
743         }
744         AST_RWLIST_UNLOCK(&devices);
745
746         if (pvt) {
747                 ast_mutex_lock(&pvt->lock);
748                 if (pvt->connected)
749                         stat = 2;
750                 if (pvt->owner)
751                         stat = 3;
752                 ast_mutex_unlock(&pvt->lock);
753         }
754
755         snprintf(status, sizeof(status), "%d", stat);
756         pbx_builtin_setvar_helper(ast, args.variable, status);
757
758         return 0;
759
760 }
761
762 static int mbl_sendsms_exec(struct ast_channel *ast, const char *data)
763 {
764
765         struct mbl_pvt *pvt;
766         char *parse, *message;
767
768         AST_DECLARE_APP_ARGS(args,
769                 AST_APP_ARG(device);
770                 AST_APP_ARG(dest);
771                 AST_APP_ARG(message);
772         );
773
774         if (ast_strlen_zero(data))
775                 return -1;
776
777         parse = ast_strdupa(data);
778
779         AST_STANDARD_APP_ARGS(args, parse);
780
781         if (ast_strlen_zero(args.device)) {
782                 ast_log(LOG_ERROR,"NULL device for message -- SMS will not be sent.\n");
783                 return -1;
784         }
785
786         if (ast_strlen_zero(args.dest)) {
787                 ast_log(LOG_ERROR,"NULL destination for message -- SMS will not be sent.\n");
788                 return -1;
789         }
790
791         if (ast_strlen_zero(args.message)) {
792                 ast_log(LOG_ERROR,"NULL Message to be sent -- SMS will not be sent.\n");
793                 return -1;
794         }
795
796         AST_RWLIST_RDLOCK(&devices);
797         AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
798                 if (!strcmp(pvt->id, args.device))
799                         break;
800         }
801         AST_RWLIST_UNLOCK(&devices);
802
803         if (!pvt) {
804                 ast_log(LOG_ERROR,"Bluetooth device %s wasn't found in the list -- SMS will not be sent.\n", args.device);
805                 goto e_return;
806         }
807
808         ast_mutex_lock(&pvt->lock);
809         if (!pvt->connected) {
810                 ast_log(LOG_ERROR,"Bluetooth device %s wasn't connected -- SMS will not be sent.\n", args.device);
811                 goto e_unlock_pvt;
812         }
813
814         if (!pvt->has_sms) {
815                 ast_log(LOG_ERROR,"Bluetooth device %s doesn't handle SMS -- SMS will not be sent.\n", args.device);
816                 goto e_unlock_pvt;
817         }
818
819         message = ast_strdup(args.message);
820
821         if (hfp_send_cmgs(pvt->hfp, args.dest)
822                 || msg_queue_push_data(pvt, AT_SMS_PROMPT, AT_CMGS, message)) {
823
824                 ast_log(LOG_ERROR, "[%s] problem sending SMS message\n", pvt->id);
825                 goto e_free_message;
826         }
827
828         ast_mutex_unlock(&pvt->lock);
829
830         return 0;
831
832 e_free_message:
833         ast_free(message);
834 e_unlock_pvt:
835         ast_mutex_unlock(&pvt->lock);
836 e_return:
837         return -1;
838 }
839
840 /*
841
842         Channel Driver callbacks
843
844 */
845
846 static struct ast_channel *mbl_new(int state, struct mbl_pvt *pvt, struct cidinfo *cidinfo,
847                 const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor)
848 {
849         struct ast_channel *chn;
850
851         pvt->answered = 0;
852         pvt->alignment_count = 0;
853         pvt->alignment_detection_triggered = 0;
854         if (pvt->adapter->alignment_detection)
855                 pvt->do_alignment_detection = 1;
856         else
857                 pvt->do_alignment_detection = 0;
858
859         ast_smoother_reset(pvt->smoother, DEVICE_FRAME_SIZE);
860         ast_dsp_digitreset(pvt->dsp);
861
862         chn = ast_channel_alloc(1, state,
863                 cidinfo ? cidinfo->cnum : NULL,
864                 cidinfo ? cidinfo->cnam : NULL,
865                 0, 0, pvt->context, assignedids, requestor, 0,
866                 "Mobile/%s-%04lx", pvt->id, ast_random() & 0xffff);
867         if (!chn) {
868                 goto e_return;
869         }
870
871         ast_channel_tech_set(chn, &mbl_tech);
872         ast_channel_nativeformats_set(chn, mbl_tech.capabilities);
873         ast_channel_set_rawreadformat(chn, DEVICE_FRAME_FORMAT);
874         ast_channel_set_rawwriteformat(chn, DEVICE_FRAME_FORMAT);
875         ast_channel_set_writeformat(chn, DEVICE_FRAME_FORMAT);
876         ast_channel_set_readformat(chn, DEVICE_FRAME_FORMAT);
877         ast_channel_tech_pvt_set(chn, pvt);
878
879         if (state == AST_STATE_RING)
880                 ast_channel_rings_set(chn, 1);
881
882         ast_channel_language_set(chn, "en");
883         pvt->owner = chn;
884
885         if (pvt->sco_socket != -1) {
886                 ast_channel_set_fd(chn, 0, pvt->sco_socket);
887         }
888         ast_channel_unlock(chn);
889
890         return chn;
891
892 e_return:
893         return NULL;
894 }
895
896 static struct ast_channel *mbl_request(const char *type, struct ast_format_cap *cap,
897                 const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
898 {
899
900         struct ast_channel *chn = NULL;
901         struct mbl_pvt *pvt;
902         char *dest_dev = NULL;
903         char *dest_num = NULL;
904         int group = -1;
905
906         if (!data) {
907                 ast_log(LOG_WARNING, "Channel requested with no data\n");
908                 *cause = AST_CAUSE_INCOMPATIBLE_DESTINATION;
909                 return NULL;
910         }
911
912         if (ast_format_cap_iscompatible_format(cap, DEVICE_FRAME_FORMAT) == AST_FORMAT_CMP_NOT_EQUAL) {
913                 struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
914                 ast_log(LOG_WARNING, "Asked to get a channel of unsupported format '%s'\n", ast_format_cap_get_names(cap, &codec_buf));
915                 *cause = AST_CAUSE_FACILITY_NOT_IMPLEMENTED;
916                 return NULL;
917         }
918
919         dest_dev = ast_strdupa(data);
920
921         dest_num = strchr(dest_dev, '/');
922         if (dest_num)
923                 *dest_num++ = 0x00;
924
925         if (((dest_dev[0] == 'g') || (dest_dev[0] == 'G')) && ((dest_dev[1] >= '0') && (dest_dev[1] <= '9'))) {
926                 group = atoi(&dest_dev[1]);
927         }
928
929         /* Find requested device and make sure it's connected. */
930         AST_RWLIST_RDLOCK(&devices);
931         AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
932                 if (group > -1 && pvt->group == group && pvt->connected && !pvt->owner) {
933                         if (!mbl_has_service(pvt)) {
934                                 continue;
935                         }
936
937                         break;
938                 } else if (!strcmp(pvt->id, dest_dev)) {
939                         break;
940                 }
941         }
942         AST_RWLIST_UNLOCK(&devices);
943         if (!pvt || !pvt->connected || pvt->owner) {
944                 ast_log(LOG_WARNING, "Request to call on device %s which is not connected / already in use.\n", dest_dev);
945                 *cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
946                 return NULL;
947         }
948
949         if ((pvt->type == MBL_TYPE_PHONE) && !dest_num) {
950                 ast_log(LOG_WARNING, "Can't determine destination number.\n");
951                 *cause = AST_CAUSE_INCOMPATIBLE_DESTINATION;
952                 return NULL;
953         }
954
955         ast_mutex_lock(&pvt->lock);
956         chn = mbl_new(AST_STATE_DOWN, pvt, NULL, assignedids, requestor);
957         ast_mutex_unlock(&pvt->lock);
958         if (!chn) {
959                 ast_log(LOG_WARNING, "Unable to allocate channel structure.\n");
960                 *cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
961                 return NULL;
962         }
963
964         return chn;
965
966 }
967
968 static int mbl_call(struct ast_channel *ast, const char *dest, int timeout)
969 {
970         struct mbl_pvt *pvt;
971         char *dest_dev;
972         char *dest_num = NULL;
973
974         dest_dev = ast_strdupa(dest);
975
976         pvt = ast_channel_tech_pvt(ast);
977
978         if (pvt->type == MBL_TYPE_PHONE) {
979                 dest_num = strchr(dest_dev, '/');
980                 if (!dest_num) {
981                         ast_log(LOG_WARNING, "Cant determine destination number.\n");
982                         return -1;
983                 }
984                 *dest_num++ = 0x00;
985         }
986
987         if ((ast_channel_state(ast) != AST_STATE_DOWN) && (ast_channel_state(ast) != AST_STATE_RESERVED)) {
988                 ast_log(LOG_WARNING, "mbl_call called on %s, neither down nor reserved\n", ast_channel_name(ast));
989                 return -1;
990         }
991
992         ast_debug(1, "Calling %s on %s\n", dest, ast_channel_name(ast));
993
994         ast_mutex_lock(&pvt->lock);
995         if (pvt->type == MBL_TYPE_PHONE) {
996                 if (hfp_send_atd(pvt->hfp, dest_num)) {
997                         ast_mutex_unlock(&pvt->lock);
998                         ast_log(LOG_ERROR, "error sending ATD command on %s\n", pvt->id);
999                         return -1;
1000                 }
1001                 pvt->hangupcause = 0;
1002                 pvt->needchup = 1;
1003                 msg_queue_push(pvt, AT_OK, AT_D);
1004         } else {
1005                 if (hsp_send_ring(pvt->rfcomm_socket)) {
1006                         ast_log(LOG_ERROR, "[%s] error ringing device\n", pvt->id);
1007                         ast_mutex_unlock(&pvt->lock);
1008                         return -1;
1009                 }
1010
1011                 if ((pvt->ring_sched_id = ast_sched_add(pvt->sched, 6000, headset_send_ring, pvt)) == -1) {
1012                         ast_log(LOG_ERROR, "[%s] error ringing device\n", pvt->id);
1013                         ast_mutex_unlock(&pvt->lock);
1014                         return -1;
1015                 }
1016
1017                 pvt->outgoing = 1;
1018                 pvt->needring = 1;
1019         }
1020         ast_mutex_unlock(&pvt->lock);
1021
1022         return 0;
1023
1024 }
1025
1026 static int mbl_hangup(struct ast_channel *ast)
1027 {
1028
1029         struct mbl_pvt *pvt;
1030
1031         if (!ast_channel_tech_pvt(ast)) {
1032                 ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
1033                 return 0;
1034         }
1035         pvt = ast_channel_tech_pvt(ast);
1036
1037         ast_debug(1, "[%s] hanging up device\n", pvt->id);
1038
1039         ast_mutex_lock(&pvt->lock);
1040         ast_channel_set_fd(ast, 0, -1);
1041         close(pvt->sco_socket);
1042         pvt->sco_socket = -1;
1043
1044         if (pvt->needchup) {
1045                 hfp_send_chup(pvt->hfp);
1046                 msg_queue_push(pvt, AT_OK, AT_CHUP);
1047                 pvt->needchup = 0;
1048         }
1049
1050         pvt->outgoing = 0;
1051         pvt->incoming = 0;
1052         pvt->needring = 0;
1053         pvt->owner = NULL;
1054         ast_channel_tech_pvt_set(ast, NULL);
1055
1056         ast_mutex_unlock(&pvt->lock);
1057
1058         ast_setstate(ast, AST_STATE_DOWN);
1059
1060         return 0;
1061
1062 }
1063
1064 static int mbl_answer(struct ast_channel *ast)
1065 {
1066
1067         struct mbl_pvt *pvt;
1068
1069         pvt = ast_channel_tech_pvt(ast);
1070
1071         if (pvt->type == MBL_TYPE_HEADSET)
1072                 return 0;
1073
1074         ast_mutex_lock(&pvt->lock);
1075         if (pvt->incoming) {
1076                 hfp_send_ata(pvt->hfp);
1077                 msg_queue_push(pvt, AT_OK, AT_A);
1078                 pvt->answered = 1;
1079         }
1080         ast_mutex_unlock(&pvt->lock);
1081
1082         return 0;
1083
1084 }
1085
1086 static int mbl_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
1087 {
1088         struct mbl_pvt *pvt = ast_channel_tech_pvt(ast);
1089
1090         if (pvt->type == MBL_TYPE_HEADSET)
1091                 return 0;
1092
1093         ast_mutex_lock(&pvt->lock);
1094         if (hfp_send_dtmf(pvt->hfp, digit)) {
1095                 ast_mutex_unlock(&pvt->lock);
1096                 ast_debug(1, "[%s] error sending digit %c\n", pvt->id, digit);
1097                 return -1;
1098         }
1099         msg_queue_push(pvt, AT_OK, AT_VTS);
1100         ast_mutex_unlock(&pvt->lock);
1101
1102         ast_debug(1, "[%s] dialed %c\n", pvt->id, digit);
1103
1104         return 0;
1105 }
1106
1107 static struct ast_frame *mbl_read(struct ast_channel *ast)
1108 {
1109
1110         struct mbl_pvt *pvt = ast_channel_tech_pvt(ast);
1111         struct ast_frame *fr = &ast_null_frame;
1112         int r;
1113
1114         ast_debug(3, "*** mbl_read()\n");
1115
1116         while (ast_mutex_trylock(&pvt->lock)) {
1117                 CHANNEL_DEADLOCK_AVOIDANCE(ast);
1118         }
1119
1120         if (!pvt->owner || pvt->sco_socket == -1) {
1121                 goto e_return;
1122         }
1123
1124         memset(&pvt->fr, 0x00, sizeof(struct ast_frame));
1125         pvt->fr.frametype = AST_FRAME_VOICE;
1126         pvt->fr.subclass.format = DEVICE_FRAME_FORMAT;
1127         pvt->fr.src = "Mobile";
1128         pvt->fr.offset = AST_FRIENDLY_OFFSET;
1129         pvt->fr.mallocd = 0;
1130         pvt->fr.delivery.tv_sec = 0;
1131         pvt->fr.delivery.tv_usec = 0;
1132         pvt->fr.data.ptr = pvt->io_buf + AST_FRIENDLY_OFFSET;
1133
1134         if ((r = read(pvt->sco_socket, pvt->fr.data.ptr, DEVICE_FRAME_SIZE)) == -1) {
1135                 if (errno != EAGAIN && errno != EINTR) {
1136                         ast_debug(1, "[%s] read error %d, going to wait for new connection\n", pvt->id, errno);
1137                         close(pvt->sco_socket);
1138                         pvt->sco_socket = -1;
1139                         ast_channel_set_fd(ast, 0, -1);
1140                 }
1141                 goto e_return;
1142         }
1143
1144         pvt->fr.datalen = r;
1145         pvt->fr.samples = r / 2;
1146
1147         if (pvt->do_alignment_detection)
1148                 do_alignment_detection(pvt, pvt->fr.data.ptr, r);
1149
1150         fr = ast_dsp_process(ast, pvt->dsp, &pvt->fr);
1151
1152         ast_mutex_unlock(&pvt->lock);
1153
1154         return fr;
1155
1156 e_return:
1157         ast_mutex_unlock(&pvt->lock);
1158         return fr;
1159 }
1160
1161 static int mbl_write(struct ast_channel *ast, struct ast_frame *frame)
1162 {
1163
1164         struct mbl_pvt *pvt = ast_channel_tech_pvt(ast);
1165         struct ast_frame *f;
1166
1167         ast_debug(3, "*** mbl_write\n");
1168
1169         if (frame->frametype != AST_FRAME_VOICE) {
1170                 return 0;
1171         }
1172
1173         while (ast_mutex_trylock(&pvt->lock)) {
1174                 CHANNEL_DEADLOCK_AVOIDANCE(ast);
1175         }
1176
1177         ast_smoother_feed(pvt->smoother, frame);
1178
1179         while ((f = ast_smoother_read(pvt->smoother))) {
1180                 sco_write(pvt->sco_socket, f->data.ptr, f->datalen);
1181         }
1182
1183         ast_mutex_unlock(&pvt->lock);
1184
1185         return 0;
1186
1187 }
1188
1189 static int mbl_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
1190 {
1191
1192         struct mbl_pvt *pvt = ast_channel_tech_pvt(newchan);
1193
1194         if (!pvt) {
1195                 ast_debug(1, "fixup failed, no pvt on newchan\n");
1196                 return -1;
1197         }
1198
1199         ast_mutex_lock(&pvt->lock);
1200         if (pvt->owner == oldchan)
1201                 pvt->owner = newchan;
1202         ast_mutex_unlock(&pvt->lock);
1203
1204         return 0;
1205
1206 }
1207
1208 static int mbl_devicestate(const char *data)
1209 {
1210
1211         char *device;
1212         int res = AST_DEVICE_INVALID;
1213         struct mbl_pvt *pvt;
1214
1215         device = ast_strdupa(S_OR(data, ""));
1216
1217         ast_debug(1, "Checking device state for device %s\n", device);
1218
1219         AST_RWLIST_RDLOCK(&devices);
1220         AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
1221                 if (!strcmp(pvt->id, device))
1222                         break;
1223         }
1224         AST_RWLIST_UNLOCK(&devices);
1225
1226         if (!pvt)
1227                 return res;
1228
1229         ast_mutex_lock(&pvt->lock);
1230         if (pvt->connected) {
1231                 if (pvt->owner)
1232                         res = AST_DEVICE_INUSE;
1233                 else
1234                         res = AST_DEVICE_NOT_INUSE;
1235
1236                 if (!mbl_has_service(pvt))
1237                         res = AST_DEVICE_UNAVAILABLE;
1238         }
1239         ast_mutex_unlock(&pvt->lock);
1240
1241         return res;
1242
1243 }
1244
1245 /*
1246
1247         Callback helpers
1248
1249 */
1250
1251 /*
1252
1253         do_alignment_detection()
1254
1255         This routine attempts to detect where we get misaligned sco audio data from the bluetooth adaptor.
1256
1257         Its enabled by alignmentdetect=yes under the adapter entry in mobile.conf
1258
1259         Some adapters suffer a problem where occasionally they will byte shift the audio stream one byte to the right.
1260         The result is static or white noise on the inbound (from the adapter) leg of the call.
1261         This is characterised by a sudden jump in magnitude of the value of the 16 bit samples.
1262
1263         Here we look at the first 4 48 byte frames. We average the absolute values of each sample in the frame,
1264         then average the sum of the averages of frames 1, 2, and 3.
1265         Frame zero is usually zero.
1266         If the end result > 100, and it usually is if we have the problem, set a flag and compensate by shifting the bytes
1267         for each subsequent frame during the call.
1268
1269         If the result is <= 100 then clear the flag so we don't come back in here...
1270
1271         This seems to work OK....
1272
1273 */
1274
1275 static void do_alignment_detection(struct mbl_pvt *pvt, char *buf, int buflen)
1276 {
1277
1278         int i;
1279         short a, *s;
1280         char *p;
1281
1282         if (pvt->alignment_detection_triggered) {
1283                 for (i=buflen, p=buf+buflen-1; i>0; i--, p--)
1284                         *p = *(p-1);
1285                 *(p+1) = 0;
1286                 return;
1287         }
1288
1289         if (pvt->alignment_count < 4) {
1290                 s = (short *)buf;
1291                 for (i=0, a=0; i<buflen/2; i++) {
1292                         a += *s++;
1293                         a /= i+1;
1294                 }
1295                 pvt->alignment_samples[pvt->alignment_count++] = a;
1296                 return;
1297         }
1298
1299         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]);
1300
1301         a = abs(pvt->alignment_samples[1]) + abs(pvt->alignment_samples[2]) + abs(pvt->alignment_samples[3]);
1302         a /= 3;
1303         if (a > 100) {
1304                 pvt->alignment_detection_triggered = 1;
1305                 ast_debug(1, "Alignment Detection Triggered.\n");
1306         } else
1307                 pvt->do_alignment_detection = 0;
1308
1309 }
1310
1311 static int mbl_queue_control(struct mbl_pvt *pvt, enum ast_control_frame_type control)
1312 {
1313         for (;;) {
1314                 if (pvt->owner) {
1315                         if (ast_channel_trylock(pvt->owner)) {
1316                                 DEADLOCK_AVOIDANCE(&pvt->lock);
1317                         } else {
1318                                 ast_queue_control(pvt->owner, control);
1319                                 ast_channel_unlock(pvt->owner);
1320                                 break;
1321                         }
1322                 } else
1323                         break;
1324         }
1325         return 0;
1326 }
1327
1328 static int mbl_queue_hangup(struct mbl_pvt *pvt)
1329 {
1330         for (;;) {
1331                 if (pvt->owner) {
1332                         if (ast_channel_trylock(pvt->owner)) {
1333                                 DEADLOCK_AVOIDANCE(&pvt->lock);
1334                         } else {
1335                                 if (pvt->hangupcause != 0) {
1336                                         ast_channel_hangupcause_set(pvt->owner, pvt->hangupcause);
1337                                 }
1338                                 ast_queue_hangup(pvt->owner);
1339                                 ast_channel_unlock(pvt->owner);
1340                                 break;
1341                         }
1342                 } else
1343                         break;
1344         }
1345         return 0;
1346 }
1347
1348 static int mbl_ast_hangup(struct mbl_pvt *pvt)
1349 {
1350         ast_hangup(pvt->owner);
1351         return 0;
1352 }
1353
1354 /*!
1355  * \brief Check if a mobile device has service.
1356  * \param pvt a mbl_pvt struct
1357  * \retval 1 this device has service
1358  * \retval 0 no service
1359  *
1360  * \note This function will always indicate that service is available if the
1361  * given device does not support service indication.
1362  */
1363 static int mbl_has_service(struct mbl_pvt *pvt)
1364 {
1365
1366         if (pvt->type != MBL_TYPE_PHONE)
1367                 return 1;
1368
1369         if (!pvt->hfp->cind_map.service)
1370                 return 1;
1371
1372         if (pvt->hfp->cind_state[pvt->hfp->cind_map.service] == HFP_CIND_SERVICE_AVAILABLE)
1373                 return 1;
1374
1375         return 0;
1376 }
1377
1378 /*
1379
1380         rfcomm helpers
1381
1382 */
1383
1384 static int rfcomm_connect(bdaddr_t src, bdaddr_t dst, int remote_channel)
1385 {
1386
1387         struct sockaddr_rc addr;
1388         int s;
1389
1390         if ((s = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) < 0) {
1391                 ast_debug(1, "socket() failed (%d).\n", errno);
1392                 return -1;
1393         }
1394
1395         memset(&addr, 0, sizeof(addr));
1396         addr.rc_family = AF_BLUETOOTH;
1397         bacpy(&addr.rc_bdaddr, &src);
1398         addr.rc_channel = (uint8_t) 0;
1399         if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
1400                 ast_debug(1, "bind() failed (%d).\n", errno);
1401                 close(s);
1402                 return -1;
1403         }
1404
1405         memset(&addr, 0, sizeof(addr));
1406         addr.rc_family = AF_BLUETOOTH;
1407         bacpy(&addr.rc_bdaddr, &dst);
1408         addr.rc_channel = remote_channel;
1409         if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
1410                 ast_debug(1, "connect() failed (%d).\n", errno);
1411                 close(s);
1412                 return -1;
1413         }
1414
1415         return s;
1416
1417 }
1418
1419 /*!
1420  * \brief Write to an rfcomm socket.
1421  * \param rsock the socket to write to
1422  * \param buf the null terminated buffer to write
1423  *
1424  * This function will write characters from buf.  The buffer must be null
1425  * terminated.
1426  *
1427  * \retval -1 error
1428  * \retval 0 success
1429  */
1430 static int rfcomm_write(int rsock, char *buf)
1431 {
1432         return rfcomm_write_full(rsock, buf, strlen(buf));
1433 }
1434
1435
1436 /*!
1437  * \brief Write to an rfcomm socket.
1438  * \param rsock the socket to write to
1439  * \param buf the buffer to write
1440  * \param count the number of characters from the buffer to write
1441  *
1442  * This function will write count characters from buf.  It will always write
1443  * count chars unless it encounters an error.
1444  *
1445  * \retval -1 error
1446  * \retval 0 success
1447  */
1448 static int rfcomm_write_full(int rsock, char *buf, size_t count)
1449 {
1450         char *p = buf;
1451         ssize_t out_count;
1452
1453         ast_debug(1, "rfcomm_write() (%d) [%.*s]\n", rsock, (int) count, buf);
1454         while (count > 0) {
1455                 if ((out_count = write(rsock, p, count)) == -1) {
1456                         ast_debug(1, "rfcomm_write() error [%d]\n", errno);
1457                         return -1;
1458                 }
1459                 count -= out_count;
1460                 p += out_count;
1461         }
1462
1463         return 0;
1464 }
1465
1466 /*!
1467  * \brief Wait for activity on an rfcomm socket.
1468  * \param rsock the socket to watch
1469  * \param ms a pointer to an int containing a timeout in ms
1470  * \return zero on timeout and the socket fd (non-zero) otherwise
1471  * \retval 0 timeout
1472  */
1473 static int rfcomm_wait(int rsock, int *ms)
1474 {
1475         int exception, outfd;
1476         outfd = ast_waitfor_n_fd(&rsock, 1, ms, &exception);
1477         if (outfd < 0)
1478                 outfd = 0;
1479
1480         return outfd;
1481 }
1482
1483 #ifdef RFCOMM_READ_DEBUG
1484 #define rfcomm_read_debug(c) __rfcomm_read_debug(c)
1485 static void __rfcomm_read_debug(char c)
1486 {
1487         if (c == '\r')
1488                 ast_debug(2, "rfcomm_read: \\r\n");
1489         else if (c == '\n')
1490                 ast_debug(2, "rfcomm_read: \\n\n");
1491         else
1492                 ast_debug(2, "rfcomm_read: %c\n", c);
1493 }
1494 #else
1495 #define rfcomm_read_debug(c)
1496 #endif
1497
1498 /*!
1499  * \brief Append the given character to the given buffer and increase the
1500  * in_count.
1501  */
1502 static void inline rfcomm_append_buf(char **buf, size_t count, size_t *in_count, char c)
1503 {
1504         if (*in_count < count) {
1505                 (*in_count)++;
1506                 *(*buf)++ = c;
1507         }
1508 }
1509
1510 /*!
1511  * \brief Read a character from the given stream and check if it matches what
1512  * we expected.
1513  */
1514 static int rfcomm_read_and_expect_char(int rsock, char *result, char expected)
1515 {
1516         int res;
1517         char c;
1518
1519         if (!result)
1520                 result = &c;
1521
1522         if ((res = read(rsock, result, 1)) < 1) {
1523                 return res;
1524         }
1525         rfcomm_read_debug(*result);
1526
1527         if (*result != expected) {
1528                 return -2;
1529         }
1530
1531         return 1;
1532 }
1533
1534 /*!
1535  * \brief Read a character from the given stream and append it to the given
1536  * buffer if it matches the expected character.
1537  */
1538 static int rfcomm_read_and_append_char(int rsock, char **buf, size_t count, size_t *in_count, char *result, char expected)
1539 {
1540         int res;
1541         char c;
1542
1543         if (!result)
1544                 result = &c;
1545
1546         if ((res = rfcomm_read_and_expect_char(rsock, result, expected)) < 1) {
1547                 return res;
1548         }
1549
1550         rfcomm_append_buf(buf, count, in_count, *result);
1551         return 1;
1552 }
1553
1554 /*!
1555  * \brief Read until \verbatim '\r\n'. \endverbatim
1556  * This function consumes the \verbatim'\r\n'\endverbatim but does not add it to buf.
1557  */
1558 static int rfcomm_read_until_crlf(int rsock, char **buf, size_t count, size_t *in_count)
1559 {
1560         int res;
1561         char c;
1562
1563         while ((res = read(rsock, &c, 1)) == 1) {
1564                 rfcomm_read_debug(c);
1565                 if (c == '\r') {
1566                         if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) == 1) {
1567                                 break;
1568                         } else if (res == -2) {
1569                                 rfcomm_append_buf(buf, count, in_count, '\r');
1570                         } else {
1571                                 rfcomm_append_buf(buf, count, in_count, '\r');
1572                                 break;
1573                         }
1574                 }
1575
1576                 rfcomm_append_buf(buf, count, in_count, c);
1577         }
1578         return res;
1579 }
1580
1581 /*!
1582  * \brief Read the remainder of an AT SMS prompt.
1583  * \note the entire parsed string is \verbatim '\r\n> ' \endverbatim
1584  *
1585  * By the time this function is executed, only a ' ' is left to read.
1586  */
1587 static int rfcomm_read_sms_prompt(int rsock, char **buf, size_t count, size_t *in_count)
1588 {
1589         int res;
1590         if ((res = rfcomm_read_and_append_char(rsock, buf, count, in_count, NULL, ' ')) < 1)
1591                goto e_return;
1592
1593         return 1;
1594
1595 e_return:
1596         ast_log(LOG_ERROR, "error parsing SMS prompt on rfcomm socket\n");
1597         return res;
1598 }
1599
1600 /*!
1601  * \brief Read until a \verbatim \r\nOK\r\n \endverbatim message.
1602  */
1603 static int rfcomm_read_until_ok(int rsock, char **buf, size_t count, size_t *in_count)
1604 {
1605         int res;
1606         char c;
1607
1608         /* here, we read until finding a \r\n, then we read one character at a
1609          * time looking for the string '\r\nOK\r\n'.  If we only find a partial
1610          * match, we place that in the buffer and try again. */
1611
1612         for (;;) {
1613                 if ((res = rfcomm_read_until_crlf(rsock, buf, count, in_count)) != 1) {
1614                         break;
1615                 }
1616
1617                 rfcomm_append_buf(buf, count, in_count, '\r');
1618                 rfcomm_append_buf(buf, count, in_count, '\n');
1619
1620                 if ((res = rfcomm_read_and_expect_char(rsock, &c, '\r')) != 1) {
1621                         if (res != -2) {
1622                                 break;
1623                         }
1624
1625                         rfcomm_append_buf(buf, count, in_count, c);
1626                         continue;
1627                 }
1628
1629                 if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) != 1) {
1630                         if (res != -2) {
1631                                 break;
1632                         }
1633
1634                         rfcomm_append_buf(buf, count, in_count, '\r');
1635                         rfcomm_append_buf(buf, count, in_count, c);
1636                         continue;
1637                 }
1638                 if ((res = rfcomm_read_and_expect_char(rsock, &c, 'O')) != 1) {
1639                         if (res != -2) {
1640                                 break;
1641                         }
1642
1643                         rfcomm_append_buf(buf, count, in_count, '\r');
1644                         rfcomm_append_buf(buf, count, in_count, '\n');
1645                         rfcomm_append_buf(buf, count, in_count, c);
1646                         continue;
1647                 }
1648
1649                 if ((res = rfcomm_read_and_expect_char(rsock, &c, 'K')) != 1) {
1650                         if (res != -2) {
1651                                 break;
1652                         }
1653
1654                         rfcomm_append_buf(buf, count, in_count, '\r');
1655                         rfcomm_append_buf(buf, count, in_count, '\n');
1656                         rfcomm_append_buf(buf, count, in_count, 'O');
1657                         rfcomm_append_buf(buf, count, in_count, c);
1658                         continue;
1659                 }
1660
1661                 if ((res = rfcomm_read_and_expect_char(rsock, &c, '\r')) != 1) {
1662                         if (res != -2) {
1663                                 break;
1664                         }
1665
1666                         rfcomm_append_buf(buf, count, in_count, '\r');
1667                         rfcomm_append_buf(buf, count, in_count, '\n');
1668                         rfcomm_append_buf(buf, count, in_count, 'O');
1669                         rfcomm_append_buf(buf, count, in_count, 'K');
1670                         rfcomm_append_buf(buf, count, in_count, c);
1671                         continue;
1672                 }
1673
1674                 if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) != 1) {
1675                         if (res != -2) {
1676                                 break;
1677                         }
1678
1679                         rfcomm_append_buf(buf, count, in_count, '\r');
1680                         rfcomm_append_buf(buf, count, in_count, '\n');
1681                         rfcomm_append_buf(buf, count, in_count, 'O');
1682                         rfcomm_append_buf(buf, count, in_count, 'K');
1683                         rfcomm_append_buf(buf, count, in_count, '\r');
1684                         rfcomm_append_buf(buf, count, in_count, c);
1685                         continue;
1686                 }
1687
1688                 /* we have successfully parsed a '\r\nOK\r\n' string */
1689                 return 1;
1690         }
1691
1692         return res;
1693 }
1694
1695
1696 /*!
1697  * \brief Read the remainder of a +CMGR message.
1698  * \note the entire parsed string is \verbatim '+CMGR: ...\r\n...\r\n...\r\n...\r\nOK\r\n' \endverbatim
1699  */
1700 static int rfcomm_read_cmgr(int rsock, char **buf, size_t count, size_t *in_count)
1701 {
1702         int res;
1703
1704         /* append the \r\n that was stripped by the calling function */
1705         rfcomm_append_buf(buf, count, in_count, '\r');
1706         rfcomm_append_buf(buf, count, in_count, '\n');
1707
1708         if ((res = rfcomm_read_until_ok(rsock, buf, count, in_count)) != 1) {
1709                 ast_log(LOG_ERROR, "error reading +CMGR message on rfcomm socket\n");
1710         }
1711
1712         return res;
1713 }
1714
1715 /*!
1716  * \brief Read and AT result code.
1717  * \note the entire parsed string is \verbatim '\r\n<result code>\r\n' \endverbatim
1718  */
1719 static int rfcomm_read_result(int rsock, char **buf, size_t count, size_t *in_count)
1720 {
1721         int res;
1722         char c;
1723
1724         if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) < 1) {
1725                 goto e_return;
1726         }
1727
1728         if ((res = rfcomm_read_and_append_char(rsock, buf, count, in_count, &c, '>')) == 1) {
1729                 return rfcomm_read_sms_prompt(rsock, buf, count, in_count);
1730         } else if (res != -2) {
1731                 goto e_return;
1732         }
1733
1734         rfcomm_append_buf(buf, count, in_count, c);
1735         res = rfcomm_read_until_crlf(rsock, buf, count, in_count);
1736
1737         if (res != 1)
1738                 return res;
1739
1740         /* check for CMGR, which contains an embedded \r\n pairs terminated by
1741          * an \r\nOK\r\n message */
1742         if (*in_count >= 5 && !strncmp(*buf - *in_count, "+CMGR", 5)) {
1743                 return rfcomm_read_cmgr(rsock, buf, count, in_count);
1744         }
1745
1746         return 1;
1747
1748 e_return:
1749         ast_log(LOG_ERROR, "error parsing AT result on rfcomm socket\n");
1750         return res;
1751 }
1752
1753 /*!
1754  * \brief Read the remainder of an AT command.
1755  * \note the entire parsed string is \verbatim '<at command>\r' \endverbatim
1756  */
1757 static int rfcomm_read_command(int rsock, char **buf, size_t count, size_t *in_count)
1758 {
1759         int res;
1760         char c;
1761
1762         while ((res = read(rsock, &c, 1)) == 1) {
1763                 rfcomm_read_debug(c);
1764                 /* stop when we get to '\r' */
1765                 if (c == '\r')
1766                         break;
1767
1768                 rfcomm_append_buf(buf, count, in_count, c);
1769         }
1770         return res;
1771 }
1772
1773 /*!
1774  * \brief Read one Hayes AT message from an rfcomm socket.
1775  * \param rsock the rfcomm socket to read from
1776  * \param buf the buffer to store the result in
1777  * \param count the size of the buffer or the maximum number of characters to read
1778  *
1779  * Here we need to read complete Hayes AT messages.  The AT message formats we
1780  * support are listed below.
1781  *
1782  * \verbatim
1783  * \r\n<result code>\r\n
1784  * <at command>\r
1785  * \r\n>
1786  * \endverbatim
1787  *
1788  * These formats correspond to AT result codes, AT commands, and the AT SMS
1789  * prompt respectively.  When messages are read the leading and trailing \verbatim '\r' \endverbatim
1790  * and \verbatim '\n' \endverbatim characters are discarded.  If the given buffer is not large enough
1791  * to hold the response, what does not fit in the buffer will be dropped.
1792  *
1793  * \note The rfcomm connection to the device is asynchronous, so there is no
1794  * guarantee that responses will be returned in a single read() call. We handle
1795  * this by blocking until we can read an entire response.
1796  *
1797  * \retval 0 end of file
1798  * \retval -1 read error
1799  * \retval -2 parse error
1800  * \retval other the number of characters added to buf
1801  */
1802 static ssize_t rfcomm_read(int rsock, char *buf, size_t count)
1803 {
1804         ssize_t res;
1805         size_t in_count = 0;
1806         char c;
1807
1808         if ((res = rfcomm_read_and_expect_char(rsock, &c, '\r')) == 1) {
1809                 res = rfcomm_read_result(rsock, &buf, count, &in_count);
1810         } else if (res == -2) {
1811                 rfcomm_append_buf(&buf, count, &in_count, c);
1812                 res = rfcomm_read_command(rsock, &buf, count, &in_count);
1813         }
1814
1815         if (res < 1)
1816                 return res;
1817         else
1818                 return in_count;
1819 }
1820
1821 /*
1822
1823         sco helpers and callbacks
1824
1825 */
1826
1827 static int sco_connect(bdaddr_t src, bdaddr_t dst)
1828 {
1829
1830         struct sockaddr_sco addr;
1831         int s;
1832
1833         if ((s = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) {
1834                 ast_debug(1, "socket() failed (%d).\n", errno);
1835                 return -1;
1836         }
1837
1838 /* XXX this does not work with the do_sco_listen() thread (which also bind()s
1839  * to this address).  Also I am not sure if it is necessary. */
1840 #if 0
1841         memset(&addr, 0, sizeof(addr));
1842         addr.sco_family = AF_BLUETOOTH;
1843         bacpy(&addr.sco_bdaddr, &src);
1844         if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
1845                 ast_debug(1, "bind() failed (%d).\n", errno);
1846                 close(s);
1847                 return -1;
1848         }
1849 #endif
1850
1851         memset(&addr, 0, sizeof(addr));
1852         addr.sco_family = AF_BLUETOOTH;
1853         bacpy(&addr.sco_bdaddr, &dst);
1854
1855         if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
1856                 ast_debug(1, "sco connect() failed (%d).\n", errno);
1857                 close(s);
1858                 return -1;
1859         }
1860
1861         return s;
1862
1863 }
1864
1865 static int sco_write(int s, char *buf, int len)
1866 {
1867
1868         int r;
1869
1870         if (s == -1) {
1871                 ast_debug(3, "sco_write() not ready\n");
1872                 return 0;
1873         }
1874
1875         ast_debug(3, "sco_write()\n");
1876
1877         r = write(s, buf, len);
1878         if (r == -1) {
1879                 ast_debug(3, "sco write error %d\n", errno);
1880                 return 0;
1881         }
1882
1883         return 1;
1884
1885 }
1886
1887 /*!
1888  * \brief Accept SCO connections.
1889  * This function is an ast_io callback function used to accept incoming sco
1890  * audio connections.
1891  */
1892 static int sco_accept(int *id, int fd, short events, void *data)
1893 {
1894         struct adapter_pvt *adapter = (struct adapter_pvt *) data;
1895         struct sockaddr_sco addr;
1896         socklen_t addrlen;
1897         struct mbl_pvt *pvt;
1898         socklen_t len;
1899         char saddr[18];
1900         struct sco_options so;
1901         int sock;
1902
1903         addrlen = sizeof(struct sockaddr_sco);
1904         if ((sock = accept(fd, (struct sockaddr *)&addr, &addrlen)) == -1) {
1905                 ast_log(LOG_ERROR, "error accepting audio connection on adapter %s\n", adapter->id);
1906                 return 0;
1907         }
1908
1909         len = sizeof(so);
1910         getsockopt(sock, SOL_SCO, SCO_OPTIONS, &so, &len);
1911
1912         ba2str(&addr.sco_bdaddr, saddr);
1913         ast_debug(1, "Incoming Audio Connection from device %s MTU is %d\n", saddr, so.mtu);
1914
1915         /* figure out which device this sco connection belongs to */
1916         pvt = NULL;
1917         AST_RWLIST_RDLOCK(&devices);
1918         AST_RWLIST_TRAVERSE(&devices, pvt, entry) {
1919                 if (!bacmp(&pvt->addr, &addr.sco_bdaddr))
1920                         break;
1921         }
1922         AST_RWLIST_UNLOCK(&devices);
1923         if (!pvt) {
1924                 ast_log(LOG_WARNING, "could not find device for incoming audio connection\n");
1925                 close(sock);
1926                 return 1;
1927         }
1928
1929         ast_mutex_lock(&pvt->lock);
1930         if (pvt->sco_socket != -1) {
1931                 close(pvt->sco_socket);
1932                 pvt->sco_socket = -1;
1933         }
1934
1935         pvt->sco_socket = sock;
1936         if (pvt->owner) {
1937                 ast_channel_set_fd(pvt->owner, 0, sock);
1938         } else {
1939                 ast_debug(1, "incoming audio connection for pvt without owner\n");
1940         }
1941
1942         ast_mutex_unlock(&pvt->lock);
1943
1944         return 1;
1945 }
1946
1947 /*!
1948  * \brief Bind an SCO listener socket for the given adapter.
1949  * \param adapter an adapter_pvt
1950  * \return -1 on error, non zero on success
1951  */
1952 static int sco_bind(struct adapter_pvt *adapter)
1953 {
1954         struct sockaddr_sco addr;
1955         int opt = 1;
1956
1957         if ((adapter->sco_socket = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) {
1958                 ast_log(LOG_ERROR, "Unable to create sco listener socket for adapter %s.\n", adapter->id);
1959                 goto e_return;
1960         }
1961
1962         memset(&addr, 0, sizeof(addr));
1963         addr.sco_family = AF_BLUETOOTH;
1964         bacpy(&addr.sco_bdaddr, &adapter->addr);
1965         if (bind(adapter->sco_socket, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
1966                 ast_log(LOG_ERROR, "Unable to bind sco listener socket. (%d)\n", errno);
1967                 goto e_close_socket;
1968         }
1969         if (setsockopt(adapter->sco_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
1970                 ast_log(LOG_ERROR, "Unable to setsockopt sco listener socket.\n");
1971                 goto e_close_socket;
1972         }
1973         if (listen(adapter->sco_socket, 5) < 0) {
1974                 ast_log(LOG_ERROR, "Unable to listen sco listener socket.\n");
1975                 goto e_close_socket;
1976         }
1977
1978         return adapter->sco_socket;
1979
1980 e_close_socket:
1981         close(adapter->sco_socket);
1982         adapter->sco_socket = -1;
1983 e_return:
1984         return -1;
1985 }
1986
1987
1988 /*
1989  * Hayes AT command helpers.
1990  */
1991
1992 /*!
1993  * \brief Match the given buffer with the given prefix.
1994  * \param buf the buffer to match
1995  * \param prefix the prefix to match
1996  */
1997 static int at_match_prefix(char *buf, char *prefix)
1998 {
1999         return !strncmp(buf, prefix, strlen(prefix));
2000 }
2001
2002 /*!
2003  * \brief Read an AT message and clasify it.
2004  * \param rsock an rfcomm socket
2005  * \param buf the buffer to store the result in
2006  * \param count the size of the buffer or the maximum number of characters to read
2007  * \return the type of message received, in addition buf will contain the
2008  * message received and will be null terminated
2009  * \see at_read()
2010  */
2011 static at_message_t at_read_full(int rsock, char *buf, size_t count)
2012 {
2013         ssize_t s;
2014         if ((s = rfcomm_read(rsock, buf, count - 1)) < 1)
2015                 return s;
2016         buf[s] = '\0';
2017
2018         if (!strcmp("OK", buf)) {
2019                 return AT_OK;
2020         } else if (!strcmp("ERROR", buf)) {
2021                 return AT_ERROR;
2022         } else if (!strcmp("RING", buf)) {
2023                 return AT_RING;
2024         } else if (!strcmp("AT+CKPD=200", buf)) {
2025                 return AT_CKPD;
2026         } else if (!strcmp("> ", buf)) {
2027                 return AT_SMS_PROMPT;
2028         } else if (at_match_prefix(buf, "+CMTI:")) {
2029                 return AT_CMTI;
2030         } else if (at_match_prefix(buf, "+CIEV:")) {
2031                 return AT_CIEV;
2032         } else if (at_match_prefix(buf, "+BRSF:")) {
2033                 return AT_BRSF;
2034         } else if (at_match_prefix(buf, "+CIND:")) {
2035                 return AT_CIND;
2036         } else if (at_match_prefix(buf, "+CLIP:")) {
2037                 return AT_CLIP;
2038         } else if (at_match_prefix(buf, "+CMGR:")) {
2039                 return AT_CMGR;
2040         } else if (at_match_prefix(buf, "+VGM:")) {
2041                 return AT_VGM;
2042         } else if (at_match_prefix(buf, "+VGS:")) {
2043                 return AT_VGS;
2044         } else if (at_match_prefix(buf, "+CMS ERROR:")) {
2045                 return AT_CMS_ERROR;
2046         } else if (at_match_prefix(buf, "AT+VGM=")) {
2047                 return AT_VGM;
2048         } else if (at_match_prefix(buf, "AT+VGS=")) {
2049                 return AT_VGS;
2050         } else if (at_match_prefix(buf, "+CUSD:")) {
2051                 return AT_CUSD;
2052         } else if (at_match_prefix(buf, "BUSY")) {
2053                 return AT_BUSY;
2054         } else if (at_match_prefix(buf, "NO DIALTONE")) {
2055                 return AT_NO_DIALTONE;
2056         } else if (at_match_prefix(buf, "NO CARRIER")) {
2057                 return AT_NO_CARRIER;
2058         } else if (at_match_prefix(buf, "*ECAV:")) {
2059                 return AT_ECAM;
2060         } else {
2061                 return AT_UNKNOWN;
2062         }
2063 }
2064
2065 /*!
2066  * \brief Get the string representation of the given AT message.
2067  * \param msg the message to process
2068  * \return a string describing the given message
2069  */
2070 static inline const char *at_msg2str(at_message_t msg)
2071 {
2072         switch (msg) {
2073         /* errors */
2074         case AT_PARSE_ERROR:
2075                 return "PARSE ERROR";
2076         case AT_READ_ERROR:
2077                 return "READ ERROR";
2078         default:
2079         case AT_UNKNOWN:
2080                 return "UNKNOWN";
2081         /* at responses */
2082         case AT_OK:
2083                 return "OK";
2084         case AT_ERROR:
2085                 return "ERROR";
2086         case AT_RING:
2087                 return "RING";
2088         case AT_BRSF:
2089                 return "AT+BRSF";
2090         case AT_CIND:
2091                 return "AT+CIND";
2092         case AT_CIEV:
2093                 return "AT+CIEV";
2094         case AT_CLIP:
2095                 return "AT+CLIP";
2096         case AT_CMTI:
2097                 return "AT+CMTI";
2098         case AT_CMGR:
2099                 return "AT+CMGR";
2100         case AT_SMS_PROMPT:
2101                 return "SMS PROMPT";
2102         case AT_CMS_ERROR:
2103                 return "+CMS ERROR";
2104         case AT_BUSY:
2105                 return "BUSY";
2106         case AT_NO_DIALTONE:
2107                 return "NO DIALTONE";
2108         case AT_NO_CARRIER:
2109                 return "NO CARRIER";
2110         /* at commands */
2111         case AT_A:
2112                 return "ATA";
2113         case AT_D:
2114                 return "ATD";
2115         case AT_CHUP:
2116                 return "AT+CHUP";
2117         case AT_CKPD:
2118                 return "AT+CKPD";
2119         case AT_CMGS:
2120                 return "AT+CMGS";
2121         case AT_VGM:
2122                 return "AT+VGM";
2123         case AT_VGS:
2124                 return "AT+VGS";
2125         case AT_VTS:
2126                 return "AT+VTS";
2127         case AT_CMGF:
2128                 return "AT+CMGF";
2129         case AT_CNMI:
2130                 return "AT+CNMI";
2131         case AT_CMER:
2132                 return "AT+CMER";
2133         case AT_CIND_TEST:
2134                 return "AT+CIND=?";
2135         case AT_CUSD:
2136                 return "AT+CUSD";
2137         case AT_ECAM:
2138                 return "AT*ECAM";
2139         }
2140 }
2141
2142
2143 /*
2144  * bluetooth handsfree profile helpers
2145  */
2146
2147  /*!
2148  * \brief Parse a ECAV event.
2149  * \param hfp an hfp_pvt struct
2150  * \param buf the buffer to parse (null terminated)
2151  * \return -1 on error (parse error) or a ECAM value on success
2152  *
2153  * Example string: *ECAV: <ccid>,<ccstatus>,<calltype>[,<processid>]
2154  * [,exitcause][,<number>,<type>]
2155  *
2156  * Example indicating busy: *ECAV: 1,7,1
2157  */
2158 static int hfp_parse_ecav(struct hfp_pvt *hfp, char *buf)
2159 {
2160         int ccid = 0;
2161         int ccstatus = 0;
2162         int calltype = 0;
2163
2164         if (!sscanf(buf, "*ECAV: %2d,%2d,%2d", &ccid, &ccstatus, &calltype)) {
2165                 ast_debug(1, "[%s] error parsing ECAV event '%s'\n", hfp->owner->id, buf);
2166                 return -1;
2167         }
2168
2169         return ccstatus;
2170 }
2171
2172 /*!
2173  * \brief Enable Sony Erricson extensions / indications.
2174  * \param hfp an hfp_pvt struct
2175  */
2176 static int hfp_send_ecam(struct hfp_pvt *hfp)
2177 {
2178         return rfcomm_write(hfp->rsock, "AT*ECAM=1\r");
2179 }
2180
2181 /*!
2182  * \brief Parse a CIEV event.
2183  * \param hfp an hfp_pvt struct
2184  * \param buf the buffer to parse (null terminated)
2185  * \param value a pointer to an int to store the event value in (can be NULL)
2186  * \return 0 on error (parse error, or unknown event) or a HFP_CIND_* value on
2187  * success
2188  */
2189 static int hfp_parse_ciev(struct hfp_pvt *hfp, char *buf, int *value)
2190 {
2191         int i, v;
2192         if (!value)
2193                 value = &v;
2194
2195         if (!sscanf(buf, "+CIEV: %d,%d", &i, value)) {
2196                 ast_debug(2, "[%s] error parsing CIEV event '%s'\n", hfp->owner->id, buf);
2197                 return HFP_CIND_NONE;
2198         }
2199
2200         if (i >= ARRAY_LEN(hfp->cind_state)) {
2201                 ast_debug(2, "[%s] CIEV event index too high (%s)\n", hfp->owner->id, buf);
2202                 return HFP_CIND_NONE;
2203         }
2204
2205         hfp->cind_state[i] = *value;
2206         return hfp->cind_index[i];
2207 }
2208
2209 /*!
2210  * \brief Parse a CLIP event.
2211  * \param hfp an hfp_pvt struct
2212  * \param buf the buffer to parse (null terminated)
2213  * \note buf will be modified when the CID string is parsed
2214  * \return a cidinfo structure pointing to the cnam and cnum
2215  * data in buf.  On parse errors, either or both pointers
2216  * will point to null strings
2217  */
2218 static struct cidinfo hfp_parse_clip(struct hfp_pvt *hfp, char *buf)
2219 {
2220         int i;
2221         int tokens[6];
2222         char *cnamtmp;
2223         char delim = ' ';       /* First token terminates with space */
2224         int invalid = 0;        /* Number of invalid chars in cnam */
2225         struct cidinfo cidinfo = { NULL, NULL };
2226
2227         /* parse clip info in the following format:
2228          * +CLIP: "123456789",128,...
2229          */
2230         ast_debug(3, "[%s] hfp_parse_clip is processing \"%s\"\n", hfp->owner->id, buf);
2231         tokens[0] = 0;          /* First token starts in position 0 */
2232         for (i = 1; i < ARRAY_LEN(tokens); i++) {
2233                 tokens[i] = parse_next_token(buf, tokens[i - 1], delim);
2234                 delim = ',';    /* Subsequent tokens terminate with comma */
2235         }
2236         ast_debug(3, "[%s] hfp_parse_clip found tokens: 0=%s, 1=%s, 2=%s, 3=%s, 4=%s, 5=%s\n",
2237                 hfp->owner->id, &buf[tokens[0]], &buf[tokens[1]], &buf[tokens[2]],
2238                 &buf[tokens[3]], &buf[tokens[4]], &buf[tokens[5]]);
2239
2240         /* Clean up cnum, and make sure it is legitimate since it is untrusted. */
2241         cidinfo.cnum = ast_strip_quoted(&buf[tokens[1]], "\"", "\"");
2242         if (!ast_isphonenumber(cidinfo.cnum)) {
2243                 ast_debug(1, "[%s] hfp_parse_clip invalid cidinfo.cnum data \"%s\" - deleting\n",
2244                         hfp->owner->id, cidinfo.cnum);
2245                 cidinfo.cnum = "";
2246         }
2247
2248         /*
2249          * Some docs say tokens 2 and 3 including the commas are optional.
2250          * If absent, that would move CNAM back to token 3.
2251          */
2252         cidinfo.cnam = &buf[tokens[5]]; /* Assume it's in token 5 */
2253         if (buf[tokens[5]] == '\0' && buf[tokens[4]] == '\0') {
2254                 /* Tokens 4 and 5 are empty.  See if token 3 looks like CNAM (starts with ") */
2255                 i = tokens[3];
2256                 while (buf[i] == ' ') {         /* Find the first non-blank */
2257                         i++;
2258                 }
2259                 if (buf[i] == '"') {
2260                         /* Starts with quote.  Use this for CNAM. */
2261                         cidinfo.cnam = &buf[i];
2262                 }
2263         }
2264
2265         /* Clean up CNAM. */
2266         cidinfo.cnam = ast_strip_quoted(cidinfo.cnam, "\"", "\"");
2267         for (cnamtmp = cidinfo.cnam; *cnamtmp != '\0'; cnamtmp++) {
2268                 if (!strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789-,abcdefghijklmnopqrstuvwxyz_", *cnamtmp)) {
2269                         *cnamtmp = '_'; /* Invalid.  Replace with underscore. */
2270                         invalid++;
2271                 }
2272         }
2273         if (invalid) {
2274                 ast_debug(2, "[%s] hfp_parse_clip replaced %d invalid byte(s) in cnam data\n",
2275                         hfp->owner->id, invalid);
2276         }
2277         ast_debug(2, "[%s] hfp_parse_clip returns cnum=%s and cnam=%s\n",
2278                 hfp->owner->id, cidinfo.cnum, cidinfo.cnam);
2279
2280         return cidinfo;
2281 }
2282
2283 /*!
2284  * \brief Terminate current token and return an index to start of the next token.
2285  * \param string the null-terminated string being parsed (will be altered!)
2286  * \param start where the current token starts
2287  * \param delim the token termination delimiter.  \0 is also considered a terminator.
2288  * \return index of the next token.  May be the same as this token if the string is
2289  * exhausted.
2290  */
2291 static int parse_next_token(char string[], const int start, const char delim)
2292 {
2293         int index;
2294         int quoting = 0;
2295
2296         for (index = start; string[index] != 0; index++) {
2297                 if ((string[index] == delim) && !quoting ) {
2298                         /* Found the delimiter, outside of quotes.  This is the end of the token. */
2299                         string[index] = '\0';   /* Terminate this token. */
2300                         index++;                /* Point the index to the start of the next token. */
2301                         break;                  /* We're done. */
2302                 } else if (string[index] == '"' && !quoting) {
2303                         /* Found a beginning quote mark.  Remember it. */
2304                         quoting = 1;
2305                 } else if (string[index] == '"' ) {
2306                         /* Found the end quote mark. */
2307                         quoting = 0;
2308                 }
2309         }
2310         return index;
2311 }
2312
2313 /*!
2314  * \brief Parse a CMTI notification.
2315  * \param hfp an hfp_pvt struct
2316  * \param buf the buffer to parse (null terminated)
2317  * \note buf will be modified when the CMTI message is parsed
2318  * \return -1 on error (parse error) or the index of the new sms message
2319  */
2320 static int hfp_parse_cmti(struct hfp_pvt *hfp, char *buf)
2321 {
2322         int index = -1;
2323
2324         /* parse cmti info in the following format:
2325          * +CMTI: <mem>,<index>
2326          */
2327         if (!sscanf(buf, "+CMTI: %*[^,],%d", &index)) {
2328                 ast_debug(2, "[%s] error parsing CMTI event '%s'\n", hfp->owner->id, buf);
2329                 return -1;
2330         }
2331
2332         return index;
2333 }
2334
2335 /*!
2336  * \brief Parse a CMGR message.
2337  * \param hfp an hfp_pvt struct
2338  * \param buf the buffer to parse (null terminated)
2339  * \param from_number a pointer to a char pointer which will store the from
2340  * number
2341  * \param text a pointer to a char pointer which will store the message text
2342  * \note buf will be modified when the CMGR message is parsed
2343  * \retval -1 parse error
2344  * \retval 0 success
2345  */
2346 static int hfp_parse_cmgr(struct hfp_pvt *hfp, char *buf, char **from_number, char **text)
2347 {
2348         int i, state;
2349         size_t s;
2350
2351         /* parse cmgr info in the following format:
2352          * +CMGR: <msg status>,"+123456789",...\r\n
2353          * <message text>
2354          */
2355         state = 0;
2356         s = strlen(buf);
2357         for (i = 0; i < s && state != 6; i++) {
2358                 switch (state) {
2359                 case 0: /* search for start of the number section (,) */
2360                         if (buf[i] == ',') {
2361                                 state++;
2362                         }
2363                         break;
2364                 case 1: /* find the opening quote (") */
2365                         if (buf[i] == '"') {
2366                                 state++;
2367                         }
2368                         break;
2369                 case 2: /* mark the start of the number */
2370                         if (from_number) {
2371                                 *from_number = &buf[i];
2372                                 state++;
2373                         }
2374                         /* fall through */
2375                 case 3: /* search for the end of the number (") */
2376                         if (buf[i] == '"') {
2377                                 buf[i] = '\0';
2378                                 state++;
2379                         }
2380                         break;
2381                 case 4: /* search for the start of the message text (\n) */
2382                         if (buf[i] == '\n') {
2383                                 state++;
2384                         }
2385                         break;
2386                 case 5: /* mark the start of the message text */
2387                         if (text) {
2388                                 *text = &buf[i];
2389                                 state++;
2390                         }
2391                         break;
2392                 }
2393         }
2394
2395         if (state != 6) {
2396                 return -1;
2397         }
2398
2399         return 0;
2400 }
2401
2402 /*!
2403  * \brief Parse a CUSD answer.
2404  * \param hfp an hfp_pvt struct
2405  * \param buf the buffer to parse (null terminated)
2406  * \note buf will be modified when the CUSD string is parsed
2407  * \return NULL on error (parse error) or a pointer to the cusd message
2408  * information in buf
2409  */
2410 static char *hfp_parse_cusd(struct hfp_pvt *hfp, char *buf)
2411 {
2412         int i, message_start, message_end;
2413         char *cusd;
2414         size_t s;
2415
2416         /* parse cusd message in the following format:
2417          * +CUSD: 0,"100,00 EURO, valid till 01.01.2010, you are using tariff "Mega Tariff". More informations *111#."
2418          */
2419         message_start = 0;
2420         message_end = 0;
2421         s = strlen(buf);
2422
2423         /* Find the start of the message (") */
2424         for (i = 0; i < s; i++) {
2425                 if (buf[i] == '"') {
2426                         message_start = i + 1;
2427                         break;
2428                 }
2429         }
2430
2431         if (message_start == 0 || message_start >= s) {
2432                 return NULL;
2433         }
2434
2435         /* Find the end of the message (") */
2436         for (i = s; i > 0; i--) {
2437                 if (buf[i] == '"') {
2438                         message_end = i;
2439                         break;
2440                 }
2441         }
2442
2443         if (message_end == 0) {
2444                 return NULL;
2445         }
2446
2447         if (message_start >= message_end) {
2448                 return NULL;
2449         }
2450
2451         cusd = &buf[message_start];
2452         buf[message_end] = '\0';
2453
2454         return cusd;
2455 }
2456
2457 /*!
2458  * \brief Convert a hfp_hf struct to a BRSF int.
2459  * \param hf an hfp_hf brsf object
2460  * \return an integer representing the given brsf struct
2461  */
2462 static int hfp_brsf2int(struct hfp_hf *hf)
2463 {
2464         int brsf = 0;
2465
2466         brsf |= hf->ecnr ? HFP_HF_ECNR : 0;
2467         brsf |= hf->cw ? HFP_HF_CW : 0;
2468         brsf |= hf->cid ? HFP_HF_CID : 0;
2469         brsf |= hf->voice ? HFP_HF_VOICE : 0;
2470         brsf |= hf->volume ? HFP_HF_VOLUME : 0;
2471         brsf |= hf->status ? HFP_HF_STATUS : 0;
2472         brsf |= hf->control ? HFP_HF_CONTROL : 0;
2473
2474         return brsf;
2475 }
2476
2477 /*!
2478  * \brief Convert a BRSF int to an hfp_ag struct.
2479  * \param brsf a brsf integer
2480  * \param ag a AG (hfp_ag) brsf object
2481  * \return a pointer to the given hfp_ag object populated with the values from
2482  * the given brsf integer
2483  */
2484 static struct hfp_ag *hfp_int2brsf(int brsf, struct hfp_ag *ag)
2485 {
2486         ag->cw = brsf & HFP_AG_CW ? 1 : 0;
2487         ag->ecnr = brsf & HFP_AG_ECNR ? 1 : 0;
2488         ag->voice = brsf & HFP_AG_VOICE ? 1 : 0;
2489         ag->ring = brsf & HFP_AG_RING ? 1 : 0;
2490         ag->tag = brsf & HFP_AG_TAG ? 1 : 0;
2491         ag->reject = brsf & HFP_AG_REJECT ? 1 : 0;
2492         ag->status = brsf & HFP_AG_STATUS ? 1 : 0;
2493         ag->control = brsf & HFP_AG_CONTROL ? 1 : 0;
2494         ag->errors = brsf & HFP_AG_ERRORS ? 1 : 0;
2495
2496         return ag;
2497 }
2498
2499
2500 /*!
2501  * \brief Send a BRSF request.
2502  * \param hfp an hfp_pvt struct
2503  * \param brsf an hfp_hf brsf struct
2504  *
2505  * \retval 0 on success
2506  * \retval -1 on error
2507  */
2508 static int hfp_send_brsf(struct hfp_pvt *hfp, struct hfp_hf *brsf)
2509 {
2510         char cmd[32];
2511         snprintf(cmd, sizeof(cmd), "AT+BRSF=%d\r", hfp_brsf2int(brsf));
2512         return rfcomm_write(hfp->rsock, cmd);
2513 }
2514
2515 /*!
2516  * \brief Send the CIND read command.
2517  * \param hfp an hfp_pvt struct
2518  */
2519 static int hfp_send_cind(struct hfp_pvt *hfp)
2520 {
2521         return rfcomm_write(hfp->rsock, "AT+CIND?\r");
2522 }
2523
2524 /*!
2525  * \brief Send the CIND test command.
2526  * \param hfp an hfp_pvt struct
2527  */
2528 static int hfp_send_cind_test(struct hfp_pvt *hfp)
2529 {
2530         return rfcomm_write(hfp->rsock, "AT+CIND=?\r");
2531 }
2532
2533 /*!
2534  * \brief Enable or disable indicator events reporting.
2535  * \param hfp an hfp_pvt struct
2536  * \param status enable or disable events reporting (should be 1 or 0)
2537  */
2538 static int hfp_send_cmer(struct hfp_pvt *hfp, int status)
2539 {
2540         char cmd[32];
2541         snprintf(cmd, sizeof(cmd), "AT+CMER=3,0,0,%d\r", status ? 1 : 0);
2542         return rfcomm_write(hfp->rsock, cmd);
2543 }
2544
2545 /*!
2546  * \brief Send the current speaker gain level.
2547  * \param hfp an hfp_pvt struct
2548  * \param value the value to send (must be between 0 and 15)
2549  */
2550 static int hfp_send_vgs(struct hfp_pvt *hfp, int value)
2551 {
2552         char cmd[32];
2553         snprintf(cmd, sizeof(cmd), "AT+VGS=%d\r", value);
2554         return rfcomm_write(hfp->rsock, cmd);
2555 }
2556
2557 #if 0
2558 /*!
2559  * \brief Send the current microphone gain level.
2560  * \param hfp an hfp_pvt struct
2561  * \param value the value to send (must be between 0 and 15)
2562  */
2563 static int hfp_send_vgm(struct hfp_pvt *hfp, int value)
2564 {
2565         char cmd[32];
2566         snprintf(cmd, sizeof(cmd), "AT+VGM=%d\r", value);
2567         return rfcomm_write(hfp->rsock, cmd);
2568 }
2569 #endif
2570
2571 /*!
2572  * \brief Enable or disable calling line identification.
2573  * \param hfp an hfp_pvt struct
2574  * \param status enable or disable calling line identification (should be 1 or
2575  * 0)
2576  */
2577 static int hfp_send_clip(struct hfp_pvt *hfp, int status)
2578 {
2579         char cmd[32];
2580         snprintf(cmd, sizeof(cmd), "AT+CLIP=%d\r", status ? 1 : 0);
2581         return rfcomm_write(hfp->rsock, cmd);
2582 }
2583
2584 /*!
2585  * \brief Send a DTMF command.
2586  * \param hfp an hfp_pvt struct
2587  * \param digit the dtmf digit to send
2588  * \return the result of rfcomm_write() or -1 on an invalid digit being sent
2589  */
2590 static int hfp_send_dtmf(struct hfp_pvt *hfp, char digit)
2591 {
2592         char cmd[10];
2593
2594         switch(digit) {
2595         case '0':
2596         case '1':
2597         case '2':
2598         case '3':
2599         case '4':
2600         case '5':
2601         case '6':
2602         case '7':
2603         case '8':
2604         case '9':
2605         case '*':
2606         case '#':
2607                 snprintf(cmd, sizeof(cmd), "AT+VTS=%c\r", digit);
2608                 return rfcomm_write(hfp->rsock, cmd);
2609         default:
2610                 return -1;
2611         }
2612 }
2613
2614 /*!
2615  * \brief Set the SMS mode.
2616  * \param hfp an hfp_pvt struct
2617  * \param mode the sms mode (0 = PDU, 1 = Text)
2618  */
2619 static int hfp_send_cmgf(struct hfp_pvt *hfp, int mode)
2620 {
2621         char cmd[32];
2622         snprintf(cmd, sizeof(cmd), "AT+CMGF=%d\r", mode);
2623         return rfcomm_write(hfp->rsock, cmd);
2624 }
2625
2626 /*!
2627  * \brief Setup SMS new message indication.
2628  * \param hfp an hfp_pvt struct
2629  */
2630 static int hfp_send_cnmi(struct hfp_pvt *hfp)
2631 {
2632         return rfcomm_write(hfp->rsock, "AT+CNMI=2,1,0,0,0\r");
2633 }
2634
2635 /*!
2636  * \brief Read an SMS message.
2637  * \param hfp an hfp_pvt struct
2638  * \param index the location of the requested message
2639  */
2640 static int hfp_send_cmgr(struct hfp_pvt *hfp, int index)
2641 {
2642         char cmd[32];
2643         snprintf(cmd, sizeof(cmd), "AT+CMGR=%d\r", index);
2644         return rfcomm_write(hfp->rsock, cmd);
2645 }
2646
2647 /*!
2648  * \brief Start sending an SMS message.
2649  * \param hfp an hfp_pvt struct
2650  * \param number the destination of the message
2651  */
2652 static int hfp_send_cmgs(struct hfp_pvt *hfp, const char *number)
2653 {
2654         char cmd[64];
2655         snprintf(cmd, sizeof(cmd), "AT+CMGS=\"%s\"\r", number);
2656         return rfcomm_write(hfp->rsock, cmd);
2657 }
2658
2659 /*!
2660  * \brief Send the text of an SMS message.
2661  * \param hfp an hfp_pvt struct
2662  * \param message the text of the message
2663  */
2664 static int hfp_send_sms_text(struct hfp_pvt *hfp, const char *message)
2665 {
2666         char cmd[162];
2667         snprintf(cmd, sizeof(cmd), "%.160s\x1a", message);
2668         return rfcomm_write(hfp->rsock, cmd);
2669 }
2670
2671 /*!
2672  * \brief Send AT+CHUP.
2673  * \param hfp an hfp_pvt struct
2674  */
2675 static int hfp_send_chup(struct hfp_pvt *hfp)
2676 {
2677         return rfcomm_write(hfp->rsock, "AT+CHUP\r");
2678 }
2679
2680 /*!
2681  * \brief Send ATD.
2682  * \param hfp an hfp_pvt struct
2683  * \param number the number to send
2684  */
2685 static int hfp_send_atd(struct hfp_pvt *hfp, const char *number)
2686 {
2687         char cmd[64];
2688         snprintf(cmd, sizeof(cmd), "ATD%s;\r", number);
2689         return rfcomm_write(hfp->rsock, cmd);
2690 }
2691
2692 /*!
2693  * \brief Send ATA.
2694  * \param hfp an hfp_pvt struct
2695  */
2696 static int hfp_send_ata(struct hfp_pvt *hfp)
2697 {
2698         return rfcomm_write(hfp->rsock, "ATA\r");
2699 }
2700
2701 /*!
2702  * \brief Send CUSD.
2703  * \param hfp an hfp_pvt struct
2704  * \param code the CUSD code to send
2705  */
2706 static int hfp_send_cusd(struct hfp_pvt *hfp, const char *code)
2707 {
2708         char cmd[128];
2709         snprintf(cmd, sizeof(cmd), "AT+CUSD=1,\"%s\",15\r", code);
2710         return rfcomm_write(hfp->rsock, cmd);
2711 }
2712
2713 /*!
2714  * \brief Parse BRSF data.
2715  * \param hfp an hfp_pvt struct
2716  * \param buf the buffer to parse (null terminated)
2717  */
2718 static int hfp_parse_brsf(struct hfp_pvt *hfp, const char *buf)
2719 {
2720         int brsf;
2721
2722         if (!sscanf(buf, "+BRSF:%d", &brsf))
2723                 return -1;
2724
2725         hfp_int2brsf(brsf, &hfp->brsf);
2726
2727         return 0;
2728 }
2729
2730 /*!
2731  * \brief Parse and store the given indicator.
2732  * \param hfp an hfp_pvt struct
2733  * \param group the indicator group
2734  * \param indicator the indicator to parse
2735  */
2736 static int hfp_parse_cind_indicator(struct hfp_pvt *hfp, int group, char *indicator)
2737 {
2738         int value;
2739
2740         /* store the current indicator */
2741         if (group >= ARRAY_LEN(hfp->cind_state)) {
2742                 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));
2743                 return -1;
2744         }
2745
2746         if (!sscanf(indicator, "%d", &value)) {
2747                 ast_debug(1, "error parsing CIND state '%s' for group %d\n", indicator, group);
2748                 return -1;
2749         }
2750
2751         hfp->cind_state[group] = value;
2752         return 0;
2753 }
2754
2755 /*!
2756  * \brief Read the result of the AT+CIND? command.
2757  * \param hfp an hfp_pvt struct
2758  * \param buf the buffer to parse (null terminated)
2759  * \note hfp_send_cind_test() and hfp_parse_cind_test() should be called at
2760  * least once before this function is called.
2761  */
2762 static int hfp_parse_cind(struct hfp_pvt *hfp, char *buf)
2763 {
2764         int i, state, group;
2765         size_t s;
2766         char *indicator = NULL;
2767
2768         /* parse current state of all of our indicators.  The list is in the
2769          * following format:
2770          * +CIND: 1,0,2,0,0,0,0
2771          */
2772         group = 0;
2773         state = 0;
2774         s = strlen(buf);
2775         for (i = 0; i < s; i++) {
2776                 switch (state) {
2777                 case 0: /* search for start of the status indicators (a space) */
2778                         if (buf[i] == ' ') {
2779                                 group++;
2780                                 state++;
2781                         }
2782                         break;
2783                 case 1: /* mark this indicator */
2784                         indicator = &buf[i];
2785                         state++;
2786                         break;
2787                 case 2: /* search for the start of the next indicator (a comma) */
2788                         if (buf[i] == ',') {
2789                                 buf[i] = '\0';
2790
2791                                 hfp_parse_cind_indicator(hfp, group, indicator);
2792
2793                                 group++;
2794                                 state = 1;
2795                         }
2796                         break;
2797                 }
2798         }
2799
2800         /* store the last indicator */
2801         if (state == 2)
2802                 hfp_parse_cind_indicator(hfp, group, indicator);
2803
2804         return 0;
2805 }
2806
2807 /*!
2808  * \brief Parse the result of the AT+CIND=? command.
2809  * \param hfp an hfp_pvt struct
2810  * \param buf the buffer to parse (null terminated)
2811  */
2812 static int hfp_parse_cind_test(struct hfp_pvt *hfp, char *buf)
2813 {
2814         int i, state, group;
2815         size_t s;
2816         char *indicator = NULL;
2817
2818         hfp->nocallsetup = 1;
2819
2820         /* parse the indications list.  It is in the follwing format:
2821          * +CIND: ("ind1",(0-1)),("ind2",(0-5))
2822          */
2823         group = 0;
2824         state = 0;
2825         s = strlen(buf);
2826         for (i = 0; i < s; i++) {
2827                 switch (state) {
2828                 case 0: /* search for start of indicator block */
2829                         if (buf[i] == '(') {
2830                                 group++;
2831                                 state++;
2832                         }
2833                         break;
2834                 case 1: /* search for '"' in indicator block */
2835                         if (buf[i] == '"') {
2836                                 state++;
2837                         }
2838                         break;
2839                 case 2: /* mark the start of the indicator name */
2840                         indicator = &buf[i];
2841                         state++;
2842                         break;
2843                 case 3: /* look for the end of the indicator name */
2844                         if (buf[i] == '"') {
2845                                 buf[i] = '\0';
2846                                 state++;
2847                         }
2848                         break;
2849                 case 4: /* find the start of the value range */
2850                         if (buf[i] == '(') {
2851                                 state++;
2852                         }
2853                         break;
2854                 case 5: /* mark the start of the value range */
2855                         state++;
2856                         break;
2857                 case 6: /* find the end of the value range */
2858                         if (buf[i] == ')') {
2859                                 buf[i] = '\0';
2860                                 state++;
2861                         }
2862                         break;
2863                 case 7: /* process the values we found */
2864                         if (group < sizeof(hfp->cind_index)) {
2865                                 if (!strcmp(indicator, "service")) {
2866                                         hfp->cind_map.service = group;
2867                                         hfp->cind_index[group] = HFP_CIND_SERVICE;
2868                                 } else if (!strcmp(indicator, "call")) {
2869                                         hfp->cind_map.call = group;
2870                                         hfp->cind_index[group] = HFP_CIND_CALL;
2871                                 } else if (!strcmp(indicator, "callsetup")) {
2872                                         hfp->nocallsetup = 0;
2873                                         hfp->cind_map.callsetup = group;
2874                                         hfp->cind_index[group] = HFP_CIND_CALLSETUP;
2875                                 } else if (!strcmp(indicator, "call_setup")) { /* non standard call setup identifier */
2876                                         hfp->nocallsetup = 0;
2877                                         hfp->cind_map.callsetup = group;
2878                                         hfp->cind_index[group] = HFP_CIND_CALLSETUP;
2879                                 } else if (!strcmp(indicator, "callheld")) {
2880                                         hfp->cind_map.callheld = group;
2881                                         hfp->cind_index[group] = HFP_CIND_CALLHELD;
2882                                 } else if (!strcmp(indicator, "signal")) {
2883                                         hfp->cind_map.signal = group;
2884                                         hfp->cind_index[group] = HFP_CIND_SIGNAL;
2885                                 } else if (!strcmp(indicator, "roam")) {
2886                                         hfp->cind_map.roam = group;
2887                                         hfp->cind_index[group] = HFP_CIND_ROAM;
2888                                 } else if (!strcmp(indicator, "battchg")) {
2889                                         hfp->cind_map.battchg = group;
2890                                         hfp->cind_index[group] = HFP_CIND_BATTCHG;
2891                                 } else {
2892                                         hfp->cind_index[group] = HFP_CIND_UNKNOWN;
2893                                         ast_debug(2, "ignoring unknown CIND indicator '%s'\n", indicator);
2894                                 }
2895                         } else {
2896                                         ast_debug(1, "can't store indicator %d (%s), we only support up to %d indicators", group, indicator, (int) sizeof(hfp->cind_index));
2897                         }
2898
2899                         state = 0;
2900                         break;
2901                 }
2902         }
2903
2904         hfp->owner->no_callsetup = hfp->nocallsetup;
2905
2906         return 0;
2907 }
2908
2909
2910 /*
2911  * Bluetooth Headset Profile helpers
2912  */
2913
2914 /*!
2915  * \brief Send an OK AT response.
2916  * \param rsock the rfcomm socket to use
2917  */
2918 static int hsp_send_ok(int rsock)
2919 {
2920         return rfcomm_write(rsock, "\r\nOK\r\n");
2921 }
2922
2923 /*!
2924  * \brief Send an ERROR AT response.
2925  * \param rsock the rfcomm socket to use
2926  */
2927 static int hsp_send_error(int rsock)
2928 {
2929         return rfcomm_write(rsock, "\r\nERROR\r\n");
2930 }
2931
2932 /*!
2933  * \brief Send a speaker gain unsolicited AT response
2934  * \param rsock the rfcomm socket to use
2935  * \param gain the speaker gain value
2936  */
2937 static int hsp_send_vgs(int rsock, int gain)
2938 {
2939         char cmd[32];
2940         snprintf(cmd, sizeof(cmd), "\r\n+VGS=%d\r\n", gain);
2941         return rfcomm_write(rsock, cmd);
2942 }
2943
2944 /*!
2945  * \brief Send a microphone gain unsolicited AT response
2946  * \param rsock the rfcomm socket to use
2947  * \param gain the microphone gain value
2948  */
2949 static int hsp_send_vgm(int rsock, int gain)
2950 {
2951         char cmd[32];
2952         snprintf(cmd, sizeof(cmd), "\r\n+VGM=%d\r\n", gain);
2953         return rfcomm_write(rsock, cmd);
2954 }
2955
2956 /*!
2957  * \brief Send a RING unsolicited AT response.
2958  * \param rsock the rfcomm socket to use
2959  */
2960 static int hsp_send_ring(int rsock)
2961 {
2962         return rfcomm_write(rsock, "\r\nRING\r\n");
2963 }
2964
2965 /*
2966  * message queue functions
2967  */
2968
2969 /*!
2970  * \brief Add an item to the back of the queue.
2971  * \param pvt a mbl_pvt structure
2972  * \param expect the msg we expect to receive
2973  * \param response_to the message that was sent to generate the expected
2974  * response
2975  */
2976 static int msg_queue_push(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to)
2977 {
2978         struct msg_queue_entry *msg;
2979         if (!(msg = ast_calloc(1, sizeof(*msg)))) {
2980                 return -1;
2981         }
2982         msg->expected = expect;
2983         msg->response_to = response_to;
2984
2985         AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry);
2986         return 0;
2987 }
2988
2989 /*!
2990  * \brief Add an item to the back of the queue with data.
2991  * \param pvt a mbl_pvt structure
2992  * \param expect the msg we expect to receive
2993  * \param response_to the message that was sent to generate the expected
2994  * response
2995  * \param data data associated with this message, it will be freed when the
2996  * message is freed
2997  */
2998 static int msg_queue_push_data(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to, void *data)
2999 {
3000         struct msg_queue_entry *msg;
3001         if (!(msg = ast_calloc(1, sizeof(*msg)))) {
3002                 return -1;
3003         }
3004         msg->expected = expect;
3005         msg->response_to = response_to;
3006         msg->data = data;
3007
3008         AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry);
3009         return 0;
3010 }
3011
3012 /*!
3013  * \brief Remove an item from the front of the queue.
3014  * \param pvt a mbl_pvt structure
3015  * \return a pointer to the removed item
3016  */
3017 static struct msg_queue_entry *msg_queue_pop(struct mbl_pvt *pvt)
3018 {
3019         return AST_LIST_REMOVE_HEAD(&pvt->msg_queue, entry);
3020 }
3021
3022 /*!
3023  * \brief Remove an item from the front of the queue, and free it.
3024  * \param pvt a mbl_pvt structure
3025  */
3026 static void msg_queue_free_and_pop(struct mbl_pvt *pvt)
3027 {
3028         struct msg_queue_entry *msg;
3029         if ((msg = msg_queue_pop(pvt))) {
3030                 if (msg->data)
3031                         ast_free(msg->data);
3032                 ast_free(msg);
3033         }
3034 }
3035
3036 /*!
3037  * \brief Remove all itmes from the queue and free them.
3038  * \param pvt a mbl_pvt structure
3039  */
3040 static void msg_queue_flush(struct mbl_pvt *pvt)
3041 {
3042         struct msg_queue_entry *msg;
3043         while ((msg = msg_queue_head(pvt)))
3044                 msg_queue_free_and_pop(pvt);
3045 }
3046
3047 /*!
3048  * \brief Get the head of a queue.
3049  * \param pvt a mbl_pvt structure
3050  * \return a pointer to the head of the given msg queue
3051  */
3052 static struct msg_queue_entry *msg_queue_head(struct mbl_pvt *pvt)
3053 {
3054         return AST_LIST_FIRST(&pvt->msg_queue);
3055 }
3056
3057
3058
3059 /*
3060
3061         sdp helpers
3062
3063 */
3064
3065 static int sdp_search(char *addr, int profile)
3066 {
3067
3068         sdp_session_t *session = 0;
3069         bdaddr_t bdaddr;
3070         uuid_t svc_uuid;
3071         uint32_t range = 0x0000ffff;
3072         sdp_list_t *response_list, *search_list, *attrid_list;
3073         int status, port;
3074         sdp_list_t *proto_list;
3075         sdp_record_t *sdprec;
3076
3077         str2ba(addr, &bdaddr);
3078         port = 0;
3079         session = sdp_connect(BDADDR_ANY, &bdaddr, SDP_RETRY_IF_BUSY);
3080         if (!session) {
3081                 ast_debug(1, "sdp_connect() failed on device %s.\n", addr);
3082                 return 0;
3083         }
3084
3085         sdp_uuid32_create(&svc_uuid, profile);
3086         search_list = sdp_list_append(0, &svc_uuid);
3087         attrid_list = sdp_list_append(0, &range);
3088         response_list = 0x00;
3089         status = sdp_service_search_attr_req(session, search_list, SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
3090         if (status == 0) {
3091                 if (response_list) {
3092                         sdprec = (sdp_record_t *) response_list->data;
3093                         proto_list = 0x00;
3094                         if (sdp_get_access_protos(sdprec, &proto_list) == 0) {
3095                                 port = sdp_get_proto_port(proto_list, RFCOMM_UUID);
3096                                 sdp_list_free(proto_list, 0);
3097                         }
3098                         sdp_record_free(sdprec);
3099                         sdp_list_free(response_list, 0);
3100                 } else
3101                         ast_debug(1, "No responses returned for device %s.\n", addr);
3102         } else
3103                 ast_debug(1, "sdp_service_search_attr_req() failed on device %s.\n", addr);
3104
3105         sdp_list_free(search_list, 0);
3106         sdp_list_free(attrid_list, 0);
3107         sdp_close(session);
3108
3109         return port;
3110
3111 }
3112
3113 static sdp_session_t *sdp_register(void)
3114 {
3115         uint32_t service_uuid_int[] = {0, 0, 0, GENERIC_AUDIO_SVCLASS_ID};
3116         uint8_t rfcomm_channel = 1;
3117         const char *service_name = "Asterisk PABX";
3118         const char *service_dsc = "Asterisk PABX";
3119         const char *service_prov = "Asterisk";
3120
3121         uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid, svc_class1_uuid, svc_class2_uuid;
3122         sdp_list_t  *l2cap_list = 0, *rfcomm_list = 0, *root_list = 0, *proto_list = 0, *access_proto_list = 0, *svc_uuid_list = 0;
3123         sdp_data_t *channel = 0;
3124
3125         sdp_session_t *session = 0;
3126
3127         sdp_record_t *record = sdp_record_alloc();
3128
3129         sdp_uuid128_create(&svc_uuid, &service_uuid_int);
3130         sdp_set_service_id(record, svc_uuid);
3131
3132         sdp_uuid32_create(&svc_class1_uuid, GENERIC_AUDIO_SVCLASS_ID);
3133         sdp_uuid32_create(&svc_class2_uuid, HEADSET_PROFILE_ID);
3134
3135         svc_uuid_list = sdp_list_append(0, &svc_class1_uuid);
3136         svc_uuid_list = sdp_list_append(svc_uuid_list, &svc_class2_uuid);
3137         sdp_set_service_classes(record, svc_uuid_list);
3138
3139         sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
3140         root_list = sdp_list_append(0, &root_uuid);
3141         sdp_set_browse_groups( record, root_list );
3142
3143         sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
3144         l2cap_list = sdp_list_append(0, &l2cap_uuid);
3145         proto_list = sdp_list_append(0, l2cap_list);
3146
3147         sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
3148         channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
3149         rfcomm_list = sdp_list_append(0, &rfcomm_uuid);
3150         sdp_list_append(rfcomm_list, channel);
3151         sdp_list_append(proto_list, rfcomm_list);
3152
3153         access_proto_list = sdp_list_append(0, proto_list);
3154         sdp_set_access_protos(record, access_proto_list);
3155
3156         sdp_set_info_attr(record, service_name, service_prov, service_dsc);
3157
3158         if (!(session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY)))
3159                 ast_log(LOG_WARNING, "Failed to connect sdp and create session.\n");
3160         else {
3161                 if (sdp_record_register(session, record, 0) < 0) {
3162                         ast_log(LOG_WARNING, "Failed to sdp_record_register error: %d\n", errno);
3163                         return NULL;
3164                 }
3165         }
3166
3167         sdp_data_free(channel);
3168         sdp_list_free(rfcomm_list, 0);
3169         sdp_list_free(root_list, 0);
3170         sdp_list_free(access_proto_list, 0);
3171         sdp_list_free(svc_uuid_list, 0);
3172
3173         return session;
3174
3175 }
3176
3177 /*
3178
3179         Thread routines
3180
3181 */
3182
3183 /*!
3184  * \brief Handle the BRSF response.
3185  * \param pvt a mbl_pvt structure
3186  * \param buf a null terminated buffer containing an AT message
3187  * \retval 0 success
3188  * \retval -1 error
3189  */
3190 static int handle_response_brsf(struct mbl_pvt *pvt, char *buf)
3191 {
3192         struct msg_queue_entry *entry;
3193         if ((entry = msg_queue_head(pvt)) && entry->expected == AT_BRSF) {
3194                 if (hfp_parse_brsf(pvt->hfp, buf)) {
3195                         ast_debug(1, "[%s] error parsing BRSF\n", pvt->id);
3196                         goto e_return;
3197                 }
3198
3199                 if (msg_queue_push(pvt, AT_OK, AT_BRSF)) {
3200                         ast_debug(1, "[%s] error handling BRSF\n", pvt->id);
3201                         goto e_return;
3202                 }
3203
3204                 msg_queue_free_and_pop(pvt);
3205         } else if (entry) {
3206                 ast_debug(1, "[%s] received unexpected AT message 'BRSF' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
3207         } else {
3208                 ast_debug(1, "[%s] received unexpected AT message 'BRSF'\n", pvt->id);
3209         }
3210
3211         return 0;
3212
3213 e_return:
3214         msg_queue_free_and_pop(pvt);
3215         return -1;
3216 }
3217
3218 /*!
3219  * \brief Handle the CIND response.
3220  * \param pvt a mbl_pvt structure
3221  * \param buf a null terminated buffer containing an AT message
3222  * \retval 0 success
3223  * \retval -1 error
3224  */
3225 static int handle_response_cind(struct mbl_pvt *pvt, char *buf)
3226 {
3227         struct msg_queue_entry *entry;
3228         if ((entry = msg_queue_head(pvt)) && entry->expected == AT_CIND) {
3229                 switch (entry->response_to) {
3230                 case AT_CIND_TEST:
3231                         if (hfp_parse_cind_test(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND_TEST)) {
3232                                 ast_debug(1, "[%s] error performing CIND test\n", pvt->id);
3233                                 goto e_return;
3234                         }
3235                         break;
3236                 case AT_CIND:
3237                         if (hfp_parse_cind(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND)) {
3238                                 ast_debug(1, "[%s] error getting CIND state\n", pvt->id);
3239                                 goto e_return;
3240                         }
3241                         break;
3242                 default:
3243                         ast_debug(1, "[%s] error getting CIND state\n", pvt->id);
3244                         goto e_return;
3245                 }
3246                 msg_queue_free_and_pop(pvt);
3247         } else if (entry) {
3248                 ast_debug(1, "[%s] received unexpected AT message 'CIND' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
3249         } else {
3250                 ast_debug(1, "[%s] received unexpected AT message 'CIND'\n", pvt->id);
3251         }
3252
3253         return 0;
3254
3255 e_return:
3256         msg_queue_free_and_pop(pvt);
3257         return -1;
3258 }
3259
3260 /*!
3261  * \brief Handle OK AT messages.
3262  * \param pvt a mbl_pvt structure
3263  * \param buf a null terminated buffer containing an AT message
3264  * \retval 0 success
3265  * \retval -1 error
3266  */
3267 static int handle_response_ok(struct mbl_pvt *pvt, char *buf)
3268 {
3269         struct msg_queue_entry *entry;
3270         if ((entry = msg_queue_head(pvt)) && entry->expected == AT_OK) {
3271                 switch (entry->response_to) {
3272
3273                 /* initialization stuff */
3274                 case AT_BRSF:
3275                         ast_debug(1, "[%s] BSRF sent successfully\n", pvt->id);
3276
3277                         /* If this is a blackberry do CMER now, otherwise
3278                          * continue with CIND as normal. */
3279                         if (pvt->blackberry) {
3280                                 if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) {
3281                                         ast_debug(1, "[%s] error sending CMER\n", pvt->id);
3282                                         goto e_return;
3283                                 }
3284                         } else {
3285                                 if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) {
3286                                         ast_debug(1, "[%s] error sending CIND test\n", pvt->id);
3287                                         goto e_return;
3288                                 }
3289                         }
3290                         break;
3291                 case AT_CIND_TEST:
3292                         ast_debug(1, "[%s] CIND test sent successfully\n", pvt->id);
3293
3294                         ast_debug(2, "[%s] call: %d\n", pvt->id, pvt->hfp->cind_map.call);
3295                         ast_debug(2, "[%s] callsetup: %d\n", pvt->id, pvt->hfp->cind_map.callsetup);
3296                         ast_debug(2, "[%s] service: %d\n", pvt->id, pvt->hfp->cind_map.service);
3297
3298                         if (hfp_send_cind(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND)) {
3299                                 ast_debug(1, "[%s] error requesting CIND state\n", pvt->id);
3300                                 goto e_return;
3301                         }
3302                         break;
3303                 case AT_CIND:
3304                         ast_debug(1, "[%s] CIND sent successfully\n", pvt->id);
3305
3306                         /* check if a call is active */
3307                         if (pvt->hfp->cind_state[pvt->hfp->cind_map.call]) {
3308                                 ast_verb(3, "Bluetooth Device %s has a call in progress - delaying connection.\n", pvt->id);
3309                                 goto e_return;
3310                         }
3311
3312                         /* If this is NOT a blackberry proceed with CMER,
3313                          * otherwise send CLIP. */
3314                         if (!pvt->blackberry) {
3315                                 if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) {
3316                                         ast_debug(1, "[%s] error sending CMER\n", pvt->id);
3317                                         goto e_return;
3318                                 }
3319                         } else {
3320                                 if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) {
3321                                         ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id);
3322                                         goto e_return;
3323                                 }
3324                         }
3325                         break;
3326                 case AT_CMER:
3327                         ast_debug(1, "[%s] CMER sent successfully\n", pvt->id);
3328
3329                         /* If this is a blackberry proceed with the CIND test,
3330                          * otherwise send CLIP. */
3331                         if (pvt->blackberry) {
3332                                 if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) {
3333                                         ast_debug(1, "[%s] error sending CIND test\n", pvt->id);
3334                                         goto e_return;
3335                                 }
3336                         } else {
3337                                 if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) {
3338                                         ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id);
3339                                         goto e_return;
3340                                 }
3341                         }
3342                         break;
3343                 case AT_CLIP:
3344                         ast_debug(1, "[%s] caling line indication enabled\n", pvt->id);
3345                         if (hfp_send_ecam(pvt->hfp) || msg_queue_push(pvt, AT_OK, AT_ECAM)) {
3346                                 ast_debug(1, "[%s] error enabling Sony Ericsson call monitoring extensions\n", pvt->id);
3347                                 goto e_return;
3348                         }
3349
3350                         break;
3351                 case AT_ECAM:
3352                         ast_debug(1, "[%s] Sony Ericsson call monitoring is active on device\n", pvt->id);
3353                         if (hfp_send_vgs(pvt->hfp, 15) || msg_queue_push(pvt, AT_OK, AT_VGS)) {
3354                                 ast_debug(1, "[%s] error synchronizing gain settings\n", pvt->id);
3355                                 goto e_return;