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