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