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