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