openwrt/package/asterisk/patches/asterisk-1.0.9-chan_bluetooth.patch

   1 diff -ruN asterisk-1.0.9-old/channels/Makefile asterisk-1.0.9-new/channels/Makefile
   2 --- asterisk-1.0.9-old/channels/Makefile        2005-08-22 20:42:22.000000000 +0200
   3 +++ asterisk-1.0.9-new/channels/Makefile        2005-08-22 21:12:14.000000000 +0200
   4 @@ -202,6 +202,13 @@
   5  chan_h323.so: chan_h323.o h323/libchanh323.a
   6         $(CC) $(SOLINK) -o $@ $< h323/libchanh323.a $(CHANH323LIB) -L$(PWLIBDIR)/lib $(PTLIB) -L$(OPENH323DIR)/lib $(H323LIB) -L/usr/lib -lcrypto -lssl -lexpat
   7
   8 +#
   9 +# Asterisk Bluetooth Support
  10 +# http://www.crazygreek.co.uk/content/chan_bluetooth
  11 +#
  12 +chan_bluetooth.so: chan_bluetooth.o
  13 +       $(CC) $(SOLINK) -o $@ $< $(EXTRA_LDFLAGS) -lbluetooth
  14 +
  15
  16  #chan_modem.so : chan_modem.o
  17  #      $(CC) -rdynamic -shared -Xlinker -x -o $@ $<
  18 diff -ruN asterisk-1.0.9-old/channels/chan_bluetooth.c asterisk-1.0.9-new/channels/chan_bluetooth.c
  19 --- asterisk-1.0.9-old/channels/chan_bluetooth.c        1970-01-01 01:00:00.000000000 +0100
  20 +++ asterisk-1.0.9-new/channels/chan_bluetooth.c        2005-09-06 22:51:30.000000000 +0200
  21 @@ -0,0 +1,3598 @@
  22 +/*
  23 + * Asterisk -- A telephony toolkit for Linux.
  24 + *
  25 + * Asterisk Bluetooth Channel
  26 + *
  27 + * Author: Theo Zourzouvillys <theo@adaptive-it.co.uk>
  28 + *
  29 + * Adaptive Linux Solutions <http://www.adaptive-it.co.uk>
  30 + *
  31 + * Copyright (C) 2004 Adaptive Linux Solutions
  32 + *
  33 + * This program is free software, distributed under the terms of
  34 + * the GNU General Public License
  35 + *
  36 + * ******************* NOTE NOTE NOTE NOTE NOTE *********************
  37 + *
  38 + * This code is not at all tested, and only been developed with a
  39 + * HBH-200 headset and a Nokia 6310i right now.
  40 + *
  41 + * Expect it to crash, dial random numbers, and steal all your money.
  42 + *
  43 + * PLEASE try any headsets and phones, and let me know the results,
  44 + * working or not, along with all debug output!
  45 + *
  46 + * ------------------------------------------------------------------
  47 + *
  48 + * Asterisk Bluetooth Support
  49 + *
  50 + * Well, here we go - Attempt to provide Handsfree profile support in
  51 + * both AG and HF modes, AG (AudioGateway) mode support for using
  52 + * headsets, and HF (Handsfree) mode for utilising mobile/cell phones
  53 + *
  54 + * It would be nice to also provide Headset support at some time in
  55 + * the future, however, a working Handsfree profile is nice for now,
  56 + * and as far as I can see, almost all new HS devices also support HF
  57 + *
  58 + * ------------------------------------------------------------------
  59 + * INSTRUCTIONS
  60 + *
  61 + * You need to have bluez's bluetooth stack, along with user space
  62 + * tools (>=v2.10), and running hcid and sdsp.
  63 + *
  64 + * See bluetooth.conf for configuration details.
  65 + *
  66 + * - Ensure bluetooth subsystem is up and running.  'hciconfig'
  67 + *   should show interface as UP.
  68 + *
  69 + * - If you're trying to use a headset/HS, start up asterisk, and try
  70 + *   to pair it as you normally would.
  71 + *
  72 + * - If you're trying to use a Phone/AG, just make sure bluetooth is
  73 + *   enabled on your phone, and start up asterisk.
  74 + *
  75 + * - 'bluetooth show peers' will show all bluetooth devices states.
  76 + *
  77 + * - Send a call out by using Dial(BLT/DevName/0123456).  Call a HS
  78 + *   with Dial(BLT/DevName)
  79 + *
  80 + * ------------------------------------------------------------------
  81 + * BUGS
  82 + *
  83 + * - What should happen when an AG is paired with asterisk and
  84 + *   someone uses the AG dalling a number manually?  My test phone
  85 + *   seems to try to open an SCO link.  Perhaps an extension to
  86 + *   route the call to, or maybe drop the RFCOM link all together?
  87 + *
  88 + * ------------------------------------------------------------------
  89 + * COMPATIBILITY
  90 + *
  91 + * PLEASE email <theo@adaptive-it.co.uk> with the results of ANY
  92 + * device not listed in here (working or not), or if the device is
  93 + * listed and it doesn't work!  Please also email full debug output
  94 + * for any device not working correctly or generating errors in log.
  95 + *
  96 + * HandsFree Profile:
  97 + *
  98 + *  HS (HeadSet):
  99 + *   - Ericsson HBH-200
 100 + *
 101 + *  AG (AudioGateway):
 102 + *   - Nokia 6310i
 103 + *
 104 + * ------------------------------------------------------------------
 105 + *
 106 + * Questions, bugs, or (preferably) patches to:
 107 + *
 108 + *  <theo@adaptive-it.co.uk>
 109 + *
 110 + * ------------------------------------------------------------------
 111 + */
 112 +
 113 +/* ---------------------------------- */
 114 +
 115 +#include <stdio.h>
 116 +#include <string.h>
 117 +#include <asterisk/lock.h>
 118 +#include <asterisk/utils.h>
 119 +#include <asterisk/channel.h>
 120 +#include <asterisk/config.h>
 121 +#include <asterisk/logger.h>
 122 +#include <asterisk/module.h>
 123 +#include <asterisk/pbx.h>
 124 +#include <asterisk/sched.h>
 125 +#include <asterisk/options.h>
 126 +#include <asterisk/cli.h>
 127 +#include <asterisk/callerid.h>
 128 +#include <sys/socket.h>
 129 +#include <sys/signal.h>
 130 +#include <sys/time.h>
 131 +#include <errno.h>
 132 +#include <unistd.h>
 133 +#include <stdlib.h>
 134 +#include <arpa/inet.h>
 135 +#include <fcntl.h>
 136 +#include <sys/ioctl.h>
 137 +#include <ctype.h>
 138 +#include <endian.h>
 139 +
 140 +#include <bluetooth/bluetooth.h>
 141 +#include <bluetooth/hci.h>
 142 +#include <bluetooth/hci_lib.h>
 143 +#include <bluetooth/sco.h>
 144 +#include <bluetooth/rfcomm.h>
 145 +#include <bluetooth/sdp.h>
 146 +#include <bluetooth/sdp_lib.h>
 147 +
 148 +/* --- Data types and definitions --- */
 149 +
 150 +#ifndef HANDSFREE_AUDIO_GW_SVCLASS_ID
 151 +# define HANDSFREE_AUDIO_GW_SVCLASS_ID 0x111f
 152 +#endif
 153 +#define BLUETOOTH_FORMAT    AST_FORMAT_SLINEAR
 154 +#define BLT_CHAN_NAME       "BLT"
 155 +#define BLT_CONFIG_FILE     "bluetooth.conf"
 156 +#define BLT_RDBUFF_MAX      1024
 157 +#define BLT_DEFAULT_HCI_DEV 0
 158 +#define BLT_SVN_REVISION    "$Rev$"
 159 +
 160 +/* ---------------------------------- */
 161 +
 162 +typedef enum {
 163 +  BLT_ROLE_NONE = 0, // Unknown Device
 164 +  BLT_ROLE_HS = 1,   // Device is a Headset
 165 +  BLT_ROLE_AG = 2,   // Device is an Audio Gateway
 166 +  BLT_ROLE_GUI = 3   // Device is used as an GUI
 167 +} blt_role_t;
 168 +
 169 +/* State when we're in HS mode */
 170 +
 171 +typedef enum {
 172 +  BLT_STATE_WANT_R   = 0,
 173 +  BLT_STATE_WANT_N   = 1,
 174 +  BLT_STATE_WANT_CMD = 2,
 175 +  BLT_STATE_WANT_N2  = 3,
 176 +} blt_state_t;
 177 +
 178 +typedef enum {
 179 +  BLT_STATUS_DOWN,
 180 +  BLT_STATUS_CONNECTING,
 181 +  BLT_STATUS_NEGOTIATING,
 182 +  BLT_STATUS_READY,
 183 +  BLT_STATUS_RINGING,
 184 +  BLT_STATUS_IN_CALL,
 185 +} blt_status_t;
 186 +
 187 +/* ---------------------------------- */
 188 +
 189 +/* Default config settings */
 190 +
 191 +#define BLT_DEFAULT_CHANNEL_AG   5
 192 +#define BLT_DEFAULT_CHANNEL_HS   6
 193 +#define BLT_DEFAULT_CHANNEL_GUI  1
 194 +#define BLT_DEFAULT_ROLE         BLT_ROLE_HS
 195 +#define BLT_OBUF_LEN             (48 * 25)
 196 +
 197 +#define BUFLEN (4800)
 198 +
 199 +/* ---------------------------------- */
 200 +
 201 +typedef struct blt_dev blt_dev_t;
 202 +
 203 +void ag_cgmi_response(blt_dev_t * dev, char * cmd);
 204 +void ag_unknown_response(blt_dev_t * dev, char * cmd);
 205 +void ag_cgmi_valid_response(blt_dev_t * dev, char * cmd);
 206 +void ag_clip_response(blt_dev_t * dev, char * cmd);
 207 +void ag_cmer_response(blt_dev_t * dev, char * cmd);
 208 +void ag_cind_status_response(blt_dev_t * dev, char * cmd);
 209 +void ag_cind_response(blt_dev_t * dev, char * cmd);
 210 +void ag_brsf_response(blt_dev_t * dev, char * cmd);
 211 +void remove_sdp_records(void);
 212 +
 213 +void gui_easm_response(blt_dev_t * dev, char * cmd);
 214 +
 215 +int sock_err(int fd);
 216 +int parse_clip(const char * str, char *number, int number_len, char * name, int name_len, int *type);
 217 +int set_buffer(char * ring, char * data, int circular_len, int * pos, int data_len);
 218 +int get_buffer(char * dst, char * ring, int ring_size, int * head, int to_copy);
 219 +void gui_eaid_response(blt_dev_t * dev, char * cmd);
 220 +
 221 +
 222 +
 223 +struct blt_ring {
 224 +       unsigned char buf[BUFLEN];
 225 +};
 226 +// XXX:T: Tidy this lot up.
 227 +struct blt_dev {
 228 +
 229 +  blt_status_t status;              /* Device Status */
 230 +
 231 +  struct ast_channel * owner;       /* Channel we belong to, possibly NULL */
 232 +  blt_dev_t * dev;                  /* The bluetooth device channel is for */
 233 +  struct ast_frame fr;              /* Recieved frame */
 234 +
 235 +  /* SCO Handler */
 236 +  int sco_pipe[2];                   /* SCO alert pipe */
 237 +  int sco;                           /* SCO fd */
 238 +  int sco_handle;                    /* SCO Handle */
 239 +  int sco_mtu;                       /* SCO MTU */
 240 +  int sco_running;                   /* 1 when sCO thread should be running */
 241 +  pthread_t sco_thread;              /* SCO thread */
 242 +  ast_mutex_t sco_lock;              /* SCO lock */
 243 +  int sco_pos_in;                    /* Reader in position (drain)*/
 244 +  int sco_pos_inrcv;                 /* Reader in position (fill) */
 245 +       int wakeread; /* blt_read() needs to be woken */
 246 +  int sco_pos_out;                   /* Reader out position */
 247 +  int sco_sending;                   /* Sending SCO packets */
 248 +  char buf[1200];                    /* Incoming data buffer */
 249 +  int bufpos;
 250 +  char sco_buf_out[BUFLEN];          /* 24 chunks of 48 */
 251 +  char sco_buf_in[BUFLEN];           /* 24 chunks of 48 */
 252 +
 253 +  char dnid[1024];                    /* Outgoi gncall dialed number */
 254 +  unsigned char * obuf[BLT_OBUF_LEN]; /* Outgoing data buffer */
 255 +  int obuf_len;                       /* Output Buffer Position */
 256 +  int obuf_wpos;                      /* Buffer Reader */
 257 +
 258 +  // device
 259 +  int autoconnect;                  /* 1 for autoconnect */
 260 +  int outgoing_id;                  /* Outgoing connection scheduler id */
 261 +  char * name;                      /* Devices friendly name */
 262 +  blt_role_t role;                  /* Device role (HS or AG) */
 263 +  bdaddr_t bdaddr;                  /* remote address */
 264 +  int channel;                      /* remote channel */
 265 +  int rd;                           /* RFCOMM fd */
 266 +  int tmp_rd;                       /* RFCOMM fd */
 267 +  int call_cnt;                     /* Number of attempted calls */
 268 +  ast_mutex_t lock;                 /* RFCOMM socket lock */
 269 +  char rd_buff[BLT_RDBUFF_MAX];     /* RFCOMM input buffer */
 270 +  int rd_buff_pos;                  /* RFCOMM input buffer position */
 271 +  int ready;                        /* 1 When ready */
 272 +  char *context;
 273 +
 274 +  /* AG mode */
 275 +  char last_ok_cmd[BLT_RDBUFF_MAX];        /* Runtime[AG]: Last AT command that was OK */
 276 +  int cind;                                /* Runtime[AG]: Recieved +CIND */
 277 +  int call_pos, service_pos, callsetup_pos;  /* Runtime[AG]: Positions in CIND/CMER */
 278 +  int call, service, callsetup;              /* Runtime[AG]: Values */
 279 +  char cid_num[AST_MAX_EXTENSION];
 280 +  char cid_name[AST_MAX_EXTENSION];
 281 +
 282 +  /* HS mode */
 283 +  blt_state_t state;                       /* Runtime: Device state (AG mode only) */
 284 +  int ring_timer;                          /* Runtime:Ring Timer */
 285 +  char last_err_cmd[BLT_RDBUFF_MAX];       /* Runtime: Last AT command that was OK */
 286 +  void (*cb)(blt_dev_t * dev, char * str); /* Runtime: Callback when in HS mode */
 287 +
 288 +  int brsf;                                /* Runtime: Bluetooth Retrieve Supported Features */
 289 +  int bvra;                                /* Runtime: Bluetooth Voice Recognised Activation */
 290 +  int gain_speaker;                        /* Runtime: Gain Of Speaker */
 291 +  int clip;                                /* Runtime: Supports CLID */
 292 +  int colp;                                /* Runtime: Connected Line ID */
 293 +  int elip;                                /* Runtime: (Ericsson) Supports CLID */
 294 +  int eolp;                                /* Runtime: (Ericsson) Connected Line ID */
 295 +  int ringing;                             /* Runtime: Device is ringing */
 296 +
 297 +  blt_dev_t * next;                        /* Next in linked list */
 298 +
 299 +};
 300 +
 301 +typedef struct blt_atcb {
 302 +
 303 +  /* The command */
 304 +  char * str;
 305 +
 306 +  /* DTE callbacks: */
 307 +  int (*set)(blt_dev_t * dev, const char * arg, int len);
 308 +  int (*read)(blt_dev_t * dev);
 309 +  int (*execute)(blt_dev_t * dev, const char * data);
 310 +  int (*test)(blt_dev_t * dev);
 311 +
 312 +  /* DCE callbacks: */
 313 +  int (*unsolicited)(blt_dev_t * dev, const char * value);
 314 +
 315 +} blt_atcb_t;
 316 +
 317 +/* ---------------------------------- */
 318 +
 319 +static void rd_close(blt_dev_t * dev, int reconnect, int err);
 320 +static int send_atcmd(blt_dev_t * device, const char * fmt, ...);
 321 +static int sco_connect(blt_dev_t * dev);
 322 +static int sco_start(blt_dev_t * dev, int fd);
 323 +
 324 +/* ---------------------------------- */
 325 +
 326 +/* RFCOMM channel we listen on*/
 327 +static int rfcomm_channel_ag = BLT_DEFAULT_CHANNEL_AG;
 328 +static int rfcomm_channel_hs = BLT_DEFAULT_CHANNEL_HS;
 329 +static int rfcomm_channel_gui = BLT_DEFAULT_CHANNEL_GUI;
 330 +
 331 +static char* gui_default_sip_number = "";
 332 +static char* gui_default_sip_address = "";
 333 +
 334 +/* Address of local bluetooth interface */
 335 +static int hcidev_id;
 336 +static bdaddr_t local_bdaddr;
 337 +
 338 +/* All the current sockets */
 339 +AST_MUTEX_DEFINE_STATIC(iface_lock);
 340 +static blt_dev_t * iface_head;
 341 +static int ifcount = 0;
 342 +
 343 +static int sdp_record_hs = -1;
 344 +static int sdp_record_ag = -1;
 345 +static int sdp_record_gui = -1;
 346 +
 347 +/* RFCOMM listen socket */
 348 +static int rfcomm_sock_ag = -1;
 349 +static int rfcomm_sock_hs = -1;
 350 +static int rfcomm_sock_gui = -1;
 351 +
 352 +static int sco_socket = -1;
 353 +
 354 +static int monitor_pid = -1;
 355 +
 356 +/* The socket monitoring thread */
 357 +static pthread_t monitor_thread = AST_PTHREADT_NULL;
 358 +AST_MUTEX_DEFINE_STATIC(monitor_lock);
 359 +
 360 +/* Count how many times this module is currently in use */
 361 +static int usecnt = 0;
 362 +AST_MUTEX_DEFINE_STATIC(usecnt_lock);
 363 +
 364 +static struct sched_context * sched = NULL;
 365 +
 366 +/* ---------------------------------- */
 367 +
 368 +#if ASTERISK_VERSION_NUM <= 010107
 369 +#include <asterisk/channel_pvt.h>
 370 +#define tech_pvt pvt->pvt
 371 +#else /* CVS. FIXME: Version number */
 372 +static struct ast_channel *blt_request(const char *type, int format, void *data, int *cause);
 373 +static int blt_hangup(struct ast_channel *c);
 374 +static int blt_answer(struct ast_channel *c);
 375 +static struct ast_frame *blt_read(struct ast_channel *chan);
 376 +static int blt_call(struct ast_channel *c, char *dest, int timeout);
 377 +static int blt_write(struct ast_channel *chan, struct ast_frame *f);
 378 +static int blt_indicate(struct ast_channel *chan, int cond);
 379 +
 380 +static const struct ast_channel_tech blt_tech = {
 381 +       .type = BLT_CHAN_NAME,
 382 +       .description = "Bluetooth Channel Driver",
 383 +       .capabilities = BLUETOOTH_FORMAT,
 384 +       .requester = blt_request,
 385 +       .hangup = blt_hangup,
 386 +       .answer = blt_answer,
 387 +       .read = blt_read,
 388 +       .call = blt_call,
 389 +       .write = blt_write,
 390 +       .indicate = blt_indicate,
 391 +};
 392 +#endif
 393 +/* ---------------------------------- */
 394 +
 395 +static const char *
 396 +role2str(blt_role_t role)
 397 +{
 398 +  switch (role) {
 399 +    case BLT_ROLE_HS:
 400 +      return "HS";
 401 +    case BLT_ROLE_AG:
 402 +      return "AG";
 403 +    case BLT_ROLE_GUI:
 404 +      return "GUI";
 405 +    case BLT_ROLE_NONE:
 406 +    default:
 407 +      return "??";
 408 +  }
 409 +}
 410 +
 411 +static const char *
 412 +status2str(blt_status_t status)
 413 +{
 414 +  switch (status) {
 415 +    case BLT_STATUS_DOWN:
 416 +      return "Down";
 417 +    case BLT_STATUS_CONNECTING:
 418 +      return "Connecting";
 419 +    case BLT_STATUS_NEGOTIATING:
 420 +      return "Negotiating";
 421 +    case BLT_STATUS_READY:
 422 +      return "Ready";
 423 +    case BLT_STATUS_RINGING:
 424 +      return "Ringing";
 425 +    case BLT_STATUS_IN_CALL:
 426 +      return "InCall";
 427 +  };
 428 +  return "Unknown";
 429 +}
 430 +
 431 +int sock_err(int fd)
 432 +{
 433 +  int ret;
 434 +  int len = sizeof(ret);
 435 +  getsockopt(fd, SOL_SOCKET, SO_ERROR, &ret, &len);
 436 +  return ret;
 437 +}
 438 +
 439 +/* ---------------------------------- */
 440 +int parse_clip(const char * str, char *number, int number_len, char * name, int name_len, int *type)
 441 +{
 442 +  const char *c = str;
 443 +  const char *start;
 444 +  int length;
 445 +  char typestr[256];
 446 +
 447 +  memset(number, 0, number_len);
 448 +  memset(name, 0, name_len);
 449 +  *type = 0;
 450 +
 451 +  number[0] = '\0';
 452 +  name[0] = '\0';
 453 +  while(*c && *c != '"')
 454 +    c++;
 455 +  c++;
 456 +  start = c;
 457 +  while(*c && *c != '"')
 458 +    c++;
 459 +  length = c - start < number_len ? c - start : number_len;
 460 +  strncpy(number, start, length);
 461 +  number[length] = '\0';
 462 +  c++;
 463 +  while(*c && *c != ',')
 464 +    c++;
 465 +  c++;
 466 +  start = c;
 467 +  while(*c && *c != ',')
 468 +    c++;
 469 +  length = c - start < number_len ? c - start : number_len;
 470 +  strncpy(typestr, start, length);
 471 +  typestr[length] = '\0';
 472 +  *type = atoi(typestr);
 473 +  c++;
 474 +  while(*c && *c != ',')
 475 +    c++;
 476 +  c++;
 477 +  while(*c && *c != ',')
 478 +    c++;
 479 +  c++;
 480 +  while(*c && *c != '"')
 481 +    c++;
 482 +  c++;
 483 +  start = c;
 484 +  while(*c && *c != '"')
 485 +    c++;
 486 +  length = c - start < number_len ? c - start : number_len;
 487 +  strncpy(name, start, length);
 488 +  name[length] = '\0';
 489 +
 490 +  return(1);
 491 +}
 492 +
 493 +
 494 +static const char *
 495 +parse_cind(const char * str, char * name, int name_len)
 496 +{
 497 +  int c = 0;
 498 +
 499 +  memset(name, 0, name_len);
 500 +
 501 +  while (*str) {
 502 +    if (*str == '(') {
 503 +      if (++c == 1 && *(str+1) == '"') {
 504 +        const char * start = str + 2;
 505 +        int len = 0;
 506 +        str += 2;
 507 +        while (*str && *str != '"') {
 508 +          len++;
 509 +          str++;
 510 +        }
 511 +        if (len == 0)
 512 +          return NULL;
 513 +        strncpy(name, start, (len > name_len) ? name_len : len);
 514 +      }
 515 +    } else if (*str == ')')
 516 +      c--;
 517 +    else if (c == 0 && *str == ',')
 518 +      return str + 1;
 519 +    str++;
 520 +  }
 521 +  return NULL;
 522 +}
 523 +
 524 +static void
 525 +set_cind(blt_dev_t * dev, int indicator, int val)
 526 +{
 527 +
 528 +  ast_log(LOG_DEBUG, "CIND %d set to %d\n", indicator, val);
 529 +
 530 +  if (indicator == dev->callsetup_pos) {
 531 +
 532 +    // call progress
 533 +
 534 +    dev->callsetup = val;
 535 +
 536 +    switch (val) {
 537 +      case 3:
 538 +        // Outgoing ringing
 539 +        if ((dev->owner && dev->role == BLT_ROLE_AG) ||
 540 +           (dev->owner && dev->role == BLT_ROLE_GUI))
 541 +          ast_queue_control(dev->owner, AST_CONTROL_RINGING);
 542 +        break;
 543 +      case 2:
 544 +        break;
 545 +      case 1:
 546 +        break;
 547 +      case 0:
 548 +        if ((dev->owner && dev->role == BLT_ROLE_AG && dev->call == 0) ||
 549 +           (dev->owner && dev->role == BLT_ROLE_AG && dev->call == 0))
 550 +          ast_queue_control(dev->owner, AST_CONTROL_CONGESTION);
 551 +        break;
 552 +    }
 553 +
 554 +  } else if (indicator == dev->service_pos) {
 555 +
 556 +    // Signal
 557 +
 558 +    if (val == 0)
 559 +      ast_log(LOG_NOTICE, "Audio Gateway %s lost signal\n", dev->name);
 560 +    else if (dev->service == 0 && val > 0)
 561 +      ast_log(LOG_NOTICE, "Audio Gateway %s got signal\n", dev->name);
 562 +
 563 +    dev->service = val;
 564 +
 565 +  } else if (indicator == dev->call_pos) {
 566 +
 567 +    // Call
 568 +
 569 +    dev->call = val;
 570 +
 571 +    if (dev->owner) {
 572 +      if (val == 1) {
 573 +       sco_start(dev, -1);
 574 +        ast_queue_control(dev->owner, AST_CONTROL_ANSWER);
 575 +      } else if (val == 0)
 576 +        ast_queue_control(dev->owner, AST_CONTROL_HANGUP);
 577 +    }
 578 +
 579 +  }
 580 +
 581 +
 582 +}
 583 +
 584 +/* ---------------------------------- */
 585 +
 586 +int
 587 +set_buffer(char * ring, char * data, int circular_len, int * pos, int data_len)
 588 +{
 589 +  int start_pos = *(pos);
 590 +  int done = 0;
 591 +  int copy;
 592 +
 593 +  while (data_len) {
 594 +    // Set can_do to the most we can do in this copy.
 595 +
 596 +    copy = MIN(circular_len - start_pos, data_len);
 597 +    memcpy(ring + start_pos, data + done, copy);
 598 +    done += copy;
 599 +    start_pos += copy;
 600 +    data_len -= copy;
 601 +
 602 +    if (start_pos == circular_len) {
 603 +      start_pos = 0;
 604 +    }
 605 +  }
 606 +  *(pos) = start_pos;
 607 +  return 0;
 608 +}
 609 +
 610 +int
 611 +get_buffer(char * dst, char * ring, int ring_size, int * head, int to_copy)
 612 +{
 613 +  int copy;
 614 +
 615 +  // |1|2|3|4|5|6|7|8|9|
 616 +  //      |-----|
 617 +
 618 +  while (to_copy) {
 619 +
 620 +    // Set can_do to the most we can do in this copy.
 621 +    copy = MIN(ring_size - *head, to_copy);
 622 +
 623 +    // ast_log(LOG_DEBUG, "Getting: %d bytes, From pos %d\n", copy, *head);
 624 +#if __BYTE_ORDER == __LITTLE_ENDIAN
 625 +    memcpy(dst, ring + *head, copy);
 626 +#else
 627 +    //    memcpy(dst, ring + *head, copy);
 628 +    ast_swapcopy_samples(dst, ring+*head, copy/2);
 629 +#endif
 630 +    memset(ring+*head, 0, copy);
 631 +    dst += copy;
 632 +    *head += copy;
 633 +    to_copy -= copy;
 634 +
 635 +    if (*head == ring_size ) {
 636 +           *head = 0;
 637 +    }
 638 +
 639 +  }
 640 +
 641 +  return 0;
 642 +}
 643 +
 644 +/* Handle SCO audio sync.
 645 + *
 646 + * If we are the MASTER, then we control the timing,
 647 + * in 48 byte chunks.  If we're the SLAVE, we send
 648 + * as and when we recieve a packet.
 649 + *
 650 + * Because of packet/timing nessecity, we
 651 + * start up a thread when we're passing audio, so
 652 + * that things are timed exactly right.
 653 + *
 654 + * sco_thread() is the function that handles it.
 655 + *
 656 + */
 657 +
 658 +static void *
 659 +sco_thread(void * data)
 660 +{
 661 +  blt_dev_t * dev = (blt_dev_t*)data;
 662 +  int res;
 663 +  struct pollfd pfd[2];
 664 +  int in_pos = 0;
 665 +  int out_pos = 0;
 666 +  char c = 1;
 667 +  int sending;
 668 +  char buf[1024];
 669 +  int len;
 670 +
 671 +  // Avoid deadlock in odd circumstances
 672 +
 673 +  ast_log(LOG_WARNING, "SCO thread started on fd %d, pid %d\n", dev->sco, getpid());
 674 +
 675 +  if (fcntl(dev->sco_pipe[1], F_SETFL, O_RDWR|O_NONBLOCK)) {
 676 +         ast_log(LOG_WARNING, "fcntl failed on sco_pipe\n");
 677 +  }
 678 +
 679 +  // dev->status = BLT_STATUS_IN_CALL;
 680 +  // ast_queue_control(dev->owner, AST_CONTROL_ANSWER);
 681 +  // Set buffer to silence, just incase.
 682 +
 683 +  ast_mutex_lock(&(dev->sco_lock));
 684 +
 685 +  memset(dev->sco_buf_in, 0, BUFLEN);
 686 +  memset(dev->sco_buf_out, 0, BUFLEN);
 687 +
 688 +  dev->sco_pos_in  = 0;
 689 +  dev->sco_pos_out = 0;
 690 +  dev->sco_pos_inrcv = 0;
 691 +  dev->wakeread = 1;
 692 +
 693 +  ast_mutex_unlock(&(dev->sco_lock));
 694 +
 695 +  while (1) {
 696 +
 697 +    ast_mutex_lock(&(dev->sco_lock));
 698 +
 699 +    if (dev->sco_running != 1) {
 700 +      ast_log(LOG_DEBUG, "SCO stopped.\n");
 701 +      break;
 702 +    }
 703 +
 704 +    pfd[0].fd = dev->sco;
 705 +    pfd[0].events = POLLIN;
 706 +
 707 +    pfd[1].fd = dev->sco_pipe[1];
 708 +    pfd[1].events = POLLIN;
 709 +
 710 +    ast_mutex_unlock(&(dev->sco_lock));
 711 +
 712 +    res = poll(pfd, 2, 50);
 713 +
 714 +    if (res == -1 && errno != EINTR) {
 715 +      ast_log(LOG_DEBUG, "SCO poll() error\n");
 716 +      break;
 717 +    }
 718 +
 719 +    if (res == 0)
 720 +      continue;
 721 +
 722 +
 723 +    if (pfd[0].revents & POLLIN) {
 724 +
 725 +      len = read(dev->sco, buf, 48);
 726 +
 727 +      if (len) {
 728 +        ast_mutex_lock(&(dev->lock));
 729 +
 730 +        if (dev->owner && dev->owner->_state == AST_STATE_UP) {
 731 +               ast_mutex_lock(&(dev->sco_lock));
 732 +               set_buffer(dev->sco_buf_in,  buf, BUFLEN, &in_pos,  len);
 733 +               dev->sco_pos_inrcv = in_pos;
 734 +
 735 +               get_buffer(buf, dev->sco_buf_out, BUFLEN, &out_pos, len);
 736 +               if (write(dev->sco, buf, len) != len)
 737 +                       ast_log(LOG_WARNING, "Wrote <48 to sco\n");
 738 +
 739 +               if (dev->wakeread) {
 740 +                       /* blt_read has caught up. Kick it */
 741 +                       dev->wakeread = 0;
 742 +                       if(write(dev->sco_pipe[1], &c, 1) != 1)
 743 +                               ast_log(LOG_WARNING, "write to kick sco_pipe failed\n");
 744 +               }
 745 +               ast_mutex_unlock(&(dev->sco_lock));
 746 +       }
 747 +        ast_mutex_unlock(&(dev->lock));
 748 +      }
 749 +
 750 +    } else if (pfd[0].revents) {
 751 +
 752 +      int e = sock_err(pfd[0].fd);
 753 +      ast_log(LOG_ERROR, "SCO connection error: %s (errno %d)\n", strerror(e), e);
 754 +      break;
 755 +
 756 +    } else if (pfd[1].revents & POLLIN) {
 757 +
 758 +      int len;
 759 +
 760 +      len = read(pfd[1].fd, &c, 1);
 761 +      sending = (sending) ? 0 : 1;
 762 +
 763 +      ast_mutex_unlock(&(dev->sco_lock));
 764 +
 765 +    } else if (pfd[1].revents) {
 766 +
 767 +      int e = sock_err(pfd[1].fd);
 768 +      ast_log(LOG_ERROR, "SCO pipe connection event %d on pipe[1]=%d: %s (errno %d)\n", pfd[1].revents, pfd[1].fd, strerror(e), e);
 769 +      break;
 770 +
 771 +    } else {
 772 +      ast_log(LOG_NOTICE, "Unhandled poll output\n");
 773 +      ast_mutex_unlock(&(dev->sco_lock));
 774 +    }
 775 +
 776 +  }
 777 +
 778 +  ast_mutex_lock(&(dev->lock));
 779 +  close(dev->sco);
 780 +  dev->sco = -1;
 781 +  dev->sco_running = -1;
 782 +
 783 +  memset(dev->sco_buf_in, 0, BUFLEN);
 784 +  memset(dev->sco_buf_out, 0, BUFLEN);
 785 +
 786 +  dev->sco_pos_in  = 0;
 787 +  dev->sco_pos_out = 0;
 788 +  dev->sco_pos_inrcv = 0;
 789 +
 790 +  ast_mutex_unlock(&(dev->sco_lock));
 791 +  if (dev->owner)
 792 +    ast_queue_control(dev->owner, AST_CONTROL_HANGUP);
 793 +  ast_mutex_unlock(&(dev->lock));
 794 +  ast_log(LOG_DEBUG, "SCO thread stopped\n");
 795 +  return NULL;
 796 +}
 797 +
 798 +/* Start SCO thread.  Must be called with dev->lock */
 799 +
 800 +static int
 801 +sco_start(blt_dev_t * dev, int fd)
 802 +{
 803 +
 804 +  if (dev->sco_pipe[1] <= 0) {
 805 +    ast_log(LOG_ERROR, "SCO pipe[1] == %d\n", dev->sco_pipe[1]);
 806 +    return -1;
 807 +  }
 808 +
 809 +  ast_mutex_lock(&(dev->sco_lock));
 810 +
 811 +  if (dev->sco_running != -1) {
 812 +    ast_log(LOG_ERROR, "Tried to start SCO thread while already running\n");
 813 +    ast_mutex_unlock(&(dev->sco_lock));
 814 +    return -1;
 815 +  }
 816 +
 817 +  if (dev->sco == -1) {
 818 +    if (fd > 0) {
 819 +      dev->sco = fd;
 820 +    } else if (sco_connect(dev) != 0) {
 821 +      ast_log(LOG_ERROR, "SCO fd invalid\n");
 822 +      ast_mutex_unlock(&(dev->sco_lock));
 823 +      return -1;
 824 +    }
 825 +  }
 826 +
 827 +  dev->sco_running = 1;
 828 +
 829 +  if (ast_pthread_create(&(dev->sco_thread), NULL, sco_thread, dev) < 0) {
 830 +    ast_log(LOG_ERROR, "Unable to start SCO thread.\n");
 831 +    dev->sco_running = -1;
 832 +    ast_mutex_unlock(&(dev->sco_lock));
 833 +    return -1;
 834 +  }
 835 +
 836 +  ast_mutex_unlock(&(dev->sco_lock));
 837 +
 838 +  return 0;
 839 +}
 840 +
 841 +/* Stop SCO thread.  Must be called with dev->lock */
 842 +
 843 +static int
 844 +sco_stop(blt_dev_t * dev)
 845 +{
 846 +  ast_mutex_lock(&(dev->sco_lock));
 847 +  if (dev->sco_running == 1)
 848 +    dev->sco_running = 0;
 849 +  else
 850 +    dev->sco_running = -1;
 851 +  dev->sco_sending = 0;
 852 +  ast_mutex_unlock(&(dev->sco_lock));
 853 +  return 0;
 854 +}
 855 +
 856 +/* ---------------------------------- */
 857 +
 858 +/* Answer the call.  Call with lock held on device */
 859 +
 860 +static int
 861 +answer(blt_dev_t * dev)
 862 +{
 863 +
 864 +  if ( (!dev->owner) || (dev->ready != 1) || (dev->status != BLT_STATUS_READY && dev->status != BLT_STATUS_RINGING)) {
 865 +    ast_log(LOG_ERROR, "Attempt to answer() in invalid state (owner=%p, ready=%d, status=%s)\n",
 866 +              dev->owner, dev->ready, status2str(dev->status));
 867 +    return -1;
 868 +  }
 869 +
 870 +    // dev->sd = sco_connect(&local_bdaddr, &(dev->bdaddr), NULL, NULL, 0);
 871 +    // dev->status = BLT_STATUS_IN_CALL;
 872 +    // dev->owner->fds[0] = dev->sd;
 873 +    //  if we are answering (hitting button):
 874 +  ast_queue_control(dev->owner, AST_CONTROL_ANSWER);
 875 +    //  if asterisk signals us to answer:
 876 +    // ast_setstate(ast, AST_STATE_UP);
 877 +
 878 +  /* Start SCO link */
 879 +  sco_start(dev, -1);
 880 +  return 0;
 881 +}
 882 +
 883 +/* ---------------------------------- */
 884 +
 885 +static int
 886 +blt_write(struct ast_channel * ast, struct ast_frame * frame)
 887 +{
 888 +  blt_dev_t * dev = ast->tech_pvt;
 889 +
 890 +  /* Write a frame of (presumably voice) data */
 891 +
 892 +  if (frame->frametype != AST_FRAME_VOICE) {
 893 +    ast_log(LOG_WARNING, "Don't know what to do with  frame type '%d'\n", frame->frametype);
 894 +    return 0;
 895 +  }
 896 +
 897 +  if (!(frame->subclass & BLUETOOTH_FORMAT)) {
 898 +         static int fish = 5;
 899 +         if (fish) {
 900 +                 ast_log(LOG_WARNING, "Cannot handle frames in format %d\n", frame->subclass);
 901 +                 fish--;
 902 +         }
 903 +    return 0;
 904 +  }
 905 +
 906 +  if (ast->_state != AST_STATE_UP) {
 907 +    return 0;
 908 +  }
 909 +
 910 +  ast_mutex_lock(&(dev->sco_lock));
 911 +  set_buffer(dev->sco_buf_out, frame->data, BUFLEN, &(dev->sco_pos_out), MIN(frame->datalen, BUFLEN));
 912 +  ast_mutex_unlock(&(dev->sco_lock));
 913 +
 914 +  return 0;
 915 +
 916 +}
 917 +
 918 +static struct ast_frame *
 919 +blt_read(struct ast_channel * ast)
 920 +{
 921 +  blt_dev_t * dev = ast->tech_pvt;
 922 +  char c = 1;
 923 +  int len;
 924 +  static int fish = 0;
 925 +  /* Some nice norms */
 926 +
 927 +  dev->fr.datalen = 0;
 928 +  dev->fr.samples = 0;
 929 +  dev->fr.data =  NULL;
 930 +  dev->fr.src = BLT_CHAN_NAME;
 931 +  dev->fr.offset = 0;
 932 +  dev->fr.mallocd = AST_MALLOCD_DATA;
 933 +  dev->fr.delivery.tv_sec = 0;
 934 +  dev->fr.delivery.tv_usec = 0;
 935 +  read(dev->sco_pipe[0], &c, 1);
 936 +  ast_mutex_lock(&(dev->sco_lock));
 937 +  dev->sco_sending = 1;
 938 +
 939 +  if (dev->sco_pos_inrcv < dev->sco_pos_in) {
 940 +         /* Buffer wrapped. Read only till the end */
 941 +         len = BUFLEN - dev->sco_pos_in + dev->sco_pos_inrcv;
 942 +  } else {
 943 +         len = dev->sco_pos_inrcv - dev->sco_pos_in;
 944 +  }
 945 +  dev->fr.data = malloc(AST_FRIENDLY_OFFSET+len) + AST_FRIENDLY_OFFSET;
 946 +
 947 +  get_buffer(dev->fr.data, dev->sco_buf_in, BUFLEN, &(dev->sco_pos_in), len);
 948 +  dev->wakeread = 1;
 949 +  ast_mutex_unlock(&(dev->sco_lock));
 950 +  if (fish) {
 951 +         unsigned char *x = dev->fr.data;
 952 +         ast_log(LOG_WARNING, "blt_read  %d: %02x %02x %02x %02x %02x %02x\n",
 953 +                 dev->fr.datalen, x[0], x[1], x[2], x[3], x[4], x[5]);
 954 +         fish--;
 955 +  }
 956 +
 957 +  dev->fr.samples = len / 2;
 958 +  dev->fr.datalen = len;
 959 +  dev->fr.frametype = AST_FRAME_VOICE;
 960 +  dev->fr.subclass = BLUETOOTH_FORMAT;
 961 +  dev->fr.offset = AST_FRIENDLY_OFFSET;
 962 +  return &dev->fr;
 963 +}
 964 +
 965 +/* Escape Any '"' in str.  Return malloc()ed string */
 966 +static char *
 967 +escape_str(char * str)
 968 +{
 969 +  char * ptr = str;
 970 +  char * pret;
 971 +  char * ret;
 972 +  int len = 0;
 973 +
 974 +  while (*ptr) {
 975 +    if (*ptr == '"')
 976 +      len++;
 977 +    len++;
 978 +    ptr++;
 979 +  }
 980 +
 981 +  ret = malloc(len + 1);
 982 +  pret = memset(ret, 0, len + 1);
 983 +
 984 +  ptr = str;
 985 +
 986 +  while (*ptr) {
 987 +    if (*ptr == '"')
 988 +      *pret++ = '\\';
 989 +    *pret++ = *ptr++;
 990 +  }
 991 +
 992 +  return ret;
 993 +}
 994 +
 995 +static int
 996 +ring_hs(blt_dev_t * dev)
 997 +{
 998 +#if (ASTERISK_VERSION_NUM < 010100)
 999 +  char tmp[AST_MAX_EXTENSION];
1000 +  char *name, *num;
1001 +#endif
1002 +
1003 +  ast_mutex_lock(&(dev->lock));
1004 +
1005 +  if (dev->owner == NULL) {
1006 +    ast_mutex_unlock(&(dev->lock));
1007 +    return 0;
1008 +  }
1009 +
1010 +  dev->ringing = 1;
1011 +  dev->status = BLT_STATUS_RINGING;
1012 +
1013 +  send_atcmd(dev, "RING");
1014 +
1015 +  dev->owner->rings++;
1016 +
1017 +  // XXX:T: '"' needs to be escaped in ELIP.
1018 +
1019 +#if (ASTERISK_VERSION_NUM < 010100)
1020 +
1021 +  if (dev->owner->callerid) {
1022 +
1023 +    memset(tmp, 0, sizeof(tmp));
1024 +    strncpy(tmp, dev->owner->callerid, sizeof(tmp)-1);
1025 +
1026 +    if (!ast_callerid_parse(tmp, &name, &num)) {
1027 +
1028 +      if (dev->clip && num)
1029 +        send_atcmd(dev, "+CLIP: \"%s\",129", num);
1030 +
1031 +      if (dev->elip && name) {
1032 +        char * esc = escape_str(name);
1033 +        send_atcmd(dev, "*ELIP: \"%s\"", esc);
1034 +        free(esc);
1035 +      }
1036 +    }
1037 +  }
1038 +
1039 +
1040 +#else
1041 +
1042 +  if (dev->clip && dev->owner->cid.cid_num)
1043 +    send_atcmd(dev, "+CLIP: \"%s\",129", dev->owner->cid.cid_num);
1044 +
1045 +  if (dev->elip && dev->owner->cid.cid_name) {
1046 +    char * esc = escape_str(dev->owner->cid.cid_name);
1047 +    send_atcmd(dev, "*ELIP: \"%s\"", esc);
1048 +    free(esc);
1049 +  }
1050 +
1051 +#endif
1052 +
1053 +  ast_mutex_unlock(&(dev->lock));
1054 +
1055 +  return 1;
1056 +}
1057 +
1058 +/*
1059 + * If the HS is already connected, then just send RING, otherwise, things get a
1060 + * little more sticky.  We first have to find the channel for HS using SDP,
1061 + * then initiate the connection.  Once we've done that, we can start the call.
1062 + */
1063 +
1064 +static int
1065 +blt_call(struct ast_channel * ast, char * dest, int timeout)
1066 +{
1067 +  blt_dev_t * dev = ast->tech_pvt;
1068 +
1069 +  if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1070 +    ast_log(LOG_WARNING, "blt_call called on %s, neither down nor reserved\n", ast->name);
1071 +    return -1;
1072 +  }
1073 +
1074 +  ast_log(LOG_DEBUG, "Calling %s on %s [t: %d]\n", dest, ast->name, timeout);
1075 +
1076 +  if (ast_mutex_lock(&iface_lock)) {
1077 +    ast_log(LOG_ERROR, "Failed to get iface_lock.\n");
1078 +    return -1;
1079 +  }
1080 +
1081 +//  ast_mutex_lock(&(dev->lock));
1082 +
1083 +  if (dev->ready == 0) {
1084 +    ast_log(LOG_WARNING, "Tried to call a device not ready/connected.\n");
1085 +    ast_setstate(ast, AST_CONTROL_CONGESTION);
1086 +//    ast_mutex_unlock(&(dev->lock));
1087 +    ast_mutex_unlock(&iface_lock);
1088 +    return 0;
1089 +  }
1090 +
1091 +  if (dev->role == BLT_ROLE_HS) {
1092 +
1093 +    send_atcmd(dev, "+CIEV: 3,1");
1094 +
1095 +    dev->ring_timer = ast_sched_add(sched, 5000, AST_SCHED_CB(ring_hs), dev);
1096 +
1097 +    ring_hs(dev);
1098 +
1099 +    ast_setstate(ast, AST_STATE_RINGING);
1100 +    ast_queue_control(ast, AST_CONTROL_RINGING);
1101 +
1102 +  } else if (dev->role == BLT_ROLE_AG) {
1103 +
1104 +    send_atcmd(dev, "ATD%s;", dev->dnid);
1105 +// it does not seem like we should start the audio until the call is connected
1106 +//    sco_start(dev, -1);
1107 +  } else if (dev->role == BLT_ROLE_GUI) {
1108 +
1109 +    send_atcmd(dev, "ATD%s;", dev->dnid);
1110 +
1111 +  } else {
1112 +
1113 +    ast_setstate(ast, AST_CONTROL_CONGESTION);
1114 +    ast_log(LOG_ERROR, "Unknown device role\n");
1115 +
1116 +  }
1117 +
1118 +//  ast_mutex_unlock(&(dev->lock));
1119 +  ast_mutex_unlock(&iface_lock);
1120 +
1121 +  return 0;
1122 +}
1123 +
1124 +static int
1125 +blt_hangup(struct ast_channel * ast)
1126 +{
1127 +  blt_dev_t * dev = ast->tech_pvt;
1128 +
1129 +  ast_log(LOG_DEBUG, "blt_hangup(%s)\n", ast->name);
1130 +
1131 +  if (!ast->tech_pvt) {
1132 +    ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
1133 +    return 0;
1134 +  }
1135 +
1136 +  if (ast_mutex_lock(&iface_lock)) {
1137 +    ast_log(LOG_ERROR, "Failed to get iface_lock\n");
1138 +    return 0;
1139 +  }
1140 +
1141 +  ast_mutex_lock(&(dev->lock));
1142 +
1143 +  sco_stop(dev);
1144 +  dev->sco_sending = 0;
1145 +
1146 +  if (dev->role == BLT_ROLE_HS) {
1147 +
1148 +    if (dev->ringing == 0) {
1149 +      // Actual call in progress
1150 +      send_atcmd(dev, "+CIEV: 2,0");
1151 +    } else {
1152 +
1153 +      // Just ringing still
1154 +
1155 +      if (dev->role == BLT_ROLE_HS)
1156 +        send_atcmd(dev, "+CIEV: 3,0");
1157 +
1158 +      if (dev->ring_timer >= 0)
1159 +        ast_sched_del(sched, dev->ring_timer);
1160 +
1161 +      dev->ring_timer = -1;
1162 +      dev->ringing = 0;
1163 +
1164 +    }
1165 +
1166 +  } else if (dev->role == BLT_ROLE_AG) {
1167 +
1168 +    // Cancel call.
1169 +    send_atcmd(dev, "ATH");
1170 +    send_atcmd(dev, "AT+CHUP");
1171 +
1172 +  }
1173 +
1174 +  if (dev->status == BLT_STATUS_IN_CALL || dev->status == BLT_STATUS_RINGING)
1175 +    dev->status = BLT_STATUS_READY;
1176 +
1177 +  ast->tech_pvt = NULL;
1178 +  dev->owner = NULL;
1179 +  ast_mutex_unlock(&(dev->lock));
1180 +  ast_setstate(ast, AST_STATE_DOWN);
1181 +  ast_mutex_unlock(&(iface_lock));
1182 +
1183 +  return 0;
1184 +}
1185 +
1186 +static int
1187 +blt_indicate(struct ast_channel * c, int condition)
1188 +{
1189 +  ast_log(LOG_DEBUG, "blt_indicate (%d)\n", condition);
1190 +
1191 +  switch(condition) {
1192 +    case AST_CONTROL_RINGING:
1193 +      return -1;
1194 +    default:
1195 +      ast_log(LOG_WARNING, "Don't know how to condition %d\n", condition);
1196 +      break;
1197 +  }
1198 +  return -1;
1199 +}
1200 +
1201 +static int
1202 +blt_answer(struct ast_channel * ast)
1203 +{
1204 +  blt_dev_t * dev = ast->tech_pvt;
1205 +
1206 +  ast_mutex_lock(&dev->lock);
1207 +
1208 +  // if (dev->ring_timer >= 0)
1209 +  //   ast_sched_del(sched, dev->ring_timer);
1210 +  // dev->ring_timer = -1;
1211 +
1212 +  ast_log(LOG_DEBUG, "Answering interface\n");
1213 +
1214 +  if (ast->_state != AST_STATE_UP) {
1215 +    send_atcmd(dev, "+CIEV: 2,1");
1216 +    send_atcmd(dev, "+CIEV: 3,0");
1217 +    sco_start(dev, -1);
1218 +    ast_setstate(ast, AST_STATE_UP);
1219 +  }
1220 +
1221 +  ast_mutex_unlock(&dev->lock);
1222 +
1223 +  return 0;
1224 +}
1225 +
1226 +static struct ast_channel *
1227 +blt_new(blt_dev_t * dev, int state, const char * context, const char * number)
1228 +{
1229 +  struct ast_channel * ast;
1230 +  char c = 0;
1231 +
1232 +  if ((ast = ast_channel_alloc(1)) == NULL) {
1233 +    ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
1234 +    return NULL;
1235 +  }
1236 +
1237 +  snprintf(ast->name, sizeof(ast->name), "BLT/%s", dev->name);
1238 +
1239 +  // ast->fds[0] = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO);
1240 +
1241 +  ast->nativeformats       = BLUETOOTH_FORMAT;
1242 +  //ast->rawreadformat  = BLUETOOTH_FORMAT;
1243 +  //ast->rawwriteformat = BLUETOOTH_FORMAT;
1244 +  ast->writeformat         = BLUETOOTH_FORMAT;
1245 +  ast->readformat          = BLUETOOTH_FORMAT;
1246 +
1247 +  ast_setstate(ast, state);
1248 +
1249 +  ast->type = BLT_CHAN_NAME;
1250 +
1251 +  ast->tech_pvt = dev;
1252 +#if ASTERISK_VERSION_NUM > 010107
1253 +  ast->tech = &blt_tech;
1254 +#else
1255 +  ast->pvt->call     = blt_call;
1256 +  ast->pvt->indicate = blt_indicate;
1257 +  ast->pvt->hangup   = blt_hangup;
1258 +  ast->pvt->read     = blt_read;
1259 +  ast->pvt->write    = blt_write;
1260 +  ast->pvt->answer   = blt_answer;
1261 +#endif
1262 +  strncpy(ast->context, context, sizeof(ast->context)-1);
1263 +  strncpy(ast->exten,   number,  sizeof(ast->exten) - 1);
1264 +  if(0 == strcmp(number, "s"))
1265 +  {
1266 +    //ast_set_callerid(ast, dev->cid_num, dev->cid_name, dev->cid_num);
1267 +  }
1268 +
1269 +  ast->language[0] = '\0';
1270 +
1271 +  ast->fds[0] = dev->sco_pipe[0];
1272 +  write(dev->sco_pipe[1], &c, 1);
1273 +
1274 +  dev->owner = ast;
1275 +
1276 +  ast_mutex_lock(&usecnt_lock);
1277 +  usecnt++;
1278 +  ast_mutex_unlock(&usecnt_lock);
1279 +
1280 +  ast_update_use_count();
1281 +
1282 +  if (state != AST_STATE_DOWN) {
1283 +    if (ast_pbx_start(ast)) {
1284 +      ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ast->name);
1285 +      ast_hangup(ast);
1286 +    }
1287 +  }
1288 +
1289 +  return ast;
1290 +}
1291 +
1292 +static struct ast_channel *
1293 +#if (ASTERISK_VERSION_NUM < 010100)
1294 +blt_request(char * type, int format, void * local_data)
1295 +#elif (ASTERISK_VERSION_NUM <= 010107)
1296 +blt_request(const char * type, int format, void * local_data)
1297 +#else
1298 +blt_request(const char * type, int format, void * local_data, int *cause)
1299 +#endif
1300 +{
1301 +  char * data = (char*)local_data;
1302 +  int oldformat;
1303 +  blt_dev_t * dev = NULL;
1304 +  struct ast_channel * ast = NULL;
1305 +  char * number = data, * dname;
1306 +
1307 +  dname = strsep(&number, "/");
1308 +
1309 +  oldformat = format;
1310 +
1311 +  format &= BLUETOOTH_FORMAT;
1312 +
1313 +  if (!format) {
1314 +    ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format '%d'\n", oldformat);
1315 +    return NULL;
1316 +  }
1317 +
1318 +  ast_log(LOG_DEBUG, "Dialing '%s' via '%s'\n", number, dname);
1319 +
1320 +  if (ast_mutex_lock(&iface_lock)) {
1321 +    ast_log(LOG_ERROR, "Unable to lock iface_list\n");
1322 +    return NULL;
1323 +  }
1324 +
1325 +  dev = iface_head;
1326 +
1327 +  while (dev) {
1328 +    if (strcmp(dev->name, dname) == 0) {
1329 +      ast_mutex_lock(&(dev->lock));
1330 +      if (!dev->ready) {
1331 +        ast_log(LOG_ERROR, "Device %s is not connected\n", dev->name);
1332 +        ast_mutex_unlock(&(dev->lock));
1333 +        ast_mutex_unlock(&iface_lock);
1334 +        return NULL;
1335 +      }
1336 +      break;
1337 +    }
1338 +    dev = dev->next;
1339 +  }
1340 +
1341 +  ast_mutex_unlock(&iface_lock);
1342 +
1343 +  if (!dev) {
1344 +    ast_log(LOG_WARNING, "Failed to find device named '%s'\n", dname);
1345 +    return NULL;
1346 +  }
1347 +
1348 +  if (number && dev->role != BLT_ROLE_AG) {
1349 +    ast_log(LOG_WARNING, "Tried to send a call out on non AG\n");
1350 +    ast_mutex_unlock(&(dev->lock));
1351 +    return NULL;
1352 +  }
1353 +
1354 +  if (dev->role == BLT_ROLE_AG)
1355 +    strncpy(dev->dnid, number, sizeof(dev->dnid) - 1);
1356 +
1357 +  ast = blt_new(dev, AST_STATE_DOWN, dev->context, "s");
1358 +
1359 +  ast_mutex_unlock(&(dev->lock));
1360 +
1361 +  return ast;
1362 +}
1363 +
1364 +/* ---------------------------------- */
1365 +
1366 +
1367 +/* ---- AT COMMAND SOCKET STUFF ---- */
1368 +
1369 +static int
1370 +send_atcmd(blt_dev_t * dev, const char * fmt, ...)
1371 +{
1372 +  char buf[1024];
1373 +  va_list ap;
1374 +  int len;
1375 +
1376 +  va_start(ap, fmt);
1377 +  len = vsnprintf(buf, 1023, fmt, ap);
1378 +  va_end(ap);
1379 +
1380 +  if (option_verbose)
1381 +    ast_verbose(VERBOSE_PREFIX_1 "[%s] %*s < %s\n", role2str(dev->role), 10, dev->name, buf);
1382 +
1383 +  write(dev->rd, "\r\n", 2);
1384 +  len = write(dev->rd, buf, len);
1385 +  write(dev->rd, "\r\n", 2);
1386 +  return (len) ? 0 : -1;
1387 +}
1388 +
1389 +
1390 +static int
1391 +send_atcmd_ok(blt_dev_t * dev, const char * cmd)
1392 +{
1393 +  int len;
1394 +  strncpy(dev->last_ok_cmd, cmd, BLT_RDBUFF_MAX - 1);
1395 +  if (option_verbose)
1396 +    ast_verbose(VERBOSE_PREFIX_1 "[%s] %*s < OK\n", role2str(dev->role), 10, dev->name);
1397 +  len = write(dev->rd, "\r\nOK\r\n", 6);
1398 +  return (len) ? 0 : -1;
1399 +}
1400 +
1401 +static int
1402 +send_atcmd_error(blt_dev_t * dev)
1403 +{
1404 +  int len;
1405 +
1406 +  if (option_verbose)
1407 +    ast_verbose(VERBOSE_PREFIX_1 "[%s] %*s < ERROR\n", role2str(dev->role), 10, dev->name);
1408 +
1409 +//  write(dev->rd, "\r\n", 2);
1410 +//  len = write(dev->rd, dev->last_ok_cmd, 5);
1411 +  write(dev->rd, "\r\n", 2);
1412 +  len = write(dev->rd, "ERROR", 5);
1413 +  write(dev->rd, "\r\n", 2);
1414 +
1415 +  return (len) ? 0 : -1;
1416 +}
1417 +
1418 +
1419 +/* ---------------------------------- */
1420 +
1421 +/* -- Handle negotiation when we're an AG -- */
1422 +
1423 +/* Bluetooth Support */
1424 +
1425 +static int
1426 +atcmd_brsf_set(blt_dev_t * dev, const char * arg, int len)
1427 +{
1428 +  ast_log(LOG_DEBUG, "Device Supports: %s\n", arg);
1429 +  dev->brsf = atoi(arg);
1430 +  send_atcmd(dev, "+BRSF: %d", 23);
1431 +  return 0;
1432 +}
1433 +
1434 +/* Bluetooth Voice Recognition */
1435 +
1436 +static int
1437 +atcmd_bvra_set(blt_dev_t * dev, const char * arg, int len)
1438 +{
1439 +  ast_log(LOG_WARNING, "+BVRA Not Yet Supported\n");
1440 +  return -1;
1441 +#if 0
1442 +  // XXX:T: Fix voice recognition somehow!
1443 +  int action = atoi(arg);
1444 +  ast_log(LOG_DEBUG, "Voice Recognition: %s\n", (a) ? "ACTIVATED" : "DEACTIVATED");
1445 +  if ((action == 0) & (dev->bvra == 1)) {
1446 +    /* Disable it */
1447 +    dev->bvra = 0;
1448 +    // XXX:T: Shutdown any active bvra channel
1449 +    ast_log(LOG_DEBUG, "Voice Recognition: DISABLED\n");
1450 +  } else if ((action == 1) && (dev->bvra == 0)) {
1451 +    /* Enable it */
1452 +    dev->bvra = 1;
1453 +    // XXX:T: Schedule connection to voice recognition extension/application
1454 +    ast_log(LOG_DEBUG, "Voice Recognition: ENABLED\n");
1455 +  } else {
1456 +    ast_log(LOG_ERROR, "+BVRA out of sync (we think %d, but HS wants %d)\n", dev->bvra, action);
1457 +    return -1;
1458 +  }
1459 +  return 0;
1460 +#endif
1461 +}
1462 +
1463 +/* Clock */
1464 +
1465 +static int
1466 +atcmd_cclk_read(blt_dev_t * dev)
1467 +{
1468 +  struct tm t, *tp;
1469 +  const time_t ti = time(0);
1470 +  tp = localtime_r(&ti, &t);
1471 +  send_atcmd(dev, "+CCLK: \"%02d/%02d/%02d,%02d:%02d:%02d+%02d\"",
1472 +                  (tp->tm_year % 100), (tp->tm_mon + 1), (tp->tm_mday),
1473 +                  tp->tm_hour, tp->tm_min, tp->tm_sec, ((tp->tm_gmtoff / 60) / 15));
1474 +  return 0;
1475 +}
1476 +
1477 +/* CHUP - Hangup Call */
1478 +
1479 +static int
1480 +atcmd_chup_execute(blt_dev_t * dev, const char * data)
1481 +{
1482 +  if (!dev->owner) {
1483 +    ast_log(LOG_ERROR, "Request to hangup call when none in progress\n");
1484 +    return -1;
1485 +  }
1486 +  ast_log(LOG_DEBUG, "Hangup Call\n");
1487 +  ast_queue_control(dev->owner, AST_CONTROL_HANGUP);
1488 +  return 0;
1489 +}
1490 +
1491 +/* CIND - Call Indicator */
1492 +
1493 +static int
1494 +atcmd_cind_read(blt_dev_t * dev)
1495 +{
1496 +  send_atcmd(dev, "+CIND: 1,0,0");
1497 +  return 0;
1498 +}
1499 +
1500 +static int
1501 +atcmd_cind_test(blt_dev_t * dev)
1502 +{
1503 +  send_atcmd(dev, "+CIND: (\"service\",(0,1)),(\"call\",(0,1)),(\"callsetup\",(0-4))");
1504 +  return 0;
1505 +}
1506 +
1507 +/* Set Language */
1508 +
1509 +static int
1510 +atcmd_clan_read(blt_dev_t * dev)
1511 +{
1512 +  send_atcmd(dev, "+CLAN: \"en\"");
1513 +  return 0;
1514 +}
1515 +
1516 +/* Caller Id Presentation */
1517 +
1518 +static int
1519 +atcmd_clip_set(blt_dev_t * dev, const char * arg, int len)
1520 +{
1521 +  dev->clip = atoi(arg);
1522 +  return 0;
1523 +}
1524 +
1525 +/* Connected Line Identification Presentation */
1526 +
1527 +static int
1528 +atcmd_colp_set(blt_dev_t * dev, const char * arg, int len)
1529 +{
1530 +  dev->colp = atoi(arg);
1531 +  return 0;
1532 +}
1533 +
1534 +/* CMER - Mobile Equipment Event Reporting */
1535 +
1536 +static int
1537 +atcmd_cmer_set(blt_dev_t * dev, const char * arg, int len)
1538 +{
1539 +  dev->ready = 1;
1540 +  dev->status = BLT_STATUS_READY;
1541 +  return 0;
1542 +}
1543 +
1544 +/* PhoneBook Types:
1545 + *
1546 + *  - FD - SIM Fixed Dialing Phone Book
1547 + *  - ME - ME Phone book
1548 + *  - SM - SIM Phone Book
1549 + *  - DC - ME dialled-calls list
1550 + *  - RC - ME recieved-calls lisr
1551 + *  - MC - ME missed-calls list
1552 + *  - MV - ME Voice Activated Dialing List
1553 + *  - HP - Hierachial Phone Book
1554 + *  - BC - Own Business Card (PIN2 required)
1555 + *
1556 + */
1557 +
1558 +/* Read Phone Book Entry */
1559 +
1560 +static int
1561 +atcmd_cpbr_set(blt_dev_t * dev, const char * arg, int len)
1562 +{
1563 +  // XXX:T: Fix the phone book!
1564 +  // * Maybe add res_phonebook or something? */
1565 +  send_atcmd(dev, "+CPBR: %d,\"%s\",128,\"%s\"", atoi(arg), arg, arg);
1566 +  return 0;
1567 +}
1568 +
1569 +/* Select Phone Book */
1570 +
1571 +static int
1572 +atcmd_cpbs_set(blt_dev_t * dev, const char * arg, int len)
1573 +{
1574 +  // XXX:T: I guess we'll just accept any?
1575 +  return 0;
1576 +}
1577 +
1578 +static int
1579 +atcmd_cscs_set(blt_dev_t * dev, const char * arg, int len)
1580 +{
1581 +  // XXX:T: Language
1582 +  return 0;
1583 +}
1584 +
1585 +static int
1586 +atcmd_eips_set(blt_dev_t * dev, const char * arg, int len)
1587 +{
1588 +  ast_log(LOG_DEBUG, "Identify Presentation Set: %s=%s\n",
1589 +                         (*(arg) == 49) ? "ELIP" : "EOLP",
1590 +                         (*(arg+2) == 49) ? "ON" : "OFF");
1591 +
1592 +  if (*(arg) == 49)
1593 +    dev->eolp = (*(arg+2) == 49) ? 1 : 0;
1594 +  else
1595 +    dev->elip = (*(arg+2) == 49) ? 1 : 0;
1596 +
1597 +  return 0;
1598 +}
1599 +
1600 +/* VGS - Speaker Volume Gain */
1601 +
1602 +static int
1603 +atcmd_vgs_set(blt_dev_t * dev, const char * arg, int len)
1604 +{
1605 +  dev->gain_speaker = atoi(arg);
1606 +  return 0;
1607 +}
1608 +
1609 +void
1610 +gui_eaid_response(blt_dev_t * dev, char * cmd)
1611 +{
1612 +  ast_log(LOG_NOTICE, "Submenu displayed.\n");
1613 +}
1614 +
1615 +static int
1616 +atcmd_eami_execute(blt_dev_t * dev, const char * data)
1617 +{
1618 +  char * number = NULL;
1619 +
1620 +  number = strndup(data, strlen(data));
1621 +  int menuitem = atoi(number);
1622 +
1623 +  ast_log(LOG_NOTICE, "Menu Item '%d'.\n", menuitem);
1624 +
1625 +  dev->cb = gui_eaid_response;
1626 +
1627 +  if (menuitem == 1) {
1628 +    char command[1024] = "";
1629 +    const char* c1 = "AT*EAID=8,1,\"Make a SIP call\",\"Number\",\"";
1630 +    const char* c2 = "\"";
1631 +
1632 +    (void)strncat(command, c1, sizeof(command) - strlen(command) - 1);
1633 +    (void)strncat(command, gui_default_sip_number, sizeof(command) - strlen(command) - 1);
1634 +    (void)strncat(command, c2, sizeof(command) - strlen(command) - 1);
1635 +
1636 +    //strcat(command, "AT*EAID=8,1,\"Make a SIP call\",\"Number\",\"");
1637 +    //strcat(command, gui_default_sip_number);
1638 +    //strcat(command, "\"");
1639 +    send_atcmd(dev, command);
1640 +  } else if (menuitem == 2) {
1641 +    char command[1024] = "";
1642 +    const char* c1 = "AT*EAID=11,1,\"Make a SIP call\",\"SIP Address\",100,\"";
1643 +    const char* c2 = "\"";
1644 +
1645 +    (void)strncat(command, c1, sizeof(command) - strlen(command) - 1);
1646 +    (void)strncat(command, gui_default_sip_address, sizeof(command) - strlen(command) - 1);
1647 +    (void)strncat(command, c2, sizeof(command) - strlen(command) - 1);
1648 +
1649 +    //strcat(command, "AT*EAID=11,1,\"Make a SIP call\",\"SIP Address\",100,\"");
1650 +    //strcat(command, gui_default_sip_address);
1651 +    //strcat(command, "\"");
1652 +    send_atcmd(dev, command);
1653 +  } else if (menuitem == 0) {
1654 +    dev->cb = gui_easm_response;
1655 +//    send_atcmd(dev,"AT*EASM=\"SIP Menu\",1,1,3,\"Call Number\",\"Call Address\",\"More Options\",1");
1656 +    send_atcmd(dev,"AT*EASM=\"SIP Menu\",1,1,2,\"Call Number\",\"Call Address\",1");
1657 +  } else {
1658 +    ast_log(LOG_ERROR, "Menu item not implementented.\n");
1659 +  }
1660 +  return 0;
1661 +}
1662 +
1663 +static int
1664 +atcmd_eaii_execute(blt_dev_t * dev, const char * data)
1665 +{
1666 +  int pos = 1, len = 0;
1667 +  char type[128];
1668 +  char val[128];
1669 +  const char * start = data;
1670 +  struct sockaddr_in addr;
1671 +
1672 +  while (*data) {
1673 +    if (*data == ',') {
1674 +      memset(type, 0, 128);
1675 +      strncpy(type, start, len);
1676 +
1677 +      ast_log(LOG_NOTICE, "Number(8)/Address(11): '%s'.\n", type);
1678 +
1679 +      pos++;
1680 +      len = 0;
1681 +      data++;
1682 +      start = data;
1683 +      continue;
1684 +    }
1685 +    len++;
1686 +    data++;
1687 +  }
1688 +
1689 +  memset(val, 0, 128);
1690 +  strncpy(val, start, len);
1691 +
1692 +  char del[]= "\"";
1693 +  char* address;
1694 +  address = strtok(val, del);
1695 +  int type_int = atoi(type);
1696 +
1697 +  if (strcmp(address, " 0") == 0) {
1698 +      ast_log(LOG_NOTICE, "Spurious EAII:\n");
1699 +      ast_log(LOG_NOTICE, data);
1700 +      return 0;
1701 +  }
1702 +
1703 +  if (type_int == 8) {
1704 +      (void)strncat(address, "@sipgate.de", sizeof(address) - strlen(address) - 1);
1705 +  }
1706 +
1707 +  ast_log(LOG_NOTICE, "SIP number/address: '%i','%s'.\n", type_int, address);
1708 +
1709 +  if (type_int == 8 || type_int == 11) {
1710 +
1711 +    char messagebox[1024] = "";
1712 +    const char* mb1 = "AT*EAID=1,1,\"Setting up SIP call to ";
1713 +    const char* mb2 = "\",30";
1714 +
1715 +    (void)strncat(messagebox, mb1, sizeof(messagebox) - strlen(messagebox) - 1);
1716 +    (void)strncat(messagebox, address, sizeof(messagebox) - strlen(messagebox) - 1);
1717 +    (void)strncat(messagebox, mb2, sizeof(messagebox) - strlen(messagebox) - 1);
1718 +
1719 +    //strcat(messagebox, "AT*EAID=1,1,\"Setting up SIP call to ");
1720 +    //strcat(messagebox, address);
1721 +    //strcat(messagebox, "\",30");
1722 +    send_atcmd(dev, messagebox);
1723 +
1724 +    send_atcmd(dev, "AT*ESKS=2");
1725 +    send_atcmd(dev, "AT*EKSP");
1726 +    send_atcmd(dev, "AT*ESKS=0");
1727 +
1728 +    //Create manager connection to create call
1729 +    int s = socket(AF_INET,SOCK_STREAM,0);
1730 +    if (s < 0) {
1731 +      ast_log(LOG_ERROR, "Manager connection failed.");
1732 +
1733 +      dev->cb = ag_cgmi_response;
1734 +      send_atcmd(dev, "AT*EAID=1,1,\"Call failed\"");
1735 +      return -1;
1736 +    }
1737 +    addr.sin_family = AF_INET;
1738 +    addr.sin_port = htons(5038);
1739 +    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
1740 +    memset(&(addr.sin_zero), '\0', 8);
1741 +
1742 +    if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
1743 +      ast_log(LOG_ERROR, "Manager connection failed. (2)");
1744 +      dev->cb = ag_cgmi_response;
1745 +      send_atcmd(dev, "AT*EAID=1,1,\"Call failed\"");
1746 +      return -1;
1747 +    }
1748 +    char* command = "Action: login\r\nUsername: markus\r\nSecret: supAEr\r\n\r\n";
1749 +    if (write(s,command,strlen(command)) < 0) {
1750 +      ast_log(LOG_ERROR, "Manager connection failed. (3)");
1751 +      dev->cb = ag_cgmi_response;
1752 +      send_atcmd(dev, "AT*EAID=1,1,\"Call failed\"");
1753 +      return -1;
1754 +    }
1755 +
1756 +    char command3[1024] = "";
1757 +    const char* action = "Action: Originate\r\nChannel: SIP/";
1758 +    const char* action2 = "\r\nExten: 1235\r\nPriority: 1\r\nContext: sipgate.de\r\n\r\nAction: logoff\r\n\r\n";
1759 +
1760 +    (void)strncat(command3, action, sizeof(command3) - strlen(command3) - 1);
1761 +    (void)strncat(command3, address, sizeof(command3) - strlen(command3) - 1);
1762 +    (void)strncat(command3, action2, sizeof(command3) - strlen(command3) - 1);
1763 +
1764 +    //strcat(command3, "Action: Originate\r\nChannel: SIP/");
1765 +    //strcat(command3, address);
1766 +    //strcat(command3, "\r\nExten: 1235\r\nPriority: 1\r\nContext: sipgate.de\r\n\r\n");
1767 +    ast_log(LOG_NOTICE, command3);
1768 +
1769 +    if (write(s,command3,strlen(command3)) < 0) {
1770 +      ast_log(LOG_ERROR, "Manager connection failed. (5)");
1771 +      return -1;
1772 +    }
1773 +  }
1774 +  //dev->cb = ag_cgmi_response;
1775 +  return 0;
1776 +}
1777 +
1778 +/* Dial */
1779 +static int
1780 +atcmd_dial_execute(blt_dev_t * dev, const char * data)
1781 +{
1782 +  char * number = NULL;
1783 +
1784 +  /* Make sure there is a ';' at the end of the line */
1785 +  if (*(data + (strlen(data) - 1)) != ';') {
1786 +    ast_log(LOG_WARNING, "Can't dial non-voice right now: %s\n", data);
1787 +    return -1;
1788 +  }
1789 +
1790 +  number = strndup(data, strlen(data) - 1);
1791 +  ast_log(LOG_NOTICE, "Dial: [%s]\n", number);
1792 +
1793 +  send_atcmd(dev, "+CIEV: 2,1");
1794 +  send_atcmd(dev, "+CIEV: 3,0");
1795 +
1796 +  sco_start(dev, -1);
1797 +
1798 +  if (blt_new(dev, AST_STATE_UP, dev->context, number) == NULL) {
1799 +    sco_stop(dev);
1800 +  }
1801 +
1802 +  free(number);
1803 +
1804 +  return 0;
1805 +}
1806 +
1807 +static int atcmd_bldn_execute(blt_dev_t * dev, const char *data)
1808 +{
1809 +       return atcmd_dial_execute(dev, "bldn;");
1810 +}
1811 +
1812 +/* Answer */
1813 +
1814 +static int
1815 +atcmd_answer_execute(blt_dev_t * dev, const char * data)
1816 +{
1817 +
1818 +  if (!dev->ringing || !dev->owner) {
1819 +    ast_log(LOG_WARNING, "Can't answer non existant call\n");
1820 +    return -1;
1821 +  }
1822 +
1823 +  dev->ringing = 0;
1824 +
1825 +  if (dev->ring_timer >= 0)
1826 +    ast_sched_del(sched, dev->ring_timer);
1827 +
1828 +  dev->ring_timer = -1;
1829 +
1830 +  send_atcmd(dev, "+CIEV: 2,1");
1831 +  send_atcmd(dev, "+CIEV: 3,0");
1832 +
1833 +  return answer(dev);
1834 +}
1835 +
1836 +static int
1837 +ag_unsol_ciev(blt_dev_t * dev, const char * data)
1838 +{
1839 +  const char * orig = data;
1840 +  int indicator;
1841 +  int status;
1842 +
1843 +  while (*(data) && *(data) == ' ')
1844 +    data++;
1845 +
1846 +  if (*(data) == 0) {
1847 +    ast_log(LOG_WARNING, "Invalid value[1] for '+CIEV:%s'\n", orig);
1848 +    return -1;
1849 +  }
1850 +
1851 +  indicator = *(data++) - 48;
1852 +
1853 +  if (*(data++) != ',') {
1854 +    ast_log(LOG_WARNING, "Invalid value[2] for '+CIEV:%s'\n", orig);
1855 +    return -1;
1856 +  }
1857 +
1858 +  if (*(data) == 0) {
1859 +    ast_log(LOG_WARNING, "Invalid value[3] for '+CIEV:%s'\n", orig);
1860 +    return -1;
1861 +  }
1862 +
1863 +  status = *(data) - 48;
1864 +
1865 +  set_cind(dev, indicator, status);
1866 +
1867 +  return 0;
1868 +}
1869 +
1870 +static int
1871 +ag_unsol_cind(blt_dev_t * dev, const char * data)
1872 +{
1873 +
1874 +  while (*(data) && *(data) == ' ')
1875 +    data++;
1876 +
1877 +
1878 +  if (dev->cind == 0)
1879 +  {
1880 +    int pos = 1;
1881 +    char name[1024];
1882 +
1883 +    while ((data = parse_cind(data, name, 1023)) != NULL) {
1884 +      ast_log(LOG_DEBUG, "CIND: %d=%s\n", pos, name);
1885 +      if (strcmp(name, "call") == 0)
1886 +        dev->call_pos = pos;
1887 +      else if (strcmp(name, "service") == 0)
1888 +        dev->service_pos = pos;
1889 +      else if (strcmp(name, "call_setup") == 0 || strcmp(name, "callsetup") == 0)
1890 +        dev->callsetup_pos = pos;
1891 +      pos++;
1892 +    }
1893 +
1894 +    ast_log(LOG_DEBUG, "CIND: %d=%s\n", pos, name);
1895 +
1896 +  } else {
1897 +
1898 +    int pos = 1, len = 0;
1899 +    char val[128];
1900 +    const char * start = data;
1901 +
1902 +    while (*data) {
1903 +      if (*data == ',') {
1904 +        memset(val, 0, 128);
1905 +        strncpy(val, start, len);
1906 +        set_cind(dev, pos, atoi(val));
1907 +        pos++;
1908 +        len = 0;
1909 +        data++;
1910 +        start = data;
1911 +        continue;
1912 +      }
1913 +      len++;
1914 +      data++;
1915 +    }
1916 +
1917 +    memset(val, 0, 128);
1918 +    strncpy(val, start, len);
1919 +    ast_log(LOG_DEBUG, "CIND IND %d set to %d [%s]\n", pos, atoi(val), val);
1920 +
1921 +
1922 +  }
1923 +
1924 +  return 0;
1925 +}
1926 +
1927 +/*
1928 + * handle an incoming call
1929 + */
1930 +static int
1931 +ag_unsol_clip(blt_dev_t * dev, const char * data)
1932 +{
1933 +  const char * orig = data;
1934 +  char name[256];
1935 +  char number[64];
1936 +  int type;
1937 +
1938 +  while (*(data) && *(data) == ' ')
1939 +    data++;
1940 +
1941 +  if (*(data) == 0) {
1942 +    ast_log(LOG_WARNING, "Invalid value[1] for '+CLIP:%s'\n", orig);
1943 +    return -1;
1944 +  }
1945 +
1946 +  parse_clip(data, number, sizeof(number)-1, name, sizeof(name)-1, &type);
1947 +  ast_log(LOG_NOTICE, "Parsed '+CLIP: %s' number='%s' type='%d' name='%s'\n", data, number, type, name);
1948 +
1949 +  blt_new(dev, AST_STATE_RING, dev->context, "s");
1950 +
1951 +  return 0;
1952 +}
1953 +
1954 +
1955 +
1956 +static blt_atcb_t
1957 +atcmd_list[] =
1958 +{
1959 +  { "A",     NULL,           NULL,            atcmd_answer_execute, NULL,             NULL },
1960 +  { "D",     NULL,           NULL,            atcmd_dial_execute,   NULL,             NULL },
1961 +  { "+BRSF", atcmd_brsf_set, NULL,            NULL,                 NULL,             NULL },
1962 +  { "+BVRA", atcmd_bvra_set, NULL,            NULL,                 NULL,             NULL },
1963 +  { "+CCLK", NULL,           atcmd_cclk_read, NULL,                 NULL,             NULL },
1964 +  { "+CHUP", NULL,           NULL,            atcmd_chup_execute,   NULL,             NULL },
1965 +  { "+CIEV", NULL,           NULL,            NULL,                 NULL,             ag_unsol_ciev },
1966 +  { "+CIND", NULL,           atcmd_cind_read, NULL,                 atcmd_cind_test,  ag_unsol_cind },
1967 +  { "*EAMI", NULL,           NULL,            atcmd_eami_execute,   NULL,             NULL},
1968 +  { "*EAII", NULL,           NULL,            atcmd_eaii_execute,   NULL,             NULL},
1969 +
1970 +  { "+CLAN", NULL,           atcmd_clan_read, NULL,                 NULL,             NULL },
1971 +  { "+CLIP", atcmd_clip_set, NULL,            NULL,                 NULL,             ag_unsol_clip },
1972 +  { "+COLP", atcmd_colp_set, NULL,            NULL,                 NULL,             NULL },
1973 +  { "+CMER", atcmd_cmer_set, NULL,            NULL,                 NULL,             NULL },
1974 +  { "+CPBR", atcmd_cpbr_set, NULL,            NULL,                 NULL,             NULL },
1975 +  { "+CPBS", atcmd_cpbs_set, NULL,            NULL,                 NULL,             NULL },
1976 +  { "+CSCS", atcmd_cscs_set, NULL,            NULL,                 NULL,             NULL },
1977 +  { "*EIPS", atcmd_eips_set, NULL,            NULL,                 NULL,             NULL },
1978 +  { "+VGS",  atcmd_vgs_set,  NULL,            NULL,                 NULL,             NULL },
1979 +  { "+BLDN", NULL,           NULL,            atcmd_bldn_execute,   NULL,             NULL },
1980 +};
1981 +
1982 +#define ATCMD_LIST_LEN (sizeof(atcmd_list) / sizeof(blt_atcb_t))
1983 +
1984 +/* ---------------------------------- */
1985 +
1986 +/* -- Handle negotiation when we're a HS -- */
1987 +
1988 +void
1989 +ag_unknown_response(blt_dev_t * dev, char * cmd)
1990 +{
1991 +  ast_log(LOG_DEBUG, "Got UNKN response: %s\n", cmd);
1992 +
1993 +  // DELAYED
1994 +  // NO CARRIER
1995 +
1996 +}
1997 +
1998 +void
1999 +gui_easm_response(blt_dev_t * dev, char * cmd)
2000 +{
2001 +  ast_log(LOG_NOTICE, "Menu displayed.\n");
2002 +}
2003 +
2004 +void
2005 +ag_cgmi_response(blt_dev_t * dev, char * cmd)
2006 +{
2007 +  // CGMM - Phone Model
2008 +  // CGMR - Phone Revision
2009 +  // CGSN - IMEI
2010 +  // AT*
2011 +  // VTS - send tone
2012 +  // CREG
2013 +  // CBC - BATTERY
2014 +  // CSQ - SIGANL
2015 +  // CSMS - SMS STUFFS
2016 +  //  CMGL
2017 +  //  CMGR
2018 +  //  CMGS
2019 +  // CSCA - sms CENTER NUMBER
2020 +  // CNMI - SMS INDICATION
2021 +  // ast_log(LOG_DEBUG, "Manufacturer: %s\n", cmd);
2022 +
2023 +  if (dev->role == BLT_ROLE_GUI) {
2024 +    ast_log(LOG_NOTICE, "Displaying Menu.\n");
2025 +    dev->cb = gui_easm_response;
2026 +//    send_atcmd(dev,"AT*EASM=\"SIP Menu\",1,1,3,\"Call Number\",\"Call Address\",\"More Options\",1");
2027 +    send_atcmd(dev,"AT*EASM=\"SIP Menu\",1,1,2,\"Call Number\",\"Call Address\",1");
2028 +  } else {
2029 +    dev->cb = ag_unknown_response;
2030 +  }
2031 +}
2032 +
2033 +void
2034 +ag_cgmi_valid_response(blt_dev_t * dev, char * cmd)
2035 +{
2036 +  // send_atcmd(dev, "AT+WS46?");
2037 +  // send_atcmd(dev, "AT+CRC=1");
2038 +  // send_atcmd(dev, "AT+CNUM");
2039 +
2040 +  if (strcmp(cmd, "OK") == 0) {
2041 +    send_atcmd(dev, "AT+CGMI");
2042 +    dev->cb = ag_cgmi_response;
2043 +  } else {
2044 +    dev->cb = ag_unknown_response;
2045 +  }
2046 +}
2047 +
2048 +void
2049 +ag_clip_response(blt_dev_t * dev, char * cmd)
2050 +{
2051 +  send_atcmd(dev, "AT+CGMI=?");
2052 +  dev->cb = ag_cgmi_valid_response;
2053 +}
2054 +
2055 +void
2056 +ag_cmer_response(blt_dev_t * dev, char * cmd)
2057 +{
2058 +  dev->cb = ag_clip_response;
2059 +  dev->ready = 1;
2060 +  dev->status = BLT_STATUS_READY;
2061 +  send_atcmd(dev, "AT+CLIP=1");
2062 +}
2063 +
2064 +void
2065 +ag_cind_status_response(blt_dev_t * dev, char * cmd)
2066 +{
2067 +  // XXX:T: Handle response.
2068 +  dev->cb = ag_cmer_response;
2069 +  send_atcmd(dev, "AT+CMER=3,0,0,1");
2070 +  // Initiliase SCO link!
2071 +}
2072 +
2073 +void
2074 +ag_cind_response(blt_dev_t * dev, char * cmd)
2075 +{
2076 +  dev->cb = ag_cind_status_response;
2077 +  dev->cind = 1;
2078 +  send_atcmd(dev, "AT+CIND?");
2079 +}
2080 +
2081 +void
2082 +ag_brsf_response(blt_dev_t * dev, char * cmd)
2083 +{
2084 +  dev->cb = ag_cind_response;
2085 +  ast_log(LOG_DEBUG, "Bluetooth features: %s\n", cmd);
2086 +  dev->cind = 0;
2087 +  send_atcmd(dev, "AT+CIND=?");
2088 +}
2089 +
2090 +/* ---------------------------------- */
2091 +
2092 +static int
2093 +sdp_register(sdp_session_t * session)
2094 +{
2095 +  // XXX:T: Fix this horrible function so it makes some sense and is extensible!
2096 +  sdp_list_t *svclass_id, *pfseq, *apseq, *root;
2097 +  uuid_t root_uuid, svclass_uuid, ga_svclass_uuid, l2cap_uuid, rfcomm_uuid;
2098 +  sdp_profile_desc_t profile;
2099 +  sdp_list_t *aproto, *proto[2];
2100 +  sdp_record_t record;
2101 +  uint8_t u8 = rfcomm_channel_ag;
2102 +  uint8_t u8_hs = rfcomm_channel_hs;
2103 +  sdp_data_t *channel;
2104 +  int ret = 0;
2105 +
2106 +  memset((void *)&record, 0, sizeof(sdp_record_t));
2107 +  record.handle = 0xffffffff;
2108 +  sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
2109 +  root = sdp_list_append(0, &root_uuid);
2110 +  sdp_set_browse_groups(&record, root);
2111 +
2112 +  // Register as an AG
2113 +
2114 +  sdp_uuid16_create(&svclass_uuid, HANDSFREE_AUDIO_GW_SVCLASS_ID);
2115 +  svclass_id = sdp_list_append(0, &svclass_uuid);
2116 +  sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID);
2117 +  svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid);
2118 +  sdp_set_service_classes(&record, svclass_id);
2119 +  sdp_uuid16_create(&profile.uuid, 0x111f);
2120 +  profile.version = 0x0100;
2121 +  pfseq = sdp_list_append(0, &profile);
2122 +
2123 +  sdp_set_profile_descs(&record, pfseq);
2124 +
2125 +  sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
2126 +  proto[0] = sdp_list_append(0, &l2cap_uuid);
2127 +  apseq = sdp_list_append(0, proto[0]);
2128 +
2129 +  sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
2130 +  proto[1] = sdp_list_append(0, &rfcomm_uuid);
2131 +  channel = sdp_data_alloc(SDP_UINT8, &u8);
2132 +  proto[1] = sdp_list_append(proto[1], channel);
2133 +  apseq = sdp_list_append(apseq, proto[1]);
2134 +
2135 +  aproto = sdp_list_append(0, apseq);
2136 +  sdp_set_access_protos(&record, aproto);
2137 +
2138 +  sdp_set_info_attr(&record, "Voice Gateway", 0, 0);
2139 +
2140 +  if (sdp_record_register(session, &record, SDP_RECORD_PERSIST) < 0) {
2141 +    ast_log(LOG_ERROR, "Service Record registration failed\n");
2142 +    ret = -1;
2143 +    goto end;
2144 +  }
2145 +
2146 +  sdp_record_ag = record.handle;
2147 +  sdp_record_gui = record.handle;
2148 +
2149 +  ast_log(LOG_NOTICE, "HeadsetAudioGateway service registered\n");
2150 +
2151 +  sdp_data_free(channel);
2152 +  sdp_list_free(proto[0], 0);
2153 +  sdp_list_free(proto[1], 0);
2154 +  sdp_list_free(apseq, 0);
2155 +  sdp_list_free(aproto, 0);
2156 +
2157 +  // -------------
2158 +
2159 +  memset((void *)&record, 0, sizeof(sdp_record_t));
2160 +  record.handle = 0xffffffff;
2161 +  sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
2162 +  root = sdp_list_append(0, &root_uuid);
2163 +  sdp_set_browse_groups(&record, root);
2164 +
2165 +  // Register as an HS
2166 +
2167 +  sdp_uuid16_create(&svclass_uuid, HANDSFREE_AUDIO_GW_SVCLASS_ID);
2168 +  svclass_id = sdp_list_append(0, &svclass_uuid);
2169 +  sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID);
2170 +  svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid);
2171 +  sdp_set_service_classes(&record, svclass_id);
2172 +  sdp_uuid16_create(&profile.uuid, 0x111e);
2173 +  profile.version = 0x0100;
2174 +  pfseq = sdp_list_append(0, &profile);
2175 +  sdp_set_profile_descs(&record, pfseq);
2176 +
2177 +  sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
2178 +  proto[0] = sdp_list_append(0, &l2cap_uuid);
2179 +  apseq = sdp_list_append(0, proto[0]);
2180 +
2181 +  sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID);
2182 +  proto[1] = sdp_list_append(0, &rfcomm_uuid);
2183 +  channel = sdp_data_alloc(SDP_UINT8, &u8_hs);
2184 +  proto[1] = sdp_list_append(proto[1], channel);
2185 +  apseq = sdp_list_append(apseq, proto[1]);
2186 +
2187 +  aproto = sdp_list_append(0, apseq);
2188 +  sdp_set_access_protos(&record, aproto);
2189 +  sdp_set_info_attr(&record, "Voice Gateway", 0, 0);
2190 +
2191 +  if (sdp_record_register(session, &record, SDP_RECORD_PERSIST) < 0) {
2192 +    ast_log(LOG_ERROR, "Service Record registration failed\n");
2193 +    ret = -1;
2194 +    goto end;
2195 +  }
2196 +
2197 +  sdp_record_hs = record.handle;
2198 +
2199 +  ast_log(LOG_NOTICE, "HeadsetAudioGateway service registered\n");
2200 +
2201 +end:
2202 +  sdp_data_free(channel);
2203 +  sdp_list_free(proto[0], 0);
2204 +  sdp_list_free(proto[1], 0);
2205 +  sdp_list_free(apseq, 0);
2206 +  sdp_list_free(aproto, 0);
2207 +
2208 +  return ret;
2209 +}
2210 +
2211 +static int
2212 +rfcomm_listen(bdaddr_t * bdaddr, int channel)
2213 +{
2214 +
2215 +  int sock = -1;
2216 +  struct sockaddr_rc loc_addr;
2217 +  int on = 1;
2218 +
2219 +  if ((sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) < 0) {
2220 +    ast_log(LOG_ERROR, "Can't create socket: %s (errno: %d)\n", strerror(errno), errno);
2221 +    return -1;
2222 +  }
2223 +
2224 +  loc_addr.rc_family = AF_BLUETOOTH;
2225 +
2226 +  /* Local Interface Address */
2227 +  bacpy(&loc_addr.rc_bdaddr, bdaddr);
2228 +
2229 +  /* Channel */
2230 +  loc_addr.rc_channel = channel;
2231 +
2232 +  if (bind(sock, (struct sockaddr *)&loc_addr, sizeof(loc_addr)) < 0) {
2233 +    ast_log(LOG_ERROR, "Can't bind socket: %s (errno: %d)\n", strerror(errno), errno);
2234 +    close(sock);
2235 +    return -1;
2236 +  }
2237 +
2238 +  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
2239 +    ast_log(LOG_ERROR, "Set socket SO_REUSEADDR option on failed: errno %d, %s", errno, strerror(errno));
2240 +    close(sock);
2241 +    return -1;
2242 +  }
2243 +
2244 +  if (fcntl(sock, F_SETFL, O_RDWR|O_NONBLOCK) != 0)
2245 +    ast_log(LOG_ERROR, "Can't set RFCOMM socket to NBIO\n");
2246 +
2247 +  if (listen(sock, 10) < 0) {
2248 +    ast_log(LOG_ERROR,"Can not listen on the socket. %s(%d)\n", strerror(errno), errno);
2249 +    close(sock);
2250 +    return -1;
2251 +  }
2252 +
2253 +  ast_log(LOG_NOTICE, "Listening for RFCOMM channel %d connections on FD %d\n", channel, sock);
2254 +
2255 +  return sock;
2256 +}
2257 +
2258 +
2259 +static int
2260 +sco_listen(bdaddr_t * bdaddr)
2261 +{
2262 +  int sock = -1;
2263 +  int on = 1;
2264 +  struct sockaddr_sco loc_addr;
2265 +
2266 +  memset(&loc_addr, 0, sizeof(loc_addr));
2267 +
2268 +  if ((sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) {
2269 +    ast_log(LOG_ERROR, "Can't create SCO socket: %s (errno: %d)\n", strerror(errno), errno);
2270 +    return -1;
2271 +  }
2272 +
2273 +  loc_addr.sco_family = AF_BLUETOOTH;
2274 +  bacpy(&loc_addr.sco_bdaddr, BDADDR_ANY);
2275 +
2276 +  if (bind(sock, (struct sockaddr *)&loc_addr, sizeof(loc_addr)) < 0) {
2277 +    ast_log(LOG_ERROR, "Can't bind SCO socket: %s (errno: %d)\n", strerror(errno), errno);
2278 +    close(sock);
2279 +    return -1;
2280 +  }
2281 +
2282 +  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
2283 +    ast_log(LOG_ERROR, "Set SCO socket SO_REUSEADDR option on failed: errno %d, %s", errno, strerror(errno));
2284 +    close(sock);
2285 +    return -1;
2286 +  }
2287 +
2288 +  if (fcntl(sock, F_SETFL, O_RDWR|O_NONBLOCK) != 0)
2289 +    ast_log(LOG_ERROR, "Can't set SCO socket to NBIO\n");
2290 +
2291 +  if (listen(sock, 10) < 0) {
2292 +    ast_log(LOG_ERROR,"Can not listen on SCO socket: %s(%d)\n", strerror(errno), errno);
2293 +    close(sock);
2294 +    return -1;
2295 +  }
2296 +
2297 +  ast_log(LOG_NOTICE, "Listening for SCO connections on FD %d\n", sock);
2298 +
2299 +  return sock;
2300 +}
2301 +
2302 +static int
2303 +rfcomm_connect(bdaddr_t * src, bdaddr_t * dst, int channel, int nbio)
2304 +{
2305 +  struct sockaddr_rc addr;
2306 +  int s;
2307 +
2308 +  if ((s = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) < 0) {
2309 +    return -1;
2310 +  }
2311 +
2312 +  memset(&addr, 0, sizeof(addr));
2313 +  addr.rc_family = AF_BLUETOOTH;
2314 +  bacpy(&addr.rc_bdaddr, src);
2315 +  addr.rc_channel = 0;
2316 +
2317 +  if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
2318 +    close(s);
2319 +    return -1;
2320 +  }
2321 +
2322 +  memset(&addr, 0, sizeof(addr));
2323 +  addr.rc_family = AF_BLUETOOTH;
2324 +  bacpy(&addr.rc_bdaddr, dst);
2325 +  addr.rc_channel = channel;
2326 +
2327 +  if (nbio) {
2328 +    if (fcntl(s, F_SETFL, O_RDWR|O_NONBLOCK) != 0)
2329 +      ast_log(LOG_ERROR, "Can't set RFCOMM socket to NBIO\n");
2330 +  }
2331 +
2332 +  if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0 && (nbio != 1 || (errno != EAGAIN))) {
2333 +    close(s);
2334 +    return -1;
2335 +  }
2336 +
2337 +  return s;
2338 +}
2339 +
2340 +/* Must be called with dev->lock held */
2341 +
2342 +static int
2343 +sco_connect(blt_dev_t * dev)
2344 +{
2345 +  struct sockaddr_sco addr;
2346 +  // struct sco_conninfo conn;
2347 +  // struct sco_options opts;
2348 +  // int size;
2349 +  // bdaddr_t * src = &local_bdaddr;
2350 +
2351 +  int s;
2352 +  bdaddr_t * dst = &(dev->bdaddr);
2353 +
2354 +  if (dev->sco != -1) {
2355 +    ast_log(LOG_ERROR, "SCO fd already open.\n");
2356 +    return -1;
2357 +  }
2358 +
2359 +  if ((s = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) {
2360 +    ast_log(LOG_ERROR, "Can't create SCO socket(): %s\n", strerror(errno));
2361 +    return -1;
2362 +  }
2363 +
2364 +  memset(&addr, 0, sizeof(addr));
2365 +
2366 +  addr.sco_family = AF_BLUETOOTH;
2367 +  bacpy(&addr.sco_bdaddr, BDADDR_ANY);
2368 +
2369 +  if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
2370 +    ast_log(LOG_ERROR, "Can't bind() SCO socket: %s\n", strerror(errno));
2371 +    close(s);
2372 +    return -1;
2373 +  }
2374 +
2375 +  memset(&addr, 0, sizeof(addr));
2376 +  addr.sco_family = AF_BLUETOOTH;
2377 +  bacpy(&addr.sco_bdaddr, dst);
2378 +
2379 +  if (fcntl(s, F_SETFL, O_RDWR|O_NONBLOCK) != 0)
2380 +    ast_log(LOG_ERROR, "Can't set SCO socket to NBIO\n");
2381 +
2382 +  if ((connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) && (errno != EAGAIN)) {
2383 +    ast_log(LOG_ERROR, "Can't connect() SCO socket: %s (errno %d)\n", strerror(errno), errno);
2384 +    close(s);
2385 +    return -1;
2386 +  }
2387 +
2388 +  //size = sizeof(conn);
2389 +
2390 +
2391 +/* XXX:T: HERE, fix getting SCO conninfo.
2392 +
2393 +  if (getsockopt(s, SOL_SCO, SCO_CONNINFO, &conn, &size) < 0) {
2394 +    ast_log(LOG_ERROR, "Can't getsockopt SCO_CONNINFO on SCO socket: %s\n", strerror(errno));
2395 +    close(s);
2396 +    return -1;
2397 +  }
2398 +
2399 +  size = sizeof(opts);
2400 +
2401 +  if (getsockopt(s, SOL_SCO, SCO_OPTIONS, &opts, &size) < 0) {
2402 +    ast_log(LOG_ERROR, "Can't getsockopt SCO_OPTIONS on SCO socket: %s\n", strerror(errno));
2403 +    close(s);
2404 +    return -1;
2405 +  }
2406 +
2407 +  dev->sco_handle = conn.hci_handle;
2408 +  dev->sco_mtu = opts.mtu;
2409 +
2410 +*/
2411 +
2412 +  ast_log(LOG_DEBUG, "SCO: %d\n", s);
2413 +
2414 +  dev->sco = s;
2415 +
2416 +  return 0;
2417 +}
2418 +
2419 +
2420 +/* ---------------------------------- */
2421 +
2422 +/* Non blocking (async) outgoing bluetooth connection */
2423 +
2424 +static int
2425 +try_connect(blt_dev_t * dev)
2426 +{
2427 +  int fd;
2428 +  ast_mutex_lock(&(dev->lock));
2429 +
2430 +  if (dev->status != BLT_STATUS_CONNECTING && dev->status != BLT_STATUS_DOWN) {
2431 +    ast_mutex_unlock(&(dev->lock));
2432 +    return 0;
2433 +  }
2434 +
2435 +  if (dev->rd != -1) {
2436 +
2437 +    int ret;
2438 +    struct pollfd pfd;
2439 +
2440 +    if (dev->status != BLT_STATUS_CONNECTING) {
2441 +      ast_mutex_unlock(&(dev->lock));
2442 +      dev->outgoing_id = -1;
2443 +      return 0;
2444 +    }
2445 +
2446 +    // ret = connect(dev->rd, (struct sockaddr *)&(dev->addr), sizeof(struct sockaddr_rc)); //
2447 +
2448 +    pfd.fd = dev->rd;
2449 +    pfd.events = POLLIN | POLLOUT;
2450 +
2451 +    ret = poll(&pfd, 1, 0);
2452 +
2453 +    if (ret == -1) {
2454 +      close(dev->rd);
2455 +      dev->rd = -1;
2456 +      dev->status = BLT_STATUS_DOWN;
2457 +      dev->outgoing_id = ast_sched_add(sched, 10000, AST_SCHED_CB(try_connect), dev);
2458 +      ast_mutex_unlock(&(dev->lock));
2459 +      return 0;
2460 +    }
2461 +
2462 +    if (ret > 0) {
2463 +
2464 +      int len = sizeof(ret);
2465 +      getsockopt(dev->rd, SOL_SOCKET, SO_ERROR, &ret, &len);
2466 +
2467 +      if (ret == 0) {
2468 +
2469 +        ast_log(LOG_NOTICE, "Initialised bluetooth link to device %s\n", dev->name);
2470 +
2471 +#if 0
2472 +        {
2473 +          struct hci_conn_info_req * cr;
2474 +          int dd;
2475 +          char name[248];
2476 +
2477 +          cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
2478 +          dd = hci_open_dev(hcidev_id);
2479 +          cr->type = ACL_LINK;
2480 +          bacpy(&cr->bdaddr, &(dev->bdaddr));
2481 +
2482 +          if (ioctl(dd, HCIGETCONNINFO, (unsigned long)cr) < 0) {
2483 +            ast_log(LOG_ERROR, "Failed to get connection info: %s\n", strerror(errno));
2484 +          } else {
2485 +            ast_log(LOG_DEBUG, "HCI Handle: %d\n", cr->conn_info->handle);
2486 +          }
2487 +
2488 +          if (hci_read_remote_name(dd, &(dev->bdaddr), sizeof(name), name, 25000) == 0)
2489 +            ast_log(LOG_DEBUG, "Remote Name: %s\n", name);
2490 +          free(cr);
2491 +        }
2492 +#endif
2493 +
2494 +        dev->status = BLT_STATUS_NEGOTIATING;
2495 +
2496 +        /* If this device is an AG/GUI, we initiate the negotiation. */
2497 +
2498 +        if (dev->role == BLT_ROLE_AG ||
2499 +           dev->role == BLT_ROLE_GUI) {
2500 +          dev->cb = ag_brsf_response;
2501 +          send_atcmd(dev, "AT+BRSF=23");
2502 +        }
2503 +
2504 +        dev->outgoing_id = -1;
2505 +        ast_mutex_unlock(&(dev->lock));
2506 +        return 0;
2507 +
2508 +      } else {
2509 +
2510 +        if (ret != EHOSTDOWN)
2511 +          ast_log(LOG_NOTICE, "Connect to device %s failed: %s (errno %d)\n", dev->name, strerror(ret), ret);
2512 +
2513 +        close(dev->rd);
2514 +        dev->rd = -1;
2515 +        dev->status = BLT_STATUS_DOWN;
2516 +        dev->outgoing_id = ast_sched_add(sched, (ret == EHOSTDOWN) ? 10000 : 2500, AST_SCHED_CB(try_connect), dev);
2517 +        ast_mutex_unlock(&(dev->lock));
2518 +        return 0;
2519 +
2520 +      }
2521 +
2522 +    }
2523 +
2524 +    dev->outgoing_id = ast_sched_add(sched, 100, AST_SCHED_CB(try_connect), dev);
2525 +    ast_mutex_unlock(&(dev->lock));
2526 +    return 0;
2527 +  }
2528 +
2529 +  ast_log(LOG_NOTICE, "RFCOMM connect start.\n");
2530 +  fd = rfcomm_connect(&local_bdaddr, &(dev->bdaddr), dev->channel, 1);
2531 +  ast_log(LOG_NOTICE, "RFCOMM connect done.\n");
2532 +
2533 +  if (fd == -1) {
2534 +    ast_log(LOG_WARNING, "NBIO connect() to %s returned %d: %s\n", dev->name, errno, strerror(errno));
2535 +    dev->outgoing_id = ast_sched_add(sched, 5000, AST_SCHED_CB(try_connect), dev);
2536 +    ast_mutex_unlock(&(dev->lock));
2537 +    return 0;
2538 +  }
2539 +
2540 +  dev->rd = fd;
2541 +  dev->status = BLT_STATUS_CONNECTING;
2542 +  dev->outgoing_id = ast_sched_add(sched, 100, AST_SCHED_CB(try_connect), dev);
2543 +  ast_mutex_unlock(&(dev->lock));
2544 +  return 0;
2545 +}
2546 +
2547 +
2548 +/* Called whenever a new command is received while we're the AG */
2549 +
2550 +
2551 +static int
2552 +process_rfcomm_cmd(blt_dev_t * dev, char * cmd)
2553 +{
2554 +  int i;
2555 +  char * fullcmd = cmd;
2556 +
2557 +  if (option_verbose)
2558 +    ast_verbose(VERBOSE_PREFIX_1 "[%s] %*s > %s\n", role2str(dev->role), 10, dev->name, cmd);
2559 +
2560 +  /* Read the 'AT' from the start of the string */
2561 +  if (strncmp(cmd, "AT", 2)) {
2562 +    ast_log(LOG_WARNING, "Unknown command without 'AT': %s\n", cmd);
2563 +    send_atcmd_error(dev);
2564 +    return 0;
2565 +  }
2566 +
2567 +  cmd += 2;
2568 +
2569 +  // Don't forget 'AT' on its own is OK.
2570 +
2571 +  if (strlen(cmd) == 0) {
2572 +    send_atcmd_ok(dev, fullcmd);
2573 +    return 0;
2574 +  }
2575 +
2576 +  for (i = 0 ; i < ATCMD_LIST_LEN ; i++) {
2577 +    if (strncmp(atcmd_list[i].str, cmd, strlen(atcmd_list[i].str)) == 0) {
2578 +      char * pos = (cmd + strlen(atcmd_list[i].str));
2579 +      if ((strncmp(pos, "=?", 2) == 0) && (strlen(pos) == 2)) {
2580 +        /* TEST command */
2581 +        if (atcmd_list[i].test) {
2582 +          if (atcmd_list[i].test(dev) == 0)
2583 +            send_atcmd_ok(dev, fullcmd);
2584 +          else
2585 +            send_atcmd_error(dev);
2586 +        } else {
2587 +          send_atcmd_ok(dev, fullcmd);
2588 +        }
2589 +      } else if ((strncmp(pos, "?", 1) == 0) && (strlen(pos) == 1)) {
2590 +        /* READ command */
2591 +        if (atcmd_list[i].read) {
2592 +          if (atcmd_list[i].read(dev) == 0)
2593 +            send_atcmd_ok(dev, fullcmd);
2594 +          else
2595 +            send_atcmd_error(dev);
2596 +        } else {
2597 +          ast_log(LOG_WARNING, "AT Command: '%s' missing READ function\n", fullcmd);
2598 +          send_atcmd_error(dev);
2599 +        }
2600 +      } else if (strncmp(pos, "=", 1) == 0) {
2601 +        /* SET command */
2602 +        if (atcmd_list[i].set) {
2603 +          if (atcmd_list[i].set(dev, (pos + 1), (*(pos + 1)) ? strlen(pos + 1) : 0) == 0)
2604 +            send_atcmd_ok(dev, fullcmd);
2605 +          else
2606 +            send_atcmd_error(dev);
2607 +        } else {
2608 +          ast_log(LOG_WARNING, "AT Command: '%s' missing SET function\n", fullcmd);
2609 +          send_atcmd_error(dev);
2610 +        }
2611 +      } else {
2612 +        /* EXECUTE command */
2613 +        if (atcmd_list[i].execute) {
2614 +          if (atcmd_list[i].execute(dev, cmd + strlen(atcmd_list[i].str)) == 0)
2615 +            send_atcmd_ok(dev, fullcmd);
2616 +          else
2617 +            send_atcmd_error(dev);
2618 +        } else {
2619 +          ast_log(LOG_WARNING, "AT Command: '%s' missing EXECUTE function\n", fullcmd);
2620 +          send_atcmd_error(dev);
2621 +        }
2622 +      }
2623 +      return 0;
2624 +    }
2625 +  }
2626 +
2627 +  ast_log(LOG_NOTICE, "Unknown AT Command: '%s' (%s)\n", fullcmd, cmd);
2628 +  send_atcmd_error(dev);
2629 +
2630 +  return 0;
2631 +}
2632 +
2633 +/* Called when a socket is incoming */
2634 +
2635 +static void
2636 +handle_incoming(int fd, blt_role_t role)
2637 +{
2638 +  blt_dev_t * dev;
2639 +  struct sockaddr_rc addr;
2640 +  int len = sizeof(addr);
2641 +
2642 +  // Got a new incoming socket.
2643 +  ast_log(LOG_DEBUG, "Incoming RFCOMM socket\n");
2644 +
2645 +  ast_mutex_lock(&iface_lock);
2646 +
2647 +  fd = accept(fd, (struct sockaddr*)&addr, &len);
2648 +
2649 +  dev = iface_head;
2650 +  while (dev) {
2651 +    if (bacmp(&(dev->bdaddr), &addr.rc_bdaddr) == 0) {
2652 +      ast_log(LOG_DEBUG, "Connect from %s\n", dev->name);
2653 +      ast_mutex_lock(&(dev->lock));
2654 +      /* Kill any outstanding connect attempt. */
2655 +      if (dev->outgoing_id > -1) {
2656 +        ast_sched_del(sched, dev->outgoing_id);
2657 +        dev->outgoing_id = -1;
2658 +      }
2659 +
2660 +      rd_close(dev, 0, 0);
2661 +
2662 +      dev->status = BLT_STATUS_NEGOTIATING;
2663 +      dev->rd = fd;
2664 +
2665 +      if (dev->role == BLT_ROLE_AG ||
2666 +         dev->role == BLT_ROLE_GUI) {
2667 +        dev->cb = ag_brsf_response;
2668 +        send_atcmd(dev, "AT+BRSF=23");
2669 +      }
2670 +      ast_mutex_unlock(&(dev->lock));
2671 +      break;
2672 +    }
2673 +    dev = dev->next;
2674 +  }
2675 +
2676 +  if (dev == NULL) {
2677 +    ast_log(LOG_WARNING, "Connect from unknown device\n");
2678 +    close(fd);
2679 +  }
2680 +  ast_mutex_unlock(&iface_lock);
2681 +
2682 +  return;
2683 +}
2684 +
2685 +static void
2686 +handle_incoming_sco(int master)
2687 +{
2688 +
2689 +  blt_dev_t * dev;
2690 +  struct sockaddr_sco addr;
2691 +  struct sco_conninfo conn;
2692 +  struct sco_options opts;
2693 +  int len = sizeof(addr);
2694 +  int fd;
2695 +
2696 +  ast_log(LOG_DEBUG, "Incoming SCO socket\n");
2697 +
2698 +  fd = accept(master, (struct sockaddr*)&addr, &len);
2699 +
2700 +  if (fcntl(fd, F_SETFL, O_RDWR|O_NONBLOCK) != 0) {
2701 +    ast_log(LOG_ERROR, "Can't set SCO socket to NBIO\n");
2702 +    close(fd);
2703 +    return;
2704 +  }
2705 +
2706 +  len = sizeof(conn);
2707 +
2708 +  if (getsockopt(fd, SOL_SCO, SCO_CONNINFO, &conn, &len) < 0) {
2709 +    ast_log(LOG_ERROR, "Can't getsockopt SCO_CONNINFO on SCO socket: %s\n", strerror(errno));
2710 +    close(fd);
2711 +    return;
2712 +  }
2713 +
2714 +  len = sizeof(opts);
2715 +
2716 +  if (getsockopt(fd, SOL_SCO, SCO_OPTIONS, &opts, &len) < 0) {
2717 +    ast_log(LOG_ERROR, "Can't getsockopt SCO_OPTIONS on SCO socket: %s\n", strerror(errno));
2718 +    close(fd);
2719 +    return;
2720 +  }
2721 +
2722 +  ast_mutex_lock(&iface_lock);
2723 +  dev = iface_head;
2724 +  while (dev) {
2725 +    if (bacmp(&(dev->bdaddr), &addr.sco_bdaddr) == 0) {
2726 +      ast_log(LOG_DEBUG, "SCO Connect from %s\n", dev->name);
2727 +      ast_mutex_lock(&(dev->lock));
2728 +      if (dev->sco_running != -1) {
2729 +        ast_log(LOG_ERROR, "Incoming SCO socket, but SCO thread already running.\n");
2730 +      } else {
2731 +        sco_start(dev, fd);
2732 +      }
2733 +      ast_mutex_unlock(&(dev->lock));
2734 +      break;
2735 +    }
2736 +    dev = dev->next;
2737 +  }
2738 +
2739 +  ast_mutex_unlock(&iface_lock);
2740 +
2741 +  if (dev == NULL) {
2742 +    ast_log(LOG_WARNING, "SCO Connect from unknown device\n");
2743 +    close(fd);
2744 +  } else {
2745 +    // XXX:T: We need to handle the fact we might have an outgoing connection attempt in progress.
2746 +    ast_log(LOG_DEBUG, "SCO: %d, HCIHandle=%d, MUT=%d\n", fd, conn.hci_handle, opts.mtu);
2747 +  }
2748 +
2749 +
2750 +
2751 +  return;
2752 +}
2753 +
2754 +/* Called when there is data waiting on a socket */
2755 +
2756 +static int
2757 +handle_rd_data(blt_dev_t * dev)
2758 +{
2759 +  char c;
2760 +  int ret;
2761 +
2762 +  while ((ret = read(dev->rd, &c, 1)) == 1) {
2763 +
2764 +    // log_buf[i++] = c;
2765 +
2766 +    if (dev->role == BLT_ROLE_HS) {
2767 +
2768 +      if (c == '\r') {
2769 +        ret = process_rfcomm_cmd(dev, dev->rd_buff);
2770 +        dev->rd_buff_pos = 0;
2771 +        memset(dev->rd_buff, 0, BLT_RDBUFF_MAX);
2772 +        return ret;
2773 +      }
2774 +
2775 +      if (dev->rd_buff_pos >= BLT_RDBUFF_MAX)
2776 +        return 0;
2777 +
2778 +      dev->rd_buff[dev->rd_buff_pos++] = c;
2779 +
2780 +    } else if (dev->role == BLT_ROLE_AG ||
2781 +              dev->role == BLT_ROLE_GUI) {
2782 +
2783 +      //ast_log(LOG_ERROR, "%s: %c\n", dev->name, c);
2784 +
2785 +      switch (dev->state) {
2786 +        case BLT_STATE_WANT_R:
2787 +          if (c == '\r' || c == 10) {
2788 +            dev->state = BLT_STATE_WANT_N;
2789 +          } else if (c == '+') {
2790 +            dev->state = BLT_STATE_WANT_CMD;
2791 +            dev->rd_buff[dev->rd_buff_pos++] = '+';
2792 +          } else {
2793 +            ast_log(LOG_ERROR, "Device %s: Expected '\\r', got %d. state=BLT_STATE_WANT_R\n", dev->name, c);
2794 +            return -1;
2795 +          }
2796 +          break;
2797 +
2798 +        case BLT_STATE_WANT_N:
2799 +          if (c == '\n' || c == 13)
2800 +            dev->state = BLT_STATE_WANT_CMD;
2801 +          else {
2802 +            ast_log(LOG_ERROR, "Device %s: Expected '\\n', got %d. state=BLT_STATE_WANT_N\n", dev->name, c);
2803 +            return -1;
2804 +          }
2805 +          break;
2806 +
2807 +        case BLT_STATE_WANT_CMD:
2808 +          if (c == '\r' || c == 10)
2809 +            dev->state = BLT_STATE_WANT_N2;
2810 +          else {
2811 +            if (dev->rd_buff_pos >= BLT_RDBUFF_MAX) {
2812 +              ast_log(LOG_ERROR, "Device %s: Buffer exceeded\n", dev->name);
2813 +              return -1;
2814 +            }
2815 +            dev->rd_buff[dev->rd_buff_pos++] = c;
2816 +          }
2817 +          break;
2818 +
2819 +        case BLT_STATE_WANT_N2:
2820 +          if (c == '\n' || c == 13) {
2821 +
2822 +            dev->state = BLT_STATE_WANT_R;
2823 +
2824 +            if (dev->rd_buff[0] == '+') {
2825 +              int i;
2826 +              // find unsolicited
2827 +              for (i = 0 ; i < ATCMD_LIST_LEN ; i++) {
2828 +                if (strncmp(atcmd_list[i].str, dev->rd_buff, strlen(atcmd_list[i].str)) == 0) {
2829 +                  if (atcmd_list[i].unsolicited)
2830 +                    atcmd_list[i].unsolicited(dev, dev->rd_buff + strlen(atcmd_list[i].str) + 1);
2831 +                  else
2832 +                    ast_log(LOG_WARNING, "Device %s: Unhandled Unsolicited: %s\n", dev->name, dev->rd_buff);
2833 +                  break;
2834 +                }
2835 +              }
2836 +
2837 +             if (option_verbose)
2838 +                ast_verbose(VERBOSE_PREFIX_1 "[%s] %*s > %s\n", role2str(dev->role), 10, dev->name, dev->rd_buff);
2839 +
2840 +              if (i == ATCMD_LIST_LEN)
2841 +                ast_log(LOG_NOTICE, "Device %s: Got unsolicited message: %s\n", dev->name, dev->rd_buff);
2842 +
2843 +           } else if (dev->rd_buff[0] == '*') {
2844 +             if (option_verbose)
2845 +               ast_verbose(VERBOSE_PREFIX_1 "[%s]* %*s > %s\n", role2str(dev->role), 9, dev->name, dev->rd_buff);
2846 +
2847 +              int i;
2848 +              // find execute
2849 +              for (i = 0 ; i < ATCMD_LIST_LEN ; i++) {
2850 +                if (strncmp(atcmd_list[i].str, dev->rd_buff, strlen(atcmd_list[i].str)) == 0) {
2851 +                  if (atcmd_list[i].execute)
2852 +                    atcmd_list[i].execute(dev, dev->rd_buff + strlen(atcmd_list[i].str) + 1);
2853 +                  else
2854 +                    ast_log(LOG_ERROR, "Device %s: Unhandled Execute: %s\n", dev->name, dev->rd_buff);
2855 +                  break;
2856 +                }
2857 +              }
2858 +
2859 +
2860 +            } else {
2861 +
2862 +              if (
2863 +                strcmp(dev->rd_buff, "OK") != 0 &&
2864 +                strcmp(dev->rd_buff, "CONNECT") != 0 &&
2865 +                strcmp(dev->rd_buff, "RING") != 0 &&
2866 +                strcmp(dev->rd_buff, "NO CARRIER") != 0 &&
2867 +                strcmp(dev->rd_buff, "ERROR") != 0 &&
2868 +                strcmp(dev->rd_buff, "NO DIALTONE") != 0 &&
2869 +                strcmp(dev->rd_buff, "BUSY") != 0 &&
2870 +                strcmp(dev->rd_buff, "NO ANSWER") != 0 &&
2871 +                strcmp(dev->rd_buff, "DELAYED") != 0
2872 +              ){
2873 +                // It must be a multiline error
2874 +                strncpy(dev->last_err_cmd, dev->rd_buff, 1023);
2875 +                if (option_verbose)
2876 +                  ast_verbose(VERBOSE_PREFIX_1 "[%s] %*s > %s\n", role2str(dev->role), 10, dev->name, dev->rd_buff);
2877 +              } else if (dev->cb) {
2878 +                if (option_verbose)
2879 +                  ast_verbose(VERBOSE_PREFIX_1 "[%s] %*s > %s\n", role2str(dev->role), 10, dev->name, dev->rd_buff);
2880 +                dev->cb(dev, dev->rd_buff);
2881 +              } else {
2882 +                ast_log(LOG_ERROR, "Device %s: Data on socket in HS mode, but no callback\n", dev->name);
2883 +              }
2884 +
2885 +            }
2886 +
2887 +            dev->rd_buff_pos = 0;
2888 +            memset(dev->rd_buff, 0, BLT_RDBUFF_MAX);
2889 +          } else {
2890 +
2891 +            ast_log(LOG_ERROR, "Device %s: Expected '\\n' got %d. state = BLT_STATE_WANT_N2:\n", dev->name, c);
2892 +            return -1;
2893 +
2894 +          }
2895 +
2896 +          break;
2897 +
2898 +        default:
2899 +          ast_log(LOG_ERROR, "Device %s: Unknown device state %d\n", dev->name, dev->state);
2900 +          return -1;
2901 +
2902 +      }
2903 +
2904 +    }
2905 +
2906 +  }
2907 +
2908 +  return 0;
2909 +}
2910 +
2911 +/* Close the devices RFCOMM socket, and SCO if it exists. Must hold dev->lock */
2912 +
2913 +static void
2914 +rd_close(blt_dev_t * dev, int reconnect, int e)
2915 +{
2916 +  dev->ready = 0;
2917 +
2918 +  if (dev->rd)
2919 +    close(dev->rd);
2920 +
2921 +  dev->rd = -1;
2922 +
2923 +  dev->status = BLT_STATUS_DOWN;
2924 +
2925 +  sco_stop(dev);
2926 +
2927 +  if (dev->owner) {
2928 +    ast_setstate(dev->owner, AST_STATE_DOWN);
2929 +    ast_queue_control(dev->owner, AST_CONTROL_HANGUP);
2930 +  }
2931 +
2932 +  /* Schedule a reconnect */
2933 +  if (reconnect && dev->autoconnect) {
2934 +    dev->outgoing_id = ast_sched_add(sched, 5000, AST_SCHED_CB(try_connect), dev);
2935 +
2936 +    if (monitor_thread == pthread_self()) {
2937 +      // Because we're not the monitor thread, we needd to inturrupt poll().
2938 +      pthread_kill(monitor_thread, SIGURG);
2939 +    }
2940 +
2941 +    if (e)
2942 +      ast_log(LOG_NOTICE, "Device %s disconnected, scheduled reconnect in 5 seconds: %s (errno %d)\n", dev->name, strerror(e), e);
2943 +  } else if (e) {
2944 +    ast_log(LOG_NOTICE, "Device %s disconnected: %s (errno %d)\n", dev->name, strerror(e), e);
2945 +  }
2946 +
2947 +  return;
2948 +}
2949 +
2950 +/*
2951 + * Remember that we can only add to the scheduler from
2952 + * the do_monitor thread, as it calculates time to next one from
2953 + * this loop.
2954 + */
2955 +
2956 +static void *
2957 +do_monitor(void * data)
2958 +{
2959 +#define SRV_SOCK_CNT 4
2960 +
2961 +  int res = 0;
2962 +  blt_dev_t * dev;
2963 +  struct pollfd * pfds = malloc(sizeof(struct pollfd) * (ifcount + SRV_SOCK_CNT));
2964 +
2965 +  /* -- We start off by trying to connect all of our devices (non blocking) -- */
2966 +
2967 +  monitor_pid = getpid();
2968 +
2969 +  if (ast_mutex_lock(&iface_lock)) {
2970 +    ast_log(LOG_ERROR, "Failed to get iface_lock.\n");
2971 +    return NULL;
2972 +  }
2973 +
2974 +  dev = iface_head;
2975 +  while (dev) {
2976 +
2977 +    if (socketpair(PF_UNIX, SOCK_STREAM, 0, dev->sco_pipe) != 0) {
2978 +      ast_log(LOG_ERROR, "Failed to create socket pair: %s (errno %d)\n", strerror(errno), errno);
2979 +      ast_mutex_unlock(&iface_lock);
2980 +      return NULL;
2981 +    }
2982 +
2983 +    if (dev->autoconnect && dev->status == BLT_STATUS_DOWN)
2984 +      dev->outgoing_id = ast_sched_add(sched, 1500, AST_SCHED_CB(try_connect), dev);
2985 +    dev = dev->next;
2986 +  }
2987 +  ast_mutex_unlock(&iface_lock);
2988 +
2989 +  /* -- Now, Scan all sockets, and service scheduler -- */
2990 +
2991 +  pfds[0].fd = rfcomm_sock_ag;
2992 +  pfds[0].events = POLLIN;
2993 +
2994 +  pfds[1].fd = rfcomm_sock_hs;
2995 +  pfds[1].events = POLLIN;
2996 +
2997 +  pfds[2].fd = rfcomm_sock_gui;
2998 +  pfds[2].events = POLLIN;
2999 +
3000 +  pfds[3].fd = sco_socket;
3001 +  pfds[3].events = POLLIN;
3002 +
3003 +  while (1) {
3004 +    int cnt = SRV_SOCK_CNT;
3005 +    int i;
3006 +
3007 +    /* -- Build pfds -- */
3008 +
3009 +    if (ast_mutex_lock(&iface_lock)) {
3010 +      ast_log(LOG_ERROR, "Failed to get iface_lock.\n");
3011 +      return NULL;
3012 +    }
3013 +    dev = iface_head;
3014 +    while (dev) {
3015 +      ast_mutex_lock(&(dev->lock));
3016 +      if (dev->rd > 0 && ((dev->status != BLT_STATUS_DOWN) && (dev->status != BLT_STATUS_CONNECTING))) {
3017 +        pfds[cnt].fd = dev->rd;
3018 +        pfds[cnt].events = POLLIN;
3019 +        cnt++;
3020 +      }
3021 +      ast_mutex_unlock(&(dev->lock));
3022 +      dev = dev->next;
3023 +    }
3024 +    ast_mutex_unlock(&iface_lock);
3025 +
3026 +    /* -- End Build pfds -- */
3027 +
3028 +    res = ast_sched_wait(sched);
3029 +    res = poll(pfds, cnt, MAX(100, MIN(100, res)));
3030 +
3031 +    if (res == 0)
3032 +      ast_sched_runq(sched);
3033 +
3034 +    if (pfds[0].revents) {
3035 +      handle_incoming(rfcomm_sock_ag, BLT_ROLE_AG);
3036 +      res--;
3037 +    }
3038 +
3039 +    if (pfds[1].revents) {
3040 +      handle_incoming(rfcomm_sock_hs, BLT_ROLE_HS);
3041 +      res--;
3042 +    }
3043 +
3044 +    if (pfds[2].revents) {
3045 +      handle_incoming(rfcomm_sock_gui, BLT_ROLE_GUI);
3046 +      res--;
3047 +    }
3048 +
3049 +    if (pfds[3].revents) {
3050 +      handle_incoming_sco(sco_socket);
3051 +      res--;
3052 +    }
3053 +
3054 +    if (res == 0)
3055 +      continue;
3056 +
3057 +    for (i = SRV_SOCK_CNT ; i < cnt ; i++) {
3058 +
3059 +      /* Optimise a little bit */
3060 +      if (res == 0)
3061 +        break;
3062 +      else if (pfds[i].revents == 0)
3063 +        continue;
3064 +
3065 +      /* -- Find the socket that has activity -- */
3066 +
3067 +      if (ast_mutex_lock(&iface_lock)) {
3068 +        ast_log(LOG_ERROR, "Failed to get iface_lock.\n");
3069 +        return NULL;
3070 +      }
3071 +
3072 +      dev = iface_head;
3073 +
3074 +      while (dev) {
3075 +        if (pfds[i].fd == dev->rd) {
3076 +          ast_mutex_lock(&(dev->lock));
3077 +          if (pfds[i].revents & POLLIN) {
3078 +            if (handle_rd_data(dev) == -1) {
3079 +              rd_close(dev, 0, 0);
3080 +            }
3081 +          } else {
3082 +            rd_close(dev, 1, sock_err(dev->rd));
3083 +          }
3084 +          ast_mutex_unlock(&(dev->lock));
3085 +          res--;
3086 +          break;
3087 +        }
3088 +        dev = dev->next;
3089 +      }
3090 +
3091 +      if (dev == NULL) {
3092 +        ast_log(LOG_ERROR, "Unhandled fd from poll()\n");
3093 +        close(pfds[i].fd);
3094 +      }
3095 +
3096 +      ast_mutex_unlock(&iface_lock);
3097 +
3098 +      /* -- End find socket with activity -- */
3099 +
3100 +    }
3101 +
3102 +  }
3103 +
3104 +  return NULL;
3105 +}
3106 +
3107 +static int
3108 +restart_monitor(void)
3109 +{
3110 +
3111 +  if (monitor_thread == AST_PTHREADT_STOP)
3112 +    return 0;
3113 +
3114 +  if (ast_mutex_lock(&monitor_lock)) {
3115 +    ast_log(LOG_WARNING, "Unable to lock monitor\n");
3116 +    return -1;
3117 +  }
3118 +
3119 +  if (monitor_thread == pthread_self()) {
3120 +    ast_mutex_unlock(&monitor_lock);
3121 +    ast_log(LOG_WARNING, "Cannot kill myself\n");
3122 +    return -1;
3123 +  }
3124 +
3125 +  if (monitor_thread != AST_PTHREADT_NULL) {
3126 +
3127 +    /* Just signal it to be sure it wakes up */
3128 +    pthread_cancel(monitor_thread);
3129 +    pthread_kill(monitor_thread, SIGURG);
3130 +    ast_log(LOG_DEBUG, "Waiting for monitor thread to join...\n");
3131 +    pthread_join(monitor_thread, NULL);
3132 +    ast_log(LOG_DEBUG, "joined\n");
3133 +
3134 +  } else {
3135 +
3136 +    /* Start a new monitor */
3137 +    if (ast_pthread_create(&monitor_thread, NULL, do_monitor, NULL) < 0) {
3138 +      ast_mutex_unlock(&monitor_lock);
3139 +      ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
3140 +      return -1;
3141 +    }
3142 +
3143 +  }
3144 +
3145 +  ast_mutex_unlock(&monitor_lock);
3146 +  return 0;
3147 +}
3148 +
3149 +static int
3150 +blt_parse_config(void)
3151 +{
3152 +  struct ast_config * cfg;
3153 +  struct ast_variable * v;
3154 +  char * cat;
3155 +
3156 +  cfg = ast_load(BLT_CONFIG_FILE);
3157 +
3158 +  if (!cfg) {
3159 +    ast_log(LOG_NOTICE, "Unable to load Bluetooth config: %s.  Bluetooth disabled\n", BLT_CONFIG_FILE);
3160 +    return -1;
3161 +  }
3162 +
3163 +  v = ast_variable_browse(cfg, "general");
3164 +
3165 +  while (v) {
3166 +    if (!strcasecmp(v->name, "rfchannel_ag")) {
3167 +      rfcomm_channel_ag = atoi(v->value);
3168 +    } else if (!strcasecmp(v->name, "rfchannel_hs")) {
3169 +      rfcomm_channel_hs = atoi(v->value);
3170 +    } else if (!strcasecmp(v->name, "rfchannel_gui")) {
3171 +      rfcomm_channel_gui = atoi(v->value);
3172 +    } else if (!strcasecmp(v->name, "interface")) {
3173 +      hcidev_id = atoi(v->value);
3174 +    } else if (!strcasecmp(v->name, "gui_default_sip_number")) {
3175 +      gui_default_sip_number = v->value;
3176 +    } else if (!strcasecmp(v->name, "gui_default_sip_address")) {
3177 +      gui_default_sip_address = v->value;
3178 +    } else {
3179 +      ast_log(LOG_WARNING, "Unknown config key '%s' in section [general]\n", v->name);
3180 +    }
3181 +    v = v->next;
3182 +  }
3183 +  cat = ast_category_browse(cfg, NULL);
3184 +
3185 +  while(cat) {
3186 +
3187 +    char * str;
3188 +
3189 +    if (strcasecmp(cat, "general")) {
3190 +      blt_dev_t * device = malloc(sizeof(blt_dev_t));
3191 +      memset(device, 0, sizeof(blt_dev_t));
3192 +      device->sco_running = -1;
3193 +      device->sco = -1;
3194 +      device->rd = -1;
3195 +      device->outgoing_id = -1;
3196 +      device->status = BLT_STATUS_DOWN;
3197 +      str2ba(cat, &(device->bdaddr));
3198 +      device->name = ast_variable_retrieve(cfg, cat, "name");
3199 +
3200 +      str = ast_variable_retrieve(cfg, cat, "type");
3201 +
3202 +      if (str == NULL) {
3203 +        ast_log(LOG_ERROR, "Device [%s] has no role.  Specify type=<HS/AG>\n", cat);
3204 +        return -1;
3205 +      } else if (strcasecmp(str, "HS") == 0) {
3206 +        device->role = BLT_ROLE_HS;
3207 +      } else if (strcasecmp(str, "AG") == 0) {
3208 +        device->role = BLT_ROLE_AG;
3209 +      } else if (strcasecmp(str, "GUI") == 0) {
3210 +        device->role = BLT_ROLE_GUI;
3211 +      } else {
3212 +        ast_log(LOG_ERROR, "Device [%s] has invalid role '%s'\n", cat, str);
3213 +        return -1;
3214 +      }
3215 +
3216 +      /* XXX:T: Find channel to use using SDP.
3217 +       *        However, this needs to be non blocking, and I can't see
3218 +       *        anything in sdp_lib.h that will allow non blocking calls.
3219 +       */
3220 +
3221 +      device->channel = 1;
3222 +
3223 +      if ((str = ast_variable_retrieve(cfg, cat, "channel")) != NULL)
3224 +        device->channel = atoi(str);
3225 +
3226 +      if ((str = ast_variable_retrieve(cfg, cat, "autoconnect")) != NULL)
3227 +        device->autoconnect = (strcasecmp(str, "yes") == 0 || strcmp(str, "1") == 0) ? 1 : 0;
3228 +
3229 +      if ((str = ast_variable_retrieve(cfg, cat, "context")) != NULL)
3230 +       device->context = str;
3231 +      else
3232 +       device->context = "bluetooth";
3233 +
3234 +      device->next = iface_head;
3235 +      iface_head = device;
3236 +      ifcount++;
3237 +    }
3238 +
3239 +    cat = ast_category_browse(cfg, cat);
3240 +  }
3241 +  return 0;
3242 +}
3243 +
3244 +
3245 +static int
3246 +blt_show_peers(int fd, int argc, char *argv[])
3247 +{
3248 +  blt_dev_t * dev;
3249 +
3250 +  if (ast_mutex_lock(&iface_lock)) {
3251 +    ast_log(LOG_ERROR, "Failed to get Iface lock\n");
3252 +    ast_cli(fd, "Failed to get iface lock\n");
3253 +    return RESULT_FAILURE;
3254 +  }
3255 +
3256 +  dev = iface_head;
3257 +
3258 +  ast_cli(fd, "BDAddr            Name       Role Status      A/C SCOCon/Fd/Th Sig\n");
3259 +  ast_cli(fd, "----------------- ---------- ---- ----------- --- ------------ ---\n");
3260 +
3261 +  while (dev) {
3262 +    char b1[18];
3263 +    ba2str(&(dev->bdaddr), b1);
3264 +    ast_cli(fd, "%s %-10s %-4s %-11s %-3s %2d/%02d/%-6ld %s\n",
3265 +           b1, dev->name,
3266 +//         (dev->role == BLT_ROLE_HS) ? "HS" : "AG",
3267 +           (dev->role == BLT_ROLE_HS) ? "HS" :  (dev->role == BLT_ROLE_AG) ? "AG" : "GUI",
3268 +           status2str(dev->status),
3269 +           (dev->autoconnect) ? "Yes" : "No",
3270 +           dev->sco_running,
3271 +           dev->sco,
3272 +           dev->sco_thread,
3273 +           (dev->role == BLT_ROLE_AG) ? (dev->service) ? "Yes" : "No" : "N/A"
3274 +            );
3275 +    dev = dev->next;
3276 +  }
3277 +
3278 +  ast_mutex_unlock(&iface_lock);
3279 +  return RESULT_SUCCESS;
3280 +}
3281 +
3282 +static int
3283 +blt_show_information(int fd, int argc, char *argv[])
3284 +{
3285 +  char b1[18];
3286 +  ba2str(&local_bdaddr, b1);
3287 +  ast_cli(fd, "-------------------------------------------\n");
3288 +  ast_cli(fd, "       Version  : %s\n", BLT_SVN_REVISION);
3289 +  ast_cli(fd, "   Monitor PID  : %d\n", monitor_pid);
3290 +  ast_cli(fd, "     RFCOMM AG  : Channel %d, FD %d\n", rfcomm_channel_ag, rfcomm_sock_ag);
3291 +  ast_cli(fd, "     RFCOMM HS  : Channel %d, FD %d\n", rfcomm_channel_hs, rfcomm_sock_hs);
3292 +  ast_cli(fd, "     RFCOMM GUI : Channel %d, FD %d\n", rfcomm_channel_gui, rfcomm_sock_gui);
3293 +  ast_cli(fd, "        Device  : hci%d, MAC Address %s\n", hcidev_id, b1);
3294 +  ast_cli(fd, "-------------------------------------------\n");
3295 +  return RESULT_SUCCESS;
3296 +}
3297 +
3298 +static int
3299 +blt_ag_sendcmd(int fd, int argc, char *argv[])
3300 +{
3301 +  blt_dev_t * dev;
3302 +
3303 +  if (argc != 4)
3304 +    return RESULT_SHOWUSAGE;
3305 +
3306 +  ast_mutex_lock(&iface_lock);
3307 +  dev = iface_head;
3308 +  while (dev) {
3309 +    if (!strcasecmp(argv[2], dev->name))
3310 +      break;
3311 +    dev = dev->next;
3312 +  }
3313 +  ast_mutex_unlock(&iface_lock);
3314 +
3315 +  if (!dev) {
3316 +    ast_cli(fd, "Device '%s' does not exist\n", argv[2]);
3317 +    return RESULT_FAILURE;
3318 +  }
3319 +
3320 +  if ((dev->role != BLT_ROLE_AG) && (dev->role != BLT_ROLE_GUI)) {
3321 +    ast_cli(fd, "Device '%s' is not an AG or GUI\n", argv[2]);
3322 +    return RESULT_FAILURE;
3323 +  }
3324 +
3325 +  if (dev->status == BLT_STATUS_DOWN || dev->status == BLT_STATUS_NEGOTIATING) {
3326 +    ast_cli(fd, "Device '%s' is not connected\n", argv[2]);
3327 +    return RESULT_FAILURE;
3328 +  }
3329 +
3330 +  if (*(argv[3] + strlen(argv[3]) - 1) == '.')
3331 +    *(argv[3] + strlen(argv[3]) - 1) = '?';
3332 +
3333 +  ast_cli(fd, "Sending AT command to %s: %s\n", dev->name, argv[3]);
3334 +
3335 +  ast_mutex_lock(&(dev->lock));
3336 +  send_atcmd(dev, argv[3]);
3337 +  ast_mutex_unlock(&(dev->lock));
3338 +
3339 +  return RESULT_SUCCESS;
3340 +}
3341 +
3342 +static char *
3343 +complete_device(char * line, char * word, int pos, int state, int rpos, blt_role_t role)
3344 +{
3345 +  blt_dev_t * dev;
3346 +  int which = 0;
3347 +  char *ret;
3348 +
3349 +  if (pos != rpos)
3350 +    return NULL;
3351 +
3352 +  ast_mutex_lock(&iface_lock);
3353 +
3354 +  dev = iface_head;
3355 +
3356 +  while (dev) {
3357 +
3358 +    if ((dev->role == role) && (!strncasecmp(word, dev->name, strlen(word)))) {
3359 +      if (++which > state)
3360 +        break;
3361 +    }
3362 +
3363 +    dev = dev->next;
3364 +  }
3365 +
3366 +  if (dev)
3367 +    ret = strdup(dev->name);
3368 +  else
3369 +    ret = NULL;
3370 +
3371 +  ast_mutex_unlock(&iface_lock);
3372 +
3373 +  return ret;
3374 +}
3375 +
3376 +static char *
3377 +complete_device_2_ag_gui(char * line, char * word, int pos, int state)
3378 +{
3379 +  return complete_device(line, word, pos, state, 2, BLT_ROLE_AG);
3380 +}
3381 +
3382 +static char show_peers_usage[] =
3383 +"Usage: bluetooth show peers\n"
3384 +"       List all bluetooth peers and their status\n";
3385 +
3386 +static struct ast_cli_entry
3387 +cli_show_peers =
3388 +    { { "bluetooth", "show", "peers", NULL }, blt_show_peers, "List Bluetooth Peers", show_peers_usage };
3389 +
3390 +
3391 +static char ag_sendcmd[] =
3392 +"Usage: bluetooth <device> sendcmd <cmd>\n"
3393 +"       Sends a AT cmd over the RFCOMM link, and print result (AG only)\n";
3394 +
3395 +static struct ast_cli_entry
3396 +cli_ag_sendcmd =
3397 +    { { "bluetooth", "sendcmd", NULL }, blt_ag_sendcmd, "Send AG/GUI an AT command", ag_sendcmd, complete_device_2_ag_gui };
3398 +
3399 +static char show_information[] =
3400 +"Usage: bluetooth show information\n"
3401 +"       Lists information about the bluetooth subsystem\n";
3402 +
3403 +static struct ast_cli_entry
3404 +cli_show_information =
3405 +    { { "bluetooth", "show", "information", NULL }, blt_show_information, "List Bluetooth Info", show_information };
3406 +
3407 +void
3408 +remove_sdp_records(void)
3409 +{
3410 +
3411 +  sdp_session_t * sdp;
3412 +  sdp_list_t * attr;
3413 +  sdp_record_t * rec;
3414 +  int res = -1;
3415 +  uint32_t range = 0x0000ffff;
3416 +
3417 +  if (sdp_record_ag == -1 || sdp_record_gui == -1 || sdp_record_hs == -1)
3418 +    return;
3419 +
3420 +  ast_log(LOG_DEBUG, "Removing SDP records\n");
3421 +
3422 +  sdp = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
3423 +
3424 +  if (!sdp)
3425 +    return;
3426 +
3427 +  attr = sdp_list_append(0, &range);
3428 +  rec = sdp_service_attr_req(sdp, sdp_record_ag, SDP_ATTR_REQ_RANGE, attr);
3429 +  sdp_list_free(attr, 0);
3430 +
3431 +  if (rec)
3432 +    if (sdp_record_unregister(sdp, rec) == 0)
3433 +      res = 0;
3434 +
3435 +  rec = sdp_service_attr_req(sdp, sdp_record_gui, SDP_ATTR_REQ_RANGE, attr);
3436 +  sdp_list_free(attr, 0);
3437 +
3438 +  if (rec)
3439 +    if (sdp_record_unregister(sdp, rec) == 0)
3440 +      res = 0;
3441 +
3442 +  attr = sdp_list_append(0, &range);
3443 +  rec = sdp_service_attr_req(sdp, sdp_record_hs, SDP_ATTR_REQ_RANGE, attr);
3444 +  sdp_list_free(attr, 0);
3445 +
3446 +  if (rec)
3447 +    if (sdp_record_unregister(sdp, rec) == 0)
3448 +      res = 0;
3449 +
3450 +  sdp_close(sdp);
3451 +
3452 +  if (res == 0)
3453 +    ast_log(LOG_NOTICE, "Removed SDP records\n");
3454 +  else
3455 +    ast_log(LOG_ERROR, "Failed to remove SDP records\n");
3456 +
3457 +}
3458 +
3459 +static int
3460 +__unload_module(void)
3461 +{
3462 +
3463 +#if ASTERISK_VERSION_NUM <= 010107
3464 +  ast_channel_unregister(BLT_CHAN_NAME);
3465 +#else
3466 +  ast_channel_unregister(&blt_tech);
3467 +#endif
3468 +
3469 +  if (monitor_thread != AST_PTHREADT_NULL) {
3470 +
3471 +    if (ast_mutex_lock(&monitor_lock)) {
3472 +
3473 +      if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP) && (monitor_thread != AST_PTHREADT_NULL)) {
3474 +        pthread_cancel(monitor_thread);
3475 +        pthread_kill(monitor_thread, SIGURG);
3476 +        fprintf(stderr, "Waiting for monitor thread to join...\n");
3477 +        pthread_join(monitor_thread, NULL);
3478 +        fprintf(stderr, "joined\n");
3479 +      }
3480 +      monitor_thread = AST_PTHREADT_STOP;
3481 +      ast_mutex_unlock(&monitor_lock);
3482 +
3483 +    } else {
3484 +
3485 +      ast_log(LOG_WARNING, "Unable to lock the monitor\n");
3486 +      return -1;
3487 +
3488 +    }
3489 +
3490 +  }
3491 +
3492 +  ast_unregister_atexit(remove_sdp_records);
3493 +  remove_sdp_records();
3494 +  return 0;
3495 +}
3496 +
3497 +int
3498 +load_module()
3499 +{
3500 +  sdp_session_t * sess;
3501 +  int dd;
3502 +  uint16_t vs;
3503 +
3504 +  hcidev_id = BLT_DEFAULT_HCI_DEV;
3505 +
3506 +  if (blt_parse_config() != 0) {
3507 +    ast_log(LOG_ERROR, "Bluetooth configuration error.  Bluetooth Disabled\n");
3508 +    return unload_module();
3509 +  }
3510 +
3511 +  dd  = hci_open_dev(hcidev_id);
3512 +  if (dd == -1) {
3513 +    ast_log(LOG_ERROR, "Unable to open interface hci%d: %s.\n", hcidev_id, strerror(errno));
3514 +    return -1;
3515 +  }
3516 +
3517 +  hci_read_voice_setting(dd, &vs, 1000);
3518 +  vs = htobs(vs);
3519 +  close(dd);
3520 +
3521 +  if (vs != 0x0060) {
3522 +    ast_log(LOG_ERROR, "Bluetooth voice setting must be 0x0060, not 0x%04x\n", vs);
3523 +    unload_module();
3524 +    return 0;
3525 +  }
3526 +
3527 +  if ((sched = sched_context_create()) == NULL) {
3528 +    ast_log(LOG_WARNING, "Unable to create schedule context\n");
3529 +    return -1;
3530 +  }
3531 +
3532 +  memset(&local_bdaddr, 0, sizeof(local_bdaddr));
3533 +
3534 +  hci_devba(hcidev_id, &local_bdaddr);
3535 +
3536 +  /* --- Add SDP record --- */
3537 +
3538 +  sess = sdp_connect(&local_bdaddr, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
3539 +
3540 +  if ((rfcomm_sock_ag = rfcomm_listen(&local_bdaddr, rfcomm_channel_ag)) < 0) {
3541 +    return -1;
3542 +  }
3543 +
3544 +  if ((rfcomm_sock_hs = rfcomm_listen(&local_bdaddr, rfcomm_channel_hs)) < 0)
3545 +    return -1;
3546 +
3547 +  if ((rfcomm_sock_gui = rfcomm_listen(&local_bdaddr, rfcomm_channel_gui)) < 0)
3548 +    return -1;
3549 +
3550 +  if ((sco_socket = sco_listen(&local_bdaddr)) < 0)
3551 +    return -1;
3552 +
3553 +  if (!sess) {
3554 +    ast_log(LOG_ERROR, "Failed to connect to SDP server: %s\n", strerror(errno));
3555 +    return -1;
3556 +  }
3557 +
3558 +  if (sdp_register(sess) != 0) {
3559 +    ast_log(LOG_ERROR, "Failed to register HeadsetAudioGateway in SDP\n");
3560 +    return -1;
3561 +  }
3562 +
3563 +  sdp_close(sess);
3564 +
3565 +  if (restart_monitor() != 0)
3566 +    return -1;
3567 +
3568 +#if ASTERISK_VERSION_NUM <= 010107
3569 +  if (ast_channel_register(BLT_CHAN_NAME, "Bluetooth Driver", BLUETOOTH_FORMAT, blt_request)) {
3570 +#else
3571 +  if (ast_channel_register(&blt_tech)) {
3572 +#endif
3573 +    ast_log(LOG_ERROR, "Unable to register channel class BTL\n");
3574 +    __unload_module();
3575 +    return -1;
3576 +  }
3577 +
3578 +  ast_cli_register(&cli_show_information);
3579 +  ast_cli_register(&cli_show_peers);
3580 +  ast_cli_register(&cli_ag_sendcmd);
3581 +
3582 +  ast_register_atexit(remove_sdp_records);
3583 +
3584 +  ast_log(LOG_NOTICE, "Loaded Bluetooth support, %s\n", BLT_SVN_REVISION + 1);
3585 +
3586 +  return 0;
3587 +}
3588 +
3589 +int
3590 +unload_module(void)
3591 +{
3592 +  ast_cli_unregister(&cli_ag_sendcmd);
3593 +  ast_cli_unregister(&cli_show_peers);
3594 +  ast_cli_unregister(&cli_show_information);
3595 +  return __unload_module();
3596 +}
3597 +
3598 +int
3599 +usecount()
3600 +{
3601 +  int res;
3602 +  ast_mutex_lock(&usecnt_lock);
3603 +  res = usecnt;
3604 +  ast_mutex_unlock(&usecnt_lock);
3605 +  return res;
3606 +}
3607 +
3608 +char *description()
3609 +{
3610 +  return "Bluetooth Channel Driver";
3611 +}
3612 +
3613 +char *
3614 +key()
3615 +{
3616 +  return ASTERISK_GPL_KEY;
3617 +}
3618 +
3619 +
3620 diff -ruN asterisk-1.0.9-old/configs/bluetooth.conf asterisk-1.0.9-new/configs/bluetooth.conf
3621 --- asterisk-1.0.9-old/configs/bluetooth.conf   1970-01-01 01:00:00.000000000 +0100
3622 +++ asterisk-1.0.9-new/configs/bluetooth.conf   2005-09-06 22:51:38.000000000 +0200
3623 @@ -0,0 +1,46 @@
3624 +[general]
3625 +; Channel we listen on as a HS (Headset)
3626 +rfchannel_hs = 2
3627 +; Channel we listen on as an AG (AudioGateway)
3628 +rfchannel_ag = 3
3629 +; Channel we listen on as GUI
3630 +rfchannel_gui = 4
3631 +; hci interface to use (number - e.g '0')
3632 +interface = 0
3633 +
3634 +; RFCOMM channel to connect to.  For a HandsSet:
3635 +;    sdptool search --bdaddr xx:xx:xx:xx:xx:xx 0x111E
3636 +; or,for an AudioGateway (Phone):
3637 +;    sdptool search --bdaddr xx:xx:xx:xx:xx:xx 0x111F
3638 +;
3639 +; Find the 'channel' value under RFCOMM.
3640 +;
3641 +;channel     = 6
3642 +; Automatically connect?
3643 +;autoconnect = yes
3644 +
3645 +;example for a SonyEricsson mobile as a GUI device
3646 +[00:0F:DE:6E:77:6B]
3647 +name    = T610
3648 +type    = GUI
3649 +channel = 6
3650 +;channel = 1
3651 +autoconnect     = yes
3652 +
3653 +;[00:0E:6D:1A:3D:86]
3654 +;name   = Nokia
3655 +;type   = AG
3656 +;channel = 13
3657 +;autoconnect    = yes
3658 +
3659 +[00:0E:A1:01:49:AE]
3660 +name    = AutoBlue
3661 +type    = HS
3662 +channel = 2
3663 +autoconnect = yes
3664 +
3665 +;[00:0A:D9:EB:FD:D8]
3666 +;name    = P900
3667 +;type    = AG
3668 +;channel = 8
3669 +;autoconnect = no