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