Fixed a comment for hfp_parse_clip
[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/received an answer */
150         unsigned int connected:1;       /*!< do we have an rfcomm connection to a device */
151
152         AST_LIST_ENTRY(mbl_pvt) entry;
153 };
154
155 static AST_RWLIST_HEAD_STATIC(devices, mbl_pvt);
156
157 static int handle_response_ok(struct mbl_pvt *pvt, char *buf);
158 static int handle_response_error(struct mbl_pvt *pvt, char *buf);
159 static int handle_response_ciev(struct mbl_pvt *pvt, char *buf);
160 static int handle_response_clip(struct mbl_pvt *pvt, char *buf);
161 static int handle_response_ring(struct mbl_pvt *pvt, char *buf);
162 static int handle_response_cmti(struct mbl_pvt *pvt, char *buf);
163 static int handle_response_cmgr(struct mbl_pvt *pvt, char *buf);
164 static int handle_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 = newchan->tech_pvt;
1104
1105         if (!pvt) {
1106                 ast_debug(1, "fixup failed, no pvt on newchan\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  * information in buf
1942  */
1943 static char *hfp_parse_clip(struct hfp_pvt *hfp, char *buf)
1944 {
1945         int i, state;
1946         char *clip = NULL;
1947         size_t s;
1948
1949         /* parse clip info in the following format:
1950          * +CLIP: "123456789",128,...
1951          */
1952         state = 0;
1953         s = strlen(buf);
1954         for (i = 0; i < s && state != 3; i++) {
1955                 switch (state) {
1956                 case 0: /* search for start of the number (") */
1957                         if (buf[i] == '"') {
1958                                 state++;
1959                         }
1960                         break;
1961                 case 1: /* mark the number */
1962                         clip = &buf[i];
1963                         state++;
1964                         /* fall through */
1965                 case 2: /* search for the end of the number (") */
1966                         if (buf[i] == '"') {
1967                                 buf[i] = '\0';
1968                                 state++;
1969                         }
1970                         break;
1971                 }
1972         }
1973
1974         if (state != 3) {
1975                 return NULL;
1976         }
1977
1978         return clip;
1979 }
1980
1981 /*!
1982  * \brief Parse a CMTI notification.
1983  * \param hfp an hfp_pvt struct
1984  * \param buf the buffer to parse (null terminated)
1985  * @note buf will be modified when the CMTI message is parsed
1986  * \return -1 on error (parse error) or the index of the new sms message
1987  */
1988 static int hfp_parse_cmti(struct hfp_pvt *hfp, char *buf)
1989 {
1990         int index = -1;
1991
1992         /* parse cmti info in the following format:
1993          * +CMTI: <mem>,<index> 
1994          */
1995         if (!sscanf(buf, "+CMTI: %*[^,],%d", &index)) {
1996                 ast_debug(2, "[%s] error parsing CMTI event '%s'\n", hfp->owner->id, buf);
1997                 return -1;
1998         }
1999
2000         return index;
2001 }
2002
2003 /*!
2004  * \brief Parse a CMGR message.
2005  * \param hfp an hfp_pvt struct
2006  * \param buf the buffer to parse (null terminated)
2007  * \param from_number a pointer to a char pointer which will store the from
2008  * number
2009  * \param text a pointer to a char pointer which will store the message text
2010  * @note buf will be modified when the CMGR message is parsed
2011  * \retval -1 parse error
2012  * \retval 0 success
2013  */
2014 static int hfp_parse_cmgr(struct hfp_pvt *hfp, char *buf, char **from_number, char **text)
2015 {
2016         int i, state;
2017         size_t s;
2018
2019         /* parse cmgr info in the following format:
2020          * +CMGR: <msg status>,"+123456789",...\r\n
2021          * <message text>
2022          */
2023         state = 0;
2024         s = strlen(buf);
2025         for (i = 0; i < s && s != 6; i++) {
2026                 switch (state) {
2027                 case 0: /* search for start of the number section (,) */
2028                         if (buf[i] == ',') {
2029                                 state++;
2030                         }
2031                         break;
2032                 case 1: /* find the opening quote (") */
2033                         if (buf[i] == '"') {
2034                                 state++;
2035                         }
2036                 case 2: /* mark the start of the number */
2037                         if (from_number) {
2038                                 *from_number = &buf[i];
2039                                 state++;
2040                         }
2041                         /* fall through */
2042                 case 3: /* search for the end of the number (") */
2043                         if (buf[i] == '"') {
2044                                 buf[i] = '\0';
2045                                 state++;
2046                         }
2047                         break;
2048                 case 4: /* search for the start of the message text (\n) */
2049                         if (buf[i] == '\n') {
2050                                 state++;
2051                         }
2052                         break;
2053                 case 5: /* mark the start of the message text */
2054                         if (text) {
2055                                 *text = &buf[i];
2056                                 state++;
2057                         }
2058                         break;
2059                 }
2060         }
2061
2062         if (state != 6) {
2063                 return -1;
2064         }
2065
2066         return 0;
2067 }
2068
2069 /*!
2070  * \brief Convert a hfp_hf struct to a BRSF int.
2071  * \param hf an hfp_hf brsf object
2072  * \return an integer representing the given brsf struct
2073  */
2074 static int hfp_brsf2int(struct hfp_hf *hf)
2075 {
2076         int brsf = 0;
2077
2078         brsf |= hf->ecnr ? HFP_HF_ECNR : 0;
2079         brsf |= hf->cw ? HFP_HF_CW : 0;
2080         brsf |= hf->cid ? HFP_HF_CID : 0;
2081         brsf |= hf->voice ? HFP_HF_VOICE : 0;
2082         brsf |= hf->volume ? HFP_HF_VOLUME : 0;
2083         brsf |= hf->status ? HFP_HF_STATUS : 0;
2084         brsf |= hf->control ? HFP_HF_CONTROL : 0;
2085
2086         return brsf;
2087 }
2088
2089 /*!
2090  * \brief Convert a BRSF int to an hfp_ag struct.
2091  * \param brsf a brsf integer
2092  * \param ag a AG (hfp_ag) brsf object
2093  * \return a pointer to the given hfp_ag object populated with the values from
2094  * the given brsf integer
2095  */
2096 static struct hfp_ag *hfp_int2brsf(int brsf, struct hfp_ag *ag)
2097 {
2098         ag->cw = brsf & HFP_AG_CW ? 1 : 0;
2099         ag->ecnr = brsf & HFP_AG_ECNR ? 1 : 0;
2100         ag->voice = brsf & HFP_AG_VOICE ? 1 : 0;
2101         ag->ring = brsf & HFP_AG_RING ? 1 : 0;
2102         ag->tag = brsf & HFP_AG_TAG ? 1 : 0;
2103         ag->reject = brsf & HFP_AG_REJECT ? 1 : 0;
2104         ag->status = brsf & HFP_AG_STATUS ? 1 : 0;
2105         ag->control = brsf & HFP_AG_CONTROL ? 1 : 0;
2106         ag->errors = brsf & HFP_AG_ERRORS ? 1 : 0;
2107
2108         return ag;
2109 }
2110
2111
2112 /*!
2113  * \brief Send a BRSF request.
2114  * \param hfp an hfp_pvt struct
2115  * \param brsf an hfp_hf brsf struct
2116  *
2117  * \retval 0 on success
2118  * \retval -1 on error
2119  */
2120 static int hfp_send_brsf(struct hfp_pvt *hfp, struct hfp_hf *brsf)
2121 {
2122         char cmd[32];
2123         snprintf(cmd, sizeof(cmd), "AT+BRSF=%d\r", hfp_brsf2int(brsf));
2124         return rfcomm_write(hfp->rsock, cmd);
2125 }
2126
2127 /*!
2128  * \brief Send the CIND read command.
2129  * \param hfp an hfp_pvt struct
2130  */
2131 static int hfp_send_cind(struct hfp_pvt *hfp)
2132 {
2133         return rfcomm_write(hfp->rsock, "AT+CIND?\r");
2134 }
2135
2136 /*!
2137  * \brief Send the CIND test command.
2138  * \param hfp an hfp_pvt struct
2139  */
2140 static int hfp_send_cind_test(struct hfp_pvt *hfp)
2141 {
2142         return rfcomm_write(hfp->rsock, "AT+CIND=?\r");
2143 }
2144
2145 /*!
2146  * \brief Enable or disable indicator events reporting.
2147  * \param hfp an hfp_pvt struct
2148  * \param status enable or disable events reporting (should be 1 or 0)
2149  */
2150 static int hfp_send_cmer(struct hfp_pvt *hfp, int status)
2151 {
2152         char cmd[32];
2153         snprintf(cmd, sizeof(cmd), "AT+CMER=3,0,0,%d\r", status ? 1 : 0);
2154         return rfcomm_write(hfp->rsock, cmd);
2155 }
2156
2157 /*!
2158  * \brief Send the current speaker gain level.
2159  * \param hfp an hfp_pvt struct
2160  * \param value the value to send (must be between 0 and 15)
2161  */
2162 static int hfp_send_vgs(struct hfp_pvt *hfp, int value)
2163 {
2164         char cmd[32];
2165         snprintf(cmd, sizeof(cmd), "AT+VGS=%d\r", value);
2166         return rfcomm_write(hfp->rsock, cmd);
2167 }
2168
2169 #if 0
2170 /*!
2171  * \brief Send the current microphone gain level.
2172  * \param hfp an hfp_pvt struct
2173  * \param value the value to send (must be between 0 and 15)
2174  */
2175 static int hfp_send_vgm(struct hfp_pvt *hfp, int value)
2176 {
2177         char cmd[32];
2178         snprintf(cmd, sizeof(cmd), "AT+VGM=%d\r", value);
2179         return rfcomm_write(hfp->rsock, cmd);
2180 }
2181 #endif
2182
2183 /*!
2184  * \brief Enable or disable calling line identification.
2185  * \param hfp an hfp_pvt struct
2186  * \param status enable or disable calling line identification (should be 1 or
2187  * 0)
2188  */
2189 static int hfp_send_clip(struct hfp_pvt *hfp, int status)
2190 {
2191         char cmd[32];
2192         snprintf(cmd, sizeof(cmd), "AT+CLIP=%d\r", status ? 1 : 0);
2193         return rfcomm_write(hfp->rsock, cmd);
2194 }
2195
2196 /*!
2197  * \brief Send a DTMF command.
2198  * \param hfp an hfp_pvt struct
2199  * \param digit the dtmf digit to send
2200  * \return the result of rfcomm_write() or -1 on an invalid digit being sent
2201  */
2202 static int hfp_send_dtmf(struct hfp_pvt *hfp, char digit)
2203 {
2204         char cmd[10];
2205
2206         switch(digit) {
2207         case '0':
2208         case '1':
2209         case '2':
2210         case '3':
2211         case '4':
2212         case '5':
2213         case '6':
2214         case '7':
2215         case '8':
2216         case '9':
2217         case '*':
2218         case '#':
2219                 snprintf(cmd, sizeof(cmd), "AT+VTS=%c\r", digit);
2220                 return rfcomm_write(hfp->rsock, cmd);
2221         default:
2222                 return -1;
2223         }
2224 }
2225
2226 /*!
2227  * \brief Set the SMS mode.
2228  * \param hfp an hfp_pvt struct
2229  * \param mode the sms mode (0 = PDU, 1 = Text)
2230  */
2231 static int hfp_send_cmgf(struct hfp_pvt *hfp, int mode)
2232 {
2233         char cmd[32];
2234         snprintf(cmd, sizeof(cmd), "AT+CMGF=%d\r", mode);
2235         return rfcomm_write(hfp->rsock, cmd);
2236 }
2237
2238 /*!
2239  * \brief Setup SMS new message indication.
2240  * \param hfp an hfp_pvt struct
2241  */
2242 static int hfp_send_cnmi(struct hfp_pvt *hfp)
2243 {
2244         return rfcomm_write(hfp->rsock, "AT+CNMI=2,1,0,0,0\r");
2245 }
2246
2247 /*!
2248  * \brief Read an SMS message.
2249  * \param hfp an hfp_pvt struct
2250  * \param index the location of the requested message
2251  */
2252 static int hfp_send_cmgr(struct hfp_pvt *hfp, int index)
2253 {
2254         char cmd[32];
2255         snprintf(cmd, sizeof(cmd), "AT+CMGR=%d\r", index);
2256         return rfcomm_write(hfp->rsock, cmd);
2257 }
2258
2259 /*!
2260  * \brief Start sending an SMS message.
2261  * \param hfp an hfp_pvt struct
2262  * \param number the destination of the message
2263  */
2264 static int hfp_send_cmgs(struct hfp_pvt *hfp, const char *number)
2265 {
2266         char cmd[64];
2267         snprintf(cmd, sizeof(cmd), "AT+CMGS=\"%s\"\r", number);
2268         return rfcomm_write(hfp->rsock, cmd);
2269 }
2270
2271 /*!
2272  * \brief Send the text of an SMS message.
2273  * \param hfp an hfp_pvt struct
2274  * \param message the text of the message
2275  */
2276 static int hfp_send_sms_text(struct hfp_pvt *hfp, const char *message)
2277 {
2278         char cmd[162];
2279         snprintf(cmd, sizeof(cmd), "%.160s\x1a", message);
2280         return rfcomm_write(hfp->rsock, cmd);
2281 }
2282
2283 /*!
2284  * \brief Send AT+CHUP.
2285  * \param hfp an hfp_pvt struct
2286  */
2287 static int hfp_send_chup(struct hfp_pvt *hfp)
2288 {
2289         return rfcomm_write(hfp->rsock, "AT+CHUP\r");
2290 }
2291
2292 /*!
2293  * \brief Send ATD.
2294  * \param hfp an hfp_pvt struct
2295  * \param number the number to send
2296  */
2297 static int hfp_send_atd(struct hfp_pvt *hfp, const char *number)
2298 {
2299         char cmd[64];
2300         snprintf(cmd, sizeof(cmd), "ATD%s;\r", number);
2301         return rfcomm_write(hfp->rsock, cmd);
2302 }
2303
2304 /*!
2305  * \brief Send ATA.
2306  * \param hfp an hfp_pvt struct
2307  */
2308 static int hfp_send_ata(struct hfp_pvt *hfp)
2309 {
2310         return rfcomm_write(hfp->rsock, "ATA\r");
2311 }
2312
2313 /*!
2314  * \brief Parse BRSF data.
2315  * \param hfp an hfp_pvt struct
2316  * \param buf the buffer to parse (null terminated)
2317  */
2318 static int hfp_parse_brsf(struct hfp_pvt *hfp, const char *buf)
2319 {
2320         int brsf;
2321
2322         if (!sscanf(buf, "+BRSF:%d", &brsf))
2323                 return -1;
2324
2325         hfp_int2brsf(brsf, &hfp->brsf);
2326
2327         return 0;
2328 }
2329
2330 /*!
2331  * \brief Parse and store the given indicator.
2332  * \param hfp an hfp_pvt struct
2333  * \param group the indicator group
2334  * \param indicator the indicator to parse
2335  */
2336 static int hfp_parse_cind_indicator(struct hfp_pvt *hfp, int group, char *indicator)
2337 {
2338         int value;
2339
2340         /* store the current indicator */
2341         if (group >= sizeof(hfp->cind_state)) {
2342                 ast_debug(1, "ignoring CIND state '%s' for group %d, we only support up to %d indicators\n", indicator, group, (int) sizeof(hfp->cind_state));
2343                 return -1;
2344         }
2345
2346         if (!sscanf(indicator, "%d", &value)) {
2347                 ast_debug(1, "error parsing CIND state '%s' for group %d\n", indicator, group);
2348                 return -1;
2349         }
2350
2351         hfp->cind_state[group] = value;
2352         return 0;
2353 }
2354
2355 /*!
2356  * \brief Read the result of the AT+CIND? command.
2357  * \param hfp an hfp_pvt struct
2358  * \param buf the buffer to parse (null terminated)
2359  * \note hfp_send_cind_test() and hfp_parse_cind_test() should be called at
2360  * least once before this function is called.
2361  */
2362 static int hfp_parse_cind(struct hfp_pvt *hfp, char *buf)
2363 {
2364         int i, state, group;
2365         size_t s;
2366         char *indicator = NULL;
2367
2368         /* parse current state of all of our indicators.  The list is in the
2369          * following format:
2370          * +CIND: 1,0,2,0,0,0,0
2371          */
2372         group = 0;
2373         state = 0;
2374         s = strlen(buf);
2375         for (i = 0; i < s; i++) {
2376                 switch (state) {
2377                 case 0: /* search for start of the status indicators (a space) */
2378                         if (buf[i] == ' ') {
2379                                 group++;
2380                                 state++;
2381                         }
2382                         break;
2383                 case 1: /* mark this indicator */
2384                         indicator = &buf[i];
2385                         state++;
2386                         break;
2387                 case 2: /* search for the start of the next indicator (a comma) */
2388                         if (buf[i] == ',') {
2389                                 buf[i] = '\0';
2390
2391                                 hfp_parse_cind_indicator(hfp, group, indicator);
2392
2393                                 group++;
2394                                 state = 1;
2395                         }
2396                         break;
2397                 }
2398         }
2399
2400         /* store the last indicator */
2401         if (state == 2)
2402                 hfp_parse_cind_indicator(hfp, group, indicator);
2403
2404         return 0;
2405 }
2406
2407 /*!
2408  * \brief Parse the result of the AT+CIND=? command.
2409  * \param hfp an hfp_pvt struct
2410  * \param buf the buffer to parse (null terminated)
2411  */
2412 static int hfp_parse_cind_test(struct hfp_pvt *hfp, char *buf)
2413 {
2414         int i, state, group;
2415         size_t s;
2416         char *indicator = NULL, *values;
2417
2418         hfp->nocallsetup = 1;
2419
2420         /* parse the indications list.  It is in the follwing format:
2421          * +CIND: ("ind1",(0-1)),("ind2",(0-5))
2422          */
2423         group = 0;
2424         state = 0;
2425         s = strlen(buf);
2426         for (i = 0; i < s; i++) {
2427                 switch (state) {
2428                 case 0: /* search for start of indicator block */
2429                         if (buf[i] == '(') {
2430                                 group++;
2431                                 state++;
2432                         }
2433                         break;
2434                 case 1: /* search for '"' in indicator block */
2435                         if (buf[i] == '"') {
2436                                 state++;
2437                         }
2438                         break;
2439                 case 2: /* mark the start of the indicator name */
2440                         indicator = &buf[i];
2441                         state++;
2442                         break;
2443                 case 3: /* look for the end of the indicator name */
2444                         if (buf[i] == '"') {
2445                                 buf[i] = '\0';
2446                                 state++;
2447                         }
2448                         break;
2449                 case 4: /* find the start of the value range */
2450                         if (buf[i] == '(') {
2451                                 state++;
2452                         }
2453                         break;
2454                 case 5: /* mark the start of the value range */
2455                         values = &buf[i];
2456                         state++;
2457                         break;
2458                 case 6: /* find the end of the value range */
2459                         if (buf[i] == ')') {
2460                                 buf[i] = '\0';
2461                                 state++;
2462                         }
2463                         break;
2464                 case 7: /* process the values we found */
2465                         if (group < sizeof(hfp->cind_index)) {
2466                                 if (!strcmp(indicator, "service")) {
2467                                         hfp->cind_map.service = group;
2468                                         hfp->cind_index[group] = HFP_CIND_SERVICE;
2469                                 } else if (!strcmp(indicator, "call")) {
2470                                         hfp->cind_map.call = group;
2471                                         hfp->cind_index[group] = HFP_CIND_CALL;
2472                                 } else if (!strcmp(indicator, "callsetup")) {
2473                                         hfp->nocallsetup = 0;
2474                                         hfp->cind_map.callsetup = group;
2475                                         hfp->cind_index[group] = HFP_CIND_CALLSETUP;
2476                                 } else if (!strcmp(indicator, "call_setup")) { /* non standard call setup identifier */
2477                                         hfp->nocallsetup = 0;
2478                                         hfp->cind_map.callsetup = group;
2479                                         hfp->cind_index[group] = HFP_CIND_CALLSETUP;
2480                                 } else if (!strcmp(indicator, "callheld")) {
2481                                         hfp->cind_map.callheld = group;
2482                                         hfp->cind_index[group] = HFP_CIND_CALLHELD;
2483                                 } else if (!strcmp(indicator, "signal")) {
2484                                         hfp->cind_map.signal = group;
2485                                         hfp->cind_index[group] = HFP_CIND_SIGNAL;
2486                                 } else if (!strcmp(indicator, "roam")) {
2487                                         hfp->cind_map.roam = group;
2488                                         hfp->cind_index[group] = HFP_CIND_ROAM;
2489                                 } else if (!strcmp(indicator, "battchg")) {
2490                                         hfp->cind_map.battchg = group;
2491                                         hfp->cind_index[group] = HFP_CIND_BATTCHG;
2492                                 } else {
2493                                         hfp->cind_index[group] = HFP_CIND_UNKNOWN;
2494                                         ast_debug(2, "ignoring unknown CIND indicator '%s'\n", indicator);
2495                                 }
2496                         } else {
2497                                         ast_debug(1, "can't store indicator %d (%s), we only support up to %d indicators", group, indicator, (int) sizeof(hfp->cind_index));
2498                         }
2499
2500                         state = 0;
2501                         break;
2502                 }
2503         }
2504
2505         hfp->owner->no_callsetup = hfp->nocallsetup;
2506
2507         return 0;
2508 }
2509
2510
2511 /*
2512  * Bluetooth Headset Profile helpers
2513  */
2514
2515 /*!
2516  * \brief Send an OK AT response.
2517  * \param rsock the rfcomm socket to use
2518  */
2519 static int hsp_send_ok(int rsock)
2520 {
2521         return rfcomm_write(rsock, "\r\nOK\r\n");
2522 }
2523
2524 /*!
2525  * \brief Send an ERROR AT response.
2526  * \param rsock the rfcomm socket to use
2527  */
2528 static int hsp_send_error(int rsock)
2529 {
2530         return rfcomm_write(rsock, "\r\nERROR\r\n");
2531 }
2532
2533 /*!
2534  * \brief Send a speaker gain unsolicited AT response
2535  * \param rsock the rfcomm socket to use
2536  * \param gain the speaker gain value
2537  */
2538 static int hsp_send_vgs(int rsock, int gain)
2539 {
2540         char cmd[32];
2541         snprintf(cmd, sizeof(cmd), "\r\n+VGS=%d\r\n", gain);
2542         return rfcomm_write(rsock, cmd);
2543 }
2544
2545 /*!
2546  * \brief Send a microphone gain unsolicited AT response
2547  * \param rsock the rfcomm socket to use
2548  * \param gain the microphone gain value
2549  */
2550 static int hsp_send_vgm(int rsock, int gain)
2551 {
2552         char cmd[32];
2553         snprintf(cmd, sizeof(cmd), "\r\n+VGM=%d\r\n", gain);
2554         return rfcomm_write(rsock, cmd);
2555 }
2556
2557 /*!
2558  * \brief Send a RING unsolicited AT response.
2559  * \param rsock the rfcomm socket to use
2560  */
2561 static int hsp_send_ring(int rsock)
2562 {
2563         return rfcomm_write(rsock, "\r\nRING\r\n");
2564 }
2565
2566 /*
2567  * message queue functions
2568  */
2569
2570 /*!
2571  * \brief Add an item to the back of the queue.
2572  * \param pvt a mbl_pvt structure
2573  * \param expect the msg we expect to receive
2574  * \param response_to the message that was sent to generate the expected
2575  * response
2576  */
2577 static int msg_queue_push(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to)
2578 {
2579         struct msg_queue_entry *msg;
2580         if (!(msg = ast_calloc(1, sizeof(*msg)))) {
2581                 return -1;
2582         }
2583         msg->expected = expect;
2584         msg->response_to = response_to;
2585
2586         AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry);
2587         return 0;
2588 }
2589
2590 /*!
2591  * \brief Add an item to the back of the queue with data.
2592  * \param pvt a mbl_pvt structure
2593  * \param expect the msg we expect to receive
2594  * \param response_to the message that was sent to generate the expected
2595  * response
2596  * \param data data associated with this message, it will be freed when the
2597  * message is freed
2598  */
2599 static int msg_queue_push_data(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to, void *data)
2600 {
2601         struct msg_queue_entry *msg;
2602         if (!(msg = ast_calloc(1, sizeof(*msg)))) {
2603                 return -1;
2604         }
2605         msg->expected = expect;
2606         msg->response_to = response_to;
2607         msg->data = data;
2608
2609         AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry);
2610         return 0;
2611 }
2612
2613 /*!
2614  * \brief Remove an item from the front of the queue.
2615  * \param pvt a mbl_pvt structure
2616  * \return a pointer to the removed item
2617  */
2618 static struct msg_queue_entry *msg_queue_pop(struct mbl_pvt *pvt)
2619 {
2620         return AST_LIST_REMOVE_HEAD(&pvt->msg_queue, entry);
2621 }
2622
2623 /*!
2624  * \brief Remove an item from the front of the queue, and free it.
2625  * \param pvt a mbl_pvt structure
2626  */
2627 static void msg_queue_free_and_pop(struct mbl_pvt *pvt)
2628 {
2629         struct msg_queue_entry *msg;
2630         if ((msg = msg_queue_pop(pvt))) {
2631                 if (msg->data)
2632                         ast_free(msg->data);
2633                 ast_free(msg);
2634         }
2635 }
2636
2637 /*!
2638  * \brief Remove all itmes from the queue and free them.
2639  * \param pvt a mbl_pvt structure
2640  */
2641 static void msg_queue_flush(struct mbl_pvt *pvt)
2642 {
2643         struct msg_queue_entry *msg;
2644         while ((msg = msg_queue_head(pvt)))
2645                 msg_queue_free_and_pop(pvt);
2646 }
2647
2648 /*!
2649  * \brief Get the head of a queue.
2650  * \param pvt a mbl_pvt structure
2651  * \return a pointer to the head of the given msg queue
2652  */
2653 static struct msg_queue_entry *msg_queue_head(struct mbl_pvt *pvt)
2654 {
2655         return AST_LIST_FIRST(&pvt->msg_queue);
2656 }
2657
2658
2659
2660 /*
2661
2662         sdp helpers
2663
2664 */
2665
2666 static int sdp_search(char *addr, int profile)
2667 {
2668
2669         sdp_session_t *session = 0;
2670         bdaddr_t bdaddr;
2671         uuid_t svc_uuid;
2672         uint32_t range = 0x0000ffff;
2673         sdp_list_t *response_list, *search_list, *attrid_list;
2674         int status, port;
2675         sdp_list_t *proto_list;
2676         sdp_record_t *sdprec;
2677
2678         str2ba(addr, &bdaddr);
2679         port = 0;
2680         session = sdp_connect(BDADDR_ANY, &bdaddr, SDP_RETRY_IF_BUSY);
2681         if (!session) {
2682                 ast_debug(1, "sdp_connect() failed on device %s.\n", addr);
2683                 return 0;
2684         }
2685
2686         sdp_uuid32_create(&svc_uuid, profile);
2687         search_list = sdp_list_append(0, &svc_uuid);
2688         attrid_list = sdp_list_append(0, &range);
2689         response_list = 0x00;
2690         status = sdp_service_search_attr_req(session, search_list, SDP_ATTR_REQ_RANGE, attrid_list, &response_list);
2691         if (status == 0) {
2692                 if (response_list) {
2693                         sdprec = (sdp_record_t *) response_list->data;
2694                         proto_list = 0x00;
2695                         if (sdp_get_access_protos(sdprec, &proto_list) == 0) {
2696                                 port = sdp_get_proto_port(proto_list, RFCOMM_UUID);
2697                                 sdp_list_free(proto_list, 0);
2698                         }
2699                         sdp_record_free(sdprec);
2700                         sdp_list_free(response_list, 0);
2701                 } else
2702                         ast_debug(1, "No responses returned for device %s.\n", addr);
2703         } else
2704                 ast_debug(1, "sdp_service_search_attr_req() failed on device %s.\n", addr);
2705
2706         sdp_list_free(search_list, 0);
2707         sdp_list_free(attrid_list, 0);
2708         sdp_close(session);
2709
2710         return port;
2711
2712 }
2713
2714 static sdp_session_t *sdp_register(void)
2715 {
2716
2717         uint32_t service_uuid_int[] = {0, 0, 0, GENERIC_AUDIO_SVCLASS_ID};
2718         uint8_t rfcomm_channel = 1;
2719         const char *service_name = "Asterisk PABX";
2720         const char *service_dsc = "Asterisk PABX";
2721         const char *service_prov = "Asterisk";
2722
2723         uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid, svc_class1_uuid, svc_class2_uuid;
2724         sdp_list_t  *l2cap_list = 0, *rfcomm_list = 0, *root_list = 0, *proto_list = 0, *access_proto_list = 0, *svc_uuid_list = 0;
2725         sdp_data_t *channel = 0;
2726
2727         int err = 0;
2728         sdp_session_t *session = 0;
2729
2730         sdp_record_t *record = sdp_record_alloc();
2731
2732         sdp_uuid128_create(&svc_uuid, &service_uuid_int);
2733         sdp_set_service_id(record, svc_uuid);
2734
2735         sdp_uuid32_create(&svc_class1_uuid, GENERIC_AUDIO_SVCLASS_ID);
2736         sdp_uuid32_create(&svc_class2_uuid, HEADSET_PROFILE_ID);
2737
2738         svc_uuid_list = sdp_list_append(0, &svc_class1_uuid);
2739         svc_uuid_list = sdp_list_append(svc_uuid_list, &svc_class2_uuid);
2740         sdp_set_service_classes(record, svc_uuid_list);
2741
2742         sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
2743         root_list = sdp_list_append(0, &root_uuid);
2744         sdp_set_browse_groups( record, root_list );
2745
2746         sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
2747         l2cap_list = sdp_list_append(0, &l2cap_uuid);
2748         proto_list = sdp_list_append(0, l2cap_list);
2749
2750         sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
2751         channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel);
2752         rfcomm_list = sdp_list_append(0, &rfcomm_uuid);
2753         sdp_list_append(rfcomm_list, channel);
2754         sdp_list_append(proto_list, rfcomm_list);
2755
2756         access_proto_list = sdp_list_append(0, proto_list);
2757         sdp_set_access_protos(record, access_proto_list);
2758
2759         sdp_set_info_attr(record, service_name, service_prov, service_dsc);
2760
2761         if (!(session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY)))
2762                 ast_log(LOG_WARNING, "Failed to connect sdp and create session.\n");
2763         else
2764                 err = sdp_record_register(session, record, 0);
2765
2766         sdp_data_free(channel);
2767         sdp_list_free(rfcomm_list, 0);
2768         sdp_list_free(root_list, 0);
2769         sdp_list_free(access_proto_list, 0);
2770         sdp_list_free(svc_uuid_list, 0);
2771
2772         return session;
2773
2774 }
2775
2776 /*
2777
2778         Thread routines
2779
2780 */
2781
2782 /*!
2783  * \brief Handle the BRSF response.
2784  * \param pvt a mbl_pvt structure
2785  * \param buf a null terminated buffer containing an AT message
2786  * \retval 0 success
2787  * \retval -1 error
2788  */
2789 static int handle_response_brsf(struct mbl_pvt *pvt, char *buf)
2790 {
2791         struct msg_queue_entry *entry;
2792         if ((entry = msg_queue_head(pvt)) && entry->expected == AT_BRSF) {
2793                 if (hfp_parse_brsf(pvt->hfp, buf)) {
2794                         ast_debug(1, "[%s] error parsing BRSF\n", pvt->id);
2795                         goto e_return;
2796                 }
2797
2798                 if (msg_queue_push(pvt, AT_OK, AT_BRSF)) {
2799                         ast_debug(1, "[%s] error handling BRSF\n", pvt->id);
2800                         goto e_return;
2801                 }
2802
2803                 msg_queue_free_and_pop(pvt);
2804         } else if (entry) {
2805                 ast_debug(1, "[%s] received unexpected AT message 'BRSF' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
2806         } else {
2807                 ast_debug(1, "[%s] received unexpected AT message 'BRSF'\n", pvt->id);
2808         }
2809
2810         return 0;
2811
2812 e_return:
2813         msg_queue_free_and_pop(pvt);
2814         return -1;
2815 }
2816
2817 /*!
2818  * \brief Handle the CIND response.
2819  * \param pvt a mbl_pvt structure
2820  * \param buf a null terminated buffer containing an AT message
2821  * \retval 0 success
2822  * \retval -1 error
2823  */
2824 static int handle_response_cind(struct mbl_pvt *pvt, char *buf)
2825 {
2826         struct msg_queue_entry *entry;
2827         if ((entry = msg_queue_head(pvt)) && entry->expected == AT_CIND) {
2828                 switch (entry->response_to) {
2829                 case AT_CIND_TEST:
2830                         if (hfp_parse_cind_test(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND_TEST)) {
2831                                 ast_debug(1, "[%s] error performing CIND test\n", pvt->id);
2832                                 goto e_return;
2833                         }
2834                         break;
2835                 case AT_CIND:
2836                         if (hfp_parse_cind(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND)) {
2837                                 ast_debug(1, "[%s] error getting CIND state\n", pvt->id);
2838                                 goto e_return;
2839                         }
2840                         break;
2841                 default:
2842                         ast_debug(1, "[%s] error getting CIND state\n", pvt->id);
2843                         goto e_return;
2844                 }
2845                 msg_queue_free_and_pop(pvt);
2846         } else if (entry) {
2847                 ast_debug(1, "[%s] received unexpected AT message 'CIND' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
2848         } else {
2849                 ast_debug(1, "[%s] received unexpected AT message 'CIND'\n", pvt->id);
2850         }
2851
2852         return 0;
2853
2854 e_return:
2855         msg_queue_free_and_pop(pvt);
2856         return -1;
2857 }
2858
2859 /*!
2860  * \brief Handle OK AT messages.
2861  * \param pvt a mbl_pvt structure
2862  * \param buf a null terminated buffer containing an AT message
2863  * \retval 0 success
2864  * \retval -1 error
2865  */
2866 static int handle_response_ok(struct mbl_pvt *pvt, char *buf)
2867 {
2868         struct msg_queue_entry *entry;
2869         if ((entry = msg_queue_head(pvt)) && entry->expected == AT_OK) {
2870                 switch (entry->response_to) {
2871
2872                 /* initialization stuff */
2873                 case AT_BRSF:
2874                         ast_debug(1, "[%s] BSRF sent successfully\n", pvt->id);
2875
2876                         /* If this is a blackberry do CMER now, otherwise
2877                          * continue with CIND as normal. */
2878                         if (pvt->blackberry) {
2879                                 if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) {
2880                                         ast_debug(1, "[%s] error sending CMER\n", pvt->id);
2881                                         goto e_return;
2882                                 }
2883                         } else {
2884                                 if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) {
2885                                         ast_debug(1, "[%s] error sending CIND test\n", pvt->id);
2886                                         goto e_return;
2887                                 }
2888                         }
2889                         break;
2890                 case AT_CIND_TEST:
2891                         ast_debug(1, "[%s] CIND test sent successfully\n", pvt->id);
2892
2893                         ast_debug(2, "[%s] call: %d\n", pvt->id, pvt->hfp->cind_map.call);
2894                         ast_debug(2, "[%s] callsetup: %d\n", pvt->id, pvt->hfp->cind_map.callsetup);
2895
2896                         if (hfp_send_cind(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND)) {
2897                                 ast_debug(1, "[%s] error requesting CIND state\n", pvt->id);
2898                                 goto e_return;
2899                         }
2900                         break;
2901                 case AT_CIND:
2902                         ast_debug(1, "[%s] CIND sent successfully\n", pvt->id);
2903
2904                         /* check if a call is active */
2905                         if (pvt->hfp->cind_state[pvt->hfp->cind_map.call]) {
2906                                 ast_verb(3, "Bluetooth Device %s has a call in progress - delaying connection.\n", pvt->id);
2907                                 goto e_return;
2908                         }
2909
2910                         /* If this is NOT a blackberry proceed with CMER,
2911                          * otherwise send CLIP. */
2912                         if (!pvt->blackberry) {
2913                                 if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) {
2914                                         ast_debug(1, "[%s] error sending CMER\n", pvt->id);
2915                                         goto e_return;
2916                                 }
2917                         } else {
2918                                 if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) {
2919                                         ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id);
2920                                         goto e_return;
2921                                 }
2922                         }
2923                         break;
2924                 case AT_CMER:
2925                         ast_debug(1, "[%s] CMER sent successfully\n", pvt->id);
2926
2927                         /* If this is a blackberry proceed with the CIND test,
2928                          * otherwise send CLIP. */
2929                         if (pvt->blackberry) {
2930                                 if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) {
2931                                         ast_debug(1, "[%s] error sending CIND test\n", pvt->id);
2932                                         goto e_return;
2933                                 }
2934                         } else {
2935                                 if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) {
2936                                         ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id);
2937                                         goto e_return;
2938                                 }
2939                         }
2940                         break;
2941                 case AT_CLIP:
2942                         ast_debug(1, "[%s] caling line indication enabled\n", pvt->id);
2943                         if (hfp_send_vgs(pvt->hfp, 15) || msg_queue_push(pvt, AT_OK, AT_VGS)) {
2944                                 ast_debug(1, "[%s] error synchronizing gain settings\n", pvt->id);
2945                                 goto e_return;
2946                         }
2947
2948                         pvt->timeout = -1;
2949                         pvt->hfp->initialized = 1;
2950                         ast_verb(3, "Bluetooth Device %s initialized and ready.\n", pvt->id);
2951
2952                         break;
2953                 case AT_VGS:
2954                         ast_debug(1, "[%s] volume level synchronization successful\n", pvt->id);
2955
2956                         /* set the SMS operating mode to text mode */
2957                         if (hfp_send_cmgf(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMGF)) {
2958                                 ast_debug(1, "[%s] error setting CMGF\n", pvt->id);
2959                                 goto e_return;
2960                         }
2961                         break;
2962                 case AT_CMGF:
2963                         ast_debug(1, "[%s] sms text mode enabled\n", pvt->id);
2964                         /* turn on SMS new message indication */
2965                         if (hfp_send_cnmi(pvt->hfp) || msg_queue_push(pvt, AT_OK, AT_CNMI)) {
2966                                 ast_debug(1, "[%s] error setting CNMI\n", pvt->id);
2967                                 goto e_return;
2968                         }
2969                         break;
2970                 case AT_CNMI:
2971                         ast_debug(1, "[%s] sms new message indication enabled\n", pvt->id);
2972                         pvt->has_sms = 1;
2973                         break;
2974                 /* end initialization stuff */
2975
2976                 case AT_A:
2977                         ast_debug(1, "[%s] answer sent successfully\n", pvt->id);
2978                         pvt->needchup = 1;
2979                         break;
2980                 case AT_D:
2981                         ast_debug(1, "[%s] dial sent successfully\n", pvt->id);
2982                         pvt->needchup = 1;
2983                         pvt->outgoing = 1;
2984                         mbl_queue_control(pvt, AST_CONTROL_PROGRESS);
2985                         break;
2986                 case AT_CHUP:
2987                         ast_debug(1, "[%s] successful hangup\n", pvt->id);
2988                         break;
2989                 case AT_CMGR:
2990                         ast_debug(1, "[%s] successfully read sms message\n", pvt->id);
2991                         pvt->incoming_sms = 0;
2992                         break;
2993                 case AT_CMGS:
2994                         ast_debug(1, "[%s] successfully sent sms message\n", pvt->id);
2995                         pvt->outgoing_sms = 0;
2996                         break;
2997                 case AT_VTS:
2998                         ast_debug(1, "[%s] digit sent successfully\n", pvt->id);
2999                         break;
3000                 case AT_UNKNOWN:
3001                 default:
3002                         ast_debug(1, "[%s] received OK for unhandled request: %s\n", pvt->id, at_msg2str(entry->response_to));
3003                         break;
3004                 }
3005                 msg_queue_free_and_pop(pvt);
3006         } else if (entry) {
3007                 ast_debug(1, "[%s] received AT message 'OK' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
3008         } else {
3009                 ast_debug(1, "[%s] received unexpected AT message 'OK'\n", pvt->id);
3010         }
3011         return 0;
3012
3013 e_return:
3014         msg_queue_free_and_pop(pvt);
3015         return -1;
3016 }
3017
3018 /*!
3019  * \brief Handle ERROR AT messages.
3020  * \param pvt a mbl_pvt structure
3021  * \param buf a null terminated buffer containing an AT message
3022  * \retval 0 success
3023  * \retval -1 error
3024  */
3025 static int handle_response_error(struct mbl_pvt *pvt, char *buf)
3026 {
3027         struct msg_queue_entry *entry;
3028         if ((entry = msg_queue_head(pvt))
3029                         && (entry->expected == AT_OK
3030                         || entry->expected == AT_ERROR
3031                         || entry->expected == AT_CMS_ERROR
3032                         || entry->expected == AT_CMGR
3033                         || entry->expected == AT_SMS_PROMPT)) {
3034                 switch (entry->response_to) {
3035
3036                 /* initialization stuff */
3037                 case AT_BRSF:
3038                         ast_debug(1, "[%s] error reading BSRF\n", pvt->id);
3039                         goto e_return;
3040                 case AT_CIND_TEST:
3041                         ast_debug(1, "[%s] error during CIND test\n", pvt->id);
3042                         goto e_return;
3043                 case AT_CIND:
3044                         ast_debug(1, "[%s] error requesting CIND state\n", pvt->id);
3045                         goto e_return;
3046                 case AT_CMER:
3047                         ast_debug(1, "[%s] error during CMER request\n", pvt->id);
3048                         goto e_return;
3049                 case AT_CLIP:
3050                         ast_debug(1, "[%s] error enabling calling line indication\n", pvt->id);
3051                         goto e_return;
3052                 case AT_VGS:
3053                         ast_debug(1, "[%s] volume level synchronization failed\n", pvt->id);
3054
3055                         /* this is not a fatal error, let's continue with initialization */
3056
3057                         /* set the SMS operating mode to text mode */
3058                         if (hfp_send_cmgf(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMGF)) {
3059                                 ast_debug(1, "[%s] error setting CMGF\n", pvt->id);
3060                                 goto e_return;
3061                         }
3062                         break;
3063                 case AT_CMGF:
3064                         ast_debug(1, "[%s] error setting CMGF\n", pvt->id);
3065                         ast_debug(1, "[%s] no SMS support\n", pvt->id);
3066                         break;
3067                 case AT_CNMI:
3068                         ast_debug(1, "[%s] error setting CNMI\n", pvt->id);
3069                         ast_debug(1, "[%s] no SMS support\n", pvt->id);
3070                         break;
3071                 /* end initialization stuff */
3072
3073                 case AT_A:
3074                         ast_debug(1, "[%s] answer failed\n", pvt->id);
3075                         mbl_queue_hangup(pvt);
3076                         break;
3077                 case AT_D:
3078                         ast_debug(1, "[%s] dial failed\n", pvt->id);
3079                         pvt->needchup = 0;
3080                         mbl_queue_control(pvt, AST_CONTROL_CONGESTION);
3081                         break;
3082                 case AT_CHUP:
3083                         ast_debug(1, "[%s] error sending hangup, disconnecting\n", pvt->id);
3084                         goto e_return;
3085                 case AT_CMGR:
3086                         ast_debug(1, "[%s] error reading sms message\n", pvt->id);
3087                         pvt->incoming_sms = 0;
3088                         break;
3089                 case AT_CMGS:
3090                         ast_debug(1, "[%s] error sending sms message\n", pvt->id);
3091                         pvt->outgoing_sms = 0;
3092                         break;
3093                 case AT_VTS:
3094                         ast_debug(1, "[%s] error sending digit\n", pvt->id);
3095                         break;
3096                 case AT_UNKNOWN:
3097                 default:
3098                         ast_debug(1, "[%s] received ERROR for unhandled request: %s\n", pvt->id, at_msg2str(entry->response_to));
3099                         break;
3100                 }
3101                 msg_queue_free_and_pop(pvt);
3102         } else if (entry) {
3103                 ast_debug(1, "[%s] received AT message 'ERROR' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected));
3104         } else {
3105                 ast_debug(1, "[%s] received unexpected AT message 'ERROR'\n", pvt->id);
3106         }
3107
3108         return 0;
3109
3110 e_return:
3111         msg_queue_free_and_pop(pvt);
3112         return -1;
3113 }
3114
3115 /*!
3116  * \brief Handle AT+CIEV messages.
3117  * \param pvt a mbl_pvt structure
3118  * \param buf a null terminated buffer containing an AT message
3119  * \retval 0 success
3120  * \retval -1 error
3121  */
3122 static int handle_response_ciev(struct mbl_pvt *pvt, char *buf)
3123 {
3124         int i;
3125         switch (hfp_parse_ciev(pvt->hfp, buf, &i)) {
3126         case HFP_CIND_CALL:
3127                 switch (i) {
3128                 case HFP_CIND_CALL_NONE:
3129                         ast_debug(1, "[%s] line disconnected\n", pvt->id);
3130                         if (pvt->owner) {
3131                                 ast_debug(1, "[%s] hanging up owner\n", pvt->id);
3132                                 if (mbl_queue_hangup(pvt)) {
3133                                         ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnectiong...\n", pvt->id);
3134                                         return -1;
3135                                 }
3136                         }
3137                         pvt->needchup = 0;
3138                         pvt->needcallerid = 0;
3139                         pvt->incoming = 0;
3140                         pvt->outgoing = 0;
3141                         break;
3142                 case HFP_CIND_CALL_ACTIVE:
3143                         if (pvt->outgoing) {
3144                                 ast_debug(1, "[%s] remote end answered\n", pvt->id);
3145                                 mbl_queue_control(pvt, AST_CONTROL_ANSWER);
3146                         } else if (pvt->incoming && pvt->answered) {
3147                                 ast_setstate(pvt->owner, AST_STATE_UP);
3148                         } else if (pvt->incoming) {
3149                                 /* user answered from handset, disconnecting */
3150                                 ast_verb(3, "[%s] user answered bluetooth device from handset, disconnecting\n", pvt->id);
3151                                 mbl_queue_hangup(pvt);
3152                                 return -1;
3153                         }
3154                         break;
3155                 }
3156                 break;
3157
3158         case HFP_CIND_CALLSETUP:
3159                 switch (i) {
3160                 case HFP_CIND_CALLSETUP_NONE:
3161                         if (pvt->hfp->cind_state[pvt->hfp->cind_map.call] != HFP_CIND_CALL_ACTIVE) {
3162                                 if (pvt->owner) {
3163                                         if (mbl_queue_hangup(pvt)) {
3164                                                 ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnectiong...\n", pvt->id);
3165                                                 return -1;
3166                                         }
3167                                 }
3168                                 pvt->needchup = 0;
3169                                 pvt->needcallerid = 0;
3170                                 pvt->incoming = 0;
3171                                 pvt->outgoing = 0;
3172                         }
3173                         break;
3174                 case HFP_CIND_CALLSETUP_INCOMING:
3175                         ast_debug(1, "[%s] incoming call, waiting for caller id\n", pvt->id);
3176                         pvt->needcallerid = 1;
3177                         pvt->incoming = 1;
3178                         break;
3179                 case HFP_CIND_CALLSETUP_OUTGOING:
3180                         if (pvt->outgoing) {
3181                                 ast_debug(1, "[%s] outgoing call\n", pvt->id);
3182                         } else {
3183                                 ast_verb(3, "[%s] user dialed from handset, disconnecting\n", pvt->id);
3184                                 return -1;
3185                         }
3186                         break;
3187                 case HFP_CIND_CALLSETUP_ALERTING:
3188                         if (pvt->outgoing) {
3189                                 ast_debug(1, "[%s] remote alerting\n", pvt->id);
3190                                 mbl_queue_control(pvt, AST_CONTROL_RINGING);
3191                         }
3192                         break;
3193                 }
3194                 break;
3195         case HFP_CIND_NONE:
3196                 ast_debug(1, "[%s] error parsing CIND: %s\n", pvt->id, buf);
3197                 break;
3198         }
3199         return 0;
3200 }
3201
3202 /*!
3203  * \brief Handle AT+CLIP messages.
3204  * \param pvt a mbl_pvt structure
3205  * \param buf a null terminated buffer containing an AT message
3206  * \retval 0 success
3207  * \retval -1 error
3208  */
3209 static int handle_response_clip(struct mbl_pvt *pvt, char *buf)
3210 {
3211         char *clip;
3212         struct msg_queue_entry *msg;
3213         struct ast_channel *chan;
3214
3215         if ((msg = msg_queue_head(pvt)) && msg->expected == AT_CLIP) {
3216                 msg_queue_free_and_pop(pvt);
3217
3218                 pvt->needcallerid = 0;
3219                 if (!(clip = hfp_parse_clip(pvt->hfp, buf))) {
3220                         ast_debug(1, "[%s] error parsing CLIP: %s\n", pvt->id, buf);
3221                 }
3222
3223                 if (!(chan = mbl_new(AST_STATE_RING, pvt, clip, NULL))) {
3224                         ast_log(LOG_ERROR, "[%s] unable to allocate channel for incoming call\n", pvt->id);
3225                         hfp_send_chup(pvt->hfp);
3226                         msg_queue_push(pvt, AT_OK, AT_CHUP);
3227                         return -1;
3228                 }
3229
3230                 /* from this point on, we need to send a chup in the event of a
3231                  * hangup */
3232                 pvt->needchup = 1;
3233
3234                 if (ast_pbx_start(chan)) {
3235                         ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming call\n", pvt->id);
3236                         mbl_ast_hangup(pvt);
3237                         return -1;
3238                 }
3239         }
3240
3241         return 0;
3242 }
3243
3244 /*!
3245  * \brief Handle RING messages.
3246  * \param pvt a mbl_pvt structure
3247  * \param buf a null terminated buffer containing an AT message
3248  * \retval 0 success
3249  * \retval -1 error
3250  */
3251 static int handle_response_ring(struct mbl_pvt *pvt, char *buf)
3252 {
3253         if (pvt->needcallerid) {
3254                 ast_debug(1, "[%s] got ring while waiting for caller id\n", pvt->id);
3255                 return msg_queue_push(pvt, AT_CLIP, AT_UNKNOWN);
3256         } else {
3257                 return 0;
3258         }
3259 }
3260
3261 /*!
3262  * \brief Handle AT+CMTI messages.
3263  * \param pvt a mbl_pvt structure
3264  * \param buf a null terminated buffer containing an AT message
3265  * \retval 0 success
3266  * \retval -1 error
3267  */
3268 static int handle_response_cmti(struct mbl_pvt *pvt, char *buf)
3269 {
3270         int index = hfp_parse_cmti(pvt->hfp, buf);
3271         if (index > 0) {
3272                 ast_debug(1, "[%s] incoming sms message\n", pvt->id);
3273
3274                 if (hfp_send_cmgr(pvt->hfp, index)
3275                                 || msg_queue_push(pvt, AT_CMGR, AT_CMGR)) {
3276                         ast_debug(1, "[%s] error sending CMGR to retrieve SMS message\n", pvt->id);
3277                         return -1;
3278                 }
3279
3280                 pvt->incoming_sms = 1;
3281                 return 0;
3282         } else {
3283                 ast_debug(1, "[%s] error parsing incoming sms message alert, disconnecting\n", pvt->id);
3284                 return -1;
3285         }
3286 }
3287
3288 /*!
3289  * \brief Handle AT+CMGR messages.
3290  * \param pvt a mbl_pvt structure
3291  * \param buf a null terminated buffer containing an AT message
3292  * \retval 0 success
3293  * \retval -1 error
3294  */
3295 static int handle_response_cmgr(struct mbl_pvt *pvt, char *buf)
3296 {
3297         char *from_number = NULL, *text = NULL;
3298         struct ast_channel *chan;
3299         struct msg_queue_entry *msg;
3300
3301         if ((msg = msg_queue_head(pvt)) && msg->expected == AT_CMGR) {
3302                 msg_queue_free_and_pop(pvt);
3303
3304                 if (hfp_parse_cmgr(pvt->hfp, buf, &from_number, &text)
3305                                 || msg_queue_push(pvt, AT_OK, AT_CMGR)) {
3306
3307                         ast_debug(1, "[%s] error parsing sms message, disconnecting\n", pvt->id);
3308                         return -1;
3309                 }
3310
3311                 /* XXX this channel probably does not need to be associated with this pvt */
3312                 if (!(chan = mbl_new(AST_STATE_DOWN, pvt, NULL, NULL))) {
3313                         ast_debug(1, "[%s] error creating sms message channel, disconnecting\n", pvt->id);
3314                         return -1;
3315                 }
3316
3317                 strcpy(chan->exten, "sms");
3318                 pbx_builtin_setvar_helper(chan, "SMSSRC", from_number);
3319