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