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