1 /*
2 *
3 * BlueZ - Bluetooth protocol stack for Linux
4 *
5 * Copyright (C) 2006-2007 Nokia Corporation
6 * Copyright (C) 2004-2009 Marcel Holtmann <marcel@holtmann.org>
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 */
24
25 #ifdef HAVE_CONFIG_H
26 #include <config.h>
27 #endif
28
29 #include <stdlib.h>
30 #include <stdint.h>
31 #include <errno.h>
32 #include <unistd.h>
33 #include <assert.h>
34 #include <signal.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <fcntl.h>
38 #include <netinet/in.h>
39
40 #include <bluetooth/bluetooth.h>
41 #include <bluetooth/sdp.h>
42 #include <bluetooth/sdp_lib.h>
43 #include <bluetooth/l2cap.h>
44
45 #include <glib.h>
46 #include <dbus/dbus.h>
47 #include <gdbus.h>
48
49 #include "logging.h"
50 #include "error.h"
51 #include "uinput.h"
52 #include "adapter.h"
53 #include "../src/device.h"
54 #include "device.h"
55 #include "manager.h"
56 #include "avdtp.h"
57 #include "control.h"
58 #include "sdpd.h"
59 #include "glib-helper.h"
60 #include "btio.h"
61 #include "dbus-common.h"
62
63 #define AVCTP_PSM 23
64
65 /* Message types */
66 #define AVCTP_COMMAND 0
67 #define AVCTP_RESPONSE 1
68
69 /* Packet types */
70 #define AVCTP_PACKET_SINGLE 0
71 #define AVCTP_PACKET_START 1
72 #define AVCTP_PACKET_CONTINUE 2
73 #define AVCTP_PACKET_END 3
74
75 /* ctype entries */
76 #define CTYPE_CONTROL 0x0
77 #define CTYPE_STATUS 0x1
78 #define CTYPE_NOT_IMPLEMENTED 0x8
79 #define CTYPE_ACCEPTED 0x9
80 #define CTYPE_REJECTED 0xA
81 #define CTYPE_STABLE 0xC
82
83 /* opcodes */
84 #define OP_UNITINFO 0x30
85 #define OP_SUBUNITINFO 0x31
86 #define OP_PASSTHROUGH 0x7c
87
88 /* subunits of interest */
89 #define SUBUNIT_PANEL 0x09
90
91 /* operands in passthrough commands */
92 #define VOL_UP_OP 0x41
93 #define VOL_DOWN_OP 0x42
94 #define MUTE_OP 0x43
95 #define PLAY_OP 0x44
96 #define STOP_OP 0x45
97 #define PAUSE_OP 0x46
98 #define RECORD_OP 0x47
99 #define REWIND_OP 0x48
100 #define FAST_FORWARD_OP 0x49
101 #define EJECT_OP 0x4a
102 #define FORWARD_OP 0x4b
103 #define BACKWARD_OP 0x4c
104
105 static DBusConnection *connection = NULL;
106 static gchar *input_device_name = NULL;
107 static GSList *servers = NULL;
108
109 #if __BYTE_ORDER == __LITTLE_ENDIAN
110
111 struct avctp_header {
112 uint8_t ipid:1;
113 uint8_t cr:1;
114 uint8_t packet_type:2;
115 uint8_t transaction:4;
116 uint16_t pid;
117 } __attribute__ ((packed));
118 #define AVCTP_HEADER_LENGTH 3
119
120 struct avrcp_header {
121 uint8_t code:4;
122 uint8_t _hdr0:4;
123 uint8_t subunit_id:3;
124 uint8_t subunit_type:5;
125 uint8_t opcode;
126 } __attribute__ ((packed));
127 #define AVRCP_HEADER_LENGTH 3
128
129 #elif __BYTE_ORDER == __BIG_ENDIAN
130
131 struct avctp_header {
132 uint8_t transaction:4;
133 uint8_t packet_type:2;
134 uint8_t cr:1;
135 uint8_t ipid:1;
136 uint16_t pid;
137 } __attribute__ ((packed));
138 #define AVCTP_HEADER_LENGTH 3
139
140 struct avrcp_header {
141 uint8_t _hdr0:4;
142 uint8_t code:4;
143 uint8_t subunit_type:5;
144 uint8_t subunit_id:3;
145 uint8_t opcode;
146 } __attribute__ ((packed));
147 #define AVRCP_HEADER_LENGTH 3
148
149 #else
150 #error "Unknown byte order"
151 #endif
152
153 struct avctp_state_callback {
154 avctp_state_cb cb;
155 void *user_data;
156 unsigned int id;
157 };
158
159 struct avctp_server {
160 bdaddr_t src;
161 GIOChannel *io;
162 uint32_t tg_record_id;
163 #ifndef ANDROID
164 uint32_t ct_record_id;
165 #endif
166 };
167
168 struct control {
169 struct audio_device *dev;
170
171 avctp_state_t state;
172
173 int uinput;
174
175 GIOChannel *io;
176 guint io_id;
177
178 uint16_t mtu;
179
180 gboolean target;
181 };
182
183 static struct {
184 const char *name;
185 uint8_t avrcp;
186 uint16_t uinput;
187 } key_map[] = {
188 { "PLAY", PLAY_OP, KEY_PLAYCD },
189 { "STOP", STOP_OP, KEY_STOPCD },
190 { "PAUSE", PAUSE_OP, KEY_PAUSECD },
191 { "FORWARD", FORWARD_OP, KEY_NEXTSONG },
192 { "BACKWARD", BACKWARD_OP, KEY_PREVIOUSSONG },
193 { "REWIND", REWIND_OP, KEY_REWIND },
194 { "FAST FORWARD", FAST_FORWARD_OP, KEY_FASTFORWARD },
195 { NULL }
196 };
197
198 static GSList *avctp_callbacks = NULL;
199
avrcp_ct_record()200 static sdp_record_t *avrcp_ct_record()
201 {
202 sdp_list_t *svclass_id, *pfseq, *apseq, *root;
203 uuid_t root_uuid, l2cap, avctp, avrct;
204 sdp_profile_desc_t profile[1];
205 sdp_list_t *aproto, *proto[2];
206 sdp_record_t *record;
207 sdp_data_t *psm, *version, *features;
208 uint16_t lp = AVCTP_PSM, ver = 0x0100, feat = 0x000f;
209
210 record = sdp_record_alloc();
211 if (!record)
212 return NULL;
213
214 sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
215 root = sdp_list_append(0, &root_uuid);
216 sdp_set_browse_groups(record, root);
217
218 /* Service Class ID List */
219 sdp_uuid16_create(&avrct, AV_REMOTE_SVCLASS_ID);
220 svclass_id = sdp_list_append(0, &avrct);
221 sdp_set_service_classes(record, svclass_id);
222
223 /* Protocol Descriptor List */
224 sdp_uuid16_create(&l2cap, L2CAP_UUID);
225 proto[0] = sdp_list_append(0, &l2cap);
226 psm = sdp_data_alloc(SDP_UINT16, &lp);
227 proto[0] = sdp_list_append(proto[0], psm);
228 apseq = sdp_list_append(0, proto[0]);
229
230 sdp_uuid16_create(&avctp, AVCTP_UUID);
231 proto[1] = sdp_list_append(0, &avctp);
232 version = sdp_data_alloc(SDP_UINT16, &ver);
233 proto[1] = sdp_list_append(proto[1], version);
234 apseq = sdp_list_append(apseq, proto[1]);
235
236 aproto = sdp_list_append(0, apseq);
237 sdp_set_access_protos(record, aproto);
238
239 /* Bluetooth Profile Descriptor List */
240 sdp_uuid16_create(&profile[0].uuid, AV_REMOTE_PROFILE_ID);
241 profile[0].version = ver;
242 pfseq = sdp_list_append(0, &profile[0]);
243 sdp_set_profile_descs(record, pfseq);
244
245 features = sdp_data_alloc(SDP_UINT16, &feat);
246 sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
247
248 sdp_set_info_attr(record, "AVRCP CT", 0, 0);
249
250 free(psm);
251 free(version);
252 sdp_list_free(proto[0], 0);
253 sdp_list_free(proto[1], 0);
254 sdp_list_free(apseq, 0);
255 sdp_list_free(pfseq, 0);
256 sdp_list_free(aproto, 0);
257 sdp_list_free(root, 0);
258 sdp_list_free(svclass_id, 0);
259
260 return record;
261 }
262
avrcp_tg_record()263 static sdp_record_t *avrcp_tg_record()
264 {
265 sdp_list_t *svclass_id, *pfseq, *apseq, *root;
266 uuid_t root_uuid, l2cap, avctp, avrtg;
267 sdp_profile_desc_t profile[1];
268 sdp_list_t *aproto, *proto[2];
269 sdp_record_t *record;
270 sdp_data_t *psm, *version, *features;
271 uint16_t lp = AVCTP_PSM, ver = 0x0100, feat = 0x000f;
272
273 record = sdp_record_alloc();
274 if (!record)
275 return NULL;
276
277 sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
278 root = sdp_list_append(0, &root_uuid);
279 sdp_set_browse_groups(record, root);
280
281 /* Service Class ID List */
282 sdp_uuid16_create(&avrtg, AV_REMOTE_TARGET_SVCLASS_ID);
283 svclass_id = sdp_list_append(0, &avrtg);
284 sdp_set_service_classes(record, svclass_id);
285
286 /* Protocol Descriptor List */
287 sdp_uuid16_create(&l2cap, L2CAP_UUID);
288 proto[0] = sdp_list_append(0, &l2cap);
289 psm = sdp_data_alloc(SDP_UINT16, &lp);
290 proto[0] = sdp_list_append(proto[0], psm);
291 apseq = sdp_list_append(0, proto[0]);
292
293 sdp_uuid16_create(&avctp, AVCTP_UUID);
294 proto[1] = sdp_list_append(0, &avctp);
295 version = sdp_data_alloc(SDP_UINT16, &ver);
296 proto[1] = sdp_list_append(proto[1], version);
297 apseq = sdp_list_append(apseq, proto[1]);
298
299 aproto = sdp_list_append(0, apseq);
300 sdp_set_access_protos(record, aproto);
301
302 /* Bluetooth Profile Descriptor List */
303 sdp_uuid16_create(&profile[0].uuid, AV_REMOTE_PROFILE_ID);
304 profile[0].version = ver;
305 pfseq = sdp_list_append(0, &profile[0]);
306 sdp_set_profile_descs(record, pfseq);
307
308 features = sdp_data_alloc(SDP_UINT16, &feat);
309 sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
310
311 sdp_set_info_attr(record, "AVRCP TG", 0, 0);
312
313 free(psm);
314 free(version);
315 sdp_list_free(proto[0], 0);
316 sdp_list_free(proto[1], 0);
317 sdp_list_free(apseq, 0);
318 sdp_list_free(aproto, 0);
319 sdp_list_free(pfseq, 0);
320 sdp_list_free(root, 0);
321 sdp_list_free(svclass_id, 0);
322
323 return record;
324 }
325
send_event(int fd,uint16_t type,uint16_t code,int32_t value)326 static int send_event(int fd, uint16_t type, uint16_t code, int32_t value)
327 {
328 struct uinput_event event;
329
330 memset(&event, 0, sizeof(event));
331 event.type = type;
332 event.code = code;
333 event.value = value;
334
335 return write(fd, &event, sizeof(event));
336 }
337
send_key(int fd,uint16_t key,int pressed)338 static void send_key(int fd, uint16_t key, int pressed)
339 {
340 if (fd < 0)
341 return;
342
343 send_event(fd, EV_KEY, key, pressed);
344 send_event(fd, EV_SYN, SYN_REPORT, 0);
345 }
346
handle_panel_passthrough(struct control * control,const unsigned char * operands,int operand_count)347 static void handle_panel_passthrough(struct control *control,
348 const unsigned char *operands,
349 int operand_count)
350 {
351 const char *status;
352 int pressed, i;
353
354 if (operand_count == 0)
355 return;
356
357 if (operands[0] & 0x80) {
358 status = "released";
359 pressed = 0;
360 } else {
361 status = "pressed";
362 pressed = 1;
363 }
364
365 for (i = 0; key_map[i].name != NULL; i++) {
366 if ((operands[0] & 0x7F) == key_map[i].avrcp) {
367 debug("AVRCP: %s %s", key_map[i].name, status);
368 send_key(control->uinput, key_map[i].uinput, pressed);
369 break;
370 }
371 }
372
373 if (key_map[i].name == NULL)
374 debug("AVRCP: unknown button 0x%02X %s",
375 operands[0] & 0x7F, status);
376 }
377
avctp_disconnected(struct audio_device * dev)378 static void avctp_disconnected(struct audio_device *dev)
379 {
380 struct control *control = dev->control;
381
382 if (!control)
383 return;
384
385 if (control->io) {
386 g_io_channel_shutdown(control->io, TRUE, NULL);
387 g_io_channel_unref(control->io);
388 control->io = NULL;
389 }
390
391 if (control->io_id) {
392 g_source_remove(control->io_id);
393 control->io_id = 0;
394 }
395
396 if (control->uinput >= 0) {
397 ioctl(control->uinput, UI_DEV_DESTROY);
398 close(control->uinput);
399 control->uinput = -1;
400 }
401 }
402
avctp_set_state(struct control * control,avctp_state_t new_state)403 static void avctp_set_state(struct control *control, avctp_state_t new_state)
404 {
405 GSList *l;
406 struct audio_device *dev = control->dev;
407 avdtp_session_state_t old_state = control->state;
408 gboolean value;
409
410 switch (new_state) {
411 case AVCTP_STATE_DISCONNECTED:
412 avctp_disconnected(control->dev);
413
414 if (old_state != AVCTP_STATE_CONNECTED)
415 break;
416
417 value = FALSE;
418 g_dbus_emit_signal(dev->conn, dev->path,
419 AUDIO_CONTROL_INTERFACE,
420 "Disconnected", DBUS_TYPE_INVALID);
421 emit_property_changed(dev->conn, dev->path,
422 AUDIO_CONTROL_INTERFACE, "Connected",
423 DBUS_TYPE_BOOLEAN, &value);
424 break;
425 case AVCTP_STATE_CONNECTING:
426 break;
427 case AVCTP_STATE_CONNECTED:
428 value = TRUE;
429 g_dbus_emit_signal(control->dev->conn, control->dev->path,
430 AUDIO_CONTROL_INTERFACE, "Connected",
431 DBUS_TYPE_INVALID);
432 emit_property_changed(control->dev->conn, control->dev->path,
433 AUDIO_CONTROL_INTERFACE, "Connected",
434 DBUS_TYPE_BOOLEAN, &value);
435 break;
436 default:
437 error("Invalid AVCTP state %d", new_state);
438 return;
439 }
440
441 control->state = new_state;
442
443 for (l = avctp_callbacks; l != NULL; l = l->next) {
444 struct avctp_state_callback *cb = l->data;
445 cb->cb(control->dev, old_state, new_state, cb->user_data);
446 }
447 }
448
control_cb(GIOChannel * chan,GIOCondition cond,gpointer data)449 static gboolean control_cb(GIOChannel *chan, GIOCondition cond,
450 gpointer data)
451 {
452 struct control *control = data;
453 unsigned char buf[1024], *operands;
454 struct avctp_header *avctp;
455 struct avrcp_header *avrcp;
456 int ret, packet_size, operand_count, sock;
457
458 if (!(cond | G_IO_IN))
459 goto failed;
460
461 sock = g_io_channel_unix_get_fd(control->io);
462
463 ret = read(sock, buf, sizeof(buf));
464 if (ret <= 0)
465 goto failed;
466
467 debug("Got %d bytes of data for AVCTP session %p", ret, control);
468
469 if ((unsigned int) ret < sizeof(struct avctp_header)) {
470 error("Too small AVCTP packet");
471 goto failed;
472 }
473
474 packet_size = ret;
475
476 avctp = (struct avctp_header *) buf;
477
478 debug("AVCTP transaction %u, packet type %u, C/R %u, IPID %u, "
479 "PID 0x%04X",
480 avctp->transaction, avctp->packet_type,
481 avctp->cr, avctp->ipid, ntohs(avctp->pid));
482
483 ret -= sizeof(struct avctp_header);
484 if ((unsigned int) ret < sizeof(struct avrcp_header)) {
485 error("Too small AVRCP packet");
486 goto failed;
487 }
488
489 avrcp = (struct avrcp_header *) (buf + sizeof(struct avctp_header));
490
491 ret -= sizeof(struct avrcp_header);
492
493 operands = buf + sizeof(struct avctp_header) + sizeof(struct avrcp_header);
494 operand_count = ret;
495
496 debug("AVRCP %s 0x%01X, subunit_type 0x%02X, subunit_id 0x%01X, "
497 "opcode 0x%02X, %d operands",
498 avctp->cr ? "response" : "command",
499 avrcp->code, avrcp->subunit_type, avrcp->subunit_id,
500 avrcp->opcode, operand_count);
501
502 if (avctp->packet_type != AVCTP_PACKET_SINGLE) {
503 avctp->cr = AVCTP_RESPONSE;
504 avrcp->code = CTYPE_NOT_IMPLEMENTED;
505 } else if (avctp->pid != htons(AV_REMOTE_SVCLASS_ID)) {
506 avctp->ipid = 1;
507 avctp->cr = AVCTP_RESPONSE;
508 avrcp->code = CTYPE_REJECTED;
509 } else if (avctp->cr == AVCTP_COMMAND &&
510 avrcp->code == CTYPE_CONTROL &&
511 avrcp->subunit_type == SUBUNIT_PANEL &&
512 avrcp->opcode == OP_PASSTHROUGH) {
513 handle_panel_passthrough(control, operands, operand_count);
514 avctp->cr = AVCTP_RESPONSE;
515 avrcp->code = CTYPE_ACCEPTED;
516 } else if (avctp->cr == AVCTP_COMMAND &&
517 avrcp->code == CTYPE_STATUS &&
518 (avrcp->opcode == OP_UNITINFO
519 || avrcp->opcode == OP_SUBUNITINFO)) {
520 avctp->cr = AVCTP_RESPONSE;
521 avrcp->code = CTYPE_STABLE;
522 /* The first operand should be 0x07 for the UNITINFO response.
523 * Neither AVRCP (section 22.1, page 117) nor AVC Digital
524 * Interface Command Set (section 9.2.1, page 45) specs
525 * explain this value but both use it */
526 if (operand_count >= 1 && avrcp->opcode == OP_UNITINFO)
527 operands[0] = 0x07;
528 if (operand_count >= 2)
529 operands[1] = SUBUNIT_PANEL << 3;
530 debug("reply to %s", avrcp->opcode == OP_UNITINFO ?
531 "OP_UNITINFO" : "OP_SUBUNITINFO");
532 } else {
533 avctp->cr = AVCTP_RESPONSE;
534 avrcp->code = CTYPE_REJECTED;
535 }
536 ret = write(sock, buf, packet_size);
537
538 return TRUE;
539
540 failed:
541 debug("AVCTP session %p got disconnected", control);
542 avctp_set_state(control, AVCTP_STATE_DISCONNECTED);
543 return FALSE;
544 }
545
uinput_create(char * name)546 static int uinput_create(char *name)
547 {
548 struct uinput_dev dev;
549 int fd, err, i;
550
551 fd = open("/dev/uinput", O_RDWR);
552 if (fd < 0) {
553 fd = open("/dev/input/uinput", O_RDWR);
554 if (fd < 0) {
555 fd = open("/dev/misc/uinput", O_RDWR);
556 if (fd < 0) {
557 err = errno;
558 error("Can't open input device: %s (%d)",
559 strerror(err), err);
560 return -err;
561 }
562 }
563 }
564
565 memset(&dev, 0, sizeof(dev));
566 if (name)
567 strncpy(dev.name, name, UINPUT_MAX_NAME_SIZE - 1);
568
569 dev.id.bustype = BUS_BLUETOOTH;
570 dev.id.vendor = 0x0000;
571 dev.id.product = 0x0000;
572 dev.id.version = 0x0000;
573
574 if (write(fd, &dev, sizeof(dev)) < 0) {
575 err = errno;
576 error("Can't write device information: %s (%d)",
577 strerror(err), err);
578 close(fd);
579 errno = err;
580 return -err;
581 }
582
583 ioctl(fd, UI_SET_EVBIT, EV_KEY);
584 ioctl(fd, UI_SET_EVBIT, EV_REL);
585 ioctl(fd, UI_SET_EVBIT, EV_REP);
586 ioctl(fd, UI_SET_EVBIT, EV_SYN);
587
588 for (i = 0; key_map[i].name != NULL; i++)
589 ioctl(fd, UI_SET_KEYBIT, key_map[i].uinput);
590
591 if (ioctl(fd, UI_DEV_CREATE, NULL) < 0) {
592 err = errno;
593 error("Can't create uinput device: %s (%d)",
594 strerror(err), err);
595 close(fd);
596 errno = err;
597 return -err;
598 }
599
600 return fd;
601 }
602
init_uinput(struct control * control)603 static void init_uinput(struct control *control)
604 {
605 char address[18], *name;
606
607 ba2str(&control->dev->dst, address);
608
609 /* Use device name from config file if specified */
610 name = input_device_name;
611 if (!name)
612 name = address;
613
614 control->uinput = uinput_create(name);
615 if (control->uinput < 0)
616 error("AVRCP: failed to init uinput for %s", address);
617 else
618 debug("AVRCP: uinput initialized for %s", address);
619 }
620
avctp_connect_cb(GIOChannel * chan,GError * err,gpointer data)621 static void avctp_connect_cb(GIOChannel *chan, GError *err, gpointer data)
622 {
623 struct control *control = data;
624 char address[18];
625 uint16_t imtu;
626 GError *gerr = NULL;
627
628 if (err) {
629 avctp_set_state(control, AVCTP_STATE_DISCONNECTED);
630 error("%s", err->message);
631 return;
632 }
633
634 bt_io_get(chan, BT_IO_L2CAP, &gerr,
635 BT_IO_OPT_DEST, &address,
636 BT_IO_OPT_IMTU, &imtu,
637 BT_IO_OPT_INVALID);
638 if (gerr) {
639 avctp_set_state(control, AVCTP_STATE_DISCONNECTED);
640 error("%s", gerr->message);
641 g_error_free(gerr);
642 return;
643 }
644
645 debug("AVCTP: connected to %s", address);
646
647 if (!control->io)
648 control->io = g_io_channel_ref(chan);
649
650 init_uinput(control);
651
652 avctp_set_state(control, AVCTP_STATE_CONNECTED);
653 control->mtu = imtu;
654 control->io_id = g_io_add_watch(chan,
655 G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
656 (GIOFunc) control_cb, control);
657 }
658
auth_cb(DBusError * derr,void * user_data)659 static void auth_cb(DBusError *derr, void *user_data)
660 {
661 struct control *control = user_data;
662 GError *err = NULL;
663
664 if (derr && dbus_error_is_set(derr)) {
665 error("Access denied: %s", derr->message);
666 avctp_set_state(control, AVCTP_STATE_DISCONNECTED);
667 return;
668 }
669
670 if (!bt_io_accept(control->io, avctp_connect_cb, control,
671 NULL, &err)) {
672 error("bt_io_accept: %s", err->message);
673 g_error_free(err);
674 avctp_set_state(control, AVCTP_STATE_DISCONNECTED);
675 }
676 }
677
avctp_confirm_cb(GIOChannel * chan,gpointer data)678 static void avctp_confirm_cb(GIOChannel *chan, gpointer data)
679 {
680 struct control *control = NULL;
681 struct audio_device *dev;
682 char address[18];
683 bdaddr_t src, dst;
684 GError *err = NULL;
685
686 bt_io_get(chan, BT_IO_L2CAP, &err,
687 BT_IO_OPT_SOURCE_BDADDR, &src,
688 BT_IO_OPT_DEST_BDADDR, &dst,
689 BT_IO_OPT_DEST, address,
690 BT_IO_OPT_INVALID);
691 if (err) {
692 error("%s", err->message);
693 g_error_free(err);
694 g_io_channel_shutdown(chan, TRUE, NULL);
695 return;
696 }
697
698 dev = manager_get_device(&src, &dst, TRUE);
699 if (!dev) {
700 error("Unable to get audio device object for %s", address);
701 goto drop;
702 }
703
704 if (!dev->control) {
705 btd_device_add_uuid(dev->btd_dev, AVRCP_REMOTE_UUID);
706 if (!dev->control)
707 goto drop;
708 }
709
710 control = dev->control;
711
712 if (control->io) {
713 error("Refusing unexpected connect from %s", address);
714 goto drop;
715 }
716
717 avctp_set_state(control, AVCTP_STATE_CONNECTING);
718 control->io = g_io_channel_ref(chan);
719
720 if (audio_device_request_authorization(dev, AVRCP_TARGET_UUID,
721 auth_cb, dev->control) < 0)
722 goto drop;
723
724 return;
725
726 drop:
727 if (!control || !control->io)
728 g_io_channel_shutdown(chan, TRUE, NULL);
729 if (control)
730 avctp_set_state(control, AVCTP_STATE_DISCONNECTED);
731 }
732
avctp_server_socket(const bdaddr_t * src,gboolean master)733 static GIOChannel *avctp_server_socket(const bdaddr_t *src, gboolean master)
734 {
735 GError *err = NULL;
736 GIOChannel *io;
737
738 io = bt_io_listen(BT_IO_L2CAP, NULL, avctp_confirm_cb, NULL,
739 NULL, &err,
740 BT_IO_OPT_SOURCE_BDADDR, src,
741 BT_IO_OPT_PSM, AVCTP_PSM,
742 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM,
743 BT_IO_OPT_MASTER, master,
744 BT_IO_OPT_INVALID);
745 if (!io) {
746 error("%s", err->message);
747 g_error_free(err);
748 }
749
750 return io;
751 }
752
avrcp_connect(struct audio_device * dev)753 gboolean avrcp_connect(struct audio_device *dev)
754 {
755 struct control *control = dev->control;
756 GError *err = NULL;
757 GIOChannel *io;
758
759 if (control->state > AVCTP_STATE_DISCONNECTED)
760 return TRUE;
761
762 avctp_set_state(control, AVCTP_STATE_CONNECTING);
763
764 io = bt_io_connect(BT_IO_L2CAP, avctp_connect_cb, control, NULL, &err,
765 BT_IO_OPT_SOURCE_BDADDR, &dev->src,
766 BT_IO_OPT_DEST_BDADDR, &dev->dst,
767 BT_IO_OPT_PSM, AVCTP_PSM,
768 BT_IO_OPT_INVALID);
769 if (err) {
770 avctp_set_state(control, AVCTP_STATE_DISCONNECTED);
771 error("%s", err->message);
772 g_error_free(err);
773 return FALSE;
774 }
775
776 control->io = io;
777
778 return TRUE;
779 }
780
avrcp_disconnect(struct audio_device * dev)781 void avrcp_disconnect(struct audio_device *dev)
782 {
783 struct control *control = dev->control;
784
785 if (!(control && control->io))
786 return;
787
788 avctp_set_state(control, AVCTP_STATE_DISCONNECTED);
789 }
790
avrcp_register(DBusConnection * conn,const bdaddr_t * src,GKeyFile * config)791 int avrcp_register(DBusConnection *conn, const bdaddr_t *src, GKeyFile *config)
792 {
793 sdp_record_t *record;
794 gboolean tmp, master = TRUE;
795 GError *err = NULL;
796 struct avctp_server *server;
797
798 if (config) {
799 tmp = g_key_file_get_boolean(config, "General",
800 "Master", &err);
801 if (err) {
802 debug("audio.conf: %s", err->message);
803 g_error_free(err);
804 } else
805 master = tmp;
806 err = NULL;
807 input_device_name = g_key_file_get_string(config,
808 "AVRCP", "InputDeviceName", &err);
809 if (err) {
810 debug("audio.conf: %s", err->message);
811 input_device_name = NULL;
812 g_error_free(err);
813 }
814 }
815
816 server = g_new0(struct avctp_server, 1);
817 if (!server)
818 return -ENOMEM;
819
820 if (!connection)
821 connection = dbus_connection_ref(conn);
822
823 record = avrcp_tg_record();
824 if (!record) {
825 error("Unable to allocate new service record");
826 return -1;
827 }
828
829 if (add_record_to_server(src, record) < 0) {
830 error("Unable to register AVRCP target service record");
831 sdp_record_free(record);
832 return -1;
833 }
834 server->tg_record_id = record->handle;
835
836 #ifndef ANDROID
837 record = avrcp_ct_record();
838 if (!record) {
839 error("Unable to allocate new service record");
840 return -1;
841 }
842
843 if (add_record_to_server(src, record) < 0) {
844 error("Unable to register AVRCP controller service record");
845 sdp_record_free(record);
846 return -1;
847 }
848 server->ct_record_id = record->handle;
849 #endif
850
851 server->io = avctp_server_socket(src, master);
852 if (!server->io) {
853 #ifndef ANDROID
854 remove_record_from_server(server->ct_record_id);
855 #endif
856 remove_record_from_server(server->tg_record_id);
857 g_free(server);
858 return -1;
859 }
860
861 bacpy(&server->src, src);
862
863 servers = g_slist_append(servers, server);
864
865 return 0;
866 }
867
find_server(GSList * list,const bdaddr_t * src)868 static struct avctp_server *find_server(GSList *list, const bdaddr_t *src)
869 {
870 GSList *l;
871
872 for (l = list; l; l = l->next) {
873 struct avctp_server *server = l->data;
874
875 if (bacmp(&server->src, src) == 0)
876 return server;
877 }
878
879 return NULL;
880 }
881
avrcp_unregister(const bdaddr_t * src)882 void avrcp_unregister(const bdaddr_t *src)
883 {
884 struct avctp_server *server;
885
886 server = find_server(servers, src);
887 if (!server)
888 return;
889
890 servers = g_slist_remove(servers, server);
891
892 #ifndef ANDROID
893 remove_record_from_server(server->ct_record_id);
894 #endif
895 remove_record_from_server(server->tg_record_id);
896
897 g_io_channel_shutdown(server->io, TRUE, NULL);
898 g_io_channel_unref(server->io);
899 g_free(server);
900
901 if (servers)
902 return;
903
904 dbus_connection_unref(connection);
905 connection = NULL;
906 }
907
control_is_connected(DBusConnection * conn,DBusMessage * msg,void * data)908 static DBusMessage *control_is_connected(DBusConnection *conn,
909 DBusMessage *msg,
910 void *data)
911 {
912 struct audio_device *device = data;
913 struct control *control = device->control;
914 DBusMessage *reply;
915 dbus_bool_t connected;
916
917 reply = dbus_message_new_method_return(msg);
918 if (!reply)
919 return NULL;
920
921 connected = (control->state == AVCTP_STATE_CONNECTED);
922
923 dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connected,
924 DBUS_TYPE_INVALID);
925
926 return reply;
927 }
928
avctp_send_passthrough(struct control * control,uint8_t op)929 static int avctp_send_passthrough(struct control *control, uint8_t op)
930 {
931 unsigned char buf[AVCTP_HEADER_LENGTH + AVRCP_HEADER_LENGTH + 2];
932 struct avctp_header *avctp = (void *) buf;
933 struct avrcp_header *avrcp = (void *) &buf[AVCTP_HEADER_LENGTH];
934 uint8_t *operands = &buf[AVCTP_HEADER_LENGTH + AVRCP_HEADER_LENGTH];
935 int err, sk = g_io_channel_unix_get_fd(control->io);
936 static uint8_t transaction = 0;
937
938 memset(buf, 0, sizeof(buf));
939
940 avctp->transaction = transaction++;
941 avctp->packet_type = AVCTP_PACKET_SINGLE;
942 avctp->cr = AVCTP_COMMAND;
943 avctp->pid = htons(AV_REMOTE_SVCLASS_ID);
944
945 avrcp->code = CTYPE_CONTROL;
946 avrcp->subunit_type = SUBUNIT_PANEL;
947 avrcp->opcode = OP_PASSTHROUGH;
948
949 operands[0] = op & 0x7f;
950 operands[1] = 0;
951
952 err = write(sk, buf, sizeof(buf));
953 if (err < 0)
954 return err;
955
956 /* Button release */
957 avctp->transaction = transaction++;
958 operands[0] |= 0x80;
959
960 return write(sk, buf, sizeof(buf));
961 }
962
volume_up(DBusConnection * conn,DBusMessage * msg,void * data)963 static DBusMessage *volume_up(DBusConnection *conn, DBusMessage *msg,
964 void *data)
965 {
966 struct audio_device *device = data;
967 struct control *control = device->control;
968 DBusMessage *reply;
969 int err;
970
971 reply = dbus_message_new_method_return(msg);
972 if (!reply)
973 return NULL;
974
975 if (control->state != AVCTP_STATE_CONNECTED)
976 return g_dbus_create_error(msg,
977 ERROR_INTERFACE ".NotConnected",
978 "Device not Connected");
979
980 if (!control->target)
981 return g_dbus_create_error(msg,
982 ERROR_INTERFACE ".NotSupported",
983 "AVRCP Target role not supported");
984
985 err = avctp_send_passthrough(control, VOL_UP_OP);
986 if (err < 0)
987 return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
988 strerror(-err));
989
990 return dbus_message_new_method_return(msg);
991 }
992
volume_down(DBusConnection * conn,DBusMessage * msg,void * data)993 static DBusMessage *volume_down(DBusConnection *conn, DBusMessage *msg,
994 void *data)
995 {
996 struct audio_device *device = data;
997 struct control *control = device->control;
998 DBusMessage *reply;
999 int err;
1000
1001 reply = dbus_message_new_method_return(msg);
1002 if (!reply)
1003 return NULL;
1004
1005 if (control->state != AVCTP_STATE_CONNECTED)
1006 return g_dbus_create_error(msg,
1007 ERROR_INTERFACE ".NotConnected",
1008 "Device not Connected");
1009
1010 if (!control->target)
1011 return g_dbus_create_error(msg,
1012 ERROR_INTERFACE ".NotSupported",
1013 "AVRCP Target role not supported");
1014
1015 err = avctp_send_passthrough(control, VOL_DOWN_OP);
1016 if (err < 0)
1017 return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
1018 strerror(-err));
1019
1020 return dbus_message_new_method_return(msg);
1021 }
1022
control_get_properties(DBusConnection * conn,DBusMessage * msg,void * data)1023 static DBusMessage *control_get_properties(DBusConnection *conn,
1024 DBusMessage *msg, void *data)
1025 {
1026 struct audio_device *device = data;
1027 DBusMessage *reply;
1028 DBusMessageIter iter;
1029 DBusMessageIter dict;
1030 gboolean value;
1031
1032 reply = dbus_message_new_method_return(msg);
1033 if (!reply)
1034 return NULL;
1035
1036 dbus_message_iter_init_append(reply, &iter);
1037
1038 dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1039 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1040 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
1041 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
1042
1043 /* Connected */
1044 value = (device->control->state == AVCTP_STATE_CONNECTED);
1045 dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &value);
1046
1047 dbus_message_iter_close_container(&iter, &dict);
1048
1049 return reply;
1050 }
1051
1052 static GDBusMethodTable control_methods[] = {
1053 { "IsConnected", "", "b", control_is_connected,
1054 G_DBUS_METHOD_FLAG_DEPRECATED },
1055 { "GetProperties", "", "a{sv}",control_get_properties },
1056 { "VolumeUp", "", "", volume_up },
1057 { "VolumeDown", "", "", volume_down },
1058 { NULL, NULL, NULL, NULL }
1059 };
1060
1061 static GDBusSignalTable control_signals[] = {
1062 { "Connected", "", G_DBUS_SIGNAL_FLAG_DEPRECATED},
1063 { "Disconnected", "", G_DBUS_SIGNAL_FLAG_DEPRECATED},
1064 { "PropertyChanged", "sv" },
1065 { NULL, NULL }
1066 };
1067
path_unregister(void * data)1068 static void path_unregister(void *data)
1069 {
1070 struct audio_device *dev = data;
1071 struct control *control = dev->control;
1072
1073 debug("Unregistered interface %s on path %s",
1074 AUDIO_CONTROL_INTERFACE, dev->path);
1075
1076 if (control->state != AVCTP_STATE_DISCONNECTED)
1077 avctp_disconnected(dev);
1078
1079 g_free(control);
1080 dev->control = NULL;
1081 }
1082
control_unregister(struct audio_device * dev)1083 void control_unregister(struct audio_device *dev)
1084 {
1085 g_dbus_unregister_interface(dev->conn, dev->path,
1086 AUDIO_CONTROL_INTERFACE);
1087 }
1088
control_update(struct audio_device * dev,uint16_t uuid16)1089 void control_update(struct audio_device *dev, uint16_t uuid16)
1090 {
1091 struct control *control = dev->control;
1092
1093 if (uuid16 == AV_REMOTE_TARGET_SVCLASS_ID)
1094 control->target = TRUE;
1095 }
1096
control_init(struct audio_device * dev,uint16_t uuid16)1097 struct control *control_init(struct audio_device *dev, uint16_t uuid16)
1098 {
1099 struct control *control;
1100
1101 if (!g_dbus_register_interface(dev->conn, dev->path,
1102 AUDIO_CONTROL_INTERFACE,
1103 control_methods, control_signals, NULL,
1104 dev, path_unregister))
1105 return NULL;
1106
1107 debug("Registered interface %s on path %s",
1108 AUDIO_CONTROL_INTERFACE, dev->path);
1109
1110 control = g_new0(struct control, 1);
1111 control->dev = dev;
1112 control->state = AVCTP_STATE_DISCONNECTED;
1113 control->uinput = -1;
1114
1115 if (uuid16 == AV_REMOTE_TARGET_SVCLASS_ID)
1116 control->target = TRUE;
1117
1118 return control;
1119 }
1120
control_is_active(struct audio_device * dev)1121 gboolean control_is_active(struct audio_device *dev)
1122 {
1123 struct control *control = dev->control;
1124
1125 if (control && control->state != AVCTP_STATE_DISCONNECTED)
1126 return TRUE;
1127
1128 return FALSE;
1129 }
1130
avctp_add_state_cb(avctp_state_cb cb,void * user_data)1131 unsigned int avctp_add_state_cb(avctp_state_cb cb, void *user_data)
1132 {
1133 struct avctp_state_callback *state_cb;
1134 static unsigned int id = 0;
1135
1136 state_cb = g_new(struct avctp_state_callback, 1);
1137 state_cb->cb = cb;
1138 state_cb->user_data = user_data;
1139 state_cb->id = ++id;
1140
1141 avctp_callbacks = g_slist_append(avctp_callbacks, state_cb);
1142
1143 return state_cb->id;
1144 }
1145
avctp_remove_state_cb(unsigned int id)1146 gboolean avctp_remove_state_cb(unsigned int id)
1147 {
1148 GSList *l;
1149
1150 for (l = avctp_callbacks; l != NULL; l = l->next) {
1151 struct avctp_state_callback *cb = l->data;
1152 if (cb && cb->id == id) {
1153 avctp_callbacks = g_slist_remove(avctp_callbacks, cb);
1154 g_free(cb);
1155 return TRUE;
1156 }
1157 }
1158
1159 return FALSE;
1160 }
1161