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