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