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