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