btio.c revision 85bf920f1f67d77ea2827e3f9ad78443cba1d9a1
1/* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2009-2010 Marcel Holtmann <marcel@holtmann.org> 6 * Copyright (C) 2009-2010 Nokia Corporation 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#include <stdarg.h> 25#include <stdlib.h> 26#include <unistd.h> 27#include <errno.h> 28#include <poll.h> 29#include <sys/types.h> 30#include <sys/socket.h> 31 32#include <bluetooth/bluetooth.h> 33#include <bluetooth/l2cap.h> 34#include <bluetooth/rfcomm.h> 35#include <bluetooth/sco.h> 36#include <bluetooth/hci.h> 37#include <bluetooth/hci_lib.h> 38 39#include <glib.h> 40 41#include "btio.h" 42 43#define ERROR_FAILED(gerr, str, err) \ 44 g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_FAILED, \ 45 str ": %s (%d)", strerror(err), err) 46 47#define DEFAULT_DEFER_TIMEOUT 30 48 49struct set_opts { 50 bdaddr_t src; 51 bdaddr_t dst; 52 int defer; 53 int sec_level; 54 uint8_t channel; 55 uint16_t psm; 56 uint16_t cid; 57 uint16_t mtu; 58 uint16_t imtu; 59 uint16_t omtu; 60 int master; 61 uint8_t mode; 62}; 63 64struct connect { 65 BtIOConnect connect; 66 gpointer user_data; 67 GDestroyNotify destroy; 68}; 69 70struct accept { 71 BtIOConnect connect; 72 gpointer user_data; 73 GDestroyNotify destroy; 74}; 75 76struct server { 77 BtIOConnect connect; 78 BtIOConfirm confirm; 79 gpointer user_data; 80 GDestroyNotify destroy; 81}; 82 83static void server_remove(struct server *server) 84{ 85 if (server->destroy) 86 server->destroy(server->user_data); 87 g_free(server); 88} 89 90static void connect_remove(struct connect *conn) 91{ 92 if (conn->destroy) 93 conn->destroy(conn->user_data); 94 g_free(conn); 95} 96 97static void accept_remove(struct accept *accept) 98{ 99 if (accept->destroy) 100 accept->destroy(accept->user_data); 101 g_free(accept); 102} 103 104static gboolean check_nval(GIOChannel *io) 105{ 106 struct pollfd fds; 107 108 memset(&fds, 0, sizeof(fds)); 109 fds.fd = g_io_channel_unix_get_fd(io); 110 fds.events = POLLNVAL; 111 112 if (poll(&fds, 1, 0) > 0 && (fds.revents & POLLNVAL)) 113 return TRUE; 114 115 return FALSE; 116} 117 118static gboolean accept_cb(GIOChannel *io, GIOCondition cond, 119 gpointer user_data) 120{ 121 struct accept *accept = user_data; 122 GError *err = NULL; 123 124 /* If the user aborted this accept attempt */ 125 if ((cond & G_IO_NVAL) || check_nval(io)) 126 return FALSE; 127 128 if (cond & (G_IO_HUP | G_IO_ERR)) 129 g_set_error(&err, BT_IO_ERROR, BT_IO_ERROR_DISCONNECTED, 130 "HUP or ERR on socket"); 131 132 accept->connect(io, err, accept->user_data); 133 134 g_clear_error(&err); 135 136 return FALSE; 137} 138 139static gboolean connect_cb(GIOChannel *io, GIOCondition cond, 140 gpointer user_data) 141{ 142 struct connect *conn = user_data; 143 GError *gerr = NULL; 144 145 /* If the user aborted this connect attempt */ 146 if ((cond & G_IO_NVAL) || check_nval(io)) 147 return FALSE; 148 149 if (cond & G_IO_OUT) { 150 int err = 0, sock = g_io_channel_unix_get_fd(io); 151 socklen_t len = sizeof(err); 152 153 if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &err, &len) < 0) 154 err = errno; 155 156 if (err) 157 g_set_error(&gerr, BT_IO_ERROR, 158 BT_IO_ERROR_CONNECT_FAILED, "%s (%d)", 159 strerror(err), err); 160 } else if (cond & (G_IO_HUP | G_IO_ERR)) 161 g_set_error(&gerr, BT_IO_ERROR, BT_IO_ERROR_CONNECT_FAILED, 162 "HUP or ERR on socket"); 163 164 conn->connect(io, gerr, conn->user_data); 165 166 if (gerr) 167 g_error_free(gerr); 168 169 return FALSE; 170} 171 172static gboolean server_cb(GIOChannel *io, GIOCondition cond, 173 gpointer user_data) 174{ 175 struct server *server = user_data; 176 int srv_sock, cli_sock; 177 GIOChannel *cli_io; 178 179 /* If the user closed the server */ 180 if ((cond & G_IO_NVAL) || check_nval(io)) 181 return FALSE; 182 183 srv_sock = g_io_channel_unix_get_fd(io); 184 185 cli_sock = accept(srv_sock, NULL, NULL); 186 if (cli_sock < 0) 187 return TRUE; 188 189 cli_io = g_io_channel_unix_new(cli_sock); 190 191 g_io_channel_set_close_on_unref(cli_io, TRUE); 192 g_io_channel_set_flags(cli_io, G_IO_FLAG_NONBLOCK, NULL); 193 194 if (server->confirm) 195 server->confirm(cli_io, server->user_data); 196 else 197 server->connect(cli_io, NULL, server->user_data); 198 199 g_io_channel_unref(cli_io); 200 201 return TRUE; 202} 203 204static void server_add(GIOChannel *io, BtIOConnect connect, 205 BtIOConfirm confirm, gpointer user_data, 206 GDestroyNotify destroy) 207{ 208 struct server *server; 209 GIOCondition cond; 210 211 server = g_new0(struct server, 1); 212 server->connect = connect; 213 server->confirm = confirm; 214 server->user_data = user_data; 215 server->destroy = destroy; 216 217 cond = G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL; 218 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, server_cb, server, 219 (GDestroyNotify) server_remove); 220} 221 222static void connect_add(GIOChannel *io, BtIOConnect connect, 223 gpointer user_data, GDestroyNotify destroy) 224{ 225 struct connect *conn; 226 GIOCondition cond; 227 228 conn = g_new0(struct connect, 1); 229 conn->connect = connect; 230 conn->user_data = user_data; 231 conn->destroy = destroy; 232 233 cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL; 234 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, connect_cb, conn, 235 (GDestroyNotify) connect_remove); 236} 237 238static void accept_add(GIOChannel *io, BtIOConnect connect, gpointer user_data, 239 GDestroyNotify destroy) 240{ 241 struct accept *accept; 242 GIOCondition cond; 243 244 accept = g_new0(struct accept, 1); 245 accept->connect = connect; 246 accept->user_data = user_data; 247 accept->destroy = destroy; 248 249 cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL; 250 g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, accept_cb, accept, 251 (GDestroyNotify) accept_remove); 252} 253 254static int l2cap_bind(int sock, const bdaddr_t *src, uint16_t psm, 255 uint16_t cid, GError **err) 256{ 257 struct sockaddr_l2 addr; 258 259 memset(&addr, 0, sizeof(addr)); 260 addr.l2_family = AF_BLUETOOTH; 261 bacpy(&addr.l2_bdaddr, src); 262 263 if (cid) 264 addr.l2_cid = htobs(cid); 265 else 266 addr.l2_psm = htobs(psm); 267 268 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 269 ERROR_FAILED(err, "l2cap_bind", errno); 270 return -1; 271 } 272 273 return 0; 274} 275 276static int l2cap_connect(int sock, const bdaddr_t *dst, 277 uint16_t psm, uint16_t cid) 278{ 279 int err; 280 struct sockaddr_l2 addr; 281 282 memset(&addr, 0, sizeof(addr)); 283 addr.l2_family = AF_BLUETOOTH; 284 bacpy(&addr.l2_bdaddr, dst); 285 if (cid) 286 addr.l2_cid = htobs(cid); 287 else 288 addr.l2_psm = htobs(psm); 289 290 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr)); 291 if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS)) 292 return err; 293 294 return 0; 295} 296 297static int l2cap_set_master(int sock, int master) 298{ 299 int flags; 300 socklen_t len; 301 302 len = sizeof(flags); 303 if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, &len) < 0) 304 return -errno; 305 306 if (master) { 307 if (flags & L2CAP_LM_MASTER) 308 return 0; 309 flags |= L2CAP_LM_MASTER; 310 } else { 311 if (!(flags & L2CAP_LM_MASTER)) 312 return 0; 313 flags &= ~L2CAP_LM_MASTER; 314 } 315 316 if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, sizeof(flags)) < 0) 317 return -errno; 318 319 return 0; 320} 321 322static int rfcomm_set_master(int sock, int master) 323{ 324 int flags; 325 socklen_t len; 326 327 len = sizeof(flags); 328 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, &len) < 0) 329 return -errno; 330 331 if (master) { 332 if (flags & RFCOMM_LM_MASTER) 333 return 0; 334 flags |= RFCOMM_LM_MASTER; 335 } else { 336 if (!(flags & RFCOMM_LM_MASTER)) 337 return 0; 338 flags &= ~RFCOMM_LM_MASTER; 339 } 340 341 if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, sizeof(flags)) < 0) 342 return -errno; 343 344 return 0; 345} 346 347static int l2cap_set_lm(int sock, int level) 348{ 349 int lm_map[] = { 350 0, 351 L2CAP_LM_AUTH, 352 L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT, 353 L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT | L2CAP_LM_SECURE, 354 }, opt = lm_map[level]; 355 356 if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0) 357 return -errno; 358 359 return 0; 360} 361 362static int rfcomm_set_lm(int sock, int level) 363{ 364 int lm_map[] = { 365 0, 366 RFCOMM_LM_AUTH, 367 RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT, 368 RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT | RFCOMM_LM_SECURE, 369 }, opt = lm_map[level]; 370 371 if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, sizeof(opt)) < 0) 372 return -errno; 373 374 return 0; 375} 376 377static gboolean set_sec_level(int sock, BtIOType type, int level, GError **err) 378{ 379 struct bt_security sec; 380 int ret; 381 382 if (level < BT_SECURITY_LOW || level > BT_SECURITY_HIGH) { 383 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 384 "Valid security level range is %d-%d", 385 BT_SECURITY_LOW, BT_SECURITY_HIGH); 386 return FALSE; 387 } 388 389 memset(&sec, 0, sizeof(sec)); 390 sec.level = level; 391 392 if (setsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec, 393 sizeof(sec)) == 0) 394 return TRUE; 395 396 if (errno != ENOPROTOOPT) { 397 ERROR_FAILED(err, "setsockopt(BT_SECURITY)", errno); 398 return FALSE; 399 } 400 401 if (type == BT_IO_L2CAP) 402 ret = l2cap_set_lm(sock, level); 403 else 404 ret = rfcomm_set_lm(sock, level); 405 406 if (ret < 0) { 407 ERROR_FAILED(err, "setsockopt(LM)", -ret); 408 return FALSE; 409 } 410 411 return TRUE; 412} 413 414static int l2cap_get_lm(int sock, int *sec_level) 415{ 416 int opt; 417 socklen_t len; 418 419 len = sizeof(opt); 420 if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, &len) < 0) 421 return -errno; 422 423 *sec_level = 0; 424 425 if (opt & L2CAP_LM_AUTH) 426 *sec_level = BT_SECURITY_LOW; 427 if (opt & L2CAP_LM_ENCRYPT) 428 *sec_level = BT_SECURITY_MEDIUM; 429 if (opt & L2CAP_LM_SECURE) 430 *sec_level = BT_SECURITY_HIGH; 431 432 return 0; 433} 434 435static int rfcomm_get_lm(int sock, int *sec_level) 436{ 437 int opt; 438 socklen_t len; 439 440 len = sizeof(opt); 441 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, &len) < 0) 442 return -errno; 443 444 *sec_level = 0; 445 446 if (opt & RFCOMM_LM_AUTH) 447 *sec_level = BT_SECURITY_LOW; 448 if (opt & RFCOMM_LM_ENCRYPT) 449 *sec_level = BT_SECURITY_MEDIUM; 450 if (opt & RFCOMM_LM_SECURE) 451 *sec_level = BT_SECURITY_HIGH; 452 453 return 0; 454} 455 456static gboolean get_sec_level(int sock, BtIOType type, int *level, 457 GError **err) 458{ 459 struct bt_security sec; 460 socklen_t len; 461 int ret; 462 463 memset(&sec, 0, sizeof(sec)); 464 len = sizeof(sec); 465 if (getsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec, &len) == 0) { 466 *level = sec.level; 467 return TRUE; 468 } 469 470 if (errno != ENOPROTOOPT) { 471 ERROR_FAILED(err, "getsockopt(BT_SECURITY)", errno); 472 return FALSE; 473 } 474 475 if (type == BT_IO_L2CAP) 476 ret = l2cap_get_lm(sock, level); 477 else 478 ret = rfcomm_get_lm(sock, level); 479 480 if (ret < 0) { 481 ERROR_FAILED(err, "getsockopt(LM)", -ret); 482 return FALSE; 483 } 484 485 return TRUE; 486} 487 488static gboolean l2cap_set(int sock, int sec_level, uint16_t imtu, uint16_t omtu, 489 uint8_t mode, int master, GError **err) 490{ 491 if (imtu || omtu || mode) { 492 struct l2cap_options l2o; 493 socklen_t len; 494 495 memset(&l2o, 0, sizeof(l2o)); 496 len = sizeof(l2o); 497 if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o, 498 &len) < 0) { 499 ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno); 500 return FALSE; 501 } 502 503 if (imtu) 504 l2o.imtu = imtu; 505 if (omtu) 506 l2o.omtu = omtu; 507 if (mode) 508 l2o.mode = mode; 509 510 if (setsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o, 511 sizeof(l2o)) < 0) { 512 ERROR_FAILED(err, "setsockopt(L2CAP_OPTIONS)", errno); 513 return FALSE; 514 } 515 } 516 517 if (master >= 0 && l2cap_set_master(sock, master) < 0) { 518 ERROR_FAILED(err, "l2cap_set_master", errno); 519 return FALSE; 520 } 521 522 if (sec_level && !set_sec_level(sock, BT_IO_L2CAP, sec_level, err)) 523 return FALSE; 524 525 return TRUE; 526} 527 528static int rfcomm_bind(int sock, 529 const bdaddr_t *src, uint8_t channel, GError **err) 530{ 531 struct sockaddr_rc addr; 532 533 memset(&addr, 0, sizeof(addr)); 534 addr.rc_family = AF_BLUETOOTH; 535 bacpy(&addr.rc_bdaddr, src); 536 addr.rc_channel = channel; 537 538 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 539 ERROR_FAILED(err, "rfcomm_bind", errno); 540 return -1; 541 } 542 543 return 0; 544} 545 546static int rfcomm_connect(int sock, const bdaddr_t *dst, uint8_t channel) 547{ 548 int err; 549 struct sockaddr_rc addr; 550 551 memset(&addr, 0, sizeof(addr)); 552 addr.rc_family = AF_BLUETOOTH; 553 bacpy(&addr.rc_bdaddr, dst); 554 addr.rc_channel = channel; 555 556 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr)); 557 if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS)) 558 return err; 559 560 return 0; 561} 562 563static gboolean rfcomm_set(int sock, int sec_level, int master, GError **err) 564{ 565 if (sec_level && !set_sec_level(sock, BT_IO_RFCOMM, sec_level, err)) 566 return FALSE; 567 568 if (master >= 0 && rfcomm_set_master(sock, master) < 0) { 569 ERROR_FAILED(err, "rfcomm_set_master", errno); 570 return FALSE; 571 } 572 573 return TRUE; 574} 575 576static int sco_bind(int sock, const bdaddr_t *src, GError **err) 577{ 578 struct sockaddr_sco addr; 579 580 memset(&addr, 0, sizeof(addr)); 581 addr.sco_family = AF_BLUETOOTH; 582 bacpy(&addr.sco_bdaddr, src); 583 584 if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 585 ERROR_FAILED(err, "sco_bind", errno); 586 return -1; 587 } 588 589 return 0; 590} 591 592static int sco_connect(int sock, const bdaddr_t *dst) 593{ 594 struct sockaddr_sco addr; 595 int err; 596 597 memset(&addr, 0, sizeof(addr)); 598 addr.sco_family = AF_BLUETOOTH; 599 bacpy(&addr.sco_bdaddr, dst); 600 601 err = connect(sock, (struct sockaddr *) &addr, sizeof(addr)); 602 if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS)) 603 return err; 604 605 return 0; 606} 607 608static gboolean sco_set(int sock, uint16_t mtu, GError **err) 609{ 610 struct sco_options sco_opt; 611 socklen_t len; 612 613 if (!mtu) 614 return TRUE; 615 616 len = sizeof(sco_opt); 617 memset(&sco_opt, 0, len); 618 if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) { 619 ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno); 620 return FALSE; 621 } 622 623 sco_opt.mtu = mtu; 624 if (setsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, 625 sizeof(sco_opt)) < 0) { 626 ERROR_FAILED(err, "setsockopt(SCO_OPTIONS)", errno); 627 return FALSE; 628 } 629 630 return TRUE; 631} 632 633static gboolean parse_set_opts(struct set_opts *opts, GError **err, 634 BtIOOption opt1, va_list args) 635{ 636 BtIOOption opt = opt1; 637 const char *str; 638 639 memset(opts, 0, sizeof(*opts)); 640 641 /* Set defaults */ 642 opts->defer = DEFAULT_DEFER_TIMEOUT; 643 opts->master = -1; 644 opts->sec_level = BT_IO_SEC_MEDIUM; 645 opts->mode = L2CAP_MODE_BASIC; 646 647 while (opt != BT_IO_OPT_INVALID) { 648 switch (opt) { 649 case BT_IO_OPT_SOURCE: 650 str = va_arg(args, const char *); 651 if (strncasecmp(str, "hci", 3) == 0) 652 hci_devba(atoi(str + 3), &opts->src); 653 else 654 str2ba(str, &opts->src); 655 break; 656 case BT_IO_OPT_SOURCE_BDADDR: 657 bacpy(&opts->src, va_arg(args, const bdaddr_t *)); 658 break; 659 case BT_IO_OPT_DEST: 660 str2ba(va_arg(args, const char *), &opts->dst); 661 break; 662 case BT_IO_OPT_DEST_BDADDR: 663 bacpy(&opts->dst, va_arg(args, const bdaddr_t *)); 664 break; 665 case BT_IO_OPT_DEFER_TIMEOUT: 666 opts->defer = va_arg(args, int); 667 break; 668 case BT_IO_OPT_SEC_LEVEL: 669 opts->sec_level = va_arg(args, int); 670 break; 671 case BT_IO_OPT_CHANNEL: 672 opts->channel = va_arg(args, int); 673 break; 674 case BT_IO_OPT_PSM: 675 opts->psm = va_arg(args, int); 676 break; 677 case BT_IO_OPT_CID: 678 opts->cid = va_arg(args, int); 679 break; 680 case BT_IO_OPT_MTU: 681 opts->mtu = va_arg(args, int); 682 opts->imtu = opts->mtu; 683 opts->omtu = opts->mtu; 684 break; 685 case BT_IO_OPT_OMTU: 686 opts->omtu = va_arg(args, int); 687 if (!opts->mtu) 688 opts->mtu = opts->omtu; 689 break; 690 case BT_IO_OPT_IMTU: 691 opts->imtu = va_arg(args, int); 692 if (!opts->mtu) 693 opts->mtu = opts->imtu; 694 break; 695 case BT_IO_OPT_MASTER: 696 opts->master = va_arg(args, gboolean); 697 break; 698 case BT_IO_OPT_MODE: 699 opts->mode = va_arg(args, int); 700 break; 701 default: 702 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 703 "Unknown option %d", opt); 704 return FALSE; 705 } 706 707 opt = va_arg(args, int); 708 } 709 710 return TRUE; 711} 712 713static gboolean get_peers(int sock, struct sockaddr *src, struct sockaddr *dst, 714 socklen_t len, GError **err) 715{ 716 socklen_t olen; 717 718 memset(src, 0, len); 719 olen = len; 720 if (getsockname(sock, src, &olen) < 0) { 721 ERROR_FAILED(err, "getsockname", errno); 722 return FALSE; 723 } 724 725 memset(dst, 0, len); 726 olen = len; 727 if (getpeername(sock, dst, &olen) < 0) { 728 ERROR_FAILED(err, "getpeername", errno); 729 return FALSE; 730 } 731 732 return TRUE; 733} 734 735static int l2cap_get_info(int sock, uint16_t *handle, uint8_t *dev_class) 736{ 737 struct l2cap_conninfo info; 738 socklen_t len; 739 740 len = sizeof(info); 741 if (getsockopt(sock, SOL_L2CAP, L2CAP_CONNINFO, &info, &len) < 0) 742 return -errno; 743 744 if (handle) 745 *handle = info.hci_handle; 746 747 if (dev_class) 748 memcpy(dev_class, info.dev_class, 3); 749 750 return 0; 751} 752 753static gboolean l2cap_get(int sock, GError **err, BtIOOption opt1, 754 va_list args) 755{ 756 BtIOOption opt = opt1; 757 struct sockaddr_l2 src, dst; 758 struct l2cap_options l2o; 759 int flags; 760 uint8_t dev_class[3]; 761 uint16_t handle; 762 socklen_t len; 763 764 len = sizeof(l2o); 765 memset(&l2o, 0, len); 766 if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o, &len) < 0) { 767 ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno); 768 return FALSE; 769 } 770 771 if (!get_peers(sock, (struct sockaddr *) &src, 772 (struct sockaddr *) &dst, sizeof(src), err)) 773 return FALSE; 774 775 while (opt != BT_IO_OPT_INVALID) { 776 switch (opt) { 777 case BT_IO_OPT_SOURCE: 778 ba2str(&src.l2_bdaddr, va_arg(args, char *)); 779 break; 780 case BT_IO_OPT_SOURCE_BDADDR: 781 bacpy(va_arg(args, bdaddr_t *), &src.l2_bdaddr); 782 break; 783 case BT_IO_OPT_DEST: 784 ba2str(&dst.l2_bdaddr, va_arg(args, char *)); 785 break; 786 case BT_IO_OPT_DEST_BDADDR: 787 bacpy(va_arg(args, bdaddr_t *), &dst.l2_bdaddr); 788 break; 789 case BT_IO_OPT_DEFER_TIMEOUT: 790 len = sizeof(int); 791 if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP, 792 va_arg(args, int *), &len) < 0) { 793 ERROR_FAILED(err, "getsockopt(DEFER_SETUP)", 794 errno); 795 return FALSE; 796 } 797 break; 798 case BT_IO_OPT_SEC_LEVEL: 799 if (!get_sec_level(sock, BT_IO_L2CAP, 800 va_arg(args, int *), err)) 801 return FALSE; 802 break; 803 case BT_IO_OPT_PSM: 804 *(va_arg(args, uint16_t *)) = src.l2_psm ? 805 src.l2_psm : dst.l2_psm; 806 break; 807 case BT_IO_OPT_CID: 808 *(va_arg(args, uint16_t *)) = src.l2_cid ? 809 src.l2_cid : dst.l2_cid; 810 break; 811 case BT_IO_OPT_OMTU: 812 *(va_arg(args, uint16_t *)) = l2o.omtu; 813 break; 814 case BT_IO_OPT_IMTU: 815 *(va_arg(args, uint16_t *)) = l2o.imtu; 816 break; 817 case BT_IO_OPT_MASTER: 818 len = sizeof(flags); 819 if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, 820 &len) < 0) { 821 ERROR_FAILED(err, "getsockopt(L2CAP_LM)", 822 errno); 823 return FALSE; 824 } 825 *(va_arg(args, gboolean *)) = 826 (flags & L2CAP_LM_MASTER) ? TRUE : FALSE; 827 break; 828 case BT_IO_OPT_HANDLE: 829 if (l2cap_get_info(sock, &handle, dev_class) < 0) { 830 ERROR_FAILED(err, "L2CAP_CONNINFO", errno); 831 return FALSE; 832 } 833 *(va_arg(args, uint16_t *)) = handle; 834 break; 835 case BT_IO_OPT_CLASS: 836 if (l2cap_get_info(sock, &handle, dev_class) < 0) { 837 ERROR_FAILED(err, "L2CAP_CONNINFO", errno); 838 return FALSE; 839 } 840 memcpy(va_arg(args, uint8_t *), dev_class, 3); 841 break; 842 case BT_IO_OPT_MODE: 843 *(va_arg(args, uint8_t *)) = l2o.mode; 844 break; 845 default: 846 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 847 "Unknown option %d", opt); 848 return FALSE; 849 } 850 851 opt = va_arg(args, int); 852 } 853 854 return TRUE; 855} 856 857static int rfcomm_get_info(int sock, uint16_t *handle, uint8_t *dev_class) 858{ 859 struct rfcomm_conninfo info; 860 socklen_t len; 861 862 len = sizeof(info); 863 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_CONNINFO, &info, &len) < 0) 864 return -errno; 865 866 if (handle) 867 *handle = info.hci_handle; 868 869 if (dev_class) 870 memcpy(dev_class, info.dev_class, 3); 871 872 return 0; 873} 874 875static gboolean rfcomm_get(int sock, GError **err, BtIOOption opt1, 876 va_list args) 877{ 878 BtIOOption opt = opt1; 879 struct sockaddr_rc src, dst; 880 int flags; 881 socklen_t len; 882 uint8_t dev_class[3]; 883 uint16_t handle; 884 885 if (!get_peers(sock, (struct sockaddr *) &src, 886 (struct sockaddr *) &dst, sizeof(src), err)) 887 return FALSE; 888 889 while (opt != BT_IO_OPT_INVALID) { 890 switch (opt) { 891 case BT_IO_OPT_SOURCE: 892 ba2str(&src.rc_bdaddr, va_arg(args, char *)); 893 break; 894 case BT_IO_OPT_SOURCE_BDADDR: 895 bacpy(va_arg(args, bdaddr_t *), &src.rc_bdaddr); 896 break; 897 case BT_IO_OPT_DEST: 898 ba2str(&dst.rc_bdaddr, va_arg(args, char *)); 899 break; 900 case BT_IO_OPT_DEST_BDADDR: 901 bacpy(va_arg(args, bdaddr_t *), &dst.rc_bdaddr); 902 break; 903 case BT_IO_OPT_DEFER_TIMEOUT: 904 len = sizeof(int); 905 if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP, 906 va_arg(args, int *), &len) < 0) { 907 ERROR_FAILED(err, "getsockopt(DEFER_SETUP)", 908 errno); 909 return FALSE; 910 } 911 break; 912 case BT_IO_OPT_SEC_LEVEL: 913 if (!get_sec_level(sock, BT_IO_RFCOMM, 914 va_arg(args, int *), err)) 915 return FALSE; 916 break; 917 case BT_IO_OPT_CHANNEL: 918 *(va_arg(args, uint8_t *)) = src.rc_channel ? 919 src.rc_channel : dst.rc_channel; 920 break; 921 case BT_IO_OPT_SOURCE_CHANNEL: 922 *(va_arg(args, uint8_t *)) = src.rc_channel; 923 break; 924 case BT_IO_OPT_DEST_CHANNEL: 925 *(va_arg(args, uint8_t *)) = dst.rc_channel; 926 break; 927 case BT_IO_OPT_MASTER: 928 len = sizeof(flags); 929 if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, 930 &len) < 0) { 931 ERROR_FAILED(err, "getsockopt(RFCOMM_LM)", 932 errno); 933 return FALSE; 934 } 935 *(va_arg(args, gboolean *)) = 936 (flags & RFCOMM_LM_MASTER) ? TRUE : FALSE; 937 break; 938 case BT_IO_OPT_HANDLE: 939 if (rfcomm_get_info(sock, &handle, dev_class) < 0) { 940 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno); 941 return FALSE; 942 } 943 *(va_arg(args, uint16_t *)) = handle; 944 break; 945 case BT_IO_OPT_CLASS: 946 if (rfcomm_get_info(sock, &handle, dev_class) < 0) { 947 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno); 948 return FALSE; 949 } 950 memcpy(va_arg(args, uint8_t *), dev_class, 3); 951 break; 952 default: 953 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 954 "Unknown option %d", opt); 955 return FALSE; 956 } 957 958 opt = va_arg(args, int); 959 } 960 961 return TRUE; 962} 963 964static int sco_get_info(int sock, uint16_t *handle, uint8_t *dev_class) 965{ 966 struct sco_conninfo info; 967 socklen_t len; 968 969 len = sizeof(info); 970 if (getsockopt(sock, SOL_SCO, SCO_CONNINFO, &info, &len) < 0) 971 return -errno; 972 973 if (handle) 974 *handle = info.hci_handle; 975 976 if (dev_class) 977 memcpy(dev_class, info.dev_class, 3); 978 979 return 0; 980} 981 982static gboolean sco_get(int sock, GError **err, BtIOOption opt1, va_list args) 983{ 984 BtIOOption opt = opt1; 985 struct sockaddr_sco src, dst; 986 struct sco_options sco_opt; 987 socklen_t len; 988 uint8_t dev_class[3]; 989 uint16_t handle; 990 991 len = sizeof(sco_opt); 992 memset(&sco_opt, 0, len); 993 if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) { 994 ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno); 995 return FALSE; 996 } 997 998 if (!get_peers(sock, (struct sockaddr *) &src, 999 (struct sockaddr *) &dst, sizeof(src), err)) 1000 return FALSE; 1001 1002 while (opt != BT_IO_OPT_INVALID) { 1003 switch (opt) { 1004 case BT_IO_OPT_SOURCE: 1005 ba2str(&src.sco_bdaddr, va_arg(args, char *)); 1006 break; 1007 case BT_IO_OPT_SOURCE_BDADDR: 1008 bacpy(va_arg(args, bdaddr_t *), &src.sco_bdaddr); 1009 break; 1010 case BT_IO_OPT_DEST: 1011 ba2str(&dst.sco_bdaddr, va_arg(args, char *)); 1012 break; 1013 case BT_IO_OPT_DEST_BDADDR: 1014 bacpy(va_arg(args, bdaddr_t *), &dst.sco_bdaddr); 1015 break; 1016 case BT_IO_OPT_MTU: 1017 case BT_IO_OPT_IMTU: 1018 case BT_IO_OPT_OMTU: 1019 *(va_arg(args, uint16_t *)) = sco_opt.mtu; 1020 break; 1021 case BT_IO_OPT_HANDLE: 1022 if (sco_get_info(sock, &handle, dev_class) < 0) { 1023 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno); 1024 return FALSE; 1025 } 1026 *(va_arg(args, uint16_t *)) = handle; 1027 break; 1028 case BT_IO_OPT_CLASS: 1029 if (sco_get_info(sock, &handle, dev_class) < 0) { 1030 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno); 1031 return FALSE; 1032 } 1033 memcpy(va_arg(args, uint8_t *), dev_class, 3); 1034 break; 1035 default: 1036 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 1037 "Unknown option %d", opt); 1038 return FALSE; 1039 } 1040 1041 opt = va_arg(args, int); 1042 } 1043 1044 return TRUE; 1045} 1046 1047static gboolean get_valist(GIOChannel *io, BtIOType type, GError **err, 1048 BtIOOption opt1, va_list args) 1049{ 1050 int sock; 1051 1052 sock = g_io_channel_unix_get_fd(io); 1053 1054 switch (type) { 1055 case BT_IO_L2RAW: 1056 case BT_IO_L2CAP: 1057 return l2cap_get(sock, err, opt1, args); 1058 case BT_IO_RFCOMM: 1059 return rfcomm_get(sock, err, opt1, args); 1060 case BT_IO_SCO: 1061 return sco_get(sock, err, opt1, args); 1062 } 1063 1064 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 1065 "Unknown BtIO type %d", type); 1066 return FALSE; 1067} 1068 1069gboolean bt_io_accept(GIOChannel *io, BtIOConnect connect, gpointer user_data, 1070 GDestroyNotify destroy, GError **err) 1071{ 1072 int sock; 1073 char c; 1074 struct pollfd pfd; 1075 1076 sock = g_io_channel_unix_get_fd(io); 1077 1078 memset(&pfd, 0, sizeof(pfd)); 1079 pfd.fd = sock; 1080 pfd.events = POLLOUT; 1081 1082 if (poll(&pfd, 1, 0) < 0) { 1083 ERROR_FAILED(err, "poll", errno); 1084 return FALSE; 1085 } 1086 1087 if (!(pfd.revents & POLLOUT)) { 1088 int ret; 1089 ret = read(sock, &c, 1); 1090 } 1091 1092 accept_add(io, connect, user_data, destroy); 1093 1094 return TRUE; 1095} 1096 1097gboolean bt_io_set(GIOChannel *io, BtIOType type, GError **err, 1098 BtIOOption opt1, ...) 1099{ 1100 va_list args; 1101 gboolean ret; 1102 struct set_opts opts; 1103 int sock; 1104 1105 va_start(args, opt1); 1106 ret = parse_set_opts(&opts, err, opt1, args); 1107 va_end(args); 1108 1109 if (!ret) 1110 return ret; 1111 1112 sock = g_io_channel_unix_get_fd(io); 1113 1114 switch (type) { 1115 case BT_IO_L2RAW: 1116 case BT_IO_L2CAP: 1117 return l2cap_set(sock, opts.sec_level, opts.imtu, opts.omtu, 1118 opts.mode, opts.master, err); 1119 case BT_IO_RFCOMM: 1120 return rfcomm_set(sock, opts.sec_level, opts.master, err); 1121 case BT_IO_SCO: 1122 return sco_set(sock, opts.mtu, err); 1123 } 1124 1125 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 1126 "Unknown BtIO type %d", type); 1127 return FALSE; 1128} 1129 1130gboolean bt_io_get(GIOChannel *io, BtIOType type, GError **err, 1131 BtIOOption opt1, ...) 1132{ 1133 va_list args; 1134 gboolean ret; 1135 1136 va_start(args, opt1); 1137 ret = get_valist(io, type, err, opt1, args); 1138 va_end(args); 1139 1140 return ret; 1141} 1142 1143static GIOChannel *create_io(BtIOType type, gboolean server, 1144 struct set_opts *opts, GError **err) 1145{ 1146 int sock; 1147 GIOChannel *io; 1148 1149 switch (type) { 1150 case BT_IO_L2RAW: 1151 sock = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_L2CAP); 1152 if (sock < 0) { 1153 ERROR_FAILED(err, "socket(RAW, L2CAP)", errno); 1154 return NULL; 1155 } 1156 if (l2cap_bind(sock, &opts->src, server ? opts->psm : 0, 1157 opts->cid, err) < 0) 1158 goto failed; 1159 if (!l2cap_set(sock, opts->sec_level, 0, 0, 0, -1, err)) 1160 goto failed; 1161 break; 1162 case BT_IO_L2CAP: 1163 sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP); 1164 if (sock < 0) { 1165 ERROR_FAILED(err, "socket(SEQPACKET, L2CAP)", errno); 1166 return NULL; 1167 } 1168 if (l2cap_bind(sock, &opts->src, server ? opts->psm : 0, 1169 opts->cid, err) < 0) 1170 goto failed; 1171 if (!l2cap_set(sock, opts->sec_level, opts->imtu, opts->omtu, 1172 opts->mode, opts->master, err)) 1173 goto failed; 1174 break; 1175 case BT_IO_RFCOMM: 1176 sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); 1177 if (sock < 0) { 1178 ERROR_FAILED(err, "socket(STREAM, RFCOMM)", errno); 1179 return NULL; 1180 } 1181 if (rfcomm_bind(sock, &opts->src, 1182 server ? opts->channel : 0, err) < 0) 1183 goto failed; 1184 if (!rfcomm_set(sock, opts->sec_level, opts->master, err)) 1185 goto failed; 1186 break; 1187 case BT_IO_SCO: 1188 sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO); 1189 if (sock < 0) { 1190 ERROR_FAILED(err, "socket(SEQPACKET, SCO)", errno); 1191 return NULL; 1192 } 1193 if (sco_bind(sock, &opts->src, err) < 0) 1194 goto failed; 1195 if (!sco_set(sock, opts->mtu, err)) 1196 goto failed; 1197 break; 1198 default: 1199 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 1200 "Unknown BtIO type %d", type); 1201 return NULL; 1202 } 1203 1204 io = g_io_channel_unix_new(sock); 1205 1206 g_io_channel_set_close_on_unref(io, TRUE); 1207 g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL); 1208 1209 return io; 1210 1211failed: 1212 close(sock); 1213 1214 return NULL; 1215} 1216 1217GIOChannel *bt_io_connect(BtIOType type, BtIOConnect connect, 1218 gpointer user_data, GDestroyNotify destroy, 1219 GError **gerr, BtIOOption opt1, ...) 1220{ 1221 GIOChannel *io; 1222 va_list args; 1223 struct set_opts opts; 1224 int err, sock; 1225 gboolean ret; 1226 1227 va_start(args, opt1); 1228 ret = parse_set_opts(&opts, gerr, opt1, args); 1229 va_end(args); 1230 1231 if (ret == FALSE) 1232 return NULL; 1233 1234 io = create_io(type, FALSE, &opts, gerr); 1235 if (io == NULL) 1236 return NULL; 1237 1238 sock = g_io_channel_unix_get_fd(io); 1239 1240 switch (type) { 1241 case BT_IO_L2RAW: 1242 err = l2cap_connect(sock, &opts.dst, 0, opts.cid); 1243 break; 1244 case BT_IO_L2CAP: 1245 err = l2cap_connect(sock, &opts.dst, opts.psm, opts.cid); 1246 break; 1247 case BT_IO_RFCOMM: 1248 err = rfcomm_connect(sock, &opts.dst, opts.channel); 1249 break; 1250 case BT_IO_SCO: 1251 err = sco_connect(sock, &opts.dst); 1252 break; 1253 default: 1254 g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 1255 "Unknown BtIO type %d", type); 1256 return NULL; 1257 } 1258 1259 if (err < 0) { 1260 g_set_error(gerr, BT_IO_ERROR, BT_IO_ERROR_CONNECT_FAILED, 1261 "connect: %s (%d)", strerror(-err), -err); 1262 g_io_channel_unref(io); 1263 return NULL; 1264 } 1265 1266 connect_add(io, connect, user_data, destroy); 1267 1268 return io; 1269} 1270 1271GIOChannel *bt_io_listen(BtIOType type, BtIOConnect connect, 1272 BtIOConfirm confirm, gpointer user_data, 1273 GDestroyNotify destroy, GError **err, 1274 BtIOOption opt1, ...) 1275{ 1276 GIOChannel *io; 1277 va_list args; 1278 struct set_opts opts; 1279 int sock; 1280 gboolean ret; 1281 1282 if (type == BT_IO_L2RAW) { 1283 g_set_error(err, BT_IO_ERROR, BT_IO_ERROR_INVALID_ARGS, 1284 "Server L2CAP RAW sockets not supported"); 1285 return NULL; 1286 } 1287 1288 va_start(args, opt1); 1289 ret = parse_set_opts(&opts, err, opt1, args); 1290 va_end(args); 1291 1292 if (ret == FALSE) 1293 return NULL; 1294 1295 io = create_io(type, TRUE, &opts, err); 1296 if (io == NULL) 1297 return NULL; 1298 1299 sock = g_io_channel_unix_get_fd(io); 1300 1301 if (confirm) 1302 setsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP, &opts.defer, 1303 sizeof(opts.defer)); 1304 1305 if (listen(sock, 5) < 0) { 1306 ERROR_FAILED(err, "listen", errno); 1307 g_io_channel_unref(io); 1308 return NULL; 1309 } 1310 1311 server_add(io, connect, confirm, user_data, destroy); 1312 1313 return io; 1314} 1315 1316GQuark bt_io_error_quark(void) 1317{ 1318 return g_quark_from_static_string("bt-io-error-quark"); 1319} 1320