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