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