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