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