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