btio/btio.c

   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
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #include <stdarg.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33 #include <poll.h>
  34 #include <sys/types.h>
  35 #include <sys/socket.h>
  36
  37 #include <glib.h>
  38
  39 #include "lib/bluetooth.h"
  40 #include "lib/l2cap.h"
  41 #include "lib/rfcomm.h"
  42 #include "lib/sco.h"
  43
  44 #include "btio.h"
  45
  46 #ifndef BT_FLUSHABLE
  47 #define BT_FLUSHABLE    8
  48 #endif
  49
  50 #define ERROR_FAILED(gerr, str, err) \
  51                 g_set_error(gerr, BT_IO_ERROR, err, \
  52                                 str ": %s (%d)", strerror(err), err)
  53
  54 #define DEFAULT_DEFER_TIMEOUT 30
  55
  56 typedef enum {
  57         BT_IO_L2CAP,
  58         BT_IO_RFCOMM,
  59         BT_IO_SCO,
  60         BT_IO_INVALID,
  61 } BtIOType;
  62
  63 struct set_opts {
  64         bdaddr_t src;
  65         bdaddr_t dst;
  66         BtIOType type;
  67         uint8_t src_type;
  68         uint8_t dst_type;
  69         int defer;
  70         int sec_level;
  71         uint8_t channel;
  72         uint16_t psm;
  73         uint16_t cid;
  74         uint16_t mtu;
  75         uint16_t imtu;
  76         uint16_t omtu;
  77         int master;
  78         uint8_t mode;
  79         int flushable;
  80         uint32_t priority;
  81         uint16_t voice;
  82 };
  83
  84 struct connect {
  85         BtIOConnect connect;
  86         gpointer user_data;
  87         GDestroyNotify destroy;
  88 };
  89
  90 struct accept {
  91         BtIOConnect connect;
  92         gpointer user_data;
  93         GDestroyNotify destroy;
  94 };
  95
  96 struct server {
  97         BtIOConnect connect;
  98         BtIOConfirm confirm;
  99         gpointer user_data;
 100         GDestroyNotify destroy;
 101 };
 102
 103 static BtIOType bt_io_get_type(GIOChannel *io, GError **gerr)
 104 {
 105         int sk = g_io_channel_unix_get_fd(io);
 106         int domain, proto, err;
 107         socklen_t len;
 108
 109         domain = 0;
 110         len = sizeof(domain);
 111         err = getsockopt(sk, SOL_SOCKET, SO_DOMAIN, &domain, &len);
 112         if (err < 0) {
 113                 ERROR_FAILED(gerr, "getsockopt(SO_DOMAIN)", errno);
 114                 return BT_IO_INVALID;
 115         }
 116
 117         if (domain != AF_BLUETOOTH) {
 118                 g_set_error(gerr, BT_IO_ERROR, EINVAL,
 119                                 "BtIO socket domain not AF_BLUETOOTH");
 120                 return BT_IO_INVALID;
 121         }
 122
 123         proto = 0;
 124         len = sizeof(proto);
 125         err = getsockopt(sk, SOL_SOCKET, SO_PROTOCOL, &proto, &len);
 126         if (err < 0) {
 127                 ERROR_FAILED(gerr, "getsockopt(SO_PROTOCOL)", errno);
 128                 return BT_IO_INVALID;
 129         }
 130
 131         switch (proto) {
 132         case BTPROTO_RFCOMM:
 133                 return BT_IO_RFCOMM;
 134         case BTPROTO_SCO:
 135                 return BT_IO_SCO;
 136         case BTPROTO_L2CAP:
 137                 return BT_IO_L2CAP;
 138         default:
 139                 g_set_error(gerr, BT_IO_ERROR, EINVAL,
 140                                         "Unknown BtIO socket type");
 141                 return BT_IO_INVALID;
 142         }
 143 }
 144
 145 static void server_remove(struct server *server)
 146 {
 147         if (server->destroy)
 148                 server->destroy(server->user_data);
 149         g_free(server);
 150 }
 151
 152 static void connect_remove(struct connect *conn)
 153 {
 154         if (conn->destroy)
 155                 conn->destroy(conn->user_data);
 156         g_free(conn);
 157 }
 158
 159 static void accept_remove(struct accept *accept)
 160 {
 161         if (accept->destroy)
 162                 accept->destroy(accept->user_data);
 163         g_free(accept);
 164 }
 165
 166 static gboolean check_nval(GIOChannel *io)
 167 {
 168         struct pollfd fds;
 169
 170         memset(&fds, 0, sizeof(fds));
 171         fds.fd = g_io_channel_unix_get_fd(io);
 172         fds.events = POLLNVAL;
 173
 174         if (poll(&fds, 1, 0) > 0 && (fds.revents & POLLNVAL))
 175                 return TRUE;
 176
 177         return FALSE;
 178 }
 179
 180 static gboolean accept_cb(GIOChannel *io, GIOCondition cond,
 181                                                         gpointer user_data)
 182 {
 183         struct accept *accept = user_data;
 184         GError *gerr = NULL;
 185
 186         /* If the user aborted this accept attempt */
 187         if ((cond & G_IO_NVAL) || check_nval(io))
 188                 return FALSE;
 189
 190         if (cond & (G_IO_HUP | G_IO_ERR)) {
 191                 int err, sk_err, sock = g_io_channel_unix_get_fd(io);
 192                 socklen_t len = sizeof(sk_err);
 193
 194                 if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &sk_err, &len) < 0)
 195                         err = -errno;
 196                 else
 197                         err = -sk_err;
 198
 199                 if (err < 0)
 200                         ERROR_FAILED(&gerr, "HUP or ERR on socket", -err);
 201         }
 202
 203         accept->connect(io, gerr, accept->user_data);
 204
 205         g_clear_error(&gerr);
 206
 207         return FALSE;
 208 }
 209
 210 static gboolean connect_cb(GIOChannel *io, GIOCondition cond,
 211                                                         gpointer user_data)
 212 {
 213         struct connect *conn = user_data;
 214         GError *gerr = NULL;
 215         int err, sk_err, sock;
 216         socklen_t len = sizeof(sk_err);
 217
 218         /* If the user aborted this connect attempt */
 219         if ((cond & G_IO_NVAL) || check_nval(io))
 220                 return FALSE;
 221
 222         sock = g_io_channel_unix_get_fd(io);
 223
 224         if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &sk_err, &len) < 0)
 225                 err = -errno;
 226         else
 227                 err = -sk_err;
 228
 229         if (err < 0)
 230                 ERROR_FAILED(&gerr, "connect error", -err);
 231
 232         conn->connect(io, gerr, conn->user_data);
 233
 234         g_clear_error(&gerr);
 235
 236         return FALSE;
 237 }
 238
 239 static gboolean server_cb(GIOChannel *io, GIOCondition cond,
 240                                                         gpointer user_data)
 241 {
 242         struct server *server = user_data;
 243         int srv_sock, cli_sock;
 244         GIOChannel *cli_io;
 245
 246         /* If the user closed the server */
 247         if ((cond & G_IO_NVAL) || check_nval(io))
 248                 return FALSE;
 249
 250         srv_sock = g_io_channel_unix_get_fd(io);
 251
 252         cli_sock = accept(srv_sock, NULL, NULL);
 253         if (cli_sock < 0)
 254                 return TRUE;
 255
 256         cli_io = g_io_channel_unix_new(cli_sock);
 257
 258         g_io_channel_set_close_on_unref(cli_io, TRUE);
 259         g_io_channel_set_flags(cli_io, G_IO_FLAG_NONBLOCK, NULL);
 260
 261         if (server->confirm)
 262                 server->confirm(cli_io, server->user_data);
 263         else
 264                 server->connect(cli_io, NULL, server->user_data);
 265
 266         g_io_channel_unref(cli_io);
 267
 268         return TRUE;
 269 }
 270
 271 static void server_add(GIOChannel *io, BtIOConnect connect,
 272                                 BtIOConfirm confirm, gpointer user_data,
 273                                 GDestroyNotify destroy)
 274 {
 275         struct server *server;
 276         GIOCondition cond;
 277
 278         server = g_new0(struct server, 1);
 279         server->connect = connect;
 280         server->confirm = confirm;
 281         server->user_data = user_data;
 282         server->destroy = destroy;
 283
 284         cond = G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
 285         g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, server_cb, server,
 286                                         (GDestroyNotify) server_remove);
 287 }
 288
 289 static void connect_add(GIOChannel *io, BtIOConnect connect,
 290                                 gpointer user_data, GDestroyNotify destroy)
 291 {
 292         struct connect *conn;
 293         GIOCondition cond;
 294
 295         conn = g_new0(struct connect, 1);
 296         conn->connect = connect;
 297         conn->user_data = user_data;
 298         conn->destroy = destroy;
 299
 300         cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
 301         g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, connect_cb, conn,
 302                                         (GDestroyNotify) connect_remove);
 303 }
 304
 305 static void accept_add(GIOChannel *io, BtIOConnect connect, gpointer user_data,
 306                                                         GDestroyNotify destroy)
 307 {
 308         struct accept *accept;
 309         GIOCondition cond;
 310
 311         accept = g_new0(struct accept, 1);
 312         accept->connect = connect;
 313         accept->user_data = user_data;
 314         accept->destroy = destroy;
 315
 316         cond = G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL;
 317         g_io_add_watch_full(io, G_PRIORITY_DEFAULT, cond, accept_cb, accept,
 318                                         (GDestroyNotify) accept_remove);
 319 }
 320
 321 static int l2cap_bind(int sock, const bdaddr_t *src, uint8_t src_type,
 322                                 uint16_t psm, uint16_t cid, GError **err)
 323 {
 324         struct sockaddr_l2 addr;
 325
 326         memset(&addr, 0, sizeof(addr));
 327         addr.l2_family = AF_BLUETOOTH;
 328         bacpy(&addr.l2_bdaddr, src);
 329
 330         if (cid)
 331                 addr.l2_cid = htobs(cid);
 332         else
 333                 addr.l2_psm = htobs(psm);
 334
 335         addr.l2_bdaddr_type = src_type;
 336
 337         if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 338                 int error = -errno;
 339                 ERROR_FAILED(err, "l2cap_bind", errno);
 340                 return error;
 341         }
 342
 343         return 0;
 344 }
 345
 346 static int l2cap_connect(int sock, const bdaddr_t *dst, uint8_t dst_type,
 347                                                 uint16_t psm, uint16_t cid)
 348 {
 349         int err;
 350         struct sockaddr_l2 addr;
 351
 352         memset(&addr, 0, sizeof(addr));
 353         addr.l2_family = AF_BLUETOOTH;
 354         bacpy(&addr.l2_bdaddr, dst);
 355         if (cid)
 356                 addr.l2_cid = htobs(cid);
 357         else
 358                 addr.l2_psm = htobs(psm);
 359
 360         addr.l2_bdaddr_type = dst_type;
 361
 362         err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
 363         if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
 364                 return -errno;
 365
 366         return 0;
 367 }
 368
 369 static int l2cap_set_master(int sock, int master)
 370 {
 371         int flags;
 372         socklen_t len;
 373
 374         len = sizeof(flags);
 375         if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, &len) < 0)
 376                 return -errno;
 377
 378         if (master) {
 379                 if (flags & L2CAP_LM_MASTER)
 380                         return 0;
 381                 flags |= L2CAP_LM_MASTER;
 382         } else {
 383                 if (!(flags & L2CAP_LM_MASTER))
 384                         return 0;
 385                 flags &= ~L2CAP_LM_MASTER;
 386         }
 387
 388         if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags, sizeof(flags)) < 0)
 389                 return -errno;
 390
 391         return 0;
 392 }
 393
 394 static int rfcomm_set_master(int sock, int master)
 395 {
 396         int flags;
 397         socklen_t len;
 398
 399         len = sizeof(flags);
 400         if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, &len) < 0)
 401                 return -errno;
 402
 403         if (master) {
 404                 if (flags & RFCOMM_LM_MASTER)
 405                         return 0;
 406                 flags |= RFCOMM_LM_MASTER;
 407         } else {
 408                 if (!(flags & RFCOMM_LM_MASTER))
 409                         return 0;
 410                 flags &= ~RFCOMM_LM_MASTER;
 411         }
 412
 413         if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags, sizeof(flags)) < 0)
 414                 return -errno;
 415
 416         return 0;
 417 }
 418
 419 static int l2cap_set_lm(int sock, int level)
 420 {
 421         int lm_map[] = {
 422                 0,
 423                 L2CAP_LM_AUTH,
 424                 L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT,
 425                 L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT | L2CAP_LM_SECURE,
 426         }, opt = lm_map[level];
 427
 428         if (setsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0)
 429                 return -errno;
 430
 431         return 0;
 432 }
 433
 434 static int rfcomm_set_lm(int sock, int level)
 435 {
 436         int lm_map[] = {
 437                 0,
 438                 RFCOMM_LM_AUTH,
 439                 RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT,
 440                 RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT | RFCOMM_LM_SECURE,
 441         }, opt = lm_map[level];
 442
 443         if (setsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, sizeof(opt)) < 0)
 444                 return -errno;
 445
 446         return 0;
 447 }
 448
 449 static gboolean set_sec_level(int sock, BtIOType type, int level, GError **err)
 450 {
 451         struct bt_security sec;
 452         int ret;
 453
 454         if (level < BT_SECURITY_LOW || level > BT_SECURITY_HIGH) {
 455                 g_set_error(err, BT_IO_ERROR, EINVAL,
 456                                 "Valid security level range is %d-%d",
 457                                 BT_SECURITY_LOW, BT_SECURITY_HIGH);
 458                 return FALSE;
 459         }
 460
 461         memset(&sec, 0, sizeof(sec));
 462         sec.level = level;
 463
 464         if (setsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec,
 465                                                         sizeof(sec)) == 0)
 466                 return TRUE;
 467
 468         if (errno != ENOPROTOOPT) {
 469                 ERROR_FAILED(err, "setsockopt(BT_SECURITY)", errno);
 470                 return FALSE;
 471         }
 472
 473         if (type == BT_IO_L2CAP)
 474                 ret = l2cap_set_lm(sock, level);
 475         else
 476                 ret = rfcomm_set_lm(sock, level);
 477
 478         if (ret < 0) {
 479                 ERROR_FAILED(err, "setsockopt(LM)", -ret);
 480                 return FALSE;
 481         }
 482
 483         return TRUE;
 484 }
 485
 486 static int l2cap_get_lm(int sock, int *sec_level)
 487 {
 488         int opt;
 489         socklen_t len;
 490
 491         len = sizeof(opt);
 492         if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &opt, &len) < 0)
 493                 return -errno;
 494
 495         *sec_level = 0;
 496
 497         if (opt & L2CAP_LM_AUTH)
 498                 *sec_level = BT_SECURITY_LOW;
 499         if (opt & L2CAP_LM_ENCRYPT)
 500                 *sec_level = BT_SECURITY_MEDIUM;
 501         if (opt & L2CAP_LM_SECURE)
 502                 *sec_level = BT_SECURITY_HIGH;
 503
 504         return 0;
 505 }
 506
 507 static int rfcomm_get_lm(int sock, int *sec_level)
 508 {
 509         int opt;
 510         socklen_t len;
 511
 512         len = sizeof(opt);
 513         if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &opt, &len) < 0)
 514                 return -errno;
 515
 516         *sec_level = 0;
 517
 518         if (opt & RFCOMM_LM_AUTH)
 519                 *sec_level = BT_SECURITY_LOW;
 520         if (opt & RFCOMM_LM_ENCRYPT)
 521                 *sec_level = BT_SECURITY_MEDIUM;
 522         if (opt & RFCOMM_LM_SECURE)
 523                 *sec_level = BT_SECURITY_HIGH;
 524
 525         return 0;
 526 }
 527
 528 static gboolean get_sec_level(int sock, BtIOType type, int *level,
 529                                                                 GError **err)
 530 {
 531         struct bt_security sec;
 532         socklen_t len;
 533         int ret;
 534
 535         memset(&sec, 0, sizeof(sec));
 536         len = sizeof(sec);
 537         if (getsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec, &len) == 0) {
 538                 *level = sec.level;
 539                 return TRUE;
 540         }
 541
 542         if (errno != ENOPROTOOPT) {
 543                 ERROR_FAILED(err, "getsockopt(BT_SECURITY)", errno);
 544                 return FALSE;
 545         }
 546
 547         if (type == BT_IO_L2CAP)
 548                 ret = l2cap_get_lm(sock, level);
 549         else
 550                 ret = rfcomm_get_lm(sock, level);
 551
 552         if (ret < 0) {
 553                 ERROR_FAILED(err, "getsockopt(LM)", -ret);
 554                 return FALSE;
 555         }
 556
 557         return TRUE;
 558 }
 559
 560 static int l2cap_set_flushable(int sock, gboolean flushable)
 561 {
 562         int f;
 563
 564         f = flushable;
 565         if (setsockopt(sock, SOL_BLUETOOTH, BT_FLUSHABLE, &f, sizeof(f)) < 0)
 566                 return -errno;
 567
 568         return 0;
 569 }
 570
 571 static int set_priority(int sock, uint32_t prio)
 572 {
 573         if (setsockopt(sock, SOL_SOCKET, SO_PRIORITY, &prio, sizeof(prio)) < 0)
 574                 return -errno;
 575
 576         return 0;
 577 }
 578
 579 static gboolean get_key_size(int sock, int *size, GError **err)
 580 {
 581         struct bt_security sec;
 582         socklen_t len;
 583
 584         memset(&sec, 0, sizeof(sec));
 585         len = sizeof(sec);
 586         if (getsockopt(sock, SOL_BLUETOOTH, BT_SECURITY, &sec, &len) == 0) {
 587                 *size = sec.key_size;
 588                 return TRUE;
 589         }
 590
 591         return FALSE;
 592 }
 593
 594 static gboolean set_l2opts(int sock, uint16_t imtu, uint16_t omtu,
 595                                                 uint8_t mode, GError **err)
 596 {
 597         struct l2cap_options l2o;
 598         socklen_t len;
 599
 600         memset(&l2o, 0, sizeof(l2o));
 601         len = sizeof(l2o);
 602         if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o, &len) < 0) {
 603                 ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno);
 604                 return FALSE;
 605         }
 606
 607         if (imtu)
 608                 l2o.imtu = imtu;
 609         if (omtu)
 610                 l2o.omtu = omtu;
 611         if (mode)
 612                 l2o.mode = mode;
 613
 614         if (setsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o, sizeof(l2o)) < 0) {
 615                 ERROR_FAILED(err, "setsockopt(L2CAP_OPTIONS)", errno);
 616                 return FALSE;
 617         }
 618
 619         return TRUE;
 620 }
 621
 622 static gboolean set_le_imtu(int sock, uint16_t imtu, GError **err)
 623 {
 624         if (setsockopt(sock, SOL_BLUETOOTH, BT_RCVMTU, &imtu,
 625                                                         sizeof(imtu)) < 0) {
 626                 ERROR_FAILED(err, "setsockopt(BT_RCVMTU)", errno);
 627                 return FALSE;
 628         }
 629
 630         return TRUE;
 631 }
 632
 633 static gboolean l2cap_set(int sock, uint8_t src_type, int sec_level,
 634                                 uint16_t imtu, uint16_t omtu, uint8_t mode,
 635                                 int master, int flushable, uint32_t priority,
 636                                 GError **err)
 637 {
 638         if (imtu || omtu || mode) {
 639                 gboolean ret;
 640
 641                 if (src_type == BDADDR_BREDR)
 642                         ret = set_l2opts(sock, imtu, omtu, mode, err);
 643                 else
 644                         ret = set_le_imtu(sock, imtu, err);
 645
 646                 if (!ret)
 647                         return ret;
 648         }
 649
 650         if (master >= 0 && l2cap_set_master(sock, master) < 0) {
 651                 ERROR_FAILED(err, "l2cap_set_master", errno);
 652                 return FALSE;
 653         }
 654
 655         if (flushable >= 0 && l2cap_set_flushable(sock, flushable) < 0) {
 656                 ERROR_FAILED(err, "l2cap_set_flushable", errno);
 657                 return FALSE;
 658         }
 659
 660         if (priority > 0 && set_priority(sock, priority) < 0) {
 661                 ERROR_FAILED(err, "set_priority", errno);
 662                 return FALSE;
 663         }
 664
 665         if (sec_level && !set_sec_level(sock, BT_IO_L2CAP, sec_level, err))
 666                 return FALSE;
 667
 668         return TRUE;
 669 }
 670
 671 static int rfcomm_bind(int sock,
 672                 const bdaddr_t *src, uint8_t channel, GError **err)
 673 {
 674         struct sockaddr_rc addr;
 675
 676         memset(&addr, 0, sizeof(addr));
 677         addr.rc_family = AF_BLUETOOTH;
 678         bacpy(&addr.rc_bdaddr, src);
 679         addr.rc_channel = channel;
 680
 681         if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 682                 int error = -errno;
 683                 ERROR_FAILED(err, "rfcomm_bind", errno);
 684                 return error;
 685         }
 686
 687         return 0;
 688 }
 689
 690 static int rfcomm_connect(int sock, const bdaddr_t *dst, uint8_t channel)
 691 {
 692         int err;
 693         struct sockaddr_rc addr;
 694
 695         memset(&addr, 0, sizeof(addr));
 696         addr.rc_family = AF_BLUETOOTH;
 697         bacpy(&addr.rc_bdaddr, dst);
 698         addr.rc_channel = channel;
 699
 700         err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
 701         if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
 702                 return -errno;
 703
 704         return 0;
 705 }
 706
 707 static gboolean rfcomm_set(int sock, int sec_level, int master, GError **err)
 708 {
 709         if (sec_level && !set_sec_level(sock, BT_IO_RFCOMM, sec_level, err))
 710                 return FALSE;
 711
 712         if (master >= 0 && rfcomm_set_master(sock, master) < 0) {
 713                 ERROR_FAILED(err, "rfcomm_set_master", errno);
 714                 return FALSE;
 715         }
 716
 717         return TRUE;
 718 }
 719
 720 static int sco_bind(int sock, const bdaddr_t *src, GError **err)
 721 {
 722         struct sockaddr_sco addr;
 723
 724         memset(&addr, 0, sizeof(addr));
 725         addr.sco_family = AF_BLUETOOTH;
 726         bacpy(&addr.sco_bdaddr, src);
 727
 728         if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 729                 int error = -errno;
 730                 ERROR_FAILED(err, "sco_bind", errno);
 731                 return error;
 732         }
 733
 734         return 0;
 735 }
 736
 737 static int sco_connect(int sock, const bdaddr_t *dst)
 738 {
 739         struct sockaddr_sco addr;
 740         int err;
 741
 742         memset(&addr, 0, sizeof(addr));
 743         addr.sco_family = AF_BLUETOOTH;
 744         bacpy(&addr.sco_bdaddr, dst);
 745
 746         err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));
 747         if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
 748                 return -errno;
 749
 750         return 0;
 751 }
 752
 753 static gboolean sco_set(int sock, uint16_t mtu, uint16_t voice, GError **err)
 754 {
 755         struct sco_options sco_opt;
 756         struct bt_voice bt_voice;
 757         socklen_t len;
 758
 759         if (!mtu)
 760                 goto voice;
 761
 762         len = sizeof(sco_opt);
 763         memset(&sco_opt, 0, len);
 764         if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) {
 765                 ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno);
 766                 return FALSE;
 767         }
 768
 769         sco_opt.mtu = mtu;
 770         if (setsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt,
 771                                                 sizeof(sco_opt)) < 0) {
 772                 ERROR_FAILED(err, "setsockopt(SCO_OPTIONS)", errno);
 773                 return FALSE;
 774         }
 775
 776 voice:
 777         if (!voice)
 778                 return TRUE;
 779
 780         memset(&bt_voice, 0, sizeof(bt_voice));
 781         bt_voice.setting = voice;
 782         if (setsockopt(sock, SOL_BLUETOOTH, BT_VOICE, &bt_voice,
 783                                                 sizeof(bt_voice)) < 0) {
 784                 ERROR_FAILED(err, "setsockopt(BT_VOICE)", errno);
 785                 return FALSE;
 786         }
 787
 788         return TRUE;
 789 }
 790
 791 static gboolean parse_set_opts(struct set_opts *opts, GError **err,
 792                                                 BtIOOption opt1, va_list args)
 793 {
 794         BtIOOption opt = opt1;
 795         const char *str;
 796
 797         memset(opts, 0, sizeof(*opts));
 798
 799         /* Set defaults */
 800         opts->type = BT_IO_SCO;
 801         opts->defer = DEFAULT_DEFER_TIMEOUT;
 802         opts->master = -1;
 803         opts->mode = L2CAP_MODE_BASIC;
 804         opts->flushable = -1;
 805         opts->priority = 0;
 806         opts->src_type = BDADDR_BREDR;
 807         opts->dst_type = BDADDR_BREDR;
 808
 809         while (opt != BT_IO_OPT_INVALID) {
 810                 switch (opt) {
 811                 case BT_IO_OPT_SOURCE:
 812                         str = va_arg(args, const char *);
 813                         str2ba(str, &opts->src);
 814                         break;
 815                 case BT_IO_OPT_SOURCE_BDADDR:
 816                         bacpy(&opts->src, va_arg(args, const bdaddr_t *));
 817                         break;
 818                 case BT_IO_OPT_SOURCE_TYPE:
 819                         opts->src_type = va_arg(args, int);
 820                         break;
 821                 case BT_IO_OPT_DEST:
 822                         str2ba(va_arg(args, const char *), &opts->dst);
 823                         break;
 824                 case BT_IO_OPT_DEST_BDADDR:
 825                         bacpy(&opts->dst, va_arg(args, const bdaddr_t *));
 826                         break;
 827                 case BT_IO_OPT_DEST_TYPE:
 828                         opts->dst_type = va_arg(args, int);
 829                         break;
 830                 case BT_IO_OPT_DEFER_TIMEOUT:
 831                         opts->defer = va_arg(args, int);
 832                         break;
 833                 case BT_IO_OPT_SEC_LEVEL:
 834                         opts->sec_level = va_arg(args, int);
 835                         break;
 836                 case BT_IO_OPT_CHANNEL:
 837                         opts->type = BT_IO_RFCOMM;
 838                         opts->channel = va_arg(args, int);
 839                         break;
 840                 case BT_IO_OPT_PSM:
 841                         opts->type = BT_IO_L2CAP;
 842                         opts->psm = va_arg(args, int);
 843                         break;
 844                 case BT_IO_OPT_CID:
 845                         opts->type = BT_IO_L2CAP;
 846                         opts->cid = va_arg(args, int);
 847                         break;
 848                 case BT_IO_OPT_MTU:
 849                         opts->mtu = va_arg(args, int);
 850                         opts->imtu = opts->mtu;
 851                         opts->omtu = opts->mtu;
 852                         break;
 853                 case BT_IO_OPT_OMTU:
 854                         opts->omtu = va_arg(args, int);
 855                         if (!opts->mtu)
 856                                 opts->mtu = opts->omtu;
 857                         break;
 858                 case BT_IO_OPT_IMTU:
 859                         opts->imtu = va_arg(args, int);
 860                         if (!opts->mtu)
 861                                 opts->mtu = opts->imtu;
 862                         break;
 863                 case BT_IO_OPT_MASTER:
 864                         opts->master = va_arg(args, gboolean);
 865                         break;
 866                 case BT_IO_OPT_MODE:
 867                         opts->mode = va_arg(args, int);
 868                         break;
 869                 case BT_IO_OPT_FLUSHABLE:
 870                         opts->flushable = va_arg(args, gboolean);
 871                         break;
 872                 case BT_IO_OPT_PRIORITY:
 873                         opts->priority = va_arg(args, int);
 874                         break;
 875                 case BT_IO_OPT_VOICE:
 876                         opts->voice = va_arg(args, int);
 877                         break;
 878                 case BT_IO_OPT_INVALID:
 879                 case BT_IO_OPT_KEY_SIZE:
 880                 case BT_IO_OPT_SOURCE_CHANNEL:
 881                 case BT_IO_OPT_DEST_CHANNEL:
 882                 case BT_IO_OPT_HANDLE:
 883                 case BT_IO_OPT_CLASS:
 884                 default:
 885                         g_set_error(err, BT_IO_ERROR, EINVAL,
 886                                         "Unknown option %d", opt);
 887                         return FALSE;
 888                 }
 889
 890                 opt = va_arg(args, int);
 891         }
 892
 893         return TRUE;
 894 }
 895
 896 static gboolean get_src(int sock, void *src, socklen_t len, GError **err)
 897 {
 898         socklen_t olen;
 899
 900         memset(src, 0, len);
 901         olen = len;
 902         if (getsockname(sock, src, &olen) < 0) {
 903                 ERROR_FAILED(err, "getsockname", errno);
 904                 return FALSE;
 905         }
 906
 907         return TRUE;
 908 }
 909
 910 static gboolean get_dst(int sock, void *dst, socklen_t len, GError **err)
 911 {
 912         socklen_t olen;
 913
 914         memset(dst, 0, len);
 915         olen = len;
 916         if (getpeername(sock, dst, &olen) < 0) {
 917                 ERROR_FAILED(err, "getpeername", errno);
 918                 return FALSE;
 919         }
 920
 921         return TRUE;
 922 }
 923
 924 static int l2cap_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
 925 {
 926         struct l2cap_conninfo info;
 927         socklen_t len;
 928
 929         len = sizeof(info);
 930         if (getsockopt(sock, SOL_L2CAP, L2CAP_CONNINFO, &info, &len) < 0)
 931                 return -errno;
 932
 933         if (handle)
 934                 *handle = info.hci_handle;
 935
 936         if (dev_class)
 937                 memcpy(dev_class, info.dev_class, 3);
 938
 939         return 0;
 940 }
 941
 942 static int l2cap_get_flushable(int sock, gboolean *flushable)
 943 {
 944         int f;
 945         socklen_t len;
 946
 947         f = 0;
 948         len = sizeof(f);
 949         if (getsockopt(sock, SOL_BLUETOOTH, BT_FLUSHABLE, &f, &len) < 0)
 950                 return -errno;
 951
 952         if (f)
 953                 *flushable = TRUE;
 954         else
 955                 *flushable = FALSE;
 956
 957         return 0;
 958 }
 959
 960 static int get_priority(int sock, uint32_t *prio)
 961 {
 962         socklen_t len;
 963
 964         len = sizeof(*prio);
 965         if (getsockopt(sock, SOL_SOCKET, SO_PRIORITY, prio, &len) < 0)
 966                 return -errno;
 967
 968         return 0;
 969 }
 970
 971 static gboolean l2cap_get(int sock, GError **err, BtIOOption opt1,
 972                                                                 va_list args)
 973 {
 974         BtIOOption opt = opt1;
 975         struct sockaddr_l2 src, dst;
 976         struct l2cap_options l2o;
 977         int flags;
 978         uint8_t dev_class[3];
 979         uint16_t handle = 0;
 980         socklen_t len;
 981         gboolean flushable = FALSE, have_dst = FALSE;
 982         uint32_t priority;
 983
 984         if (!get_src(sock, &src, sizeof(src), err))
 985                 return FALSE;
 986
 987         memset(&l2o, 0, sizeof(l2o));
 988
 989         if (src.l2_bdaddr_type != BDADDR_BREDR) {
 990                 len = sizeof(l2o.imtu);
 991                 if (getsockopt(sock, SOL_BLUETOOTH, BT_RCVMTU,
 992                                                 &l2o.imtu, &len) == 0)
 993                         goto parse_opts;
 994
 995                 /* Non-LE CoC enabled kernels will return one of these
 996                  * in which case we need to fall back to L2CAP_OPTIONS.
 997                  */
 998                 if (errno != EPROTONOSUPPORT && errno != ENOPROTOOPT) {
 999                         ERROR_FAILED(err, "getsockopt(BT_RCVMTU)", errno);
1000                         return FALSE;
1001                 }
1002         }
1003
1004         len = sizeof(l2o);
1005         if (getsockopt(sock, SOL_L2CAP, L2CAP_OPTIONS, &l2o, &len) < 0) {
1006                 ERROR_FAILED(err, "getsockopt(L2CAP_OPTIONS)", errno);
1007                 return FALSE;
1008         }
1009
1010 parse_opts:
1011         while (opt != BT_IO_OPT_INVALID) {
1012                 switch (opt) {
1013                 case BT_IO_OPT_SOURCE:
1014                         ba2str(&src.l2_bdaddr, va_arg(args, char *));
1015                         break;
1016                 case BT_IO_OPT_SOURCE_BDADDR:
1017                         bacpy(va_arg(args, bdaddr_t *), &src.l2_bdaddr);
1018                         break;
1019                 case BT_IO_OPT_DEST:
1020                         if (!have_dst)
1021                                 have_dst = get_dst(sock, &dst, sizeof(dst),
1022                                                                         err);
1023                         if (!have_dst)
1024                                 return FALSE;
1025                         ba2str(&dst.l2_bdaddr, va_arg(args, char *));
1026                         break;
1027                 case BT_IO_OPT_DEST_BDADDR:
1028                         if (!have_dst)
1029                                 have_dst = get_dst(sock, &dst, sizeof(dst),
1030                                                                         err);
1031                         if (!have_dst)
1032                                 return FALSE;
1033                         bacpy(va_arg(args, bdaddr_t *), &dst.l2_bdaddr);
1034                         break;
1035                 case BT_IO_OPT_DEST_TYPE:
1036                         if (!have_dst)
1037                                 have_dst = get_dst(sock, &dst, sizeof(dst),
1038                                                                         err);
1039                         if (!have_dst)
1040                                 return FALSE;
1041                         *(va_arg(args, uint8_t *)) = dst.l2_bdaddr_type;
1042                         break;
1043                 case BT_IO_OPT_DEFER_TIMEOUT:
1044                         len = sizeof(int);
1045                         if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP,
1046                                         va_arg(args, int *), &len) < 0) {
1047                                 ERROR_FAILED(err, "getsockopt(DEFER_SETUP)",
1048                                                                         errno);
1049                                 return FALSE;
1050                         }
1051                         break;
1052                 case BT_IO_OPT_SEC_LEVEL:
1053                         if (!get_sec_level(sock, BT_IO_L2CAP,
1054                                                 va_arg(args, int *), err))
1055                                 return FALSE;
1056                         break;
1057                 case BT_IO_OPT_KEY_SIZE:
1058                         if (!get_key_size(sock, va_arg(args, int *), err))
1059                                 return FALSE;
1060                         break;
1061                 case BT_IO_OPT_PSM:
1062                         if (src.l2_psm) {
1063                                 *(va_arg(args, uint16_t *)) = btohs(src.l2_psm);
1064                                 break;
1065                         }
1066
1067                         if (!have_dst)
1068                                 have_dst = get_dst(sock, &dst, sizeof(dst),
1069                                                                         err);
1070                         if (!have_dst)
1071                                 return FALSE;
1072
1073                         *(va_arg(args, uint16_t *)) = btohs(dst.l2_psm);
1074                         break;
1075                 case BT_IO_OPT_CID:
1076                         if (src.l2_cid) {
1077                                 *(va_arg(args, uint16_t *)) = btohs(src.l2_cid);
1078                                 break;
1079                         }
1080
1081                         if (!have_dst)
1082                                 have_dst = get_dst(sock, &dst, sizeof(dst),
1083                                                                         err);
1084                         if (!have_dst)
1085                                 return FALSE;
1086
1087                         *(va_arg(args, uint16_t *)) = btohs(dst.l2_cid);
1088                         break;
1089                 case BT_IO_OPT_OMTU:
1090                         if (src.l2_bdaddr_type == BDADDR_BREDR) {
1091                                 *(va_arg(args, uint16_t *)) = l2o.omtu;
1092                                 break;
1093                         }
1094
1095                         len = sizeof(l2o.omtu);
1096                         if (getsockopt(sock, SOL_BLUETOOTH, BT_SNDMTU,
1097                                                         &l2o.omtu, &len) < 0) {
1098                                 ERROR_FAILED(err, "getsockopt(BT_SNDMTU)",
1099                                                                         errno);
1100                                 return FALSE;
1101                         }
1102
1103                         *(va_arg(args, uint16_t *)) = l2o.omtu;
1104                         break;
1105                 case BT_IO_OPT_IMTU:
1106                         *(va_arg(args, uint16_t *)) = l2o.imtu;
1107                         break;
1108                 case BT_IO_OPT_MASTER:
1109                         len = sizeof(flags);
1110                         if (getsockopt(sock, SOL_L2CAP, L2CAP_LM, &flags,
1111                                                                 &len) < 0) {
1112                                 ERROR_FAILED(err, "getsockopt(L2CAP_LM)",
1113                                                                         errno);
1114                                 return FALSE;
1115                         }
1116                         *(va_arg(args, gboolean *)) =
1117                                 (flags & L2CAP_LM_MASTER) ? TRUE : FALSE;
1118                         break;
1119                 case BT_IO_OPT_HANDLE:
1120                         if (l2cap_get_info(sock, &handle, dev_class) < 0) {
1121                                 ERROR_FAILED(err, "L2CAP_CONNINFO", errno);
1122                                 return FALSE;
1123                         }
1124                         *(va_arg(args, uint16_t *)) = handle;
1125                         break;
1126                 case BT_IO_OPT_CLASS:
1127                         if (l2cap_get_info(sock, &handle, dev_class) < 0) {
1128                                 ERROR_FAILED(err, "L2CAP_CONNINFO", errno);
1129                                 return FALSE;
1130                         }
1131                         memcpy(va_arg(args, uint8_t *), dev_class, 3);
1132                         break;
1133                 case BT_IO_OPT_MODE:
1134                         *(va_arg(args, uint8_t *)) = l2o.mode;
1135                         break;
1136                 case BT_IO_OPT_FLUSHABLE:
1137                         if (l2cap_get_flushable(sock, &flushable) < 0) {
1138                                 ERROR_FAILED(err, "get_flushable", errno);
1139                                 return FALSE;
1140                         }
1141                         *(va_arg(args, gboolean *)) = flushable;
1142                         break;
1143                 case BT_IO_OPT_PRIORITY:
1144                         if (get_priority(sock, &priority) < 0) {
1145                                 ERROR_FAILED(err, "get_priority", errno);
1146                                 return FALSE;
1147                         }
1148                         *(va_arg(args, uint32_t *)) = priority;
1149                         break;
1150                 case BT_IO_OPT_INVALID:
1151                 case BT_IO_OPT_SOURCE_TYPE:
1152                 case BT_IO_OPT_CHANNEL:
1153                 case BT_IO_OPT_SOURCE_CHANNEL:
1154                 case BT_IO_OPT_DEST_CHANNEL:
1155                 case BT_IO_OPT_MTU:
1156                 case BT_IO_OPT_VOICE:
1157                 default:
1158                         g_set_error(err, BT_IO_ERROR, EINVAL,
1159                                         "Unknown option %d", opt);
1160                         return FALSE;
1161                 }
1162
1163                 opt = va_arg(args, int);
1164         }
1165
1166         return TRUE;
1167 }
1168
1169 static int rfcomm_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
1170 {
1171         struct rfcomm_conninfo info;
1172         socklen_t len;
1173
1174         len = sizeof(info);
1175         if (getsockopt(sock, SOL_RFCOMM, RFCOMM_CONNINFO, &info, &len) < 0)
1176                 return -errno;
1177
1178         if (handle)
1179                 *handle = info.hci_handle;
1180
1181         if (dev_class)
1182                 memcpy(dev_class, info.dev_class, 3);
1183
1184         return 0;
1185 }
1186
1187 static gboolean rfcomm_get(int sock, GError **err, BtIOOption opt1,
1188                                                                 va_list args)
1189 {
1190         BtIOOption opt = opt1;
1191         struct sockaddr_rc src, dst;
1192         gboolean have_dst = FALSE;
1193         int flags;
1194         socklen_t len;
1195         uint8_t dev_class[3];
1196         uint16_t handle = 0;
1197
1198         if (!get_src(sock, &src, sizeof(src), err))
1199                 return FALSE;
1200
1201         while (opt != BT_IO_OPT_INVALID) {
1202                 switch (opt) {
1203                 case BT_IO_OPT_SOURCE:
1204                         ba2str(&src.rc_bdaddr, va_arg(args, char *));
1205                         break;
1206                 case BT_IO_OPT_SOURCE_BDADDR:
1207                         bacpy(va_arg(args, bdaddr_t *), &src.rc_bdaddr);
1208                         break;
1209                 case BT_IO_OPT_DEST:
1210                         if (!have_dst)
1211                                 have_dst = get_dst(sock, &dst, sizeof(dst),
1212                                                                         err);
1213                         if (!have_dst)
1214                                 return FALSE;
1215                         ba2str(&dst.rc_bdaddr, va_arg(args, char *));
1216                         break;
1217                 case BT_IO_OPT_DEST_BDADDR:
1218                         if (!have_dst)
1219                                 have_dst = get_dst(sock, &dst, sizeof(dst),
1220                                                                         err);
1221                         if (!have_dst)
1222                                 return FALSE;
1223                         bacpy(va_arg(args, bdaddr_t *), &dst.rc_bdaddr);
1224                         break;
1225                 case BT_IO_OPT_DEFER_TIMEOUT:
1226                         len = sizeof(int);
1227                         if (getsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP,
1228                                         va_arg(args, int *), &len) < 0) {
1229                                 ERROR_FAILED(err, "getsockopt(DEFER_SETUP)",
1230                                                                         errno);
1231                                 return FALSE;
1232                         }
1233                         break;
1234                 case BT_IO_OPT_SEC_LEVEL:
1235                         if (!get_sec_level(sock, BT_IO_RFCOMM,
1236                                                 va_arg(args, int *), err))
1237                                 return FALSE;
1238                         break;
1239                 case BT_IO_OPT_CHANNEL:
1240                         if (src.rc_channel) {
1241                                 *(va_arg(args, uint8_t *)) = src.rc_channel;
1242                                 break;
1243                         }
1244
1245                         if (!have_dst)
1246                                 have_dst = get_dst(sock, &dst, sizeof(dst),
1247                                                                         err);
1248                         if (!have_dst)
1249                                 return FALSE;
1250
1251                         *(va_arg(args, uint8_t *)) = dst.rc_channel;
1252                         break;
1253                 case BT_IO_OPT_SOURCE_CHANNEL:
1254                         *(va_arg(args, uint8_t *)) = src.rc_channel;
1255                         break;
1256                 case BT_IO_OPT_DEST_CHANNEL:
1257                         if (!have_dst)
1258                                 have_dst = get_dst(sock, &dst, sizeof(dst),
1259                                                                         err);
1260                         if (!have_dst)
1261                                 return FALSE;
1262
1263                         *(va_arg(args, uint8_t *)) = dst.rc_channel;
1264                         break;
1265                 case BT_IO_OPT_MASTER:
1266                         len = sizeof(flags);
1267                         if (getsockopt(sock, SOL_RFCOMM, RFCOMM_LM, &flags,
1268                                                                 &len) < 0) {
1269                                 ERROR_FAILED(err, "getsockopt(RFCOMM_LM)",
1270                                                                         errno);
1271                                 return FALSE;
1272                         }
1273                         *(va_arg(args, gboolean *)) =
1274                                 (flags & RFCOMM_LM_MASTER) ? TRUE : FALSE;
1275                         break;
1276                 case BT_IO_OPT_HANDLE:
1277                         if (rfcomm_get_info(sock, &handle, dev_class) < 0) {
1278                                 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno);
1279                                 return FALSE;
1280                         }
1281                         *(va_arg(args, uint16_t *)) = handle;
1282                         break;
1283                 case BT_IO_OPT_CLASS:
1284                         if (rfcomm_get_info(sock, &handle, dev_class) < 0) {
1285                                 ERROR_FAILED(err, "RFCOMM_CONNINFO", errno);
1286                                 return FALSE;
1287                         }
1288                         memcpy(va_arg(args, uint8_t *), dev_class, 3);
1289                         break;
1290                 case BT_IO_OPT_SOURCE_TYPE:
1291                 case BT_IO_OPT_DEST_TYPE:
1292                 case BT_IO_OPT_KEY_SIZE:
1293                 case BT_IO_OPT_PSM:
1294                 case BT_IO_OPT_CID:
1295                 case BT_IO_OPT_MTU:
1296                 case BT_IO_OPT_OMTU:
1297                 case BT_IO_OPT_IMTU:
1298                 case BT_IO_OPT_MODE:
1299                 case BT_IO_OPT_FLUSHABLE:
1300                 case BT_IO_OPT_PRIORITY:
1301                 case BT_IO_OPT_VOICE:
1302                 case BT_IO_OPT_INVALID:
1303                 default:
1304                         g_set_error(err, BT_IO_ERROR, EINVAL,
1305                                         "Unknown option %d", opt);
1306                         return FALSE;
1307                 }
1308
1309                 opt = va_arg(args, int);
1310         }
1311
1312         return TRUE;
1313 }
1314
1315 static int sco_get_info(int sock, uint16_t *handle, uint8_t *dev_class)
1316 {
1317         struct sco_conninfo info;
1318         socklen_t len;
1319
1320         len = sizeof(info);
1321         if (getsockopt(sock, SOL_SCO, SCO_CONNINFO, &info, &len) < 0)
1322                 return -errno;
1323
1324         if (handle)
1325                 *handle = info.hci_handle;
1326
1327         if (dev_class)
1328                 memcpy(dev_class, info.dev_class, 3);
1329
1330         return 0;
1331 }
1332
1333 static gboolean sco_get(int sock, GError **err, BtIOOption opt1, va_list args)
1334 {
1335         BtIOOption opt = opt1;
1336         struct sockaddr_sco src, dst;
1337         struct sco_options sco_opt;
1338         socklen_t len;
1339         uint8_t dev_class[3];
1340         uint16_t handle = 0;
1341
1342         len = sizeof(sco_opt);
1343         memset(&sco_opt, 0, len);
1344         if (getsockopt(sock, SOL_SCO, SCO_OPTIONS, &sco_opt, &len) < 0) {
1345                 ERROR_FAILED(err, "getsockopt(SCO_OPTIONS)", errno);
1346                 return FALSE;
1347         }
1348
1349         if (!get_src(sock, &src, sizeof(src), err))
1350                 return FALSE;
1351
1352         if (!get_dst(sock, &dst, sizeof(dst), err))
1353                 return FALSE;
1354
1355         while (opt != BT_IO_OPT_INVALID) {
1356                 switch (opt) {
1357                 case BT_IO_OPT_SOURCE:
1358                         ba2str(&src.sco_bdaddr, va_arg(args, char *));
1359                         break;
1360                 case BT_IO_OPT_SOURCE_BDADDR:
1361                         bacpy(va_arg(args, bdaddr_t *), &src.sco_bdaddr);
1362                         break;
1363                 case BT_IO_OPT_DEST:
1364                         ba2str(&dst.sco_bdaddr, va_arg(args, char *));
1365                         break;
1366                 case BT_IO_OPT_DEST_BDADDR:
1367                         bacpy(va_arg(args, bdaddr_t *), &dst.sco_bdaddr);
1368                         break;
1369                 case BT_IO_OPT_MTU:
1370                 case BT_IO_OPT_IMTU:
1371                 case BT_IO_OPT_OMTU:
1372                         *(va_arg(args, uint16_t *)) = sco_opt.mtu;
1373                         break;
1374                 case BT_IO_OPT_HANDLE:
1375                         if (sco_get_info(sock, &handle, dev_class) < 0) {
1376                                 ERROR_FAILED(err, "SCO_CONNINFO", errno);
1377                                 return FALSE;
1378                         }
1379                         *(va_arg(args, uint16_t *)) = handle;
1380                         break;
1381                 case BT_IO_OPT_CLASS:
1382                         if (sco_get_info(sock, &handle, dev_class) < 0) {
1383                                 ERROR_FAILED(err, "SCO_CONNINFO", errno);
1384                                 return FALSE;
1385                         }
1386                         memcpy(va_arg(args, uint8_t *), dev_class, 3);
1387                         break;
1388                 case BT_IO_OPT_SOURCE_TYPE:
1389                 case BT_IO_OPT_DEST_TYPE:
1390                 case BT_IO_OPT_DEFER_TIMEOUT:
1391                 case BT_IO_OPT_SEC_LEVEL:
1392                 case BT_IO_OPT_KEY_SIZE:
1393                 case BT_IO_OPT_CHANNEL:
1394                 case BT_IO_OPT_SOURCE_CHANNEL:
1395                 case BT_IO_OPT_DEST_CHANNEL:
1396                 case BT_IO_OPT_PSM:
1397                 case BT_IO_OPT_CID:
1398                 case BT_IO_OPT_MASTER:
1399                 case BT_IO_OPT_MODE:
1400                 case BT_IO_OPT_FLUSHABLE:
1401                 case BT_IO_OPT_PRIORITY:
1402                 case BT_IO_OPT_VOICE:
1403                 case BT_IO_OPT_INVALID:
1404                 default:
1405                         g_set_error(err, BT_IO_ERROR, EINVAL,
1406                                         "Unknown option %d", opt);
1407                         return FALSE;
1408                 }
1409
1410                 opt = va_arg(args, int);
1411         }
1412
1413         return TRUE;
1414 }
1415
1416 static gboolean get_valist(GIOChannel *io, BtIOType type, GError **err,
1417                                                 BtIOOption opt1, va_list args)
1418 {
1419         int sock;
1420
1421         sock = g_io_channel_unix_get_fd(io);
1422
1423         switch (type) {
1424         case BT_IO_L2CAP:
1425                 return l2cap_get(sock, err, opt1, args);
1426         case BT_IO_RFCOMM:
1427                 return rfcomm_get(sock, err, opt1, args);
1428         case BT_IO_SCO:
1429                 return sco_get(sock, err, opt1, args);
1430         case BT_IO_INVALID:
1431         default:
1432                 g_set_error(err, BT_IO_ERROR, EINVAL,
1433                                 "Unknown BtIO type %d", type);
1434                 return FALSE;
1435         }
1436 }
1437
1438 gboolean bt_io_accept(GIOChannel *io, BtIOConnect connect, gpointer user_data,
1439                                         GDestroyNotify destroy, GError **err)
1440 {
1441         int sock;
1442         char c;
1443         struct pollfd pfd;
1444
1445         sock = g_io_channel_unix_get_fd(io);
1446
1447         memset(&pfd, 0, sizeof(pfd));
1448         pfd.fd = sock;
1449         pfd.events = POLLOUT;
1450
1451         if (poll(&pfd, 1, 0) < 0) {
1452                 ERROR_FAILED(err, "poll", errno);
1453                 return FALSE;
1454         }
1455
1456         if (!(pfd.revents & POLLOUT)) {
1457                 if (read(sock, &c, 1) < 0) {
1458                         ERROR_FAILED(err, "read", errno);
1459                         return FALSE;
1460                 }
1461         }
1462
1463         accept_add(io, connect, user_data, destroy);
1464
1465         return TRUE;
1466 }
1467
1468 gboolean bt_io_set(GIOChannel *io, GError **err, BtIOOption opt1, ...)
1469 {
1470         va_list args;
1471         gboolean ret;
1472         struct set_opts opts;
1473         int sock;
1474         BtIOType type;
1475
1476         va_start(args, opt1);
1477         ret = parse_set_opts(&opts, err, opt1, args);
1478         va_end(args);
1479
1480         if (!ret)
1481                 return ret;
1482
1483         type = bt_io_get_type(io, err);
1484         if (type == BT_IO_INVALID)
1485                 return FALSE;
1486
1487         sock = g_io_channel_unix_get_fd(io);
1488
1489         switch (type) {
1490         case BT_IO_L2CAP:
1491                 return l2cap_set(sock, opts.src_type, opts.sec_level, opts.imtu,
1492                                         opts.omtu, opts.mode, opts.master,
1493                                         opts.flushable, opts.priority, err);
1494         case BT_IO_RFCOMM:
1495                 return rfcomm_set(sock, opts.sec_level, opts.master, err);
1496         case BT_IO_SCO:
1497                 return sco_set(sock, opts.mtu, opts.voice, err);
1498         case BT_IO_INVALID:
1499         default:
1500                 g_set_error(err, BT_IO_ERROR, EINVAL,
1501                                 "Unknown BtIO type %d", type);
1502                 return FALSE;
1503         }
1504
1505 }
1506
1507 gboolean bt_io_get(GIOChannel *io, GError **err, BtIOOption opt1, ...)
1508 {
1509         va_list args;
1510         gboolean ret;
1511         BtIOType type;
1512
1513         type = bt_io_get_type(io, err);
1514         if (type == BT_IO_INVALID)
1515                 return FALSE;
1516
1517         va_start(args, opt1);
1518         ret = get_valist(io, type, err, opt1, args);
1519         va_end(args);
1520
1521         return ret;
1522 }
1523
1524 static GIOChannel *create_io(gboolean server, struct set_opts *opts,
1525                                                                 GError **err)
1526 {
1527         int sock;
1528         GIOChannel *io;
1529
1530         switch (opts->type) {
1531         case BT_IO_L2CAP:
1532                 sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
1533                 if (sock < 0) {
1534                         ERROR_FAILED(err, "socket(SEQPACKET, L2CAP)", errno);
1535                         return NULL;
1536                 }
1537                 if (l2cap_bind(sock, &opts->src, opts->src_type,
1538                                 server ? opts->psm : 0, opts->cid, err) < 0)
1539                         goto failed;
1540                 if (!l2cap_set(sock, opts->src_type, opts->sec_level,
1541                                 opts->imtu, opts->omtu, opts->mode,
1542                                 opts->master, opts->flushable, opts->priority,
1543                                 err))
1544                         goto failed;
1545                 break;
1546         case BT_IO_RFCOMM:
1547                 sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
1548                 if (sock < 0) {
1549                         ERROR_FAILED(err, "socket(STREAM, RFCOMM)", errno);
1550                         return NULL;
1551                 }
1552                 if (rfcomm_bind(sock, &opts->src,
1553                                         server ? opts->channel : 0, err) < 0)
1554                         goto failed;
1555                 if (!rfcomm_set(sock, opts->sec_level, opts->master, err))
1556                         goto failed;
1557                 break;
1558         case BT_IO_SCO:
1559                 sock = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO);
1560                 if (sock < 0) {
1561                         ERROR_FAILED(err, "socket(SEQPACKET, SCO)", errno);
1562                         return NULL;
1563                 }
1564                 if (sco_bind(sock, &opts->src, err) < 0)
1565                         goto failed;
1566                 if (!sco_set(sock, opts->mtu, opts->voice, err))
1567                         goto failed;
1568                 break;
1569         case BT_IO_INVALID:
1570         default:
1571                 g_set_error(err, BT_IO_ERROR, EINVAL,
1572                                 "Unknown BtIO type %d", opts->type);
1573                 return NULL;
1574         }
1575
1576         io = g_io_channel_unix_new(sock);
1577
1578         g_io_channel_set_close_on_unref(io, TRUE);
1579         g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL);
1580
1581         return io;
1582
1583 failed:
1584         close(sock);
1585
1586         return NULL;
1587 }
1588
1589 GIOChannel *bt_io_connect(BtIOConnect connect, gpointer user_data,
1590                                 GDestroyNotify destroy, GError **gerr,
1591                                 BtIOOption opt1, ...)
1592 {
1593         GIOChannel *io;
1594         va_list args;
1595         struct set_opts opts;
1596         int err, sock;
1597         gboolean ret;
1598
1599         va_start(args, opt1);
1600         ret = parse_set_opts(&opts, gerr, opt1, args);
1601         va_end(args);
1602
1603         if (ret == FALSE)
1604                 return NULL;
1605
1606         io = create_io(FALSE, &opts, gerr);
1607         if (io == NULL)
1608                 return NULL;
1609
1610         sock = g_io_channel_unix_get_fd(io);
1611
1612         switch (opts.type) {
1613         case BT_IO_L2CAP:
1614                 err = l2cap_connect(sock, &opts.dst, opts.dst_type,
1615                                                         opts.psm, opts.cid);
1616                 break;
1617         case BT_IO_RFCOMM:
1618                 err = rfcomm_connect(sock, &opts.dst, opts.channel);
1619                 break;
1620         case BT_IO_SCO:
1621                 err = sco_connect(sock, &opts.dst);
1622                 break;
1623         case BT_IO_INVALID:
1624         default:
1625                 g_set_error(gerr, BT_IO_ERROR, EINVAL,
1626                                         "Unknown BtIO type %d", opts.type);
1627                 return NULL;
1628         }
1629
1630         if (err < 0) {
1631                 ERROR_FAILED(gerr, "connect", -err);
1632                 g_io_channel_unref(io);
1633                 return NULL;
1634         }
1635
1636         connect_add(io, connect, user_data, destroy);
1637
1638         return io;
1639 }
1640
1641 GIOChannel *bt_io_listen(BtIOConnect connect, BtIOConfirm confirm,
1642                                 gpointer user_data, GDestroyNotify destroy,
1643                                 GError **err, BtIOOption opt1, ...)
1644 {
1645         GIOChannel *io;
1646         va_list args;
1647         struct set_opts opts;
1648         int sock;
1649         gboolean ret;
1650
1651         va_start(args, opt1);
1652         ret = parse_set_opts(&opts, err, opt1, args);
1653         va_end(args);
1654
1655         if (ret == FALSE)
1656                 return NULL;
1657
1658         io = create_io(TRUE, &opts, err);
1659         if (io == NULL)
1660                 return NULL;
1661
1662         sock = g_io_channel_unix_get_fd(io);
1663
1664         if (confirm)
1665                 setsockopt(sock, SOL_BLUETOOTH, BT_DEFER_SETUP, &opts.defer,
1666                                                         sizeof(opts.defer));
1667
1668         if (listen(sock, 5) < 0) {
1669                 ERROR_FAILED(err, "listen", errno);
1670                 g_io_channel_unref(io);
1671                 return NULL;
1672         }
1673
1674         server_add(io, connect, confirm, user_data, destroy);
1675
1676         return io;
1677 }
1678
1679 GQuark bt_io_error_quark(void)
1680 {
1681         return g_quark_from_static_string("bt-io-error-quark");
1682 }